NotAShelf/nvf
2
1
Fork 0
mirror of https://github.com/NotAShelf/nvf.git synced 2025-11-11 16:05:30 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'main' into feature/codecompanion-nvim

Browse source
This commit is contained in:
army castillo 2025-03-11 20:31:04 -04:00
commit 618776eebf
51 changed files with 1741 additions and 733 deletions
Download patch file Download diff file Expand all files Collapse all files

2
.editorconfig
View file

@ -14,7 +14,7 @@ indent_style = space
indent_size = 2
trim_trailing_whitespace = false
[*.{js,json,nix,yml,yaml}]
[*.{js,json,nix,yml,yaml,toml}]
indent_style = space
indent_size = 2
tab_width = 2

2
.github/README.md vendored
View file

@ -237,7 +237,7 @@ customizability of plugin inputs, which is one of our primary features.
an imperative path (e.g., `~/.config/nvim`) for my Neovim configuration instead
of a configuration generated from Nix?
**A**: Yes! Add `"~/.config.nvim"` to `vim.additionalRuntimePaths = [ ... ]` and
**A**: Yes! Add `"~/.config/nvim"` to `vim.additionalRuntimePaths = [ ... ]` and
any plugins you want to load to `vim.startPlugins`. This will load your
configuration from `~/.config/nvim`. You may still use `vim.*` to modify
Neovim's behaviour with Nix.

11
.github/typos.toml vendored
View file

@ -1,5 +1,10 @@
default.extend-ignore-words-re = ["(?i)(noice)", "befores", "annote", "viw"]
files.extend-exclude = [
"npins/sources.json"
files.extend-exclude = ["npins/sources.json"]
default.extend-ignore-words-re = [
"(?i)(noice)",
"befores",
"annote",
"viw",
"BA", # somehow "BANanaD3V" is valid, but BA is not...
]

2
.github/workflows/cachix.yml vendored
View file

@ -36,7 +36,7 @@ jobs:
- name: Install Nix
uses: DeterminateSystems/nix-installer-action@main
- uses: cachix/cachix-action@v15
- uses: cachix/cachix-action@v16
with:
authToken: ${{ secrets.CACHIX_TOKEN }}
extraPullNames: nix-community

7
configuration.nix
View file

@ -173,17 +173,18 @@ isMaximal: {
utility = {
ccc.enable = false;
vim-wakatime.enable = false;
icon-picker.enable = isMaximal;
surround.enable = isMaximal;
diffview-nvim.enable = true;
yanky-nvim.enable = false;
icon-picker.enable = isMaximal;
surround.enable = isMaximal;
leetcode-nvim.enable = isMaximal;
multicursors.enable = isMaximal;
motion = {
hop.enable = true;
leap.enable = true;
precognition.enable = isMaximal;
};
images = {
image-nvim.enable = false;
};

92
docs/release-notes/rl-0.8.md
View file

@ -3,13 +3,16 @@
## Breaking changes
- `git-conflict` keybinds are now prefixed with `<leader>` to avoid conflicting
with builtins
with builtins.
- `alpha` is now configured with nix, default config removed.
[NotAShelf](https://github.com/notashelf):
[typst-preview.nvim]: https://github.com/chomosuke/typst-preview.nvim
[render-markdown.nvim]: https://github.com/MeanderingProgrammer/render-markdown.nvim
[yanky.nvim]: https://github.com/gbprod/yanky.nvim
[yazi.nvim]: https://github.com/mikavilpas/yazi.nvim
- Add [typst-preview.nvim] under
`languages.typst.extensions.typst-preview-nvim`.
@ -17,7 +20,7 @@
- Add a search widget to the options page in the nvf manual.
- Add [render-markdown.nvim] under
`languages.markdown.extensions.render-markdown-nvim`
`languages.markdown.extensions.render-markdown-nvim`.
- Implement [](#opt-vim.git.gitsigns.setupOpts) for user-specified setup table
in gitsigns configuration.
@ -46,6 +49,19 @@
- Add [yanky.nvim] to available plugins, under `vim.utility.yanky-nvim`.
- Fix plugin `setupOpts` for yanky.nvim and assert if shada is configured as a
backend while shada is disabled in Neovim options.
- Add [yazi.nvim] as a companion plugin for Yazi, the terminal file manager.
- Add [](#opt-vim.autocmds) and [](#opt-vim.augroups) to allow declaring
autocommands via Nix.
- Fix plugin `setupOpts` for yanky.nvim and assert if shada is configured as a
backend while shada is disabled in Neovim options.
- Add [yazi.nvim] as a companion plugin for Yazi, the terminal file manager.
[amadaluzia](https://github.com/amadaluzia):
[haskell-tools.nvim]: https://github.com/MrcJkb/haskell-tools.nvim
@ -56,7 +72,7 @@
[blink.cmp]: https://github.com/saghen/blink.cmp
- Add [blink.cmp] support
- Add [blink.cmp] support.
[diniamo](https://github.com/diniamo):
@ -70,8 +86,8 @@
[aerial.nvim]: (https://github.com/stevearc/aerial.nvim)
[nvim-ufo]: (https://github.com/kevinhwang91/nvim-ufo)
- Add [aerial.nvim]
- Add [nvim-ufo]
- Add [aerial.nvim].
- Add [nvim-ufo].
[LilleAila](https://github.com/LilleAila):
@ -143,8 +159,10 @@
[thamenato](https://github.com/thamenato):
[ruff]: (https://github.com/astral-sh/ruff)
[cue]: (https://cuelang.org/)
- Add [ruff] as a formatter option in `vim.languages.python.format.type`.
- Add [cue] support under `vim.languages.cue`.
[ARCIII](https://github.com/ArmandoCIII):
@ -160,20 +178,70 @@
- Add support for [nixd](https://github.com/nix-community/nixd) language server.
[folospior](https://github.com/folospior)
[jahanson](https://github.com/jahanson):
- Add [multicursors.nvim](https://github.com/smoka7/multicursors.nvim) to
available plugins, under `vim.utility.multicursors`.
- Add [hydra.nvim](https://github.com/nvimtools/hydra.nvim) as dependency for
`multicursors.nvim` and lazy loads by default.
[folospior](https://github.com/folospior):
- Fix plugin name for lsp/lspkind.
[iynaix](https://github.com/iynaix)
- Move `vim-illuminate` to `setupOpts format`
[iynaix](https://github.com/iynaix):
- Add lsp options support for [nixd](https://github.com/nix-community/nixd)
language server.
[Mr-Helpful](https://github.com/Mr-Helpful)
[Mr-Helpful](https://github.com/Mr-Helpful):
- Corrects pin names used for nvim themes
- Corrects pin names used for nvim themes.
[Libadoxon](https://github.com/Libadoxon)
[Libadoxon](https://github.com/Libadoxon):
- Add [git-conflict](https://github.com/akinsho/git-conflict.nvim) plugin for resolving git conflicts
- Add formatters for go: [gofmt](https://go.dev/blog/gofmt), [golines](https://github.com/segmentio/golines) and [gofumpt](https://github.com/mvdan/gofumpt)
- Add [git-conflict](https://github.com/akinsho/git-conflict.nvim) plugin for
resolving git conflicts.
- Add formatters for go: [gofmt](https://go.dev/blog/gofmt),
[golines](https://github.com/segmentio/golines) and
[gofumpt](https://github.com/mvdan/gofumpt).
[UltraGhostie](https://github.com/UltraGhostie)
- Add [harpoon](https://github.com/ThePrimeagen/harpoon) plugin for navigation
[MaxMur](https://github.com/TheMaxMur):
- Add YAML support under `vim.languages.yaml`.
[alfarel](https://github.com/alfarelcynthesis):
- Add missing `yazi.nvim` dependency (`snacks.nvim`).
- Add [mkdir.nvim](https://github.com/jghauser/mkdir.nvim) plugin for automatic
creation of parent directories when editing a nested file.
- Add [nix-develop.nvim](https://github.com/figsoda/nix-develop.nvim) plugin for
in-neovim `nix develop`, `nix shell` and more.
- Add [direnv.vim](https://github.com/direnv/direnv.vim) plugin for automatic
syncing of nvim shell environment with direnv's.
- Add [blink.cmp] source options and some default-disabled sources.
- Add [blink.cmp] option to add
[friendly-snippets](https://github.com/rafamadriz/friendly-snippets) so
blink.cmp can source snippets from it.
[TheColorman](https://github.com/TheColorman):
- Fix plugin `setupOpts` for `neovim-session-manager` having an invalid value
for `autoload_mode`.
[esdevries](https://github.com/esdevries):
[projekt0n/github-nvim-theme]: https://github.com/projekt0n/github-nvim-theme
- Add `github-nvim-theme` theme from [projekt0n/github-nvim-theme].
[BANanaD3V](https://github.com/BANanaD3V):
- `alpha` is now configured with nix.

26
flake.lock generated
View file

@ -5,11 +5,11 @@
"nixpkgs-lib": "nixpkgs-lib"
},
"locked": {
"lastModified": 1733312601,
"narHash": "sha256-4pDvzqnegAfRkPwO3wmwBhVi/Sye1mzps0zHWYnP88c=",
"lastModified": 1738453229,
"narHash": "sha256-7H9XgNiGLKN1G1CgRh0vUL4AheZSYzPm+zmZ7vxbJdo=",
"owner": "hercules-ci",
"repo": "flake-parts",
"rev": "205b12d8b7cd4802fbcb8e8ef6a0f1408781a4f9",
"rev": "32ea77a06711b758da0ad9bd6a844c5740a87abd",
"type": "github"
},
"original": {
@ -38,11 +38,11 @@
},
"mnw": {
"locked": {
"lastModified": 1735150973,
"narHash": "sha256-OJhcCAoaMMXeD6o4qI/hxBCNELJp4dN8D5LJZc8w8XA=",
"lastModified": 1738852285,
"narHash": "sha256-8Y1uyE6gGHxdU0Vcx2CMg/dAmDSxJw19aAl3TKbbo54=",
"owner": "Gerg-L",
"repo": "mnw",
"rev": "40cd0b006cc48dffd0f8698ad7f54cf1d56779a6",
"rev": "6ae73dc9cb72cea17bcc2e3d4670825f483e80e8",
"type": "github"
},
"original": {
@ -77,11 +77,11 @@
},
"nixpkgs": {
"locked": {
"lastModified": 1737370608,
"narHash": "sha256-hFA6SmioeqvGW/XvZa9bxniAeulksCOcj3kokdNT/YE=",
"lastModified": 1740303746,
"narHash": "sha256-XcdiWLEhjJkMxDLKQJ0CCivmYYCvA5MDxu9pMybM5kM=",
"owner": "nixos",
"repo": "nixpkgs",
"rev": "300081d0cc72df578b02d914df941b8ec62240e6",
"rev": "2d068ae5c6516b2d04562de50a58c682540de9bf",
"type": "github"
},
"original": {
@ -93,14 +93,14 @@
},
"nixpkgs-lib": {
"locked": {
"lastModified": 1733096140,
"narHash": "sha256-1qRH7uAUsyQI7R1Uwl4T+XvdNv778H0Nb5njNrqvylY=",
"lastModified": 1738452942,
"narHash": "sha256-vJzFZGaCpnmo7I6i416HaBLpC+hvcURh/BQwROcGIp8=",
"type": "tarball",
"url": "https://github.com/NixOS/nixpkgs/archive/5487e69da40cbd611ab2cadee0b4637225f7cfae.tar.gz"
"url": "https://github.com/NixOS/nixpkgs/archive/072a6db25e947df2f31aab9eccd0ab75d5b2da11.tar.gz"
},
"original": {
"type": "tarball",
"url": "https://github.com/NixOS/nixpkgs/archive/5487e69da40cbd611ab2cadee0b4637225f7cfae.tar.gz"
"url": "https://github.com/NixOS/nixpkgs/archive/072a6db25e947df2f31aab9eccd0ab75d5b2da11.tar.gz"
}
},
"nmd": {

185
modules/neovim/init/autocmds.nix Normal file
View file

@ -0,0 +1,185 @@
{
config,
lib,
...
}: let
inherit (lib.options) mkOption mkEnableOption literalExpression;
inherit (lib.lists) filter;
inherit (lib.strings) optionalString;
inherit (lib.types) nullOr submodule listOf str bool;
inherit (lib.nvim.types) luaInline;
inherit (lib.nvim.lua) toLuaObject;
inherit (lib.nvim.dag) entryAfter;
autocommandType = submodule {
options = {
enable =
mkEnableOption ""
// {
default = true;
description = "Whether to enable this autocommand";
};
event = mkOption {
type = nullOr (listOf str);
default = null;
example = ["BufRead" "BufWritePre"];
description = "The event(s) that trigger the autocommand.";
};
pattern = mkOption {
type = nullOr (listOf str);
default = null;
example = ["*.lua" "*.vim"];
description = "The file pattern(s) that determine when the autocommand applies).";
};
callback = mkOption {
type = nullOr luaInline;
default = null;
example = literalExpression ''
mkLuaInline '''
function()
print("Saving a Lua file...")
end
''''
'';
description = "The file pattern(s) that determine when the autocommand applies.";
};
command = mkOption {
type = nullOr str;
default = null;
description = "Vim command string instead of a Lua function.";
};
group = mkOption {
type = nullOr str;
default = null;
example = "MyAutoCmdGroup";
description = "An optional autocommand group to manage related autocommands.";
};
desc = mkOption {
type = nullOr str;
default = null;
example = "Notify when saving a Lua file";
description = "A description for the autocommand.";
};
once = mkOption {
type = bool;
default = false;
description = "Whether autocommand run only once.";
};
nested = mkOption {
type = bool;
default = false;
description = "Whether to allow nested autocommands to trigger.";
};
};
};
autogroupType = submodule {
options = {
enable =
mkEnableOption ""
// {
default = true;
description = "Whether to enable this autogroup";
};
name = mkOption {
type = str;
example = "MyAutoCmdGroup";
description = "The name of the autocommand group.";
};
clear = mkOption {
type = bool;
default = true;
description = ''
Whether to clear existing autocommands in this group before defining new ones.
This helps avoid duplicate autocommands.
'';
};
};
};
cfg = config.vim;
in {
options.vim = {
augroups = mkOption {
type = listOf autogroupType;
default = [];
description = ''
A list of Neovim autogroups, which are used to organize and manage related
autocommands together. Groups allow multiple autocommands to be cleared
or redefined collectively, preventing duplicate definitions.
Each autogroup consists of a name, a boolean indicating whether to clear
existing autocommands, and a list of associated autocommands.
'';
};
autocmds = mkOption {
type = listOf autocommandType;
default = [];
description = ''
A list of Neovim autocommands to be registered.
Each entry defines an autocommand, specifying events, patterns, optional
callbacks, commands, groups, and execution settings.
'';
};
};
config = {
vim = let
enabledAutocommands = filter (cmd: cmd.enable) cfg.autocmds;
enabledAutogroups = filter (au: au.enable) cfg.augroups;
in {
luaConfigRC = {
augroups = entryAfter ["pluginConfigs"] (optionalString (enabledAutogroups != []) ''
local nvf_autogroups = {}
for _, group in ipairs(${toLuaObject enabledAutogroups}) do
if group.name then
nvf_autogroups[group.name] = { clear = group.clear }
end
end
for group_name, options in pairs(nvf_autogroups) do
vim.api.nvim_create_augroup(group_name, options)
end
'');
autocmds = entryAfter ["pluginConfigs"] (optionalString (enabledAutocommands != []) ''
local nvf_autocommands = ${toLuaObject enabledAutocommands}
for _, autocmd in ipairs(nvf_autocommands) do
vim.api.nvim_create_autocmd(
autocmd.event,
{
group = autocmd.group,
pattern = autocmd.pattern,
buffer = autocmd.buffer,
desc = autocmd.desc,
callback = autocmd.callback,
command = autocmd.command,
once = autocmd.once,
nested = autocmd.nested
}
)
end
'');
};
};
assertions = [
{
assertion = builtins.all (cmd: (cmd.command == null || cmd.callback == null)) cfg.autocmds;
message = "An autocommand cannot have both 'command' and 'callback' defined at the same time.";
}
];
};
}

1
modules/neovim/init/default.nix
View file

@ -1,5 +1,6 @@
{
imports = [
./autocmds.nix
./basic.nix
./debug.nix
./highlight.nix

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

@ -2,7 +2,7 @@
inherit (lib.options) mkEnableOption mkOption literalMD;
inherit (lib.types) listOf str either attrsOf submodule enum anything int nullOr;
inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.types) mkPluginSetupOption luaInline;
inherit (lib.nvim.types) mkPluginSetupOption luaInline pluginType;
inherit (lib.nvim.binds) mkMappingOption;
inherit (lib.nvim.config) mkBool;
@ -37,12 +37,6 @@ in {
description = "Default list of sources to enable for completion.";
};
cmdline = mkOption {
type = nullOr (listOf str);
default = [];
description = "List of sources to enable for cmdline. Null means use default source list.";
};
providers = mkOption {
type = attrsOf providerType;
default = {};
@ -63,6 +57,14 @@ in {
};
};
cmdline = {
sources = mkOption {
type = nullOr (listOf str);
default = [];
description = "List of sources to enable for cmdline. Null means use default source list.";
};
};
completion = {
documentation = {
auto_show = mkBool true "Show documentation whenever an item is selected";
@ -116,5 +118,66 @@ in {
scrollDocsUp = mkMappingOption "Scroll docs up [blink.cmp]" "<C-d>";
scrollDocsDown = mkMappingOption "Scroll docs down [blink.cmp]" "<C-f>";
};
sourcePlugins = let
sourcePluginType = submodule {
options = {
package = mkOption {
type = pluginType;
description = ''
`blink-cmp` source plugin package.
'';
};
module = mkOption {
type = str;
description = ''
Value of {option}`vim.autocomplete.blink-cmp.setupOpts.sources.providers.<name>.module`.
Should be present in the source's documentation.
'';
};
enable = mkEnableOption "this source";
};
};
in
mkOption {
type = submodule {
freeformType = attrsOf sourcePluginType;
options = let
defaultSourcePluginOption = name: package: module: {
package = mkOption {
type = pluginType;
default = package;
description = ''
`blink-cmp` ${name} source plugin package.
'';
};
module = mkOption {
type = str;
default = module;
description = ''
Value of {option}`vim.autocomplete.blink-cmp.setupOpts.sources.providers.${name}.module`.
'';
};
enable = mkEnableOption "${name} source";
};
in {
# emoji completion after :
emoji = defaultSourcePluginOption "emoji" "blink-emoji-nvim" "blink-emoji";
# spelling suggestions as completions
spell = defaultSourcePluginOption "spell" "blink-cmp-spell" "blink-cmp-spell";
# words from nearby files
ripgrep = defaultSourcePluginOption "ripgrep" "blink-ripgrep-nvim" "blink-ripgrep";
};
};
default = {};
description = ''
`blink.cmp` sources.
Attribute names must be source names used in {option}`vim.autocomplete.blink-cmp.setupOpts.sources.default`.
'';
};
friendly-snippets.enable = mkEnableOption "friendly-snippets for blink to source from automatically";
};
}

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

@ -6,6 +6,8 @@
inherit (lib.modules) mkIf;
inherit (lib.strings) optionalString;
inherit (lib.generators) mkLuaInline;
inherit (lib.attrsets) attrValues filterAttrs;
inherit (lib.lists) map optional;
inherit (lib.nvim.lua) toLuaObject;
inherit (builtins) concatStringsSep typeOf tryEval attrNames mapAttrs;
@ -19,9 +21,12 @@
else if (plugin ? pname && (tryEval plugin.pname).success)
then plugin.pname
else plugin.name;
enabledBlinkSources = filterAttrs (_source: definition: definition.enable) cfg.sourcePlugins;
blinkSourcePlugins = map (definition: definition.package) (attrValues enabledBlinkSources);
in {
vim = mkIf cfg.enable {
startPlugins = ["blink-compat"];
startPlugins = ["blink-compat"] ++ blinkSourcePlugins ++ (optional cfg.friendly-snippets.enable "friendly-snippets");
lazy.plugins = {
blink-cmp = {
package = "blink-cmp";
@ -32,7 +37,9 @@ in {
#
# event = ["InsertEnter" "CmdlineEnter"];
after = ''
after =
# lua
''
${optionalString config.vim.lazy.enable
(concatStringsSep "\n" (map
(package: "require('lz.n').trigger_load(${toLuaObject (getPluginName package)})")
@ -45,13 +52,26 @@ in {
enableSharedCmpSources = true;
blink-cmp.setupOpts = {
sources = {
default = ["lsp" "path" "snippets" "buffer"] ++ (attrNames cmpCfg.sources);
default =
[
"lsp"
"path"
"snippets"
"buffer"
]
++ (attrNames cmpCfg.sources)
++ (attrNames enabledBlinkSources);
providers =
mapAttrs (name: _: {
inherit name;
module = "blink.compat.source";
})
cmpCfg.sources;
cmpCfg.sources
// (mapAttrs (name: definition: {
inherit name;
inherit (definition) module;
})
enabledBlinkSources);
};
snippets = mkIf config.vim.snippets.luasnip.enable {
preset = "luasnip";
@ -67,7 +87,9 @@ in {
${mappings.next} = [
"select_next"
"snippet_forward"
(mkLuaInline ''
(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

20
modules/plugins/dashboard/alpha/alpha.nix
View file

@ -1,7 +1,23 @@
{lib, ...}: let
inherit (lib.options) mkEnableOption;
inherit (lib.options) mkEnableOption mkOption;
inherit (lib.types) listOf attrsOf anything nullOr enum;
in {
options.vim.dashboard.alpha = {
enable = mkEnableOption "fast and fully programmable greeter for neovim [alpha.mvim]";
enable = mkEnableOption "fast and fully programmable greeter for neovim [alpha.nvim]";
theme = mkOption {
type = nullOr (enum ["dashboard" "startify" "theta"]);
default = "dashboard";
description = "Alpha default theme to use";
};
layout = mkOption {
type = listOf (attrsOf anything);
default = [];
description = "Alpha dashboard layout";
};
opts = mkOption {
type = attrsOf anything;
default = {};
description = "Optional global options";
};
};
}

228
modules/plugins/dashboard/alpha/config.nix
View file

@ -5,8 +5,11 @@
}: let
inherit (lib.modules) mkIf;
inherit (lib.nvim.dag) entryAnywhere;
inherit (lib.nvim.lua) toLuaObject;
cfg = config.vim.dashboard.alpha;
themeDefined = cfg.theme != null;
layoutDefined = cfg.layout != [];
in {
config = mkIf cfg.enable {
vim.startPlugins = [
@ -14,207 +17,30 @@ in {
"nvim-web-devicons"
];
# the entire credit for this dashboard configuration to https://github.com/Rishabh672003
# honestly, excellent work
vim.pluginRC.alpha = entryAnywhere ''
local alpha = require("alpha")
local plenary_path = require("plenary.path")
local dashboard = require("alpha.themes.dashboard")
local cdir = vim.fn.getcwd()
local if_nil = vim.F.if_nil
local nvim_web_devicons = {
enabled = true,
highlight = true,
}
local function get_extension(fn)
local match = fn:match("^.+(%..+)$")
local ext = ""
if match ~= nil then
ext = match:sub(2)
end
return ext
end
local function icon(fn)
local nwd = require("nvim-web-devicons")
local ext = get_extension(fn)
return nwd.get_icon(fn, ext, { default = true })
end
local function file_button(fn, sc, short_fn)
short_fn = short_fn or fn
local ico_txt
local fb_hl = {}
if nvim_web_devicons.enabled then
local ico, hl = icon(fn)
local hl_option_type = type(nvim_web_devicons.highlight)
if hl_option_type == "boolean" then
if hl and nvim_web_devicons.highlight then
table.insert(fb_hl, { hl, 0, 3 })
end
end
if hl_option_type == "string" then
table.insert(fb_hl, { nvim_web_devicons.highlight, 0, 3 })
end
ico_txt = ico .. " "
else
ico_txt = ""
end
local file_button_el = dashboard.button(sc, ico_txt .. short_fn, "<cmd>e " .. fn .. " <CR>")
local fn_start = short_fn:match(".*[/\\]")
if fn_start ~= nil then
table.insert(fb_hl, { "Comment", #ico_txt - 2, #fn_start + #ico_txt })
end
file_button_el.opts.hl = fb_hl
return file_button_el
end
local default_mru_ignore = { "gitcommit" }
local mru_opts = {
ignore = function(path, ext)
return (string.find(path, "COMMIT_EDITMSG")) or (vim.tbl_contains(default_mru_ignore, ext))
end,
}
--- @param start number
--- @param cwd string optional
--- @param items_number number optional number of items to generate, default = 10
local function mru(start, cwd, items_number, opts)
opts = opts or mru_opts
items_number = if_nil(items_number, 15)
local oldfiles = {}
for _, v in pairs(vim.v.oldfiles) do
if #oldfiles == items_number then
break
end
local cwd_cond
if not cwd then
cwd_cond = true
else
cwd_cond = vim.startswith(v, cwd)
end
local ignore = (opts.ignore and opts.ignore(v, get_extension(v))) or false
if (vim.fn.filereadable(v) == 1) and cwd_cond and not ignore then
oldfiles[#oldfiles + 1] = v
end
end
local target_width = 35
local tbl = {}
for i, fn in ipairs(oldfiles) do
local short_fn
if cwd then
short_fn = vim.fn.fnamemodify(fn, ":.")
else
short_fn = vim.fn.fnamemodify(fn, ":~")
end
if #short_fn > target_width then
short_fn = plenary_path.new(short_fn):shorten(1, { -2, -1 })
if #short_fn > target_width then
short_fn = plenary_path.new(short_fn):shorten(1, { -1 })
end
end
local shortcut = tostring(i + start - 1)
local file_button_el = file_button(fn, shortcut, short_fn)
tbl[i] = file_button_el
end
return {
type = "group",
val = tbl,
opts = {},
}
end
local default_header = {
type = "text",
val = {
[[███ ██ ███████ ██████ ██ ██ ██ ███ ███]],
[[████ ██ ██ ██ ██ ██ ██ ██ ████ ████]],
[[██ ██ ██ █████ ██ ██ ██ ██ ██ ██ ████ ██]],
[[██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██]],
[[██ ████ ███████ ██████ ████ ██ ██ ██]],
-- [[ __ ]],
-- [[ ___ ___ ___ __ __ /\_\ ___ ___ ]],
-- [[ / _ `\ / __`\ / __`\/\ \/\ \\/\ \ / __` __`\ ]],
-- [[/\ \/\ \/\ __//\ \_\ \ \ \_/ |\ \ \/\ \/\ \/\ \ ]],
-- [[\ \_\ \_\ \____\ \____/\ \___/ \ \_\ \_\ \_\ \_\]],
-- [[ \/_/\/_/\/____/\/___/ \/__/ \/_/\/_/\/_/\/_/]],
},
opts = {
position = "center",
hl = "Type",
-- wrap = "overflow";
},
}
local section_mru = {
type = "group",
val = {
{
type = "text",
val = "Recent files",
opts = {
hl = "SpecialComment",
shrink_margin = false,
position = "center",
},
},
{ type = "padding", val = 1 },
{
type = "group",
val = function()
return { mru(0, cdir) }
end,
opts = { shrink_margin = false },
},
},
}
local buttons = {
type = "group",
val = {
{ type = "text", val = "Quick links", opts = { hl = "SpecialComment", position = "center" } },
{ type = "padding", val = 1 },
-- TODO: buttons should be added based on whether or not the relevant plugin is available
dashboard.button("e", " New file", "<cmd>ene<CR>"), -- available all the time
dashboard.button("SPC F", "󰈞 Find file"), -- telescope
dashboard.button("SPC ff", "󰊄 Live grep"), -- telescope
dashboard.button("SPC p", " Projects"), -- any project
dashboard.button("q", "󰅚 Quit", "<cmd>qa<CR>"), -- available all the time
},
position = "center",
}
local config = {
layout = {
{ type = "padding", val = 2 },
default_header,
{ type = "padding", val = 2 },
section_mru,
{ type = "padding", val = 2 },
buttons,
},
opts = {
margin = 5,
setup = function()
vim.cmd([[
autocmd alpha_temp DirChanged * lua require('alpha').redraw()
]])
end,
},
}
alpha.setup(config)
vim.pluginRC.alpha = let
setupOpts =
if themeDefined
then lib.generators.mkLuaInline "require'alpha.themes.${cfg.theme}'.config"
else {
inherit (cfg) layout opts;
};
in ''
require('alpha').setup(${toLuaObject setupOpts})
'';
assertions = [
{
assertion = themeDefined || layoutDefined;
message = ''
One of 'theme' or 'layout' should be defined in Alpha configuration.
'';
}
{
assertion = !(themeDefined && layoutDefined);
message = ''
'theme' and 'layout' cannot be defined at the same time.
'';
}
];
};
}

22
modules/plugins/hydra/config.nix Normal file
View file

@ -0,0 +1,22 @@
{
config,
lib,
...
}: let
inherit (lib.modules) mkIf;
cfg = config.vim.hydra;
in {
config = mkIf cfg.enable {
vim = {
startPlugins = [];
lazy.plugins.hydra = {
package = "hydra.nvim";
setupModule = "hydra";
inherit (cfg) setupOpts;
event = ["DeferredUIEnter"];
cmd = ["MCstart" "MCvisual" "MCclear" "MCpattern" "MCvisualPattern" "MCunderCursor"];
};
};
};
}

6
modules/plugins/hydra/default.nix Normal file
View file

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

7
modules/plugins/hydra/hydra.nix Normal file
View file

@ -0,0 +1,7 @@
{lib, ...}: let
inherit (lib.options) mkEnableOption;
in {
options.vim.utility.hydra = {
enable = mkEnableOption "utility for creating custom submodes and menus [nvimtools/hydra.nvim]";
};
}

51
modules/plugins/languages/cue.nix Normal file
View file

@ -0,0 +1,51 @@
{
pkgs,
config,
lib,
...
}: let
inherit (lib.options) mkEnableOption mkOption;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) package;
inherit (lib.nvim.types) mkGrammarOption;
cfg = config.vim.languages.cue;
in {
options.vim.languages.cue = {
enable = mkEnableOption "CUE language support";
treesitter = {
enable = mkEnableOption "CUE treesitter" // {default = config.vim.languages.enableTreesitter;};
package = mkGrammarOption pkgs "cue";
};
lsp = {
enable = mkEnableOption "CUE LSP support" // {default = config.vim.languages.enableLSP;};
package = mkOption {
type = package;
default = pkgs.cue;
description = "cue lsp implementation";
};
};
};
config = mkIf cfg.enable (mkMerge [
(mkIf cfg.treesitter.enable {
vim.treesitter.enable = true;
vim.treesitter.grammars = [cfg.treesitter.package];
})
(mkIf cfg.lsp.enable {
vim.lsp.lspconfig.enable = true;
vim.lsp.lspconfig.sources.cue-lsp = ''
lspconfig.cue.setup {
capabilities = capabilities,
on_attach = default_on_attach,
cmd = {"${cfg.lsp.package}/bin/cue", "lsp"},
}
'';
})
]);
}

2
modules/plugins/languages/default.nix
View file

@ -5,6 +5,7 @@ in {
./asm.nix
./astro.nix
./bash.nix
./cue.nix
./dart.nix
./clang.nix
./css.nix
@ -39,6 +40,7 @@ in {
./nu.nix
./odin.nix
./wgsl.nix
./yaml.nix
./ruby.nix
];

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

@ -121,8 +121,6 @@
)
'';
};
nixpkgs-fmt = null; # removed
};
defaultDiagnosticsProvider = ["statix" "deadnix"];
@ -219,7 +217,6 @@ in {
${concatStringsSep ", " (attrNames formats)}
'';
}
{
assertion = cfg.lsp.server != "rnix";
message = ''

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

@ -62,6 +62,15 @@ in {
description = "Options to pass to rust analyzer";
type = str;
default = "";
example = ''
['rust-analyzer'] = {
cargo = {allFeature = true},
checkOnSave = true,
procMacro = {
enable = true,
},
},
'';
};
};
@ -141,6 +150,9 @@ in {
if isList cfg.lsp.package
then expToLua cfg.lsp.package
else ''{"${cfg.lsp.package}/bin/rust-analyzer"}''
},
default_settings = {
${cfg.lsp.opts}
},
on_attach = function(client, bufnr)
default_on_attach(client, bufnr)

72
modules/plugins/languages/yaml.nix Normal file
View file

@ -0,0 +1,72 @@
{
pkgs,
config,
lib,
...
}: let
inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.lists) isList;
inherit (lib.types) enum either listOf package str;
inherit (lib.nvim.types) mkGrammarOption;
inherit (lib.nvim.lua) expToLua;
cfg = config.vim.languages.yaml;
defaultServer = "yaml-language-server";
servers = {
yaml-language-server = {
package = pkgs.nodePackages.yaml-language-server;
lspConfig = ''
lspconfig.yamlls.setup {
capabilities = capabilities;
on_attach = default_on_attach;
cmd = ${
if isList cfg.lsp.package
then expToLua cfg.lsp.package
else ''{"${cfg.lsp.package}/bin/yaml-language-server", "--stdio"}''
},
}
'';
};
};
in {
options.vim.languages.yaml = {
enable = mkEnableOption "YAML language support";
treesitter = {
enable = mkEnableOption "YAML treesitter" // {default = config.vim.languages.enableTreesitter;};
package = mkGrammarOption pkgs "yaml";
};
lsp = {
enable = mkEnableOption "YAML LSP support" // {default = config.vim.languages.enableLSP;};
server = mkOption {
type = enum (attrNames servers);
default = defaultServer;
description = "YAML LSP server to use";
};
package = mkOption {
type = either package (listOf str);
default = servers.${cfg.lsp.server}.package;
description = "YAML 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.lsp.lspconfig.enable = true;
vim.lsp.lspconfig.sources.yaml-lsp = servers.${cfg.lsp.server}.lspConfig;
})
]);
}

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

@ -57,8 +57,8 @@ in {
};
mappings = {
viewToggle = mkMappingOption "Open or close the docs view panel" "lvt";
viewUpdate = mkMappingOption "Manually update the docs view panel" "lvu";
viewToggle = mkMappingOption "Open or close the docs view panel" "<leader>lvt";
viewUpdate = mkMappingOption "Manually update the docs view panel" "<leader>lvu";
};
};
}

13
modules/plugins/lsp/otter/config.nix
View file

@ -15,13 +15,12 @@
mappings = addDescriptionsToMappings cfg.otter-nvim.mappings mappingDefinitions;
in {
config = mkIf (cfg.enable && cfg.otter-nvim.enable) {
assertions = [
{
assertion = !config.vim.utility.ccc.enable;
message = ''
ccc and otter have a breaking conflict. It's been reported upstream. Until it's fixed, disable one of them
'';
}
warnings = [
# TODO: remove warning when we update to nvim 0.11
(mkIf config.vim.utility.ccc.enable ''
ccc and otter occasionally have small conflicts that will disappear with nvim 0.11.
In the meantime, otter handles it by throwing a warning, but both plugins will work.
'')
];
vim = {
startPlugins = ["otter-nvim"];

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

@ -1,6 +1,10 @@
{lib, ...}: let
inherit (lib.types) nullOr str bool;
inherit (lib) mkEnableOption mkOption types mkRenamedOptionModule;
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;
in {
imports = let
renameSetupOpt = oldPath: newPath:
@ -50,68 +54,100 @@ in {
usePicker = mkOption {
type = bool;
default = true;
description = "Whether or not we should use dressing.nvim to build a session picker UI";
description = ''
Whether we should use `dressing.nvim` to build a session picker UI
'';
};
setupOpts = {
setupOpts = mkPluginSetupOption "which-key" {
path_replacer = mkOption {
type = types.str;
type = str;
default = "__";
description = "The character to which the path separator will be replaced for session files";
description = ''
The character to which the path separator will be replaced for session files
'';
};
colon_replacer = mkOption {
type = types.str;
type = str;
default = "++";
description = "The character to which the colon symbol will be replaced for session files";
description = ''
The character to which the colon symbol will be replaced for session files
'';
};
autoload_mode = mkOption {
type = types.enum ["Disabled" "CurrentDir" "LastSession"];
type = either (enum ["Disabled" "CurrentDir" "LastSession"]) luaInline;
# Variable 'sm' is defined in the pluginRC of nvim-session-manager. The
# definition is as follows: `local sm = require('session_manager.config')`
apply = val:
if isString val
then mkLuaInline "sm.AutoloadMode.${val}"
else val;
default = "LastSession";
description = "Define what to do when Neovim is started without arguments. Possible values: Disabled, CurrentDir, LastSession";
description = ''
Define what to do when Neovim is started without arguments.
Takes either one of `"Disabled"`, `"CurrentDir"`, `"LastSession` in which case the value
will be inserted into `sm.AutoloadMode.<value>`, or an inline Lua value.
'';
};
max_path_length = mkOption {
type = types.nullOr types.int;
type = nullOr int;
default = 80;
description = "Shorten the display path if length exceeds this threshold. Use 0 if don't want to shorten the path at all";
description = ''
Shorten the display path if length exceeds this threshold.
Use `0` if don't want to shorten the path at all
'';
};
autosave_last_session = mkOption {
type = types.bool;
type = bool;
default = true;
description = "Automatically save last session on exit and on session switch";
description = ''
Automatically save last session on exit and on session switch
'';
};
autosave_ignore_not_normal = mkOption {
type = types.bool;
type = bool;
default = true;
description = "Plugin will not save a session when no buffers are opened, or all of them aren't writable or listed";
description = ''
Plugin will not save a session when no buffers are opened, or all of them are
not writable or listed
'';
};
autosave_ignore_dirs = mkOption {
type = types.listOf types.str;
type = listOf str;
default = [];
description = "A list of directories where the session will not be autosaved";
};
autosave_ignore_filetypes = mkOption {
type = types.listOf types.str;
type = listOf str;
default = ["gitcommit"];
description = "All buffers of these file types will be closed before the session is saved";
description = ''
All buffers of these file types will be closed before the session is saved
'';
};
autosave_ignore_buftypes = mkOption {
type = types.listOf types.str;
type = listOf str;
default = [];
description = "All buffers of these buffer types will be closed before the session is saved";
description = ''
All buffers of these buffer types will be closed before the session is saved
'';
};
autosave_only_in_session = mkOption {
type = types.bool;
type = bool;
default = false;
description = "Always autosaves session. If true, only autosaves after a session is active";
description = ''
Always autosaves session. If `true`, only autosaves after a session is active
'';
};
};
};

11
modules/plugins/statusline/lualine/lualine.nix
View file

@ -21,6 +21,17 @@
"codedark"
"dracula"
"everforest"
"github_dark"
"github_light"
"github_dark_dimmed"
"github_dark_default"
"github_light_default"
"github_dark_high_contrast"
"github_light_high_contrast"
"github_dark_colorblind"
"github_light_colorblind"
"github_dark_tritanopia"
"github_light_tritanopia"
"gruvbox"
"gruvbox_dark"
"gruvbox_light"

16
modules/plugins/theme/supported-themes.nix
View file

@ -195,4 +195,20 @@ in {
vim.cmd.colorscheme("nord")
'';
};
github = {
setup = {
style ? "dark",
transparent ? false,
...
}: ''
require('github-theme').setup({
options = {
transparent = ${boolToString transparent},
},
})
vim.cmd[[colorscheme github_${style}]]
'';
styles = ["dark" "light" "dark_dimmed" "dark_default" "light_default" "dark_high_contrast" "light_high_contrast" "dark_colorblind" "light_colorblind" "dark_tritanopia" "light_tritanopia"];
};
}

18
modules/plugins/ui/illuminate/config.nix
View file

@ -4,22 +4,20 @@
...
}: let
inherit (lib.modules) mkIf;
inherit (lib.nvim.lua) toLuaObject;
inherit (lib.nvim.dag) entryAnywhere;
cfg = config.vim.ui.illuminate;
in {
config = mkIf cfg.enable {
vim.startPlugins = ["vim-illuminate"];
vim = {
startPlugins = ["vim-illuminate"];
vim.pluginRC.vim-illuminate = entryAnywhere ''
require('illuminate').configure({
filetypes_denylist = {
'dirvish',
'fugitive',
'NvimTree',
'TelescopePrompt',
},
})
# vim-illuminate does not have a setup function. It is instead called 'configure'
# and does what you expect from a setup function. Wild.
pluginRC.vim-illuminate = entryAnywhere ''
require('illuminate').configure(${toLuaObject cfg.setupOpts})
'';
};
};
}

16
modules/plugins/ui/illuminate/illuminate.nix
View file

@ -1,7 +1,19 @@
{lib, ...}: let
inherit (lib.options) mkEnableOption;
inherit (lib.options) mkOption mkEnableOption;
inherit (lib.types) listOf str;
inherit (lib.nvim.types) mkPluginSetupOption;
in {
options.vim.ui.illuminate = {
enable = mkEnableOption "automatically highlight other uses of the word under the cursor [vim-illuminate]";
enable = mkEnableOption ''
automatically highlight other uses of the word under the cursor [vim-illuminate]
'';
setupOpts = mkPluginSetupOption "vim-illuminate" {
filetypes_denylist = mkOption {
type = listOf str;
default = ["dirvish" "fugitive" "NvimTree" "TelescopePrompt"];
description = "Filetypes to not illuminate, this overrides `filetypes_allowlist`";
};
};
};
}

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

@ -3,18 +3,24 @@
./binds
./ccc
./diffview
./direnv
./fzf-lua
./gestures
./harpoon
./icon-picker
./images
./leetcode-nvim
./mkdir
./motion
./multicursors
./new-file-template
./nix-develop
./outline
./preview
./surround
./telescope
./wakatime
./yanky-nvim
./leetcode-nvim
./yazi-nvim
];
}

13
modules/plugins/utility/direnv/config.nix Normal file
View file

@ -0,0 +1,13 @@
{
config,
lib,
...
}: let
inherit (lib.modules) mkIf;
cfg = config.vim.utility.direnv;
in {
vim = mkIf cfg.enable {
startPlugins = ["direnv-vim"];
};
}

6
modules/plugins/utility/direnv/default.nix Normal file
View file

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

5
modules/plugins/utility/direnv/direnv.nix Normal file
View file

@ -0,0 +1,5 @@
{lib, ...}: let
inherit (lib.options) mkEnableOption;
in {
options.vim.utility.direnv.enable = mkEnableOption "syncing nvim shell environment with direnv's using `direnv.vim`";
}

41
modules/plugins/utility/harpoon/config.nix Normal file
View file

@ -0,0 +1,41 @@
{
options,
config,
lib,
...
}: let
inherit (lib.modules) mkIf;
inherit (lib.nvim.binds) pushDownDefault mkKeymap;
cfg = config.vim.navigation.harpoon;
keys = cfg.mappings;
inherit (options.vim.navigation.harpoon) mappings;
in {
config = mkIf cfg.enable {
vim = {
startPlugins = ["plenary-nvim"];
lazy.plugins.harpoon = {
package = "harpoon";
setupModule = "harpoon";
inherit (cfg) setupOpts;
cmd = ["Harpoon"];
keys = [
(mkKeymap "n" keys.markFile "<Cmd>lua require('harpoon'):list():add()<CR>" {desc = mappings.markFile.description;})
(mkKeymap "n" keys.listMarks "<Cmd>lua require('harpoon').ui:toggle_quick_menu(require('harpoon'):list())<CR>" {desc = mappings.listMarks.description;})
(mkKeymap "n" keys.file1 "<Cmd>lua require('harpoon'):list():select(1)<CR>" {desc = mappings.file1.description;})
(mkKeymap "n" keys.file2 "<Cmd>lua require('harpoon'):list():select(2)<CR>" {desc = mappings.file2.description;})
(mkKeymap "n" keys.file3 "<Cmd>lua require('harpoon'):list():select(3)<CR>" {desc = mappings.file3.description;})
(mkKeymap "n" keys.file4 "<Cmd>lua require('harpoon'):list():select(4)<CR>" {desc = mappings.file4.description;})
];
};
binds.whichKey.register = pushDownDefault {
"<leader>a" = "Harpoon Mark";
};
};
};
}

6
modules/plugins/utility/harpoon/default.nix Normal file
View file

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

53
modules/plugins/utility/harpoon/harpoon.nix Normal file
View file

@ -0,0 +1,53 @@
{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;
in {
options.vim.navigation.harpoon = {
mappings = {
markFile = mkMappingOption "Mark file [Harpoon]" "<leader>a";
listMarks = mkMappingOption "List marked files [Harpoon]" "<C-e>";
file1 = mkMappingOption "Go to marked file 1 [Harpoon]" "<C-j>";
file2 = mkMappingOption "Go to marked file 2 [Harpoon]" "<C-k>";
file3 = mkMappingOption "Go to marked file 3 [Harpoon]" "<C-l>";
file4 = mkMappingOption "Go to marked file 4 [Harpoon]" "<C-;>";
};
enable = mkEnableOption "Quick bookmarks on keybinds [Harpoon]";
setupOpts = mkPluginSetupOption "Harpoon" {
defaults = {
save_on_toggle = mkOption {
type = bool;
default = false;
description = ''
Any time the ui menu is closed then we will save the
state back to the backing list, not to the fs
'';
};
sync_on_ui_close = mkOption {
type = bool;
default = false;
description = ''
Any time the ui menu is closed then the state of the
list will be sync'd back to the fs
'';
};
key = mkOption {
type = luaInline;
default = mkLuaInline ''
function()
return vim.loop.cwd()
end
'';
description = ''
How the out list key is looked up. This can be useful
when using worktrees and using git remote instead of file path
'';
};
};
};
};
}

12
modules/plugins/utility/mkdir/config.nix Normal file
View file

@ -0,0 +1,12 @@
{
config,
lib,
...
}: let
inherit (lib.modules) mkIf;
cfg = config.vim.utility.mkdir;
in {
vim = mkIf cfg.enable {
startPlugins = ["mkdir-nvim"];
};
}

6
modules/plugins/utility/mkdir/default.nix Normal file
View file

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

7
modules/plugins/utility/mkdir/mkdir.nix Normal file
View file

@ -0,0 +1,7 @@
{lib, ...}: let
inherit (lib.options) mkEnableOption;
in {
options.vim.utility.mkdir.enable = mkEnableOption ''
parent directory creation when editing a nested path that does not exist using `mkdir.nvim`
'';
}

36
modules/plugins/utility/multicursors/config.nix Normal file
View file

@ -0,0 +1,36 @@
{
config,
lib,
...
}: let
inherit (lib.modules) mkIf;
cfg = config.vim.utility.multicursors;
in {
config = mkIf cfg.enable {
vim = {
startPlugins = ["hydra-nvim"];
lazy.plugins."multicursors-nvim" = {
package = "multicursors-nvim";
setupModule = "multicursors";
inherit (cfg) setupOpts;
event = ["DeferredUIEnter"];
cmd = ["MCstart" "MCvisual" "MCclear" "MCpattern" "MCvisualPattern" "MCunderCursor"];
keys = [
{
mode = ["v" "n"];
key = "<leader>mcs";
action = ":MCstart<cr>";
desc = "Create a selection for selected text or word under the cursor [multicursors.nvim]";
}
{
mode = ["v" "n"];
key = "<leader>mcp";
action = ":MCpattern<cr>";
desc = "Create a selection for pattern entered [multicursors.nvim]";
}
];
};
};
};
}

6
modules/plugins/utility/multicursors/default.nix Normal file
View file

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

138
modules/plugins/utility/multicursors/multicursors.nix Normal file
View file

@ -0,0 +1,138 @@
{lib, ...}: let
inherit (lib.options) mkOption mkEnableOption;
inherit (lib.types) attrsOf nullOr bool int str submodule;
inherit (lib.nvim.types) mkPluginSetupOption;
hintConfig = {
options = {
float_opts = mkOption {
description = "The options for the floating hint window";
type = submodule {
options = {
border = mkOption {
type = str;
default = "none";
description = "The border style for the hint window";
};
};
};
};
position = mkOption {
type = str;
default = "bottom";
description = "The position of the hint window";
};
};
};
generateHints = {
options = {
normal = mkOption {
type = bool;
default = true;
description = "Generate hints for the normal mode";
};
insert = mkOption {
type = bool;
default = true;
description = "Generate hints for the insert mode";
};
extend = mkOption {
type = bool;
default = true;
description = "Generate hints for the extend mode";
};
config = mkOption {
description = "The configuration for generating hints for multicursors.nvim";
type = submodule {
options = {
column_count = mkOption {
type = nullOr int;
default = null;
description = "The number of columns to use for the hint window";
};
max_hint_length = mkOption {
type = int;
default = 25;
description = "The maximum length of the hint";
};
};
};
default = {
column_count = null;
max_hint_length = 25;
};
};
};
};
in {
options.vim.utility.multicursors = {
enable = mkEnableOption "vscode like multiple cursors [multicursor.nvim]";
setupOpts = mkPluginSetupOption "multicursors" {
DEBUG_MODE = mkOption {
type = bool;
default = false;
description = "Enable debug mode.";
};
create_commands = mkOption {
type = bool;
default = true;
description = "Create Multicursor user commands";
};
updatetime = mkOption {
type = int;
default = 50;
description = "The time in milliseconds to wait before updating the cursor in insert mode";
};
nowait = mkOption {
type = bool;
default = true;
description = "Don't wait for the cursor to move before updating the cursor";
};
mode_keys = mkOption {
type = attrsOf str;
default = {
insert = "i";
append = "a";
change = "c";
extend = "e";
};
description = "The keys to use for each mode";
};
hint_config = mkOption {
type = submodule hintConfig;
default = {
float_opts.border = "none";
position = "bottom";
};
description = "The configuration for the hint window";
};
generate_hints = mkOption {
type = submodule generateHints;
default = {
normal = true;
insert = true;
extend = true;
config = {
column_count = null;
max_hint_length = 25;
};
};
description = "The configuration for generating hints";
};
};
};
}

12
modules/plugins/utility/nix-develop/config.nix Normal file
View file

@ -0,0 +1,12 @@
{
config,
lib,
...
}: let
inherit (lib.modules) mkIf;
cfg = config.vim.utility.nix-develop;
in {
vim = mkIf cfg.enable {
startPlugins = ["nix-develop-nvim"];
};
}

6
modules/plugins/utility/nix-develop/default.nix Normal file
View file

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

5
modules/plugins/utility/nix-develop/nix-develop.nix Normal file
View file

@ -0,0 +1,5 @@
{lib, ...}: let
inherit (lib.options) mkEnableOption;
in {
options.vim.utility.nix-develop.enable = mkEnableOption "in-neovim `nix develop`, `nix shell`, and more using `nix-develop.nvim`";
}

11
modules/plugins/utility/yanky-nvim/config.nix
View file

@ -11,6 +11,7 @@
cfg = config.vim.utility.yanky-nvim;
usingSqlite = cfg.setupOpts.ring.storage == "sqlite";
usingShada = cfg.setupOpts.ring.storage == "shada";
in {
config = mkIf cfg.enable {
vim = {
@ -28,5 +29,15 @@ in {
require("yanky").setup(${toLuaObject cfg.setupOpts});
'';
};
assertions = [
{
assertion = usingShada && ((config.vim.options.shada or "") == "");
message = ''
Yanky.nvim is configured to use 'shada' for the storage backend, but shada is disabled
in 'vim.options'. Please re-enable shada, or switch to a different backend.
'';
}
];
};
}

11
modules/plugins/utility/yanky-nvim/yanky-nvim.nix
View file

@ -1,13 +1,14 @@
{lib, ...}: let
inherit (lib.options) mkEnableOption mkOption;
inherit (lib.options) mkOption mkEnableOption;
inherit (lib.types) enum;
inherit (lib.nvim.types) mkPluginSetupOption;
in {
options.vim.utility.yanky-nvim = {
enable = mkEnableOption ''
improved Yank and Put functionalities for Neovim [yanky-nvim]
'';
setupOpts = {
setupOpts = mkPluginSetupOption "yanky-nvim" {
ring.storage = mkOption {
type = enum ["shada" "sqlite" "memory"];
default = "shada";
@ -15,11 +16,11 @@ in {
description = ''
storage mode for ring values.
- shada: this will save pesistantly using Neovim ShaDa feature.
- **shada**: this will save pesistantly using Neovim ShaDa feature.
This means that history will be persisted between each session of Neovim.
- memory: each Neovim instance will have his own history and it will be
- **memory**: each Neovim instance will have his own history and it will be
lost between sessions.
- sqlite: more reliable than `shada`, requires `sqlite.lua` as a dependency.
- **sqlite**: more reliable than `shada`, requires `sqlite.lua` as a dependency.
nvf will add this dependency to `PATH` automatically.
'';
};

33
modules/plugins/utility/yazi-nvim/config.nix Normal file
View file

@ -0,0 +1,33 @@
{
options,
config,
pkgs,
lib,
...
}: let
inherit (lib.modules) mkIf;
inherit (lib.nvim.binds) mkKeymap;
cfg = config.vim.utility.yazi-nvim;
keys = cfg.mappings;
inherit (options.vim.utility.yazi-nvim) mappings;
in {
config = mkIf cfg.enable {
vim = {
startPlugins = ["snacks-nvim"];
lazy.plugins."yazi.nvim" = {
package = pkgs.vimPlugins.yazi-nvim;
setupModule = "yazi";
inherit (cfg) setupOpts;
event = ["BufAdd" "VimEnter"];
keys = [
(mkKeymap "n" keys.openYazi "<cmd>Yazi<CR>" {desc = mappings.openYazi.description;})
(mkKeymap "n" keys.openYaziDir "<cmd>Yazi cwd<CR>" {desc = mappings.openYaziDir.description;})
(mkKeymap "n" keys.yaziToggle "<cmd>Yazi toggle<CR>" {desc = mappings.yaziToggle.description;})
];
};
};
};
}

6
modules/plugins/utility/yazi-nvim/default.nix Normal file
View file

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

26
modules/plugins/utility/yazi-nvim/yazi-nvim.nix Normal file
View file

@ -0,0 +1,26 @@
{lib, ...}: let
inherit (lib.options) mkEnableOption mkOption;
inherit (lib.types) bool;
inherit (lib.nvim.types) mkPluginSetupOption;
inherit (lib.nvim.binds) mkMappingOption;
in {
options.vim.utility.yazi-nvim = {
enable = mkEnableOption ''
companion plugin for the yazi terminal file manager [yazi-nvim]
'';
mappings = {
openYazi = mkMappingOption "Open yazi at the current file [yazi.nvim]" "<leader>-";
openYaziDir = mkMappingOption "Open the file manager in nvim's working directory [yazi.nvim]" "<leader>cw";
yaziToggle = mkMappingOption "Resume the last yazi session [yazi.nvim]" "<c-up>";
};
setupOpts = mkPluginSetupOption "yazi-nvim" {
open_for_directories = mkOption {
type = bool;
default = false;
description = "Whether to open Yazi instead of netrw";
};
};
};
}

9
modules/wrapper/lazy/lazy.nix
View file

@ -172,7 +172,14 @@
description = "Lazy-load on colorscheme.";
};
lazy = mkBool false "Lazy-load manually, e.g. using `trigger_load`.";
lazy = mkOption {
type = nullOr bool;
default = null;
description = ''
Force enable/disable lazy-loading. `null` means only lazy-load if
a valid lazy-load condition is set e.g. `cmd`, `ft`, `keys` etc.
'';
};
priority = mkOption {
type = nullOr int;

972
npins/sources.json
View file

File diff suppressed because it is too large Load diff