NotAShelf/nvf
2
1
Fork 0
mirror of https://github.com/NotAShelf/nvf.git synced 2026-05-18 21:17:23 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'main' into fix/invalid-keys-in-haskell-tools

Browse source
This commit is contained in:
D.A. Marcyes 2026-05-15 14:06:34 -06:00 • committed by GitHub
commit 9361263373
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
17 changed files with 627 additions and 130 deletions
Download patch file Download diff file Expand all files Collapse all files

4
configuration.nix
View file

@ -79,6 +79,7 @@ isMaximal: {
toml.enable = isMaximal;
xml.enable = isMaximal;
tex.enable = isMaximal;
docker.enable = isMaximal;
# Language modules that are not as common.
openscad.enable = false;
@ -112,10 +113,11 @@ isMaximal: {
gettext.enable = false;
fluent.enable = false;
jq.enable = false;
fish.enable = false;
# Nim LSP is broken on Darwin and therefore
# should be disabled by default. Users may still enable
# `vim.languages.vim` to enable it, this does not restrict
# `vim.languages.nim` to enable it, this does not restrict
# that.
# See: <https://github.com/PMunch/nimlsp/issues/178#issue-2128106096>
nim.enable = false;

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

@ -301,6 +301,8 @@
[Snoweuph](https://github.com/snoweuph)
- Add `emmet-ls` to the supported LSPs for all languages it supports.
- Added {option}`vim.treesitter.queries` to support adding custom queries.
- Added injections for `query = '' ... ''` as `query` and `mkLualine '' ... ''`,
@ -325,13 +327,15 @@
more flexibility in nvf and reuse of LSPs across languages. Dropped
`deprecatedSingleOrListOf` in favor of `listOf` for the affected LSP options.
- Added {option}`vim.lsp.presets.docker-language-server.enable` for Docker
support.
- Added {option}`vim.lsp.presets.angular-language-server.enable` for Angular
Template support.
- Added {option}`vim.lsp.presets.vtsls.enable` for Vue TypeScript support.
- Added {option}`vim.lsp.presets.vue-language-server.enable` for Vue Template
support.
- Added {option}`vim.lsp.presets.some-sass-language-server.enable`.
@ -349,6 +353,10 @@
- Added [Selenen](https://github.com/kampfkarren/selene) for more diagnostics in
`languages.lua`.
- Added `languages.docker` for Docker and Docker-Compose support. Thanks to
[poseidon-rises](https://github.com/poseidon-rises) for creating most of it in
[!1104](https://github.com/NotAShelf/nvf/pull/1104).
- Added [`mdformat`](https://mdformat.rtfd.io/) support to `languages.markdown`
with the extensions for [GFM](https://github.github.com/gfm/),
[front matter](https://www.markdownlang.com/advanced/frontmatter.html) and
@ -398,6 +406,8 @@
- Fix `languages.ts` registration of formatters.
- Added `asmfmt` and `nasmfmt` formatters to `languages.asm`.
- Added `biome-check` and `biome-organize-imports` formatters to `languages.ts`.
- Added [`biomejs`](https://biomejs.dev/) as extra diagnostics provider to
@ -481,10 +491,17 @@ https://github.com/gorbit99/codewindow.nvim
[neocmakelsp]: https://github.com/neocmakelsp/neocmakelsp
[arduino-language-server]: https://github.com/arduino/arduino-language-server
[glsl_analyzer]: https://github.com/nolanderc/glsl_analyzer
[fish-lsp]: https://www.fish-lsp.dev/
[fish_indent]: https://fishshell.com/docs/current/cmds/fish_indent.html
- Add CMake support with [neocmakelsp].
- Add Arduino support with [arduino-language-server].
- Add GLSL support with [glsl_analyzer].
- Update fidget-nvim setupOpts and fix NvimTree issue.
- Add Fish support via {option}`vim.languages.fish.enable` using [fish-lsp] and
[fish_indent]. Most of the work done by
[poseidon-rises](https://github.com/poseidon-rises) in
[!1107](https://github.com/NotAShelf/nvf/pull/1107).
[itscrystalline](https://github.com/itscrystalline):

2
modules/plugins/filetree/nvimtree/config.nix
View file

@ -19,6 +19,8 @@ in {
"<leader>t" = "+NvimTree";
};
visuals.fidget-nvim.setupOpts.notification.window.avoid = ["NvimTree"];
lazy.plugins.nvim-tree-lua = {
package = "nvim-tree-lua";
setupModule = "nvim-tree";

75
modules/plugins/languages/asm.nix
View file

@ -4,15 +4,36 @@
lib,
...
}: let
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.types) enum listOf;
inherit (lib) genAttrs;
inherit (lib.attrsets) attrNames genAttrs;
inherit (lib.generators) mkLuaInline;
inherit (lib.meta) getExe;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.nvim.types) mkGrammarOption;
cfg = config.vim.languages.assembly;
defaultServers = ["asm-lsp"];
servers = ["asm-lsp"];
defaultFormat = ["asmfmt"];
formats = {
asmfmt = {
command = getExe pkgs.asmfmt;
};
nasmfmt = {
command = getExe pkgs.nasmfmt;
args = mkLuaInline ''
function(self, ctx)
return {
"--ii", ctx.shiftwidth,
"$FILENAME",
}
end
'';
};
};
in {
options.vim.languages.assembly = {
enable = mkEnableOption "Assembly support";
@ -42,6 +63,20 @@ in {
description = "Assembly LSP server to use";
};
};
format = {
enable =
mkEnableOption "Assembly formatting"
// {
default = config.vim.languages.enableFormat;
defaultText = literalExpression "config.vim.languages.enableFormat";
};
type = mkOption {
type = listOf (enum (attrNames formats));
default = defaultFormat;
description = "Assembly formatter to use";
};
};
};
config = mkIf cfg.enable (mkMerge [
(mkIf cfg.treesitter.enable {
@ -57,9 +92,43 @@ in {
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["asm" "nasm" "masm" "vmasm" "fasm" "tasm" "tiasm" "asm68k" "asm8300"];
filetypes = [
"asm"
"nasm"
"masm"
"vmasm"
"fasm"
"tasm"
"tiasm"
"asm68k"
"asmh8300"
];
});
};
})
(mkIf cfg.format.enable {
vim.formatter.conform-nvim = {
enable = true;
setupOpts = {
formatters_by_ft = {
asm = cfg.format.type;
nasm = cfg.format.type;
masm = cfg.format.type;
vmasm = cfg.format.type;
tasm = cfg.format.type;
tiasm = cfg.format.type;
asm68k = cfg.format.type;
asmh8300 = cfg.format.type;
};
formatters =
mapListToAttrs (name: {
inherit name;
value = formats.${name};
})
cfg.format.type;
};
};
})
]);
}

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

@ -16,7 +16,7 @@
cfg = config.vim.languages.css;
defaultServer = ["vscode-css-language-server"];
servers = ["vscode-css-language-server"];
servers = ["vscode-css-language-server" "emmet-ls"];
defaultFormat = ["prettier"];
formats = {

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

@ -16,6 +16,7 @@ in {
./scss.nix
./elixir.nix
./elm.nix
./fish.nix
./fsharp.nix
./gleam.nix
./glsl.nix
@ -66,6 +67,7 @@ in {
./fluent.nix
./openscad.nix
./jq.nix
./docker.nix
# This is now a hard deprecation.
(mkRenamedOptionModule ["vim" "languages" "enableLSP"] ["vim" "lsp" "enable"])

163
modules/plugins/languages/docker.nix Normal file
View file

@ -0,0 +1,163 @@
{
config,
pkgs,
lib,
...
}: let
inherit (builtins) attrNames;
inherit (lib) genAttrs;
inherit (lib.meta) getExe;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) enum listOf;
inherit (lib.nvim.types) mkGrammarOption diagnostics;
inherit (lib.nvim.attrsets) mapListToAttrs;
cfg = config.vim.languages.docker;
defaultServers = ["docker-language-server"];
servers = ["docker-language-server"];
defaultFormat = ["dockerfmt"];
formats = {
dockerfmt = {
command = getExe pkgs.dockerfmt;
};
};
defaultDiagnosticsProvider = ["hadolint"];
diagnosticsProviders = {
hadolint = {
config.cmd = getExe (
pkgs.writeShellApplication {
name = "hadolint";
runtimeInputs = [pkgs.hadolint];
text = "hadolint -";
}
);
};
};
in {
options.vim.languages.docker = {
enable = mkEnableOption "Docker language support";
treesitter = {
enable =
mkEnableOption "Docker treesitter support"
// {
default = config.vim.languages.enableTreesitter;
defaultText = literalExpression "config.vim.languages.enableTreesitter";
};
package = mkGrammarOption pkgs "dockerfile";
};
lsp = {
enable =
mkEnableOption "Docker LSP support"
// {
default = config.vim.lsp.enable;
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = listOf (enum servers);
default = defaultServers;
description = "Docker LSP server to use";
};
};
format = {
enable =
mkEnableOption "Dockerfile formatting"
// {
default = config.vim.languages.enableFormat;
defaultText = literalExpression "config.vim.languages.enableFormat";
};
type = mkOption {
type = listOf (enum (attrNames formats));
default = defaultFormat;
description = "Dockerfile formatter to use";
};
};
extraDiagnostics = {
enable =
mkEnableOption "extra Dockerfile diagnostics"
// {
default = config.vim.languages.enableExtraDiagnostics;
};
types = diagnostics {
langDesc = "Dockerfile";
inherit diagnosticsProviders;
inherit defaultDiagnosticsProvider;
};
};
};
config = mkIf cfg.enable (mkMerge [
{
vim.autocmds = [
# Without this the LSP doesn't understand them correctly
# and there are conflicts with the YAML LSP
{
desc = "Set Docker Compose filetype";
event = ["BufRead" "BufNewFile"];
pattern = [
"compose.yml"
"compose.yaml"
"docker-compose.yml"
"docker-compose.yaml"
];
command = "set filetype=dockercompose";
}
];
}
(mkIf cfg.treesitter.enable {
vim.treesitter = {
enable = true;
grammars = [cfg.treesitter.package];
};
})
(mkIf cfg.lsp.enable {
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = [
"dockerfile"
"dockercompose"
];
});
};
})
(mkIf cfg.format.enable {
vim.formatter.conform-nvim = {
enable = true;
setupOpts = {
formatters_by_ft.dockerfile = cfg.format.type;
formatters =
mapListToAttrs (name: {
inherit name;
value = formats.${name};
})
cfg.format.type;
};
};
})
(mkIf cfg.extraDiagnostics.enable {
vim.diagnostics.nvim-lint = {
enable = true;
linters_by_ft.dockerfile = cfg.extraDiagnostics.types;
linters = mkMerge (
map (name: {
${name} = diagnosticsProviders.${name}.config;
})
cfg.extraDiagnostics.types
);
};
})
]);
}

102
modules/plugins/languages/fish.nix Normal file
View file

@ -0,0 +1,102 @@
{
config,
pkgs,
lib,
...
}: let
inherit (builtins) attrNames;
inherit (lib.options) mkOption mkEnableOption literalExpression;
inherit (lib.meta) getExe';
inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) enum bool listOf;
inherit (lib) genAttrs;
inherit (lib.nvim.types) mkGrammarOption;
inherit (lib.nvim.attrsets) mapListToAttrs;
cfg = config.vim.languages.fish;
defaultServers = ["fish-lsp"];
servers = ["fish-lsp"];
defaultFormat = ["fish_indent"];
formats = {
fish_indent = {
command = getExe' pkgs.fish "fish_indent";
};
};
in {
options.vim.languages.fish = {
enable = mkEnableOption "Fish language support";
treesitter = {
enable =
mkEnableOption "Fish treesitter"
// {
default = config.vim.languages.enableTreesitter;
defaultText = literalExpression "config.vim.languages.enableTreesitter";
};
package = mkGrammarOption pkgs "fish";
};
lsp = {
enable =
mkEnableOption "Fish LSP support"
// {
default = config.vim.lsp.enable;
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = listOf (enum servers);
default = defaultServers;
description = "Fish LSP server to use";
};
};
format = {
enable = mkOption {
type = bool;
default = config.vim.languages.enableFormat;
defaultText = literalExpression "config.vim.languages.enableFormat";
description = "Enable Fish formatting";
};
type = mkOption {
type = listOf (enum (attrNames formats));
default = defaultFormat;
description = "Fish formatter to use";
};
};
};
config = mkIf cfg.enable (mkMerge [
(mkIf cfg.treesitter.enable {
vim.treesitter = {
enable = true;
grammars = [cfg.treesitter.package];
};
})
(mkIf cfg.lsp.enable {
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["fish"];
});
};
})
(mkIf cfg.format.enable {
vim.formatter.conform-nvim = {
enable = true;
setupOpts = {
formatters_by_ft.fish = cfg.format.type;
formatters =
mapListToAttrs (name: {
inherit name;
value = formats.${name};
})
cfg.format.type;
};
};
})
]);
}

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

@ -16,7 +16,7 @@
cfg = config.vim.languages.hcl;
defaultServers = ["tofu-ls"];
servers = ["terraform-ls" "tofu-ls"];
servers = ["terraform-ls" "tofu-ls" "docker-language-server"];
defaultFormat = ["hclfmt"];
formats = {

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

@ -16,7 +16,7 @@
cfg = config.vim.languages.scss;
defaultServer = ["some-sass-language-server"];
servers = ["some-sass-language-server" "vscode-css-language-server"];
servers = ["some-sass-language-server" "vscode-css-language-server" "emmet-ls"];
defaultFormat = ["prettier"];
formats = {

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

@ -17,7 +17,7 @@
cfg = config.vim.languages.svelte;
defaultServers = ["svelte-language-server"];
servers = ["svelte-language-server"];
servers = ["svelte-language-server" "emmet-ls"];
defaultFormat = ["prettier"];
formats = let

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

@ -18,7 +18,7 @@
cfg = config.vim.languages.typescript;
defaultServers = ["typescript-language-server"];
servers = ["typescript-language-server" "deno" "typescript-go" "angular-language-server"];
servers = ["typescript-language-server" "deno" "typescript-go" "angular-language-server" "emmet-ls"];
# TODO: specify packages
defaultFormat = ["prettier"];

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

@ -16,7 +16,7 @@
cfg = config.vim.languages.vue;
defaultServers = ["vue-language-server" "vtsls"];
servers = ["vue-language-server" "vtsls" "typescript-language-server"];
servers = ["vue-language-server" "vtsls" "typescript-language-server" "emmet-ls"];
defaultFormat = ["biome" "biome-check" "biome-organize-imports"];
formats = {

2
modules/plugins/lsp/presets/default.nix
View file

@ -13,9 +13,11 @@
./cue.nix
./dart.nix
./deno.nix
./docker-language-server.nix
./elixir-ls.nix
./elm-language-server.nix
./emmet-ls.nix
./fish-lsp.nix
./fsautocomplete.nix
./gleam.nix
./glsl_analyzer.nix

33
modules/plugins/lsp/presets/docker-language-server.nix Normal file
View file

@ -0,0 +1,33 @@
{
config,
lib,
pkgs,
...
}: let
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf;
inherit (lib.nvim.types) mkLspPresetEnableOption;
cfg = config.vim.lsp.presets.docker-language-server;
in {
options.vim.lsp.presets.docker-language-server = {
enable = mkLspPresetEnableOption "docker-language-server" "Docker" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.docker-language-server = {
enable = true;
cmd = [(getExe pkgs.docker-language-server) "start" "--stdio"];
root_markers = [
".git"
"Dockerfile"
"docker-compose.yaml"
"docker-compose.yml"
"compose.yaml"
"compose.yml"
"docker-bake.json"
"docker-bake.hcl"
];
};
};
}

24
modules/plugins/lsp/presets/fish-lsp.nix Normal file
View file

@ -0,0 +1,24 @@
{
config,
lib,
pkgs,
...
}: let
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf;
inherit (lib.nvim.types) mkLspPresetEnableOption;
cfg = config.vim.lsp.presets.fish-lsp;
in {
options.vim.lsp.presets.fish-lsp = {
enable = mkLspPresetEnableOption "fish-lsp" "Fish" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.fish-lsp = {
enable = true;
cmd = [(getExe pkgs.fish-lsp) "start"];
root_markers = ["config.fish" ".git"];
};
};
}

507
modules/plugins/visuals/fidget-nvim/fidget.nix
View file

@ -25,69 +25,86 @@ in {
setupOpts = mkPluginSetupOption "Fidget" {
progress = {
poll_rate = mkOption {
description = "How frequently to poll for LSP progress messages";
type = int;
default = 0;
description = "How frequently to poll for LSP progress messages";
};
suppress_on_insert = mkOption {
description = "Suppress new messages when in insert mode";
type = bool;
default = false;
description = "Suppress new messages when in insert mode";
};
ignore_done_already = mkOption {
description = "Ignore new tasks that are already done";
type = bool;
default = false;
description = "Ignore new tasks that are already done";
};
ignore_empty_message = mkOption {
description = "Ignore new tasks with empty messages";
type = bool;
default = false;
description = "Ignore new tasks with empty messages";
};
notification_group = mkOption {
description = "How to get a progress message's notification group key";
type = luaInline;
default = mkLuaInline ''
function(msg)
return msg.lsp_client.name
end
'';
description = "How to get a progress message's notification group key";
};
clear_on_detach = mkOption {
type = nullOr luaInline;
default = mkLuaInline ''
function(client_id)
local client = vim.lsp.get_client_by_id(client_id)
return client and client.name or nil
end
'';
defaultText = literalExpression ''
default = mkLuaInline '''
function(client_id)
local client = vim.lsp.get_client_by_id(client_id)
return client and client.name or nil
end
''';
'';
description = "Clear notification group when LSP server detaches";
};
ignore = mkOption {
description = "Ignore LSP servers by name";
type = listOf str;
default = [];
description = "Ignore LSP servers by name";
};
display = {
render_limit = mkOption {
description = "Maximum number of messages to render";
type = int;
default = 16;
description = "Maximum number of messages to render";
};
done_ttl = mkOption {
description = "How long a message should persist when complete";
type = int;
default = 3;
description = "How long a message should persist when complete";
};
done_icon = mkOption {
description = "Icon shown when LSP progress tasks are completed";
type = str;
default = "✓";
description = "Icon shown when LSP progress tasks are completed";
};
done_style = mkOption {
description = "Highlight group for completed LSP tasks";
type = str;
default = "Constant";
description = "Highlight group for completed LSP tasks";
};
progress_ttl = mkOption {
description = "How long a message should persist when in progress";
type = int;
default = 99999;
description = "How long a message should persist when in progress";
};
progress_icon = {
pattern = mkOption {
description = "Pattern shown when LSP progress tasks are in progress";
type = enum [
"dots"
"dots_negative"
@ -124,60 +141,208 @@ in {
"meter"
];
default = "dots";
description = "Pattern shown when LSP progress tasks are in progress";
};
period = mkOption {
description = "Period of the pattern";
type = int;
default = 1;
description = "Period of the pattern";
};
};
progress_style = mkOption {
description = "Highlight group for in-progress LSP tasks";
type = str;
default = "WarningMsg";
description = "Highlight group for in-progress LSP tasks";
};
group_style = mkOption {
description = "Highlight group for group name (LSP server name)";
type = str;
default = "Title";
description = "Highlight group for group name (LSP server name)";
};
icon_style = mkOption {
description = "Highlight group for group icons";
type = str;
default = "Question";
description = "Highlight group for group icons";
};
priority = mkOption {
description = "Priority of the progress notification";
type = int;
default = 30;
description = "Priority of the progress notification";
};
skip_history = mkOption {
description = "Skip adding messages to history";
type = bool;
default = true;
description = "Skip adding messages to history";
};
format_message = mkOption {
description = "How to format a progress message";
type = luaInline;
default = mkLuaInline ''
require("fidget.progress.display").default_format_message
'';
description = "How to format a progress message";
};
format_annote = mkOption {
description = "How to format a progress annotation";
type = luaInline;
default = mkLuaInline ''
function(msg) return msg.title end
'';
description = "How to format a progress annotation";
};
format_group_name = mkOption {
description = "How to format a progress notification group's name";
type = luaInline;
default = mkLuaInline ''
function(group) return tostring(group) end
'';
description = "How to format a progress notification group's name";
};
overrides = mkOption {
type = attrsOf (submodule {
options = {
name = mkOption {
type = nullOr (oneOf [str luaInline]);
default = null;
description = ''
Name of the group, displayed in the notification window.
Can be a string or a function that returns a string.
If a function, it is invoked every render cycle with the items
list, useful for rendering animations and other dynamic content.
::: {.note}
If you're looking for detailed information into the function
signature, you can refer to the fidget API documentation available
[here](https://github.com/j-hui/fidget.nvim/blob/1ba38e4cbb24683973e00c2e36f53ae64da38ef5/doc/fidget-api.txt#L70-L77)
:::
'';
};
icon = mkOption {
type = nullOr (oneOf [str luaInline]);
default = null;
description = ''
Icon of the group, displayed in the notification window.
Can be a string or a function that returns a string.
If a function, it is invoked every render cycle with the items
list, useful for rendering animations and other dynamic content.
::: {.note}
If you're looking for detailed information into the function
signature, you can refer to the fidget API documentation available
[here](https://github.com/j-hui/fidget.nvim/blob/1ba38e4cbb24683973e00c2e36f53ae64da38ef5/doc/fidget-api.txt#L70-L77)
:::
'';
};
icon_on_left = mkOption {
type = nullOr bool;
default = null;
description = "If true, icon is rendered on the left instead of right";
};
annote_separator = mkOption {
type = nullOr str;
default = " ";
description = "Separator between message from annote";
};
ttl = mkOption {
type = nullOr int;
default = 5;
description = "How long a notification item should exist";
};
render_limit = mkOption {
type = nullOr int;
default = null;
description = "How many notification items to show at once";
};
group_style = mkOption {
type = nullOr str;
default = "Title";
description = "Style used to highlight group name";
};
icon_style = mkOption {
type = nullOr str;
default = null;
description = "Style used to highlight icon, if null, use group_style";
};
annote_style = mkOption {
type = nullOr str;
default = "Question";
description = "Default style used to highlight item annotes";
};
debug_style = mkOption {
type = nullOr str;
default = null;
description = "Style used to highlight debug item annotes";
};
info_style = mkOption {
type = nullOr str;
default = null;
description = "Style used to highlight info item annotes";
};
warn_style = mkOption {
type = nullOr str;
default = null;
description = "Style used to highlight warn item annotes";
};
error_style = mkOption {
type = nullOr str;
default = null;
description = "Style used to highlight error item annotes";
};
debug_annote = mkOption {
type = nullOr str;
default = null;
description = "Default annotation for debug items";
};
info_annote = mkOption {
type = nullOr str;
default = null;
description = "Default annotation for info items";
};
warn_annote = mkOption {
type = nullOr str;
default = null;
description = "Default annotation for warn items";
};
error_annote = mkOption {
type = nullOr str;
default = null;
description = "Default annotation for error items";
};
priority = mkOption {
type = nullOr int;
default = 50;
description = "Order in which group should be displayed";
};
skip_history = mkOption {
type = nullOr bool;
default = null;
description = "Whether messages should be preserved in history";
};
update_hook = mkOption {
type = nullOr (oneOf [bool luaInline]);
default = false;
description = ''
Called when an item is updated.
If false, no action is taken.
If a function, it is invoked with the item being updated.
::: {.note}
If you're looking for detailed information into the function
signature, you can refer to the fidget API documentation available
[here](https://github.com/j-hui/fidget.nvim/blob/1ba38e4cbb24683973e00c2e36f53ae64da38ef5/doc/fidget-api.txt#L114)
:::
'';
};
};
});
default = {};
example = literalExpression ''
{
rust_analyzer = {
name = "Rust Analyzer";
};
}
'';
description = ''
Overrides the default configuration for a notification group defined
in {option}`vim.visuals.fidget-nvim.setupOpts.notification.configs`.
@ -208,199 +373,51 @@ in {
}
```
'';
type = attrsOf (submodule {
options = {
name = mkOption {
description = ''
Name of the group, displayed in the notification window.
Can be a string or a function that returns a string.
If a function, it is invoked every render cycle with the items
list, useful for rendering animations and other dynamic content.
::: {.note}
If you're looking for detailed information into the function
signature, you can refer to the fidget API documentation available
[here](https://github.com/j-hui/fidget.nvim/blob/1ba38e4cbb24683973e00c2e36f53ae64da38ef5/doc/fidget-api.txt#L70-L77)
:::
'';
type = nullOr (oneOf [str luaInline]);
default = null;
};
icon = mkOption {
description = ''
Icon of the group, displayed in the notification window.
Can be a string or a function that returns a string.
If a function, it is invoked every render cycle with the items
list, useful for rendering animations and other dynamic content.
::: {.note}
If you're looking for detailed information into the function
signature, you can refer to the fidget API documentation available
[here](https://github.com/j-hui/fidget.nvim/blob/1ba38e4cbb24683973e00c2e36f53ae64da38ef5/doc/fidget-api.txt#L70-L77)
:::
'';
type = nullOr (oneOf [str luaInline]);
default = null;
};
icon_on_left = mkOption {
description = "If true, icon is rendered on the left instead of right";
type = nullOr bool;
default = null;
};
annote_separator = mkOption {
description = "Separator between message from annote";
type = nullOr str;
default = " ";
};
ttl = mkOption {
description = "How long a notification item should exist";
type = nullOr int;
default = 5;
};
render_limit = mkOption {
description = "How many notification items to show at once";
type = nullOr int;
default = null;
};
group_style = mkOption {
description = "Style used to highlight group name";
type = nullOr str;
default = "Title";
};
icon_style = mkOption {
description = "Style used to highlight icon, if null, use group_style";
type = nullOr str;
default = null;
};
annote_style = mkOption {
description = "Default style used to highlight item annotes";
type = nullOr str;
default = "Question";
};
debug_style = mkOption {
description = "Style used to highlight debug item annotes";
type = nullOr str;
default = null;
};
info_style = mkOption {
description = "Style used to highlight info item annotes";
type = nullOr str;
default = null;
};
warn_style = mkOption {
description = "Style used to highlight warn item annotes";
type = nullOr str;
default = null;
};
error_style = mkOption {
description = "Style used to highlight error item annotes";
type = nullOr str;
default = null;
};
debug_annote = mkOption {
description = "Default annotation for debug items";
type = nullOr str;
default = null;
};
info_annote = mkOption {
description = "Default annotation for info items";
type = nullOr str;
default = null;
};
warn_annote = mkOption {
description = "Default annotation for warn items";
type = nullOr str;
default = null;
};
error_annote = mkOption {
description = "Default annotation for error items";
type = nullOr str;
default = null;
};
priority = mkOption {
description = "Order in which group should be displayed";
type = nullOr int;
default = 50;
};
skip_history = mkOption {
description = "Whether messages should be preserved in history";
type = nullOr bool;
default = null;
};
update_hook = mkOption {
description = ''
Called when an item is updated.
If false, no action is taken.
If a function, it is invoked with the item being updated.
::: {.note}
If you're looking for detailed information into the function
signature, you can refer to the fidget API documentation available
[here](https://github.com/j-hui/fidget.nvim/blob/1ba38e4cbb24683973e00c2e36f53ae64da38ef5/doc/fidget-api.txt#L114)
:::
'';
type = nullOr (oneOf [bool luaInline]);
default = false;
};
};
});
default = {};
example = literalExpression ''
{
rust_analyzer = {
name = "Rust Analyzer";
};
}
'';
};
};
lsp = {
progress_ringbuf_size = mkOption {
description = "Nvim's LSP client ring buffer size";
type = int;
default = 100;
description = "Nvim's LSP client ring buffer size";
};
log_handler = mkOption {
description = "Log `$/progress` handler invocations";
type = bool;
default = false;
description = "Log `$/progress` handler invocations";
};
};
};
notification = {
poll_rate = mkOption {
description = "How frequently to update and render notifications";
type = int;
default = 10;
description = "How frequently to update and render notifications";
};
filter = mkOption {
description = "Minimum notifications level";
type = enum ["debug" "info" "warn" "error"];
default = "info";
description = "Minimum notifications level";
apply = filter: mkLuaInline "vim.log.levels.${toUpper filter}";
};
history_size = mkOption {
description = "Number of removed messages to retain in history";
type = int;
default = 128;
description = "Number of removed messages to retain in history";
};
override_vim_notify = mkOption {
description = "Automatically override vim.notify() with Fidget";
type = bool;
default = false;
description = "Automatically override vim.notify() with Fidget";
};
configs = mkOption {
description = "How to configure notification groups when instantiated";
type = attrsOf luaInline;
default = {default = mkLuaInline "require('fidget.notification').default_config";};
description = "How to configure notification groups when instantiated";
};
redirect = mkOption {
description = "Conditionally redirect notifications to another backend";
type = luaInline;
default = mkLuaInline ''
function(msg, level, opts)
@ -409,142 +426,206 @@ in {
end
end
'';
description = "Conditionally redirect notifications to another backend";
};
view = {
stack_upwards = mkOption {
description = "Display notification items from bottom to top";
type = bool;
default = true;
description = "Display notification items from bottom to top";
};
align = mkOption {
type = enum ["message" "annote"];
default = "message";
description = "Indent messages longer than a single line";
};
reflow = mkOption {
type = enum ["hard" "hyphenate" "ellipsis" "false"];
default = "false";
description = ''
Reflow (wrap) messages wider than notification window
The various options determine how wrapping is handled mid-word.
'';
};
icon_separator = mkOption {
description = "Separator between group name and icon";
type = str;
default = " ";
description = "Separator between group name and icon";
};
group_separator = mkOption {
description = "Separator between notification groups";
type = str;
default = "---";
description = "Separator between notification groups";
};
group_separator_hl = mkOption {
description = "Highlight group used for group separator";
type = str;
default = "Comment";
description = "Highlight group used for group separator";
};
line_margin = mkOption {
type = int;
default = 1;
description = ''
Spaces to pad both sides of each non-empty line
Useful for adding a visual gap between notification text
and any buffer it may overlap with.
'';
};
render_message = mkOption {
description = "How to render notification messages";
type = luaInline;
default = mkLuaInline ''
function(msg, cnt)
return cnt == 1 and msg or string.format("(%dx) %s", cnt, msg)
end
'';
description = "How to render notification messages";
};
};
window = {
normal_hl = mkOption {
description = "Base highlight group in the notification window";
type = str;
default = "Comment";
description = "Base highlight group in the notification window";
};
winblend = mkOption {
description = "Background color opacity in the notification window";
type = int;
default = 100;
description = "Background color opacity in the notification window";
};
border = mkOption {
description = "Border style of the notification window";
type = borderType;
default =
if config.vim.ui.borders.enable
then config.vim.ui.borders.globalStyle
else "none";
description = "Border style of the notification window";
};
border_hl = mkOption {
type = str;
default = "";
description = ''
Highlight group for notification window border
Set to empty string to keep your theme's default `FloatBorder` highlight.
'';
};
zindex = mkOption {
description = "Stacking priority of the notification window";
type = int;
default = 45;
description = "Stacking priority of the notification window";
};
max_width = mkOption {
description = "Maximum width of the notification window";
type = int;
default = 0;
description = "Maximum width of the notification window";
};
max_height = mkOption {
description = "Maximum height of the notification window";
type = int;
default = 0;
description = "Maximum height of the notification window";
};
x_padding = mkOption {
description = "Padding from right edge of window boundary";
type = int;
default = 1;
description = "Padding from right edge of window boundary";
};
y_padding = mkOption {
description = "Padding from bottom edge of window boundary";
type = int;
default = 0;
description = "Padding from bottom edge of window boundary";
};
align = mkOption {
description = "How to align the notification window";
type = enum ["top" "bottom"];
default = "bottom";
description = "How to align the notification window";
};
relative = mkOption {
description = "What the notification window position is relative to";
type = enum ["editor" "win"];
default = "editor";
description = "What the notification window position is relative to";
};
};
};
integration = {
nvim-tree = {
enable = mkOption {
description = "Integrate with nvim-tree/nvim-tree.lua (if enabled)";
type = bool;
default =
if config.vim.filetree.nvimTree.enable
then true
else false;
tabstop = mkOption {
type = int;
default = 8;
description = "Width of each tab character in the notification window";
};
};
xcodebuild-nvim = {
enable = mkOption {
description = "Integrate with wojciech-kulik/xcodebuild.nvim (if enabled)";
type = bool;
default = true;
avoid = mkOption {
type = listOf str;
default = [];
description = "Filetypes the notification window should avoid";
};
};
};
logger = {
level = mkOption {
description = "Minimum logging level";
type = enum ["debug" "error" "info" "trace" "warn" "off"];
default = "warn";
description = "Minimum logging level";
apply = logLevel: mkLuaInline "vim.log.levels.${toUpper logLevel}";
};
max_size = mkOption {
description = "Maximum log file size, in KB";
type = int;
default = 10000;
description = "Maximum log file size, in KB";
};
float_precision = mkOption {
description = "Limit the number of decimals displayed for floats";
type = float;
default = 0.01;
description = "Limit the number of decimals displayed for floats";
};
path = mkOption {
description = "Where Fidget writes its logs to";
type = luaInline;
default = mkLuaInline ''
string.format("%s/fidget.nvim.log", vim.fn.stdpath("cache"))
'';
description = "Where Fidget writes its logs to";
};
};
# removed, see below
integration = {
nvim-tree.enable = mkOption {
default = null;
visible = false;
};
xcodebuild-nvim.enable = mkOption {
default = null;
visible = false;
};
};
};
};
# this can't be done better, I tried
# mostly mostly caused by the deprecated options being inside a submodule
# try improving this if you don't care about your sanity
# ~ poz
config = {
assertions = let
inherit (config.vim.visuals.fidget-nvim.setupOpts) integration;
in [
{
assertion = integration.nvim-tree.enable == null;
message = ''
Option `vim.visuals.fidget-nvim.setupOpts.integration.nvim-tree.enable`
has been deprecated upstream. Use
`vim.visuals.fidget-nvim.setupOpts.notification.window.avoid = ["NvimTree"]` instead.
This is already set if `vim.filetree.nvimTree.enable == true`.
'';
}
{
assertion = integration.xcodebuild-nvim.enable == null;
message = ''
Option `vim.visuals.fidget-nvim.setupOpts.integration.xcodebuild-nvim.enable`
has been deprecated upstream. Use
`vim.visuals.fidget-nvim.setupOpts.notification.window.avoid = ["TestExplorer"]` instead.
'';
}
];
};
}