plugins/fidget: migrate to mkNeovimPlugin

plugins/by-name/fidget/default.nix

@@ -1,17 +1,11 @@
-{
+{ config, lib, ... }:
-  lib,
-  helpers,
-  config,
-  pkgs,
-  ...
-}:
-with lib;
 let
-  cfg = config.plugins.fidget;
+  inherit (lib) literalExpression types;
+  inherit (lib.nixvim) defaultNullOpts literalLua nestedLiteralLua;
 
   mkIconOption =
     default: desc:
-    helpers.defaultNullOpts.mkNullable
+    defaultNullOpts.mkNullable
       (
         with types;
         oneOf [
@@ -33,273 +27,210 @@ let
       '';
 
   notificationConfigType = types.submodule {
+    freeformType = with types; attrsOf anything;
     options = {
-      name = helpers.mkNullOrOption types.str ''
+      name = defaultNullOpts.mkStr (literalExpression "<name>") ''
-        Name of the group; if `null`, the key is used as name.
+        Name of the group.
       '';
-
+      icon = lib.nixvim.mkNullOrOption types.str ''
-      icon = helpers.mkNullOrOption types.str ''
         Icon of the group; if `null`, no icon is used.
       '';
 
-      iconOnLeft = helpers.mkNullOrOption types.bool ''
+      icon_on_left = lib.nixvim.mkNullOrOption types.bool ''
         If true, icon is rendered on the left instead of right.
       '';
 
-      annoteSeparator = helpers.defaultNullOpts.mkStr "” ”" ''
+      annote_separator = defaultNullOpts.mkStr "” ”" ''
         Separator between message from annote.
       '';
 
-      ttl = helpers.defaultNullOpts.mkUnsignedInt 3 ''
+      ttl = defaultNullOpts.mkUnsignedInt 3 ''
         How long a notification item should exist.
       '';
 
-      renderLimit = helpers.mkNullOrOption types.ints.unsigned ''
+      render_limit = lib.nixvim.mkNullOrOption types.ints.unsigned ''
         How many notification items to show at once.
       '';
 
-      groupStyle = helpers.defaultNullOpts.mkStr "Title" ''
+      group_style = defaultNullOpts.mkStr "Title" ''
         Style used to highlight group name.
       '';
 
-      iconStyle = helpers.mkNullOrOption types.str ''
+      icon_style = lib.nixvim.mkNullOrOption types.str ''
         Style used to highlight icon; if `null`, use `groupStyle`.
       '';
 
-      annoteStyle = helpers.defaultNullOpts.mkStr "Question" ''
+      annote_style = defaultNullOpts.mkStr "Question" ''
         Default style used to highlight item annotes.
       '';
 
-      debugStyle = helpers.mkNullOrOption types.str ''
+      debug_style = lib.nixvim.mkNullOrOption types.str ''
         Style used to highlight debug item annotes.
       '';
 
-      infoStyle = helpers.mkNullOrOption types.str ''
+      info_style = lib.nixvim.mkNullOrOption types.str ''
         Style used to highlight info item annotes.
       '';
 
-      warnStyle = helpers.mkNullOrOption types.str ''
+      warn_style = lib.nixvim.mkNullOrOption types.str ''
         Style used to highlight warn item annotes.
       '';
 
-      errorStyle = helpers.mkNullOrOption types.str ''
+      error_style = lib.nixvim.mkNullOrOption types.str ''
         Style used to highlight error item annotes.
       '';
 
-      debugAnnote = helpers.mkNullOrOption types.str ''
+      debug_annote = lib.nixvim.mkNullOrOption types.str ''
         Default annotation for debug items.
       '';
 
-      infoAnnote = helpers.mkNullOrOption types.str ''
+      info_annote = lib.nixvim.mkNullOrOption types.str ''
         Default annotation for info items.
       '';
 
-      warnAnnote = helpers.mkNullOrOption types.str ''
+      warn_annote = lib.nixvim.mkNullOrOption types.str ''
         Default annotation for warn items.
       '';
 
-      errorAnnote = helpers.mkNullOrOption types.str ''
+      error_annote = lib.nixvim.mkNullOrOption types.str ''
         Default annotation for error items.
       '';
 
-      priority = helpers.defaultNullOpts.mkUnsignedInt 50 ''
+      priority = defaultNullOpts.mkUnsignedInt 50 ''
         Order in which group should be displayed.
       '';
 
-      skipHistory = helpers.defaultNullOpts.mkBool true ''
+      skip_history = defaultNullOpts.mkBool true ''
         Whether progress notifications should be omitted from history.
       '';
+
+      update_hook = defaultNullOpts.mkNullable (with types; either rawLua (enum [ false ])) false ''
+        Called when an item is updated
+      '';
     };
   };
 in
-{
+lib.nixvim.plugins.mkNeovimPlugin {
-  # TODO: deprecation warnings introduced 2023/12/22: remove in early February 2024
+  name = "fidget";
-  imports =
+  packPathName = "fidget.nvim";
-    map
+  package = "fidget-nvim";
-      (
-        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
+  maintainers = [ lib.maintainers.HeitorAugustoLN ];
-          ''
-      )
-      [
-        "text"
-        "align"
-        "timer"
-        "window"
-        "fmt"
-        "sources"
-        "debug"
-      ];
 
-  options = {
+  settingsOptions = {
-    plugins.fidget = lib.nixvim.plugins.neovim.extraOptionsOptions // {
-      enable = mkEnableOption "fidget-nvim";
-
-      package = lib.mkPackageOption pkgs "fidget-nvim" {
-        default = [
-          "vimPlugins"
-          "fidget-nvim"
-        ];
-      };
-
-      # Options related to LSP progress subsystem
     progress = {
-        pollRate = helpers.defaultNullOpts.mkNullable (with types; either (enum [ false ]) number) 0 ''
+      poll_rate =
+        defaultNullOpts.mkNullableWithRaw (with types; either ints.unsigned (enum [ false ])) 0
+          ''
             How and when to poll for progress messages.
 
-          Set to `0` to immediately poll on each `|LspProgress|` event.
+            Set to `false` to disable polling altogether. You can still manually pool
-
+            progress messages by calling |fidget.progress.poll|.
-          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_on_insert = 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_done_already = 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_empty_message = defaultNullOpts.mkBool false ''
         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" ''
+      clear_on_detach =
-          How to get a progress message's notification group key
+        defaultNullOpts.mkNullable
-
+          (
-          Set this to return a constant to group all LSP progress messages together.
+            with types;
-
+            oneOf [
-          Example:
+              strLuaFn
-          ```lua
+              rawLua
-            notification_group = function(msg)
+              (enum [ false ])
-              -- N.B. you may also want to configure this group key ("lsp_progress")
+            ]
-              -- using progress.display.overrides or notification.configs
+          )
-              return "lsp_progress"
+          (literalLua ''
-            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.
-              Clear notification group when LSP server detaches
 
-              This option should be set to a function that, given a client ID number, returns the
+            Set this option to `false` to disable this feature entirely.
-              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 [ ] ''
+      notification_group =
-          List of LSP servers to ignore.
+        defaultNullOpts.mkNullableWithRaw types.strLuaFn
+          ''
+            function(msg) return msg.lsp_client.name end
+          ''
+          ''
+            How to get a progress message's notification group key.
+          '';
+
+      ignore = defaultNullOpts.mkListOf types.str [ ] ''
+        List of filters to ignore LSP progress messages.
       '';
 
-        # Options related to how LSP progress messages are displayed as notifications
       display = {
-          renderLimit = helpers.defaultNullOpts.mkNullable (with types; either (enum [ false ]) number) 16 ''
+        render_limit = defaultNullOpts.mkNullableWithRaw (with types; either number (enum [ false ])) 16 ''
           How many LSP messages to show at once.
 
-            If `false`, no limit.
+          If set to `false`, no limit will be enforced.
-
-            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" ''
+        done_ttl = defaultNullOpts.mkNum 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.";
+        done_icon = mkIconOption "✔" ''
+          Icon shown when all LSP progress tasks are complete.
+        '';
 
-          doneStyle = helpers.defaultNullOpts.mkStr "Constant" ''
+        done_style = defaultNullOpts.mkStr "Constant" ''
           Highlight group for completed LSP tasks.
         '';
 
-          progressTtl = helpers.defaultNullOpts.mkStrLuaFnOr types.ints.unsigned "math.huge" ''
+        progress_ttl = defaultNullOpts.mkNum (literalLua "math.huge") ''
           How long a message should persist when in progress.
         '';
 
-          progressIcon = mkIconOption ''
+        progress_icon = mkIconOption [ "dots" ] ''
-            {
+          Icon shown when an LSP progress task is in progress.
-              pattern = "dots";
+        '';
-            }
-          '' "Icon shown when LSP progress tasks are in progress";
 
-          progressStyle = helpers.defaultNullOpts.mkStr "WarningMsg" ''
+        progress_style = defaultNullOpts.mkStr "WarningMsg" ''
           Highlight group for in-progress LSP tasks.
         '';
 
-          groupStyle = helpers.defaultNullOpts.mkStr "Title" ''
+        group_style = defaultNullOpts.mkStr "Title" ''
           Highlight group for group name (LSP server name).
         '';
 
-          iconStyle = helpers.defaultNullOpts.mkStr "Question" ''
+        icon_style = defaultNullOpts.mkStr "Question" ''
           Highlight group for group icons.
         '';
 
-          priority = helpers.defaultNullOpts.mkUnsignedInt 30 ''
+        priority = defaultNullOpts.mkNullableWithRaw (with types; either number (enum [ false ])) 30 ''
           Ordering priority for LSP notification group.
         '';
 
-          skipHistory = helpers.defaultNullOpts.mkBool true ''
+        skip_history = defaultNullOpts.mkBool true ''
           Whether progress notifications should be omitted from history.
         '';
 
-          formatMessage = helpers.defaultNullOpts.mkLua "require('fidget.progress.display').default_format_message" ''
+        format_message =
+          defaultNullOpts.mkNullableWithRaw types.strLua
+            ''
+              require("fidget.progress.display").default_format_message
+            ''
+            ''
               How to format a progress message.
 
+              Example:
               ```lua
                 format_message = function(msg)
                   if string.find(msg.title, "Indexing") then
@@ -314,12 +245,20 @@ in
               ```
             '';
 
-          formatAnnote = helpers.defaultNullOpts.mkLuaFn "function(msg) return msg.title end" "How to format a progress annotation.";
+        format_annote =
+          defaultNullOpts.mkNullableWithRaw types.strLuaFn "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.";
+        format_group_name =
+          defaultNullOpts.mkNullableWithRaw types.strLuaFn "function(group) tostring(group) end"
+            ''
+              How to format a progress notification's group name.
+            '';
 
         overrides =
-            helpers.defaultNullOpts.mkAttrsOf notificationConfigType
+          defaultNullOpts.mkAttrsOf notificationConfigType
             {
               rust_analyzer = {
                 name = "rust-analyzer";
@@ -331,76 +270,56 @@ in
             '';
       };
 
-        # Options related to Neovim's built-in LSP client
       lsp = {
-          progressRingbufSize = helpers.defaultNullOpts.mkUnsignedInt 0 ''
+        progress_ringbuf_size = defaultNullOpts.mkNum 0 ''
           Configure the nvim's LSP progress ring buffer size.
+        '';
 
-            Useful for avoiding progress message overflow when the LSP server blasts more messages
+        log_handler = defaultNullOpts.mkBool false ''
-            than the ring buffer can handle.
+          Log `$/progress` handler invocations (for debugging).
-
-            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 ''
+      poll_rate = defaultNullOpts.mkNum 10 ''
         How frequently to update and render notifications.
-
         Measured in Hertz (frames per second).
       '';
 
-        filter = helpers.defaultNullOpts.mkLogLevel "info" ''
+      filter = defaultNullOpts.mkLogLevel "info" ''
-          Minimum notifications level.
+        Minimum log level to display.
-
-          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 ''
+      history_size = defaultNullOpts.mkNum 128 ''
         Number of removed messages to retain in history.
 
         Set to 0 to keep around history indefinitely (until cleared).
       '';
 
-        overrideVimNotify = helpers.defaultNullOpts.mkBool false ''
+      override_vim_notify = defaultNullOpts.mkBool false ''
-          Automatically override `vim.notify()` with Fidget.
+        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)
+        defaultNullOpts.mkAttrsOf (with types; either rawLua notificationConfigType)
-            { default = "require('fidget.notification').default_config"; }
+          { default = nestedLiteralLua ''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
+            A configuration with the key `"default"` should always be specified, and
-              the fallback for notifications lacking a group key.
+            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 ])
+        defaultNullOpts.mkNullable (with types; either rawLua (enum [ false ]))
-            ''
+          (literalLua ''
             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.
 
@@ -414,268 +333,154 @@ in
             an `on_open` callback to `|nvim-notify|` (if available).
           '';
 
-        # Options related to how notifications are rendered as text
       view = {
-          stackUpwards = helpers.defaultNullOpts.mkBool true ''
+        stack_upwards = 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 " " ''
+        icon_separator = 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 =
+        group_separator = defaultNullOpts.mkStr "--" ''
-            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 (
+        group_separator_hl = defaultNullOpts.mkStr "Comment" ''
-            with types; either str (enum [ false ])
+          Highlight group used for group separator.
-          ) "Comment" "Highlight group used for group separator.";
+        '';
+
+        render_message =
+          defaultNullOpts.mkRaw
+            ''
+              function(msg, cnt) return cnt == 1 and msg or string.format("(%dx) %s", cnt, msg) end
+            ''
+            ''
+              How to render notification messages.
+
+              Messages that appear multiple times (have the same `content_key`) will
+              only be rendered once, with a `cnt` greater than 1. This hook provides an
+              opportunity to customize how such messages should appear.
+            '';
       };
 
-        # Options related to the notification window and buffer
       window = {
-          normalHl = helpers.defaultNullOpts.mkStr "Comment" ''
+        normal_hl = 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 ''
+        winblend = defaultNullOpts.mkNum 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" "";
+        border = defaultNullOpts.mkBorder "none" "the notification window" "";
 
-          borderHl = helpers.defaultNullOpts.mkStr "" ''
+        border_hl = defaultNullOpts.mkStr "" ''
-            Highlight group for notification window border.
+          Highlight group for the notification window border.
-
-            Set to empty string to keep your theme's default `FloatBorder` highlight.
         '';
 
-          zindex = helpers.defaultNullOpts.mkUnsignedInt 45 ''
+        zindex = defaultNullOpts.mkNum 45 ''
           Stacking priority of the notification window.
-
-            Note that the default priority for Vim windows is 50.
         '';
 
-          maxWidth = helpers.defaultNullOpts.mkUnsignedInt 0 ''
+        max_width = defaultNullOpts.mkInt 0 ''
           Maximum width of the notification window.
-            `0` means no maximum width.
         '';
 
-          maxHeight = helpers.defaultNullOpts.mkUnsignedInt 0 ''
+        max_height = defaultNullOpts.mkInt 0 ''
           Maximum height of the notification window.
-            `0` means no maximum height.
         '';
 
-          xPadding = helpers.defaultNullOpts.mkUnsignedInt 1 ''
+        x_padding = defaultNullOpts.mkInt 1 ''
-            Padding from right edge of window boundary.
+          Horizontal padding of the notification window.
         '';
 
-          yPadding = helpers.defaultNullOpts.mkUnsignedInt 0 ''
+        y_padding = defaultNullOpts.mkInt 0 ''
-            Padding from bottom edge of window boundary.
+          Vertical padding of the notification window.
         '';
 
-          align =
+        align = defaultNullOpts.mkEnum [ "top" "bottom" "avoid_cursor" ] "bottom" ''
-            helpers.defaultNullOpts.mkEnum
-              [
-                "top"
-                "bottom"
-                "avoid_cursor"
-              ]
-              "bottom"
-              ''
           How to align the notification window.
         '';
 
-          relative =
+        relative = defaultNullOpts.mkEnumFirstDefault [ "editor" "win" ] ''
-            helpers.defaultNullOpts.mkEnumFirstDefault
-              [
-                "editor"
-                "win"
-              ]
-              ''
           What the notification window position is relative to.
         '';
       };
     };
 
     integration = {
-        nvim-tree = {
+      nvim-tree.enable = defaultNullOpts.mkBool true ''
-          enable = helpers.defaultNullOpts.mkBool true ''
+        Enable integration with `nvim-tree`. (if installed)
-            Integrate with nvim-tree/nvim-tree.lua (if installed).
+      '';
-
+      xcodebuild-nvim.enable = defaultNullOpts.mkBool true ''
-            Dynamically offset Fidget's notifications window when the nvim-tree window is open on
+        Enable integration with `xcodebuild-nvim`. (if installed)
-            the right side + the Fidget window is "editor"-relative.
       '';
     };
-      };
 
-      # Options related to logging
     logger = {
-        level = helpers.defaultNullOpts.mkLogLevel "warn" "Minimum logging level";
+      level = defaultNullOpts.mkLogLevel "warn" ''
+        Minimum logging level.
+      '';
 
-        floatPrecision = helpers.defaultNullOpts.mkProportion 1.0e-2 "Limit the number of decimals displayed for floats.";
+      max_size = defaultNullOpts.mkNullableWithRaw (with types; either number (enum [ false ])) 10000 ''
+        Maximum log size file, in KB.
+      '';
 
-        path =
+      float_precision = defaultNullOpts.mkProportion 0.01 ''
-          helpers.defaultNullOpts.mkStr
+        Limit the number of decimals displayed in floating point numbers.
-            { __raw = "string.format('%s/fidget.nvim.log', vim.fn.stdpath('cache'))"; }
+      '';
-            ''
-              Where Fidget writes its logs to.
 
+      path = defaultNullOpts.mkStr (literalLua ''string.format("%s/fidget.nvim.log", vim.fn.stdpath("cache"))'') ''
+        Where fidget writes its log file.
 
-              Using `{__raw = "vim.fn.stdpath('cache')";}`, the default path usually ends up at
+        Using `vim.fn.stdpath("cache")`, the default path usually ends up at
         `~/.cache/nvim/fidget.nvim.log`.
       '';
     };
   };
+
+  settingsExample = {
+    notification = {
+      window = {
+        winblend = 0;
+      };
+    };
+    progress = {
+      display = {
+        done_icon = "";
+        done_ttl = 7;
+        format_message = nestedLiteralLua ''
+          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
+        '';
+      };
+    };
+    text = {
+      spinner = "dots";
+    };
   };
 
-  config = mkIf cfg.enable {
+  extraConfig = cfg: {
     warnings =
-      optional
+      lib.optionals
         (
-          (isBool cfg.integration.nvim-tree.enable)
+          (builtins.isBool cfg.settings.integration.nvim-tree.enable)
-          && cfg.integration.nvim-tree.enable
+          && cfg.settings.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`.
+          "Nixvim(plugins.fidget): You have set `plugins.fidget.settings.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 =
+  inherit (import ./deprecations.nix { inherit lib; }) imports optionsRenamedToSettings;
-          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${lib.nixvim.toLuaObject setupOptions}
-      '';
-  };
 }

plugins/by-name/fidget/deprecations.nix

@@ -0,0 +1,136 @@
+{ lib, ... }:
+let
+  inherit (lib) mkRemovedOptionModule;
+in
+{
+  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"
+      ];
+
+  optionsRenamedToSettings =
+    let
+      progressOptions = [
+        "pollRate"
+        "suppressOnInsert"
+        "ignoreDoneAlready"
+        "ignoreEmptyMessage"
+        "notificationGroup"
+        "clearOnDetach"
+        "ignore"
+      ];
+      progressDisplayOptions = [
+        "renderLimit"
+        "doneTtl"
+        "doneIcon"
+        "doneStyle"
+        "progressTtl"
+        "progressIcon"
+        "progressStyle"
+        "groupStyle"
+        "iconStyle"
+        "priority"
+        "skipHistory"
+        "formatMessage"
+        "formatAnnote"
+        "formatGroupName"
+        "overrides"
+      ];
+      notificationOptions = [
+        "pollRate"
+        "filter"
+        "historySize"
+        "overrideVimNotify"
+        "configs"
+        "redirect"
+      ];
+      notificationViewOptions = [
+        "stackUpwards"
+        "iconSeparator"
+        "groupSeparator"
+        "groupSeparatorHl"
+      ];
+      notificationWindowOptions = [
+        "normalHl"
+        "winblend"
+        "border"
+        "borderHl"
+        "zindex"
+        "maxWidth"
+        "maxHeight"
+        "xPadding"
+        "yPadding"
+        "align"
+        "relative"
+      ];
+    in
+    [
+      [
+        "progress"
+        "lsp"
+        "progressRingbufSize"
+      ]
+      [
+        "integration"
+        "nvim-tree"
+        "enable"
+      ]
+      [
+        "logger"
+        "level"
+      ]
+      [
+        "logger"
+        "floatPrecision"
+      ]
+      [
+        "logger"
+        "path"
+      ]
+    ]
+    ++ map (oldOption: [
+      "progress"
+      oldOption
+    ]) progressOptions
+    ++ map (oldOption: [
+      "progress"
+      "display"
+      oldOption
+    ]) progressDisplayOptions
+    ++ map (oldOption: [
+      "notification"
+      oldOption
+    ]) notificationOptions
+    ++ map (oldOption: [
+      "notification"
+      "view"
+      oldOption
+    ]) notificationViewOptions
+    ++ map (oldOption: [
+      "notification"
+      "window"
+      oldOption
+    ]) notificationWindowOptions;
+}