lib/neovim-plugin: Add lazyLoad option to plugins

lib/helpers.nix

@@ -44,6 +44,7 @@ let
       defaultNullOpts
       mkCompositeOption
       mkCompositeOption'
+      mkLazyLoadOption
       mkNullOrLua
       mkNullOrLua'
       mkNullOrLuaFn

lib/neovim-plugin.nix

@@ -43,9 +43,14 @@ with lib;
       extraPackages ? [ ],
       callSetup ? true,
       installPackage ? true,
+      # lazyLoad
+      allowLazyLoad ? true,
+      packageName ? originalName, # Name of the package folder created in {runtimepath}/pack/start or {runtimepath}/pack/opt
+      lazyLoadDefaults ? { },
     }:
     let
       namespace = if isColorscheme then "colorschemes" else "plugins";
+      cfg = config.${namespace}.${name};
     in
     {
       meta = {
@@ -94,25 +99,90 @@ with lib;
             example = settingsExample;
           };
         }
+        // optionalAttrs allowLazyLoad {
+          lazyLoad = helpers.mkLazyLoadOption {
+            inherit originalName;
+            lazyLoadDefaults =
+              (optionalAttrs (isColorscheme && colorscheme != null) { inherit colorscheme; }) // lazyLoadDefaults;
+          };
+        }
         // extraOptions;
 
       config =
         let
-          cfg = config.${namespace}.${name};
           extraConfigNamespace = if isColorscheme then "extraConfigLuaPre" else "extraConfigLua";
+          lazyLoaded = cfg.lazyLoad.enable or false;
+
+          # lz-n lazyLoad backend
+          # Transform plugin into attrset and set optional to true
+          # See `tests/test-sources/plugins/pluginmanagers/lz-n.nix`
+          optionalPlugin =
+            x:
+            if isColorscheme then x else ((if x ? plugin then x else { plugin = x; }) // { optional = true; });
+          mkFn = str: if str != "" then "function()\n" + str + "end" else null;
         in
         mkIf cfg.enable (mkMerge [
-          {
-            extraPlugins = (optional installPackage cfg.package) ++ extraPlugins;
-            inherit extraPackages;
-          }
-          (optionalAttrs callSetup {
-            ${extraConfigNamespace} = ''
-              require('${luaName}')${setup}(${optionalString (cfg ? settings) (helpers.toLuaObject cfg.settings)})
-            '';
-          })
+          # Always set
           (optionalAttrs (isColorscheme && (colorscheme != null)) { colorscheme = mkDefault colorscheme; })
-          (extraConfig cfg)
+
+          # Normal loading
+          (mkIf (!lazyLoaded) (mkMerge [
+            (extraConfig cfg)
+            {
+              extraPlugins = (optional installPackage cfg.package) ++ extraPlugins;
+              inherit extraPackages;
+            }
+            (optionalAttrs callSetup {
+              ${extraConfigNamespace} = ''
+                require('${luaName}')${setup}(${optionalString (cfg ? settings) (helpers.toLuaObject cfg.settings)})
+              '';
+            })
+          ]))
+
+          # Lazy loading with lz-n
+          (mkIf (lazyLoaded && config.plugins.lz-n.enable) (mkMerge [
+            (lib.removeAttrs (extraConfig cfg) [
+              "extraConfigLua"
+              "extraConfigLuaPre"
+            ])
+            {
+              extraPlugins = (optional installPackage (optionalPlugin cfg.package)) ++ extraPlugins;
+              inherit extraPackages;
+            }
+            {
+              plugins.lz-n.plugins = [
+                {
+                  __unkeyed-1 = packageName;
+                  after =
+                    if cfg.lazyLoad.after == null then
+                      mkFn (
+                        (extraConfig cfg).extraConfigLuaPre or ""
+                        + optionalString callSetup ''require('${luaName}')${setup}(${
+                          optionalString (cfg ? settings) (helpers.toLuaObject cfg.settings)
+                        }) ''
+                        + (extraConfig cfg).extraConfigLua or ""
+                      )
+                    else
+                      cfg.lazyLoad.after;
+                  inherit (cfg.lazyLoad)
+                    enabled
+                    priority
+                    before
+                    beforeAll
+                    # after defined above
+                    event
+                    cmd
+                    ft
+                    keys
+                    colorscheme
+                    extraSettings
+                    ;
+                }
+              ];
+            }
+          ]))
+
+          # Lazy loading with lazy.nvim
         ]);
     };
 }

lib/options.nix

@@ -366,4 +366,109 @@ rec {
         else
           example;
     };
+
+  mkLazyLoadOption =
+    {
+      originalName,
+      lazyLoadDefaults ? { },
+    }:
+    mkOption {
+      description = ''
+        Lazy-load settings for ${originalName}.
+      '';
+      type =
+        with helpers.nixvimTypes;
+        let
+          triggerType = oneOf [
+            rawLua
+            str
+            (listOf str)
+          ];
+        in
+        submodule {
+          options = with defaultNullOpts; {
+
+            enable = mkEnableOption ''
+              lazy-loading for ${originalName}
+            '';
+
+            # Spec loading:
+            enabled = mkStrLuaFnOr bool (lazyLoadDefaults.enabledInSpec or null) ''
+              When false, or if the function returns false, then ${originalName} will not be included in the spec.
+
+              Equivalence: lz.n => enabled; lazy.nvim => enabled
+            '';
+
+            priority = mkNullable number (lazyLoadDefaults.priority or null) ''
+              Only useful for start plugins (not lazy-loaded) to force loading certain plugins first.
+
+              Equivalence: lz.n => priority; lazy.nvim => priority
+            '';
+
+            # Spec setup
+            # Actions
+            beforeAll = mkLuaFn (lazyLoadDefaults.beforeAll or null) ''
+              Always executed before any plugins are loaded.
+
+              Equivalence: lz.n => beforeAll; lazy.nvim => init
+            '';
+
+            before = mkLuaFn (lazyLoadDefaults.before or null) ''
+              Executed before ${originalName} is loaded.
+
+              Equivalence: lz.n => before; lazy.nvim => None
+            '';
+
+            after = mkLuaFn (lazyLoadDefaults.after or null) ''
+              Executed after ${originalName} is loaded.
+
+              Equivalence: lz.n => after; lazy.nvim => config
+            '';
+
+            # Triggers
+            event = mkNullable triggerType (lazyLoadDefaults.event or null) ''
+              Lazy-load on event. Events can be specified as `BufEnter` or with a pattern like `BufEnter *.lua`
+
+              Equivalence: lz.n => event; lazy.nvim => event
+            '';
+
+            cmd = mkNullable triggerType (lazyLoadDefaults.cmd or null) ''
+              Lazy-load on command.
+
+              Equivalence: lz.n => cmd; lazy.nvim => cmd
+            '';
+
+            ft = mkNullable triggerType (lazyLoadDefaults.ft or null) ''
+              Lazy-load on filetype.
+
+              Equivalence: lz.n => ft; lazy.nvim => ft
+            '';
+
+            keys = mkNullable (listOf helpers.keymaps.mapOptionSubmodule) (lazyLoadDefaults.keys or null) ''
+              Lazy-load on key mapping. Use the same format as `config.keymaps`.
+
+              Equivalence: lz.n => keys; lazy.nvim => keys
+            '';
+
+            colorscheme = mkNullable triggerType (lazyLoadDefaults.colorscheme or null) ''
+              Lazy-load on colorscheme.
+
+              Equivalence: lz.n => colorscheme; lazy.nvim => None
+            '';
+
+            extraSettings = mkSettingsOption {
+              description = ''
+                Extra settings to pass to the lazy loader backend.
+              '';
+              example = {
+                dependencies = {
+                  __unkeyed-1 = "nvim-lua/plenary.nvim";
+                  lazy = true;
+                };
+              };
+            };
+          };
+        };
+      default = lazyLoadDefaults;
+    };
 }

tests/test-derivation.nix

@@ -38,6 +38,7 @@ let
       buildPhase = lib.optionalString (!dontRun) (
         ''
           mkdir -p .cache/nvim
+          mkdir $out
         ''
         + lib.concatStringsSep "\n" (
           builtins.map (
@@ -47,6 +48,8 @@ let
               dontRun ? false,
             }:
             lib.optionalString (!dontRun) ''
+              ln -s ${derivation} $out/${name}
+
               echo "Running test for ${name}"
 
               output=$(HOME=$(realpath .) ${lib.getExe derivation} -mn --headless "+q" 2>&1 >/dev/null)
@@ -58,11 +61,6 @@ let
           ) testList
         )
       );
-
-      # If we don't do this nix is not happy
-      installPhase = ''
-        mkdir $out
-      '';
     };
 
   # Create a nix derivation from a nixvim configuration.

tests/test-sources/modules/lazy-load.nix

@@ -0,0 +1,39 @@
+{
+  example = {
+    plugins.lz-n.enable = true;
+    plugins = {
+      cmp = {
+        enable = true;
+        settings = {
+          sources = [ { name = "snippets"; } ];
+          mapping.__raw = "require('cmp').mapping.preset.insert()";
+        };
+      };
+
+      nvim-snippets = {
+        enable = true;
+        lazyLoad = {
+          enable = true;
+          event = "InsertEnter";
+        };
+      };
+
+      telescope = {
+        enable = true;
+        lazyLoad = {
+          enable = true;
+          cmd = "Telescope";
+        };
+      };
+    };
+
+    colorschemes.ayu = {
+      enable = true;
+      settings.mirage = true;
+      lazyLoad = {
+        enable = true;
+        event = "InsertEnter";
+      };
+    };
+  };
+}