Merge 3860063606 into d6746a7510

docs/manual/configuring/keybinds.md

@@ -1,8 +1,10 @@
 # Custom keymaps {#ch-keymaps}
 
-Some plugin modules provide keymap options for your convenience. If a keymap is
+Some plugin modules provide keymap options for your convenience. These can be
-not provided by such module options, you may easily register your own custom
+disabled using {option}`vim.vendoredKeymaps`. It is also possible to disable
-keymaps via {option}`vim.keymaps`.
+individual keymaps with options by setting them to `null`. If a keymap is not
+provided by a module, you may easily register your own custom keymaps via
+{option}`vim.keymaps`.
 
 ```nix
 {
@@ -22,7 +24,7 @@ keymaps via {option}`vim.keymaps`.
     {
       key = "<leader>k";
       mode = ["n" "x"];
-      
+
       # While `lua` is `true`, `action` is expected to be
       # a valid Lua expression.
       lua = true;

docs/manual/hacking.md

@@ -768,7 +768,7 @@ usage should look something like this:
 # pluginDefinition.nix
 {lib, ...}: let
   inherit (lib.options) mkEnableOption;
-  inherit (lib.nvim.binds) mkMappingOption;
+  inherit (config.vim.lib) mkMappingOption;
 in {
   options.vim.plugin = {
     enable = mkEnableOption "Enable plugin";

docs/manual/release-notes/rl-0.9.md

@@ -195,6 +195,7 @@
     {command}`:healthcheck` doesn't know that.
   - Remove [which-key.nvim] `<leader>o` `+Notes` description which did not
     actually correspond to any keybinds.
+- Allow disabling nvf's vendored keymaps by toggling `vendoredKeymaps`.
 
 [pyrox0](https://github.com/pyrox0):
 

modules/modules.nix

@@ -57,6 +57,7 @@
       "rc"
       "warnings"
       "lazy"
+      "lib"
     ];
 
     # Extra modules, such as deprecation warnings

modules/neovim/mappings/options.nix

@@ -1,5 +1,5 @@
 {lib, ...}: let
-  inherit (lib.options) mkOption literalMD;
+  inherit (lib.options) mkEnableOption mkOption literalMD;
   inherit (lib.types) either str listOf attrsOf nullOr submodule;
   inherit (lib.nvim.config) mkBool;
 
@@ -57,6 +57,8 @@
     };
 in {
   options.vim = {
+    vendoredKeymaps = mkEnableOption "this project's vendored keymaps by default" // {default = true;};
+
     keymaps = mkOption {
       type = listOf mapType;
       description = "Custom keybindings.";

modules/plugins/assistant/chatgpt/chatgpt.nix

@@ -1,7 +1,11 @@
-{lib, ...}: let
+{
+  config,
+  lib,
+  ...
+}: let
   inherit (lib.options) mkEnableOption;
-  inherit (lib.nvim.binds) mkMappingOption;
   inherit (lib.nvim.types) mkPluginSetupOption;
+  inherit (config.vim.lib) mkMappingOption;
 in {
   options.vim.assistant.chatgpt = {
     enable = mkEnableOption "ChatGPT AI assistant. Requires the environment variable OPENAI_API_KEY to be set";

modules/plugins/assistant/copilot/config.nix

@@ -21,11 +21,11 @@
   '';
 
   mkLuaKeymap = mode: key: action: desc: opts:
-    opts
+    mkIf (key != null) (opts
-    // {
+      // {
-      inherit mode key action desc;
+        inherit mode key action desc;
-      lua = true;
+        lua = true;
-    };
+      });
 in {
   config = mkIf cfg.enable {
     vim = {

modules/plugins/assistant/copilot/copilot.nix

@@ -8,6 +8,7 @@
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.types) nullOr str enum float;
   inherit (lib.nvim.types) mkPluginSetupOption;
+  inherit (config.vim.lib) mkMappingOption;
 
   cfg = config.vim.assistant.copilot;
 in {
@@ -59,72 +60,19 @@ in {
 
     mappings = {
       panel = {
-        jumpPrev = mkOption {
+        jumpPrev = mkMappingOption "Jump to previous suggestion" "[[";
-          type = nullOr str;
+        jumpNext = mkMappingOption "Jump to next suggestion" "]]";
-          default = "[[";
+        accept = mkMappingOption "Accept suggestion" "<CR>";
-          description = "Jump to previous suggestion";
+        refresh = mkMappingOption "Refresh suggestions" "gr";
-        };
+        open = mkMappingOption "Open suggestions" "<M-CR>";
-
-        jumpNext = mkOption {
-          type = nullOr str;
-          default = "]]";
-          description = "Jump to next suggestion";
-        };
-
-        accept = mkOption {
-          type = nullOr str;
-          default = "<CR>";
-          description = "Accept suggestion";
-        };
-
-        refresh = mkOption {
-          type = nullOr str;
-          default = "gr";
-          description = "Refresh suggestions";
-        };
-
-        open = mkOption {
-          type = nullOr str;
-          default = "<M-CR>";
-          description = "Open suggestions";
-        };
       };
       suggestion = {
-        accept = mkOption {
+        accept = mkMappingOption "Accept suggestion" "<M-l>";
-          type = nullOr str;
+        acceptWord = mkMappingOption "Accept next word" null;
-          default = "<M-l>";
+        acceptLine = mkMappingOption "Accept next line" null;
-          description = "Accept suggestion";
+        prev = mkMappingOption "Previous suggestion" "<M-[>";
-        };
+        next = mkMappingOption "Next suggestion" "<M-]>";
-
+        dismiss = mkMappingOption "Dismiss suggestion" "<C-]>";
-        acceptWord = mkOption {
-          type = nullOr str;
-          default = null;
-          description = "Accept next word";
-        };
-
-        acceptLine = mkOption {
-          type = nullOr str;
-          default = null;
-          description = "Accept next line";
-        };
-
-        prev = mkOption {
-          type = nullOr str;
-          default = "<M-[>";
-          description = "Previous suggestion";
-        };
-
-        next = mkOption {
-          type = nullOr str;
-          default = "<M-]>";
-          description = "Next suggestion";
-        };
-
-        dismiss = mkOption {
-          type = nullOr str;
-          default = "<C-]>";
-          description = "Dismiss suggestion";
-        };
       };
     };
   };

modules/plugins/assistant/neocodeium/neocodeium.nix

@@ -1,4 +1,8 @@
-{lib, ...}: let
+{
+  config,
+  lib,
+  ...
+}: let
   inherit
     (lib.types)
     nullOr
@@ -11,7 +15,7 @@
     ;
   inherit (lib.options) mkOption mkEnableOption;
   inherit (lib.nvim.types) mkPluginSetupOption luaInline;
-  inherit (lib.nvim.binds) mkMappingOption;
+  inherit (config.vim.lib) mkMappingOption;
 in {
   options.vim.assistant.neocodeium = {
     enable = mkEnableOption "NeoCodeium AI completion";

modules/plugins/assistant/supermaven-nvim/supermaven-nvim.nix

@@ -1,4 +1,8 @@
-{lib, ...}: let
+{
+  config,
+  lib,
+  ...
+}: let
   inherit
     (lib.types)
     nullOr
@@ -10,30 +14,16 @@
     ;
   inherit (lib.options) mkOption mkEnableOption;
   inherit (lib.nvim.types) mkPluginSetupOption luaInline;
+  inherit (config.vim.lib) mkMappingOption;
 in {
   options.vim.assistant.supermaven-nvim = {
     enable = mkEnableOption "Supermaven AI assistant";
 
     setupOpts = mkPluginSetupOption "Supermaven" {
       keymaps = {
-        accept_suggestion = mkOption {
+        accept_suggestion = mkMappingOption "The key to accept a suggestion" null // {example = "<Tab>";};
-          type = nullOr str;
+        clear_suggestion = mkMappingOption "The key to clear a suggestion" null // {example = "<C-]>";};
-          default = null;
+        accept_word = mkMappingOption "The key to accept a word" null // {example = "<C-j>";};
-          example = "<Tab>";
-          description = "The key to accept a suggestion";
-        };
-        clear_suggestion = mkOption {
-          type = nullOr str;
-          default = null;
-          example = "<C-]>";
-          description = "The key to clear a suggestion";
-        };
-        accept_word = mkOption {
-          type = nullOr str;
-          default = null;
-          example = "<C-j>";
-          description = "The key to accept a word";
-        };
       };
       ignore_file = mkOption {
         type = nullOr (attrsOf bool);

modules/plugins/comments/comment-nvim/comment-nvim.nix

@@ -1,7 +1,11 @@
-{lib, ...}: let
+{
+  config,
+  lib,
+  ...
+}: let
   inherit (lib.options) mkEnableOption;
-  inherit (lib.nvim.binds) mkMappingOption;
   inherit (lib.nvim.types) mkPluginSetupOption;
+  inherit (config.vim.lib) mkMappingOption;
 in {
   options.vim.comments.comment-nvim = {
     enable = mkEnableOption "smart and powerful comment plugin for neovim comment-nvim";

modules/plugins/completion/blink-cmp/blink-cmp.nix

@@ -1,9 +1,13 @@
-{lib, ...}: let
+{
+  config,
+  lib,
+  ...
+}: let
   inherit (lib.options) mkEnableOption mkOption literalMD;
   inherit (lib.types) bool listOf str either attrsOf submodule enum anything int nullOr;
   inherit (lib.nvim.types) mkPluginSetupOption luaInline pluginType;
-  inherit (lib.nvim.binds) mkMappingOption;
   inherit (lib.nvim.config) mkBool;
+  inherit (config.vim.lib) mkMappingOption;
 
   keymapType = submodule {
     freeformType = attrsOf (listOf (either str luaInline));

modules/plugins/completion/blink-cmp/config.nix

@@ -5,7 +5,7 @@
 }: let
   inherit (lib.modules) mkIf;
   inherit (lib.strings) optionalString;
-  inherit (lib.attrsets) optionalAttrs;
+  inherit (lib.attrsets) mapAttrs' optionalAttrs;
   inherit (lib.generators) mkLuaInline;
   inherit (lib.attrsets) attrValues filterAttrs mapAttrsToList;
   inherit (lib.lists) map optional optionals elem;
@@ -98,51 +98,57 @@ in {
           preset = "luasnip";
         };
 
-        keymap = {
+        keymap =
-          ${mappings.complete} = ["show" "fallback"];
+          mapAttrs' (mapping-name: action: {
-          ${mappings.close} = ["hide" "fallback"];
+            name = mappings.${mapping-name};
-          ${mappings.scrollDocsUp} = ["scroll_documentation_up" "fallback"];
+            value = action;
-          ${mappings.scrollDocsDown} = ["scroll_documentation_down" "fallback"];
+          }) (filterAttrs (mapping-name: _action: mappings.${mapping-name} != null) {
-          ${mappings.confirm} = ["accept" "fallback"];
+            complete = ["show" "fallback"];
+            close = ["hide" "fallback"];
+            scrollDocsUp = ["scroll_documentation_up" "fallback"];
+            scrollDocsDown = ["scroll_documentation_down" "fallback"];
+            confirm = ["accept" "fallback"];
+            next = [
+              "select_next"
+              "snippet_forward"
+              (mkLuaInline
+                # lua
+                ''
+                  function(cmp)
+                    local line, col = unpack(vim.api.nvim_win_get_cursor(0))
+                    has_words_before = col ~= 0 and vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1]:sub(col, col):match("%s") == nil
 
-          ${mappings.next} = [
+                    if has_words_before then
-            "select_next"
+                      return cmp.show()
-            "snippet_forward"
+                    end
-            (mkLuaInline
-              # lua
-              ''
-                function(cmp)
-                  local line, col = unpack(vim.api.nvim_win_get_cursor(0))
-                  has_words_before = col ~= 0 and vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1]:sub(col, col):match("%s") == nil
-
-                  if has_words_before then
-                    return cmp.show()
                   end
-                end
+                '')
-              '')
+              "fallback"
-            "fallback"
+            ];
-          ];
+            previous = [
-          ${mappings.previous} = [
+              "select_prev"
-            "select_prev"
+              "snippet_backward"
-            "snippet_backward"
+              "fallback"
-            "fallback"
+            ];
-          ];
+          });
-        };
 
         # cmdline is not enabled by default, we're just providing keymaps in
         # case the user enables them
-        cmdline.keymap = {
+        cmdline.keymap =
-          ${mappings.complete} = ["show" "fallback"];
+          mapAttrs' (mapping-name: action: {
-          ${mappings.close} = ["hide" "fallback"];
+            name = mappings.${mapping-name};
-          ${mappings.scrollDocsUp} = ["scroll_documentation_up" "fallback"];
+            value = action;
-          ${mappings.scrollDocsDown} = ["scroll_documentation_down" "fallback"];
+          }) (filterAttrs (mapping-name: _action: mappings.${mapping-name} != null) {
-          # NOTE: mappings.confirm is skipped because our default, <CR> would
+            complete = ["show" "fallback"];
-          # lead to accidental triggers of blink.accept instead of executing
+            close = ["hide" "fallback"];
-          # the cmd
+            scrollDocsUp = ["scroll_documentation_up" "fallback"];
-
+            scrollDocsDown = ["scroll_documentation_down" "fallback"];
-          ${mappings.next} = ["select_next" "show" "fallback"];
+            # NOTE: mappings.confirm is skipped because our default, <CR> would
-          ${mappings.previous} = ["select_prev" "fallback"];
+            # lead to accidental triggers of blink.accept instead of executing
-        };
+            # the cmd
+            next = ["select_next" "show" "fallback"];
+            previous = ["select_prev" "fallback"];
+          });
       };
     };
   };

modules/plugins/completion/nvim-cmp/config.nix

@@ -3,6 +3,7 @@
   config,
   ...
 }: let
+  inherit (lib.attrsets) filterAttrs mapAttrs';
   inherit (lib.modules) mkIf;
   inherit (lib.strings) optionalString;
   inherit (lib.generators) mkLuaInline;
@@ -72,48 +73,53 @@ in {
             formatting.format = cfg.format;
 
             # `cmp` and `luasnip` are defined above, in the `nvim-cmp` section
-            mapping = {
+            mapping =
-              ${mappings.complete} = mkLuaInline "cmp.mapping.complete()";
+              mapAttrs' (mapping-name: action: {
-              ${mappings.close} = mkLuaInline "cmp.mapping.abort()";
+                name = mappings.${mapping-name};
-              ${mappings.scrollDocsUp} = mkLuaInline "cmp.mapping.scroll_docs(-4)";
+                value = action;
-              ${mappings.scrollDocsDown} = mkLuaInline "cmp.mapping.scroll_docs(4)";
+              }) (filterAttrs (mapping-name: _action: mappings.${mapping-name} != null)
-              ${mappings.confirm} = mkLuaInline "cmp.mapping.confirm({ select = true })";
+                {
+                  complete = mkLuaInline "cmp.mapping.complete()";
+                  close = mkLuaInline "cmp.mapping.abort()";
+                  scrollDocsUp = mkLuaInline "cmp.mapping.scroll_docs(-4)";
+                  scrollDocsDown = mkLuaInline "cmp.mapping.scroll_docs(4)";
+                  confirm = mkLuaInline "cmp.mapping.confirm({ select = true })";
 
-              ${mappings.next} = mkLuaInline ''
+                  next = mkLuaInline ''
-                cmp.mapping(function(fallback)
+                    cmp.mapping(function(fallback)
-                  local has_words_before = function()
+                      local has_words_before = function()
-                    local line, col = unpack(vim.api.nvim_win_get_cursor(0))
+                        local line, col = unpack(vim.api.nvim_win_get_cursor(0))
-                    return col ~= 0 and vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1]:sub(col, col):match("%s") == nil
+                        return col ~= 0 and vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1]:sub(col, col):match("%s") == nil
-                  end
+                      end
 
-                  if cmp.visible() then
+                      if cmp.visible() then
-                    cmp.select_next_item()
+                        cmp.select_next_item()
-                    ${optionalString luasnipEnable ''
+                        ${optionalString luasnipEnable ''
-                  elseif luasnip.locally_jumpable(1) then
+                      elseif luasnip.locally_jumpable(1) then
-                    luasnip.jump(1)
+                        luasnip.jump(1)
-                ''}
+                    ''}
-                  elseif has_words_before() then
+                      elseif has_words_before() then
-                    cmp.complete()
+                        cmp.complete()
-                  else
+                      else
-                    fallback()
+                        fallback()
-                  end
+                      end
-                end)
+                    end)
-              '';
+                  '';
 
-              ${mappings.previous} = mkLuaInline ''
+                  previous = mkLuaInline ''
-                cmp.mapping(function(fallback)
+                    cmp.mapping(function(fallback)
-                  if cmp.visible() then
+                      if cmp.visible() then
-                    cmp.select_prev_item()
+                        cmp.select_prev_item()
-                    ${optionalString luasnipEnable ''
+                        ${optionalString luasnipEnable ''
-                  elseif luasnip.locally_jumpable(-1) then
+                      elseif luasnip.locally_jumpable(-1) then
-                    luasnip.jump(-1)
+                        luasnip.jump(-1)
-                ''}
+                    ''}
-                  else
+                      else
-                    fallback()
+                        fallback()
-                  end
+                      end
-                end)
+                    end)
-              '';
+                  '';
-            };
+                });
           };
         };
       };

modules/plugins/completion/nvim-cmp/nvim-cmp.nix

@@ -6,9 +6,9 @@
   inherit (lib.options) mkEnableOption mkOption literalMD;
   inherit (lib.types) str attrsOf nullOr either listOf;
   inherit (lib.generators) mkLuaInline;
-  inherit (lib.nvim.binds) mkMappingOption;
   inherit (lib.nvim.types) mkPluginSetupOption luaInline mergelessListOf pluginType;
   inherit (lib.nvim.lua) toLuaObject;
+  inherit (config.vim.lib) mkMappingOption;
   inherit (builtins) isString;
 
   cfg = config.vim.autocomplete.nvim-cmp;

modules/plugins/debugger/nvim-dap/nvim-dap.nix

@@ -1,8 +1,12 @@
-{lib, ...}: let
+{
+  config,
+  lib,
+  ...
+}: let
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.types) bool attrsOf str;
-  inherit (lib.nvim.binds) mkMappingOption;
   inherit (lib.nvim.types) mkPluginSetupOption;
+  inherit (config.vim.lib) mkMappingOption;
 in {
   options.vim.debugger.nvim-dap = {
     enable = mkEnableOption "debugging via nvim-dap";

modules/plugins/filetree/nvimtree/nvimtree.nix

@@ -1,13 +1,15 @@
 {
+  config,
   pkgs,
   lib,
   ...
 }: let
   inherit (lib.options) mkEnableOption mkOption literalExpression;
   inherit (lib.generators) mkLuaInline;
-  inherit (lib.types) nullOr str bool int submodule listOf enum oneOf attrs addCheck;
+  inherit (lib.types) str bool int submodule listOf enum oneOf attrs addCheck;
   inherit (lib.nvim.types) mkPluginSetupOption;
   inherit (lib.nvim.config) batchRenameOptions;
+  inherit (config.vim.lib) mkMappingOption;
 
   migrationTable = {
     disableNetrw = "disable_netrw";
@@ -76,26 +78,10 @@ in {
     enable = mkEnableOption "filetree via nvim-tree.lua";
 
     mappings = {
-      toggle = mkOption {
+      toggle = mkMappingOption "Toggle NvimTree" "<leader>t";
-        type = nullOr str;
+      refresh = mkMappingOption "Refresh NvimTree" "<leader>tr";
-        default = "<leader>t";
+      findFile = mkMappingOption "Find file in NvimTree" "<leader>tg";
-        description = "Toggle NvimTree";
+      focus = mkMappingOption "Focus NvimTree" "<leader>tf";
-      };
-      refresh = mkOption {
-        type = nullOr str;
-        default = "<leader>tr";
-        description = "Refresh NvimTree";
-      };
-      findFile = mkOption {
-        type = nullOr str;
-        default = "<leader>tg";
-        description = "Find file in NvimTree";
-      };
-      focus = mkOption {
-        type = nullOr str;
-        default = "<leader>tf";
-        description = "Focus NvimTree";
-      };
     };
 
     setupOpts = mkPluginSetupOption "Nvim Tree" {

modules/plugins/git/git-conflict/git-conflict.nix

@@ -4,8 +4,8 @@
   ...
 }: let
   inherit (lib.options) mkEnableOption;
-  inherit (lib.nvim.binds) mkMappingOption;
   inherit (lib.nvim.types) mkPluginSetupOption;
+  inherit (config.vim.lib) mkMappingOption;
 in {
   options.vim.git.git-conflict = {
     enable = mkEnableOption "git-conflict" // {default = config.vim.git.enable;};

modules/plugins/git/gitsigns/gitsigns.nix

@@ -5,8 +5,8 @@
 }: let
   inherit (lib.options) mkEnableOption;
   inherit (lib.modules) mkRenamedOptionModule;
-  inherit (lib.nvim.binds) mkMappingOption;
   inherit (lib.nvim.types) mkPluginSetupOption;
+  inherit (config.vim.lib) mkMappingOption;
 in {
   imports = [
     (mkRenamedOptionModule ["vim" "git" "gitsigns" "codeActions" "vim" "gitsigns" "codeActions"] ["vim" "git" "gitsigns" "codeActions" "enable"])

modules/plugins/git/neogit/neogit.nix

@@ -1,7 +1,11 @@
-{lib, ...}: let
+{
+  config,
+  lib,
+  ...
+}: let
   inherit (lib.options) mkEnableOption;
-  inherit (lib.nvim.binds) mkMappingOption;
   inherit (lib.nvim.types) mkPluginSetupOption;
+  inherit (config.vim.lib) mkMappingOption;
 in {
   options.vim.git.neogit = {
     enable = mkEnableOption "An Interactive and powerful Git interface [Neogit]";

modules/plugins/languages/rust.nix

@@ -214,24 +214,31 @@ in {
               on_attach = function(client, bufnr)
                 default_on_attach(client, bufnr)
                 local opts = { noremap=true, silent=true, buffer = bufnr }
-                vim.keymap.set("n", "<localleader>rr", ":RustLsp runnables<CR>", opts)
+
-                vim.keymap.set("n", "<localleader>rp", ":RustLsp parentModule<CR>", opts)
+                ${optionalString config.vim.vendoredKeymaps ''
-                vim.keymap.set("n", "<localleader>rm", ":RustLsp expandMacro<CR>", opts)
+              vim.keymap.set("n", "<localleader>rr", ":RustLsp runnables<CR>", opts)
-                vim.keymap.set("n", "<localleader>rc", ":RustLsp openCargo", opts)
+              vim.keymap.set("n", "<localleader>rp", ":RustLsp parentModule<CR>", opts)
-                vim.keymap.set("n", "<localleader>rg", ":RustLsp crateGraph x11", opts)
+              vim.keymap.set("n", "<localleader>rm", ":RustLsp expandMacro<CR>", opts)
-                ${optionalString cfg.dap.enable ''
+              vim.keymap.set("n", "<localleader>rc", ":RustLsp openCargo", opts)
+              vim.keymap.set("n", "<localleader>rg", ":RustLsp crateGraph x11", opts)
+            ''}
+
+                ${optionalString (cfg.dap.enable && config.vim.vendoredKeymaps) ''
               vim.keymap.set("n", "<localleader>rd", ":RustLsp debuggables<cr>", opts)
+            ''}
+
+                ${optionalString (cfg.dap.enable && config.vim.debugger.nvim-dap.mappings.continue != null) ''
               vim.keymap.set(
-               "n", "${config.vim.debugger.nvim-dap.mappings.continue}",
+              "n", "${config.vim.debugger.nvim-dap.mappings.continue}",
-               function()
+              function()
-                 local dap = require("dap")
+                local dap = require("dap")
-                 if dap.status() == "" then
+                if dap.status() == "" then
-                   vim.cmd "RustLsp debuggables"
+                  vim.cmd "RustLsp debuggables"
-                 else
+                else
-                   dap.continue()
+                  dap.continue()
-                 end
+                end
-               end,
+              end,
-               opts
+              opts
               )
             ''}
               end

modules/plugins/languages/scala.nix

@@ -6,13 +6,13 @@
 }: let
   inherit (lib.generators) mkLuaInline;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.binds) mkMappingOption;
   inherit (lib.nvim.dag) entryAfter;
   inherit (lib.nvim.lua) toLuaObject;
   inherit (lib.nvim.types) mkGrammarOption luaInline;
   inherit (lib.options) mkOption mkEnableOption mkPackageOption literalExpression;
   inherit (lib.strings) optionalString;
   inherit (lib.types) attrsOf anything bool;
+  inherit (config.vim.lib) mkMappingOption;
 
   listCommandsAction =
     if config.vim.telescope.enable
@@ -117,7 +117,9 @@ in {
 
             local attach_metals_keymaps = function(client, bufnr)
               attach_keymaps(client, bufnr)  -- from lsp-setup
+              ${optionalString (cfg.lsp.extraMappings.listCommands != null) ''
               vim.api.nvim_buf_set_keymap(bufnr, 'n', '${cfg.lsp.extraMappings.listCommands}', '<cmd>lua ${listCommandsAction}<CR>', {noremap=true, silent=true, desc='Show all Metals commands'})
+            ''}
             end
 
             metals_config = require('metals').bare_config()

modules/plugins/languages/typst.nix

@@ -13,8 +13,9 @@
   inherit (lib.nvim.dag) entryAnywhere;
   inherit (lib.nvim.lua) toLuaObject;
   inherit (lib.nvim.attrsets) mapListToAttrs;
-  inherit (lib.nvim.binds) mkKeymap mkMappingOption;
+  inherit (lib.nvim.binds) mkKeymap;
   inherit (lib.generators) mkLuaInline;
+  inherit (config.vim.lib) mkMappingOption;
 
   cfg = config.vim.languages.typst;
 

modules/plugins/lsp/module.nix

@@ -1,6 +1,10 @@
-{lib, ...}: let
+{
+  config,
+  lib,
+  ...
+}: let
   inherit (lib.options) mkEnableOption;
-  inherit (lib.nvim.binds) mkMappingOption;
+  inherit (config.vim.lib) mkMappingOption;
 in {
   options.vim.lsp = {
     formatOnSave = mkEnableOption "format on save";
@@ -10,66 +14,26 @@ in {
     };
 
     mappings = {
-      goToDefinition =
+      goToDefinition = mkMappingOption "Go to definition" "<leader>lgd";
-        mkMappingOption "Go to definition"
+      goToDeclaration = mkMappingOption "Go to declaration" "<leader>lgD";
-        "<leader>lgd";
+      goToType = mkMappingOption "Go to type" "<leader>lgt";
-      goToDeclaration =
+      listImplementations = mkMappingOption "List implementations" "<leader>lgi";
-        mkMappingOption "Go to declaration"
+      listReferences = mkMappingOption "List references" "<leader>lgr";
-        "<leader>lgD";
+      nextDiagnostic = mkMappingOption "Go to next diagnostic" "<leader>lgn";
-      goToType =
+      previousDiagnostic = mkMappingOption "Go to previous diagnostic" "<leader>lgp";
-        mkMappingOption "Go to type"
+      openDiagnosticFloat = mkMappingOption "Open diagnostic float" "<leader>le";
-        "<leader>lgt";
+      documentHighlight = mkMappingOption "Document highlight" "<leader>lH";
-      listImplementations =
+      listDocumentSymbols = mkMappingOption "List document symbols" "<leader>lS";
-        mkMappingOption "List implementations"
+      addWorkspaceFolder = mkMappingOption "Add workspace folder" "<leader>lwa";
-        "<leader>lgi";
+      removeWorkspaceFolder = mkMappingOption "Remove workspace folder" "<leader>lwr";
-      listReferences =
+      listWorkspaceFolders = mkMappingOption "List workspace folders" "<leader>lwl";
-        mkMappingOption "List references"
+      listWorkspaceSymbols = mkMappingOption "List workspace symbols" "<leader>lws";
-        "<leader>lgr";
+      hover = mkMappingOption "Trigger hover" "<leader>lh";
-      nextDiagnostic =
+      signatureHelp = mkMappingOption "Signature help" "<leader>ls";
-        mkMappingOption "Go to next diagnostic"
+      renameSymbol = mkMappingOption "Rename symbol" "<leader>ln";
-        "<leader>lgn";
+      codeAction = mkMappingOption "Code action" "<leader>la";
-      previousDiagnostic =
+      format = mkMappingOption "Format" "<leader>lf";
-        mkMappingOption "Go to previous diagnostic"
+      toggleFormatOnSave = mkMappingOption "Toggle format on save" "<leader>ltf";
-        "<leader>lgp";
-      openDiagnosticFloat =
-        mkMappingOption "Open diagnostic float"
-        "<leader>le";
-      documentHighlight =
-        mkMappingOption "Document highlight"
-        "<leader>lH";
-      listDocumentSymbols =
-        mkMappingOption "List document symbols"
-        "<leader>lS";
-      addWorkspaceFolder =
-        mkMappingOption "Add workspace folder"
-        "<leader>lwa";
-      removeWorkspaceFolder =
-        mkMappingOption "Remove workspace folder"
-        "<leader>lwr";
-      listWorkspaceFolders =
-        mkMappingOption "List workspace folders"
-        "<leader>lwl";
-      listWorkspaceSymbols =
-        mkMappingOption "List workspace symbols"
-        "<leader>lws";
-      hover =
-        mkMappingOption "Trigger hover"
-        "<leader>lh";
-      signatureHelp =
-        mkMappingOption "Signature help"
-        "<leader>ls";
-      renameSymbol =
-        mkMappingOption "Rename symbol"
-        "<leader>ln";
-      codeAction =
-        mkMappingOption "Code action"
-        "<leader>la";
-      format =
-        mkMappingOption "Format"
-        "<leader>lf";
-      toggleFormatOnSave =
-        mkMappingOption "Toggle format on save"
-        "<leader>ltf";
     };
   };
 }

modules/plugins/lsp/nvim-docs-view/nvim-docs-view.nix

@@ -1,9 +1,13 @@
-{lib, ...}: let
+{
+  config,
+  lib,
+  ...
+}: let
   inherit (lib.options) mkEnableOption mkOption;
-  inherit (lib.nvim.binds) mkMappingOption;
   inherit (lib.nvim.types) mkPluginSetupOption;
   inherit (lib.types) enum int;
   inherit (lib.modules) mkRenamedOptionModule;
+  inherit (config.vim.lib) mkMappingOption;
 in {
   imports = let
     renamedSetupOption = oldPath: newPath:

modules/plugins/lsp/otter/otter.nix

@@ -1,8 +1,12 @@
-{lib, ...}: let
+{
+  config,
+  lib,
+  ...
+}: let
   inherit (lib.options) mkOption mkEnableOption;
-  inherit (lib.nvim.binds) mkMappingOption;
   inherit (lib.types) bool str listOf;
   inherit (lib.nvim.types) mkPluginSetupOption;
+  inherit (config.vim.lib) mkMappingOption;
 in {
   options.vim.lsp = {
     otter-nvim = {

modules/plugins/lsp/trouble/trouble.nix

@@ -1,7 +1,11 @@
-{lib, ...}: let
+{
+  config,
+  lib,
+  ...
+}: let
   inherit (lib.options) mkEnableOption;
-  inherit (lib.nvim.binds) mkMappingOption;
   inherit (lib.nvim.types) mkPluginSetupOption;
+  inherit (config.vim.lib) mkMappingOption;
 in {
   options.vim.lsp = {
     trouble = {

modules/plugins/minimap/codewindow/codewindow.nix

@@ -1,7 +1,11 @@
-{lib, ...}: let
+{
+  config,
+  lib,
+  ...
+}: let
   inherit (lib.options) mkEnableOption;
-  inherit (lib.nvim.binds) mkMappingOption;
   inherit (lib.nvim.types) mkPluginSetupOption;
+  inherit (config.vim.lib) mkMappingOption;
 in {
   options.vim.minimap.codewindow = {
     enable = mkEnableOption "codewindow plugin for minimap view";

modules/plugins/notes/todo-comments/todo-comments.nix

@@ -1,4 +1,5 @@
 {
+  config,
   pkgs,
   lib,
   ...
@@ -6,8 +7,8 @@
   inherit (lib.modules) mkRenamedOptionModule;
   inherit (lib.options) mkOption mkEnableOption;
   inherit (lib.types) str listOf;
-  inherit (lib.nvim.binds) mkMappingOption;
   inherit (lib.nvim.types) mkPluginSetupOption;
+  inherit (config.vim.lib) mkMappingOption;
 in {
   imports = let
     renamedSetupOption = oldPath: newPath:

modules/plugins/runner/run-nvim/run-nvim.nix

@@ -1,7 +1,11 @@
-{lib, ...}: let
+{
+  config,
+  lib,
+  ...
+}: let
   inherit (lib.options) mkEnableOption;
   inherit (lib.nvim.types) mkPluginSetupOption;
-  inherit (lib.nvim.binds) mkMappingOption;
+  inherit (config.vim.lib) mkMappingOption;
 in {
   options = {
     vim.runner.run-nvim = {

modules/plugins/session/nvim-session-manager/nvim-session-manager.nix

@@ -1,10 +1,15 @@
-{lib, ...}: let
+{
+  config,
+  lib,
+  ...
+}: let
   inherit (lib.options) mkOption mkEnableOption;
   inherit (lib.modules) mkRenamedOptionModule;
   inherit (lib.strings) isString;
   inherit (lib.types) nullOr str bool int enum listOf either;
   inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.types) luaInline mkPluginSetupOption;
+  inherit (config.vim.lib) mkMappingOption;
 in {
   imports = let
     renameSetupOpt = oldPath: newPath:
@@ -26,29 +31,10 @@ in {
     enable = mkEnableOption "nvim-session-manager: manage sessions like folders in VSCode";
 
     mappings = {
-      loadSession = mkOption {
+      loadSession = mkMappingOption "Load session" "<leader>sl";
-        type = nullOr str;
+      deleteSession = mkMappingOption "Delete session" "<leader>sd";
-        description = "Load session";
+      saveCurrentSession = mkMappingOption "Save current session" "<leader>sc";
-        default = "<leader>sl";
+      loadLastSession = mkMappingOption "Load last session" "<leader>slt";
-      };
-
-      deleteSession = mkOption {
-        type = nullOr str;
-        description = "Delete session";
-        default = "<leader>sd";
-      };
-
-      saveCurrentSession = mkOption {
-        type = nullOr str;
-        description = "Save current session";
-        default = "<leader>sc";
-      };
-
-      loadLastSession = mkOption {
-        type = nullOr str;
-        description = "Load last session";
-        default = "<leader>slt";
-      };
     };
 
     usePicker = mkOption {

modules/plugins/tabline/nvim-bufferline/nvim-bufferline.nix

@@ -6,8 +6,8 @@
   inherit (lib.options) mkOption mkEnableOption literalExpression literalMD;
   inherit (lib.types) enum bool either nullOr str int listOf attrs;
   inherit (lib.generators) mkLuaInline;
-  inherit (lib.nvim.binds) mkMappingOption;
   inherit (lib.nvim.types) mkPluginSetupOption luaInline;
+  inherit (config.vim.lib) mkMappingOption;
 in {
   options.vim.tabline.nvimBufferline = {
     enable = mkEnableOption "neovim bufferline";

modules/plugins/terminal/toggleterm/config.nix

@@ -54,7 +54,9 @@ in {
             end
           })
 
-          vim.keymap.set('n', ${toLuaObject cfg.lazygit.mappings.open}, function() lazygit:toggle() end, {silent = true, noremap = true, desc = '${lazygitMapDesc}'})
+          ${optionalString (cfg.lazygit.mappings.open != null) ''
+            vim.keymap.set('n', ${toLuaObject cfg.lazygit.mappings.open}, function() lazygit:toggle() end, {silent = true, noremap = true, desc = '${lazygitMapDesc}'})
+          ''}
         '';
       };
     };

modules/plugins/terminal/toggleterm/toggleterm.nix

@@ -1,14 +1,15 @@
 {
+  config,
   pkgs,
   lib,
   ...
 }: let
   inherit (lib.options) mkOption mkEnableOption;
-  inherit (lib.nvim.binds) mkMappingOption;
+  inherit (lib.types) nullOr enum bool package either int;
-  inherit (lib.types) nullOr str enum bool package either int;
   inherit (lib.modules) mkRenamedOptionModule;
   inherit (lib.nvim.types) mkPluginSetupOption luaInline;
   inherit (lib.generators) mkLuaInline;
+  inherit (config.vim.lib) mkMappingOption;
 in {
   imports = [
     (mkRenamedOptionModule ["vim" "terminal" "toggleterm" "direction"] ["vim" "terminal" "toggleterm" "setupOpts" "direction"])
@@ -18,11 +19,7 @@ in {
   options.vim.terminal.toggleterm = {
     enable = mkEnableOption "toggleterm as a replacement to built-in terminal command";
     mappings = {
-      open = mkOption {
+      open = mkMappingOption "Open toggleterm" "<c-t>";
-        type = nullOr str;
-        description = "The keymapping to open toggleterm";
-        default = "<c-t>";
-      };
     };
 
     setupOpts = mkPluginSetupOption "ToggleTerm" {

modules/plugins/ui/breadcrumbs/breadcrumbs.nix

@@ -7,6 +7,8 @@
   inherit (lib.types) nullOr listOf enum bool str int;
   inherit (lib.modules) mkRenamedOptionModule;
   inherit (lib.nvim.types) mkPluginSetupOption borderType;
+  inherit (config.vim.lib) mkMappingOption;
+
   mkSimpleIconOption = default:
     mkOption {
       inherit default;
@@ -83,167 +85,33 @@ in {
     navbuddy = {
       enable = mkEnableOption "navbuddy LSP helper UI. Enabling this option automatically loads and enables nvim-navic";
       mappings = {
-        close = mkOption {
+        close = mkMappingOption "Close and return the cursor to its original location." "<esc>";
-          type = str;
+        nextSibling = mkMappingOption "Navigate to the next sibling node." "j";
-          default = "<esc>";
+        previousSibling = mkMappingOption "Navigate to the previous sibling node." "k";
-          description = "Close and return the cursor to its original location.";
+        parent = mkMappingOption "Navigate to the parent node." "h";
-        };
+        children = mkMappingOption "Navigate to the child node." "l";
-
+        root = mkMappingOption "Navigate to the root node." "0";
-        nextSibling = mkOption {
+        visualName = mkMappingOption "Select the name visually." "v";
-          type = str;
+        visualScope = mkMappingOption "Select the scope visually." "V";
-          default = "j";
+        yankName = mkMappingOption "Yank the name to system clipboard." "y";
-          description = "Navigate to the next sibling node.";
+        yankScope = mkMappingOption "Yank the scope to system clipboard." "Y";
-        };
+        insertName = mkMappingOption "Insert at the start of name." "i";
-
+        insertScope = mkMappingOption "Insert at the start of scope." "I";
-        previousSibling = mkOption {
+        appendName = mkMappingOption "Insert at the end of name." "a";
-          type = str;
+        appendScope = mkMappingOption "Insert at the end of scope." "A";
-          default = "k";
+        rename = mkMappingOption "Rename the node." "r";
-          description = "Navigate to the previous sibling node.";
+        delete = mkMappingOption "Delete the node." "d";
-        };
+        foldCreate = mkMappingOption "Create a new fold of the node." "f";
-
+        foldDelete = mkMappingOption "Delete the current fold of the node." "F";
-        parent = mkOption {
+        comment = mkMappingOption "Comment the node." "c";
-          type = str;
+        select = mkMappingOption "Goto the node." "<enter>";
-          default = "h";
+        moveDown = mkMappingOption "Move the node down." "J";
-          description = "Navigate to the parent node.";
+        moveUp = mkMappingOption "Move the node up." "K";
-        };
+        togglePreview = mkMappingOption "Toggle the preview." "s";
-
+        vsplit = mkMappingOption "Open the node in a vertical split." "<C-v>";
-        children = mkOption {
+        hsplit = mkMappingOption "Open the node in a horizontal split." "<C-s>";
-          type = str;
+        telescope = mkMappingOption "Start fuzzy finder at the current level." "t";
-          default = "l";
+        help = mkMappingOption "Open the mappings help window." "g?";
-          description = "Navigate to the child node.";
-        };
-
-        root = mkOption {
-          type = str;
-          default = "0";
-          description = "Navigate to the root node.";
-        };
-
-        visualName = mkOption {
-          type = str;
-          default = "v";
-          description = "Select the name visually.";
-        };
-
-        visualScope = mkOption {
-          type = str;
-          default = "V";
-          description = "Select the scope visually.";
-        };
-
-        yankName = mkOption {
-          type = str;
-          default = "y";
-          description = "Yank the name to system clipboard.";
-        };
-
-        yankScope = mkOption {
-          type = str;
-          default = "Y";
-          description = "Yank the scope to system clipboard.";
-        };
-
-        insertName = mkOption {
-          type = str;
-          default = "i";
-          description = "Insert at the start of name.";
-        };
-
-        insertScope = mkOption {
-          type = str;
-          default = "I";
-          description = "Insert at the start of scope.";
-        };
-
-        appendName = mkOption {
-          type = str;
-          default = "a";
-          description = "Insert at the end of name.";
-        };
-
-        appendScope = mkOption {
-          type = str;
-          default = "A";
-          description = "Insert at the end of scope.";
-        };
-
-        rename = mkOption {
-          type = str;
-          default = "r";
-          description = "Rename the node.";
-        };
-
-        delete = mkOption {
-          type = str;
-          default = "d";
-          description = "Delete the node.";
-        };
-
-        foldCreate = mkOption {
-          type = str;
-          default = "f";
-          description = "Create a new fold of the node.";
-        };
-
-        foldDelete = mkOption {
-          type = str;
-          default = "F";
-          description = "Delete the current fold of the node.";
-        };
-
-        comment = mkOption {
-          type = str;
-          default = "c";
-          description = "Comment the node.";
-        };
-
-        select = mkOption {
-          type = str;
-          default = "<enter>";
-          description = "Goto the node.";
-        };
-
-        moveDown = mkOption {
-          type = str;
-          default = "J";
-          description = "Move the node down.";
-        };
-
-        moveUp = mkOption {
-          type = str;
-          default = "K";
-          description = "Move the node up.";
-        };
-
-        togglePreview = mkOption {
-          type = str;
-          default = "s";
-          description = "Toggle the preview.";
-        };
-
-        vsplit = mkOption {
-          type = str;
-          default = "<C-v>";
-          description = "Open the node in a vertical split.";
-        };
-
-        hsplit = mkOption {
-          type = str;
-          default = "<C-s>";
-          description = "Open the node in a horizontal split.";
-        };
-
-        telescope = mkOption {
-          type = str;
-          default = "t";
-          description = "Start fuzzy finder at the current level.";
-        };
-
-        help = mkOption {
-          type = str;
-          default = "g?";
-          description = "Open the mappings help window.";
-        };
       };
 
       setupOpts = mkPluginSetupOption "navbuddy" {

modules/plugins/ui/breadcrumbs/config.nix

@@ -3,6 +3,7 @@
   lib,
   ...
 }: let
+  inherit (lib.attrsets) filterAttrs mapAttrs';
   inherit (lib.strings) optionalString;
   inherit (lib.modules) mkIf;
   inherit (lib.lists) optionals;
@@ -30,57 +31,62 @@ in {
       ];
 
     vim.ui.breadcrumbs.navbuddy.setupOpts = {
-      mappings = {
+      mappings =
-        ${cfg.navbuddy.mappings.close} = mkLuaInline "actions.close()";
+        mapAttrs' (mapping-name: action: {
-        ${cfg.navbuddy.mappings.nextSibling} = mkLuaInline "actions.next_sibling()";
+          name = cfg.navbuddy.mappings.${mapping-name};
-        ${cfg.navbuddy.mappings.previousSibling} = mkLuaInline "actions.previous_sibling()";
+          value = action;
-        ${cfg.navbuddy.mappings.parent} = mkLuaInline "actions.parent()";
+        }) (filterAttrs (mapping-name: _action: cfg.navbuddy.mappings.${mapping-name} != null)
-        ${cfg.navbuddy.mappings.children} = mkLuaInline "actions.children()";
+          {
-        ${cfg.navbuddy.mappings.root} = mkLuaInline "actions.root()";
+            close = mkLuaInline "actions.close()";
+            nextSibling = mkLuaInline "actions.next_sibling()";
+            previousSibling = mkLuaInline "actions.previous_sibling()";
+            parent = mkLuaInline "actions.parent()";
+            children = mkLuaInline "actions.children()";
+            root = mkLuaInline "actions.root()";
 
-        ${cfg.navbuddy.mappings.visualName} = mkLuaInline "actions.visual_name()";
+            visualName = mkLuaInline "actions.visual_name()";
-        ${cfg.navbuddy.mappings.visualScope} = mkLuaInline "actions.visual_scope()";
+            visualScope = mkLuaInline "actions.visual_scope()";
 
-        ${cfg.navbuddy.mappings.yankName} = mkLuaInline "actions.yank_name()";
+            yankName = mkLuaInline "actions.yank_name()";
-        ${cfg.navbuddy.mappings.yankScope} = mkLuaInline "actions.yank_scope()";
+            yankScope = mkLuaInline "actions.yank_scope()";
 
-        ${cfg.navbuddy.mappings.insertName} = mkLuaInline "actions.insert_name()";
+            insertName = mkLuaInline "actions.insert_name()";
-        ${cfg.navbuddy.mappings.insertScope} = mkLuaInline "actions.insert_scope()";
+            insertScope = mkLuaInline "actions.insert_scope()";
 
-        ${cfg.navbuddy.mappings.appendName} = mkLuaInline "actions.append_name()";
+            appendName = mkLuaInline "actions.append_name()";
-        ${cfg.navbuddy.mappings.appendScope} = mkLuaInline "actions.append_scope()";
+            appendScope = mkLuaInline "actions.append_scope()";
 
-        ${cfg.navbuddy.mappings.rename} = mkLuaInline "actions.rename()";
+            rename = mkLuaInline "actions.rename()";
 
-        ${cfg.navbuddy.mappings.delete} = mkLuaInline "actions.delete()";
+            delete = mkLuaInline "actions.delete()";
 
-        ${cfg.navbuddy.mappings.foldCreate} = mkLuaInline "actions.fold_create()";
+            foldCreate = mkLuaInline "actions.fold_create()";
-        ${cfg.navbuddy.mappings.foldDelete} = mkLuaInline "actions.fold_delete()";
+            foldDelete = mkLuaInline "actions.fold_delete()";
 
-        ${cfg.navbuddy.mappings.comment} = mkLuaInline "actions.comment()";
+            comment = mkLuaInline "actions.comment()";
 
-        ${cfg.navbuddy.mappings.select} = mkLuaInline "actions.select()";
+            select = mkLuaInline "actions.select()";
 
-        ${cfg.navbuddy.mappings.moveDown} = mkLuaInline "actions.move_down()";
+            moveDown = mkLuaInline "actions.move_down()";
-        ${cfg.navbuddy.mappings.moveUp} = mkLuaInline "actions.move_up()";
+            moveUp = mkLuaInline "actions.move_up()";
 
-        ${cfg.navbuddy.mappings.togglePreview} = mkLuaInline "actions.toggle_preview()";
+            togglePreview = mkLuaInline "actions.toggle_preview()";
 
-        ${cfg.navbuddy.mappings.vsplit} = mkLuaInline "actions.vsplit()";
+            vsplit = mkLuaInline "actions.vsplit()";
-        ${cfg.navbuddy.mappings.hsplit} = mkLuaInline "actions.hsplit()";
+            hsplit = mkLuaInline "actions.hsplit()";
 
-        ${cfg.navbuddy.mappings.telescope} = mkLuaInline ''
+            telescope = mkLuaInline ''
-          actions.telescope({
+              actions.telescope({
-            layout_strategy = "horizontal",
+                layout_strategy = "horizontal",
-            layout_config = {
+                layout_config = {
-              height = 0.60,
+                  height = 0.60,
-              width = 0.75,
+                  width = 0.75,
-              prompt_position = "top",
+                  prompt_position = "top",
-              preview_width = 0.50
+                  preview_width = 0.50
-            },
+                },
-          })'';
+              })'';
-        ${cfg.navbuddy.mappings.help} = mkLuaInline "actions.help()";
+            help = mkLuaInline "actions.help()";
-      };
+          });
     };
 
     vim.pluginRC.breadcrumbs = entryAfter ["lspconfig"] ''

modules/plugins/utility/ccc/ccc.nix

@@ -1,9 +1,13 @@
-{lib, ...}: let
+{
+  config,
+  lib,
+  ...
+}: let
   inherit (lib.options) mkOption mkEnableOption;
   inherit (lib.types) anything attrsOf listOf enum;
-  inherit (lib.nvim.binds) mkMappingOption;
   inherit (lib.nvim.types) mkPluginSetupOption luaInline;
   inherit (lib.generators) mkLuaInline;
+  inherit (config.vim.lib) mkMappingOption;
 in {
   options.vim.utility.ccc = {
     enable = mkEnableOption "ccc color picker for neovim";

modules/plugins/utility/gestures/gesture-nvim/gesture-nvim.nix

@@ -1,6 +1,10 @@
-{lib, ...}: let
+{
+  config,
+  lib,
+  ...
+}: let
   inherit (lib.options) mkEnableOption;
-  inherit (lib.nvim.binds) mkMappingOption;
+  inherit (config.vim.lib) mkMappingOption;
 in {
   options.vim.gestures.gesture-nvim = {
     enable = mkEnableOption "gesture-nvim: mouse gestures";

modules/plugins/utility/harpoon/harpoon.nix

@@ -1,9 +1,13 @@
-{lib, ...}: let
+{
+  config,
+  lib,
+  ...
+}: let
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.types) bool;
-  inherit (lib.nvim.binds) mkMappingOption;
   inherit (lib.nvim.types) mkPluginSetupOption luaInline;
   inherit (lib.generators) mkLuaInline;
+  inherit (config.vim.lib) mkMappingOption;
 in {
   options.vim.navigation.harpoon = {
     mappings = {

modules/plugins/utility/motion/flash/flash.nix

@@ -1,38 +1,22 @@
-{lib, ...}: let
+{
-  inherit (lib.options) mkEnableOption mkOption;
+  config,
-  inherit (lib.types) nullOr str;
+  lib,
+  ...
+}: let
+  inherit (lib.options) mkEnableOption;
   inherit (lib.nvim.types) mkPluginSetupOption;
+  inherit (config.vim.lib) mkMappingOption;
 in {
   options.vim.utility.motion.flash-nvim = {
     enable = mkEnableOption "enhanced code navigation with flash.nvim";
     setupOpts = mkPluginSetupOption "flash-nvim" {};
 
     mappings = {
-      jump = mkOption {
+      jump = mkMappingOption "Jump" "s";
-        type = nullOr str;
+      treesitter = mkMappingOption "Treesitter" "S";
-        default = "s";
+      remote = mkMappingOption "Remote Flash" "r";
-        description = "Jump";
+      treesitter_search = mkMappingOption "Treesitter Search" "R";
-      };
+      toggle = mkMappingOption "Toggle Flash Search" "<c-s>";
-      treesitter = mkOption {
-        type = nullOr str;
-        default = "S";
-        description = "Treesitter";
-      };
-      remote = mkOption {
-        type = nullOr str;
-        default = "r";
-        description = "Remote Flash";
-      };
-      treesitter_search = mkOption {
-        type = nullOr str;
-        default = "R";
-        description = "Treesitter Search";
-      };
-      toggle = mkOption {
-        type = nullOr str;
-        default = "<c-s>";
-        description = "Toggle Flash Search";
-      };
     };
   };
 }

modules/plugins/utility/motion/hop/hop.nix

@@ -1,6 +1,10 @@
-{lib, ...}: let
+{
+  config,
+  lib,
+  ...
+}: let
   inherit (lib.options) mkEnableOption;
-  inherit (lib.nvim.binds) mkMappingOption;
+  inherit (config.vim.lib) mkMappingOption;
 in {
   options.vim.utility.motion.hop = {
     mappings = {

modules/plugins/utility/motion/leap/leap.nix

@@ -1,36 +1,20 @@
-{lib, ...}: let
+{
-  inherit (lib.options) mkEnableOption mkOption;
+  config,
-  inherit (lib.types) nullOr str;
+  lib,
+  ...
+}: let
+  inherit (lib.options) mkEnableOption;
+  inherit (config.vim.lib) mkMappingOption;
 in {
   options.vim.utility.motion.leap = {
     enable = mkEnableOption "leap.nvim plugin (easy motion)";
 
     mappings = {
-      leapForwardTo = mkOption {
+      leapForwardTo = mkMappingOption "Leap forward to" "<leader>ss";
-        type = nullOr str;
+      leapBackwardTo = mkMappingOption "Leap backward to" "<leader>sS";
-        description = "Leap forward to";
+      leapForwardTill = mkMappingOption "Leap forward till" "<leader>sx";
-        default = "<leader>ss";
+      leapBackwardTill = mkMappingOption "Leap backward till" "<leader>sX";
-      };
+      leapFromWindow = mkMappingOption "Leap from window" "gs";
-      leapBackwardTo = mkOption {
-        type = nullOr str;
-        description = "Leap backward to";
-        default = "<leader>sS";
-      };
-      leapForwardTill = mkOption {
-        type = nullOr str;
-        description = "Leap forward till";
-        default = "<leader>sx";
-      };
-      leapBackwardTill = mkOption {
-        type = nullOr str;
-        description = "Leap backward till";
-        default = "<leader>sX";
-      };
-      leapFromWindow = mkOption {
-        type = nullOr str;
-        description = "Leap from window";
-        default = "gs";
-      };
     };
   };
 }

modules/plugins/utility/outline/aerial-nvim/aerial-nvim.nix

@@ -1,7 +1,11 @@
-{lib, ...}: let
+{
+  config,
+  lib,
+  ...
+}: let
   inherit (lib.options) mkEnableOption;
   inherit (lib.nvim.types) mkPluginSetupOption;
-  inherit (lib.nvim.binds) mkMappingOption;
+  inherit (config.vim.lib) mkMappingOption;
 in {
   options.vim.utility.outline.aerial-nvim = {
     enable = mkEnableOption "Aerial.nvim";

modules/plugins/utility/preview/glow/glow.nix

@@ -1,7 +1,11 @@
-{lib, ...}: let
+{
+  config,
+  lib,
+  ...
+}: let
   inherit (lib.modules) mkRenamedOptionModule;
   inherit (lib.options) mkEnableOption;
-  inherit (lib.nvim.binds) mkMappingOption;
+  inherit (config.vim.lib) mkMappingOption;
 in {
   imports = [
     (mkRenamedOptionModule ["vim" "languages" "markdown" "glow" "enable"] ["vim" "utility" "preview" "glow" "enable"])

modules/plugins/utility/smart-splits/smart-splits.nix

@@ -1,8 +1,12 @@
-{lib, ...}: let
+{
+  config,
+  lib,
+  ...
+}: let
   inherit (lib.options) mkOption;
   inherit (lib.types) bool;
   inherit (lib.nvim.types) mkPluginSetupOption;
-  inherit (lib.nvim.binds) mkMappingOption;
+  inherit (config.vim.lib) mkMappingOption;
 in {
   options.vim.utility.smart-splits = {
     enable = mkOption {

modules/plugins/utility/surround/surround.nix

@@ -3,7 +3,7 @@
   config,
   ...
 }: let
-  inherit (lib.options) mkOption;
+  inherit (lib.options) literalExpression mkOption;
   inherit (lib.types) bool str;
   inherit (lib.nvim.types) mkPluginSetupOption;
 
@@ -64,7 +64,8 @@ in {
 
     useVendoredKeybindings = mkOption {
       type = bool;
-      default = true;
+      default = config.vim.vendoredKeymaps;
+      defaultText = literalExpression "config.vim.vendoredKeymaps";
       description = ''
         Use alternative set of keybindings that avoids conflicts with other popular plugins, e.g. nvim-leap
       '';

modules/plugins/utility/telescope/telescope.nix

@@ -6,8 +6,8 @@
 }: let
   inherit (lib.options) mkOption mkEnableOption literalExpression;
   inherit (lib.types) int str listOf float bool either enum submodule attrsOf anything package;
-  inherit (lib.nvim.binds) mkMappingOption;
   inherit (lib.nvim.types) mkPluginSetupOption luaInline;
+  inherit (config.vim.lib) mkMappingOption;
 
   cfg = config.vim.telescope;
   setupOptions = {

modules/plugins/utility/yazi-nvim/yazi-nvim.nix

@@ -1,8 +1,12 @@
-{lib, ...}: let
+{
+  config,
+  lib,
+  ...
+}: let
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.types) bool;
   inherit (lib.nvim.types) mkPluginSetupOption;
-  inherit (lib.nvim.binds) mkMappingOption;
+  inherit (config.vim.lib) mkMappingOption;
 in {
   options.vim.utility.yazi-nvim = {
     enable = mkEnableOption ''

modules/plugins/visuals/cellular-automaton/cellular-automaton.nix

@@ -1,9 +1,13 @@
-{lib, ...}: let
+{
+  config,
+  lib,
+  ...
+}: let
   inherit (lib.modules) mkRenamedOptionModule;
   inherit (lib.options) mkOption mkEnableOption;
   inherit (lib.nvim.types) luaInline;
-  inherit (lib.nvim.binds) mkMappingOption;
   inherit (lib.generators) mkLuaInline;
+  inherit (config.vim.lib) mkMappingOption;
 in {
   imports = [
     (mkRenamedOptionModule ["vim" "visuals" "cellularAutomaton"] ["vim" "visuals" "cellular-automaton"])

modules/wrapper/lib/config.nix

@@ -0,0 +1,20 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.options) mkOption;
+  inherit (lib.types) nullOr str;
+in {
+  config.vim.lib = {
+    mkMappingOption = description: default:
+      mkOption {
+        type = nullOr str;
+        default =
+          if config.vim.vendoredKeymaps
+          then default
+          else null;
+        inherit description;
+      };
+  };
+}

modules/wrapper/lib/default.nix

@@ -0,0 +1,6 @@
+{
+  imports = [
+    ./config.nix
+    ./options.nix
+  ];
+}

modules/wrapper/lib/options.nix

@@ -0,0 +1,11 @@
+{lib, ...}: let
+  inherit (lib.options) mkOption;
+  inherit (lib.types) attrsOf raw;
+in {
+  options.vim.lib = mkOption {
+    # The second type should be one without merge semantics and which allows function values.
+    type = attrsOf raw;
+    default = {};
+    internal = true;
+  };
+}