NotAShelf/nvf
2
1
Fork 0
mirror of https://github.com/NotAShelf/nvf.git synced 2026-04-09 03:56:11 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Merge 3860063606 into d6746a7510

Browse source
This commit is contained in:
Alfarel 2026-04-08 00:20:10 +02:00 • committed by GitHub
commit b6b8b90e97
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
52 changed files with 485 additions and 623 deletions
Download patch file Download diff file Expand all files Collapse all files

8
docs/manual/configuring/keybinds.md
View file

@ -1,8 +1,10 @@
# Custom keymaps {#ch-keymaps}
Some plugin modules provide keymap options for your convenience. If a keymap is
not provided by such module options, you may easily register your own custom
keymaps via {option}`vim.keymaps`.
Some plugin modules provide keymap options for your convenience. These can be
disabled using {option}`vim.vendoredKeymaps`. It is also possible to disable
individual keymaps with options by setting them to `null`. If a keymap is not
provided by a module, you may easily register your own custom keymaps via
{option}`vim.keymaps`.
```nix
{

2
docs/manual/hacking.md
View file

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

1
docs/manual/release-notes/rl-0.9.md
View file

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

1
modules/modules.nix
View file

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

4
modules/neovim/mappings/options.nix
View file

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

8
modules/plugins/assistant/chatgpt/chatgpt.nix
View file

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

10
modules/plugins/assistant/copilot/config.nix
View file

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

76
modules/plugins/assistant/copilot/copilot.nix
View file

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

8
modules/plugins/assistant/neocodeium/neocodeium.nix
View file

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

28
modules/plugins/assistant/supermaven-nvim/supermaven-nvim.nix
View file

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

8
modules/plugins/comments/comment-nvim/comment-nvim.nix
View file

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

8
modules/plugins/completion/blink-cmp/blink-cmp.nix
View file

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

88
modules/plugins/completion/blink-cmp/config.nix
View file

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

84
modules/plugins/completion/nvim-cmp/config.nix
View file

@ -3,6 +3,7 @@
config,
...
}: let
inherit (lib.attrsets) filterAttrs mapAttrs';
inherit (lib.modules) mkIf;
inherit (lib.strings) optionalString;
inherit (lib.generators) mkLuaInline;
@ -72,48 +73,53 @@ in {
formatting.format = cfg.format;
# `cmp` and `luasnip` are defined above, in the `nvim-cmp` section
mapping = {
${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 })";
mapping =
mapAttrs' (mapping-name: action: {
name = mappings.${mapping-name};
value = action;
}) (filterAttrs (mapping-name: _action: mappings.${mapping-name} != null)
{
complete = mkLuaInline "cmp.mapping.complete()";
close = mkLuaInline "cmp.mapping.abort()";
scrollDocsUp = mkLuaInline "cmp.mapping.scroll_docs(-4)";
scrollDocsDown = mkLuaInline "cmp.mapping.scroll_docs(4)";
confirm = mkLuaInline "cmp.mapping.confirm({ select = true })";
${mappings.next} = mkLuaInline ''
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
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
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)
'';
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)
'';
${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)
'';
};
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)
'';
});
};
};
};

2
modules/plugins/completion/nvim-cmp/nvim-cmp.nix
View file

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

8
modules/plugins/debugger/nvim-dap/nvim-dap.nix
View file

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

28
modules/plugins/filetree/nvimtree/nvimtree.nix
View file

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

2
modules/plugins/git/git-conflict/git-conflict.nix
View file

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

2
modules/plugins/git/gitsigns/gitsigns.nix
View file

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

8
modules/plugins/git/neogit/neogit.nix
View file

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

39
modules/plugins/languages/rust.nix
View file

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

4
modules/plugins/languages/scala.nix
View file

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

3
modules/plugins/languages/typst.nix
View file

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

88
modules/plugins/lsp/module.nix
View file

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

8
modules/plugins/lsp/nvim-docs-view/nvim-docs-view.nix
View file

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

8
modules/plugins/lsp/otter/otter.nix
View file

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

8
modules/plugins/lsp/trouble/trouble.nix
View file

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

8
modules/plugins/minimap/codewindow/codewindow.nix
View file

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

3
modules/plugins/notes/todo-comments/todo-comments.nix
View file

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

8
modules/plugins/runner/run-nvim/run-nvim.nix
View file

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

34
modules/plugins/session/nvim-session-manager/nvim-session-manager.nix
View file

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

2
modules/plugins/tabline/nvim-bufferline/nvim-bufferline.nix
View file

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

4
modules/plugins/terminal/toggleterm/config.nix
View file

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

11
modules/plugins/terminal/toggleterm/toggleterm.nix
View file

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

190
modules/plugins/ui/breadcrumbs/breadcrumbs.nix
View file

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

82
modules/plugins/ui/breadcrumbs/config.nix
View file

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

8
modules/plugins/utility/ccc/ccc.nix
View file

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

8
modules/plugins/utility/gestures/gesture-nvim/gesture-nvim.nix
View file

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

8
modules/plugins/utility/harpoon/harpoon.nix
View file

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

40
modules/plugins/utility/motion/flash/flash.nix
View file

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

8
modules/plugins/utility/motion/hop/hop.nix
View file

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

40
modules/plugins/utility/motion/leap/leap.nix
View file

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

8
modules/plugins/utility/outline/aerial-nvim/aerial-nvim.nix
View file

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

8
modules/plugins/utility/preview/glow/glow.nix
View file

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

8
modules/plugins/utility/smart-splits/smart-splits.nix
View file

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

5
modules/plugins/utility/surround/surround.nix
View file

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

2
modules/plugins/utility/telescope/telescope.nix
View file

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

8
modules/plugins/utility/yazi-nvim/yazi-nvim.nix
View file

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

8
modules/plugins/visuals/cellular-automaton/cellular-automaton.nix
View file

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

20
modules/wrapper/lib/config.nix Normal file
View file

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

6
modules/wrapper/lib/default.nix Normal file
View file

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

11
modules/wrapper/lib/options.nix Normal file
View file

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