From 6ede63c170b25af745949c58915b50c9dac0897c Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 30 Sep 2024 21:55:37 +0200
Subject: [PATCH 01/22] flake: add lz.n and lzn-auto-require

---
 flake.lock | 35 +++++++++++++++++++++++++++++++++++
 flake.nix  | 11 +++++++++++
 2 files changed, 46 insertions(+)

diff --git a/flake.lock b/flake.lock
index 3e26731..aa5763e 100644
--- a/flake.lock
+++ b/flake.lock
@@ -828,6 +828,39 @@
         "type": "github"
       }
     },
+    "plugin-lz-n": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1727574854,
+        "narHash": "sha256-qDWNleR2NHFkiEKE/+LNVOBRwEeskMC4dWTl5BTyZuE=",
+        "owner": "nvim-neorocks",
+        "repo": "lz.n",
+        "rev": "470173e3cbef763c6d1b918f3f129b67db75e1f8",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nvim-neorocks",
+        "repo": "lz.n",
+        "type": "github"
+      }
+    },
+    "plugin-lzn-auto-require": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1727636949,
+        "narHash": "sha256-BAOzN+XOrFAJwHmsF8JtZ2EyjP9283FD/I2TbFqGSEw=",
+        "owner": "horriblename",
+        "repo": "lzn-auto-require",
+        "rev": "55ecd60831dac8c01d6f3dcb63a30a63a1690eb8",
+        "type": "github"
+      },
+      "original": {
+        "owner": "horriblename",
+        "ref": "require-rewrite",
+        "repo": "lzn-auto-require",
+        "type": "github"
+      }
+    },
     "plugin-mind-nvim": {
       "flake": false,
       "locked": {
@@ -1859,6 +1892,8 @@
         "plugin-lspkind": "plugin-lspkind",
         "plugin-lspsaga": "plugin-lspsaga",
         "plugin-lualine": "plugin-lualine",
+        "plugin-lz-n": "plugin-lz-n",
+        "plugin-lzn-auto-require": "plugin-lzn-auto-require",
         "plugin-mind-nvim": "plugin-mind-nvim",
         "plugin-minimap-vim": "plugin-minimap-vim",
         "plugin-modes-nvim": "plugin-modes-nvim",
diff --git a/flake.nix b/flake.nix
index c4a1a2a..994477a 100644
--- a/flake.nix
+++ b/flake.nix
@@ -113,6 +113,17 @@
     };
 
     ## Plugins
+    # Lazy loading
+    plugin-lz-n = {
+      url = "github:nvim-neorocks/lz.n";
+      flake = false;
+    };
+
+    plugin-lzn-auto-require = {
+      url = "github:horriblename/lzn-auto-require/require-rewrite";
+      flake = false;
+    };
+
     # LSP plugins
     plugin-nvim-lspconfig = {
       url = "github:neovim/nvim-lspconfig";

From 937d0f22af142021bfa92c5e03b83d34e81a4b85 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 30 Sep 2024 21:56:31 +0200
Subject: [PATCH 02/22] lazy: init module

---
 modules/modules.nix              |   1 +
 modules/wrapper/lazy/config.nix  |  76 ++++++++++++
 modules/wrapper/lazy/default.nix |   6 +
 modules/wrapper/lazy/lazy.nix    | 207 +++++++++++++++++++++++++++++++
 4 files changed, 290 insertions(+)
 create mode 100644 modules/wrapper/lazy/config.nix
 create mode 100644 modules/wrapper/lazy/default.nix
 create mode 100644 modules/wrapper/lazy/lazy.nix

diff --git a/modules/modules.nix b/modules/modules.nix
index 1204e43..784c413 100644
--- a/modules/modules.nix
+++ b/modules/modules.nix
@@ -50,6 +50,7 @@
       "build"
       "rc"
       "warnings"
+      "lazy"
     ];
 
     # Extra modules, such as deprecation warnings
diff --git a/modules/wrapper/lazy/config.nix b/modules/wrapper/lazy/config.nix
new file mode 100644
index 0000000..9ee15e7
--- /dev/null
+++ b/modules/wrapper/lazy/config.nix
@@ -0,0 +1,76 @@
+{
+  lib,
+  config,
+  ...
+}: let
+  inherit (builtins) toJSON typeOf head length tryEval filter;
+  inherit (lib.modules) mkIf;
+  inherit (lib.generators) mkLuaInline;
+  inherit (lib.strings) optionalString;
+  inherit (lib.nvim.lua) toLuaObject;
+  inherit (lib.nvim.dag) entryBefore;
+  cfg = config.vim.lazy;
+
+  toLuaLznKeySpec = keySpec:
+    (removeAttrs keySpec ["key" "lua" "action"])
+    // {
+      "@1" = keySpec.key;
+      "@2" =
+        if keySpec.lua
+        then mkLuaInline keySpec.action
+        else keySpec.action;
+    };
+
+  toLuaLznSpec = spec: let
+    name =
+      if typeOf spec.package == "string"
+      then spec.package
+      else if (spec.package ? pname && (tryEval spec.package.pname).success)
+      then spec.package.pname
+      else spec.package.name;
+  in
+    (removeAttrs spec ["package" "setupModule" "setupOpts" "keys"])
+    // {
+      "@1" = name;
+      before =
+        if spec.before != null
+        then
+          mkLuaInline ''
+            function()
+              ${spec.before}
+            end
+          ''
+        else null;
+
+      after =
+        if spec.setupModule == null && spec.after == null
+        then null
+        else
+          mkLuaInline ''
+            function()
+              ${
+              optionalString (spec.setupModule != null)
+              "require(${toJSON spec.setupModule}).setup(${toLuaObject spec.setupOpts})"
+            }
+              ${optionalString (spec.after != null) spec.after}
+            end
+          '';
+
+      keys =
+        if typeOf spec.keys == "list" && length spec.keys > 0 && typeOf (head spec.keys) == "set"
+        then map toLuaLznKeySpec (filter (keySpec: keySpec.key != null) spec.keys)
+        # empty list or str or (listOf str)
+        else spec.keys;
+    };
+  lznSpecs = map toLuaLznSpec cfg.plugins;
+in {
+  config.vim = mkIf cfg.enable {
+    startPlugins = ["lz-n" "lzn-auto-require"];
+
+    optPlugins = map (plugin: plugin.package) cfg.plugins;
+
+    luaConfigRC.lzn-load = entryBefore ["pluginConfigs"] ''
+      require('lz.n').load(${toLuaObject lznSpecs})
+    '';
+  };
+}
diff --git a/modules/wrapper/lazy/default.nix b/modules/wrapper/lazy/default.nix
new file mode 100644
index 0000000..fa40127
--- /dev/null
+++ b/modules/wrapper/lazy/default.nix
@@ -0,0 +1,6 @@
+_: {
+  imports = [
+    ./lazy.nix
+    ./config.nix
+  ];
+}
diff --git a/modules/wrapper/lazy/lazy.nix b/modules/wrapper/lazy/lazy.nix
new file mode 100644
index 0000000..5f20c12
--- /dev/null
+++ b/modules/wrapper/lazy/lazy.nix
@@ -0,0 +1,207 @@
+{lib, ...}: let
+  inherit (lib.options) mkOption mkEnableOption;
+  inherit (lib.types) enum listOf submodule nullOr str bool int attrsOf anything either oneOf;
+  inherit (lib.nvim.types) pluginType;
+  inherit (lib.nvim.config) mkBool;
+
+  lznKeysSpec = submodule {
+    options = {
+      key = mkOption {
+        type = nullOr str;
+        description = "Key to bind to. If key is null this entry is ignored.";
+      };
+
+      action = mkOption {
+        type = nullOr str;
+        default = null;
+        description = "Action to trigger.";
+      };
+      lua = mkBool false ''
+        If true, `action` is considered to be lua code.
+        Thus, it will not be wrapped in `""`.
+      '';
+
+      desc = mkOption {
+        description = "Description of the key map";
+        type = nullOr str;
+        default = null;
+      };
+
+      ft = mkOption {
+        description = "TBD";
+        type = nullOr (listOf str);
+        default = null;
+      };
+
+      mode = mkOption {
+        description = "Modes to bind in";
+        type = listOf str;
+        default = ["n" "x" "s" "o"];
+      };
+
+      silent = mkBool true "Whether this mapping should be silent. Equivalent to adding <silent> to a map.";
+      nowait = mkBool false "Whether to wait for extra input on ambiguous mappings. Equivalent to adding <nowait> to a map.";
+      script = mkBool false "Equivalent to adding <script> to a map.";
+      expr = mkBool false "Means that the action is actually an expression. Equivalent to adding <expr> to a map.";
+      unique = mkBool false "Whether to fail if the map is already defined. Equivalent to adding <unique> to a map.";
+      noremap = mkBool true "Whether to use the 'noremap' variant of the command, ignoring any custom mappings on the defined action. It is highly advised to keep this on, which is the default.";
+    };
+  };
+
+  lznPluginType = submodule {
+    options = {
+      package = mkOption {
+        type = pluginType;
+        description = "Plugin package";
+      };
+
+      setupModule = mkOption {
+        type = nullOr str;
+        description = "Lua module to run setup function on.";
+        default = null;
+      };
+
+      setupOpts = mkOption {
+        type = submodule {freeformType = attrsOf anything;};
+        description = "Options to pass to the setup function";
+        default = {};
+      };
+
+      # lz.n options
+
+      enabled = mkOption {
+        type = nullOr (either bool str);
+        description = "When false, or if the lua function returns false, this plugin will not be included in the spec";
+        default = null;
+      };
+
+      beforeAll = mkOption {
+        type = nullOr str;
+        description = "Lua code to run before any plugins are loaded. This will be wrapped in a function.";
+        default = null;
+      };
+
+      before = mkOption {
+        type = nullOr str;
+        description = "Lua code to run before plugin is loaded. This will be wrapped in a function.";
+        default = null;
+      };
+
+      after = mkOption {
+        type = nullOr str;
+        description = ''
+          Lua code to run after plugin is loaded. This will be wrapped in a function.
+
+          If {opt}`vim.plugins.*.setupModule` is provided, the setup will be ran before `after`.
+        '';
+        default = null;
+      };
+
+      event = mkOption {
+        description = "Lazy-load on event";
+        default = null;
+        type = let
+          event = submodule {
+            options = {
+              event = mkOption {
+                type = nullOr (either str (listOf str));
+                description = "Exact event name";
+                example = "BufEnter";
+              };
+              pattern = mkOption {
+                type = nullOr (either str (listOf str));
+                description = "Event pattern";
+                example = "BufEnter *.lua";
+              };
+            };
+          };
+        in
+          nullOr (oneOf [str (listOf str) event]);
+      };
+
+      cmd = mkOption {
+        description = "Lazy-load on command";
+        default = null;
+        type = nullOr (either str (listOf str));
+      };
+
+      ft = mkOption {
+        description = "Lazy-load on filetype";
+        default = null;
+        type = nullOr (either str (listOf str));
+      };
+
+      keys = mkOption {
+        description = "Lazy-load on key mapping";
+        default = null;
+        type = nullOr (oneOf [str (listOf lznKeysSpec) (listOf str)]);
+        example = ''
+          keys = [
+            {
+              mode = "n";
+              key = "<leader>s";
+              action = ":DapStepOver<cr>";
+              desc = "DAP Step Over";
+            }
+            {
+              mode = ["n", "x"];
+              key = "<leader>dc";
+              action = "function() require('dap').continue() end";
+              lua = true;
+              desc = "DAP Continue";
+            }
+          ]
+        '';
+      };
+
+      colorscheme = mkOption {
+        description = "Lazy-load on colorscheme.";
+        type = nullOr (either str (listOf str));
+        default = null;
+      };
+
+      priority = mkOption {
+        type = nullOr int;
+        description = "Only useful for stat plugins (not lazy-loaded) to force loading certain plugins first.";
+        default = null;
+      };
+
+      load = mkOption {
+        type = nullOr str;
+        default = null;
+        description = ''
+          Lua code to override the `vim.g.lz_n.load()` function for a single plugin.
+
+          This will be wrapped in a function
+        '';
+      };
+    };
+  };
+in {
+  options.vim.lazy = {
+    enable = mkEnableOption "plugin lazy-loading" // {default = true;};
+    loader = mkOption {
+      description = "Lazy loader to use";
+      type = enum ["lz.n"];
+      default = "lz.n";
+    };
+
+    plugins = mkOption {
+      default = [];
+      type = listOf lznPluginType;
+      description = "list of plugins to lazy load";
+      example = ''
+        [
+          {
+            package = "toggleterm-nvim";
+            setupModule = "toggleterm";
+            setupOpts = cfg.setupOpts;
+
+            after = "require('toggleterm').do_something()";
+            cmd = ["ToggleTerm"];
+          }
+        ]
+      '';
+    };
+  };
+}

From 3e48cea5361b0854c6a5036be7313e8214350194 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 30 Sep 2024 21:57:03 +0200
Subject: [PATCH 03/22] lzn-auto-require: add init lua code

---
 modules/wrapper/rc/config.nix | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/modules/wrapper/rc/config.nix b/modules/wrapper/rc/config.nix
index 6f9ed1c..25fc9bc 100644
--- a/modules/wrapper/rc/config.nix
+++ b/modules/wrapper/rc/config.nix
@@ -4,8 +4,8 @@
   ...
 }: let
   inherit (builtins) map mapAttrs filter;
-  inherit (lib.attrsets) mapAttrsToList filterAttrs;
-  inherit (lib.strings) concatLines concatMapStringsSep;
+  inherit (lib.attrsets) mapAttrsToList;
+  inherit (lib.strings) concatLines concatMapStringsSep optionalString;
   inherit (lib.trivial) showWarnings;
   inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.dag) entryAfter mkLuarcSection resolveDag entryAnywhere;
@@ -55,6 +55,8 @@ in {
         pluginConfigs = entryAfter ["optionsScript"] pluginConfigs;
         extraPluginConfigs = entryAfter ["pluginConfigs"] extraPluginConfigs;
         mappings = entryAfter ["extraPluginConfigs"] keymaps;
+        # FIXME: put this somewhere less stupid
+        footer = entryAfter ["mappings"] (optionalString config.vim.lazy.enable "require('lzn-auto-require').enable()");
       };
 
       builtLuaConfigRC = let

From 96954beeceec00d0a2310bd220fc2b183233cab4 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 30 Sep 2024 21:57:36 +0200
Subject: [PATCH 04/22] wrapper: fix opt plugin format

---
 modules/default.nix | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/modules/default.nix b/modules/default.nix
index 6a95080..6306da9 100644
--- a/modules/default.nix
+++ b/modules/default.nix
@@ -84,10 +84,7 @@
 
   # built (or "normalized") plugins that are modified
   builtStartPlugins = buildConfigPlugins vimOptions.startPlugins;
-  builtOptPlugins = map (package: {
-    plugin = package;
-    optional = true;
-  }) (buildConfigPlugins vimOptions.optPlugins);
+  builtOptPlugins = map (package: package // {optional = true;}) (buildConfigPlugins vimOptions.optPlugins);
 
   # additional Lua and Python3 packages, mapped to their respective functions
   # to conform to the format mnw expects. end user should

From 7e144707d94a0455ee733ac3515a087df89fb373 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 30 Sep 2024 21:58:06 +0200
Subject: [PATCH 05/22] lib.binds: add lz.n variant of bind functions

---
 lib/binds.nix | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/lib/binds.nix b/lib/binds.nix
index 8c9e9a6..298cd30 100644
--- a/lib/binds.nix
+++ b/lib/binds.nix
@@ -67,6 +67,30 @@
       mkLuaBinding binding.value action binding.description;
 
     pushDownDefault = attr: mapAttrs (_: mkDefault) attr;
+
+    mkLznBinding = mode: key: action: desc: {
+      inherit mode desc key action;
+    };
+
+    mkLznExprBinding = mode: key: action: desc: {
+      inherit mode desc key action;
+      lua = true;
+      silent = true;
+      expr = true;
+    };
+
+    mkSetLznBinding = binding: action: {
+      inherit action;
+      key = binding.value;
+      desc = binding.description;
+    };
+
+    mkSetLuaLznBinding = binding: action: {
+      inherit action;
+      key = binding.value;
+      lua = true;
+      desc = binding.description;
+    };
   };
 in
   binds

From bc6597c36a2743dd4395b9bb4f9f3dc857c4d65d Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 30 Sep 2024 21:58:21 +0200
Subject: [PATCH 06/22] telescope: lazy load

---
 modules/plugins/utility/telescope/config.nix | 114 +++++++++----------
 1 file changed, 52 insertions(+), 62 deletions(-)

diff --git a/modules/plugins/utility/telescope/config.nix b/modules/plugins/utility/telescope/config.nix
index 68af964..f50e955 100644
--- a/modules/plugins/utility/telescope/config.nix
+++ b/modules/plugins/utility/telescope/config.nix
@@ -4,11 +4,11 @@
   lib,
   ...
 }: let
-  inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.binds) addDescriptionsToMappings mkSetBinding;
-  inherit (lib.nvim.dag) entryAnywhere;
-  inherit (lib.nvim.binds) pushDownDefault;
-  inherit (lib.nvim.lua) toLuaObject;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.binds) addDescriptionsToMappings;
+  inherit (lib.strings) optionalString;
+  inherit (lib.lists) optionals;
+  inherit (lib.nvim.binds) pushDownDefault mkSetLznBinding;
 
   cfg = config.vim.telescope;
   self = import ./telescope.nix {inherit pkgs lib;};
@@ -18,45 +18,58 @@
 in {
   config = mkIf cfg.enable {
     vim = {
-      startPlugins = [
-        "telescope"
-        "plenary-nvim"
-      ];
+      startPlugins = ["plenary-nvim"];
 
-      maps.normal = mkMerge [
-        (mkSetBinding mappings.findFiles "<cmd> Telescope find_files<CR>")
-        (mkSetBinding mappings.liveGrep "<cmd> Telescope live_grep<CR>")
-        (mkSetBinding mappings.buffers "<cmd> Telescope buffers<CR>")
-        (mkSetBinding mappings.helpTags "<cmd> Telescope help_tags<CR>")
-        (mkSetBinding mappings.open "<cmd> Telescope<CR>")
-        (mkSetBinding mappings.resume "<cmd> Telescope resume<CR>")
+      lazy.plugins = [
+        {
+          package = "telescope";
+          setupModule = "telescope";
+          inherit (cfg) setupOpts;
+          # FIXME: how do I deal with extensions? set all as deps?
+          after = ''
+            local telescope = require("telescope")
+            ${optionalString config.vim.ui.noice.enable "telescope.load_extension('noice')"}
+            ${optionalString config.vim.notify.nvim-notify.enable "telescope.load_extension('notify')"}
+            ${optionalString config.vim.projects.project-nvim.enable "telescope.load_extension('projects')"}
+          '';
 
-        (mkSetBinding mappings.gitCommits "<cmd> Telescope git_commits<CR>")
-        (mkSetBinding mappings.gitBufferCommits "<cmd> Telescope git_bcommits<CR>")
-        (mkSetBinding mappings.gitBranches "<cmd> Telescope git_branches<CR>")
-        (mkSetBinding mappings.gitStatus "<cmd> Telescope git_status<CR>")
-        (mkSetBinding mappings.gitStash "<cmd> Telescope git_stash<CR>")
+          cmd = ["Telescope"];
 
-        (mkIf config.vim.lsp.enable (mkMerge [
-          (mkSetBinding mappings.lspDocumentSymbols "<cmd> Telescope lsp_document_symbols<CR>")
-          (mkSetBinding mappings.lspWorkspaceSymbols "<cmd> Telescope lsp_workspace_symbols<CR>")
+          keys =
+            [
+              (mkSetLznBinding mappings.findFiles "<cmd> Telescope find_files<CR>")
+              (mkSetLznBinding mappings.liveGrep "<cmd> Telescope live_grep<CR>")
+              (mkSetLznBinding mappings.buffers "<cmd> Telescope buffers<CR>")
+              (mkSetLznBinding mappings.helpTags "<cmd> Telescope help_tags<CR>")
+              (mkSetLznBinding mappings.open "<cmd> Telescope<CR>")
 
-          (mkSetBinding mappings.lspReferences "<cmd> Telescope lsp_references<CR>")
-          (mkSetBinding mappings.lspImplementations "<cmd> Telescope lsp_implementations<CR>")
-          (mkSetBinding mappings.lspDefinitions "<cmd> Telescope lsp_definitions<CR>")
-          (mkSetBinding mappings.lspTypeDefinitions "<cmd> Telescope lsp_type_definitions<CR>")
-          (mkSetBinding mappings.diagnostics "<cmd> Telescope diagnostics<CR>")
-        ]))
+              (mkSetLznBinding mappings.gitCommits "<cmd> Telescope git_commits<CR>")
+              (mkSetLznBinding mappings.gitBufferCommits "<cmd> Telescope git_bcommits<CR>")
+              (mkSetLznBinding mappings.gitBranches "<cmd> Telescope git_branches<CR>")
+              (mkSetLznBinding mappings.gitStatus "<cmd> Telescope git_status<CR>")
+              (mkSetLznBinding mappings.gitStash "<cmd> Telescope git_stash<CR>")
+            ]
+            ++ (optionals config.vim.lsp.enable [
+              (mkSetLznBinding mappings.lspDocumentSymbols "<cmd> Telescope lsp_document_symbols<CR>")
+              (mkSetLznBinding mappings.lspWorkspaceSymbols "<cmd> Telescope lsp_workspace_symbols<CR>")
 
-        (
-          mkIf config.vim.treesitter.enable
-          (mkSetBinding mappings.treesitter "<cmd> Telescope treesitter<CR>")
-        )
-
-        (
-          mkIf config.vim.projects.project-nvim.enable
-          (mkSetBinding mappings.findProjects "<cmd> Telescope projects<CR>")
-        )
+              (mkSetLznBinding mappings.lspReferences "<cmd> Telescope lsp_references<CR>")
+              (mkSetLznBinding mappings.lspImplementations "<cmd> Telescope lsp_implementations<CR>")
+              (mkSetLznBinding mappings.lspDefinitions "<cmd> Telescope lsp_definitions<CR>")
+              (mkSetLznBinding mappings.lspTypeDefinitions "<cmd> Telescope lsp_type_definitions<CR>")
+              (mkSetLznBinding mappings.diagnostics "<cmd> Telescope diagnostics<CR>")
+            ])
+            ++ (
+              optionals config.vim.treesitter.enable [
+                (mkSetLznBinding mappings.treesitter "<cmd> Telescope treesitter<CR>")
+              ]
+            )
+            ++ (
+              optionals config.vim.projects.project-nvim.enable [
+                (mkSetLznBinding mappings.findProjects "<cmd Telescope projects<CR>")
+              ]
+            );
+        }
       ];
 
       binds.whichKey.register = pushDownDefault {
@@ -66,29 +79,6 @@ in {
         "<leader>fv" = "Telescope Git";
         "<leader>fvc" = "Commits";
       };
-
-      pluginRC.telescope = entryAnywhere ''
-        local telescope = require('telescope')
-        telescope.setup(${toLuaObject cfg.setupOpts})
-
-        ${
-          if config.vim.ui.noice.enable
-          then "telescope.load_extension('noice')"
-          else ""
-        }
-
-        ${
-          if config.vim.notify.nvim-notify.enable
-          then "telescope.load_extension('notify')"
-          else ""
-        }
-
-        ${
-          if config.vim.projects.project-nvim.enable
-          then "telescope.load_extension('projects')"
-          else ""
-        }
-      '';
     };
   };
 }

From edab575b52218a59afa3a4e5961ae92328b6e19e Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 30 Sep 2024 21:58:38 +0200
Subject: [PATCH 07/22] nvim-tree: lazy load

---
 modules/plugins/filetree/nvimtree/config.nix | 32 +++++++++++---------
 1 file changed, 18 insertions(+), 14 deletions(-)

diff --git a/modules/plugins/filetree/nvimtree/config.nix b/modules/plugins/filetree/nvimtree/config.nix
index b97b1e4..66a901b 100644
--- a/modules/plugins/filetree/nvimtree/config.nix
+++ b/modules/plugins/filetree/nvimtree/config.nix
@@ -5,10 +5,9 @@
   ...
 }: let
   inherit (lib.strings) optionalString;
-  inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.binds) mkBinding;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.binds) mkLznBinding;
   inherit (lib.nvim.dag) entryAnywhere;
-  inherit (lib.nvim.lua) toLuaObject;
   inherit (lib.nvim.binds) pushDownDefault;
 
   cfg = config.vim.filetree.nvimTree;
@@ -16,19 +15,25 @@
   inherit (self.options.vim.filetree.nvimTree) mappings;
 in {
   config = mkIf cfg.enable {
-    vim.startPlugins = ["nvim-tree-lua"];
-
-    vim.maps.normal = mkMerge [
-      (mkBinding cfg.mappings.toggle ":NvimTreeToggle<cr>" mappings.toggle.description)
-      (mkBinding cfg.mappings.refresh ":NvimTreeRefresh<cr>" mappings.refresh.description)
-      (mkBinding cfg.mappings.findFile ":NvimTreeFindFile<cr>" mappings.findFile.description)
-      (mkBinding cfg.mappings.focus ":NvimTreeFocus<cr>" mappings.focus.description)
-    ];
-
     vim.binds.whichKey.register = pushDownDefault {
       "<leader>t" = "+NvimTree";
     };
 
+    vim.lazy.plugins = [
+      {
+        package = "nvim-tree-lua";
+        setupModule = "nvim-tree";
+        inherit (cfg) setupOpts;
+        cmd = ["NvimTreeClipboard" "NvimTreeClose" "NvimTreeCollapse" "NvimTreeCollapseKeepBuffers" "NvimTreeFindFile" "NvimTreeFindFileToggle" "NvimTreeFocus" "NvimTreeHiTest" "NvimTreeOpen" "NvimTreeRefresh" "NvimTreeResize" "NvimTreeToggle"];
+        keys = [
+          (mkLznBinding ["n"] cfg.mappings.toggle ":NvimTreeToggle<cr>" mappings.toggle.description)
+          (mkLznBinding ["n"] cfg.mappings.refresh ":NvimTreeRefresh<cr>" mappings.refresh.description)
+          (mkLznBinding ["n"] cfg.mappings.findFile ":NvimTreeFindFile<cr>" mappings.findFile.description)
+          (mkLznBinding ["n"] cfg.mappings.focus ":NvimTreeFocus<cr>" mappings.focus.description)
+        ];
+      }
+    ];
+
     vim.pluginRC.nvimtreelua = entryAnywhere ''
       ${
         optionalString cfg.setupOpts.disable_netrw ''
@@ -38,10 +43,9 @@ in {
         ''
       }
 
-      require'nvim-tree'.setup(${toLuaObject cfg.setupOpts})
-
       ${
         optionalString cfg.openOnSetup ''
+          ${optionalString config.vim.lazy.enable ''require('lz.n').trigger_load("nvim-tree-lua")''}
           -- autostart behaviour
           -- Open on startup has been deprecated
           -- see https://github.com/nvim-tree/nvim-tree.lua/wiki/Open-At-Startup

From 0608e107cdba656c22b62d36bdd832f3957975f8 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 30 Sep 2024 21:58:43 +0200
Subject: [PATCH 08/22] dapui: lazy load

---
 modules/plugins/debugger/nvim-dap/config.nix | 33 +++++++++++++-------
 1 file changed, 21 insertions(+), 12 deletions(-)

diff --git a/modules/plugins/debugger/nvim-dap/config.nix b/modules/plugins/debugger/nvim-dap/config.nix
index 072ad9a..1c80ac4 100644
--- a/modules/plugins/debugger/nvim-dap/config.nix
+++ b/modules/plugins/debugger/nvim-dap/config.nix
@@ -6,7 +6,7 @@
   inherit (lib.strings) optionalString;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.attrsets) mapAttrs;
-  inherit (lib.nvim.binds) addDescriptionsToMappings mkSetLuaBinding;
+  inherit (lib.nvim.binds) addDescriptionsToMappings mkSetLuaBinding mkSetLuaLznBinding;
   inherit (lib.nvim.dag) entryAnywhere entryAfter;
 
   cfg = config.vim.debugger.nvim-dap;
@@ -49,24 +49,33 @@ in {
       ];
     })
     (mkIf (cfg.enable && cfg.ui.enable) {
-      vim.startPlugins = ["nvim-dap-ui" "nvim-nio"];
+      vim.startPlugins = ["nvim-nio"];
 
-      vim.pluginRC.nvim-dap-ui = entryAfter ["nvim-dap"] (''
-          local dapui = require("dapui")
-          dapui.setup()
-        ''
-        + optionalString cfg.ui.autoStart ''
+      vim.lazy.plugins = [
+        {
+          package = "nvim-dap-ui";
+          setupModule = "dapui";
+          setupOpts = {};
+
+          keys = [
+            (mkSetLuaLznBinding mappings.toggleDapUI "function() require('dapui').toggle() end")
+          ];
+        }
+      ];
+
+      vim.pluginRC.nvim-dap-ui = entryAfter ["nvim-dap"] (
+        optionalString cfg.ui.autoStart ''
           dap.listeners.after.event_initialized["dapui_config"] = function()
-            dapui.open()
+            require("dapui").open()
           end
           dap.listeners.before.event_terminated["dapui_config"] = function()
-            dapui.close()
+            require("dapui").close()
           end
           dap.listeners.before.event_exited["dapui_config"] = function()
-            dapui.close()
+            require("dapui").close()
           end
-        '');
-      vim.maps.normal = mkSetLuaBinding mappings.toggleDapUI "require('dapui').toggle";
+        ''
+      );
     })
   ];
 }

From 6c92f6cec5a69a99ebbbc6feac148a67cf0734be Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 30 Sep 2024 21:58:48 +0200
Subject: [PATCH 09/22] trouble: lazy load

---
 modules/plugins/lsp/trouble/config.nix  | 33 +++++++++++++------------
 modules/plugins/lsp/trouble/trouble.nix |  3 +++
 2 files changed, 20 insertions(+), 16 deletions(-)

diff --git a/modules/plugins/lsp/trouble/config.nix b/modules/plugins/lsp/trouble/config.nix
index dd853e3..1a7eb46 100644
--- a/modules/plugins/lsp/trouble/config.nix
+++ b/modules/plugins/lsp/trouble/config.nix
@@ -3,9 +3,8 @@
   lib,
   ...
 }: let
-  inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.dag) entryAnywhere;
-  inherit (lib.nvim.binds) addDescriptionsToMappings mkSetBinding pushDownDefault;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.binds) addDescriptionsToMappings mkSetLznBinding pushDownDefault;
 
   cfg = config.vim.lsp;
 
@@ -15,15 +14,22 @@
 in {
   config = mkIf (cfg.enable && cfg.trouble.enable) {
     vim = {
-      startPlugins = ["trouble"];
+      lazy.plugins = [
+        {
+          package = "trouble";
+          setupModule = "trouble";
+          inherit (cfg.trouble) setupOpts;
 
-      maps.normal = mkMerge [
-        (mkSetBinding mappings.toggle "<cmd>TroubleToggle<CR>")
-        (mkSetBinding mappings.workspaceDiagnostics "<cmd>TroubleToggle workspace_diagnostics<CR>")
-        (mkSetBinding mappings.documentDiagnostics "<cmd>TroubleToggle document_diagnostics<CR>")
-        (mkSetBinding mappings.lspReferences "<cmd>TroubleToggle lsp_references<CR>")
-        (mkSetBinding mappings.quickfix "<cmd>TroubleToggle quickfix<CR>")
-        (mkSetBinding mappings.locList "<cmd>TroubleToggle loclist<CR>")
+          cmd = "Trouble";
+          keys = [
+            (mkSetLznBinding mappings.toggle "<cmd>TroubleToggle<CR>")
+            (mkSetLznBinding mappings.workspaceDiagnostics "<cmd>TroubleToggle workspace_diagnostics<CR>")
+            (mkSetLznBinding mappings.documentDiagnostics "<cmd>TroubleToggle document_diagnostics<CR>")
+            (mkSetLznBinding mappings.lspReferences "<cmd>TroubleToggle lsp_references<CR>")
+            (mkSetLznBinding mappings.quickfix "<cmd>TroubleToggle quickfix<CR>")
+            (mkSetLznBinding mappings.locList "<cmd>TroubleToggle loclist<CR>")
+          ];
+        }
       ];
 
       binds.whichKey.register = pushDownDefault {
@@ -31,11 +37,6 @@ in {
         "<leader>x" = "+Trouble";
         "<leader>lw" = "Workspace";
       };
-
-      pluginRC.trouble = entryAnywhere ''
-        -- Enable trouble diagnostics viewer
-        require("trouble").setup {}
-      '';
     };
   };
 }
diff --git a/modules/plugins/lsp/trouble/trouble.nix b/modules/plugins/lsp/trouble/trouble.nix
index bd16c67..04bd506 100644
--- a/modules/plugins/lsp/trouble/trouble.nix
+++ b/modules/plugins/lsp/trouble/trouble.nix
@@ -1,11 +1,14 @@
 {lib, ...}: let
   inherit (lib.options) mkEnableOption;
   inherit (lib.nvim.binds) mkMappingOption;
+  inherit (lib.nvim.types) mkPluginSetupOption;
 in {
   options.vim.lsp = {
     trouble = {
       enable = mkEnableOption "trouble diagnostics viewer";
 
+      setupOpts = mkPluginSetupOption "Trouble" {};
+
       mappings = {
         toggle = mkMappingOption "Toggle trouble [trouble]" "<leader>xx";
         workspaceDiagnostics = mkMappingOption "Workspace diagnostics [trouble]" "<leader>lwd";

From bb2b3ff225cf41c47ba66a91dba2f17d615d2eae Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 30 Sep 2024 21:58:54 +0200
Subject: [PATCH 10/22] toggleterm: lazy load

---
 .../plugins/terminal/toggleterm/config.nix    | 80 +++++++++----------
 1 file changed, 37 insertions(+), 43 deletions(-)

diff --git a/modules/plugins/terminal/toggleterm/config.nix b/modules/plugins/terminal/toggleterm/config.nix
index 07851e4..b416748 100644
--- a/modules/plugins/terminal/toggleterm/config.nix
+++ b/modules/plugins/terminal/toggleterm/config.nix
@@ -4,55 +4,49 @@
   ...
 }: let
   inherit (builtins) toJSON;
-  inherit (lib.lists) optionals;
-  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.strings) optionalString;
+  inherit (lib.modules) mkIf;
   inherit (lib.meta) getExe;
-  inherit (lib.nvim.binds) mkBinding;
-  inherit (lib.nvim.dag) entryAnywhere entryAfter;
-  inherit (lib.nvim.lua) toLuaObject;
+  inherit (lib.nvim.binds) mkLznBinding;
 
   cfg = config.vim.terminal.toggleterm;
+  lazygitMapDesc = "Open lazygit [toggleterm]";
 in {
-  config = mkMerge [
-    (
-      mkIf cfg.enable {
-        vim = {
-          startPlugins = [
-            "toggleterm-nvim"
+  config = mkIf cfg.enable {
+    vim = {
+      lazy.plugins = [
+        {
+          package = "toggleterm-nvim";
+          cmd = ["ToggleTerm" "ToggleTermSendCurrentLine" "ToggleTermSendVisualLines" "ToggleTermSendVisualSelection" "ToggleTermSetName" "ToggleTermToggleAll"];
+          keys = [
+            (mkLznBinding ["n"] cfg.mappings.open "<Cmd>execute v:count . \"ToggleTerm\"<CR>" "Toggle terminal")
+            {
+              key = cfg.lazygit.mappings.open;
+              desc = lazygitMapDesc;
+            }
           ];
 
-          maps.normal = mkBinding cfg.mappings.open "<Cmd>execute v:count . \"ToggleTerm\"<CR>" "Toggle terminal";
+          setupModule = "toggleterm";
+          inherit (cfg) setupOpts;
+          after = optionalString cfg.lazygit.enable ''
+            local terminal = require 'toggleterm.terminal'
+            local lazygit = terminal.Terminal:new({
+              cmd = '${
+              if (cfg.lazygit.package != null)
+              then getExe cfg.lazygit.package
+              else "lazygit"
+            }',
+              direction = '${cfg.lazygit.direction}',
+              hidden = true,
+              on_open = function(term)
+                vim.cmd("startinsert!")
+              end
+            })
 
-          pluginRC.toggleterm = entryAnywhere ''
-            require("toggleterm").setup(${toLuaObject cfg.setupOpts})
+            vim.keymap.set('n', ${toJSON cfg.lazygit.mappings.open}, function() lazygit:toggle() end, {silent = true, noremap = true, desc = '${lazygitMapDesc}'})
           '';
-        };
-      }
-    )
-    (
-      mkIf (cfg.enable && cfg.lazygit.enable)
-      {
-        vim.startPlugins = optionals (cfg.lazygit.package != null) [
-          cfg.lazygit.package
-        ];
-        vim.pluginRC.toggleterm-lazygit = entryAfter ["toggleterm"] ''
-          local terminal = require 'toggleterm.terminal'
-          local lazygit = terminal.Terminal:new({
-            cmd = '${
-            if (cfg.lazygit.package != null)
-            then getExe cfg.lazygit.package
-            else "lazygit"
-          }',
-            direction = '${cfg.lazygit.direction}',
-            hidden = true,
-            on_open = function(term)
-              vim.cmd("startinsert!")
-            end
-          })
-
-          vim.keymap.set('n', ${toJSON cfg.lazygit.mappings.open}, function() lazygit:toggle() end, {silent = true, noremap = true, desc = 'Open lazygit [toggleterm]'})
-        '';
-      }
-    )
-  ];
+        }
+      ];
+    };
+  };
 }

From 127ae0200d7f9cb81973d45b5bc4a41758294759 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 30 Sep 2024 21:59:00 +0200
Subject: [PATCH 11/22] cheatsheet: lazy load

---
 .../plugins/utility/binds/cheatsheet/config.nix   | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/modules/plugins/utility/binds/cheatsheet/config.nix b/modules/plugins/utility/binds/cheatsheet/config.nix
index 2848ddc..f7bfa44 100644
--- a/modules/plugins/utility/binds/cheatsheet/config.nix
+++ b/modules/plugins/utility/binds/cheatsheet/config.nix
@@ -4,15 +4,20 @@
   ...
 }: let
   inherit (lib.modules) mkIf;
-  inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.strings) optionalString;
 
   cfg = config.vim.binds.cheatsheet;
 in {
   config = mkIf cfg.enable {
-    vim.startPlugins = ["cheatsheet-nvim"];
+    vim.lazy.plugins = [
+      {
+        package = "cheatsheet-nvim";
+        setupModule = "cheatsheet";
+        setupOpts = {};
+        cmd = ["Cheatsheet" "CheatsheetEdit"];
 
-    vim.pluginRC.cheaetsheet-nvim = entryAnywhere ''
-      require('cheatsheet').setup({})
-    '';
+        before = optionalString config.vim.lazy.enable "require('lz.n').trigger_load('telescope')";
+      }
+    ];
   };
 }

From a9ce2fe101f39bb4774eb6a5d2c3b7792c29a835 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 30 Sep 2024 21:59:05 +0200
Subject: [PATCH 12/22] diffview: lazy load

---
 modules/plugins/utility/diffview/config.nix   | 15 +++++++++++----
 modules/plugins/utility/diffview/diffview.nix |  2 ++
 2 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/modules/plugins/utility/diffview/config.nix b/modules/plugins/utility/diffview/config.nix
index 681a305..5ea51d7 100644
--- a/modules/plugins/utility/diffview/config.nix
+++ b/modules/plugins/utility/diffview/config.nix
@@ -8,9 +8,16 @@
   cfg = config.vim.utility.diffview-nvim;
 in {
   config = mkIf cfg.enable {
-    vim.startPlugins = [
-      "diffview-nvim"
-      "plenary-nvim"
-    ];
+    vim = {
+      startPlugins = ["plenary-nvim"];
+      lazy.plugins = [
+        {
+          package = "diffview-nvim";
+          cmd = ["DiffviewClose" "DiffviewFileHistory" "DiffviewFocusFiles" "DiffviewLog" "DiffviewOpen" "DiffviewRefresh" "DiffviewToggleFiles"];
+          setupModule = "diffview";
+          inherit (cfg) setupOpts;
+        }
+      ];
+    };
   };
 }
diff --git a/modules/plugins/utility/diffview/diffview.nix b/modules/plugins/utility/diffview/diffview.nix
index 74ddd57..793666d 100644
--- a/modules/plugins/utility/diffview/diffview.nix
+++ b/modules/plugins/utility/diffview/diffview.nix
@@ -1,7 +1,9 @@
 {lib, ...}: let
   inherit (lib.options) mkEnableOption;
+  inherit (lib.nvim.types) mkPluginSetupOption;
 in {
   options.vim.utility.diffview-nvim = {
     enable = mkEnableOption "diffview-nvim: cycle through diffs for all modified files for any git rev";
+    setupOpts = mkPluginSetupOption "Fidget" {};
   };
 }

From fb36de0aac998c7cb2d45f80e01ffc0bde63097b Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 30 Sep 2024 21:59:10 +0200
Subject: [PATCH 13/22] icon-picker: lazy load

---
 .../plugins/utility/icon-picker/config.nix    | 22 ++++++++++---------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/modules/plugins/utility/icon-picker/config.nix b/modules/plugins/utility/icon-picker/config.nix
index 405f691..13fa45e 100644
--- a/modules/plugins/utility/icon-picker/config.nix
+++ b/modules/plugins/utility/icon-picker/config.nix
@@ -4,20 +4,22 @@
   ...
 }: let
   inherit (lib.modules) mkIf;
-  inherit (lib.nvim.dag) entryAnywhere;
 
   cfg = config.vim.utility.icon-picker;
 in {
   config = mkIf cfg.enable {
-    vim.startPlugins = [
-      "icon-picker-nvim"
-      "dressing-nvim"
-    ];
+    vim.startPlugins = ["dressing-nvim"];
 
-    vim.pluginRC.icon-picker = entryAnywhere ''
-      require("icon-picker").setup({
-        disable_legacy_commands = true
-      })
-    '';
+    vim.lazy.plugins = [
+      {
+        package = "icon-picker-nvim";
+        setupModule = "icon-picker";
+        setupOpts = {
+          disable_legacy_commands = true;
+        };
+
+        cmd = ["IconPickerInsert" "IconPickerNormal" "IconPickerYank"];
+      }
+    ];
   };
 }

From f7b099e6f818fc1fe2f8933060d6d9199fe8e354 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 30 Sep 2024 21:59:14 +0200
Subject: [PATCH 14/22] leap: lazy load

---
 .../plugins/utility/motion/leap/config.nix    | 110 ++++++++----------
 1 file changed, 49 insertions(+), 61 deletions(-)

diff --git a/modules/plugins/utility/motion/leap/config.nix b/modules/plugins/utility/motion/leap/config.nix
index 9ede98f..9e9cf40 100644
--- a/modules/plugins/utility/motion/leap/config.nix
+++ b/modules/plugins/utility/motion/leap/config.nix
@@ -3,71 +3,59 @@
   lib,
   ...
 }: let
-  inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.binds) mkBinding;
-  inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.binds) mkLznBinding;
 
   cfg = config.vim.utility.motion.leap;
 in {
   config = mkIf cfg.enable {
-    vim.startPlugins = [
-      "leap-nvim"
-      "vim-repeat"
-    ];
+    vim = {
+      startPlugins = ["vim-repeat"];
+      lazy.plugins = [
+        {
+          package = "leap-nvim";
+          keys = [
+            (mkLznBinding ["n" "o" "x"] cfg.mappings.leapForwardTo "<Plug>(leap-forward-to)" "Leap forward to")
+            (mkLznBinding ["n" "o" "x"] cfg.mappings.leapBackwardTo "<Plug>(leap-backward-to)" "Leap backward to")
+            (mkLznBinding ["n" "o" "x"] cfg.mappings.leapForwardTill "<Plug>(leap-forward-till)" "Leap forward till")
+            (mkLznBinding ["n" "o" "x"] cfg.mappings.leapBackwardTill "<Plug>(leap-backward-till)" "Leap backward till")
+            (mkLznBinding ["n" "o" "x"] cfg.mappings.leapFromWindow "<Plug>(leap-from-window)" "Leap from window")
+          ];
 
-    vim.maps.normal = mkMerge [
-      (mkBinding cfg.mappings.leapForwardTo "<Plug>(leap-forward-to)" "Leap forward to")
-      (mkBinding cfg.mappings.leapBackwardTo "<Plug>(leap-backward-to)" "Leap backward to")
-      (mkBinding cfg.mappings.leapFromWindow "<Plug>(leap-from-window)" "Leap from window")
-    ];
-
-    vim.maps.operator = mkMerge [
-      (mkBinding cfg.mappings.leapForwardTo "<Plug>(leap-forward-to)" "Leap forward to")
-      (mkBinding cfg.mappings.leapBackwardTo "<Plug>(leap-backward-to)" "Leap backward to")
-      (mkBinding cfg.mappings.leapForwardTill "<Plug>(leap-forward-till)" "Leap forward till")
-      (mkBinding cfg.mappings.leapBackwardTill "<Plug>(leap-backward-till)" "Leap backward till")
-      (mkBinding cfg.mappings.leapFromWindow "<Plug>(leap-from-window)" "Leap from window")
-    ];
-
-    vim.maps.visualOnly = mkMerge [
-      (mkBinding cfg.mappings.leapForwardTo "<Plug>(leap-forward-to)" "Leap forward to")
-      (mkBinding cfg.mappings.leapBackwardTo "<Plug>(leap-backward-to)" "Leap backward to")
-      (mkBinding cfg.mappings.leapForwardTill "<Plug>(leap-forward-till)" "Leap forward till")
-      (mkBinding cfg.mappings.leapBackwardTill "<Plug>(leap-backward-till)" "Leap backward till")
-      (mkBinding cfg.mappings.leapFromWindow "<Plug>(leap-from-window)" "Leap from window")
-    ];
-
-    vim.pluginRC.leap-nvim = entryAnywhere ''
-      require('leap').opts = {
-        max_phase_one_targets = nil,
-        highlight_unlabeled_phase_one_targets = false,
-        max_highlighted_traversal_targets = 10,
-        case_sensitive = false,
-        equivalence_classes = { ' \t\r\n', },
-        substitute_chars = {},
-        safe_labels = {
-          "s", "f", "n", "u", "t", "/",
-          "S", "F", "N", "L", "H", "M", "U", "G", "T", "?", "Z"
-        },
-        labels = {
-          "s", "f", "n",
-          "j", "k", "l", "h", "o", "d", "w", "e", "m", "b",
-          "u", "y", "v", "r", "g", "t", "c", "x", "/", "z",
-          "S", "F", "N",
-          "J", "K", "L", "H", "O", "D", "W", "E", "M", "B",
-          "U", "Y", "V", "R", "G", "T", "C", "X", "?", "Z"
-        },
-        special_keys = {
-          repeat_search = '<enter>',
-          next_phase_one_target = '<enter>',
-          next_target = {'<enter>', ';'},
-          prev_target = {'<tab>', ','},
-          next_group = '<space>',
-          prev_group = '<tab>',
-          multi_accept = '<enter>',
-          multi_revert = '<backspace>',
-        },
-      }
-    '';
+          after = ''
+            require('leap').opts = {
+              max_phase_one_targets = nil,
+              highlight_unlabeled_phase_one_targets = false,
+              max_highlighted_traversal_targets = 10,
+              case_sensitive = false,
+              equivalence_classes = { ' \t\r\n', },
+              substitute_chars = {},
+              safe_labels = {
+                "s", "f", "n", "u", "t", "/",
+                "S", "F", "N", "L", "H", "M", "U", "G", "T", "?", "Z"
+              },
+              labels = {
+                "s", "f", "n",
+                "j", "k", "l", "h", "o", "d", "w", "e", "m", "b",
+                "u", "y", "v", "r", "g", "t", "c", "x", "/", "z",
+                "S", "F", "N",
+                "J", "K", "L", "H", "O", "D", "W", "E", "M", "B",
+                "U", "Y", "V", "R", "G", "T", "C", "X", "?", "Z"
+              },
+              special_keys = {
+                repeat_search = '<enter>',
+                next_phase_one_target = '<enter>',
+                next_target = {'<enter>', ';'},
+                prev_target = {'<tab>', ','},
+                next_group = '<space>',
+                prev_group = '<tab>',
+                multi_accept = '<enter>',
+                multi_revert = '<backspace>',
+              },
+            }
+          '';
+        }
+      ];
+    };
   };
 }

From d649939b241b96edba1154bc64151a89f9ee45e1 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <59727193+horriblename@users.noreply.github.com>
Date: Mon, 30 Sep 2024 21:59:19 +0200
Subject: [PATCH 15/22] fidget: lazy load

---
 modules/plugins/visuals/fidget/config.nix | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/modules/plugins/visuals/fidget/config.nix b/modules/plugins/visuals/fidget/config.nix
index 3ae3b6b..6e81e9d 100644
--- a/modules/plugins/visuals/fidget/config.nix
+++ b/modules/plugins/visuals/fidget/config.nix
@@ -4,16 +4,17 @@
   ...
 }: let
   inherit (lib.modules) mkIf;
-  inherit (lib.nvim.lua) toLuaObject;
-  inherit (lib.nvim.dag) entryAnywhere;
 
   cfg = config.vim.visuals.fidget-nvim;
 in {
   config = mkIf cfg.enable {
-    vim.startPlugins = ["fidget-nvim"];
-
-    vim.pluginRC.fidget-nvim = entryAnywhere ''
-      require'fidget'.setup(${toLuaObject cfg.setupOpts})
-    '';
+    vim.lazy.plugins = [
+      {
+        package = "fidget-nvim";
+        setupModule = "fidget";
+        event = "LspAttach";
+        inherit (cfg) setupOpts;
+      }
+    ];
   };
 }

From f3a41aa2b4ef3cc6bd76d9f678a5eec173bb4117 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Sun, 6 Oct 2024 16:34:28 +0200
Subject: [PATCH 16/22] docs: add section on lazy plugins

---
 docs/manual/hacking/additional-plugins.md | 59 +++++++++++++++++++++++
 1 file changed, 59 insertions(+)

diff --git a/docs/manual/hacking/additional-plugins.md b/docs/manual/hacking/additional-plugins.md
index 7c80215..6294d6f 100644
--- a/docs/manual/hacking/additional-plugins.md
+++ b/docs/manual/hacking/additional-plugins.md
@@ -124,3 +124,62 @@ vim.your-plugin.setupOpts = {
   '';
 }
 ```
+
+## Lazy plugins {#sec-lazy-plugins}
+
+If your plugin can be lazy-loaded, you should use `vim.lazy.plugins` to add your plugin. Lazy
+plugins are managed by `lz.n`.
+
+```nix
+# in modules/.../your-plugin/config.nix
+{lib, config, ...}:
+let
+  cfg = config.vim.your-plugin;
+in {
+  vim.lazy.plugins = [
+    {
+      # instead of vim.startPlugins, use this:
+      package = "your-plugin";
+
+      # if your plugin uses the `require('your-plugin').setup{...}` pattern
+      setupModule = "your-plugin";
+      inherit (cfg) setupOpts;
+
+      # events that trigger this plugin to be loaded
+      events = ["DirChanged"];
+      cmd = ["YourPluginCommand"];
+
+      # keymaps
+      keys = [
+        # we'll cover this in detail in the keymaps section
+        {
+          key = "<leader>d";
+          mode = "n";
+          action = ":YourPluginCommand";
+        }
+      ]
+    }
+  ];
+}
+```
+
+This results in the lua code:
+```lua
+require('lz.n').load({
+  {
+    "name-of-your-plugin",
+    after = function()
+      require('your-plugin').setup({--[[ your setupOpts ]]})
+    end,
+
+    events = {"DirChanged"},
+    cmd = {"YourPluginCommand"},
+    keys = {
+      {"<leader>d", ":YourPluginCommand", mode = {"n"}},
+    },
+  }
+})
+```
+
+A full list of options can be found
+[here](https://notashelf.github.io/nvf/options.html#opt-vim.lazy.plugins

From 283ea5b92c34afb6441d02d79adea2ad2ae457c2 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Sun, 6 Oct 2024 19:15:39 +0200
Subject: [PATCH 17/22] lazy: support lazy.enable=false

---
 modules/wrapper/lazy/config.nix | 50 ++++++++++++++++++++++++++-------
 1 file changed, 40 insertions(+), 10 deletions(-)

diff --git a/modules/wrapper/lazy/config.nix b/modules/wrapper/lazy/config.nix
index 9ee15e7..d575e64 100644
--- a/modules/wrapper/lazy/config.nix
+++ b/modules/wrapper/lazy/config.nix
@@ -3,12 +3,12 @@
   config,
   ...
 }: let
-  inherit (builtins) toJSON typeOf head length tryEval filter;
-  inherit (lib.modules) mkIf;
+  inherit (builtins) toJSON typeOf head length tryEval filter concatLists concatStringsSep;
+  inherit (lib.modules) mkIf mkMerge;
   inherit (lib.generators) mkLuaInline;
   inherit (lib.strings) optionalString;
   inherit (lib.nvim.lua) toLuaObject;
-  inherit (lib.nvim.dag) entryBefore;
+  inherit (lib.nvim.dag) entryBefore entryAfter;
   cfg = config.vim.lazy;
 
   toLuaLznKeySpec = keySpec:
@@ -63,14 +63,44 @@
         else spec.keys;
     };
   lznSpecs = map toLuaLznSpec cfg.plugins;
+
+  specToNotLazyConfig = spec: ''
+    do
+      ${optionalString (spec.before != null) spec.before}
+      ${optionalString (spec.setupModule != null)
+      "require(${toJSON spec.setupModule}).setup(${toLuaObject spec.setupOpts})"}
+      ${optionalString (spec.after != null) spec.after}
+    end
+  '';
+
+  specToKeymaps = spec:
+    if typeOf spec.keys == "list"
+    then map (x: removeAttrs x ["ft"]) (filter (lznKey: lznKey.action != null && lznKey.ft == null) spec.keys)
+    else if spec.keys == null || typeOf spec.keys == "string"
+    then []
+    else [spec.keys];
+
+  notLazyConfig = concatStringsSep "\n" (map specToNotLazyConfig cfg.plugins);
 in {
-  config.vim = mkIf cfg.enable {
-    startPlugins = ["lz-n" "lzn-auto-require"];
+  config.vim = mkMerge [
+    (mkIf cfg.enable {
+      startPlugins = ["lz-n" "lzn-auto-require"];
 
-    optPlugins = map (plugin: plugin.package) cfg.plugins;
+      optPlugins = map (plugin: plugin.package) cfg.plugins;
 
-    luaConfigRC.lzn-load = entryBefore ["pluginConfigs"] ''
-      require('lz.n').load(${toLuaObject lznSpecs})
-    '';
-  };
+      luaConfigRC.lzn-load = entryBefore ["pluginConfigs"] ''
+        require('lz.n').load(${toLuaObject lznSpecs})
+      '';
+    })
+    (
+      mkIf (!cfg.enable) {
+        startPlugins = map (plugin: plugin.package) cfg.plugins;
+        luaConfigPre =
+          concatStringsSep "\n"
+          (filter (x: x != null) (map (spec: spec.beforeAll) cfg.plugins));
+        luaConfigRC.unlazy = entryAfter ["pluginConfigs"] notLazyConfig;
+        keymaps = concatLists (map specToKeymaps cfg.plugins);
+      }
+    )
+  ];
 }

From 6ae18403a8de77e1cc9d305d7634471f9faad323 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Sun, 6 Oct 2024 19:34:47 +0200
Subject: [PATCH 18/22] comment-nvim: lazy load

---
 .../comments/comment-nvim/comment-nvim.nix    |  8 +++
 .../plugins/comments/comment-nvim/config.nix  | 59 +++++++++----------
 2 files changed, 36 insertions(+), 31 deletions(-)

diff --git a/modules/plugins/comments/comment-nvim/comment-nvim.nix b/modules/plugins/comments/comment-nvim/comment-nvim.nix
index 61a9171..76fd813 100644
--- a/modules/plugins/comments/comment-nvim/comment-nvim.nix
+++ b/modules/plugins/comments/comment-nvim/comment-nvim.nix
@@ -1,6 +1,7 @@
 {lib, ...}: let
   inherit (lib.options) mkEnableOption;
   inherit (lib.nvim.binds) mkMappingOption;
+  inherit (lib.nvim.types) mkPluginSetupOption;
 in {
   options.vim.comments.comment-nvim = {
     enable = mkEnableOption "smart and powerful comment plugin for neovim comment-nvim";
@@ -15,5 +16,12 @@ in {
       toggleSelectedLine = mkMappingOption "Toggle selected comment" "gc";
       toggleSelectedBlock = mkMappingOption "Toggle selected block" "gb";
     };
+
+    setupOpts = mkPluginSetupOption "Comment-nvim" {
+      mappings = {
+        basic = mkEnableOption "basic mappings";
+        extra = mkEnableOption "extra mappings";
+      };
+    };
   };
 }
diff --git a/modules/plugins/comments/comment-nvim/config.nix b/modules/plugins/comments/comment-nvim/config.nix
index e70e918..4c3a955 100644
--- a/modules/plugins/comments/comment-nvim/config.nix
+++ b/modules/plugins/comments/comment-nvim/config.nix
@@ -3,9 +3,8 @@
   lib,
   ...
 }: let
-  inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.binds) mkExprBinding mkBinding;
-  inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.binds) mkLznExprBinding mkLznBinding;
 
   cfg = config.vim.comments.comment-nvim;
   self = import ./comment-nvim.nix {inherit lib;};
@@ -16,35 +15,33 @@ in {
       "comment-nvim"
     ];
 
-    vim.maps.normal = mkMerge [
-      (mkBinding cfg.mappings.toggleOpLeaderLine "<Plug>(comment_toggle_linewise)" mappings.toggleOpLeaderLine.description)
-      (mkBinding cfg.mappings.toggleOpLeaderBlock "<Plug>(comment_toggle_blockwise)" mappings.toggleOpLeaderBlock.description)
+    vim.lazy.plugins = [
+      {
+        package = "comment-nvim";
+        setupModule = "Comment";
+        inherit (cfg) setupOpts;
+        keys = [
+          (mkLznBinding ["n"] cfg.mappings.toggleOpLeaderLine "<Plug>(comment_toggle_linewise)" mappings.toggleOpLeaderLine.description)
+          (mkLznBinding ["n"] cfg.mappings.toggleOpLeaderBlock "<Plug>(comment_toggle_blockwise)" mappings.toggleOpLeaderBlock.description)
 
-      (mkExprBinding cfg.mappings.toggleCurrentLine ''
-          function()
-            return vim.api.nvim_get_vvar('count') == 0 and '<Plug>(comment_toggle_linewise_current)'
-                    or '<Plug>(comment_toggle_linewise_count)'
-          end
-        ''
-        mappings.toggleCurrentLine.description)
-      (mkExprBinding cfg.mappings.toggleCurrentBlock ''
-          function()
-            return vim.api.nvim_get_vvar('count') == 0 and '<Plug>(comment_toggle_blockwise_current)'
-                    or '<Plug>(comment_toggle_blockwise_count)'
-          end
-        ''
-        mappings.toggleCurrentBlock.description)
+          (mkLznExprBinding ["n"] cfg.mappings.toggleCurrentLine ''
+              function()
+                return vim.api.nvim_get_vvar('count') == 0 and '<Plug>(comment_toggle_linewise_current)'
+                        or '<Plug>(comment_toggle_linewise_count)'
+              end
+            ''
+            mappings.toggleCurrentLine.description)
+          (mkLznExprBinding ["n"] cfg.mappings.toggleCurrentBlock ''
+              function()
+                return vim.api.nvim_get_vvar('count') == 0 and '<Plug>(comment_toggle_blockwise_current)'
+                        or '<Plug>(comment_toggle_blockwise_count)'
+              end
+            ''
+            mappings.toggleCurrentBlock.description)
+          (mkLznBinding ["x"] cfg.mappings.toggleSelectedLine "<Plug>(comment_toggle_linewise_visual)" mappings.toggleSelectedLine.description)
+          (mkLznBinding ["x"] cfg.mappings.toggleSelectedBlock "<Plug>(comment_toggle_blockwise_visual)" mappings.toggleSelectedBlock.description)
+        ];
+      }
     ];
-
-    vim.maps.visualOnly = mkMerge [
-      (mkBinding cfg.mappings.toggleSelectedLine "<Plug>(comment_toggle_linewise_visual)" mappings.toggleSelectedLine.description)
-      (mkBinding cfg.mappings.toggleSelectedBlock "<Plug>(comment_toggle_blockwise_visual)" mappings.toggleSelectedBlock.description)
-    ];
-
-    vim.pluginRC.comment-nvim = entryAnywhere ''
-      require('Comment').setup({
-        mappings = { basic = false, extra = false, },
-      })
-    '';
   };
 }

From 4701bb15c5be93a80af92c03380297c69c8dbef1 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Sun, 6 Oct 2024 20:13:39 +0200
Subject: [PATCH 19/22] surround-nvim: lazy load

---
 modules/plugins/utility/surround/config.nix | 51 +++++++++++++++------
 1 file changed, 38 insertions(+), 13 deletions(-)

diff --git a/modules/plugins/utility/surround/config.nix b/modules/plugins/utility/surround/config.nix
index 4c98c86..5752085 100644
--- a/modules/plugins/utility/surround/config.nix
+++ b/modules/plugins/utility/surround/config.nix
@@ -8,25 +8,50 @@
   inherit (lib.nvim.lua) toLuaObject;
 
   cfg = config.vim.utility.surround;
+  vendoredKeybinds = {
+    insert = "<C-g>z";
+    insert_line = "<C-g>Z";
+    normal = "gz";
+    normal_cur = "gZ";
+    normal_line = "gzz";
+    normal_cur_line = "gZZ";
+    visual = "gz";
+    visual_line = "gZ";
+    delete = "gzd";
+    change = "gzr";
+    change_line = "gZR";
+  };
+  mkLznKey = mode: key: {
+    inherit key mode;
+  };
 in {
   config = mkIf cfg.enable {
     vim = {
       startPlugins = ["nvim-surround"];
       pluginRC.surround = entryAnywhere "require('nvim-surround').setup(${toLuaObject cfg.setupOpts})";
 
-      utility.surround.setupOpts.keymaps = mkIf cfg.useVendoredKeybindings {
-        insert = "<C-g>z";
-        insert_line = "<C-g>Z";
-        normal = "gz";
-        normal_cur = "gZ";
-        normal_line = "gzz";
-        normal_cur_line = "gZZ";
-        visual = "gz";
-        visual_line = "gZ";
-        delete = "gzd";
-        change = "gzr";
-        change_line = "gZR";
-      };
+      lazy.plugins = [
+        {
+          package = "nvim-surround";
+          setupModule = "nvim-surround";
+          inherit (cfg) setupOpts;
+
+          keys =
+            map (mkLznKey ["i"]) (with vendoredKeybinds; [insert insert_line])
+            ++ map (mkLznKey ["x"]) (with vendoredKeybinds; [visual visual_line])
+            ++ map (mkLznKey ["n"]) (with vendoredKeybinds; [
+              normal
+              normal_cur
+              normal_line
+              normal_cur_line
+              delete
+              change
+              change_line
+            ]);
+        }
+      ];
+
+      utility.surround.setupOpts.keymaps = mkIf cfg.useVendoredKeybindings vendoredKeybinds;
     };
   };
 }

From b7a34ad52b86b589f9b1631a13093a8487a0bfbf Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Sun, 6 Oct 2024 20:51:33 +0200
Subject: [PATCH 20/22] neo-tree: lazy load

---
 modules/plugins/filetree/neo-tree/config.nix | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/modules/plugins/filetree/neo-tree/config.nix b/modules/plugins/filetree/neo-tree/config.nix
index be67df1..16cc029 100644
--- a/modules/plugins/filetree/neo-tree/config.nix
+++ b/modules/plugins/filetree/neo-tree/config.nix
@@ -4,8 +4,6 @@
   ...
 }: let
   inherit (lib.modules) mkIf;
-  inherit (lib.nvim.dag) entryAnywhere;
-  inherit (lib.nvim.lua) toLuaObject;
 
   cfg = config.vim.filetree.neo-tree;
 in {
@@ -20,11 +18,17 @@ in {
         "neo-tree-nvim"
       ];
 
-      visuals.nvimWebDevicons.enable = true;
+      lazy.plugins = [
+        {
+          package = "neo-tree-nvim";
+          setupModule = "neo-tree";
+          inherit (cfg) setupOpts;
 
-      pluginRC.neo-tree = entryAnywhere ''
-        require("neo-tree").setup(${toLuaObject cfg.setupOpts})
-      '';
+          cmd = ["Neotree"];
+        }
+      ];
+
+      visuals.nvimWebDevicons.enable = true;
     };
   };
 }

From 3b7a11cb427057682826854aaae457b30b19be27 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Sun, 6 Oct 2024 22:43:06 +0200
Subject: [PATCH 21/22] fixup! lazy: init module

---
 modules/wrapper/lazy/lazy.nix | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/wrapper/lazy/lazy.nix b/modules/wrapper/lazy/lazy.nix
index 5f20c12..9b97bb8 100644
--- a/modules/wrapper/lazy/lazy.nix
+++ b/modules/wrapper/lazy/lazy.nix
@@ -92,7 +92,7 @@
         description = ''
           Lua code to run after plugin is loaded. This will be wrapped in a function.
 
-          If {opt}`vim.plugins.*.setupModule` is provided, the setup will be ran before `after`.
+          If [](#opt-vim.lazy.plugins._.setupModule) is provided, the setup will be ran before `after`.
         '';
         default = null;
       };

From 20302afeca7ed0553ca386626b0af2ffff0dd5f1 Mon Sep 17 00:00:00 2001
From: Ching Pei Yang <badnam3o.0@gmail.com>
Date: Wed, 9 Oct 2024 17:52:32 +0200
Subject: [PATCH 22/22] dap: appease the nix gods (fix statix lint)

---
 modules/plugins/debugger/nvim-dap/config.nix | 104 ++++++++++---------
 1 file changed, 54 insertions(+), 50 deletions(-)

diff --git a/modules/plugins/debugger/nvim-dap/config.nix b/modules/plugins/debugger/nvim-dap/config.nix
index 1c80ac4..a668959 100644
--- a/modules/plugins/debugger/nvim-dap/config.nix
+++ b/modules/plugins/debugger/nvim-dap/config.nix
@@ -16,66 +16,70 @@
 in {
   config = mkMerge [
     (mkIf cfg.enable {
-      vim.startPlugins = ["nvim-dap"];
+      vim = {
+        startPlugins = ["nvim-dap"];
 
-      vim.pluginRC =
-        {
-          # TODO customizable keymaps
-          nvim-dap = entryAnywhere ''
-            local dap = require("dap")
-            vim.fn.sign_define("DapBreakpoint", { text = "🛑", texthl = "ErrorMsg", linehl = "", numhl = "" })
-          '';
-        }
-        // mapAttrs (_: v: (entryAfter ["nvim-dap"] v)) cfg.sources;
+        pluginRC =
+          {
+            # TODO customizable keymaps
+            nvim-dap = entryAnywhere ''
+              local dap = require("dap")
+              vim.fn.sign_define("DapBreakpoint", { text = "🛑", texthl = "ErrorMsg", linehl = "", numhl = "" })
+            '';
+          }
+          // mapAttrs (_: v: (entryAfter ["nvim-dap"] v)) cfg.sources;
 
-      vim.maps.normal = mkMerge [
-        (mkSetLuaBinding mappings.continue "require('dap').continue")
-        (mkSetLuaBinding mappings.restart "require('dap').restart")
-        (mkSetLuaBinding mappings.terminate "require('dap').terminate")
-        (mkSetLuaBinding mappings.runLast "require('dap').run_last")
+        maps.normal = mkMerge [
+          (mkSetLuaBinding mappings.continue "require('dap').continue")
+          (mkSetLuaBinding mappings.restart "require('dap').restart")
+          (mkSetLuaBinding mappings.terminate "require('dap').terminate")
+          (mkSetLuaBinding mappings.runLast "require('dap').run_last")
 
-        (mkSetLuaBinding mappings.toggleRepl "require('dap').repl.toggle")
-        (mkSetLuaBinding mappings.hover "require('dap.ui.widgets').hover")
-        (mkSetLuaBinding mappings.toggleBreakpoint "require('dap').toggle_breakpoint")
+          (mkSetLuaBinding mappings.toggleRepl "require('dap').repl.toggle")
+          (mkSetLuaBinding mappings.hover "require('dap.ui.widgets').hover")
+          (mkSetLuaBinding mappings.toggleBreakpoint "require('dap').toggle_breakpoint")
 
-        (mkSetLuaBinding mappings.runToCursor "require('dap').run_to_cursor")
-        (mkSetLuaBinding mappings.stepInto "require('dap').step_into")
-        (mkSetLuaBinding mappings.stepOut "require('dap').step_out")
-        (mkSetLuaBinding mappings.stepOver "require('dap').step_over")
-        (mkSetLuaBinding mappings.stepBack "require('dap').step_back")
+          (mkSetLuaBinding mappings.runToCursor "require('dap').run_to_cursor")
+          (mkSetLuaBinding mappings.stepInto "require('dap').step_into")
+          (mkSetLuaBinding mappings.stepOut "require('dap').step_out")
+          (mkSetLuaBinding mappings.stepOver "require('dap').step_over")
+          (mkSetLuaBinding mappings.stepBack "require('dap').step_back")
 
-        (mkSetLuaBinding mappings.goUp "require('dap').up")
-        (mkSetLuaBinding mappings.goDown "require('dap').down")
-      ];
+          (mkSetLuaBinding mappings.goUp "require('dap').up")
+          (mkSetLuaBinding mappings.goDown "require('dap').down")
+        ];
+      };
     })
     (mkIf (cfg.enable && cfg.ui.enable) {
-      vim.startPlugins = ["nvim-nio"];
+      vim = {
+        startPlugins = ["nvim-nio"];
 
-      vim.lazy.plugins = [
-        {
-          package = "nvim-dap-ui";
-          setupModule = "dapui";
-          setupOpts = {};
+        lazy.plugins = [
+          {
+            package = "nvim-dap-ui";
+            setupModule = "dapui";
+            setupOpts = {};
 
-          keys = [
-            (mkSetLuaLznBinding mappings.toggleDapUI "function() require('dapui').toggle() end")
-          ];
-        }
-      ];
+            keys = [
+              (mkSetLuaLznBinding mappings.toggleDapUI "function() require('dapui').toggle() end")
+            ];
+          }
+        ];
 
-      vim.pluginRC.nvim-dap-ui = entryAfter ["nvim-dap"] (
-        optionalString cfg.ui.autoStart ''
-          dap.listeners.after.event_initialized["dapui_config"] = function()
-            require("dapui").open()
-          end
-          dap.listeners.before.event_terminated["dapui_config"] = function()
-            require("dapui").close()
-          end
-          dap.listeners.before.event_exited["dapui_config"] = function()
-            require("dapui").close()
-          end
-        ''
-      );
+        pluginRC.nvim-dap-ui = entryAfter ["nvim-dap"] (
+          optionalString cfg.ui.autoStart ''
+            dap.listeners.after.event_initialized["dapui_config"] = function()
+              require("dapui").open()
+            end
+            dap.listeners.before.event_terminated["dapui_config"] = function()
+              require("dapui").close()
+            end
+            dap.listeners.before.event_exited["dapui_config"] = function()
+              require("dapui").close()
+            end
+          ''
+        );
+      };
     })
   ];
 }