Merge 1166e8aa1d into 8ff50562d7

Merge branch 'main' into v0.7
Merge pull request #428 from diniamo/add-csharp
2024-11-26 23:16:46 +00:00 · 2024-11-01 23:07:21 +00:00 · 2024-11-01 23:07:19 +00:00 · 2024-10-28 12:56:53 +00:00 · 2024-10-27 14:35:17 +01:00 · 2024-10-27 14:31:13 +01:00
56 changed files with 1549 additions and 899 deletions
--- a/configuration.nix
+++ b/configuration.nix
@ -51,6 +51,7 @@ isMaximal: {
      css.enable = isMaximal;
      sql.enable = isMaximal;
      java.enable = isMaximal;
+      kotlin.enable = isMaximal;
      ts.enable = isMaximal;
      svelte.enable = isMaximal;
      go.enable = isMaximal;
@ -69,10 +70,12 @@ isMaximal: {
        lsp.server = "clangd";
      };

+      scala.enable = isMaximal;
      rust = {
        enable = isMaximal;
        crates.enable = isMaximal;
      };
+      csharp.enable = isMaximal;
    };

    visuals = {
@ -106,12 +109,10 @@ isMaximal: {
      transparent = false;
    };

-    autopairs.enable = true;
+    autopairs.nvim-autopairs.enable = true;

-    autocomplete = {
-      enable = true;
-      type = "nvim-cmp";
-    };
+    autocomplete.nvim-cmp.enable = true;
+    snippets.luasnip.enable = true;

    filetree = {
      nvimTree = {
@ -174,6 +175,7 @@ isMaximal: {

    notes = {
      obsidian.enable = false; # FIXME: neovim fails to build if obsidian is enabled
+      neorg.enable = false;
      orgmode.enable = false;
      mind-nvim.enable = isMaximal;
      todo-comments.enable = true;
--- a/docs/manual/hacking/keybinds.md
+++ b/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
--- a/docs/release-notes/rl-0.7.md
+++ b/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,
@ -37,6 +63,24 @@ Note that we are looking to add more alternatives in the future like
 dressing.nvim and actions-preview.nvim, in case fastaction doesn't work for
 everyone.

+### `type` based modules removed {#sec-type-based-modules-removed}
+
+As part of the autocompletion rewrite, modules that used to use a `type` option
+have been replaced by per-plugin modules instead. Since both modules only had
+one type, you can simply change
+
+- `vim.autocomplete.*` -> `vim.autocomplete.nvim-cmp.*`
+- `vim.autopairs.enable` -> `vim.autopairs.nvim-autopairs.enable`
+
+### `nixpkgs-fmt` removed in favor of `nixfmt` {#sec-nixpkgs-fmt-deprecation}
+
+`nixpkgs-fmt` has been archived for a while, and it's finally being removed in
+favor of nixfmt (more information can be found
+[here](https://github.com/nix-community/nixpkgs-fmt?tab=readme-ov-file#nixpkgs-fmt---nix-code-formatter-for-nixpkgs).
+
+To migrate to `nixfmt`, simply change `vim.languages.nix.format.type` to
+`nixfmt`.
+
 ## Changelog {#sec-release-0.7-changelog}

 [ItsSorae](https://github.com/ItsSorae):
@ -67,6 +111,9 @@ everyone.
 - Add dap-go for better dap configurations
 - Make noice.nvim customizable
 - Standardize border style options and add custom borders
+- Remove `vim.disableDefaultRuntimePaths` in wrapper options.
+  - As nvf uses `$NVIM_APP_NAME` as of recent changes, we can safely assume any
+    configuration in `$XDG_CONFIG_HOME/nvf` is intentional.

 [rust-tools.nvim]: https://github.com/simrat39/rust-tools.nvim
 [rustaceanvim]: https://github.com/mrcjkb/rustaceanvim
@ -124,10 +171,32 @@ 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`.
+
+- Remove `autopairs.type`, and rename `autopairs.enable` to
+  `autopairs.nvim-autopairs.enable`. The new
+  [](#opt-vim.autopairs.nvim-autopairs.enable) supports `setupOpts` format by
+  default.
+
+- Refactor of `nvim-cmp` and completion related modules
+  - Remove `autocomplete.type` in favor of per-plugin enable options such as
+    [](#opt-vim.autocomplete.nvim-cmp.enable).
+  - Deprecate legacy Vimsnip in favor of Luasnip, and integrate
+    friendly-snippets for bundled snippets. [](#opt-vim.snippets.luasnip.enable)
+    can be used to toggle Luasnip.
+  - Add sorting function options for completion sources under
+    [](#opt-vim.autocomplete.nvim-cmp.setupOpts.sorting.comparators)
+
+- Add C# support under `vim.languages.csharp`, with support for both
+  omnisharp-roslyn and csharp-language-server.
+
 [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.
@ -136,6 +205,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
@ -212,7 +283,28 @@ everyone.
 - 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
+- Fixed typo in Otter's setupOpts
+- Add Neorg support under `vim.notes.neorg`
+- Add LSP, diagnostics, formatter and Treesitter support for Kotlin under
+  `vim.languages.kotlin`
+- changed default keybinds for leap.nvim to avoid altering expected behavior

-[Bloxx12](https://github.com/Bloxx12):
+[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.
+
+[ksonj](https://github.com/ksonj):
+
+- Add LSP support for Scala via
+  [nvim-metals](https://github.com/scalameta/nvim-metals)
+
+[nezia1](https://github.com/nezia1):
+
+- Add [biome](https://github.com/biomejs/biome) support for Typescript, CSS and
+  Svelte. Enable them via [](#opt-vim.languages.ts.format.type),
+  [](#opt-vim.languages.css.format.type) and
+  [](#opt-vim.languages.svelte.format.type) respectively.
+- Replace [nixpkgs-fmt](https://github.com/nix-community/nixpkgs-fmt) with
+  [nixfmt](https://github.com/NixOS/nixfmt) (nixfmt-rfc-style).
--- a/flake.lock
+++ b/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": {
@ -300,6 +316,22 @@
        "type": "github"
      }
    },
+    "plugin-cmp-luasnip": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1696878902,
+        "narHash": "sha256-nUJJl2zyK/oSwz5RzI9j3gf9zpDfCImCYbPbVsyXgz8=",
+        "owner": "saadparwaiz1",
+        "repo": "cmp_luasnip",
+        "rev": "05a9ab28b53f71d1aece421ef32fee2cb857a843",
+        "type": "github"
+      },
+      "original": {
+        "owner": "saadparwaiz1",
+        "repo": "cmp_luasnip",
+        "type": "github"
+      }
+    },
    "plugin-cmp-nvim-lsp": {
      "flake": false,
      "locked": {
@ -348,22 +380,6 @@
        "type": "github"
      }
    },
-    "plugin-cmp-vsnip": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1669100283,
-        "narHash": "sha256-2mkN03noOr5vBvRbSb35xZKorSH+8savQNZtgM9+QcM=",
-        "owner": "hrsh7th",
-        "repo": "cmp-vsnip",
-        "rev": "989a8a73c44e926199bfd05fa7a516d51f2d2752",
-        "type": "github"
-      },
-      "original": {
-        "owner": "hrsh7th",
-        "repo": "cmp-vsnip",
-        "type": "github"
-      }
-    },
    "plugin-codewindow-nvim": {
      "flake": false,
      "locked": {
@ -444,6 +460,22 @@
        "type": "github"
      }
    },
+    "plugin-csharpls-extended": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1728438370,
+        "narHash": "sha256-sOLPV5IhOvQ0+u7CDAfG3X0ZbRCicz18QyYXQ0dxpwQ=",
+        "owner": "Decodetalkers",
+        "repo": "csharpls-extended-lsp.nvim",
+        "rev": "b647e1bd1f9c0410f5ef4a1517a331cbac322d9a",
+        "type": "github"
+      },
+      "original": {
+        "owner": "Decodetalkers",
+        "repo": "csharpls-extended-lsp.nvim",
+        "type": "github"
+      }
+    },
    "plugin-dashboard-nvim": {
      "flake": false,
      "locked": {
@ -572,6 +604,22 @@
        "type": "github"
      }
    },
+    "plugin-friendly-snippets": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1727061933,
+        "narHash": "sha256-yTsuV5unoujY0mhLINssYYBWCeefe+nJaxQHJKm7hlk=",
+        "owner": "rafamadriz",
+        "repo": "friendly-snippets",
+        "rev": "00ba9dd3df89509f95437b8d595553707c46d5ea",
+        "type": "github"
+      },
+      "original": {
+        "owner": "rafamadriz",
+        "repo": "friendly-snippets",
+        "type": "github"
+      }
+    },
    "plugin-gesture-nvim": {
      "flake": false,
      "locked": {
@ -796,6 +844,22 @@
        "type": "github"
      }
    },
+    "plugin-lua-utils-nvim": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1708177208,
+        "narHash": "sha256-9ildzQEMkXKZ3LHq+khGFgRQFxlIXQclQ7QU3fcU1C4=",
+        "owner": "nvim-neorg",
+        "repo": "lua-utils.nvim",
+        "rev": "e565749421f4bbb5d2e85e37c3cef9d56553d8bd",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nvim-neorg",
+        "repo": "lua-utils.nvim",
+        "type": "github"
+      }
+    },
    "plugin-lualine": {
      "flake": false,
      "locked": {
@ -812,6 +876,22 @@
        "type": "github"
      }
    },
+    "plugin-luasnip": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1726165831,
+        "narHash": "sha256-nkaa1NGOI28Et2QitQB+Spv+J42QVdHE1oywteLcJJw=",
+        "owner": "L3MON4D3",
+        "repo": "LuaSnip",
+        "rev": "e808bee352d1a6fcf902ca1a71cee76e60e24071",
+        "type": "github"
+      },
+      "original": {
+        "owner": "L3MON4D3",
+        "repo": "LuaSnip",
+        "type": "github"
+      }
+    },
    "plugin-mind-nvim": {
      "flake": false,
      "locked": {
@ -908,6 +988,38 @@
        "type": "github"
      }
    },
+    "plugin-neorg": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1727821831,
+        "narHash": "sha256-yfWQ6yKytu1jkWUtRZTVICslUWej6jVYv7frmSB7/6Q=",
+        "owner": "nvim-neorg",
+        "repo": "neorg",
+        "rev": "afc9a37bf021acb0853e95714c4c6436e1588286",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nvim-neorg",
+        "repo": "neorg",
+        "type": "github"
+      }
+    },
+    "plugin-neorg-telescope": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1722358034,
+        "narHash": "sha256-ei4uUqpIQjGKzu5ryu0Hlmis9TS9FJsYnjt4J4QdWlw=",
+        "owner": "nvim-neorg",
+        "repo": "neorg-telescope",
+        "rev": "ddb2556644cae922699a239bbb0fe16e25b084b7",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nvim-neorg",
+        "repo": "neorg-telescope",
+        "type": "github"
+      }
+    },
    "plugin-new-file-template-nvim": {
      "flake": false,
      "locked": {
@ -1149,6 +1261,22 @@
        "type": "github"
      }
    },
+    "plugin-nvim-metals": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1728295172,
+        "narHash": "sha256-ja/+MNxZ3H9io9jDwm5rhE6iKNi86a22eCOY75g19O8=",
+        "owner": "scalameta",
+        "repo": "nvim-metals",
+        "rev": "f861db9fda55939797ac1b05238c49b0dcdc3bdb",
+        "type": "github"
+      },
+      "original": {
+        "owner": "scalameta",
+        "repo": "nvim-metals",
+        "type": "github"
+      }
+    },
    "plugin-nvim-navbuddy": {
      "flake": false,
      "locked": {
@ -1341,6 +1469,22 @@
        "type": "github"
      }
    },
+    "plugin-omnisharp-extended": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1719701797,
+        "narHash": "sha256-P1ZCaW8w+e3H3oBhbEjDc7vuR+XuxJmb/7IbPL3KWi4=",
+        "owner": "Hoffs",
+        "repo": "omnisharp-extended-lsp.nvim",
+        "rev": "aad7bf06b4ca0de816b919d475a75b30f5f62b61",
+        "type": "github"
+      },
+      "original": {
+        "owner": "Hoffs",
+        "repo": "omnisharp-extended-lsp.nvim",
+        "type": "github"
+      }
+    },
    "plugin-onedark": {
      "flake": false,
      "locked": {
@ -1405,6 +1549,22 @@
        "type": "github"
      }
    },
+    "plugin-pathlib-nvim": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1724943804,
+        "narHash": "sha256-YhCJeNKlcjgg3q51UWFhuIEPzNueC8YTpeuPPJDndvw=",
+        "owner": "pysan3",
+        "repo": "pathlib.nvim",
+        "rev": "57e5598af6fe253761c1b48e0b59b7cd6699e2c1",
+        "type": "github"
+      },
+      "original": {
+        "owner": "pysan3",
+        "repo": "pathlib.nvim",
+        "type": "github"
+      }
+    },
    "plugin-plenary-nvim": {
      "flake": false,
      "locked": {
@ -1741,22 +1901,6 @@
        "type": "github"
      }
    },
-    "plugin-vim-vsnip": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1704937299,
-        "narHash": "sha256-gvm6z4pgSULBVPukewRyjwxZ0vZgreQWbG/0kOB1QBo=",
-        "owner": "hrsh7th",
-        "repo": "vim-vsnip",
-        "rev": "02a8e79295c9733434aab4e0e2b8c4b7cea9f3a9",
-        "type": "github"
-      },
-      "original": {
-        "owner": "hrsh7th",
-        "repo": "vim-vsnip",
-        "type": "github"
-      }
-    },
    "plugin-which-key": {
      "flake": false,
      "locked": {
@ -1802,6 +1946,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",
@ -1810,15 +1955,16 @@
        "plugin-cheatsheet-nvim": "plugin-cheatsheet-nvim",
        "plugin-cinnamon-nvim": "plugin-cinnamon-nvim",
        "plugin-cmp-buffer": "plugin-cmp-buffer",
+        "plugin-cmp-luasnip": "plugin-cmp-luasnip",
        "plugin-cmp-nvim-lsp": "plugin-cmp-nvim-lsp",
        "plugin-cmp-path": "plugin-cmp-path",
        "plugin-cmp-treesitter": "plugin-cmp-treesitter",
-        "plugin-cmp-vsnip": "plugin-cmp-vsnip",
        "plugin-codewindow-nvim": "plugin-codewindow-nvim",
        "plugin-comment-nvim": "plugin-comment-nvim",
        "plugin-copilot-cmp": "plugin-copilot-cmp",
        "plugin-copilot-lua": "plugin-copilot-lua",
        "plugin-crates-nvim": "plugin-crates-nvim",
+        "plugin-csharpls-extended": "plugin-csharpls-extended",
        "plugin-dashboard-nvim": "plugin-dashboard-nvim",
        "plugin-diffview-nvim": "plugin-diffview-nvim",
        "plugin-dracula": "plugin-dracula",
@ -1827,6 +1973,7 @@
        "plugin-fastaction-nvim": "plugin-fastaction-nvim",
        "plugin-fidget-nvim": "plugin-fidget-nvim",
        "plugin-flutter-tools": "plugin-flutter-tools",
+        "plugin-friendly-snippets": "plugin-friendly-snippets",
        "plugin-gesture-nvim": "plugin-gesture-nvim",
        "plugin-gitsigns-nvim": "plugin-gitsigns-nvim",
        "plugin-glow-nvim": "plugin-glow-nvim",
@ -1841,13 +1988,17 @@
        "plugin-lsp-signature": "plugin-lsp-signature",
        "plugin-lspkind": "plugin-lspkind",
        "plugin-lspsaga": "plugin-lspsaga",
+        "plugin-lua-utils-nvim": "plugin-lua-utils-nvim",
        "plugin-lualine": "plugin-lualine",
+        "plugin-luasnip": "plugin-luasnip",
        "plugin-mind-nvim": "plugin-mind-nvim",
        "plugin-minimap-vim": "plugin-minimap-vim",
        "plugin-modes-nvim": "plugin-modes-nvim",
        "plugin-neo-tree-nvim": "plugin-neo-tree-nvim",
        "plugin-neocord": "plugin-neocord",
        "plugin-neodev-nvim": "plugin-neodev-nvim",
+        "plugin-neorg": "plugin-neorg",
+        "plugin-neorg-telescope": "plugin-neorg-telescope",
        "plugin-new-file-template-nvim": "plugin-new-file-template-nvim",
        "plugin-noice-nvim": "plugin-noice-nvim",
        "plugin-none-ls": "plugin-none-ls",
@ -1863,6 +2014,7 @@
        "plugin-nvim-docs-view": "plugin-nvim-docs-view",
        "plugin-nvim-lightbulb": "plugin-nvim-lightbulb",
        "plugin-nvim-lspconfig": "plugin-nvim-lspconfig",
+        "plugin-nvim-metals": "plugin-nvim-metals",
        "plugin-nvim-navbuddy": "plugin-nvim-navbuddy",
        "plugin-nvim-navic": "plugin-nvim-navic",
        "plugin-nvim-neoclip": "plugin-nvim-neoclip",
@ -1875,10 +2027,12 @@
        "plugin-nvim-ts-autotag": "plugin-nvim-ts-autotag",
        "plugin-nvim-web-devicons": "plugin-nvim-web-devicons",
        "plugin-obsidian-nvim": "plugin-obsidian-nvim",
+        "plugin-omnisharp-extended": "plugin-omnisharp-extended",
        "plugin-onedark": "plugin-onedark",
        "plugin-orgmode-nvim": "plugin-orgmode-nvim",
        "plugin-otter-nvim": "plugin-otter-nvim",
        "plugin-oxocarbon": "plugin-oxocarbon",
+        "plugin-pathlib-nvim": "plugin-pathlib-nvim",
        "plugin-plenary-nvim": "plugin-plenary-nvim",
        "plugin-project-nvim": "plugin-project-nvim",
        "plugin-registers": "plugin-registers",
@ -1900,7 +2054,6 @@
        "plugin-vim-markdown": "plugin-vim-markdown",
        "plugin-vim-repeat": "plugin-vim-repeat",
        "plugin-vim-startify": "plugin-vim-startify",
-        "plugin-vim-vsnip": "plugin-vim-vsnip",
        "plugin-which-key": "plugin-which-key",
        "rnix-lsp": "rnix-lsp",
        "systems": "systems_2"
--- a/flake.nix
+++ b/flake.nix
@ -206,6 +206,21 @@
      flake = false;
    };

+    plugin-nvim-metals = {
+      url = "github:scalameta/nvim-metals";
+      flake = false;
+    };
+
+    plugin-omnisharp-extended = {
+      url = "github:Hoffs/omnisharp-extended-lsp.nvim";
+      flake = false;
+    };
+
+    plugin-csharpls-extended = {
+      url = "github:Decodetalkers/csharpls-extended-lsp.nvim";
+      flake = false;
+    };
+
    # Copying/Registers
    plugin-registers = {
      url = "github:tversteeg/registers.nvim";
@ -277,11 +292,6 @@
      flake = false;
    };

-    plugin-cmp-vsnip = {
-      url = "github:hrsh7th/cmp-vsnip";
-      flake = false;
-    };
-
    plugin-cmp-path = {
      url = "github:hrsh7th/cmp-path";
      flake = false;
@ -292,9 +302,19 @@
      flake = false;
    };

+    plugin-cmp-luasnip = {
+      url = "github:saadparwaiz1/cmp_luasnip";
+      flake = false;
+    };
+
    # snippets
-    plugin-vim-vsnip = {
-      url = "github:hrsh7th/vim-vsnip";
+    plugin-luasnip = {
+      url = "github:L3MON4D3/LuaSnip";
+      flake = false;
+    };
+
+    plugin-friendly-snippets = {
+      url = "github:rafamadriz/friendly-snippets";
      flake = false;
    };

@ -349,6 +369,11 @@
    };

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

+    plugin-lua-utils-nvim = {
+      url = "github:nvim-neorg/lua-utils.nvim";
+      flake = false;
+    };
+
+    plugin-pathlib-nvim = {
+      url = "github:pysan3/pathlib.nvim";
+      flake = false;
+    };
+
+    plugin-neorg = {
+      url = "github:nvim-neorg/neorg";
+      flake = false;
+    };
+
+    plugin-neorg-telescope = {
+      url = "github:nvim-neorg/neorg-telescope";
+      flake = false;
+    };
+
    plugin-nui-nvim = {
      # (required by noice.nvim)
      url = "github:MunifTanjim/nui.nvim";
--- a/lib/attrsets.nix
+++ b/lib/attrsets.nix
@ -0,0 +1,5 @@
+{lib}: let
+  inherit (builtins) listToAttrs;
+in {
+  mapListToAttrs = f: list: listToAttrs (map f list);
+}
--- a/lib/default.nix
+++ b/lib/default.nix
@ -10,6 +10,7 @@
  dag = import ./dag.nix {inherit lib;};
  languages = import ./languages.nix {inherit lib;};
  lists = import ./lists.nix {inherit lib;};
+  attrsets = import ./attrsets.nix {inherit lib;};
  lua = import ./lua.nix {inherit lib;};
  neovimConfiguration = import ../modules {inherit inputs lib;};
 }
--- a/lib/languages.nix
+++ b/lib/languages.nix
@ -2,8 +2,8 @@
 {lib}: let
  inherit (builtins) isString getAttr;
  inherit (lib.options) mkOption;
-  inherit (lib.attrsets) listToAttrs;
  inherit (lib.types) bool;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
 in {
  # Converts a boolean to a yes/no string. This is used in lots of
  # configuration formats.
@ -12,21 +12,21 @@ in {
    config,
    diagnosticsProviders,
  }:
-    listToAttrs
-    (map (v: let
-        type =
-          if isString v
-          then v
-          else getAttr v.type;
-        package =
-          if isString v
-          then diagnosticsProviders.${type}.package
-          else v.package;
-      in {
-        name = "${lang}-diagnostics-${type}";
-        value = diagnosticsProviders.${type}.nullConfig package;
-      })
-      config);
+    mapListToAttrs
+    (v: let
+      type =
+        if isString v
+        then v
+        else getAttr v.type;
+      package =
+        if isString v
+        then diagnosticsProviders.${type}.package
+        else v.package;
+    in {
+      name = "${lang}-diagnostics-${type}";
+      value = diagnosticsProviders.${type}.nullConfig package;
+    })
+    config;

  mkEnable = desc:
    mkOption {
--- a/lib/types/custom.nix
+++ b/lib/types/custom.nix
@ -1,8 +1,9 @@
 {lib}: let
-  inherit (lib) isStringLike showOption showFiles getFiles mergeOneOption mergeEqualOption mkOptionType;
-  inherit (lib.types) anything attrsOf;
+  inherit (lib.options) showOption showFiles getFiles mergeOneOption mergeEqualOption;
+  inherit (lib.strings) isString isStringLike;
+  inherit (lib.types) anything attrsOf listOf mkOptionType;
  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
@ -51,6 +52,16 @@ in {
        (mergeFunctions.${commonType} or mergeEqualOption) loc defs;
    };

+  mergelessListOf = elemType: let
+    super = listOf elemType;
+  in
+    super
+    // {
+      name = "mergelessListOf";
+      description = "mergeless ${super.description}";
+      merge = mergeEqualOption;
+    };
+
  char = mkOptionType {
    name = "char";
    description = "character";
@ -58,4 +69,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;
+  };
 }
--- a/lib/types/default.nix
+++ b/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;};
+  customTypes = import ./custom.nix {inherit lib;};
 in {
  inherit (typesDag) dagOf;
  inherit (typesPlugin) pluginsOpt extraPluginType mkPluginSetupOption luaInline pluginType borderType;
  inherit (typesLanguage) diagnostics mkGrammarOption;
-  inherit (typesCustom) anythingConcatLists char;
+  inherit (customTypes) anythingConcatLists char hexColor mergelessListOf;
 }
--- a/modules/extra/deprecations.nix
+++ b/modules/extra/deprecations.nix
@ -1,5 +1,5 @@
 {lib, ...}: let
-  inherit (lib.modules) mkRemovedOptionModule;
+  inherit (lib.modules) mkRemovedOptionModule mkRenamedOptionModule;
 in {
  imports = [
    # 2024-06-06
@ -14,5 +14,45 @@ in {
      available under `vim.ui.fastaction` as a replacement. Simply remove everything under
      `vim.lsp.nvimCodeActionMenu`, and set `vim.ui.fastaction.enable` to `true`.
    '')
+
+    (mkRemovedOptionModule ["vim" "autopairs" "enable"] ''
+      vim.autopairs.enable has been removed in favor of per-plugin modules.
+      You can enable nvim-autopairs with vim.autopairs.nvim-autopairs.enable instead.
+    '')
+    (mkRemovedOptionModule ["vim" "autopairs" "type"] ''
+      vim.autopairs.type has been removed in favor of per-plugin modules.
+      You can enable nvim-autopairs with vim.autopairs.nvim-autopairs.enable instead.
+    '')
+    (mkRemovedOptionModule ["vim" "autocomplete" "enable"] ''
+      vim.autocomplete.enable has been removed in favor of per-plugin modules.
+      You can enable nvim-cmp with vim.autocomplete.nvim-cmp.enable instead.
+    '')
+    (mkRemovedOptionModule ["vim" "autocomplete" "type"] ''
+      vim.autocomplete.type has been removed in favor of per-plugin modules.
+      You can enable nvim-cmp with vim.autocomplete.nvim-cmp.enable instead.
+    '')
+    (mkRemovedOptionModule ["vim" "autocomplete" "sources"] ''
+      vim.autocomplete.sources has been removed in favor of per-plugin modules.
+      You can add nvim-cmp sources with vim.autocomplete.nvim-cmp.sources
+      instead.
+    '')
+    (mkRemovedOptionModule ["vim" "snippets" "vsnip" "enable"] ''
+      vim.snippets.vsnip.enable has been removed in favor of the more modern luasnip.
+    '')
+    (mkRenamedOptionModule ["vim" "lsp" "lspkind" "mode"] ["vim" "lsp" "lspkind" "setupOpts" "mode"])
+
+    # 2024-10-14
+    (mkRemovedOptionModule ["vim" "configRC"] ''
+      Please migrate your configRC sections to Neovim's Lua format, and
+      add them to `vim.luaConfigRC`.
+
+      See the v0.7 release notes for more information on why and how to
+      migrate your existing configurations to the new format.
+    '')
+
+    (mkRemovedOptionModule ["vim" "disableDefaultRuntimePaths"] ''
+      Nvf now uses $NVIM_APP_NAME so there is no longer the problem of
+      (accidental) leaking of user configuration.
+    '')
  ];
 }
--- a/modules/neovim/mappings/config.nix
+++ b/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
+        ]
+      )
+    ];
  };
 }
--- a/modules/neovim/mappings/options.nix
+++ b/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";
    };
  };
 }
--- a/modules/plugins/assistant/copilot/config.nix
+++ b/modules/plugins/assistant/copilot/config.nix
@ -34,6 +34,8 @@ in {
        "copilot-cmp"
      ];

+    vim.autocomplete.nvim-cmp.sources = {copilot = "[Copilot]";};
+
    vim.pluginRC.copilot = entryAnywhere ''
      require("copilot").setup(${toLuaObject cfg.setupOpts})

--- a/modules/plugins/autopairs/nvim-autopairs/config.nix
+++ b/modules/plugins/autopairs/nvim-autopairs/config.nix
@ -4,16 +4,17 @@
  ...
 }: let
  inherit (lib.modules) mkIf;
-  inherit (lib.trivial) boolToString;
  inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.nvim.lua) toLuaObject;

-  cfg = config.vim.autopairs;
+  cfg = config.vim.autopairs.nvim-autopairs;
 in {
  config = mkIf cfg.enable {
-    vim.startPlugins = ["nvim-autopairs"];
-
-    vim.pluginRC.autopairs = entryAnywhere ''
-      require("nvim-autopairs").setup({ map_cr = ${boolToString (!config.vim.autocomplete.enable)} })
-    '';
+    vim = {
+      startPlugins = ["nvim-autopairs"];
+      pluginRC.autopairs = entryAnywhere ''
+        require('nvim-autopairs').setup(${toLuaObject cfg.setupOpts})
+      '';
+    };
  };
 }
--- a/modules/plugins/autopairs/nvim-autopairs/nvim-autopairs.nix
+++ b/modules/plugins/autopairs/nvim-autopairs/nvim-autopairs.nix
@ -1,21 +1,14 @@
 {lib, ...}: let
  inherit (lib) mkRemovedOptionModule;
-  inherit (lib.options) mkEnableOption mkOption;
-  inherit (lib.types) enum;
+  inherit (lib.options) mkEnableOption;
+  inherit (lib.nvim.types) mkPluginSetupOption;
 in {
  imports = [
    (mkRemovedOptionModule ["vim" "autopairs" "nvim-compe"] "nvim-compe is deprecated and no longer suported.")
  ];

-  options.vim = {
-    autopairs = {
-      enable = mkEnableOption "autopairs" // {default = false;};
-
-      type = mkOption {
-        type = enum ["nvim-autopairs"];
-        default = "nvim-autopairs";
-        description = "Set the autopairs type. Options: nvim-autopairs [nvim-autopairs]";
-      };
-    };
+  options.vim.autopairs.nvim-autopairs = {
+    enable = mkEnableOption "autopairs";
+    setupOpts = mkPluginSetupOption "nvim-autopairs" {};
  };
 }
--- a/modules/plugins/comments/comment-nvim/config.nix
+++ b/modules/plugins/comments/comment-nvim/config.nix
@ -12,9 +12,7 @@
  inherit (self.options.vim.comments.comment-nvim) mappings;
 in {
  config = mkIf cfg.enable {
-    vim.startPlugins = [
-      "comment-nvim"
-    ];
+    vim.startPlugins = ["comment-nvim"];

    vim.maps.normal = mkMerge [
      (mkBinding cfg.mappings.toggleOpLeaderLine "<Plug>(comment_toggle_linewise)" mappings.toggleOpLeaderLine.description)
@ -36,7 +34,7 @@ in {
        mappings.toggleCurrentBlock.description)
    ];

-    vim.maps.visualOnly = mkMerge [
+    vim.maps.visual = mkMerge [
      (mkBinding cfg.mappings.toggleSelectedLine "<Plug>(comment_toggle_linewise_visual)" mappings.toggleSelectedLine.description)
      (mkBinding cfg.mappings.toggleSelectedBlock "<Plug>(comment_toggle_blockwise_visual)" mappings.toggleSelectedBlock.description)
    ];
--- a/modules/plugins/completion/nvim-cmp/config.nix
+++ b/modules/plugins/completion/nvim-cmp/config.nix
@ -3,246 +3,92 @@
  config,
  ...
 }: let
-  inherit (builtins) toJSON;
-  inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.attrsets) attrNames mapAttrsToList;
-  inherit (lib.strings) concatMapStringsSep concatStringsSep optionalString;
-  inherit (lib.nvim.binds) addDescriptionsToMappings mkSetLuaBinding;
-  inherit (lib.nvim.dag) entryAnywhere entryAfter;
+  inherit (lib.modules) mkIf;
+  inherit (lib.strings) optionalString;
+  inherit (lib.generators) mkLuaInline;
+  inherit (lib.nvim.dag) entryAfter;
+  inherit (lib.nvim.lua) toLuaObject;
+  inherit (builtins) attrNames;

-  cfg = config.vim.autocomplete;
-  lspkindEnabled = config.vim.lsp.enable && config.vim.lsp.lspkind.enable;
-
-  self = import ./nvim-cmp.nix {inherit lib;};
-  mappingDefinitions = self.options.vim.autocomplete.mappings;
-
-  mappings = addDescriptionsToMappings cfg.mappings mappingDefinitions;
-
-  builtSources =
-    concatMapStringsSep
-    "\n"
-    (n: "{ name = '${n}'},")
-    (attrNames cfg.sources);
-
-  builtMaps =
-    concatStringsSep
-    "\n"
-    (mapAttrsToList
-      (n: v:
-        if v == null
-        then ""
-        else "${n} = '${v}',")
-      cfg.sources);
-
-  dagPlacement =
-    if lspkindEnabled
-    then entryAfter ["lspkind"]
-    else entryAnywhere;
+  cfg = config.vim.autocomplete.nvim-cmp;
+  luasnipEnable = config.vim.snippets.luasnip.enable;
+  inherit (cfg) mappings;
 in {
  config = mkIf cfg.enable {
-    vim.startPlugins = [
-      "nvim-cmp"
-      "cmp-buffer"
-      "cmp-vsnip"
-      "cmp-path"
-      "vim-vsnip"
-    ];
+    vim = {
+      startPlugins = [
+        "nvim-cmp"
+        "cmp-buffer"
+        "cmp-path"
+      ];

-    vim.autocomplete.sources = {
-      "nvim-cmp" = null;
-      "vsnip" = "[VSnip]";
-      "buffer" = "[Buffer]";
-      "crates" = "[Crates]";
-      "path" = "[Path]";
-      "copilot" = "[Copilot]";
-    };
+      autocomplete.nvim-cmp.sources = {
+        nvim-cmp = null;
+        buffer = "[Buffer]";
+        path = "[Path]";
+      };

-    vim.maps.insert = mkMerge [
-      (mkSetLuaBinding mappings.complete ''
-        require('cmp').complete
-      '')
-      (let
-        defaultKeys =
-          if config.vim.autopairs.enable
-          then "require('nvim-autopairs').autopairs_cr()"
-          else "vim.api.nvim_replace_termcodes(${toJSON mappings.confirm.value}, true, false, true)";
-      in
-        mkSetLuaBinding mappings.confirm ''
-          function()
-            if not require('cmp').confirm({ select = true }) then
-              vim.fn.feedkeys(${defaultKeys}, 'n')
+      autocomplete.nvim-cmp.setupOpts = {
+        sources = map (s: {name = s;}) (attrNames cfg.sources);
+
+        # TODO: try to get nvim-cmp to follow global border style
+        window = mkIf config.vim.ui.borders.enable {
+          completion = mkLuaInline "cmp.config.window.bordered()";
+          documentation = mkLuaInline "cmp.config.window.bordered()";
+        };
+
+        formatting.format = cfg.format;
+      };
+
+      pluginRC.nvim-cmp = mkIf cfg.enable (entryAfter ["autopairs" "luasnip"] ''
+        ${optionalString luasnipEnable "local luasnip = require('luasnip')"}
+        local cmp = require("cmp")
+        cmp.setup(${toLuaObject cfg.setupOpts})
+      '');
+
+      # `cmp` and `luasnip` are defined above, in the `nvim-cmp` section
+      autocomplete.nvim-cmp.setupOpts.mapping = {
+        ${mappings.complete} = mkLuaInline "cmp.mapping.complete()";
+        ${mappings.close} = mkLuaInline "cmp.mapping.abort()";
+        ${mappings.scrollDocsUp} = mkLuaInline "cmp.mapping.scroll_docs(-4)";
+        ${mappings.scrollDocsDown} = mkLuaInline "cmp.mapping.scroll_docs(4)";
+        ${mappings.confirm} = mkLuaInline "cmp.mapping.confirm({ select = true })";
+
+        ${mappings.next} = mkLuaInline ''
+          cmp.mapping(function(fallback)
+            local has_words_before = function()
+              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
            end
-          end
-        '')
-      (mkSetLuaBinding mappings.next ''
-        function()
-          local has_words_before = function()
-            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
-          end

-          local cmp = require('cmp')
+            if cmp.visible() then
+              cmp.select_next_item()
+              ${optionalString luasnipEnable ''
+            elseif luasnip.locally_jumpable(1) then
+              luasnip.jump(1)
+          ''}
+            elseif has_words_before() then
+              cmp.complete()
+            else
+              fallback()
+            end
+          end)
+        '';

-          local feedkey = function(key, mode)
-            vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes(key, true, true, true), mode, true)
-          end
-
-          if cmp.visible() then
-            cmp.select_next_item()
-          elseif vim.fn['vsnip#available'](1) == 1 then
-            feedkey("<Plug>(vsnip-expand-or-jump)", "")
-          elseif has_words_before() then
-            cmp.complete()
-          else
-            local termcode = vim.api.nvim_replace_termcodes(${toJSON mappings.next.value}, true, false, true)
-
-            vim.fn.feedkeys(termcode, 'n')
-          end
-        end
-      '')
-      (mkSetLuaBinding mappings.previous ''
-        function()
-          local cmp = require('cmp')
-
-          local feedkey = function(key, mode)
-            vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes(key, true, true, true), mode, true)
-          end
-
-          if cmp.visible() then
-            cmp.select_prev_item()
-          elseif vim.fn['vsnip#available'](-1) == 1 then
-            feedkeys("<Plug>(vsnip-jump-prev)", "")
-          end
-        end
-      '')
-      (mkSetLuaBinding mappings.close ''
-        require('cmp').mapping.abort()
-      '')
-      (mkSetLuaBinding mappings.scrollDocsUp ''
-        require('cmp').mapping.scroll_docs(-4)
-      '')
-      (mkSetLuaBinding mappings.scrollDocsDown ''
-        require('cmp').mapping.scroll_docs(4)
-      '')
-    ];
-
-    vim.maps.command = mkMerge [
-      (mkSetLuaBinding mappings.complete ''
-        require('cmp').complete
-      '')
-      (mkSetLuaBinding mappings.close ''
-        require('cmp').mapping.close()
-      '')
-      (mkSetLuaBinding mappings.scrollDocsUp ''
-        require('cmp').mapping.scroll_docs(-4)
-      '')
-      (mkSetLuaBinding mappings.scrollDocsDown ''
-        require('cmp').mapping.scroll_docs(4)
-      '')
-    ];
-
-    vim.maps.select = mkMerge [
-      (mkSetLuaBinding mappings.next ''
-        function()
-          local cmp = require('cmp')
-          local has_words_before = function()
-            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
-          end
-
-          local feedkey = function(key, mode)
-            vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes(key, true, true, true), mode, true)
-          end
-
-          if cmp.visible() then
-            cmp.select_next_item()
-          elseif vim.fn['vsnip#available'](1) == 1 then
-            feedkey("<Plug>(vsnip-expand-or-jump)", "")
-          elseif has_words_before() then
-            cmp.complete()
-          else
-            local termcode = vim.api.nvim_replace_termcodes(${toJSON mappings.next.value}, true, false, true)
-
-            vim.fn.feedkeys(termcode, 'n')
-          end
-        end
-      '')
-      (mkSetLuaBinding mappings.previous ''
-        function()
-          local cmp = require('cmp')
-
-          local feedkey = function(key, mode)
-            vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes(key, true, true, true), mode, true)
-          end
-
-          if cmp.visible() then
-            cmp.select_prev_item()
-          elseif vim.fn['vsnip#available'](-1) == 1 then
-            feedkeys("<Plug>(vsnip-jump-prev)", "")
-          end
-        end
-      '')
-    ];
-
-    # TODO: alternative snippet engines to vsnip
-    # https://github.com/hrsh7th/nvim-cmp/blob/main/doc/cmp.txt#L82
-    vim.pluginRC.completion = mkIf (cfg.type == "nvim-cmp") (dagPlacement ''
-      local nvim_cmp_menu_map = function(entry, vim_item)
-        -- name for each source
-        vim_item.menu = ({
-          ${builtMaps}
-        })[entry.source.name]
-        return vim_item
-      end
-
-      ${optionalString lspkindEnabled ''
-        lspkind_opts.before = ${cfg.formatting.format}
-      ''}
-
-      local cmp = require'cmp'
-      cmp.setup({
-        ${optionalString config.vim.ui.borders.enable ''
-        -- explicitly enabled by setting ui.borders.enable = true
-        -- TODO: try to get nvim-cmp to follow global border style
-        window = {
-          completion = cmp.config.window.bordered(),
-          documentation = cmp.config.window.bordered(),
-        },
-      ''}
-
-        snippet = {
-          expand = function(args)
-            vim.fn["vsnip#anonymous"](args.body)
-          end,
-        },
-
-        sources = {
-          ${builtSources}
-        },
-
-        completion = {
-          completeopt = 'menu,menuone,noinsert',
-          ${optionalString (!cfg.alwaysComplete) "autocomplete = false"}
-        },
-
-        formatting = {
-          format =
-      ${
-        if lspkindEnabled
-        then "lspkind.cmp_format(lspkind_opts)"
-        else cfg.formatting.format
-      },
-        }
-      })
-      ${optionalString (config.vim.autopairs.enable && config.vim.autopairs.type == "nvim-autopairs") ''
-        local cmp_autopairs = require('nvim-autopairs.completion.cmp')
-        cmp.event:on('confirm_done', cmp_autopairs.on_confirm_done({ map_char = { text = ""} }))
-      ''}
-    '');
-
-    vim.snippets.vsnip.enable =
-      if (cfg.type == "nvim-cmp")
-      then true
-      else config.vim.snippets.vsnip.enable;
+        ${mappings.previous} = mkLuaInline ''
+          cmp.mapping(function(fallback)
+            if cmp.visible() then
+              cmp.select_prev_item()
+              ${optionalString luasnipEnable ''
+            elseif luasnip.locally_jumpable(-1) then
+              luasnip.jump(-1)
+          ''}
+            else
+              fallback()
+            end
+          end)
+        '';
+      };
+    };
  };
 }
--- a/modules/plugins/completion/nvim-cmp/default.nix
+++ b/modules/plugins/completion/nvim-cmp/default.nix
@ -1,4 +1,4 @@
-_: {
+{
  imports = [
    ./config.nix
    ./nvim-cmp.nix
--- a/modules/plugins/completion/nvim-cmp/nvim-cmp.nix
+++ b/modules/plugins/completion/nvim-cmp/nvim-cmp.nix
@ -1,72 +1,103 @@
-{lib, ...}: let
-  inherit (lib.options) mkEnableOption mkOption literalMD;
+{
+  lib,
+  config,
+  ...
+}: let
+  inherit (lib.options) mkEnableOption mkOption literalExpression literalMD;
+  inherit (lib.types) str attrsOf nullOr either;
+  inherit (lib.generators) mkLuaInline;
  inherit (lib.nvim.binds) mkMappingOption;
-  inherit (lib.types) enum attrsOf nullOr str bool;
+  inherit (lib.nvim.types) mkPluginSetupOption luaInline mergelessListOf;
+  inherit (lib.nvim.lua) toLuaObject;
+  inherit (builtins) isString;
+
+  cfg = config.vim.autocomplete.nvim-cmp;
 in {
-  options.vim = {
-    autocomplete = {
-      enable = mkEnableOption "autocomplete" // {default = false;};
-
-      alwaysComplete = mkOption {
-        type = bool;
-        description = "Automatically show completion.";
-        default = true;
-      };
-
-      mappings = {
-        complete = mkMappingOption "Complete [nvim-cmp]" "<C-Space>";
-        confirm = mkMappingOption "Confirm [nvim-cmp]" "<CR>";
-        next = mkMappingOption "Next item [nvim-cmp]" "<Tab>";
-        previous = mkMappingOption "Previous item [nvim-cmp]" "<S-Tab>";
-        close = mkMappingOption "Close [nvim-cmp]" "<C-e>";
-        scrollDocsUp = mkMappingOption "Scroll docs up [nvim-cmp]" "<C-d>";
-        scrollDocsDown = mkMappingOption "Scroll docs down [nvim-cmp]" "<C-f>";
-      };
-
-      type = mkOption {
-        type = enum ["nvim-cmp"];
-        default = "nvim-cmp";
-        description = "Set the autocomplete plugin. Options: [nvim-cmp]";
-      };
-
-      sources = mkOption {
+  options.vim.autocomplete.nvim-cmp = {
+    enable = mkEnableOption "nvim-cmp";
+    setupOpts = mkPluginSetupOption "the autocomplete plugin" {
+      completion.completeopt = mkOption {
+        type = str;
+        default = "menu,menuone,noinsert";
        description = ''
-          Attribute set of source names for nvim-cmp.
+          A comma-separated list of options for completion.

-          If an attribute set is provided, then the menu value of
-          `vim_item` in the format will be set to the value (if
-          utilizing the `nvim_cmp_menu_map` function).
-
-          Note: only use a single attribute name per attribute set
-        '';
-        type = attrsOf (nullOr str);
-        default = {};
-        example = ''
-          {nvim-cmp = null; buffer = "[Buffer]";}
+          See `:help completeopt` for the complete list.
        '';
      };

-      formatting = {
-        format = mkOption {
-          description = ''
-            The function used to customize the appearance of the completion menu.
+      sorting.comparators = mkOption {
+        type = mergelessListOf (either str luaInline);
+        default = [
+          "offset"
+          "exact"
+          "score"
+          "kind"
+          "length"
+          "sort_text"
+        ];
+        description = ''
+          The comparator functions used for sorting completions.

-            If [](#opt-vim.lsp.lspkind.enable) is true, then the function
-            will be called before modifications from lspkind.
-
-            Default is to call the menu mapping function.
-          '';
-          type = str;
-          default = "nvim_cmp_menu_map";
-          example = literalMD ''
-            ```lua
-            function(entry, vim_item)
-              return vim_item
-            end
-            ```
-          '';
-        };
+          You can either pass a valid inline lua function
+          (see `:help cmp-config.sorting.comparators`),
+          or a string, in which case the builtin comparator with that name will
+          be used.
+        '';
+        apply = map (
+          c:
+            if isString c
+            then mkLuaInline ("cmp.config.compare." + c)
+            else c
+        );
      };
    };
+
+    mappings = {
+      complete = mkMappingOption "Complete [nvim-cmp]" "<C-Space>";
+      confirm = mkMappingOption "Confirm [nvim-cmp]" "<CR>";
+      next = mkMappingOption "Next item [nvim-cmp]" "<Tab>";
+      previous = mkMappingOption "Previous item [nvim-cmp]" "<S-Tab>";
+      close = mkMappingOption "Close [nvim-cmp]" "<C-e>";
+      scrollDocsUp = mkMappingOption "Scroll docs up [nvim-cmp]" "<C-d>";
+      scrollDocsDown = mkMappingOption "Scroll docs down [nvim-cmp]" "<C-f>";
+    };
+
+    format = mkOption {
+      type = luaInline;
+      default = mkLuaInline ''
+        function(entry, vim_item)
+          vim_item.menu = (${toLuaObject cfg.sources})[entry.source.name]
+          return vim_item
+        end
+      '';
+      defaultText = literalMD ''
+        ```lua
+        function(entry, vim_item)
+          vim_item.menu = (''${toLuaObject config.vim.autocomplete.nvim-cmp.sources})[entry.source.name]
+          return vim_item
+        end
+        ```
+      '';
+      description = ''
+        The function used to customize the completion menu entires. This is
+        outside of `setupOpts` to allow for an easier integration with
+        lspkind.nvim.
+
+        See `:help cmp-config.formatting.format`.
+      '';
+    };
+
+    sources = mkOption {
+      type = attrsOf (nullOr str);
+      default = {};
+      description = "The list of sources used by nvim-cmp";
+      example = literalExpression ''
+        {
+          nvim-cmp = null;
+          buffer = "[Buffer]";
+        }
+      '';
+    };
  };
 }
--- a/modules/plugins/debugger/nvim-dap/config.nix
+++ b/modules/plugins/debugger/nvim-dap/config.nix
@ -16,57 +16,61 @@
 in {
  config = mkMerge [
    (mkIf cfg.enable {
-      vim.startPlugins = ["nvim-dap"];
+      vim = {
+        startPlugins = ["nvim-dap"];

-      vim.pluginRC =
-        {
-          # TODO customizable keymaps
-          nvim-dap = entryAnywhere ''
-            local dap = require("dap")
-            vim.fn.sign_define("DapBreakpoint", { text = "🛑", texthl = "ErrorMsg", linehl = "", numhl = "" })
-          '';
-        }
-        // mapAttrs (_: v: (entryAfter ["nvim-dap"] v)) cfg.sources;
+        pluginRC =
+          {
+            # TODO customizable keymaps
+            nvim-dap = entryAnywhere ''
+              local dap = require("dap")
+              vim.fn.sign_define("DapBreakpoint", { text = "🛑", texthl = "ErrorMsg", linehl = "", numhl = "" })
+            '';
+          }
+          // mapAttrs (_: v: (entryAfter ["nvim-dap"] v)) cfg.sources;

-      vim.maps.normal = mkMerge [
-        (mkSetLuaBinding mappings.continue "require('dap').continue")
-        (mkSetLuaBinding mappings.restart "require('dap').restart")
-        (mkSetLuaBinding mappings.terminate "require('dap').terminate")
-        (mkSetLuaBinding mappings.runLast "require('dap').run_last")
+        maps.normal = mkMerge [
+          (mkSetLuaBinding mappings.continue "require('dap').continue")
+          (mkSetLuaBinding mappings.restart "require('dap').restart")
+          (mkSetLuaBinding mappings.terminate "require('dap').terminate")
+          (mkSetLuaBinding mappings.runLast "require('dap').run_last")

-        (mkSetLuaBinding mappings.toggleRepl "require('dap').repl.toggle")
-        (mkSetLuaBinding mappings.hover "require('dap.ui.widgets').hover")
-        (mkSetLuaBinding mappings.toggleBreakpoint "require('dap').toggle_breakpoint")
+          (mkSetLuaBinding mappings.toggleRepl "require('dap').repl.toggle")
+          (mkSetLuaBinding mappings.hover "require('dap.ui.widgets').hover")
+          (mkSetLuaBinding mappings.toggleBreakpoint "require('dap').toggle_breakpoint")

-        (mkSetLuaBinding mappings.runToCursor "require('dap').run_to_cursor")
-        (mkSetLuaBinding mappings.stepInto "require('dap').step_into")
-        (mkSetLuaBinding mappings.stepOut "require('dap').step_out")
-        (mkSetLuaBinding mappings.stepOver "require('dap').step_over")
-        (mkSetLuaBinding mappings.stepBack "require('dap').step_back")
+          (mkSetLuaBinding mappings.runToCursor "require('dap').run_to_cursor")
+          (mkSetLuaBinding mappings.stepInto "require('dap').step_into")
+          (mkSetLuaBinding mappings.stepOut "require('dap').step_out")
+          (mkSetLuaBinding mappings.stepOver "require('dap').step_over")
+          (mkSetLuaBinding mappings.stepBack "require('dap').step_back")

-        (mkSetLuaBinding mappings.goUp "require('dap').up")
-        (mkSetLuaBinding mappings.goDown "require('dap').down")
-      ];
+          (mkSetLuaBinding mappings.goUp "require('dap').up")
+          (mkSetLuaBinding mappings.goDown "require('dap').down")
+        ];
+      };
    })
    (mkIf (cfg.enable && cfg.ui.enable) {
-      vim.startPlugins = ["nvim-dap-ui" "nvim-nio"];
+      vim = {
+        startPlugins = ["nvim-dap-ui" "nvim-nio"];

-      vim.pluginRC.nvim-dap-ui = entryAfter ["nvim-dap"] (''
-          local dapui = require("dapui")
-          dapui.setup()
-        ''
-        + optionalString cfg.ui.autoStart ''
-          dap.listeners.after.event_initialized["dapui_config"] = function()
-            dapui.open()
-          end
-          dap.listeners.before.event_terminated["dapui_config"] = function()
-            dapui.close()
-          end
-          dap.listeners.before.event_exited["dapui_config"] = function()
-            dapui.close()
-          end
-        '');
-      vim.maps.normal = mkSetLuaBinding mappings.toggleDapUI "require('dapui').toggle";
+        pluginRC.nvim-dap-ui = entryAfter ["nvim-dap"] (''
+            local dapui = require("dapui")
+            dapui.setup()
+          ''
+          + optionalString cfg.ui.autoStart ''
+            dap.listeners.after.event_initialized["dapui_config"] = function()
+              dapui.open()
+            end
+            dap.listeners.before.event_terminated["dapui_config"] = function()
+              dapui.close()
+            end
+            dap.listeners.before.event_exited["dapui_config"] = function()
+              dapui.close()
+            end
+          '');
+        maps.normal = mkSetLuaBinding mappings.toggleDapUI "require('dapui').toggle";
+      };
    })
  ];
 }
--- a/modules/plugins/languages/csharp.nix
+++ b/modules/plugins/languages/csharp.nix
@ -0,0 +1,122 @@
+{
+  lib,
+  pkgs,
+  config,
+  options,
+  ...
+}: let
+  inherit (builtins) attrNames;
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.types) either listOf package str enum;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.lists) isList;
+  inherit (lib.strings) optionalString;
+  inherit (lib.nvim.types) mkGrammarOption;
+  inherit (lib.nvim.lua) expToLua;
+
+  lspKeyConfig = config.vim.lsp.mappings;
+  lspKeyOptions = options.vim.lsp.mappings;
+  mkLspBinding = optionName: action: let
+    key = lspKeyConfig.${optionName};
+    desc = lspKeyOptions.${optionName}.description;
+  in
+    optionalString (key != null) "vim.keymap.set('n', '${key}', ${action}, {buffer=bufnr, noremap=true, silent=true, desc='${desc}'})";
+
+  # Omnisharp doesn't have colors in popup docs for some reason, and I've also
+  # seen mentions of it being way slower, so until someone finds missing
+  # functionality, this will be the default.
+  defaultServer = "csharp_ls";
+  servers = {
+    omnisharp = {
+      package = pkgs.omnisharp-roslyn;
+      internalFormatter = true;
+      lspConfig = ''
+        lspconfig.omnisharp.setup {
+          capabilities = capabilities,
+          on_attach = function(client, bufnr)
+            default_on_attach(client, bufnr)
+
+            local oe = require("omnisharp_extended")
+            ${mkLspBinding "goToDefinition" "oe.lsp_definition"}
+            ${mkLspBinding "goToType" "oe.lsp_type_definition"}
+            ${mkLspBinding "listReferences" "oe.lsp_references"}
+            ${mkLspBinding "listImplementations" "oe.lsp_implementation"}
+          end,
+          cmd = ${
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else "{'${cfg.lsp.package}/bin/OmniSharp'}"
+        }
+        }
+      '';
+    };
+
+    csharp_ls = {
+      package = pkgs.csharp-ls;
+      internalFormatter = true;
+      lspConfig = ''
+        local extended_handler = require("csharpls_extended").handler
+
+        lspconfig.csharp_ls.setup {
+          capabilities = capabilities,
+          on_attach = default_on_attach,
+          handlers = {
+            ["textDocument/definition"] = extended_handler,
+            ["textDocument/typeDefinition"] = extended_handler
+          },
+          cmd = ${
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else "{'${cfg.lsp.package}/bin/csharp-ls'}"
+        }
+        }
+      '';
+    };
+  };
+
+  extraServerPlugins = {
+    omnisharp = ["omnisharp-extended"];
+    csharp_ls = ["csharpls-extended"];
+  };
+
+  cfg = config.vim.languages.csharp;
+in {
+  options = {
+    vim.languages.csharp = {
+      enable = mkEnableOption "C# language support";
+
+      treesitter = {
+        enable = mkEnableOption "C# treesitter" // {default = config.vim.languages.enableTreesitter;};
+        package = mkGrammarOption pkgs "c-sharp";
+      };
+
+      lsp = {
+        enable = mkEnableOption "C# LSP support" // {default = config.vim.languages.enableLSP;};
+        server = mkOption {
+          description = "C# LSP server to use";
+          type = enum (attrNames servers);
+          default = defaultServer;
+        };
+
+        package = mkOption {
+          description = "C# LSP server package, or the command to run as a list of strings";
+          type = either package (listOf str);
+          default = servers.${cfg.lsp.server}.package;
+        };
+      };
+    };
+  };
+
+  config = mkIf cfg.enable (mkMerge [
+    (mkIf cfg.treesitter.enable {
+      vim.treesitter.enable = true;
+      vim.treesitter.grammars = [cfg.treesitter.package];
+    })
+
+    (mkIf cfg.lsp.enable {
+      vim.startPlugins = extraServerPlugins.${cfg.lsp.server} or [];
+      vim.lsp.lspconfig.enable = true;
+      vim.lsp.lspconfig.sources.csharp-lsp = servers.${cfg.lsp.server}.lspConfig;
+    })
+  ]);
+}
--- a/modules/plugins/languages/css.nix
+++ b/modules/plugins/languages/css.nix
@ -63,6 +63,18 @@
        )
      '';
    };
+
+    biome = {
+      package = pkgs.biome;
+      nullConfig = ''
+        table.insert(
+          ls_sources,
+          null_ls.builtins.formatting.biome.with({
+            command = "${cfg.format.package}/bin/biome",
+          })
+        )
+      '';
+    };
  };
 in {
  options.vim.languages.css = {
--- a/modules/plugins/languages/default.nix
+++ b/modules/plugins/languages/default.nix
@ -8,6 +8,7 @@ in {
    ./css.nix
    ./elixir.nix
    ./go.nix
+    ./kotlin.nix
    ./html.nix
    ./java.nix
    ./lua.nix
@ -19,6 +20,7 @@ in {
    ./python.nix
    ./r.nix
    ./rust.nix
+    ./scala.nix
    ./sql.nix
    ./svelte.nix
    ./tailwind.nix
@ -26,6 +28,7 @@ in {
    ./ts.nix
    ./typst.nix
    ./zig.nix
+    ./csharp.nix
  ];

  options.vim.languages = {
--- a/modules/plugins/languages/kotlin.nix
+++ b/modules/plugins/languages/kotlin.nix
@ -0,0 +1,107 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  inherit (lib.options) mkEnableOption mkOption literalExpression;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.meta) getExe;
+  inherit (lib.nvim.languages) diagnosticsToLua;
+  inherit (lib.types) either package listOf str;
+  inherit (lib.nvim.types) mkGrammarOption diagnostics;
+  inherit (lib.lists) isList;
+  inherit (lib.nvim.lua) expToLua;
+
+  cfg = config.vim.languages.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";
+
+    treesitter = {
+      enable = mkEnableOption "Kotlin treesitter" // {default = config.vim.languages.enableTreesitter;};
+      package = mkGrammarOption pkgs "kotlin";
+    };
+
+    lsp = {
+      enable = mkEnableOption "Kotlin LSP support" // {default = config.vim.languages.enableLSP;};
+
+      package = mkOption {
+        description = "kotlin_language_server package with Kotlin runtime";
+        type = either package (listOf str);
+        example = literalExpression ''
+          pkgs.symlinkJoin {
+            name = "kotlin-language-server-wrapped";
+            paths = [pkgs.kotlin-language-server];
+            nativeBuildInputs = [pkgs.makeBinaryWrapper];
+            postBuild = '''
+              wrapProgram $out/bin/kotlin-language-server \
+                --prefix PATH : ''${pkgs.kotlin}/bin
+            ''';
+          };
+        '';
+        default = pkgs.kotlin-language-server;
+      };
+    };
+
+    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 {
+      vim.treesitter.enable = true;
+      vim.treesitter.grammars = [cfg.treesitter.package];
+    })
+
+    (mkIf cfg.extraDiagnostics.enable {
+      vim.lsp.null-ls.enable = true;
+      vim.lsp.null-ls.sources = diagnosticsToLua {
+        lang = "kotlin";
+        config = cfg.extraDiagnostics.types;
+        inherit diagnosticsProviders;
+      };
+    })
+
+    (mkIf cfg.lsp.enable {
+      vim.lsp.lspconfig.enable = true;
+      vim.lsp.lspconfig.sources.kotlin_language_server = ''
+        lspconfig.kotlin_language_server.setup {
+          capabilities = capabilities,
+          root_dir = lspconfig.util.root_pattern("main.kt", ".git"),
+          on_attach=default_on_attach,
+          init_options = {
+          -- speeds up the startup time for the LSP
+            storagePath = vim.fn.stdpath('state') .. '/kotlin',
+          },
+          cmd = ${
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else ''{"${cfg.lsp.package}/bin/kotlin-language-server"}''
+        },
+        }
+      '';
+    })
+  ]);
+}
--- a/modules/plugins/languages/nix.nix
+++ b/modules/plugins/languages/nix.nix
@ -5,6 +5,7 @@
  ...
 }: let
  inherit (builtins) attrNames;
+  inherit (lib) concatStringsSep;
  inherit (lib.options) mkEnableOption mkOption;
  inherit (lib.modules) mkIf mkMerge;
  inherit (lib.lists) isList;
@ -62,10 +63,10 @@
                command = {"${cfg.format.package}/bin/alejandra", "--quiet"},
              },
            ''}
-          ${optionalString (cfg.format.type == "nixpkgs-fmt")
+          ${optionalString (cfg.format.type == "nixfmt")
            ''
              formatting = {
-                command = {"${cfg.format.package}/bin/nixpkgs-fmt"},
+                command = {"${cfg.format.package}/bin/nixfmt"},
              },
            ''}
            },
@ -90,10 +91,19 @@
      '';
    };

-    nixpkgs-fmt = {
-      package = pkgs.nixpkgs-fmt;
-      # Never need to use null-ls for nixpkgs-fmt
+    nixfmt = {
+      package = pkgs.nixfmt-rfc-style;
+      nullConfig = ''
+        table.insert(
+          ls_sources,
+          null_ls.builtins.formatting.nixfmt.with({
+            command = "${cfg.format.package}/bin/nixfmt"
+          })
+        )
+      '';
    };
+
+    nixpkgs-fmt = null; # removed
  };

  defaultDiagnosticsProvider = ["statix" "deadnix"];
@ -135,7 +145,7 @@ in {
      enable = mkEnableOption "Nix LSP support" // {default = config.vim.languages.enableLSP;};
      server = mkOption {
        description = "Nix LSP server to use";
-        type = str;
+        type = enum (attrNames servers);
        default = defaultServer;
      };

@ -175,6 +185,12 @@ in {

  config = mkIf cfg.enable (mkMerge [
    {
+      assertions = [
+        {
+          assertion = cfg.format.type != "nixpkgs-fmt";
+          message = "nixpkgs-fmt has been archived upstream. Please use one of the following instead: ${concatStringsSep ", " (attrNames formats)}";
+        }
+      ];
      vim.pluginRC.nix = ''
        vim.api.nvim_create_autocmd("FileType", {
          pattern = "nix",
--- a/modules/plugins/languages/rust.nix
+++ b/modules/plugins/languages/rust.nix
@ -9,7 +9,7 @@
  inherit (lib.options) mkOption mkEnableOption;
  inherit (lib.strings) optionalString;
  inherit (lib.trivial) boolToString;
-  inherit (lib.lists) isList optionals;
+  inherit (lib.lists) isList;
  inherit (lib.types) bool package str listOf either enum;
  inherit (lib.nvim.types) mkGrammarOption;
  inherit (lib.nvim.lua) expToLua;
@ -101,7 +101,7 @@ in {
      vim = {
        startPlugins = ["crates-nvim"];
        lsp.null-ls.enable = mkIf cfg.crates.codeActions true;
-        autocomplete.sources = {"crates" = "[Crates]";};
+        autocomplete.nvim-cmp.sources = {crates = "[Crates]";};
        pluginRC.rust-crates = entryAnywhere ''
          require('crates').setup {
            null_ls = {
--- a/modules/plugins/languages/scala.nix
+++ b/modules/plugins/languages/scala.nix
@ -0,0 +1,149 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: 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;
+  inherit (lib.strings) optionalString;
+  inherit (lib.types) attrsOf anything bool;
+
+  listCommandsAction =
+    if config.vim.telescope.enable
+    then ''require("telescope").extensions.metals.commands()''
+    else ''require("metals").commands()'';
+
+  cfg = config.vim.languages.scala;
+
+  usingDap = config.vim.debugger.nvim-dap.enable && cfg.dap.enable;
+  usingLualine = config.vim.statusline.lualine.enable;
+in {
+  options.vim.languages.scala = {
+    enable = mkEnableOption "Scala language support";
+
+    treesitter = {
+      enable = mkEnableOption "Scala treesitter" // {default = config.vim.languages.enableTreesitter;};
+      package = mkGrammarOption pkgs "scala";
+    };
+
+    lsp = {
+      enable = mkEnableOption "Scala LSP support (metals)" // {default = config.vim.languages.enableLSP;};
+      package = mkPackageOption pkgs "metals" {
+        default = ["metals"];
+      };
+
+      extraMappings = {
+        listCommands = mkMappingOption "List Metals commands" "<leader>lc";
+      };
+
+      extraSettings = mkOption {
+        type = attrsOf anything;
+        description = "Extra settings passed to the metals config. Check nvim-metals docs for available options";
+        default = {
+          showImplicitArguments = true;
+          showImplicitConversionsAndClasses = true;
+          showInferredType = true;
+          excludedPackages = [
+            "akka.actor.typed.javadsl"
+            "com.github.swagger.akka.javadsl"
+          ];
+        };
+      };
+    };
+
+    dap = {
+      enable = mkEnableOption "Scala Debug Adapter support (metals)" // {default = config.vim.languages.enableDAP;};
+      config = mkOption {
+        description = "Lua configuration for dap";
+        type = luaInline;
+        default = mkLuaInline ''
+          dap.configurations.scala = {
+            {
+              type = "scala",
+              request = "launch",
+              name = "RunOrTest",
+              metals = {
+                runType = "runOrTestFile",
+                --args = { "firstArg", "secondArg", "thirdArg" }, -- here just as an example
+              },
+            },
+            {
+              type = "scala",
+              request = "launch",
+              name = "Test Target",
+              metals = {
+                runType = "testTarget",
+              },
+            },
+          }
+        '';
+      };
+    };
+
+    fixShortmess = mkOption {
+      type = bool;
+      description = "Remove the 'F' flag from shortmess to allow messages to be shown. Without doing this, autocommands that deal with filetypes prohibit messages from being shown";
+      default = true;
+    };
+  };
+
+  config = mkIf cfg.enable (
+    mkMerge [
+      (mkIf cfg.treesitter.enable {
+        vim.treesitter.enable = true;
+        vim.treesitter.grammars = [cfg.treesitter.package];
+      })
+      (mkIf (cfg.lsp.enable || cfg.dap.enable) {
+        vim = {
+          startPlugins = ["nvim-metals"];
+          pluginRC.nvim-metals = entryAfter ["lsp-setup"] ''
+            local metals_caps = capabilities  -- from lsp-setup
+
+            local attach_metals_keymaps = function(client, bufnr)
+              attach_keymaps(client, bufnr)  -- from lsp-setup
+              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()
+            ${optionalString usingLualine "metals_config.init_options.statusBarProvider = 'on'"}
+
+            metals_config.capabilities = metals_caps
+            metals_config.on_attach = function(client, bufnr)
+              ${optionalString usingDap "require('metals').setup_dap()"}
+              attach_metals_keymaps(client, bufnr)
+            end
+
+            metals_config.settings = ${toLuaObject cfg.lsp.extraSettings}
+            metals_config.settings.metalsBinaryPath = "${cfg.lsp.package}/bin/metals"
+
+            metals_config.handlers["textDocument/publishDiagnostics"] = vim.lsp.with(
+              vim.lsp.diagnostic.on_publish_diagnostics, {
+                virtual_text = {
+                  prefix = '⚠',
+                }
+              }
+            )
+
+            ${optionalString cfg.fixShortmess ''vim.opt_global.shortmess:remove("F")''}
+
+            local lsp_group = vim.api.nvim_create_augroup('lsp', { clear = true })
+
+            vim.api.nvim_create_autocmd('FileType', {
+                group = lsp_group,
+                pattern = {'java', 'scala', 'sbt'},
+                callback = function()
+                    require('metals').initialize_or_attach(metals_config)
+                end,
+            })
+          '';
+        };
+      })
+    ]
+  );
+}
--- a/modules/plugins/languages/svelte.nix
+++ b/modules/plugins/languages/svelte.nix
@ -48,6 +48,18 @@
        )
      '';
    };
+
+    biome = {
+      package = pkgs.biome;
+      nullConfig = ''
+        table.insert(
+          ls_sources,
+          null_ls.builtins.formatting.biome.with({
+            command = "${cfg.format.package}/bin/biome",
+          })
+        )
+      '';
+    };
  };

  # TODO: specify packages
--- a/modules/plugins/languages/ts.nix
+++ b/modules/plugins/languages/ts.nix
@ -95,6 +95,18 @@
        )
      '';
    };
+
+    biome = {
+      package = pkgs.biome;
+      nullConfig = ''
+        table.insert(
+          ls_sources,
+          null_ls.builtins.formatting.biome.with({
+            command = "${cfg.format.package}/bin/biome",
+          })
+        )
+      '';
+    };
  };

  # TODO: specify packages
--- a/modules/plugins/lsp/config.nix
+++ b/modules/plugins/lsp/config.nix
@ -11,46 +11,46 @@
  inherit (lib.nvim.binds) addDescriptionsToMappings;

  cfg = config.vim.lsp;
-  usingNvimCmp = config.vim.autocomplete.enable && config.vim.autocomplete.type == "nvim-cmp";
+  usingNvimCmp = config.vim.autocomplete.nvim-cmp.enable;
  self = import ./module.nix {inherit config lib pkgs;};

  mappingDefinitions = self.options.vim.lsp.mappings;
  mappings = addDescriptionsToMappings cfg.mappings mappingDefinitions;
  mkBinding = binding: action:
    if binding.value != null
-    then "vim.api.nvim_buf_set_keymap(bufnr, 'n', '${binding.value}', '<cmd>lua ${action}<CR>', {noremap=true, silent=true, desc='${binding.description}'})"
+    then "vim.keymap.set('n', '${binding.value}', ${action}, {buffer=bufnr, noremap=true, silent=true, desc='${binding.description}'})"
    else "";
 in {
  config = mkIf cfg.enable {
    vim = {
      startPlugins = optional usingNvimCmp "cmp-nvim-lsp";

-      autocomplete.sources = {"nvim_lsp" = "[LSP]";};
+      autocomplete.nvim-cmp.sources = {nvim_lsp = "[LSP]";};

      pluginRC.lsp-setup = ''
        vim.g.formatsave = ${boolToString cfg.formatOnSave};

        local attach_keymaps = function(client, bufnr)
-          ${mkBinding mappings.goToDeclaration "vim.lsp.buf.declaration()"}
-          ${mkBinding mappings.goToDefinition "vim.lsp.buf.definition()"}
-          ${mkBinding mappings.goToType "vim.lsp.buf.type_definition()"}
-          ${mkBinding mappings.listImplementations "vim.lsp.buf.implementation()"}
-          ${mkBinding mappings.listReferences "vim.lsp.buf.references()"}
-          ${mkBinding mappings.nextDiagnostic "vim.diagnostic.goto_next()"}
-          ${mkBinding mappings.previousDiagnostic "vim.diagnostic.goto_prev()"}
-          ${mkBinding mappings.openDiagnosticFloat "vim.diagnostic.open_float()"}
-          ${mkBinding mappings.documentHighlight "vim.lsp.buf.document_highlight()"}
-          ${mkBinding mappings.listDocumentSymbols "vim.lsp.buf.document_symbol()"}
-          ${mkBinding mappings.addWorkspaceFolder "vim.lsp.buf.add_workspace_folder()"}
-          ${mkBinding mappings.removeWorkspaceFolder "vim.lsp.buf.remove_workspace_folder()"}
-          ${mkBinding mappings.listWorkspaceFolders "print(vim.inspect(vim.lsp.buf.list_workspace_folders()))"}
-          ${mkBinding mappings.listWorkspaceSymbols "vim.lsp.buf.workspace_symbol()"}
-          ${mkBinding mappings.hover "vim.lsp.buf.hover()"}
-          ${mkBinding mappings.signatureHelp "vim.lsp.buf.signature_help()"}
-          ${mkBinding mappings.renameSymbol "vim.lsp.buf.rename()"}
-          ${mkBinding mappings.codeAction "vim.lsp.buf.code_action()"}
-          ${mkBinding mappings.format "vim.lsp.buf.format()"}
-          ${mkBinding mappings.toggleFormatOnSave "vim.b.disableFormatSave = not vim.b.disableFormatSave"}
+          ${mkBinding mappings.goToDeclaration "vim.lsp.buf.declaration"}
+          ${mkBinding mappings.goToDefinition "vim.lsp.buf.definition"}
+          ${mkBinding mappings.goToType "vim.lsp.buf.type_definition"}
+          ${mkBinding mappings.listImplementations "vim.lsp.buf.implementation"}
+          ${mkBinding mappings.listReferences "vim.lsp.buf.references"}
+          ${mkBinding mappings.nextDiagnostic "vim.diagnostic.goto_next"}
+          ${mkBinding mappings.previousDiagnostic "vim.diagnostic.goto_prev"}
+          ${mkBinding mappings.openDiagnosticFloat "vim.diagnostic.open_float"}
+          ${mkBinding mappings.documentHighlight "vim.lsp.buf.document_highlight"}
+          ${mkBinding mappings.listDocumentSymbols "vim.lsp.buf.document_symbol"}
+          ${mkBinding mappings.addWorkspaceFolder "vim.lsp.buf.add_workspace_folder"}
+          ${mkBinding mappings.removeWorkspaceFolder "vim.lsp.buf.remove_workspace_folder"}
+          ${mkBinding mappings.listWorkspaceFolders "function() vim.notify(vim.inspect(vim.lsp.buf.list_workspace_folders())) end"}
+          ${mkBinding mappings.listWorkspaceSymbols "vim.lsp.buf.workspace_symbol"}
+          ${mkBinding mappings.hover "vim.lsp.buf.hover"}
+          ${mkBinding mappings.signatureHelp "vim.lsp.buf.signature_help"}
+          ${mkBinding mappings.renameSymbol "vim.lsp.buf.rename"}
+          ${mkBinding mappings.codeAction "vim.lsp.buf.code_action"}
+          ${mkBinding mappings.format "vim.lsp.buf.format"}
+          ${mkBinding mappings.toggleFormatOnSave "function() vim.b.disableFormatSave = not vim.b.disableFormatSave end"}
        end

        -- Enable formatting
--- a/modules/plugins/lsp/lspkind/config.nix
+++ b/modules/plugins/lsp/lspkind/config.nix
@ -3,18 +3,32 @@
  lib,
  ...
 }: let
-  inherit (lib.modules) mkIf;
-  inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.modules) mkIf mkForce;
+  inherit (lib.generators) mkLuaInline;
+  inherit (lib.nvim.lua) toLuaObject;

-  cfg = config.vim.lsp;
+  cfg = config.vim.lsp.lspkind;
 in {
-  config = mkIf (cfg.enable && cfg.lspkind.enable) {
-    vim.startPlugins = ["lspkind"];
-    vim.pluginRC.lspkind = entryAnywhere ''
-      local lspkind = require'lspkind'
-      local lspkind_opts = {
-        mode = '${cfg.lspkind.mode}'
+  config = mkIf cfg.enable {
+    assertions = [
+      {
+        assertion = config.vim.autocomplete.nvim-cmp.enable;
+        message = ''
+          While lspkind supports Neovim's native lsp upstream, using that over
+          nvim-cmp isn't recommended, nor supported by nvf.
+
+          Please migrate to nvim-cmp if you want to use lspkind.
+        '';
      }
-    '';
+    ];
+
+    vim = {
+      startPlugins = ["lspkind"];
+
+      lsp.lspkind.setupOpts.before = config.vim.autocomplete.nvim-cmp.format;
+      autocomplete.nvim-cmp.setupOpts.formatting.format = mkForce (mkLuaInline ''
+        require("lspkind").cmp_format(${toLuaObject cfg.setupOpts})
+      '');
+    };
  };
 }
--- a/modules/plugins/lsp/lspkind/lspkind.nix
+++ b/modules/plugins/lsp/lspkind/lspkind.nix
@ -1,16 +1,22 @@
 {lib, ...}: let
  inherit (lib.options) mkEnableOption mkOption;
-  inherit (lib.types) enum;
+  inherit (lib.types) enum nullOr;
+  inherit (lib.nvim.types) mkPluginSetupOption luaInline;
 in {
-  options.vim.lsp = {
-    lspkind = {
-      enable = mkEnableOption "vscode-like pictograms for lsp [lspkind]";
-
+  options.vim.lsp.lspkind = {
+    enable = mkEnableOption "vscode-like pictograms for lsp [lspkind]";
+    setupOpts = mkPluginSetupOption "lspkind.nvim" {
      mode = mkOption {
        description = "Defines how annotations are shown";
        type = enum ["text" "text_symbol" "symbol_text" "symbol"];
        default = "symbol_text";
      };
+
+      before = mkOption {
+        description = "The function that will be called before lspkind's modifications are applied";
+        type = nullOr luaInline;
+        default = null;
+      };
    };
  };
 }
--- a/modules/plugins/lsp/otter/config.nix
+++ b/modules/plugins/lsp/otter/config.nix
@ -32,7 +32,7 @@ in {

      pluginRC.otter-nvim = entryAnywhere ''
        -- Enable otter diagnostics viewer
-        require("otter").setup({${toLuaObject cfg.otter-nvim.setupOpts}})
+        require("otter").setup(${toLuaObject cfg.otter-nvim.setupOpts})
      '';
    };
  };
--- a/modules/plugins/notes/default.nix
+++ b/modules/plugins/notes/default.nix
@ -2,6 +2,7 @@
  imports = [
    ./obsidian
    ./orgmode
+    ./neorg
    ./mind-nvim
    ./todo-comments
  ];
--- a/modules/plugins/notes/neorg/config.nix
+++ b/modules/plugins/notes/neorg/config.nix
@ -0,0 +1,41 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.nvim.binds) pushDownDefault;
+  inherit (lib.nvim.lua) toLuaObject;
+
+  cfg = config.vim.notes.neorg;
+in {
+  config = mkIf cfg.enable (mkMerge [
+    {
+      vim = {
+        startPlugins = [
+          "lua-utils-nvim"
+          "nui-nvim"
+          "nvim-nio"
+          "pathlib-nvim"
+          "plenary-nvim"
+          "neorg"
+          "neorg-telescope"
+        ];
+
+        binds.whichKey.register = pushDownDefault {
+          "<leader>o" = "+Notes";
+        };
+
+        pluginRC.neorg = entryAnywhere ''
+          require('neorg').setup(${toLuaObject cfg.setupOpts})
+        '';
+      };
+    }
+
+    (mkIf cfg.treesitter.enable {
+      vim.treesitter.enable = true;
+      vim.treesitter.grammars = [cfg.treesitter.norgPackage];
+    })
+  ]);
+}
--- a/modules/plugins/notes/neorg/default.nix
+++ b/modules/plugins/notes/neorg/default.nix
@ -0,0 +1,6 @@
+{
+  imports = [
+    ./neorg.nix
+    ./config.nix
+  ];
+}
--- a/modules/plugins/notes/neorg/neorg.nix
+++ b/modules/plugins/notes/neorg/neorg.nix
@ -0,0 +1,50 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.types) submodule listOf str;
+  inherit (lib.nvim.types) mkGrammarOption mkPluginSetupOption;
+in {
+  options.vim.notes.neorg = {
+    enable = mkEnableOption ''
+      Neorg: An intuitive note-taking and organization tool with a structured nested syntax.
+    '';
+
+    setupOpts = mkPluginSetupOption "Neorg" {
+      load = {
+        "core.defaults" = mkOption {
+          default = {};
+          description = ''
+            all of the most important modules that any user would want to have a "just works" experience
+          '';
+
+          type = submodule {
+            options = {
+              enable = mkEnableOption ''
+                all of the most important modules that any user would want to have a "just works" experience
+              '';
+              config = {
+                disable = mkOption {
+                  description = ''
+                    list of modules from to be disabled from core.defaults
+                  '';
+                  type = listOf str;
+                  default = [];
+                  example = ["core.autocommands" "core.itero"];
+                };
+              };
+            };
+          };
+        };
+      };
+    };
+
+    treesitter = {
+      enable = mkEnableOption "Neorg treesitter" // {default = config.vim.languages.enableTreesitter;};
+      norgPackage = mkGrammarOption pkgs "norg";
+    };
+  };
+}
--- a/modules/plugins/notes/obsidian/obsidian.nix
+++ b/modules/plugins/notes/obsidian/obsidian.nix
@ -45,10 +45,10 @@ in {

        completion = {
          nvim_cmp = mkOption {
-            # if using nvim-cmp, otherwise set to false
+            # If using nvim-cmp, otherwise set to false
            type = bool;
            description = "If using nvim-cmp, otherwise set to false";
-            default = config.vim.autocomplete.type == "nvim-cmp";
+            default = config.vim.autocomplete.nvim-cmp.enable;
          };
        };
      };
--- a/modules/plugins/snippets/default.nix
+++ b/modules/plugins/snippets/default.nix
@ -1,5 +1,5 @@
 {
  imports = [
-    ./vsnip
+    ./luasnip
  ];
 }
--- a/modules/plugins/snippets/luasnip/config.nix
+++ b/modules/plugins/snippets/luasnip/config.nix
@ -0,0 +1,17 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.modules) mkIf;
+
+  cfg = config.vim.snippets.luasnip;
+in {
+  config = mkIf cfg.enable {
+    vim = {
+      startPlugins = ["luasnip" "cmp-luasnip"] ++ cfg.providers;
+      autocomplete.nvim-cmp.sources = {luasnip = "[LuaSnip]";};
+      pluginRC.luasnip = cfg.loaders;
+    };
+  };
+}
--- a/modules/plugins/snippets/luasnip/default.nix
+++ b/modules/plugins/snippets/luasnip/default.nix
@ -0,0 +1,6 @@
+{
+  imports = [
+    ./luasnip.nix
+    ./config.nix
+  ];
+}
--- a/modules/plugins/snippets/luasnip/luasnip.nix
+++ b/modules/plugins/snippets/luasnip/luasnip.nix
@ -0,0 +1,36 @@
+{lib, ...}: let
+  inherit (lib.options) mkEnableOption mkOption literalExpression literalMD;
+  inherit (lib.types) listOf lines;
+  inherit (lib.nvim.types) pluginType;
+in {
+  options.vim.snippets.luasnip = {
+    enable = mkEnableOption "luasnip";
+    providers = mkOption {
+      type = listOf pluginType;
+      default = ["friendly-snippets"];
+      description = ''
+        The snippet provider packages.
+
+        ::: {.note}
+        These are simply appended to {option} `vim.startPlugins`.
+        :::
+      '';
+      example = literalExpression "[\"vimPlugins.vim-snippets\"]";
+    };
+    loaders = mkOption {
+      type = lines;
+      default = "require('luasnip.loaders.from_vscode').lazy_load()";
+      defaultText = literalMD ''
+        ```lua
+        require('luasnip.loaders.from_vscode').lazy_load()
+        ```
+      '';
+      description = "Lua code used to load snippet providers.";
+      example = literalMD ''
+        ```lua
+        require("luasnip.loaders.from_snipmate").lazy_load()
+        ```
+      '';
+    };
+  };
+}
--- a/modules/plugins/snippets/vsnip/config.nix
+++ b/modules/plugins/snippets/vsnip/config.nix
@ -1,13 +0,0 @@
-{
-  config,
-  lib,
-  ...
-}: let
-  inherit (lib.modules) mkIf;
-
-  cfg = config.vim.snippets.vsnip;
-in {
-  config = mkIf cfg.enable {
-    vim.startPlugins = ["vim-vsnip"];
-  };
-}
--- a/modules/plugins/snippets/vsnip/default.nix
+++ b/modules/plugins/snippets/vsnip/default.nix
@ -1,5 +0,0 @@
-{
-  imports = [
-    ./vsnip.nix
-  ];
-}
--- a/modules/plugins/snippets/vsnip/vsnip.nix
+++ b/modules/plugins/snippets/vsnip/vsnip.nix
@ -1,7 +0,0 @@
-{lib, ...}: let
-  inherit (lib.options) mkEnableOption;
-in {
-  options.vim.snippets.vsnip = {
-    enable = mkEnableOption "vim-vsnip: snippet LSP/VSCode's format";
-  };
-}
--- a/modules/plugins/theme/supported-themes.nix
+++ b/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 {
--- a/modules/plugins/theme/theme.nix
+++ b/modules/plugins/theme/theme.nix
@ -5,31 +5,52 @@
 }: let
  inherit (lib.options) mkOption;
  inherit (lib.attrsets) attrNames;
+  inherit (lib.strings) hasPrefix;
  inherit (lib.types) bool lines enum;
  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
  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 =
+    mapListToAttrs (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 +68,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;}}
      '';
    };
  };
--- a/modules/plugins/treesitter/config.nix
+++ b/modules/plugins/treesitter/config.nix
@ -11,7 +11,7 @@
  inherit (lib.nvim.dag) entryBefore entryAfter;

  cfg = config.vim.treesitter;
-  usingNvimCmp = config.vim.autocomplete.enable && config.vim.autocomplete.type == "nvim-cmp";
+  usingNvimCmp = config.vim.autocomplete.nvim-cmp.enable;

  self = import ./treesitter.nix {inherit pkgs lib;};
  mappingDefinitions = self.options.vim.treesitter.mappings;
@ -21,7 +21,7 @@ in {
    vim = {
      startPlugins = ["nvim-treesitter"] ++ optional usingNvimCmp "cmp-treesitter";

-      autocomplete.sources = {"treesitter" = "[Treesitter]";};
+      autocomplete.nvim-cmp.sources = {treesitter = "[Treesitter]";};
      treesitter.grammars = optionals cfg.addDefaultGrammars cfg.defaultGrammars;

      maps = {
--- a/modules/plugins/ui/noice/noice.nix
+++ b/modules/plugins/ui/noice/noice.nix
@ -21,7 +21,7 @@ in {
            mkBool true "override the lsp markdown formatter with Noice";

          "cmp.entry.get_documentation" =
-            mkBool (config.vim.autocomplete.type == "nvim-cmp") "override cmp documentation with Noice";
+            mkBool config.vim.autocomplete.nvim-cmp.enable "override cmp documentation with Noice";
        };

        signature = {
--- a/modules/plugins/utility/motion/leap/config.nix
+++ b/modules/plugins/utility/motion/leap/config.nix
@ -3,7 +3,7 @@
  lib,
  ...
 }: let
-  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.modules) mkIf mkMerge mkDefault;
  inherit (lib.nvim.binds) mkBinding;
  inherit (lib.nvim.dag) entryAnywhere;

@ -37,6 +37,8 @@ in {
      (mkBinding cfg.mappings.leapFromWindow "<Plug>(leap-from-window)" "Leap from window")
    ];

+    vim.binds.whichKey.register."<leader>s" = mkDefault "+Leap";
+
    vim.pluginRC.leap-nvim = entryAnywhere ''
      require('leap').opts = {
        max_phase_one_targets = nil,
--- a/modules/plugins/utility/motion/leap/leap.nix
+++ b/modules/plugins/utility/motion/leap/leap.nix
@ -9,22 +9,22 @@ in {
      leapForwardTo = mkOption {
        type = nullOr str;
        description = "Leap forward to";
-        default = "s";
+        default = "<leader>ss";
      };
      leapBackwardTo = mkOption {
        type = nullOr str;
        description = "Leap backward to";
-        default = "S";
+        default = "<leader>sS";
      };
      leapForwardTill = mkOption {
        type = nullOr str;
        description = "Leap forward till";
-        default = "x";
+        default = "<leader>sx";
      };
      leapBackwardTill = mkOption {
        type = nullOr str;
        description = "Leap backward till";
-        default = "X";
+        default = "<leader>sX";
      };
      leapFromWindow = mkOption {
        type = nullOr str;
--- a/modules/plugins/utility/surround/config.nix
+++ b/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";
      };
    };
  };
--- a/modules/plugins/utility/surround/surround.nix
+++ b/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;
-    });
  };
 }
--- a/modules/wrapper/rc/config.nix
+++ b/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;
  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
--- a/modules/wrapper/rc/options.nix
+++ b/modules/wrapper/rc/options.nix
@ -3,27 +3,18 @@
  lib,
  ...
 }: let
-  inherit (lib.modules) mkRemovedOptionModule;
  inherit (lib.options) mkOption mkEnableOption literalMD literalExpression;
  inherit (lib.strings) optionalString;
-  inherit (lib.types) str attrs lines listOf either path bool;
+  inherit (lib.types) str attrs lines listOf either path;
  inherit (lib.nvim.types) dagOf;
  inherit (lib.nvim.lua) listToLuaTable;

  cfg = config.vim;
 in {
-  imports = [
-    (mkRemovedOptionModule ["vim" "configRC"] ''
-      Please migrate your configRC sections to Neovim's Lua format, and
-      add them to luaConfigRC.
-
-      See the v0.7 release notes for more information on how to migrate
-      your existing configurations.
-    '')
-  ];
-
  options.vim = {
    enableLuaLoader = mkEnableOption ''
+      [{option}`official documentation`]: https://neovim.io/doc/user/lua.html#vim.loader.enable()
+
      the experimental Lua module loader to speed up the start up process

      If `true`, this will enable the experimental Lua module loader which:
@ -32,30 +23,12 @@ in {
        - adds the libs loader
        - removes the default Neovim loader

+      ::: {.note}
      This is disabled by default. Before setting this option, please
-      take a look at the [{option}`official documentation`](https://neovim.io/doc/user/lua.html#vim.loader.enable()).
+      take a look at the [{option}`official documentation`].
+      :::
    '';

-    disableDefaultRuntimePaths = mkOption {
-      type = bool;
-      default = true;
-      example = false;
-      description = ''
-        Disables the default runtime paths that are set by Neovim
-        when it starts up. This is useful when you want to have
-        full control over the runtime paths that are set by Neovim.
-
-        ::: {.note}
-        To avoid leaking imperative user configuration into your
-        configuration, this is enabled by default. If you wish
-        to load configuration from user configuration directories
-        (e.g. {file}`$HOME/.config/nvim`, {file}`$HOME/.config/nvim/after`
-        and {file}`$HOME/.local/share/nvim/site`) you may set this
-        option to true.
-        :::
-      '';
-    };
-
    additionalRuntimePaths = mkOption {
      type = listOf (either path str);
      default = [];
@ -180,21 +153,6 @@ in {
          vim.opt.runtimepath:append(${listToLuaTable cfg.additionalRuntimePaths})
        ''}

-        ${optionalString cfg.disableDefaultRuntimePaths ''
-          -- Remove default user runtime paths from the
-          -- `runtimepath` option to avoid leaking user configuration
-          -- into the final neovim wrapper
-          local defaultRuntimePaths = {
-            vim.fn.stdpath('config'),              -- $HOME/.config/nvim
-            vim.fn.stdpath('config') .. "/after",  -- $HOME/.config/nvim/after
-            vim.fn.stdpath('data') .. "/site",     -- $HOME/.local/share/nvim/site
-          }
-
-          for _, path in ipairs(defaultRuntimePaths) do
-            vim.opt.runtimepath:remove(path)
-          end
-        ''}
-
        ${optionalString cfg.enableLuaLoader "vim.loader.enable()"}
      '';
Author	SHA1	Message	Date
raf	621fc61900	Merge `1166e8aa1d` into `8ff50562d7`	2024-11-01 23:07:21 +00:00
raf	1166e8aa1d	Merge branch 'main' into v0.7	2024-11-01 23:07:19 +00:00
raf	42c5228dc1	Merge pull request #428 from diniamo/add-csharp languages/csharp: init	2024-10-28 12:56:53 +00:00
diniamo	665feee445	languages: csharp init with omnisharp and csharp_ls	2024-10-27 14:35:17 +01:00
diniamo	0aa557dac6	lsp: avoid vimscript in bindings	2024-10-27 14:31:13 +01:00
diniamo	5ab1af9285	languages/kotlin: allow specifying a command for lsp.package, fix indentation	2024-10-27 12:54:39 +01:00
diniamo	30a8a8fce0	languages/nix: use stricter type for lsp.server	2024-10-27 12:53:44 +01:00
Soliprem	da86e554a6	Fix typo in otter setupOpts (#424 ) * Revert "leap: changed default binds" This reverts commit `92a7bfc4b8`. * Reapply "leap: changed default binds" This reverts commit ede1d4437e2d8d1a6ff31b4dc855676c6e16df36. * otter: fixed stupid typo * otter: added changelog entry	2024-10-23 14:51:43 +00:00
Anthony	71e2ae1db4	languages/nix: change nixpkgs-fmt to nixfmt (rfc-style) (#383 )	2024-10-22 21:44:18 +00:00
Anthony	e80520ddf3	languages: add biome support for formatting (#423 )	2024-10-22 22:15:07 +02:00
diniamo	3c4eced9d1	docs: add missing deprecation notes (#420 )	2024-10-17 15:19:37 +02:00
diniamo	ff9b0eeb1f	nvim-cmp: fix rewrite remnants (#419 ) * fix: bad cmp confirm * nvim-cmp: simplify confirm bind and mapping definitions --------- Co-authored-by: Pei Yang Ching <59727193+horriblename@users.noreply.github.com>	2024-10-17 05:57:29 +00:00
diniamo	54ec473039	comment-nvim: fix visual mappings (#417 )	2024-10-15 18:05:05 +02:00
Soliprem	a7e0542fd0	neorg: init (#413 ) * neorg: init * neorg: setupOpts work * neorg: disable by default * neorg: added changelog entry * neorg: setupOpts setup correctly * neorg: sane default for setupOpts * neorg: changed description and removed reduntant treesitter activation * neorg: added vim.treesitter.enable * neorg: fixing capitalisation * neorg: adding descriptions * neorg: formatting * neorg: added newline at the end of docs	2024-10-15 15:31:18 +00:00
Soliprem	94d2b837cf	leap: changing default binds (#416 ) * leap: changed default binds * leap: added changelog entry * leap: fixing requested change Co-authored-by: diniamo <55629891+diniamo@users.noreply.github.com> * Revert "leap: added changelog entry" This reverts commit `6aac9b2580`. * leap: added changelog entry * leap: fix inherits --------- Co-authored-by: diniamo <55629891+diniamo@users.noreply.github.com>	2024-10-14 22:47:44 +02:00
raf	be81f19b5f	Merge branch 'main' into v0.7	2024-10-14 11:55:43 +00:00
Ching Pei Yang	f5d33f6a53	wrapper: disableDefaultRuntimePaths --- Co-authored-by: NotAShelf <raf@notashelf.dev>	2024-10-14 14:21:35 +03:00
ksonj	caaacbf59c	languages/scala: Add scala language support (#399 ) * languages/scala: Add scala language support Adds LSP support for Scala via nvim-metals * Fix luaInline import * Add changelog entry for Scala support to 0.7 release notes --------- Co-authored-by: raf <raf@notashelf.dev>	2024-10-12 03:43:33 +00:00
Soliprem	c0790c5494	languages/kotlin: init (#390 ) * merge * created otter file merge * update merge * update merge * committing flake.lock merge * merge * haskell: added LSP and treesitter * haskell: default to isMaximal * haskell: haskell support * kotlin: LSP and treesitter * haskell: LSP cmd definition * haskell: LSP cmd definition (currently broken) * kotlin: LSP and treesitter working * removing haskell from kotlin branch * merge * merge * kotlin: capitalisation * kotlin: implemented formatter * kotlin: cleanup * kotlin: formatter and linter both work * kotlin: cleanup * kotlin: massive speedup in loadtimes for lsp * otter: cleanup * kotlin: changelog entry * flake.lock: reverting accidental formatting * kotlin: removed redundant description * kotlin: fixed typo * kotlin: using symlinkjoin better * kotlin: moved wrapper to example * kotlin: cleaning up and fixing docs render --------- Co-authored-by: raf <raf@notashelf.dev>	2024-10-10 20:14:52 +02:00
diniamo	7dbd1cd8d1	treewide: rewrite autocompletion module and related stuff (#404 ) * modules/completion: rewrite * treewide: remove vsnip, add luasnip * nvim-cmp: add default sorting * nvim-cmp: load after luasnip * lib: fix docs for mergelessListOf * docs: add changelog entires for rewrite * deprecations: add rewrite deprecations * nvim-cmp: clarify in format description * docs: fix option reference in release notes * treewide: remove reduant `// {default = false;}`s * luasnip: add missing `{option}` for option reference * deprecations: add entry for vsnip * nvim-autopairs: use multiline string * nvim-dap: use outer attribute	2024-10-09 17:50:34 +00:00
raf	ef413736e9	Merge branch 'main' into v0.7	2024-10-07 00:40:13 +00:00
Ching Pei Yang	b39b84490f	Docs/map rewrite (#403 ) * doc: fix formatting * docs: update keymaps section	2024-10-06 14:03:21 +00:00
diniamo	7a8b95cf7c	Surround setupopts (#402 ) * surround: fix keymaps * surround: make description multi-line	2024-10-06 14:35:07 +03:00
Ching Pei Yang	b637f921d5	maps: allow same key on multiple mode (#360 ) * mappings: add new keymap option * mappings: impl keymap option * doc: update release notes * map: fix misinformation * map: remove redundant variable * fixup! mappings: impl keymap option	2024-10-06 11:23:01 +02:00
NotAShelf	649f5513f9	flake.lock: Update Flake lock file updates: • Updated input 'plugin-catppuccin': 'github:catppuccin/nvim/5215ea59df6d0a7e27da9a5cd1165e06d1b04cbe' (2024-05-26) → 'github:catppuccin/nvim/7be452ee067978cdc8b2c5f3411f0c71ffa612b9' (2024-10-05)	2024-10-06 02:41:05 +03:00
raf	18ae3e1f6c	Merge branch 'main' into v0.7	2024-10-05 23:40:48 +00:00
raf	3299facbaa	Merge branch 'main' into v0.7	2024-10-05 13:48:20 +00:00
Charlie Root	bdf777dc8a	feature: add base16 support (#389 ) * modules: add base16 Theming support theme/theme.nix: fix formatting supported-themes.nix: formatting clean up base16-colors.nix theme: fix plugin setup, change base16 flake input * theme/theme.nix: fix formatting * types/theme.nix: add check regex matching types/theme.nix: fixed regex matching * lib/types: rename custom.nix to types.nix, mov theme.nix into types.nix * plugins/theme: apply requested changes types/types.nix: remove unneeded inherit theme/theme.nix: remove commented inherit * theme/theme.nix: fix up base16 helper func Co-authored-by: diniamo <55629891+diniamo@users.noreply.github.com> * theme/theme.nix: move listToAttrs inheriting, fix base16-colors declaration * theme/theme.nix: add documentation to vim.theme.name * release-notes/rl-0.7.md: add changelog entry for base16 * theme/theme.nix: fix documentation rendering --------- Co-authored-by: diniamo <55629891+diniamo@users.noreply.github.com>	2024-10-05 16:47:33 +03:00
Ching Pei Yang	6670d752c7	fix: missing function (#388 )	2024-09-29 14:35:11 +02:00
raf	5826aebdd3	Merge branch 'main' into v0.7	2024-09-29 00:23:56 +00:00
raf	a6c879e8a3	Merge branch 'main' into v0.7	2024-09-26 14:44:26 +00:00
raf	141a272747	Merge branch 'main' into v0.7	2024-09-24 10:54:31 +00:00
Ching Pei Yang	941a2a6f2e	Merge branch 'main' into v0.7	2024-08-24 14:37:46 +02:00
Ching Pei Yang	e40cce5653	fix: map descriptions (#358 ) * remove unused * maps: fix missing description	2024-08-17 13:08:47 +02:00
Ching Pei Yang	2fc7dc798b	Re-add old maps API (#356 ) * wrapper: fix wrong import source * wrapper: fix typo * Revert "lib/binds: improve code, adjust functions to new api" This reverts commit `6cb57e1d26`. * mappings: re-add legacy vim.maps API * mappings: fix wrong submodule syntax * docs: fix missing section id	2024-08-13 00:27:05 +02:00
raf	3ca7e3b841	Merge branch 'main' into v0.7	2024-08-12 00:10:03 +00:00
diniamo	b71bf75dcd	vim.maps rewrite (#352 ) * feat: rewrite vim.maps * modules/mappings: enable silent by default * docs: add entry for vim.maps rewrite * lib/binds: improve code, adjust functions to new api	2024-08-12 00:07:45 +00:00