Merge 24a7cc5627 into ef413736e9

merge

.github/pull_request_template.md

@@ -1,39 +1,57 @@
-# Description
+<!--
+^ Please include a clear and concise description of the aim of your Pull Request above this line ^
 
-A clear and concise description of the aim of your Pull Request.
+For plugin dependency/module additions, please make sure to link the source link of the added plugin
+or dependency in this section.
 
-**If your pull request aims to fix an open issue or a present bug, please link the relevant issue below. If not, please remove this section**
-Fixes #(issue)
+If your pull request aims to fix an open issue or a please bug, please also link the relevant issue
+below this line. You may attach an issue to your pull request with `Fixes #<issue number>` outside
+this comment.
+-->
 
-## Type of change
+## Sanity Checking
 
-Please delete any options that are not relevant.
+<!--
+Please check all that apply. As before, this section is not a hard requirement but checklists with more checked
+items are likely to be merged faster. You may save some time in maintainer review by performing self-reviews here
+before submitting your pull request.
 
-- Bug fix (non-breaking change which fixes an issue)
-- New feature (non-breaking change which adds functionality)
-- Breaking change (fix or feature that would cause existing functionality to not work as expected)
-- Translation/Language update
-- Docs
-- Other
+If your pull request includes any change or unexpected behaviour not covered below, please do make sure to include
+it above in your description.
+-->
 
-## Checklist
+[editorconfig]: https://editorconfig.org
+[changelog]: https://github.com/NotAShelf/nvf/tree/main/docs/release-notes
 
-Please try to check at least a majority of the checklist before opening your pull request. Exceptions to this will be reviewed on a case by case basis.
+- [ ] I have updated the [changelog] as per my changes.
+- [ ] I have tested, and self-reviewed my code.
+- Style and consistency
+  - [ ] I ran **Alejandra** to format my code (`nix fmt`).
+  - [ ] My code conforms to the [editorconfig] configuration of the project.
+  - [ ] My changes are consistent with the rest of the codebase.
+- If new changes are particularly complex:
+  - [ ] My code includes comments in particularly complex areas
+  - [ ] I have added a section in the manual.
+  - [ ] _(For breaking changes)_ I have included a migration guide.
+- Package(s) built:
+  - [ ] `.#nix` (default package)
+  - [ ] `.#maximal`
+  - [ ] `.#docs-html`
+- Tested on platform(s)
+  - [ ] `x86_64-linux`
+  - [ ] `aarch64-linux`
+  - [ ] `x86_64-darwin`
+  - [ ] `aarch64-darwin`
 
-- [ ] My code follows the style and contributing guidelines of this project.
-- [ ] I ran Alejandra to format my code (`nix fmt`).
-- [ ] I have performed a self-review of my own code and tested it.
-- [ ] I have commented my code, particularly in hard-to-understand areas.
-- [ ] My changes generate no new warnings.
-- [ ] This change requires a documentation update.
-- [ ] I have updated the documentation accordingly.
+<!--
+If your changes touch upon a portion of the codebase that you do not understand well, please make sure to consult
+the maintainers on your changes. In most cases, making an issue before creating your PR will help you avoid duplicate
+efforts in the long run.
+-->
 
-## Screenshots & Logs
+---
 
-You are kindly requested to attach screenshots of your changes in actions and preferably your build/run logs for all available packages. If you are not sure how to do this, you can refer to the [documentation](https://notashelf.github.io/neovim-flake/).
+Add a :+1: [reaction] to [pull requests you find important].
 
-**Please do not use any external image service. Instead, just paste in or drag and drop the image here, and it will be uploaded automatically.**
-
-```console
-# Paste your logs here
-```
+[reaction]: https://github.blog/2016-03-10-add-reactions-to-pull-requests-issues-and-comments/
+[pull requests you find important]: https://github.com/NixOS/nixpkgs/pulls?q=is%3Aopen+sort%3Areactions-%2B1-desc

docs/manual/hacking/keybinds.md

@@ -7,37 +7,26 @@ section contains a general overview to how you may utilize said functions.
 
 ## Custom Key Mappings Support for a Plugin {#sec-custom-key-mappings}
 
-To set a mapping, you should define it in `vim.maps.<<mode>>`.
-The available modes are:
-
-- normal
-- insert
-- select
-- visual
-- terminal
-- normalVisualOp
-- visualOnly
-- operator
-- insertCommand
-- lang
-- command
+To set a mapping, you should define it in `vim.keymaps`.
 
 An example, simple keybinding, can look like this:
 
 ```nix
 {
-  vim.maps.normal = {
-    "<leader>wq" = {
+  vim.keymaps = [
+    {
+      key = "<leader>wq";
+      mode = ["n"];
       action = ":wq<CR>";
       silent = true;
       desc = "Save file and quit";
-    };
-  };
+    }
+  ];
 }
 ```
 
 There are many settings available in the options. Please refer to the
-[documentation](https://notashelf.github.io/nvf/options.html#opt-vim.maps.command._name_.action)
+[documentation](https://notashelf.github.io/nvf/options.html#opt-vim.keymaps)
 to see a list of them.
 
 **nvf** provides a list of helper commands, so that you don't have to write the

docs/release-notes/rl-0.7.md

@@ -26,6 +26,32 @@ making good use of its extensive Lua API. Additionally, Vimscript is slow and
 brings unnecessary performance overhead while working with different
 configuration formats.
 
+### `vim.maps` rewrite {#sec-vim-maps-rewrite}
+
+Instead of specifying map modes using submodules (eg.: `vim.maps.normal`), a new
+`vim.keymaps` submodule with support for a `mode` option has been introduced. It
+can be either a string, or a list of strings, where a string represents the
+short-name of the map mode(s), that the mapping should be set for. See
+`:help map-modes` for more information.
+
+For example:
+
+```nix
+vim.maps.normal."<leader>m" = { ... };
+```
+
+has to be replaced by
+
+```nix
+vim.keymaps = [
+  {
+    key = "<leader>m";
+    mode = "n";
+  }
+  ...
+];
+```
+
 ### `vim.lsp.nvimCodeActionMenu` removed in favor of `vim.ui.fastaction` {#sec-nvim-code-action-menu-deprecation}
 
 The nvim-code-action-menu plugin has been archived and broken for a long time,
@@ -89,7 +115,8 @@ everyone.
 - Add [new-file-template.nvim] to automatically fill new file contents using
   templates
 
-- Make [neo-tree.nvim] display file icons properly by enabling `visuals.nvimWebDevicons`
+- Make [neo-tree.nvim] display file icons properly by enabling
+  `visuals.nvimWebDevicons`
 
 [diniamo](https://github.com/diniamo):
 
@@ -123,10 +150,15 @@ everyone.
 - Replace `vim.lsp.nvimCodeActionMenu` with `vim.ui.fastaction`, see the
   breaking changes section above for more details
 
+- Add a `setupOpts` option to nvim-surround, which allows modifying options that
+  aren't defined in nvf. Move the alternate nvim-surround keybinds to use
+  `setupOpts`.
+
 [Neovim documentation on `vim.cmd`]: https://neovim.io/doc/user/lua.html#vim.cmd()
 
 - Make Neovim's configuration file entirely Lua based. This comes with a few
   breaking changes:
+
   - `vim.configRC` has been removed. You will need to migrate your entries to
     Neovim-compliant Lua code, and add them to `vim.luaConfigRC` instead.
     Existing vimscript configurations may be preserved in `vim.cmd` functions.
@@ -135,6 +167,8 @@ everyone.
     has been introduced for setting up internal plugins. See the "DAG entries in
     nvf" manual page for more information.
 
+- Rewrite `vim.maps`, see the breaking changes section above.
+
 [NotAShelf](https://github.com/notashelf):
 
 [ts-error-translator.nvim]: https://github.com/dmmulroy/ts-error-translator.nvim
@@ -206,9 +240,16 @@ everyone.
   - Fixed `project-nvim` command and keybinding
   - Added default ikeybind/command for `Telescope resume` (`<leader>fr`)
 
-[Soliprem](https://github.com/Soliprem)
+[Soliprem](https://github.com/Soliprem):
 
 - Add LSP and Treesitter support for R under `vim.languages.R`.
 - Add Otter support under `vim.lsp.otter` and an assert to prevent conflict with
   ccc
-- Add LSP and Treesitter support for Kotlin under `vim.languages.kotlin`
+- Add LSP, diagnostics, formatter and Treesitter support for Kotlin under
+  `vim.languages.kotlin`
+
+[Bloxx12](https://github.com/Bloxx12)
+
+- Add support for [base16 theming](https://github.com/RRethy/base16-nvim) under
+  `vim.theme`
+- Fix internal breakage in `elixir-tools` setup.

flake.lock

@@ -172,6 +172,22 @@
         "type": "github"
       }
     },
+    "plugin-base16": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1716483968,
+        "narHash": "sha256-GRF/6AobXHamw8TZ3FjL7SI6ulcpwpcohsIuZeCSh2A=",
+        "owner": "rrethy",
+        "repo": "base16-nvim",
+        "rev": "6ac181b5733518040a33017dde654059cd771b7c",
+        "type": "github"
+      },
+      "original": {
+        "owner": "rrethy",
+        "repo": "base16-nvim",
+        "type": "github"
+      }
+    },
     "plugin-bufdelete-nvim": {
       "flake": false,
       "locked": {
@@ -191,11 +207,11 @@
     "plugin-catppuccin": {
       "flake": false,
       "locked": {
-        "lastModified": 1716704960,
-        "narHash": "sha256-UDPS+1o8FQGkfqiG4GX4DNUI2pU5hIvagmfnWTKDb44=",
+        "lastModified": 1728131011,
+        "narHash": "sha256-j6F078taxuGzr3jngrc+Pc5I1kDdxTLMETgq6Xn4w/4=",
         "owner": "catppuccin",
         "repo": "nvim",
-        "rev": "5215ea59df6d0a7e27da9a5cd1165e06d1b04cbe",
+        "rev": "7be452ee067978cdc8b2c5f3411f0c71ffa612b9",
         "type": "github"
       },
       "original": {
@@ -1802,6 +1818,7 @@
         "nixpkgs": "nixpkgs",
         "nmd": "nmd",
         "plugin-alpha-nvim": "plugin-alpha-nvim",
+        "plugin-base16": "plugin-base16",
         "plugin-bufdelete-nvim": "plugin-bufdelete-nvim",
         "plugin-catppuccin": "plugin-catppuccin",
         "plugin-ccc": "plugin-ccc",

flake.nix

@@ -349,6 +349,11 @@
     };
 
     # Themes
+    plugin-base16 = {
+      url = "github:rrethy/base16-nvim";
+      flake = false;
+    };
+
     plugin-tokyonight = {
       url = "github:folke/tokyonight.nvim";
       flake = false;

lib/types/default.nix

@@ -6,10 +6,10 @@
   typesDag = import ./dag.nix {inherit lib;};
   typesPlugin = import ./plugins.nix {inherit inputs lib;};
   typesLanguage = import ./languages.nix {inherit lib;};
-  typesCustom = import ./custom.nix {inherit lib;};
+  typesTypes = import ./types.nix {inherit lib;};
 in {
   inherit (typesDag) dagOf;
   inherit (typesPlugin) pluginsOpt extraPluginType mkPluginSetupOption luaInline pluginType borderType;
   inherit (typesLanguage) diagnostics mkGrammarOption;
-  inherit (typesCustom) anythingConcatLists char;
+  inherit (typesTypes) anythingConcatLists char hexColor;
 }

lib/types/plugins.nix

@@ -97,7 +97,7 @@ in {
 
       default = {};
       type = submodule {
-        freeformType = attrsOf anything;
+        freeformType = anything;
         options = opts;
       };
     };

lib/types/types.nix

@@ -1,8 +1,9 @@
 {lib}: let
   inherit (lib) isStringLike showOption showFiles getFiles mergeOneOption mergeEqualOption mkOptionType;
+  inherit (lib.strings) isString;
   inherit (lib.types) anything attrsOf;
   inherit (lib.nvim.types) anythingConcatLists;
-  inherit (builtins) typeOf isAttrs any head concatLists stringLength;
+  inherit (builtins) typeOf isAttrs any head concatLists stringLength match;
 in {
   # HACK: Does this break anything in our case?
   # A modified version of the nixpkgs anything type that concatenates lists
@@ -58,4 +59,11 @@ in {
     check = value: stringLength value < 2;
     merge = mergeEqualOption;
   };
+
+  hexColor = mkOptionType {
+    name = "hex-color";
+    descriptionClass = "noun";
+    description = "RGB color in hex format";
+    check = v: isString v && (match "#?[0-9a-fA-F]{6}" v) != null;
+  };
 }

modules/neovim/mappings/config.nix

@@ -3,51 +3,75 @@
   lib,
   ...
 }: let
-  inherit (lib.modules) mkIf;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.trivial) pipe;
+  inherit (lib.attrsets) mapAttrsToList;
+  inherit (lib.lists) flatten;
+
+  legacyMapModes = {
+    normal = ["n"];
+    insert = ["i"];
+    select = ["s"];
+    visual = ["v"];
+    terminal = ["t"];
+    normalVisualOp = ["n" "v" "o"];
+    visualOnly = ["n" "x"];
+    operator = ["o"];
+    insertCommand = ["i" "c"];
+    lang = ["l"];
+    command = ["c"];
+  };
 
   cfg = config.vim;
 in {
   config = {
-    vim.maps = {
-      normal = mkIf cfg.disableArrows {
-        "<up>" = {
-          action = "<nop>";
-
-          noremap = false;
-        };
-        "<down>" = {
-          action = "<nop>";
-
-          noremap = false;
-        };
-        "<left>" = {
-          action = "<nop>";
-          noremap = false;
-        };
-        "<right>" = {
-          action = "<nop>";
-          noremap = false;
-        };
-      };
-
-      insert = mkIf cfg.disableArrows {
-        "<up>" = {
-          action = "<nop>";
-          noremap = false;
-        };
-        "<down>" = {
-          action = "<nop>";
-          noremap = false;
-        };
-        "<left>" = {
-          action = "<nop>";
-          noremap = false;
-        };
-        "<right>" = {
-          action = "<nop>";
-          noremap = false;
-        };
-      };
-    };
+    vim.keymaps = mkMerge [
+      (
+        mkIf cfg.disableArrows [
+          {
+            key = "<up>";
+            mode = ["n" "i"];
+            action = "<nop>";
+            noremap = false;
+          }
+          {
+            key = "<down>";
+            mode = ["n" "i"];
+            action = "<nop>";
+            noremap = false;
+          }
+          {
+            key = "<left>";
+            mode = ["n" "i"];
+            action = "<nop>";
+            noremap = false;
+          }
+          {
+            key = "<right>";
+            mode = ["n" "i"];
+            action = "<nop>";
+            noremap = false;
+          }
+        ]
+      )
+      (
+        pipe cfg.maps
+        [
+          (mapAttrsToList (
+            oldMode: keybinds:
+              mapAttrsToList (
+                key: bind:
+                  bind
+                  // {
+                    inherit key;
+                    mode = legacyMapModes.${oldMode};
+                  }
+              )
+              keybinds
+          ))
+          flatten
+        ]
+      )
+    ];
   };
 }

modules/neovim/mappings/options.nix

@@ -1,101 +1,97 @@
 {lib, ...}: let
-  inherit (lib.options) mkOption;
-  inherit (lib.types) bool str attrsOf nullOr submodule;
+  inherit (lib.options) mkOption literalMD;
+  inherit (lib.types) either str listOf attrsOf nullOr submodule;
   inherit (lib.nvim.config) mkBool;
-  # Most of the keybindings code is highly inspired by pta2002/nixvim.
-  # Thank you!
+
   mapConfigOptions = {
-    silent =
-      mkBool false
-      "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.";
-
     desc = mkOption {
       type = nullOr str;
       default = null;
       description = "A description of this keybind, to be shown in which-key, if you have it enabled.";
     };
+
+    action = mkOption {
+      type = str;
+      description = "The command to execute.";
+    };
+    lua = mkBool false ''
+      If true, `action` is considered to be lua code.
+      Thus, it will not be wrapped in `""`.
+    '';
+
+    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.";
   };
 
-  mapOption = submodule {
+  mapType = submodule {
     options =
       mapConfigOptions
       // {
-        action = mkOption {
+        key = mkOption {
           type = str;
-          description = "The action to execute.";
+          description = "The key that triggers this keybind.";
         };
-
-        lua = mkOption {
-          type = bool;
+        mode = mkOption {
+          type = either str (listOf str);
           description = ''
-            If true, `action` is considered to be lua code.
-            Thus, it will not be wrapped in `""`.
+            The short-name of the mode to set the keymapping for. Passing an empty string is the equivalent of `:map`.
+
+            See `:help map-modes` for a list of modes.
           '';
-          default = false;
+          example = literalMD ''`["n" "v" "c"]` for normal, visual and command mode'';
         };
       };
   };
 
-  mapOptions = mode:
+  legacyMapOption = mode:
     mkOption {
       description = "Mappings for ${mode} mode";
-      type = attrsOf mapOption;
+      type = attrsOf (submodule {
+        options = mapConfigOptions;
+      });
       default = {};
     };
 in {
   options.vim = {
-    maps = mkOption {
-      type = submodule {
-        options = {
-          normal = mapOptions "normal";
-          insert = mapOptions "insert";
-          select = mapOptions "select";
-          visual = mapOptions "visual and select";
-          terminal = mapOptions "terminal";
-          normalVisualOp = mapOptions "normal, visual, select and operator-pending (same as plain 'map')";
-
-          visualOnly = mapOptions "visual only";
-          operator = mapOptions "operator-pending";
-          insertCommand = mapOptions "insert and command-line";
-          lang = mapOptions "insert, command-line and lang-arg";
-          command = mapOptions "command-line";
-        };
-      };
-      default = {};
-      description = ''
-        Custom keybindings for any mode.
-
-        For plain maps (e.g. just 'map' or 'remap') use `maps.normalVisualOp`.
-      '';
-
+    keymaps = mkOption {
+      type = listOf mapType;
+      description = "Custom keybindings.";
       example = ''
-        maps = {
-          normal."<leader>m" = {
+        vim.keymaps = [
+          {
+            key = "<leader>m";
+            mode = "n";
             silent = true;
-            action = "<cmd>make<CR>";
-          }; # Same as nnoremap <leader>m <silent> <cmd>make<CR>
-        };
+            action = ":make<CR>";
+          }
+          {
+            key = "<leader>l";
+            mode = ["n" "x"];
+            silent = true;
+            action = "<cmd>cnext<CR>";
+          }
+        ];
       '';
+      default = {};
+    };
+
+    maps = {
+      normal = legacyMapOption "normal";
+      insert = legacyMapOption "insert";
+      select = legacyMapOption "select";
+      visual = legacyMapOption "visual and select";
+      terminal = legacyMapOption "terminal";
+      normalVisualOp = legacyMapOption "normal, visual, select and operator-pending (same as plain 'map')";
+
+      visualOnly = legacyMapOption "visual only";
+      operator = legacyMapOption "operator-pending";
+      insertCommand = legacyMapOption "insert and command-line";
+      lang = legacyMapOption "insert, command-line and lang-arg";
+      command = legacyMapOption "command-line";
     };
   };
 }

modules/plugins/languages/elixir.nix

@@ -114,12 +114,12 @@ in {
     (mkIf cfg.elixir-tools.enable {
       vim.startPlugins = ["elixir-tools"];
       vim.pluginRC.elixir-tools = entryAnywhere ''
-        local elixir-tools = require("elixir")
-        local elixirls = require("elixir-tools.elixirls")
+        local elixir = require("elixir")
+        local elixirls = require("elixir.elixirls")
 
         -- disable imperative insstallations of various
         -- elixir related tools installed by elixir-tools
-        elixir-tools.setup {
+        elixir.setup {
           nextls = {
             enable = false -- defaults to false
           },

modules/plugins/languages/kotlin.nix

@@ -6,8 +6,10 @@
 }: let
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.meta) getExe;
+  inherit (lib.nvim.languages) diagnosticsToLua;
   inherit (lib.types) package;
-  inherit (lib.nvim.types) mkGrammarOption;
+  inherit (lib.nvim.types) mkGrammarOption diagnostics;
   inherit (lib.lists) isList;
   inherit (lib.nvim.lua) expToLua;
 
@@ -27,17 +29,32 @@
         --prefix PATH : ${pkgs.lib.makeBinPath [pkgs.kotlin]}
     '';
   };
+
+  defaultDiagnosticsProvider = ["ktlint"];
+  diagnosticsProviders = {
+    ktlint = {
+      package = pkgs.ktlint;
+      nullConfig = pkg: ''
+        table.insert(
+          ls_sources,
+          null_ls.builtins.diagnostics.ktlint.with({
+            command = "${getExe pkg}",
+          })
+        )
+      '';
+    };
+  };
 in {
   options.vim.languages.kotlin = {
-    enable = mkEnableOption "kotlin/HCL support";
+    enable = mkEnableOption "Kotlin/HCL support";
 
     treesitter = {
-      enable = mkEnableOption "kotlin treesitter" // {default = config.vim.languages.enableTreesitter;};
+      enable = mkEnableOption "Kotlin treesitter" // {default = config.vim.languages.enableTreesitter;};
       package = mkGrammarOption pkgs "kotlin";
     };
 
     lsp = {
-      enable = mkEnableOption "kotlin LSP support (kotlin_language_server)" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "Kotlin LSP support (kotlin_language_server)" // {default = config.vim.languages.enableLSP;};
 
       package = mkOption {
         description = "kotlin_language_server package with Kotlin runtime";
@@ -45,6 +62,16 @@ in {
         default = kotlinLspWithRuntime;
       };
     };
+
+    extraDiagnostics = {
+      enable = mkEnableOption "extra Kotlin diagnostics" // {default = config.vim.languages.enableExtraDiagnostics;};
+
+      types = diagnostics {
+        langDesc = "Kotlin";
+        inherit diagnosticsProviders;
+        inherit defaultDiagnosticsProvider;
+      };
+    };
   };
   config = mkIf cfg.enable (mkMerge [
     (mkIf cfg.treesitter.enable {
@@ -52,6 +79,15 @@ in {
       vim.treesitter.grammars = [cfg.treesitter.package];
     })
 
+    (mkIf cfg.extraDiagnostics.enable {
+      vim.lsp.null-ls.enable = true;
+      vim.lsp.null-ls.sources = diagnosticsToLua {
+        lang = "ts";
+        config = cfg.extraDiagnostics.types;
+        inherit diagnosticsProviders;
+      };
+    })
+
     (mkIf cfg.lsp.enable {
       vim.lsp.lspconfig.enable = true;
       vim.lsp.lspconfig.sources.kotlin_language_server = ''
@@ -61,7 +97,7 @@ in {
           on_attach=default_on_attach,
           init_options = {
           -- speeds up the startup time for the LSP
-            storagePath = "vim.fn.stdpath('state') .. '/kotlin'",
+            storagePath = vim.fn.stdpath('state') .. '/kotlin',
           },
           cmd = ${
           if isList cfg.lsp.package

modules/plugins/theme/supported-themes.nix

@@ -4,7 +4,14 @@
 }: let
   inherit (lib.strings) optionalString;
   inherit (lib.trivial) boolToString warnIf;
+  inherit (lib.nvim.lua) toLuaObject;
 in {
+  base16 = {
+    setup = {base16-colors, ...}: ''
+      -- Base16 theme
+      require('base16-colorscheme').setup(${toLuaObject base16-colors})
+    '';
+  };
   onedark = {
     setup = {style ? "dark", ...}: ''
       -- OneDark theme
@@ -20,6 +27,7 @@ in {
     setup = {
       style ? "night",
       transparent,
+      ...
     }: ''
       require('tokyonight').setup {
         transparent = ${boolToString transparent};
@@ -42,6 +50,7 @@ in {
     setup = {
       style ? "mocha",
       transparent ? false,
+      ...
     }: ''
       -- Catppuccin theme
       require('catppuccin').setup {

modules/plugins/theme/theme.nix

@@ -4,32 +4,51 @@
   ...
 }: let
   inherit (lib.options) mkOption;
-  inherit (lib.attrsets) attrNames;
+  inherit (lib.attrsets) attrNames listToAttrs;
+  inherit (lib.strings) hasPrefix;
   inherit (lib.types) bool lines enum;
   inherit (lib.modules) mkIf;
   inherit (lib.nvim.dag) entryBefore;
+  inherit (lib.nvim.types) hexColor;
 
   cfg = config.vim.theme;
   supportedThemes = import ./supported-themes.nix {
     inherit lib config;
   };
+
+  numbers = ["0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F"];
+  base16Options = listToAttrs (map (n: {
+      name = "base0${n}";
+      value = mkOption {
+        description = "The base0${n} color to use";
+        type = hexColor;
+        apply = v:
+          if hasPrefix "#" v
+          then v
+          else "#${v}";
+      };
+    })
+    numbers);
 in {
   options.vim.theme = {
     enable = mkOption {
       type = bool;
       description = "Enable theming";
     };
-
     name = mkOption {
       type = enum (attrNames supportedThemes);
-      description = "Supported themes can be found in `supportedThemes.nix`";
+      description = ''
+        Supported themes can be found in {file}`supportedThemes.nix`.
+        Setting the theme to "base16" enables base16 theming and
+        requires all of the colors in {option}`vim.theme.base16-colors` to be set.
+      '';
     };
+    base16-colors = base16Options;
 
     style = mkOption {
       type = enum supportedThemes.${cfg.name}.styles;
       description = "Specific style for theme if it supports it";
     };
-
     transparent = mkOption {
       type = bool;
       default = false;
@@ -47,7 +66,7 @@ in {
       startPlugins = [cfg.name];
       luaConfigRC.theme = entryBefore ["pluginConfigs"] ''
         ${cfg.extraConfig}
-        ${supportedThemes.${cfg.name}.setup {inherit (cfg) style transparent;}}
+        ${supportedThemes.${cfg.name}.setup {inherit (cfg) style transparent base16-colors;}}
       '';
     };
   };

modules/plugins/utility/surround/config.nix

@@ -3,42 +3,29 @@
   lib,
   ...
 }: let
-  inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.binds) addDescriptionsToMappings mkSetBinding;
+  inherit (lib.modules) mkIf;
   inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.nvim.lua) toLuaObject;
 
   cfg = config.vim.utility.surround;
-  self = import ./surround.nix {inherit lib config;};
-  mappingDefinitions = self.options.vim.utility.surround.mappings;
-  mappings = addDescriptionsToMappings cfg.mappings mappingDefinitions;
 in {
   config = mkIf cfg.enable {
     vim = {
-      startPlugins = [
-        "nvim-surround"
-      ];
+      startPlugins = ["nvim-surround"];
+      pluginRC.surround = entryAnywhere "require('nvim-surround').setup(${toLuaObject cfg.setupOpts})";
 
-      pluginRC.surround = entryAnywhere ''
-        require('nvim-surround').setup()
-      '';
-
-      maps = {
-        insert = mkMerge [
-          (mkIf (mappings.insert != null) (mkSetBinding mappings.insert "<Plug>(nvim-surround-insert)"))
-          (mkIf (mappings.insertLine != null) (mkSetBinding mappings.insertLine "<Plug>(nvim-surround-insert-line)"))
-        ];
-        normal = mkMerge [
-          (mkIf (mappings.normal != null) (mkSetBinding mappings.normal "<Plug>(nvim-surround-normal)"))
-          (mkIf (mappings.normalCur != null) (mkSetBinding mappings.normalCur "<Plug>(nvim-surround-normal-cur)"))
-          (mkIf (mappings.normalLine != null) (mkSetBinding mappings.normalLine "<Plug>(nvim-surround-normal-line)"))
-          (mkIf (mappings.normalCurLine != null) (mkSetBinding mappings.normalCurLine "<Plug>(nvim-surround-normal-cur-line)"))
-          (mkIf (mappings.delete != null) (mkSetBinding mappings.delete "<Plug>(nvim-surround-delete)"))
-          (mkIf (mappings.change != null) (mkSetBinding mappings.change "<Plug>(nvim-surround-change)"))
-        ];
-        visualOnly = mkMerge [
-          (mkIf (mappings.visual != null) (mkSetBinding mappings.visual "<Plug>(nvim-surround-visual)"))
-          (mkIf (mappings.visualLine != null) (mkSetBinding mappings.visualLine "<Plug>(nvim-surround-visual-line)"))
-        ];
+      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";
       };
     };
   };

modules/plugins/utility/surround/surround.nix

@@ -1,90 +1,24 @@
-{
-  lib,
-  config,
-  ...
-}: let
-  inherit (lib.modules) mkIf mkDefault;
+{lib, ...}: let
   inherit (lib.options) mkOption;
-  inherit (lib.types) bool nullOr str;
+  inherit (lib.types) bool;
+  inherit (lib.nvim.types) mkPluginSetupOption;
 in {
   options.vim.utility.surround = {
     enable = mkOption {
       type = bool;
       default = false;
-      description = "nvim-surround: add/change/delete surrounding delimiter pairs with ease. Note that the default mappings deviate from upstreeam to avoid conflicts with nvim-leap.";
+      description = ''
+        nvim-surround: add/change/delete surrounding delimiter pairs with ease.
+        Note that the default mappings deviate from upstreeam to avoid conflicts
+        with nvim-leap.
+      '';
     };
+    setupOpts = mkPluginSetupOption "nvim-surround" {};
+
     useVendoredKeybindings = mkOption {
       type = bool;
       default = true;
       description = "Use alternative set of keybindings that avoids conflicts with other popular plugins, e.g. nvim-leap";
     };
-    mappings = {
-      insert = mkOption {
-        type = nullOr str;
-        default = "<C-g>z";
-        description = "Add surround character around the cursor";
-      };
-      insertLine = mkOption {
-        type = nullOr str;
-        default = "<C-g>Z";
-        description = "Add surround character around the cursor on new lines";
-      };
-      normal = mkOption {
-        type = nullOr str;
-        default = "gz";
-        description = "Surround motion with character";
-      };
-      normalCur = mkOption {
-        type = nullOr str;
-        default = "gZ";
-        description = "Surround motion with character on new lines";
-      };
-      normalLine = mkOption {
-        type = nullOr str;
-        default = "gzz";
-        description = "Surround line with character";
-      };
-      normalCurLine = mkOption {
-        type = nullOr str;
-        default = "gZZ";
-        description = "Surround line with character on new lines";
-      };
-      visual = mkOption {
-        type = nullOr str;
-        default = "gz";
-        description = "Surround selection with character";
-      };
-      visualLine = mkOption {
-        type = nullOr str;
-        default = "gZ";
-        description = "Surround selection with character on new lines";
-      };
-      delete = mkOption {
-        type = nullOr str;
-        default = "gzd";
-        description = "Delete surrounding character";
-      };
-      change = mkOption {
-        type = nullOr str;
-        default = "gzr";
-        description = "Change surrounding character";
-      };
-    };
-  };
-  config.vim.utility.surround = let
-    cfg = config.vim.utility.surround;
-  in {
-    mappings = mkIf (! cfg.useVendoredKeybindings) (mkDefault {
-      insert = null;
-      insertLine = null;
-      normal = null;
-      normalCur = null;
-      normalLine = null;
-      normalCurLine = null;
-      visual = null;
-      visualLine = null;
-      delete = null;
-      change = null;
-    });
   };
 }

modules/wrapper/rc/config.nix

@@ -4,80 +4,14 @@
   ...
 }: let
   inherit (builtins) map mapAttrs filter;
-  inherit (lib.options) mkOption;
-  inherit (lib.attrsets) mapAttrsToList filterAttrs getAttrs attrValues attrNames;
+  inherit (lib.attrsets) mapAttrsToList filterAttrs;
   inherit (lib.strings) concatLines concatMapStringsSep;
   inherit (lib.trivial) showWarnings;
-  inherit (lib.types) str nullOr;
   inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.dag) entryAfter mkLuarcSection resolveDag entryAnywhere;
   inherit (lib.nvim.lua) toLuaObject;
-  inherit (lib.nvim.config) mkBool;
 
   cfg = config.vim;
-
-  # Most of the keybindings code is highly inspired by pta2002/nixvim.
-  # Thank you!
-  mapConfigOptions = {
-    silent =
-      mkBool false
-      "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.";
-
-    desc = mkOption {
-      type = nullOr str;
-      default = null;
-      description = "A description of this keybind, to be shown in which-key, if you have it enabled.";
-    };
-  };
-
-  genMaps = mode: maps: let
-    /*
-    Take a user-defined action (string or attrs) and return the following attribute set:
-    {
-      action = (string) the actual action to map to this key
-      config = (attrs) the configuration options for this mapping (noremap, silent...)
-    }
-    */
-    normalizeAction = action: {
-      # Extract the values of the config options that have been explicitly set by the user
-      config =
-        filterAttrs (_: v: v != null)
-        (getAttrs (attrNames mapConfigOptions) action);
-      action =
-        if action.lua
-        then mkLuaInline action.action
-        else action.action;
-    };
-  in
-    attrValues (mapAttrs
-      (key: action: let
-        normalizedAction = normalizeAction action;
-      in {
-        inherit (normalizedAction) action config;
-        inherit key;
-        inherit mode;
-      })
-      maps);
 in {
   config = let
     globalsScript =
@@ -98,38 +32,18 @@ in {
       mapResult = result: concatLines (map mkLuarcSection result);
     };
 
-    toLuaBindings = mode: maps:
-      map (value: ''
-        vim.keymap.set(${toLuaObject mode}, ${toLuaObject value.key}, ${toLuaObject value.action}, ${toLuaObject value.config})
-      '') (genMaps mode maps);
+    getAction = keymap:
+      if keymap.lua
+      then mkLuaInline keymap.action
+      else keymap.action;
 
-    # I'm not sure if every one of these will work.
-    allmap = toLuaBindings "" config.vim.maps.normalVisualOp;
-    nmap = toLuaBindings "n" config.vim.maps.normal;
-    vmap = toLuaBindings "v" config.vim.maps.visual;
-    xmap = toLuaBindings "x" config.vim.maps.visualOnly;
-    smap = toLuaBindings "s" config.vim.maps.select;
-    imap = toLuaBindings "i" config.vim.maps.insert;
-    cmap = toLuaBindings "c" config.vim.maps.command;
-    tmap = toLuaBindings "t" config.vim.maps.terminal;
-    lmap = toLuaBindings "l" config.vim.maps.lang;
-    omap = toLuaBindings "o" config.vim.maps.operator;
-    icmap = toLuaBindings "ic" config.vim.maps.insertCommand;
+    getOpts = keymap: {
+      inherit (keymap) desc silent nowait script expr unique noremap;
+    };
 
-    maps = [
-      nmap
-      imap
-      vmap
-      xmap
-      smap
-      cmap
-      omap
-      tmap
-      lmap
-      icmap
-      allmap
-    ];
-    mappings = concatLines (map concatLines maps);
+    toLuaKeymap = bind: "vim.keymap.set(${toLuaObject bind.mode}, ${toLuaObject bind.key}, ${toLuaObject (getAction bind)}, ${toLuaObject (getOpts bind)})";
+
+    keymaps = concatLines (map toLuaKeymap cfg.keymaps);
   in {
     vim = {
       luaConfigRC = {
@@ -140,7 +54,7 @@ in {
         # Basic
         pluginConfigs = entryAfter ["optionsScript"] pluginConfigs;
         extraPluginConfigs = entryAfter ["pluginConfigs"] extraPluginConfigs;
-        mappings = entryAfter ["extraPluginConfigs"] mappings;
+        mappings = entryAfter ["extraPluginConfigs"] keymaps;
       };
 
       builtLuaConfigRC = let