kotlin: changelog update

merge

.github/README.md

@@ -124,16 +124,10 @@ The _recommended_ way of installing **nvf** is using either the NixOS or the
 Home-Manager module, though it is completely possible and no less supported to
 install **nvf** as a standalone package, or a flake output.
 
-See the rendered [nvf manual] for detailed and up-to-date installation guides,
+See the [**nvf** manual] for detailed and up-to-date installation guides,
 configurations, available options, release notes and more. Tips for installing
 userspace plugins is also contained in the documentation.
 
-> [!TIP]
-> While using NixOS or Home-Manager modules,
-> `programs.nvf.enableManpages = true;` will allow you to view option
-> documentation from the comfort of your terminal via `man 5 nvf`. The more you
-> know.
-
 Please create an issue on the [issue tracker] if you find the documentation
 lacking or confusing. Any improvements to the documentation through pull
 requests are also welcome, and appreciated.

.github/pull_request_template.md

@@ -1,57 +1,39 @@
-<!--
-^ Please include a clear and concise description of the aim of your Pull Request above this line ^
+# Description
 
-For plugin dependency/module additions, please make sure to link the source link of the added plugin
-or dependency in this section.
+A clear and concise description of the aim of your Pull Request.
 
-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.
--->
+**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)
 
-## Sanity Checking
+## Type of change
 
-<!--
-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.
+Please delete any options that are not relevant.
 
-If your pull request includes any change or unexpected behaviour not covered below, please do make sure to include
-it above in your description.
--->
+- 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
 
-[editorconfig]: https://editorconfig.org
-[changelog]: https://github.com/NotAShelf/nvf/tree/main/docs/release-notes
+## Checklist
 
-- [ ] 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`
+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.
 
-<!--
-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.
--->
+- [ ] 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.
 
----
+## Screenshots & Logs
 
-Add a :+1: [reaction] to [pull requests you find important].
+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/).
 
-[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
+**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
+```

docs/manual/hacking/keybinds.md

@@ -7,26 +7,37 @@ 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.keymaps`.
+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
 
 An example, simple keybinding, can look like this:
 
 ```nix
 {
-  vim.keymaps = [
-    {
-      key = "<leader>wq";
-      mode = ["n"];
+  vim.maps.normal = {
+    "<leader>wq" = {
       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.keymaps)
+[documentation](https://notashelf.github.io/nvf/options.html#opt-vim.maps.command._name_.action)
 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,32 +26,6 @@ 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,
@@ -106,17 +80,13 @@ everyone.
 
 [ocaml-lsp]: https://github.com/ocaml/ocaml-lsp
 [new-file-template.nvim]: https://github.com/otavioschwanck/new-file-template.nvim
-[neo-tree.nvim]: https://github.com/nvim-neo-tree/neo-tree.nvim
 
 - Add [ocaml-lsp] support
 
 - Fix "Emac" typo
 
 - 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`
+  templates.
 
 [diniamo](https://github.com/diniamo):
 
@@ -150,15 +120,10 @@ 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.
@@ -167,8 +132,6 @@ 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
@@ -230,26 +193,15 @@ everyone.
 - Add [](#opt-vim.dashboard.dashboard-nvim.setupOpts) to allow user
   configuration for [dashboard.nvim](https://github.com/nvimdev/dashboard-nvim)
 
-- Update `lualine.nvim` input and add missing themes:
-  - Adds `ayu`, `gruvbox_dark`, `iceberg`, `moonfly`, `onedark`,
-    `powerline_dark` and `solarized_light` themes.
-
 [ppenguin](https://github.com/ppenguin):
 
 - Telescope:
   - 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, 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.
+- Add LSP and Treesitter support for Kotlin under `vim.languages.kotlin`

flake.lock

@@ -172,22 +172,6 @@
         "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": {
@@ -207,11 +191,11 @@
     "plugin-catppuccin": {
       "flake": false,
       "locked": {
-        "lastModified": 1728131011,
-        "narHash": "sha256-j6F078taxuGzr3jngrc+Pc5I1kDdxTLMETgq6Xn4w/4=",
+        "lastModified": 1716704960,
+        "narHash": "sha256-UDPS+1o8FQGkfqiG4GX4DNUI2pU5hIvagmfnWTKDb44=",
         "owner": "catppuccin",
         "repo": "nvim",
-        "rev": "7be452ee067978cdc8b2c5f3411f0c71ffa612b9",
+        "rev": "5215ea59df6d0a7e27da9a5cd1165e06d1b04cbe",
         "type": "github"
       },
       "original": {
@@ -815,11 +799,11 @@
     "plugin-lualine": {
       "flake": false,
       "locked": {
-        "lastModified": 1723473562,
-        "narHash": "sha256-gCm7m96PkZyrgjmt7Efc+NMZKStAq1zr7JRCYOgGDuE=",
+        "lastModified": 1712310396,
+        "narHash": "sha256-WcH2dWdRDgMkwBQhcgT+Z/ArMdm+VbRhmQftx4t2kNI=",
         "owner": "hoob3rt",
         "repo": "lualine.nvim",
-        "rev": "b431d228b7bbcdaea818bdc3e25b8cdbe861f056",
+        "rev": "0a5a66803c7407767b799067986b4dc3036e1983",
         "type": "github"
       },
       "original": {
@@ -1818,7 +1802,6 @@
         "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,11 +349,6 @@
     };
 
     # Themes
-    plugin-base16 = {
-      url = "github:rrethy/base16-nvim";
-      flake = false;
-    };
-
     plugin-tokyonight = {
       url = "github:folke/tokyonight.nvim";
       flake = false;

lib/types/custom.nix

@@ -1,9 +1,8 @@
 {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 match;
+  inherit (builtins) typeOf isAttrs any head concatLists stringLength;
 in {
   # HACK: Does this break anything in our case?
   # A modified version of the nixpkgs anything type that concatenates lists
@@ -59,11 +58,4 @@ 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;
-  };
 }

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;};
-  typesTypes = import ./types.nix {inherit lib;};
+  typesCustom = import ./custom.nix {inherit lib;};
 in {
   inherit (typesDag) dagOf;
   inherit (typesPlugin) pluginsOpt extraPluginType mkPluginSetupOption luaInline pluginType borderType;
   inherit (typesLanguage) diagnostics mkGrammarOption;
-  inherit (typesTypes) anythingConcatLists char hexColor;
+  inherit (typesCustom) anythingConcatLists char;
 }

lib/types/plugins.nix

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

modules/neovim/mappings/config.nix

@@ -3,75 +3,51 @@
   lib,
   ...
 }: let
-  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"];
-  };
+  inherit (lib.modules) mkIf;
 
   cfg = config.vim;
 in {
   config = {
-    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
-        ]
-      )
-    ];
+    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;
+        };
+      };
+    };
   };
 }

modules/neovim/mappings/options.nix

@@ -1,97 +1,101 @@
 {lib, ...}: let
-  inherit (lib.options) mkOption literalMD;
-  inherit (lib.types) either str listOf attrsOf nullOr submodule;
+  inherit (lib.options) mkOption;
+  inherit (lib.types) bool str 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.";
   };
 
-  mapType = submodule {
+  mapOption = submodule {
     options =
       mapConfigOptions
       // {
-        key = mkOption {
+        action = mkOption {
           type = str;
-          description = "The key that triggers this keybind.";
+          description = "The action to execute.";
         };
-        mode = mkOption {
-          type = either str (listOf str);
-          description = ''
-            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.
+        lua = mkOption {
+          type = bool;
+          description = ''
+            If true, `action` is considered to be lua code.
+            Thus, it will not be wrapped in `""`.
           '';
-          example = literalMD ''`["n" "v" "c"]` for normal, visual and command mode'';
+          default = false;
         };
       };
   };
 
-  legacyMapOption = mode:
+  mapOptions = mode:
     mkOption {
       description = "Mappings for ${mode} mode";
-      type = attrsOf (submodule {
-        options = mapConfigOptions;
-      });
+      type = attrsOf mapOption;
       default = {};
     };
 in {
   options.vim = {
-    keymaps = mkOption {
-      type = listOf mapType;
-      description = "Custom keybindings.";
-      example = ''
-        vim.keymaps = [
-          {
-            key = "<leader>m";
-            mode = "n";
-            silent = true;
-            action = ":make<CR>";
-          }
-          {
-            key = "<leader>l";
-            mode = ["n" "x"];
-            silent = true;
-            action = "<cmd>cnext<CR>";
-          }
-        ];
-      '';
+    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.
 
-    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')";
+        For plain maps (e.g. just 'map' or 'remap') use `maps.normalVisualOp`.
+      '';
 
-      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";
+      example = ''
+        maps = {
+          normal."<leader>m" = {
+            silent = true;
+            action = "<cmd>make<CR>";
+          }; # Same as nnoremap <leader>m <silent> <cmd>make<CR>
+        };
+      '';
     };
   };
 }

modules/plugins/filetree/neo-tree/config.nix

@@ -20,8 +20,6 @@ in {
         "neo-tree-nvim"
       ];
 
-      visuals.nvimWebDevicons.enable = true;
-
       pluginRC.neo-tree = entryAnywhere ''
         require("neo-tree").setup(${toLuaObject cfg.setupOpts})
       '';

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 = require("elixir")
-        local elixirls = require("elixir.elixirls")
+        local elixir-tools = require("elixir")
+        local elixirls = require("elixir-tools.elixirls")
 
         -- disable imperative insstallations of various
         -- elixir related tools installed by elixir-tools
-        elixir.setup {
+        elixir-tools.setup {
           nextls = {
             enable = false -- defaults to false
           },

modules/plugins/languages/kotlin.nix

@@ -6,10 +6,8 @@
 }: 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 diagnostics;
+  inherit (lib.nvim.types) mkGrammarOption;
   inherit (lib.lists) isList;
   inherit (lib.nvim.lua) expToLua;
 
@@ -29,32 +27,17 @@
         --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";
@@ -62,16 +45,6 @@ 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 {
@@ -79,15 +52,6 @@ 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 = ''
@@ -97,7 +61,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/statusline/lualine/lualine.nix

@@ -17,36 +17,29 @@
     "ayu_dark"
     "ayu_light"
     "ayu_mirage"
-    "ayu"
     "codedark"
     "dracula"
     "everforest"
     "gruvbox"
-    "gruvbox_dark"
     "gruvbox_light"
     "gruvbox_material"
     "horizon"
     "iceberg_dark"
     "iceberg_light"
-    "iceberg"
     "jellybeans"
     "material"
     "modus_vivendi"
     "molokai"
-    "moonfly"
     "nightfly"
     "nord"
     "oceanicnext"
-    "onedark"
     "onelight"
     "palenight"
     "papercolor_dark"
     "papercolor_light"
-    "powerline_dark"
     "powerline"
     "seoul256"
     "solarized_dark"
-    "solarized_light"
     "tomorrow"
     "wombat"
   ];

modules/plugins/theme/supported-themes.nix

@@ -4,14 +4,7 @@
 }: 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
@@ -27,7 +20,6 @@ in {
     setup = {
       style ? "night",
       transparent,
-      ...
     }: ''
       require('tokyonight').setup {
         transparent = ${boolToString transparent};
@@ -50,7 +42,6 @@ in {
     setup = {
       style ? "mocha",
       transparent ? false,
-      ...
     }: ''
       -- Catppuccin theme
       require('catppuccin').setup {
@@ -78,7 +69,7 @@ in {
           notify = true, -- nvim-notify
           which_key = true,
           navic = {
-            enabled = true,
+            enabled = false,
             custom_bg = "NONE", -- "lualine" will set background to mantle
           },
         },

modules/plugins/theme/theme.nix

@@ -4,51 +4,32 @@
   ...
 }: let
   inherit (lib.options) mkOption;
-  inherit (lib.attrsets) attrNames listToAttrs;
-  inherit (lib.strings) hasPrefix;
+  inherit (lib.attrsets) attrNames;
   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 {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.
-      '';
+      description = "Supported themes can be found in `supportedThemes.nix`";
     };
-    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;
@@ -66,7 +47,7 @@ in {
       startPlugins = [cfg.name];
       luaConfigRC.theme = entryBefore ["pluginConfigs"] ''
         ${cfg.extraConfig}
-        ${supportedThemes.${cfg.name}.setup {inherit (cfg) style transparent base16-colors;}}
+        ${supportedThemes.${cfg.name}.setup {inherit (cfg) style transparent;}}
       '';
     };
   };

modules/plugins/utility/surround/config.nix

@@ -3,29 +3,42 @@
   lib,
   ...
 }: let
-  inherit (lib.modules) mkIf;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.nvim.binds) addDescriptionsToMappings mkSetBinding;
   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"];
-      pluginRC.surround = entryAnywhere "require('nvim-surround').setup(${toLuaObject cfg.setupOpts})";
+      startPlugins = [
+        "nvim-surround"
+      ];
 
-      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";
+      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)"))
+        ];
       };
     };
   };

modules/plugins/utility/surround/surround.nix

@@ -1,24 +1,90 @@
-{lib, ...}: let
+{
+  lib,
+  config,
+  ...
+}: let
+  inherit (lib.modules) mkIf mkDefault;
   inherit (lib.options) mkOption;
-  inherit (lib.types) bool;
-  inherit (lib.nvim.types) mkPluginSetupOption;
+  inherit (lib.types) bool nullOr str;
 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,14 +4,80 @@
   ...
 }: let
   inherit (builtins) map mapAttrs filter;
-  inherit (lib.attrsets) mapAttrsToList filterAttrs;
+  inherit (lib.options) mkOption;
+  inherit (lib.attrsets) mapAttrsToList filterAttrs getAttrs attrValues attrNames;
   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 =
@@ -32,18 +98,38 @@ in {
       mapResult = result: concatLines (map mkLuarcSection result);
     };
 
-    getAction = keymap:
-      if keymap.lua
-      then mkLuaInline keymap.action
-      else keymap.action;
+    toLuaBindings = mode: maps:
+      map (value: ''
+        vim.keymap.set(${toLuaObject mode}, ${toLuaObject value.key}, ${toLuaObject value.action}, ${toLuaObject value.config})
+      '') (genMaps mode maps);
 
-    getOpts = keymap: {
-      inherit (keymap) desc silent nowait script expr unique noremap;
-    };
+    # 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;
 
-    toLuaKeymap = bind: "vim.keymap.set(${toLuaObject bind.mode}, ${toLuaObject bind.key}, ${toLuaObject (getAction bind)}, ${toLuaObject (getOpts bind)})";
-
-    keymaps = concatLines (map toLuaKeymap cfg.keymaps);
+    maps = [
+      nmap
+      imap
+      vmap
+      xmap
+      smap
+      cmap
+      omap
+      tmap
+      lmap
+      icmap
+      allmap
+    ];
+    mappings = concatLines (map concatLines maps);
   in {
     vim = {
       luaConfigRC = {
@@ -54,7 +140,7 @@ in {
         # Basic
         pluginConfigs = entryAfter ["optionsScript"] pluginConfigs;
         extraPluginConfigs = entryAfter ["pluginConfigs"] extraPluginConfigs;
-        mappings = entryAfter ["extraPluginConfigs"] keymaps;
+        mappings = entryAfter ["extraPluginConfigs"] mappings;
       };
 
       builtLuaConfigRC = let