{ lib, helpers, config, pkgs, ... }: with lib; let cfg = config.plugins.fidget; mkIconOption = default: desc: helpers.defaultNullOpts.mkNullable ( with types; oneOf [ str helpers.nixvimTypes.rawLua (listOf str) (attrsOf (either str ints.unsigned)) ] ) default '' ${desc} - When a string literal is given (e.g., `"✔"`), it is used as a static icon. - When a list or attrs (e.g., `["dots"]` or `{pattern = "clock"; period = 2;}`) is given, it is used to generate an animation function. - When a function is specified (e.g., `{__raw = "function(now) return now % 2 < 1 and '+' or '-' end";}`), it is used as the animation function. ''; notificationConfigType = types.submodule { options = { name = helpers.mkNullOrOption types.str '' Name of the group; if `null`, the key is used as name. ''; icon = helpers.mkNullOrOption types.str '' Icon of the group; if `null`, no icon is used. ''; iconOnLeft = helpers.mkNullOrOption types.bool '' If true, icon is rendered on the left instead of right. ''; annoteSeparator = helpers.defaultNullOpts.mkStr "” ”" '' Separator between message from annote. ''; ttl = helpers.defaultNullOpts.mkUnsignedInt 3 '' How long a notification item should exist. ''; renderLimit = helpers.mkNullOrOption types.ints.unsigned '' How many notification items to show at once. ''; groupStyle = helpers.defaultNullOpts.mkStr "Title" '' Style used to highlight group name. ''; iconStyle = helpers.mkNullOrOption types.str '' Style used to highlight icon; if `null`, use `groupStyle`. ''; annoteStyle = helpers.defaultNullOpts.mkStr "Question" '' Default style used to highlight item annotes. ''; debugStyle = helpers.mkNullOrOption types.str '' Style used to highlight debug item annotes. ''; infoStyle = helpers.mkNullOrOption types.str '' Style used to highlight info item annotes. ''; warnStyle = helpers.mkNullOrOption types.str '' Style used to highlight warn item annotes. ''; errorStyle = helpers.mkNullOrOption types.str '' Style used to highlight error item annotes. ''; debugAnnote = helpers.mkNullOrOption types.str '' Default annotation for debug items. ''; infoAnnote = helpers.mkNullOrOption types.str '' Default annotation for info items. ''; warnAnnote = helpers.mkNullOrOption types.str '' Default annotation for warn items. ''; errorAnnote = helpers.mkNullOrOption types.str '' Default annotation for error items. ''; priority = helpers.defaultNullOpts.mkUnsignedInt 50 '' Order in which group should be displayed. ''; skipHistory = helpers.defaultNullOpts.mkBool true '' Whether progress notifications should be omitted from history. ''; }; }; in { # TODO: deprecation warnings introduced 2023/12/22: remove in early February 2024 imports = map ( oldOption: mkRemovedOptionModule [ "plugins" "fidget" oldOption ] '' Nixvim: The fidget.nvim plugin has been completely rewritten. Hence, the options have changed. Please, take a look at the updated documentation and adapt your configuration accordingly. > https://github.com/j-hui/fidget.nvim '' ) [ "text" "align" "timer" "window" "fmt" "sources" "debug" ]; options = { plugins.fidget = helpers.neovim-plugin.extraOptionsOptions // { enable = mkEnableOption "fidget-nvim"; package = helpers.mkPluginPackageOption "fidget-nvim" pkgs.vimPlugins.fidget-nvim; # Options related to LSP progress subsystem progress = { pollRate = helpers.defaultNullOpts.mkNullable (with types; either (enum [ false ]) number) 0 '' How and when to poll for progress messages. Set to `0` to immediately poll on each `|LspProgress|` event. Set to a positive number to poll for progress messages at the specified frequency (Hz, i.e., polls per second). Combining a slow `poll_rate` (e.g., `0.5`) with the `ignoreDoneAlready` setting can be used to filter out short-lived progress tasks, de-cluttering notifications. Note that if too many LSP progress messages are sent between polls, Neovim's progress ring buffer will overflow and messages will be overwritten (dropped), possibly causing stale progress notifications. Workarounds include using the `|fidget.option.progress.lsp.progress_ringbuf_size|` option, or manually calling `|fidget.notification.reset|`. Set to `false` to disable polling altogether; you can still manually poll progress messages by calling `|fidget.progress.poll|`. ''; suppressOnInsert = helpers.defaultNullOpts.mkBool false '' Suppress new messages while in insert mode. Note that progress messages for new tasks will be dropped, but existing tasks will be processed to completion. ''; ignoreDoneAlready = helpers.defaultNullOpts.mkBool false '' Ignore new tasks that are already complete. This is useful if you want to avoid excessively bouncy behavior, and only seeing notifications for long-running tasks. Works best when combined with a low `pollRate`. ''; ignoreEmptyMessage = helpers.defaultNullOpts.mkBool true '' Ignore new tasks that don't contain a message. Some servers may send empty messages for tasks that don't actually exist. And if those tasks are never completed, they will become stale in Fidget. This option tells Fidget to ignore such messages unless the LSP server has anything meaningful to say. Note that progress messages for new empty tasks will be dropped, but existing tasks will be processed to completion. ''; notificationGroup = helpers.defaultNullOpts.mkLuaFn "function(msg) return msg.lsp_name end" '' How to get a progress message's notification group key Set this to return a constant to group all LSP progress messages together. Example: ```lua notification_group = function(msg) -- N.B. you may also want to configure this group key ("lsp_progress") -- using progress.display.overrides or notification.configs return "lsp_progress" end ``` ''; clearOnDetach = helpers.defaultNullOpts.mkStrLuaFnOr (types.enum [ false ]) '' function(client_id) local client = vim.lsp.get_client_by_id(client_id) return client and client.name or nil end '' '' Clear notification group when LSP server detaches This option should be set to a function that, given a client ID number, returns the notification group to clear. No group will be cleared if the function returns `nil`. The default setting looks up and returns the LSP client name, which is also used by `notificationGroup`. Set this option to `false` to disable this feature entirely (no `|LspDetach|` callback will be installed). ''; ignore = helpers.defaultNullOpts.mkListOf types.str [ ] '' List of LSP servers to ignore. ''; # Options related to how LSP progress messages are displayed as notifications display = { renderLimit = helpers.defaultNullOpts.mkNullable (with types; either (enum [ false ]) number) 16 '' How many LSP messages to show at once. If `false`, no limit. This is used to configure each LSP notification group, so by default, this is a per-server limit. ''; doneTtl = helpers.defaultNullOpts.mkStrLuaOr types.ints.unsigned "3" '' How long a message should persist after completion. Set to `0` to use notification group config default, and `math.huge` to show notification indefinitely (until overwritten). Measured in seconds. ''; doneIcon = mkIconOption "✔" "Icon shown when all LSP progress tasks are complete."; doneStyle = helpers.defaultNullOpts.mkStr "Constant" '' Highlight group for completed LSP tasks. ''; progressTtl = helpers.defaultNullOpts.mkStrLuaFnOr types.ints.unsigned "math.huge" '' How long a message should persist when in progress. ''; progressIcon = mkIconOption '' { pattern = "dots"; } '' "Icon shown when LSP progress tasks are in progress"; progressStyle = helpers.defaultNullOpts.mkStr "WarningMsg" '' Highlight group for in-progress LSP tasks. ''; groupStyle = helpers.defaultNullOpts.mkStr "Title" '' Highlight group for group name (LSP server name). ''; iconStyle = helpers.defaultNullOpts.mkStr "Question" '' Highlight group for group icons. ''; priority = helpers.defaultNullOpts.mkUnsignedInt 30 '' Ordering priority for LSP notification group. ''; skipHistory = helpers.defaultNullOpts.mkBool true '' Whether progress notifications should be omitted from history. ''; formatMessage = helpers.defaultNullOpts.mkLua "require('fidget.progress.display').default_format_message" '' How to format a progress message. ```lua format_message = function(msg) if string.find(msg.title, "Indexing") then return nil -- Ignore "Indexing..." progress messages end if msg.message then return msg.message else return msg.done and "Completed" or "In progress..." end end ``` ''; formatAnnote = helpers.defaultNullOpts.mkLuaFn "function(msg) return msg.title end" "How to format a progress annotation."; formatGroupName = helpers.defaultNullOpts.mkLuaFn "function(group) return tostring(group) end" "How to format a progress notification group's name."; overrides = helpers.defaultNullOpts.mkAttrsOf notificationConfigType { rust_analyzer = { name = "rust-analyzer"; }; } '' Override options from the default notification config. Keys of the table are each notification group's `key`. ''; }; # Options related to Neovim's built-in LSP client lsp = { progressRingbufSize = helpers.defaultNullOpts.mkUnsignedInt 0 '' Configure the nvim's LSP progress ring buffer size. Useful for avoiding progress message overflow when the LSP server blasts more messages than the ring buffer can handle. Leaves the progress ringbuf size at its default if this setting is 0 or less. Doesn't do anything for Neovim pre-v0.10.0. ''; }; }; # Options related to notification subsystem notification = { pollRate = helpers.defaultNullOpts.mkUnsignedInt 10 '' How frequently to update and render notifications. Measured in Hertz (frames per second). ''; filter = helpers.defaultNullOpts.mkLogLevel "info" '' Minimum notifications level. Note that this filter only applies to notifications with an explicit numeric level (i.e., `vim.log.levels`). Set to `"off"` to filter out all notifications with an numeric level, or `"trace"` to turn off filtering. ''; historySize = helpers.defaultNullOpts.mkUnsignedInt 128 '' Number of removed messages to retain in history. Set to 0 to keep around history indefinitely (until cleared). ''; overrideVimNotify = helpers.defaultNullOpts.mkBool false '' Automatically override `vim.notify()` with Fidget. Equivalent to the following: ```lua fidget.setup({ --[[ options ]] }) vim.notify = fidget.notify ``` ''; configs = helpers.defaultNullOpts.mkAttrsOf (with types; either str notificationConfigType) { default = "require('fidget.notification').default_config"; } '' How to configure notification groups when instantiated. A configuration with the key `"default"` should always be specified, and is used as the fallback for notifications lacking a group key. To see the default config, run: `:lua print(vim.inspect(require("fidget.notification").default_config))` ''; redirect = helpers.defaultNullOpts.mkStrLuaFnOr (types.enum [ false ]) '' function(msg, level, opts) if opts and opts.on_open then return require("fidget.integration.nvim-notify").delegate(msg, level, opts) end end '' '' Conditionally redirect notifications to another backend. This option is useful for delegating notifications to another backend that supports features Fidget has not (yet) implemented. For instance, Fidget uses a single, shared buffer and window for rendering all notifications, so it lacks a per-notification `on_open` callback that can be used to, e.g., set the `|filetype|` for a specific notification. For such notifications, Fidget's default `redirect` delegates such notifications with an `on_open` callback to `|nvim-notify|` (if available). ''; # Options related to how notifications are rendered as text view = { stackUpwards = helpers.defaultNullOpts.mkBool true '' Display notification items from bottom to top. Setting this to `true` tends to lead to more stable animations when the window is bottom-aligned. ''; iconSeparator = helpers.defaultNullOpts.mkStr " " '' Separator between group name and icon. Must not contain any newlines. Set to `""` to remove the gap between names and icons in all notification groups. ''; groupSeparator = helpers.defaultNullOpts.mkNullable (with types; either str (enum [ false ])) "---" '' Separator between notification groups. Must not contain any newlines. Set to `false` to omit separator entirely. ''; groupSeparatorHl = helpers.defaultNullOpts.mkNullable ( with types; either str (enum [ false ]) ) "Comment" "Highlight group used for group separator."; }; # Options related to the notification window and buffer window = { normalHl = helpers.defaultNullOpts.mkStr "Comment" '' Base highlight group in the notification window. Used by any Fidget notification text that is not otherwise highlighted, i.e., message text. Note that we use this blanket highlight for all messages to avoid adding separate highlights to each line (whose lengths may vary). Set to empty string to keep your theme defaults. With `winblend` set to anything less than `100`, this will also affect the background color in the notification box area (see `winblend` docs). ''; winblend = helpers.defaultNullOpts.mkUnsignedInt 100 '' Background color opacity in the notification window. Note that the notification window is rectangular, so any cells covered by that rectangular area is affected by the background color of `normal_hl`. With `winblend` set to anything less than `100`, the background of `normal_hl` will be blended with that of whatever is underneath, including, e.g., a shaded `colorcolumn`, which is usually not desirable. However, if you would like to display the notification window as its own "boxed" area (especially if you are using a non-"none" `border`), you may consider setting `winblend` to something less than `100`. ''; border = helpers.defaultNullOpts.mkBorder "none" "the notification window" ""; borderHl = helpers.defaultNullOpts.mkStr "" '' Highlight group for notification window border. Set to empty string to keep your theme's default `FloatBorder` highlight. ''; zindex = helpers.defaultNullOpts.mkUnsignedInt 45 '' Stacking priority of the notification window. Note that the default priority for Vim windows is 50. ''; maxWidth = helpers.defaultNullOpts.mkUnsignedInt 0 '' Maximum width of the notification window. `0` means no maximum width. ''; maxHeight = helpers.defaultNullOpts.mkUnsignedInt 0 '' Maximum height of the notification window. `0` means no maximum height. ''; xPadding = helpers.defaultNullOpts.mkUnsignedInt 1 '' Padding from right edge of window boundary. ''; yPadding = helpers.defaultNullOpts.mkUnsignedInt 0 '' Padding from bottom edge of window boundary. ''; align = helpers.defaultNullOpts.mkEnum [ "top" "bottom" "avoid_cursor" ] "bottom" '' How to align the notification window. ''; relative = helpers.defaultNullOpts.mkEnumFirstDefault [ "editor" "win" ] '' What the notification window position is relative to. ''; }; }; integration = { nvim-tree = { enable = helpers.defaultNullOpts.mkBool true '' Integrate with nvim-tree/nvim-tree.lua (if installed). Dynamically offset Fidget's notifications window when the nvim-tree window is open on the right side + the Fidget window is "editor"-relative. ''; }; }; # Options related to logging logger = { level = helpers.defaultNullOpts.mkLogLevel "warn" "Minimum logging level"; floatPrecision = helpers.defaultNullOpts.mkNullable ( with types; numbers.between 0.0 1.0 ) 1.0e-2 "Limit the number of decimals displayed for floats."; path = helpers.defaultNullOpts.mkStr { __raw = "string.format('%s/fidget.nvim.log', vim.fn.stdpath('cache'))"; } '' Where Fidget writes its logs to. Using `{__raw = "vim.fn.stdpath('cache')";}`, the default path usually ends up at `~/.cache/nvim/fidget.nvim.log`. ''; }; }; }; config = mkIf cfg.enable { warnings = optional ( (isBool cfg.integration.nvim-tree.enable) && cfg.integration.nvim-tree.enable && !config.plugins.nvim-tree.enable ) '' You have set `plugins.fidget.integrations.nvim-tree.enable` to true but have not enabled `plugins.nvim-tree`. ''; extraPlugins = [ cfg.package ]; extraConfigLua = let processNotificationConfig = notificationConfig: with notificationConfig; { inherit name icon; icon_on_left = iconOnLeft; annote_separator = annoteSeparator; inherit ttl; render_limit = renderLimit; group_style = groupStyle; icon_style = iconStyle; annote_style = annoteStyle; debug_style = debugStyle; info_style = infoStyle; warn_style = warnStyle; error_style = errorStyle; debug_annote = debugAnnote; info_annote = infoAnnote; warn_annote = warnAnnote; error_annote = errorAnnote; inherit priority; skip_history = skipHistory; }; setupOptions = with cfg; { progress = with progress; { poll_rate = pollRate; suppress_on_insert = suppressOnInsert; ignore_done_already = ignoreDoneAlready; ignore_empty_message = ignoreEmptyMessage; notification_group = notificationGroup; clear_on_detach = clearOnDetach; inherit ignore; display = with display; { render_limit = renderLimit; done_ttl = doneTtl; done_icon = doneIcon; done_style = doneStyle; progress_ttl = progressTtl; progress_icon = progressIcon; progress_style = progressStyle; group_style = groupStyle; icon_style = iconStyle; inherit priority; skip_history = skipHistory; format_message = formatMessage; format_annote = formatAnnote; format_group_name = formatGroupName; overrides = helpers.ifNonNull' overrides (mapAttrs (_: processNotificationConfig) overrides); }; lsp = with lsp; { progress_ringbuf_size = progressRingbufSize; }; }; notification = with notification; { poll_rate = pollRate; inherit filter; history_size = historySize; override_vim_notify = overrideVimNotify; configs = helpers.ifNonNull' configs ( mapAttrs ( _: value: if isString value then helpers.mkRaw value else processNotificationConfig value ) configs ); inherit redirect; view = with view; { stack_upwards = stackUpwards; icon_separator = iconSeparator; group_separator = groupSeparator; group_separator_hl = groupSeparatorHl; }; window = with window; { normal_hl = normalHl; inherit winblend border; border_hl = borderHl; inherit zindex; max_width = maxWidth; max_height = maxHeight; x_padding = xPadding; y_padding = yPadding; inherit align relative; }; }; integration = with integration; { nvim-tree = with nvim-tree; { inherit enable; }; }; logger = with logger; { inherit level; float_precision = floatPrecision; inherit path; }; } // cfg.extraOptions; in '' require("fidget").setup${helpers.toLuaObject setupOptions} ''; }; }