nix-community/nixvim
1
0
Fork 0
mirror of https://github.com/nix-community/nixvim.git synced 2025-11-21 17:59:41 +01:00
Code Activity

treewide: remove internal use of helpers module arg

Browse source
This commit is contained in:
Matt Sturgeon 2025-11-19 11:39:41 +00:00
parent 7add68e918
commit dad19c1238
68 changed files with 687 additions and 758 deletions
Download patch file Download diff file Expand all files Collapse all files

31
modules/commands.nix
View file

@ -1,9 +1,4 @@
{
lib,
helpers,
config,
...
}:
{ lib, config, ... }:
let
commandAttributes = lib.types.submodule {
options = {
@ -13,7 +8,7 @@ let
};
nargs =
helpers.mkNullOrOption
lib.nixvim.mkNullOrOption
(lib.types.enum [
0
1
@ -24,11 +19,11 @@ let
''
The number of arguments to expect, see :h command-nargs.
'';
complete = helpers.mkNullOrOption (with lib.types; either str rawLua) ''
complete = lib.nixvim.mkNullOrOption (with lib.types; either str rawLua) ''
Tab-completion behaviour, see :h command-complete.
'';
range =
helpers.mkNullOrOption
lib.nixvim.mkNullOrOption
(
with lib.types;
oneOf [
@ -40,18 +35,18 @@ let
''
Whether the command accepts a range, see :h command-range.
'';
count = helpers.mkNullOrOption (with lib.types; either bool int) ''
count = lib.nixvim.mkNullOrOption (with lib.types; either bool int) ''
Whether the command accepts a count, see :h command-range.
'';
addr = helpers.mkNullOrOption lib.types.str ''
addr = lib.nixvim.mkNullOrOption lib.types.str ''
Whether special characters relate to other things, see :h command-addr.
'';
bang = helpers.defaultNullOpts.mkBool false "Whether this command can take a bang (!).";
bar = helpers.defaultNullOpts.mkBool false "Whether this command can be followed by a \"|\" and another command.";
register = helpers.defaultNullOpts.mkBool false "The first argument to the command can be an optional register.";
keepscript = helpers.defaultNullOpts.mkBool false "Do not use the location of where the user command was defined for verbose messages, use the location of where the command was invoked.";
force = helpers.defaultNullOpts.mkBool false "Overwrite an existing user command.";
desc = helpers.defaultNullOpts.mkStr "" "A description of the command.";
bang = lib.nixvim.defaultNullOpts.mkBool false "Whether this command can take a bang (!).";
bar = lib.nixvim.defaultNullOpts.mkBool false "Whether this command can be followed by a \"|\" and another command.";
register = lib.nixvim.defaultNullOpts.mkBool false "The first argument to the command can be an optional register.";
keepscript = lib.nixvim.defaultNullOpts.mkBool false "Do not use the location of where the user command was defined for verbose messages, use the location of where the command was invoked.";
force = lib.nixvim.defaultNullOpts.mkBool false "Overwrite an existing user command.";
desc = lib.nixvim.defaultNullOpts.mkStr "" "A description of the command.";
# TODO: command-preview, need to grab a function here.
};
@ -72,7 +67,7 @@ in
};
in
lib.mkIf (config.userCommands != { }) {
extraConfigLua = helpers.wrapDo ''
extraConfigLua = lib.nixvim.wrapDo ''
local cmds = ${lib.nixvim.toLuaObject (lib.mapAttrs cleanupCommand config.userCommands)};
for name,cmd in pairs(cmds) do
vim.api.nvim_create_user_command(name, cmd.command, cmd.options or {})

3
modules/files.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
pkgs,
config,
...
@ -92,7 +91,7 @@ let
# TODO: Added 2024-07-07, remove after 24.11
# Before we had a fileType, we used types.str.
coercedFileType = helpers.transitionType lib.types.str (text: { inherit text; }) fileType;
coercedFileType = lib.nixvim.transitionType lib.types.str (text: { inherit text; }) fileType;
in
{
options = {

11
modules/filetype.nix
View file

@ -1,15 +1,10 @@
{
lib,
helpers,
config,
...
}:
{ lib, config, ... }:
let
inherit (lib) types;
cfg = config.filetype;
filetypeDefinition = helpers.mkNullOrOption (
filetypeDefinition = lib.nixvim.mkNullOrOption (
with types;
attrsOf (oneOf [
# Raw filetype
@ -42,7 +37,7 @@ let
in
{
options.filetype =
helpers.mkCompositeOption
lib.nixvim.mkCompositeOption
''
Define additional filetypes. The values can either be a literal filetype or a function
taking the filepath and the buffer number.

20
modules/keymaps.nix
View file

@ -1,14 +1,20 @@
{
lib,
helpers,
config,
options,
...
}:
let
inherit (lib.nixvim) toLuaObject;
inherit (lib.nixvim.keymaps)
removeDeprecatedMapAttrs
deprecatedMapOptionSubmodule
;
in
{
options = {
keymaps = lib.mkOption {
type = lib.types.listOf helpers.keymaps.deprecatedMapOptionSubmodule;
type = lib.types.listOf deprecatedMapOptionSubmodule;
default = [ ];
description = "Nixvim keymaps.";
example = [
@ -21,7 +27,7 @@
};
keymapsOnEvents = lib.mkOption {
type = lib.types.attrsOf (lib.types.listOf helpers.keymaps.deprecatedMapOptionSubmodule);
type = lib.types.attrsOf (lib.types.listOf deprecatedMapOptionSubmodule);
default = { };
example = {
"InsertEnter" = [
@ -69,7 +75,7 @@
The `${lib.showOption opt.loc}' option is deprecated and will be removed in 24.11.
You should use a "raw" `action` instead;
e.g. `action.__raw = "<lua code>"` or `action = helpers.mkRaw "<lua code>"`.
e.g. `action.__raw = "<lua code>"` or `action = lib.nixvim.mkRaw "<lua code>"`.
${lib.options.showDefs opt.definitionsWithLocations}
''))
@ -78,7 +84,7 @@
extraConfigLua = lib.mkIf (config.keymaps != [ ]) ''
-- Set up keybinds {{{
do
local __nixvim_binds = ${lib.nixvim.toLuaObject (map helpers.keymaps.removeDeprecatedMapAttrs config.keymaps)}
local __nixvim_binds = ${toLuaObject (map removeDeprecatedMapAttrs config.keymaps)}
for i, map in ipairs(__nixvim_binds) do
vim.keymap.set(map.mode, map.key, map.action, map.options)
end
@ -93,10 +99,10 @@
autoCmd = lib.mapAttrsToList (event: mappings: {
inherit event;
group = "nixvim_binds_${event}";
callback = helpers.mkRaw ''
callback = lib.nixvim.mkRaw ''
function(args)
do
local __nixvim_binds = ${lib.nixvim.toLuaObject (map helpers.keymaps.removeDeprecatedMapAttrs mappings)}
local __nixvim_binds = ${toLuaObject (map removeDeprecatedMapAttrs mappings)}
for i, map in ipairs(__nixvim_binds) do
local options = vim.tbl_extend("keep", map.options or {}, { buffer = args.buf })

9
modules/opts.nix
View file

@ -1,9 +1,4 @@
{
lib,
helpers,
config,
...
}:
{ lib, config, ... }:
let
optionsAttrs = {
opts = {
@ -56,7 +51,7 @@ in
config = {
extraConfigLuaPre =
let
content = helpers.concatNonEmptyLines (
content = lib.nixvim.concatNonEmptyLines (
lib.mapAttrsToList (
optionName:
{

19
modules/output.nix
View file

@ -1,9 +1,4 @@
{
lib,
config,
helpers,
...
}:
{ lib, config, ... }:
let
inherit (lib) types mkOption;
@ -140,19 +135,19 @@ in
content =
if config.type == "lua" then
# Lua
helpers.concatNonEmptyLines [
lib.nixvim.concatNonEmptyLines [
config.extraConfigLuaPre
(helpers.wrapVimscriptForLua config.extraConfigVim)
(lib.nixvim.wrapVimscriptForLua config.extraConfigVim)
config.extraConfigLua
config.extraConfigLuaPost
]
else
# Vimscript
helpers.concatNonEmptyLines [
(helpers.wrapLuaForVimscript config.extraConfigLuaPre)
lib.nixvim.concatNonEmptyLines [
(lib.nixvim.wrapLuaForVimscript config.extraConfigLuaPre)
config.extraConfigVim
(helpers.wrapLuaForVimscript (
helpers.concatNonEmptyLines [
(lib.nixvim.wrapLuaForVimscript (
lib.nixvim.concatNonEmptyLines [
config.extraConfigLua
config.extraConfigLuaPost
]

5
modules/top-level/output.nix
View file

@ -2,7 +2,6 @@
pkgs,
config,
lib,
helpers,
...
}:
let
@ -236,8 +235,8 @@ in
dontFixup = true;
};
customRC = helpers.concatNonEmptyLines [
(helpers.wrapVimscriptForLua wrappedNeovim.initRc)
customRC = lib.nixvim.concatNonEmptyLines [
(lib.nixvim.wrapVimscriptForLua wrappedNeovim.initRc)
config.content
];

68
plugins/by-name/arrow/default.nix
View file

@ -1,8 +1,4 @@
{
lib,
helpers,
...
}:
{ lib, ... }:
with lib;
lib.nixvim.plugins.mkNeovimPlugin {
name = "arrow";
@ -12,73 +8,73 @@ lib.nixvim.plugins.mkNeovimPlugin {
maintainers = [ maintainers.hmajid2301 ];
settingsOptions = {
show_icons = helpers.defaultNullOpts.mkBool false ''
show_icons = lib.nixvim.defaultNullOpts.mkBool false ''
If true will show icons.
'';
always_show_path = helpers.defaultNullOpts.mkBool false ''
always_show_path = lib.nixvim.defaultNullOpts.mkBool false ''
If true will show path.
'';
separate_by_branch = helpers.defaultNullOpts.mkBool false ''
separate_by_branch = lib.nixvim.defaultNullOpts.mkBool false ''
If true will split bookmarks by git branch.
'';
hide_handbook = helpers.defaultNullOpts.mkBool false ''
hide_handbook = lib.nixvim.defaultNullOpts.mkBool false ''
If true to hide the shortcuts on menu.
'';
save_path = helpers.defaultNullOpts.mkLuaFn ''
save_path = lib.nixvim.defaultNullOpts.mkLuaFn ''
function()
return vim.fn.stdpath("cache") .. "/arrow"
end
'' "Function used to determine where to save arrow data.";
mapping = {
edit = helpers.defaultNullOpts.mkStr "e" ''
edit = lib.nixvim.defaultNullOpts.mkStr "e" ''
Mapping to edit bookmarks.
'';
delete_mode = helpers.defaultNullOpts.mkStr "d" ''
delete_mode = lib.nixvim.defaultNullOpts.mkStr "d" ''
Mapping to go to delete mode, where you can remove bookmarks.
'';
clear_all_items = helpers.defaultNullOpts.mkStr "C" ''
clear_all_items = lib.nixvim.defaultNullOpts.mkStr "C" ''
Mapping to clear all bookmarks.
'';
toggle = helpers.defaultNullOpts.mkStr "s" ''
toggle = lib.nixvim.defaultNullOpts.mkStr "s" ''
Mapping to save if `separate_save_and_remove` is true.
'';
open_vertical = helpers.defaultNullOpts.mkStr "v" ''
open_vertical = lib.nixvim.defaultNullOpts.mkStr "v" ''
Mapping to open bookmarks in vertical split.
'';
open_horizontal = helpers.defaultNullOpts.mkStr "-" ''
open_horizontal = lib.nixvim.defaultNullOpts.mkStr "-" ''
Mapping to open bookmarks in horizontal split.
'';
quit = helpers.defaultNullOpts.mkStr "q" ''
quit = lib.nixvim.defaultNullOpts.mkStr "q" ''
Mapping to quit arrow.
'';
remove = helpers.defaultNullOpts.mkStr "x" ''
remove = lib.nixvim.defaultNullOpts.mkStr "x" ''
Mapping to remove bookmarks. Only used if `separate_save_and_remove` is true.
'';
next_item = helpers.defaultNullOpts.mkStr "]" ''
next_item = lib.nixvim.defaultNullOpts.mkStr "]" ''
Mapping to go to next bookmark.
'';
prev_item = helpers.defaultNullOpts.mkStr "[" ''
prev_item = lib.nixvim.defaultNullOpts.mkStr "[" ''
Mapping to go to previous bookmark.
'';
};
custom_actions = {
open =
helpers.defaultNullOpts.mkLuaFn
lib.nixvim.defaultNullOpts.mkLuaFn
''
function(target_file_name, current_file_name) end
''
@ -87,17 +83,17 @@ lib.nixvim.plugins.mkNeovimPlugin {
- `current_file_name`: filename from where this was called
'';
split_vertical = helpers.defaultNullOpts.mkLuaFn ''
split_vertical = lib.nixvim.defaultNullOpts.mkLuaFn ''
function(target_file_name, current_file_name) end
'' "";
split_horizontal = helpers.defaultNullOpts.mkLuaFn ''
split_horizontal = lib.nixvim.defaultNullOpts.mkLuaFn ''
function(target_file_name, current_file_name) end
'' "";
};
window =
helpers.defaultNullOpts.mkAttrsOf types.anything
lib.nixvim.defaultNullOpts.mkAttrsOf types.anything
{
relative = "editor";
width = "auto";
@ -113,51 +109,51 @@ lib.nixvim.plugins.mkNeovimPlugin {
'';
per_buffer_config = {
lines = helpers.defaultNullOpts.mkInt 4 ''
lines = lib.nixvim.defaultNullOpts.mkInt 4 ''
Number of lines on preview.
'';
sort_automatically = helpers.defaultNullOpts.mkBool true ''
sort_automatically = lib.nixvim.defaultNullOpts.mkBool true ''
If true will sort buffer marks automatically.
'';
satellite = {
enable = helpers.defaultNullOpts.mkBool false ''
enable = lib.nixvim.defaultNullOpts.mkBool false ''
If true will display arrow index in scrollbar at every update.
'';
overlap = helpers.defaultNullOpts.mkBool false '''';
overlap = lib.nixvim.defaultNullOpts.mkBool false '''';
priority = helpers.defaultNullOpts.mkInt 1000 '''';
priority = lib.nixvim.defaultNullOpts.mkInt 1000 '''';
};
zindex = helpers.defaultNullOpts.mkInt 50 ''
zindex = lib.nixvim.defaultNullOpts.mkInt 50 ''
Z index of the buffer.
'';
};
separate_save_and_remove = helpers.defaultNullOpts.mkBool false ''
separate_save_and_remove = lib.nixvim.defaultNullOpts.mkBool false ''
If true will remove the toggle and create the save/remove keymaps.
'';
leader_key = helpers.defaultNullOpts.mkStr ";" ''
leader_key = lib.nixvim.defaultNullOpts.mkStr ";" ''
The leader key to use for arrow. Will precede all mappings.
Recommended to be a single character.
'';
save_key = helpers.defaultNullOpts.mkStr "cwd" ''
save_key = lib.nixvim.defaultNullOpts.mkStr "cwd" ''
What will be used as root to save the bookmarks. Can be also `git_root`.
'';
global_bookmarks = helpers.defaultNullOpts.mkBool false ''
global_bookmarks = lib.nixvim.defaultNullOpts.mkBool false ''
If true arrow will save files globally (ignores `separate_by_branch`).
'';
index_keys = helpers.defaultNullOpts.mkStr "123456789zxcbnmZXVBNM,afghjklAFGHJKLwrtyuiopWRTYUIOP" ''
index_keys = lib.nixvim.defaultNullOpts.mkStr "123456789zxcbnmZXVBNM,afghjklAFGHJKLwrtyuiopWRTYUIOP" ''
Keys mapped to bookmark index.
'';
full_path_list = helpers.defaultNullOpts.mkListOf types.str [ "update_stuff" ] ''
full_path_list = lib.nixvim.defaultNullOpts.mkListOf types.str [ "update_stuff" ] ''
Filenames on this list will ALWAYS show the file path too
'';
};

7
plugins/by-name/better-escape/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
with lib;
@ -13,16 +12,16 @@ lib.nixvim.plugins.mkNeovimPlugin {
maintainers = [ maintainers.GaetanLepage ];
settingsOptions = {
timeout = helpers.defaultNullOpts.mkStrLuaOr types.ints.unsigned "vim.o.timeoutlen" ''
timeout = lib.nixvim.defaultNullOpts.mkStrLuaOr types.ints.unsigned "vim.o.timeoutlen" ''
The time in which the keys must be hit in ms.
Uses the value of `vim.o.timeoutlen` (`options.timeoutlen` in nixvim) by default.
'';
default_mappings = helpers.defaultNullOpts.mkBool true ''
default_mappings = lib.nixvim.defaultNullOpts.mkBool true ''
Whether to enable default key mappings.
'';
mappings = helpers.defaultNullOpts.mkAttrsOf' {
mappings = lib.nixvim.defaultNullOpts.mkAttrsOf' {
type = types.anything;
pluginDefault = {
i.j = {

3
plugins/by-name/bufdelete/default.nix
View file

@ -1,5 +1,4 @@
{
helpers,
lib,
...
}:
@ -52,7 +51,7 @@ lib.nixvim.plugins.mkVimPlugin {
'';
settingsOptions = {
buf_filter = helpers.defaultNullOpts.mkLuaFn null ''
buf_filter = lib.nixvim.defaultNullOpts.mkLuaFn null ''
Function that determines buffers that bufdelete.nvim can switch to,
instead of the default behavior of switching to any buffer.

9
plugins/by-name/chatgpt/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
with lib;
@ -22,15 +21,15 @@ lib.nixvim.plugins.mkNeovimPlugin {
];
settingsOptions = {
api_key_cmd = helpers.defaultNullOpts.mkStr null ''
api_key_cmd = lib.nixvim.defaultNullOpts.mkStr null ''
The path and arguments to an executable that returns the API key via stdout.
'';
yank_register = helpers.defaultNullOpts.mkStr "+" ''
yank_register = lib.nixvim.defaultNullOpts.mkStr "+" ''
Which register to use for copying.
'';
extra_curl_params = helpers.defaultNullOpts.mkListOf' {
extra_curl_params = lib.nixvim.defaultNullOpts.mkListOf' {
type = types.str;
pluginDefault = null;
description = ''
@ -43,7 +42,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
];
};
show_line_numbers = helpers.defaultNullOpts.mkBool true ''
show_line_numbers = lib.nixvim.defaultNullOpts.mkBool true ''
Whether to show line numbers in the ChatGPT window.
'';
};

32
plugins/by-name/codesnap/default.nix
View file

@ -1,8 +1,4 @@
{
lib,
helpers,
...
}:
{ lib, ... }:
with lib;
lib.nixvim.plugins.mkNeovimPlugin {
name = "codesnap";
@ -12,7 +8,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
maintainers = [ maintainers.GaetanLepage ];
settingsOptions = {
save_path = helpers.defaultNullOpts.mkStr null ''
save_path = lib.nixvim.defaultNullOpts.mkStr null ''
The save_path must be ends with `.png`, unless when you specified a directory path, CodeSnap
will append an auto-generated filename to the specified directory path.
@ -23,34 +19,34 @@ lib.nixvim.plugins.mkNeovimPlugin {
parsed: `"~/Pictures/foo.png"`
'';
mac_window_bar = helpers.defaultNullOpts.mkBool true ''
mac_window_bar = lib.nixvim.defaultNullOpts.mkBool true ''
Whether to display the MacOS style title bar.
'';
title = helpers.defaultNullOpts.mkStr "CodeSnap.nvim" ''
title = lib.nixvim.defaultNullOpts.mkStr "CodeSnap.nvim" ''
The editor title.
'';
code_font_family = helpers.defaultNullOpts.mkStr "CaskaydiaCove Nerd Font" ''
code_font_family = lib.nixvim.defaultNullOpts.mkStr "CaskaydiaCove Nerd Font" ''
Which font to use for the code.
'';
watermark_font_family = helpers.defaultNullOpts.mkStr "Pacifico" ''
watermark_font_family = lib.nixvim.defaultNullOpts.mkStr "Pacifico" ''
Which font to use for watermarks.
'';
watermark = helpers.defaultNullOpts.mkStr "CodeSnap.nvim" ''
watermark = lib.nixvim.defaultNullOpts.mkStr "CodeSnap.nvim" ''
Wartermark of the code snapshot.
'';
bg_theme = helpers.defaultNullOpts.mkStr "default" ''
bg_theme = lib.nixvim.defaultNullOpts.mkStr "default" ''
Background theme name.
Check the [upstream README](https://github.com/mistricky/codesnap.nvim?tab=readme-ov-file#custom-background)
for available options.
'';
bg_color = helpers.defaultNullOpts.mkStr' {
bg_color = lib.nixvim.defaultNullOpts.mkStr' {
pluginDefault = null;
example = "#535c68";
description = ''
@ -58,26 +54,26 @@ lib.nixvim.plugins.mkNeovimPlugin {
'';
};
breadcrumbs_separator = helpers.defaultNullOpts.mkStr "/" ''
breadcrumbs_separator = lib.nixvim.defaultNullOpts.mkStr "/" ''
Separator for breadcrumbs.
The CodeSnap.nvim uses `/` as the separator of the file path by default, of course, you can
specify any symbol you prefer as the custom separator.
'';
has_breadcrumbs = helpers.defaultNullOpts.mkBool false ''
has_breadcrumbs = lib.nixvim.defaultNullOpts.mkBool false ''
Whether to display the current snapshot file path.
'';
has_line_number = helpers.defaultNullOpts.mkBool false ''
has_line_number = lib.nixvim.defaultNullOpts.mkBool false ''
Whether to display line numbers.
'';
show_workspace = helpers.defaultNullOpts.mkBool false ''
show_workspace = lib.nixvim.defaultNullOpts.mkBool false ''
Breadcrumbs hide the workspace name by default, if you want to display workspace in
breadcrumbs, you can just set this option to `true`.
'';
min_width = helpers.defaultNullOpts.mkUnsignedInt 0 ''
min_width = lib.nixvim.defaultNullOpts.mkUnsignedInt 0 ''
Minimum width for the snapshot.
'';
};

31
plugins/by-name/comment/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
with lib;
@ -13,63 +12,63 @@ lib.nixvim.plugins.mkNeovimPlugin {
maintainers = [ maintainers.GaetanLepage ];
settingsOptions = {
padding = helpers.defaultNullOpts.mkBool true ''
padding = lib.nixvim.defaultNullOpts.mkBool true ''
Add a space b/w comment and the line.
'';
sticky = helpers.defaultNullOpts.mkBool true ''
sticky = lib.nixvim.defaultNullOpts.mkBool true ''
Whether the cursor should stay at its position.
'';
ignore = helpers.mkNullOrStr ''
ignore = lib.nixvim.mkNullOrStr ''
Lines to be ignored while (un)comment.
'';
toggler = {
line = helpers.defaultNullOpts.mkStr "gcc" ''
line = lib.nixvim.defaultNullOpts.mkStr "gcc" ''
Line-comment toggle keymap in NORMAL mode.
'';
block = helpers.defaultNullOpts.mkStr "gbc" ''
block = lib.nixvim.defaultNullOpts.mkStr "gbc" ''
Block-comment toggle keymap in NORMAL mode.
'';
};
opleader = {
line = helpers.defaultNullOpts.mkStr "gc" ''
line = lib.nixvim.defaultNullOpts.mkStr "gc" ''
Line-comment operator-pending keymap in NORMAL and VISUAL mode.
'';
block = helpers.defaultNullOpts.mkStr "gb" ''
block = lib.nixvim.defaultNullOpts.mkStr "gb" ''
Block-comment operator-pending keymap in NORMAL and VISUAL mode.
'';
};
extra = {
above = helpers.defaultNullOpts.mkStr "gcO" ''
above = lib.nixvim.defaultNullOpts.mkStr "gcO" ''
Add comment on the line above.
'';
below = helpers.defaultNullOpts.mkStr "gco" ''
below = lib.nixvim.defaultNullOpts.mkStr "gco" ''
Add comment on the line below.
'';
eol = helpers.defaultNullOpts.mkStr "gcA" ''
eol = lib.nixvim.defaultNullOpts.mkStr "gcA" ''
Add comment at the end of line.
'';
};
mappings =
helpers.defaultNullOpts.mkNullable
lib.nixvim.defaultNullOpts.mkNullable
(
with types;
either (enum [ false ]) (submodule {
options = {
basic = helpers.defaultNullOpts.mkBool true ''
basic = lib.nixvim.defaultNullOpts.mkBool true ''
Enable operator-pending mappings (`gcc`, `gbc`, `gc[count]{motion}`, `gb[count]{motion}`).
'';
extra = helpers.defaultNullOpts.mkBool true ''
extra = lib.nixvim.defaultNullOpts.mkBool true ''
Enable extra mappings (`gco`, `gcO`, `gcA`).
'';
};
@ -84,11 +83,11 @@ lib.nixvim.plugins.mkNeovimPlugin {
NOTE: If given 'false', then the plugin won't create any mappings.
'';
pre_hook = helpers.mkNullOrLuaFn ''
pre_hook = lib.nixvim.mkNullOrLuaFn ''
Lua function called before (un)comment.
'';
post_hook = helpers.mkNullOrLuaFn ''
post_hook = lib.nixvim.mkNullOrLuaFn ''
Lua function called after (un)comment.
'';
};

5
plugins/by-name/copilot-vim/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
pkgs,
...
}:
@ -43,7 +42,7 @@ lib.nixvim.plugins.mkVimPlugin {
example = "localhost:3128";
};
proxy_strict_ssl = helpers.mkNullOrOption types.bool ''
proxy_strict_ssl = lib.nixvim.mkNullOrOption types.bool ''
Corporate proxies sometimes use a man-in-the-middle SSL certificate which is incompatible
with GitHub Copilot.
To work around this, SSL certificate verification can be disabled by setting this option to
@ -53,7 +52,7 @@ lib.nixvim.plugins.mkVimPlugin {
`$NODE_TLS_REJECT_UNAUTHORIZED` environment variable to `"0"`.
'';
workspace_folders = helpers.mkNullOrOption (with types; listOf str) ''
workspace_folders = lib.nixvim.mkNullOrOption (with types; listOf str) ''
A list of "workspace folders" or project roots that Copilot may use to improve to improve
the quality of suggestions.

83
plugins/by-name/dashboard/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
with lib;
@ -69,33 +68,33 @@ lib.nixvim.plugins.mkNeovimPlugin {
freeformType = with types; attrsOf anything;
options = {
icon = helpers.defaultNullOpts.mkStr "" ''
icon = lib.nixvim.defaultNullOpts.mkStr "" ''
The icon to display with this action.
'';
icon_hl = helpers.defaultNullOpts.mkStr "DashboardIcon" ''
icon_hl = lib.nixvim.defaultNullOpts.mkStr "DashboardIcon" ''
The highlight group for the icon.
'';
desc = helpers.defaultNullOpts.mkStr "" ''
desc = lib.nixvim.defaultNullOpts.mkStr "" ''
The action's description, shown next to the icon.
'';
desc_hl = helpers.defaultNullOpts.mkStr "DashboardDesc" ''
desc_hl = lib.nixvim.defaultNullOpts.mkStr "DashboardDesc" ''
The highlight group to use for the description.
'';
key = helpers.defaultNullOpts.mkStr "" ''
key = lib.nixvim.defaultNullOpts.mkStr "" ''
Shortcut key available in the dashboard buffer.
**Note**: this will not create an actual keymap.
'';
key_hl = helpers.defaultNullOpts.mkStr "DashboardKey" ''
key_hl = lib.nixvim.defaultNullOpts.mkStr "DashboardKey" ''
The highlight group to use for the key.
'';
action = helpers.defaultNullOpts.mkStr "" ''
action = lib.nixvim.defaultNullOpts.mkStr "" ''
Action done when you press key. Can be a command or a function.
To use a lua function, pass a raw type instead of a string, e.g:
@ -116,7 +115,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
in
{
theme =
helpers.defaultNullOpts.mkEnumFirstDefault
lib.nixvim.defaultNullOpts.mkEnumFirstDefault
[
"hyper"
"doom"
@ -131,7 +130,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
'';
shortcut_type =
helpers.defaultNullOpts.mkEnumFirstDefault
lib.nixvim.defaultNullOpts.mkEnumFirstDefault
[
"letter"
"number"
@ -140,13 +139,13 @@ lib.nixvim.plugins.mkNeovimPlugin {
The shortcut type.
'';
change_to_vcs_root = helpers.defaultNullOpts.mkBool false ''
change_to_vcs_root = lib.nixvim.defaultNullOpts.mkBool false ''
When opening a file in the "hyper" theme's "recent files" list (`mru`), vim will change to the root of vcs.
'';
config = {
# TODO double check if this affects "doom" or not
disable_move = helpers.defaultNullOpts.mkBool false ''
disable_move = lib.nixvim.defaultNullOpts.mkBool false ''
Disable movement keymaps in the dashboard buffer.
Specifically, the following keymaps are disabled:
@ -154,31 +153,31 @@ lib.nixvim.plugins.mkNeovimPlugin {
`w`, `f`, `b`, `h`, `j`, `k`, `l`, `<Up>`, `<Down>`, `<Left>`, `<Right>`
'';
packages.enable = helpers.defaultNullOpts.mkBool true ''
packages.enable = lib.nixvim.defaultNullOpts.mkBool true ''
Show how many vim plugins are loaded.
${requiresTheme "hyper"}
'';
week_header = {
enable = helpers.defaultNullOpts.mkBool false ''
enable = lib.nixvim.defaultNullOpts.mkBool false ''
Whether to use a header based on the current day of the week,
instead of the default "DASHBOARD" header.
A subheading showing the current time is also displayed.
'';
concat = helpers.defaultNullOpts.mkStr "" ''
concat = lib.nixvim.defaultNullOpts.mkStr "" ''
Additional text to append at the end of the time line.
'';
append = helpers.defaultNullOpts.mkListOf types.str [ ] ''
append = lib.nixvim.defaultNullOpts.mkListOf types.str [ ] ''
Additional header lines to append after the the time line.
'';
};
header =
helpers.defaultNullOpts.mkNullableWithRaw (with types; either str (listOf (maybeRaw str)))
lib.nixvim.defaultNullOpts.mkNullableWithRaw (with types; either str (listOf (maybeRaw str)))
[
""
" ██████╗ █████╗ ███████╗██╗ ██╗██████╗ ██████╗ █████╗ ██████╗ ██████╗ "
@ -193,12 +192,12 @@ lib.nixvim.plugins.mkNeovimPlugin {
The header text, displayed at the top of the buffer.
'';
footer = helpers.defaultNullOpts.mkListOf types.str [ ] ''
footer = lib.nixvim.defaultNullOpts.mkListOf types.str [ ] ''
The footer text, displayed at the bottom of the buffer.
'';
# TODO: Once #1618 is fixed, we can switch to `defaultNullOpts.mkAttrs'`,
shortcut = helpers.mkNullOrOption' {
shortcut = lib.nixvim.mkNullOrOption' {
description = ''
Shortcut actions to be added to the "hyper" theme.
@ -229,14 +228,14 @@ lib.nixvim.plugins.mkNeovimPlugin {
];
type = types.listOf (mkActionType {
group = helpers.defaultNullOpts.mkStr "" ''
group = lib.nixvim.defaultNullOpts.mkStr "" ''
Highlight group used with the "hyper" theme,
'';
});
};
# TODO: Once #1618 is fixed, we can switch to `defaultNullOpts.mkAttrs'`,
center = helpers.mkNullOrOption' {
center = lib.nixvim.mkNullOrOption' {
description = ''
Actions to be added to the center section of the "doom" theme.
@ -268,7 +267,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
type = types.listOf (mkActionType {
# TODO if `key_format` is _also_ applicable to hyper theme,
# move the option to `mkActionList`.
key_format = helpers.defaultNullOpts.mkStr "[%s]" ''
key_format = lib.nixvim.defaultNullOpts.mkStr "[%s]" ''
Format string used when rendering the key.
`%s` will be substituted with value of `key`.
'';
@ -276,96 +275,96 @@ lib.nixvim.plugins.mkNeovimPlugin {
};
project =
helpers.mkCompositeOption
lib.nixvim.mkCompositeOption
''
Options relating to the "hyper" theme's recent projects list.
${requiresTheme "hyper"}
''
{
enable = helpers.defaultNullOpts.mkBool true ''
enable = lib.nixvim.defaultNullOpts.mkBool true ''
Whether to display the recent projects list.
'';
limit = helpers.defaultNullOpts.mkInt 8 ''
limit = lib.nixvim.defaultNullOpts.mkInt 8 ''
The maximum number of projects to list.
'';
icon = helpers.defaultNullOpts.mkStr "󰏓 " ''
icon = lib.nixvim.defaultNullOpts.mkStr "󰏓 " ''
Icon used in the section header.
'';
icon_hl = helpers.defaultNullOpts.mkStr "DashboardRecentProjectIcon" ''
icon_hl = lib.nixvim.defaultNullOpts.mkStr "DashboardRecentProjectIcon" ''
Highlight group used for the icon.
'';
label = helpers.defaultNullOpts.mkStr " Recent Projects:" ''
label = lib.nixvim.defaultNullOpts.mkStr " Recent Projects:" ''
Text used in the section header.
'';
action = helpers.defaultNullOpts.mkStr "Telescope find_files cwd=" ''
action = lib.nixvim.defaultNullOpts.mkStr "Telescope find_files cwd=" ''
When you press key or enter it will run this action
'';
};
mru =
helpers.mkCompositeOption
lib.nixvim.mkCompositeOption
''
Options relating to the "hyper" theme's recent files list.
${requiresTheme "hyper"}
''
{
enable = helpers.defaultNullOpts.mkBool true ''
enable = lib.nixvim.defaultNullOpts.mkBool true ''
Whether to display the recent file list.
'';
limit = helpers.defaultNullOpts.mkInt 10 ''
limit = lib.nixvim.defaultNullOpts.mkInt 10 ''
The maximum number of files to list.
'';
icon = helpers.defaultNullOpts.mkStr " " ''
icon = lib.nixvim.defaultNullOpts.mkStr " " ''
Icon used in the section header.
'';
icon_hl = helpers.defaultNullOpts.mkStr "DashboardMruIcon" ''
icon_hl = lib.nixvim.defaultNullOpts.mkStr "DashboardMruIcon" ''
Highlight group used for the icon.
'';
label = helpers.defaultNullOpts.mkStr " Most Recent Files:" ''
label = lib.nixvim.defaultNullOpts.mkStr " Most Recent Files:" ''
Text used in the section header.
'';
cwd_only = helpers.defaultNullOpts.mkBool false ''
cwd_only = lib.nixvim.defaultNullOpts.mkBool false ''
Whether to only include files from the current working directory.
'';
};
};
hide = {
statusline = helpers.defaultNullOpts.mkBool true ''
statusline = lib.nixvim.defaultNullOpts.mkBool true ''
Whether to hide the status line.
'';
tabline = helpers.defaultNullOpts.mkBool true ''
tabline = lib.nixvim.defaultNullOpts.mkBool true ''
Whether to hide the status line.
'';
};
preview = {
command = helpers.defaultNullOpts.mkStr "" ''
command = lib.nixvim.defaultNullOpts.mkStr "" ''
Command to print file contents.
'';
file_path = helpers.defaultNullOpts.mkStr null ''
file_path = lib.nixvim.defaultNullOpts.mkStr null ''
Path to preview file.
'';
file_height = helpers.defaultNullOpts.mkInt 0 ''
file_height = lib.nixvim.defaultNullOpts.mkInt 0 ''
The height of the preview file.
'';
file_width = helpers.defaultNullOpts.mkInt 0 ''
file_width = lib.nixvim.defaultNullOpts.mkInt 0 ''
The width of the preview file.
'';
};

15
plugins/by-name/debugprint/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
with lib;
@ -13,7 +12,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
settingsOptions = {
keymaps =
helpers.defaultNullOpts.mkAttrsOf (with lib.types; attrsOf (either str rawLua))
lib.nixvim.defaultNullOpts.mkAttrsOf (with lib.types; attrsOf (either str rawLua))
{
normal = {
plain_below = "g?p";
@ -47,7 +46,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
'';
commands =
helpers.defaultNullOpts.mkAttrsOf types.str
lib.nixvim.defaultNullOpts.mkAttrsOf types.str
{
toggle_comment_debug_prints = "ToggleCommentDebugPrints";
delete_debug_prints = "DeleteDebugPrints";
@ -63,20 +62,20 @@ lib.nixvim.plugins.mkNeovimPlugin {
Setting any command to `nil` (warning: use `__raw`) will skip it.
'';
move_to_debugline = helpers.defaultNullOpts.mkBool false ''
move_to_debugline = lib.nixvim.defaultNullOpts.mkBool false ''
When adding a debug line, moves the cursor to that line.
'';
display_counter = helpers.defaultNullOpts.mkBool true ''
display_counter = lib.nixvim.defaultNullOpts.mkBool true ''
Whether to display/include the monotonically increasing counter in each debug message.
'';
display_snippet = helpers.defaultNullOpts.mkBool true ''
display_snippet = lib.nixvim.defaultNullOpts.mkBool true ''
Whether to include a snippet of the line above/below in plain debug lines.
'';
filetypes =
helpers.defaultNullOpts.mkNullable
lib.nixvim.defaultNullOpts.mkNullable
(
with types;
attrsOf (submodule {
@ -123,7 +122,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
```
'';
print_tag = helpers.defaultNullOpts.mkStr "DEBUGPRINT" ''
print_tag = lib.nixvim.defaultNullOpts.mkStr "DEBUGPRINT" ''
The string inserted into each print statement, which can be used to uniquely identify
statements inserted by `debugprint`.
'';

49
plugins/by-name/edgy/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
with lib;
@ -23,43 +22,43 @@ lib.nixvim.plugins.mkNeovimPlugin {
settingsOptions =
let
viewOpts = {
ft = helpers.mkNullOrStr ''
ft = lib.nixvim.mkNullOrStr ''
File type of the view.
'';
filter = helpers.mkNullOrLuaFn ''
filter = lib.nixvim.mkNullOrLuaFn ''
Optional function to filter buffers and windows.
`fun(buf:buffer, win:window)`
'';
title = helpers.mkNullOrStr ''
title = lib.nixvim.mkNullOrStr ''
Optional title of the view.
Defaults to the capitalized filetype.
'';
size = helpers.mkNullOrOption types.ints.unsigned ''
size = lib.nixvim.mkNullOrOption types.ints.unsigned ''
Size of the short edge of the edgebar.
For edgebars, this is the minimum width.
For panels, minimum height.
'';
pinned = helpers.mkNullOrOption types.bool ''
pinned = lib.nixvim.mkNullOrOption types.bool ''
If true, the view will always be shown in the edgebar even when it has no windows.
'';
open = helpers.mkNullOrStr ''
open = lib.nixvim.mkNullOrStr ''
Function or command to open a pinned view.
'';
wo = helpers.mkNullOrOption (with types; attrsOf anything) ''
wo = lib.nixvim.mkNullOrOption (with types; attrsOf anything) ''
View-specific window options.
'';
};
mkViewOptsOption =
name:
helpers.defaultNullOpts.mkListOf (
lib.nixvim.defaultNullOpts.mkListOf (
with types;
either str (submodule {
options = viewOpts;
@ -75,13 +74,13 @@ lib.nixvim.plugins.mkNeovimPlugin {
options =
mapAttrs
(_: defaultSize: {
size = helpers.defaultNullOpts.mkUnsignedInt defaultSize ''
size = lib.nixvim.defaultNullOpts.mkUnsignedInt defaultSize ''
Size of the short edge of the edgebar.
For edgebars, this is the minimum width.
For panels, minimum height.
'';
wo = helpers.mkNullOrOption (with types; attrsOf anything) ''
wo = lib.nixvim.mkNullOrOption (with types; attrsOf anything) ''
View-specific window options.
'';
})
@ -93,25 +92,25 @@ lib.nixvim.plugins.mkNeovimPlugin {
};
animate = {
enabled = helpers.defaultNullOpts.mkBool true ''
enabled = lib.nixvim.defaultNullOpts.mkBool true ''
Whether to enable animations.
'';
fps = helpers.defaultNullOpts.mkUnsignedInt 100 ''
fps = lib.nixvim.defaultNullOpts.mkUnsignedInt 100 ''
Frames per second.
'';
cps = helpers.defaultNullOpts.mkUnsignedInt 120 ''
cps = lib.nixvim.defaultNullOpts.mkUnsignedInt 120 ''
Cells per second.
'';
on_begin = helpers.defaultNullOpts.mkLuaFn ''
on_begin = lib.nixvim.defaultNullOpts.mkLuaFn ''
function()
vim.g.minianimate_disable = true
end
'' "Callback for the beginning of animations.";
on_end = helpers.defaultNullOpts.mkLuaFn ''
on_end = lib.nixvim.defaultNullOpts.mkLuaFn ''
function()
vim.g.minianimate_disable = false
end
@ -134,17 +133,17 @@ lib.nixvim.plugins.mkNeovimPlugin {
"⠏"
];
in
helpers.mkNullOrOption' {
lib.nixvim.mkNullOrOption' {
type =
with lib.types;
either strLua (submodule {
freeformType = attrsOf anything;
options = {
frames = helpers.defaultNullOpts.mkListOf types.str defaultFrames ''
frames = lib.nixvim.defaultNullOpts.mkListOf types.str defaultFrames ''
Frame characters.
'';
interval = helpers.defaultNullOpts.mkUnsignedInt 80 ''
interval = lib.nixvim.defaultNullOpts.mkUnsignedInt 80 ''
Interval time between two consecutive frames.
'';
};
@ -159,16 +158,16 @@ lib.nixvim.plugins.mkNeovimPlugin {
};
};
exit_when_last = helpers.defaultNullOpts.mkBool false ''
exit_when_last = lib.nixvim.defaultNullOpts.mkBool false ''
Enable this to exit Neovim when only edgy windows are left.
'';
close_when_all_hidden = helpers.defaultNullOpts.mkBool true ''
close_when_all_hidden = lib.nixvim.defaultNullOpts.mkBool true ''
Close edgy when all windows are hidden instead of opening one of them.
Disable to always keep at least one edgy split visible in each open section.
'';
wo = helpers.defaultNullOpts.mkAttrsOf types.anything {
wo = lib.nixvim.defaultNullOpts.mkAttrsOf types.anything {
winbar = true;
winfixwidth = true;
winfixheight = false;
@ -179,7 +178,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
# This option accepts an attrs or a lua string.
# Hence, we convert the string to raw lua in `apply`.
keys = helpers.defaultNullOpts.mkAttrsOf' {
keys = lib.nixvim.defaultNullOpts.mkAttrsOf' {
type = with lib.types; either strLuaFn (enum [ false ]);
description = ''
Buffer-local keymaps to be added to edgebar buffers.
@ -255,11 +254,11 @@ lib.nixvim.plugins.mkNeovimPlugin {
};
icons = {
closed = helpers.defaultNullOpts.mkStr " " ''
closed = lib.nixvim.defaultNullOpts.mkStr " " ''
Icon for closed edgebars.
'';
open = helpers.defaultNullOpts.mkStr " " ''
open = lib.nixvim.defaultNullOpts.mkStr " " ''
Icon for opened edgebars.
'';
};

107
plugins/by-name/flash/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
with lib;
@ -41,7 +40,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
"cmp_menu"
"noice"
"flash_prompt"
(helpers.mkRaw ''
(lib.nixvim.mkRaw ''
function(win)
-- exclude non-focusable windows
return not vim.api.nvim_win_get_config(win).focusable
@ -127,27 +126,27 @@ lib.nixvim.plugins.mkNeovimPlugin {
defaults = recursiveUpdate configDefaults defaultOverrides;
in
{
labels = helpers.defaultNullOpts.mkStr defaults.labels ''
labels = lib.nixvim.defaultNullOpts.mkStr defaults.labels ''
Labels appear next to the matches, allowing you to quickly jump to any location. Labels are
guaranteed not to exist as a continuation of the search pattern.
'';
search = {
multi_window = helpers.defaultNullOpts.mkBool defaults.search.multi_window ''
multi_window = lib.nixvim.defaultNullOpts.mkBool defaults.search.multi_window ''
Search/jump in all windows
'';
forward = helpers.defaultNullOpts.mkBool defaults.search.forward ''
forward = lib.nixvim.defaultNullOpts.mkBool defaults.search.forward ''
Search direction
'';
wrap = helpers.defaultNullOpts.mkBool defaults.search.wrap ''
wrap = lib.nixvim.defaultNullOpts.mkBool defaults.search.wrap ''
Continue searching after reaching the start/end of the file.
When `false`, find only matches in the given direction
'';
mode =
helpers.defaultNullOpts.mkEnum
lib.nixvim.defaultNullOpts.mkEnum
[
"exact"
"search"
@ -169,21 +168,21 @@ lib.nixvim.plugins.mkNeovimPlugin {
```
'';
incremental = helpers.defaultNullOpts.mkBool defaults.search.incremental ''
incremental = lib.nixvim.defaultNullOpts.mkBool defaults.search.incremental ''
Behave like `incsearch`.
'';
exclude = helpers.defaultNullOpts.mkListOf types.str defaults.search.exclude ''
exclude = lib.nixvim.defaultNullOpts.mkListOf types.str defaults.search.exclude ''
Excluded filetypes and custom window filters.
'';
trigger = helpers.defaultNullOpts.mkStr defaults.search.trigger ''
trigger = lib.nixvim.defaultNullOpts.mkStr defaults.search.trigger ''
Optional trigger character that needs to be typed before a jump label can be used.
It's NOT recommended to set this, unless you know what you're doing.
'';
max_length =
helpers.defaultNullOpts.mkNullable (with types; either (enum [ false ]) int)
lib.nixvim.defaultNullOpts.mkNullable (with types; either (enum [ false ]) int)
defaults.search.max_length
''
Max pattern length. If the pattern length is equal to this labels will no longer be skipped.
@ -192,12 +191,12 @@ lib.nixvim.plugins.mkNeovimPlugin {
};
jump = {
jumplist = helpers.defaultNullOpts.mkBool defaults.jump.jumplist ''
jumplist = lib.nixvim.defaultNullOpts.mkBool defaults.jump.jumplist ''
Save location in the jumplist.
'';
pos =
helpers.defaultNullOpts.mkEnum
lib.nixvim.defaultNullOpts.mkEnum
[
"start"
"end"
@ -208,28 +207,28 @@ lib.nixvim.plugins.mkNeovimPlugin {
Jump position
'';
history = helpers.defaultNullOpts.mkBool defaults.jump.history ''
history = lib.nixvim.defaultNullOpts.mkBool defaults.jump.history ''
Add pattern to search history.
'';
register = helpers.defaultNullOpts.mkBool defaults.jump.register ''
register = lib.nixvim.defaultNullOpts.mkBool defaults.jump.register ''
Add pattern to search register.
'';
nohlsearch = helpers.defaultNullOpts.mkBool defaults.jump.nohlsearch ''
nohlsearch = lib.nixvim.defaultNullOpts.mkBool defaults.jump.nohlsearch ''
Clear highlight after jump
'';
autojump = helpers.defaultNullOpts.mkBool defaults.jump.autojump ''
autojump = lib.nixvim.defaultNullOpts.mkBool defaults.jump.autojump ''
Automatically jump when there is only one match
'';
inclusive = helpers.defaultNullOpts.mkBool defaults.jump.inclusive ''
inclusive = lib.nixvim.defaultNullOpts.mkBool defaults.jump.inclusive ''
You can force inclusive/exclusive jumps by setting the `inclusive` option. By default it
will be automatically set based on the mode.
'';
offset = helpers.defaultNullOpts.mkInt defaults.jump.offset ''
offset = lib.nixvim.defaultNullOpts.mkInt defaults.jump.offset ''
jump position offset. Not used for range jumps.
0: default
1: when pos == "end" and pos < current position
@ -237,35 +236,35 @@ lib.nixvim.plugins.mkNeovimPlugin {
};
label = {
uppercase = helpers.defaultNullOpts.mkBool defaults.label.uppercase ''
uppercase = lib.nixvim.defaultNullOpts.mkBool defaults.label.uppercase ''
Allow uppercase labels.
'';
exclude = helpers.defaultNullOpts.mkStr defaults.label.exclude ''
exclude = lib.nixvim.defaultNullOpts.mkStr defaults.label.exclude ''
add any labels with the correct case here, that you want to exclude
'';
current = helpers.defaultNullOpts.mkBool true ''
current = lib.nixvim.defaultNullOpts.mkBool true ''
Add a label for the first match in the current window.
You can always jump to the first match with `<CR>`
'';
after =
helpers.defaultNullOpts.mkNullableWithRaw (with types; either bool (listOf int))
lib.nixvim.defaultNullOpts.mkNullableWithRaw (with types; either bool (listOf int))
defaults.label.after
''
Show the label after the match
'';
before =
helpers.defaultNullOpts.mkNullableWithRaw (with types; either bool (listOf int))
lib.nixvim.defaultNullOpts.mkNullableWithRaw (with types; either bool (listOf int))
defaults.label.before
''
Show the label before the match
'';
style =
helpers.defaultNullOpts.mkEnum
lib.nixvim.defaultNullOpts.mkEnum
[
"eol"
"overlay"
@ -278,7 +277,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
'';
reuse =
helpers.defaultNullOpts.mkEnum
lib.nixvim.defaultNullOpts.mkEnum
[
"lowercase"
"all"
@ -290,25 +289,27 @@ lib.nixvim.plugins.mkNeovimPlugin {
when typing more characters. By default only lower-case labels are re-used.
'';
distance = helpers.defaultNullOpts.mkBool defaults.label.distance ''
distance = lib.nixvim.defaultNullOpts.mkBool defaults.label.distance ''
for the current window, label targets closer to the cursor first
'';
min_pattern_length = helpers.defaultNullOpts.mkInt defaults.label.min_pattern_length ''
min_pattern_length = lib.nixvim.defaultNullOpts.mkInt defaults.label.min_pattern_length ''
minimum pattrn length to show labels
Ignored for custom labelers.
'';
rainbow = {
enabled = helpers.defaultNullOpts.mkBool defaults.label.rainbow.enabled ''
enabled = lib.nixvim.defaultNullOpts.mkBool defaults.label.rainbow.enabled ''
Enable this to use rainbow colors to highlight labels
Can be useful for visualizing Treesitter ranges.
'';
shade = helpers.defaultNullOpts.mkNullable (types.ints.between 1 9) defaults.label.rainbow.shade "";
shade =
lib.nixvim.defaultNullOpts.mkNullable (types.ints.between 1 9) defaults.label.rainbow.shade
"";
};
format = helpers.defaultNullOpts.mkLuaFn defaults.label.format ''
format = lib.nixvim.defaultNullOpts.mkLuaFn defaults.label.format ''
With `format`, you can change how the label is rendered.
Should return a list of `[text, highlight]` tuples.
@ -322,19 +323,19 @@ lib.nixvim.plugins.mkNeovimPlugin {
};
highlight = {
backdrop = helpers.defaultNullOpts.mkBool defaults.highlight.backdrop ''
backdrop = lib.nixvim.defaultNullOpts.mkBool defaults.highlight.backdrop ''
Show a backdrop with hl FlashBackdrop.
'';
matches = helpers.defaultNullOpts.mkBool defaults.highlight.matches ''
matches = lib.nixvim.defaultNullOpts.mkBool defaults.highlight.matches ''
Highlight the search matches.
'';
priority = helpers.defaultNullOpts.mkPositiveInt defaults.highlight.priority ''
priority = lib.nixvim.defaultNullOpts.mkPositiveInt defaults.highlight.priority ''
Extmark priority.
'';
groups = mapAttrs (name: helpers.defaultNullOpts.mkStr defaults.highlight.groups.${name}) {
groups = mapAttrs (name: lib.nixvim.defaultNullOpts.mkStr defaults.highlight.groups.${name}) {
# opt = description
match = "FlashMatch";
current = "FlashCurrent";
@ -343,47 +344,47 @@ lib.nixvim.plugins.mkNeovimPlugin {
};
};
action = helpers.defaultNullOpts.mkLuaFn defaults.action ''
action = lib.nixvim.defaultNullOpts.mkLuaFn defaults.action ''
action to perform when picking a label.
defaults to the jumping logic depending on the mode.
@type fun(match:Flash.Match, state:Flash.State)
'';
pattern = helpers.defaultNullOpts.mkStr defaults.pattern ''
pattern = lib.nixvim.defaultNullOpts.mkStr defaults.pattern ''
Initial pattern to use when opening flash.
'';
continue = helpers.defaultNullOpts.mkBool defaults.continue ''
continue = lib.nixvim.defaultNullOpts.mkBool defaults.continue ''
When `true`, flash will try to continue the last search.
'';
config = helpers.defaultNullOpts.mkLuaFn defaults.config ''
config = lib.nixvim.defaultNullOpts.mkLuaFn defaults.config ''
Set config to a function to dynamically change the config.
@type fun(opts:Flash.Config)
'';
prompt = {
enabled = helpers.defaultNullOpts.mkBool defaults.prompt.enabled ''
enabled = lib.nixvim.defaultNullOpts.mkBool defaults.prompt.enabled ''
Options for the floating window that shows the prompt, for regular jumps.
'';
# Not sure what the type is...
# Think it's listOf (maybeRaw (listOf (maybeRaw str)))?
prefix = helpers.defaultNullOpts.mkListOf types.anything defaults.prompt.prefix "";
prefix = lib.nixvim.defaultNullOpts.mkListOf types.anything defaults.prompt.prefix "";
win_config = helpers.defaultNullOpts.mkAttrsOf types.anything defaults.prompt.win_config ''
win_config = lib.nixvim.defaultNullOpts.mkAttrsOf types.anything defaults.prompt.win_config ''
See `:h nvim_open_win` for more details.
'';
};
remote_op = {
restore = helpers.defaultNullOpts.mkBool defaults.remote_op.restore ''
restore = lib.nixvim.defaultNullOpts.mkBool defaults.remote_op.restore ''
Restore window views and cursor position after doing a remote operation.
'';
motion = helpers.defaultNullOpts.mkBool defaults.remote_op.motion ''
motion = lib.nixvim.defaultNullOpts.mkBool defaults.remote_op.motion ''
For `jump.pos = "range"`, this setting is ignored.
- `true`: always enter a new motion when doing a remote operation
- `false`: use the window's cursor position and jump target
@ -401,7 +402,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
...
}@args:
# FIXME: use mkNullableWithRaw when #1618 is fixed
helpers.defaultNullOpts.mkNullable' (
lib.nixvim.defaultNullOpts.mkNullable' (
(removeAttrs args [
"options"
"defaults"
@ -441,7 +442,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
};
};
options = {
enabled = helpers.defaultNullOpts.mkBool defaults.enabled ''
enabled = lib.nixvim.defaultNullOpts.mkBool defaults.enabled ''
When `true`, flash will be activated during regular search by default.
You can always toggle when searching with `require("flash").toggle()`
'';
@ -477,7 +478,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
label = {
exclude = "hjkliardc";
};
keys = helpers.listToUnkeyedAttrs (lib.stringToCharacters "fFtT;,");
keys = lib.nixvim.listToUnkeyedAttrs (lib.stringToCharacters "fFtT;,");
char_actions = ''
function(motion)
return {
@ -497,21 +498,21 @@ lib.nixvim.plugins.mkNeovimPlugin {
jump.register = false;
};
options = {
enabled = helpers.defaultNullOpts.mkBool defaults.enabled "";
enabled = lib.nixvim.defaultNullOpts.mkBool defaults.enabled "";
autohide = helpers.defaultNullOpts.mkBool defaults.autohide ''
autohide = lib.nixvim.defaultNullOpts.mkBool defaults.autohide ''
Hide after jump when not using jump labels.
'';
jump_labels = helpers.defaultNullOpts.mkBool defaults.jump_labels ''
jump_labels = lib.nixvim.defaultNullOpts.mkBool defaults.jump_labels ''
Show jump labels.
'';
multi_line = helpers.defaultNullOpts.mkBool defaults.multi_line ''
multi_line = lib.nixvim.defaultNullOpts.mkBool defaults.multi_line ''
Set to `false` to use the current line only.
'';
keys = helpers.defaultNullOpts.mkAttrsOf' {
keys = lib.nixvim.defaultNullOpts.mkAttrsOf' {
type = types.str;
pluginDefault = defaults.keys;
description = ''
@ -526,7 +527,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
};
};
char_actions = helpers.defaultNullOpts.mkLuaFn defaults.char_actions ''
char_actions = lib.nixvim.defaultNullOpts.mkLuaFn defaults.char_actions ''
The direction for `prev` and `next` is determined by the motion.
`left` and `right` are always left and right.
'';

11
plugins/by-name/fzf-lua/default.nix
View file

@ -1,13 +1,12 @@
{
config,
lib,
helpers,
...
}:
with lib;
let
settingsOptions = {
fzf_bin = helpers.mkNullOrStr ''
fzf_bin = lib.nixvim.mkNullOrStr ''
The path to the `fzf` binary to use.
Example: `"sk"`
@ -55,7 +54,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
visible = false;
};
profile = helpers.defaultNullOpts.mkEnumFirstDefault [
profile = lib.nixvim.defaultNullOpts.mkEnumFirstDefault [
"default"
"fzf-native"
"fzf-tmux"
@ -76,13 +75,13 @@ lib.nixvim.plugins.mkNeovimPlugin {
description = "The `fzf-lua` action to run";
example = "git_files";
};
settings = helpers.mkSettingsOption {
settings = lib.nixvim.mkSettingsOption {
options = settingsOptions;
description = "`fzf-lua` settings for this command.";
example = settingsExample;
};
mode = helpers.keymaps.mkModeOption "n";
options = helpers.keymaps.mapConfigOptions;
mode = lib.nixvim.keymaps.mkModeOption "n";
options = lib.nixvim.keymaps.mapConfigOptions;
};
})
);

15
plugins/by-name/git-conflict/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
with lib;
@ -23,7 +22,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
settingsOptions = {
default_mappings =
helpers.defaultNullOpts.mkNullable (with types; either bool (attrsOf str)) true
lib.nixvim.defaultNullOpts.mkNullable (with types; either bool (attrsOf str)) true
''
This plugin offers default buffer local mappings inside conflicted files.
This is primarily because applying these mappings only to relevant buffers is impossible
@ -44,28 +43,28 @@ lib.nixvim.plugins.mkNeovimPlugin {
```
'';
default_commands = helpers.defaultNullOpts.mkBool true ''
default_commands = lib.nixvim.defaultNullOpts.mkBool true ''
Set to `false` to disable commands created by this plugin.
'';
disable_diagnostics = helpers.defaultNullOpts.mkBool false ''
disable_diagnostics = lib.nixvim.defaultNullOpts.mkBool false ''
This will disable the diagnostics in a buffer whilst it is conflicted.
'';
list_opener = helpers.defaultNullOpts.mkStr "copen" ''
list_opener = lib.nixvim.defaultNullOpts.mkStr "copen" ''
Command or function to open the conflicts list.
'';
highlights = {
incoming = helpers.defaultNullOpts.mkStr "DiffAdd" ''
incoming = lib.nixvim.defaultNullOpts.mkStr "DiffAdd" ''
Which highlight group to use for incoming changes.
'';
current = helpers.defaultNullOpts.mkStr "DiffText" ''
current = lib.nixvim.defaultNullOpts.mkStr "DiffText" ''
Which highlight group to use for current changes.
'';
ancestor = helpers.mkNullOrStr ''
ancestor = lib.nixvim.mkNullOrStr ''
Which highlight group to use for ancestor.
Plugin default: `null`

5
plugins/by-name/gitignore/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
with lib;
@ -26,9 +25,9 @@ lib.nixvim.plugins.mkVimPlugin {
example = "<leader>gi";
};
mode = helpers.keymaps.mkModeOption "n";
mode = lib.nixvim.keymaps.mkModeOption "n";
options = helpers.keymaps.mapConfigOptions;
options = lib.nixvim.keymaps.mapConfigOptions;
};
})
);

3
plugins/by-name/godot/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
with lib;
@ -23,7 +22,7 @@ lib.nixvim.plugins.mkVimPlugin {
];
settingsOptions = {
executable = helpers.defaultNullOpts.mkStr "godot" ''
executable = lib.nixvim.defaultNullOpts.mkStr "godot" ''
Path to the `godot` executable.
'';
};

7
plugins/by-name/goyo/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
with lib.nixvim.plugins;
@ -14,11 +13,11 @@ mkVimPlugin {
maintainers = [ maintainers.GaetanLepage ];
settingsOptions = {
width = helpers.mkNullOrOption types.ints.unsigned "width";
width = lib.nixvim.mkNullOrOption types.ints.unsigned "width";
height = helpers.mkNullOrOption types.ints.unsigned "height";
height = lib.nixvim.mkNullOrOption types.ints.unsigned "height";
linenr = helpers.defaultNullOpts.mkFlagInt 0 ''
linenr = lib.nixvim.defaultNullOpts.mkFlagInt 0 ''
Show line numbers when in Goyo mode.
'';
};

5
plugins/by-name/hydra/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
with lib;
@ -13,10 +12,10 @@ lib.nixvim.plugins.mkNeovimPlugin {
extraOptions = {
# A list of `Hydra` definitions
hydras = import ./hydras-option.nix { inherit lib helpers; };
hydras = import ./hydras-option.nix { inherit lib; };
};
settingsOptions = import ./settings-options.nix { inherit lib helpers; };
settingsOptions = import ./settings-options.nix { inherit lib; };
settingsExample = {
exit = false;

36
plugins/by-name/hydra/hydras-option.nix
View file

@ -1,23 +1,23 @@
{ lib, helpers }:
{ lib }:
with lib;
let
hydraType = types.submodule {
freeformType = with types; attrsOf anything;
options = {
name = helpers.mkNullOrStr ''
name = lib.nixvim.mkNullOrStr ''
Hydra's name.
Only used in auto-generated hint.
'';
mode = helpers.defaultNullOpts.mkNullable (
with lib.types; either helpers.keymaps.modeEnum (listOf helpers.keymaps.modeEnum)
mode = lib.nixvim.defaultNullOpts.mkNullable (
with lib.types; either lib.nixvim.keymaps.modeEnum (listOf lib.nixvim.keymaps.modeEnum)
) "n" "Modes where the hydra exists, same as `vim.keymap.set()` accepts.";
body = helpers.mkNullOrStr ''
body = lib.nixvim.mkNullOrStr ''
Key required to activate the hydra, when excluded, you can use `Hydra:activate()`.
'';
hint = helpers.mkNullOrStr ''
hint = lib.nixvim.mkNullOrStr ''
The hint for a hydra can let you know that it's active, and remind you of the
hydra's heads.
The string for the hint is passed directly to the hydra.
@ -26,56 +26,56 @@ let
for more information.
'';
config = import ./settings-options.nix { inherit lib helpers; };
config = import ./settings-options.nix { inherit lib; };
heads =
let
headsOptType = types.submodule {
freeformType = with types; attrsOf anything;
options = {
private = helpers.defaultNullOpts.mkBool false ''
private = lib.nixvim.defaultNullOpts.mkBool false ''
"When the hydra hides, this head does not stick out".
Private heads are unreachable outside of the hydra state.
'';
exit = helpers.defaultNullOpts.mkBool false ''
exit = lib.nixvim.defaultNullOpts.mkBool false ''
When true, stops the hydra after executing this head.
NOTE:
- All exit heads are private
- If no exit head is specified, `esc` is set by default
'';
exit_before = helpers.defaultNullOpts.mkBool false ''
exit_before = lib.nixvim.defaultNullOpts.mkBool false ''
Like `exit`, but stops the hydra BEFORE executing the command.
'';
ok_key = helpers.defaultNullOpts.mkBool true ''
ok_key = lib.nixvim.defaultNullOpts.mkBool true ''
When set to `false`, `config.on_key` isn't run after this head.
'';
desc = helpers.mkNullOrStr ''
desc = lib.nixvim.mkNullOrStr ''
Value shown in auto-generated hint.
When false, this key doesn't show up in the auto-generated hint.
'';
expr = helpers.defaultNullOpts.mkBool false ''
expr = lib.nixvim.defaultNullOpts.mkBool false ''
Same as the builtin `expr` map option.
See `:h :map-expression`.
'';
silent = helpers.defaultNullOpts.mkBool false ''
silent = lib.nixvim.defaultNullOpts.mkBool false ''
Same as the builtin `silent` map option.
See `:h :map-silent`.
'';
nowait = helpers.defaultNullOpts.mkBool false ''
nowait = lib.nixvim.defaultNullOpts.mkBool false ''
For Pink Hydras only.
Allows binding a key which will immediately perform its action and not wait
`timeoutlen` for a possible continuation.
'';
mode = helpers.mkNullOrOption (
with lib.types; either helpers.keymaps.modeEnum (listOf helpers.keymaps.modeEnum)
mode = lib.nixvim.mkNullOrOption (
with lib.types; either lib.nixvim.keymaps.modeEnum (listOf lib.nixvim.keymaps.modeEnum)
) "Override `mode` for this head.";
};
};
@ -93,7 +93,7 @@ let
)
);
in
helpers.mkNullOrOption (types.listOf headType) ''
lib.nixvim.mkNullOrOption (types.listOf headType) ''
Each Hydra's head has the form:
`[head rhs opts]

38
plugins/by-name/hydra/settings-options.nix
View file

@ -5,19 +5,19 @@
# - for `plugins.hydra.hydras.[].config`
#
# -> https://github.com/nvimtools/hydra.nvim?tab=readme-ov-file#config
{ helpers, lib, ... }:
{ lib, ... }:
with lib;
{
debug = helpers.defaultNullOpts.mkBool false ''
debug = lib.nixvim.defaultNullOpts.mkBool false ''
Whether to enable debug mode.
'';
exit = helpers.defaultNullOpts.mkBool false ''
exit = lib.nixvim.defaultNullOpts.mkBool false ''
Set the default exit value for each head in the hydra.
'';
foreign_keys =
helpers.defaultNullOpts.mkEnum
lib.nixvim.defaultNullOpts.mkEnum
[
"warn"
"run"
@ -30,38 +30,38 @@ with lib;
- `"run"`: hydra stays active, runs the foreign key
'';
color = helpers.defaultNullOpts.mkStr "red" ''
color = lib.nixvim.defaultNullOpts.mkStr "red" ''
See `:h hydra-colors`.
`"red" | "amaranth" | "teal" | "pink"`
'';
buffer = helpers.defaultNullOpts.mkNullable (
buffer = lib.nixvim.defaultNullOpts.mkNullable (
with types; either (enum [ true ]) ints.unsigned
) null "Define a hydra for the given buffer, pass `true` for current buf.";
invoke_on_body = helpers.defaultNullOpts.mkBool false ''
invoke_on_body = lib.nixvim.defaultNullOpts.mkBool false ''
When true, summon the hydra after pressing only the `body` keys.
Normally a head is required.
'';
desc = helpers.defaultNullOpts.mkStr null ''
desc = lib.nixvim.defaultNullOpts.mkStr null ''
Description used for the body keymap when `invoke_on_body` is true.
When nil, "[Hydra] .. name" is used.
'';
on_enter = helpers.mkNullOrLuaFn ''
on_enter = lib.nixvim.mkNullOrLuaFn ''
Called when the hydra is activated.
'';
on_exit = helpers.mkNullOrLuaFn ''
on_exit = lib.nixvim.mkNullOrLuaFn ''
Called before the hydra is deactivated.
'';
on_key = helpers.mkNullOrLuaFn ''
on_key = lib.nixvim.mkNullOrLuaFn ''
Called after every hydra head.
'';
timeout = helpers.defaultNullOpts.mkNullable (with types; either bool ints.unsigned) false ''
timeout = lib.nixvim.defaultNullOpts.mkNullable (with types; either bool ints.unsigned) false ''
Timeout after which the hydra is automatically disabled.
Calling any head will refresh the timeout
- `true`: timeout set to value of `timeoutlen` (`:h timeoutlen`)
@ -76,7 +76,7 @@ with lib;
freeformType = with types; attrsOf anything;
options = {
type =
helpers.mkNullOrOption
lib.nixvim.mkNullOrOption
(types.enum [
"window"
"cmdline"
@ -93,7 +93,7 @@ with lib;
Defaults to "window" if `hint` is passed to the hydra otherwise defaults to "cmdline".
'';
position = helpers.defaultNullOpts.mkEnum [
position = lib.nixvim.defaultNullOpts.mkEnum [
"top-left"
"top"
"top-right"
@ -105,23 +105,23 @@ with lib;
"bottom-right"
] "bottom" "Set the position of the hint window.";
offset = helpers.defaultNullOpts.mkInt 0 ''
offset = lib.nixvim.defaultNullOpts.mkInt 0 ''
Offset of the floating window from the nearest editor border.
'';
float_opts = helpers.mkNullOrOption (with types; attrsOf anything) ''
float_opts = lib.nixvim.mkNullOrOption (with types; attrsOf anything) ''
Options passed to `nvim_open_win()`. See `:h nvim_open_win()`.
Lets you set `border`, `header`, `footer`, etc.
Note: `row`, `col`, `height`, `width`, `relative`, and `anchor` should not be overridden.
'';
show_name = helpers.defaultNullOpts.mkBool true ''
show_name = lib.nixvim.defaultNullOpts.mkBool true ''
Show the hydras name (or "HYDRA:" if not given a name), at the beginning of an
auto-generated hint.
'';
hide_on_load = helpers.defaultNullOpts.mkBool false ''
hide_on_load = lib.nixvim.defaultNullOpts.mkBool false ''
If set to true, this will prevent the hydra's hint window from displaying immediately.
Note: you can still show the window manually by calling `Hydra.hint:show()` and manually
@ -160,7 +160,7 @@ with lib;
};
};
in
helpers.defaultNullOpts.mkNullable (with types; either (enum [ false ]) hintConfigType)
lib.nixvim.defaultNullOpts.mkNullable (with types; either (enum [ false ]) hintConfigType)
{
show_name = true;
position = "bottom";

7
plugins/by-name/improved-search/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
with lib;
@ -30,7 +29,7 @@ lib.nixvim.plugins.mkVimPlugin {
example = "!";
};
mode = helpers.keymaps.mkModeOption "";
mode = lib.nixvim.keymaps.mkModeOption "";
action = mkOption {
type =
@ -58,7 +57,7 @@ lib.nixvim.plugins.mkVimPlugin {
example = "in_place";
};
options = helpers.keymaps.mapConfigOptions;
options = lib.nixvim.keymaps.mapConfigOptions;
};
});
default = [ ];
@ -119,7 +118,7 @@ lib.nixvim.plugins.mkVimPlugin {
isString keymap.action
# One of the plugin builtin functions
then
helpers.mkRaw "require('improved-search').${keymap.action}"
lib.nixvim.mkRaw "require('improved-search').${keymap.action}"
# If the user specifies a raw action directly
else
keymap.action;

25
plugins/by-name/instant/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
with lib;
@ -14,52 +13,52 @@ mkVimPlugin {
maintainers = [ maintainers.GaetanLepage ];
settingsOptions = {
username = helpers.mkNullOrStr ''
username = lib.nixvim.mkNullOrStr ''
Username.
Explicitly set to `null` if you do not want this option to be set.
'';
only_cwd = helpers.defaultNullOpts.mkBool true ''
only_cwd = lib.nixvim.defaultNullOpts.mkBool true ''
Choose whether to share files only in the current working directory in session mode.
'';
cursor_hl_group_user1 = helpers.defaultNullOpts.mkStr "Cursor" ''
cursor_hl_group_user1 = lib.nixvim.defaultNullOpts.mkStr "Cursor" ''
Cursor highlight group for user 1.
'';
cursor_hl_group_user2 = helpers.defaultNullOpts.mkStr "Cursor" ''
cursor_hl_group_user2 = lib.nixvim.defaultNullOpts.mkStr "Cursor" ''
Cursor highlight group for user 2.
'';
cursor_hl_group_user3 = helpers.defaultNullOpts.mkStr "Cursor" ''
cursor_hl_group_user3 = lib.nixvim.defaultNullOpts.mkStr "Cursor" ''
Cursor highlight group for user 3.
'';
cursor_hl_group_user4 = helpers.defaultNullOpts.mkStr "Cursor" ''
cursor_hl_group_user4 = lib.nixvim.defaultNullOpts.mkStr "Cursor" ''
Cursor highlight group for user 4.
'';
cursor_hl_group_default = helpers.defaultNullOpts.mkStr "Cursor" ''
cursor_hl_group_default = lib.nixvim.defaultNullOpts.mkStr "Cursor" ''
Cursor highlight group for any other userr.
'';
name_hl_group_user1 = helpers.defaultNullOpts.mkStr "CursorLineNr" ''
name_hl_group_user1 = lib.nixvim.defaultNullOpts.mkStr "CursorLineNr" ''
Virtual text highlight group for user 1.
'';
name_hl_group_user2 = helpers.defaultNullOpts.mkStr "CursorLineNr" ''
name_hl_group_user2 = lib.nixvim.defaultNullOpts.mkStr "CursorLineNr" ''
Virtual text highlight group for user 2.
'';
name_hl_group_user3 = helpers.defaultNullOpts.mkStr "CursorLineNr" ''
name_hl_group_user3 = lib.nixvim.defaultNullOpts.mkStr "CursorLineNr" ''
Virtual text highlight group for user 3.
'';
name_hl_group_user4 = helpers.defaultNullOpts.mkStr "CursorLineNr" ''
name_hl_group_user4 = lib.nixvim.defaultNullOpts.mkStr "CursorLineNr" ''
Virtual text highlight group for user 4.
'';
name_hl_group_default = helpers.defaultNullOpts.mkStr "CursorLineNr" ''
name_hl_group_default = lib.nixvim.defaultNullOpts.mkStr "CursorLineNr" ''
Virtual text highlight group for any other user.
'';
};

9
plugins/by-name/julia-cell/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
let
@ -45,7 +44,7 @@ lib.nixvim.plugins.mkVimPlugin {
settingsOptions = {
delimit_cells_by =
helpers.defaultNullOpts.mkEnumFirstDefault
lib.nixvim.defaultNullOpts.mkEnumFirstDefault
[
"marks"
"tags"
@ -54,7 +53,7 @@ lib.nixvim.plugins.mkVimPlugin {
Specifies if cells are delimited by 'marks' or 'tags'.
'';
tag = helpers.defaultNullOpts.mkStr "##" "Specifies the tag format.";
tag = lib.nixvim.defaultNullOpts.mkStr "##" "Specifies the tag format.";
};
extraOptions = {
@ -65,7 +64,9 @@ lib.nixvim.plugins.mkVimPlugin {
default = false;
};
}
// (mapAttrs (name: value: helpers.mkNullOrOption types.str "Keymap for ${value.desc}.") mappings);
// (mapAttrs (
name: value: lib.nixvim.mkNullOrOption types.str "Keymap for ${value.desc}."
) mappings);
};
extraConfig = cfg: {

4
plugins/by-name/lsp-signature/default.nix
View file

@ -1,4 +1,4 @@
{ lib, helpers, ... }:
{ lib, ... }:
let
inherit (lib.nixvim) defaultNullOpts;
in
@ -89,7 +89,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
Whether to enable virtual hint.
'';
hint_prefix = helpers.defaultNullOpts.mkNullable' {
hint_prefix = lib.nixvim.defaultNullOpts.mkNullable' {
type = lib.types.anything;
pluginDefault = "🐼 ";
description = ''

3
plugins/by-name/lspkind/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
config,
...
}:
@ -28,7 +27,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
description = "Integrate with nvim-cmp";
};
after = helpers.mkNullOrOption types.str "Function to run after calculating the formatting. function(entry, vim_item, kind)";
after = lib.nixvim.mkNullOrOption types.str "Function to run after calculating the formatting. function(entry, vim_item, kind)";
};
};

9
plugins/by-name/ltex-extra/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
config,
...
}:
@ -15,7 +14,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
callSetup = false;
settingsOptions = {
path = helpers.defaultNullOpts.mkStr "" ''
path = lib.nixvim.defaultNullOpts.mkStr "" ''
Path (relative to project root) to load external files from.
Commonly used values are:
@ -23,16 +22,16 @@ lib.nixvim.plugins.mkNeovimPlugin {
- `.vscode` for compatibility with projects using the associated VS Code extension.
'';
init_check = helpers.defaultNullOpts.mkBool true ''
init_check = lib.nixvim.defaultNullOpts.mkBool true ''
Whether to load dictionaries on startup.
'';
load_langs = helpers.defaultNullOpts.mkListOf types.str [ "en-US" ] ''
load_langs = lib.nixvim.defaultNullOpts.mkListOf types.str [ "en-US" ] ''
Languages for witch dicionnaries will be loaded.
See `plugins.lsp.servers.ltex.languages` for possible values.
'';
log_level = helpers.defaultNullOpts.mkEnumFirstDefault [
log_level = lib.nixvim.defaultNullOpts.mkEnumFirstDefault [
"none"
"trace"
"debug"

15
plugins/by-name/magma-nvim/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
with lib;
@ -15,7 +14,7 @@ mkVimPlugin {
settingsOptions = {
image_provider =
helpers.defaultNullOpts.mkEnumFirstDefault
lib.nixvim.defaultNullOpts.mkEnumFirstDefault
[
"none"
"ueberzug"
@ -28,7 +27,7 @@ mkVimPlugin {
- "kitty" -- use the Kitty protocol to display images.
'';
automatically_open_output = helpers.defaultNullOpts.mkBool true ''
automatically_open_output = lib.nixvim.defaultNullOpts.mkBool true ''
If this is true, then whenever you have an active cell its output window will be
automatically shown.
@ -40,27 +39,27 @@ mkVimPlugin {
You can then open the output window at will using `:MagmaShowOutput`.
'';
wrap_output = helpers.defaultNullOpts.mkBool true ''
wrap_output = lib.nixvim.defaultNullOpts.mkBool true ''
If this is true, then text output in the output window will be wrapped (akin to `set wrap`).
'';
output_window_borders = helpers.defaultNullOpts.mkBool true ''
output_window_borders = lib.nixvim.defaultNullOpts.mkBool true ''
If this is true, then the output window will have rounded borders.
If it is false, it will have no borders.
'';
cell_highlight_group = helpers.defaultNullOpts.mkStr "CursorLine" ''
cell_highlight_group = lib.nixvim.defaultNullOpts.mkStr "CursorLine" ''
The highlight group to be used for highlighting cells.
'';
save_path = helpers.defaultNullOpts.mkStr (lib.nixvim.literalLua "vim.fn.stdpath('data') .. '/magma'") ''
save_path = lib.nixvim.defaultNullOpts.mkStr (lib.nixvim.literalLua "vim.fn.stdpath('data') .. '/magma'") ''
Where to save/load with `:MagmaSave` and `:MagmaLoad` (with no parameters).
The generated file is placed in this directory, with the filename itself being the
buffer's name, with `%` replaced by `%%` and `/` replaced by `%`, and postfixed with the
extension `.json`.
'';
show_mimetype_debug = helpers.defaultNullOpts.mkBool false ''
show_mimetype_debug = lib.nixvim.defaultNullOpts.mkBool false ''
If this is true, then before any non-iostream output chunk, Magma shows the mimetypes it
received for it.
This is meant for debugging and adding new mimetypes.

49
plugins/by-name/neoclip/default.nix
View file

@ -1,7 +1,6 @@
{
lib,
config,
helpers,
...
}:
with lib;
@ -13,21 +12,21 @@ lib.nixvim.plugins.mkNeovimPlugin {
maintainers = [ maintainers.GaetanLepage ];
settingsOptions = {
history = helpers.defaultNullOpts.mkUnsignedInt 1000 ''
history = lib.nixvim.defaultNullOpts.mkUnsignedInt 1000 ''
The max number of entries to store.
'';
enable_persistent_history = helpers.defaultNullOpts.mkBool false ''
enable_persistent_history = lib.nixvim.defaultNullOpts.mkBool false ''
If set to `true` the history is stored on `VimLeavePre` using `sqlite.lua` and lazy loaded when
querying.
'';
length_limit = helpers.defaultNullOpts.mkUnsignedInt 1048576 ''
length_limit = lib.nixvim.defaultNullOpts.mkUnsignedInt 1048576 ''
The max number of characters of an entry to be stored (default 1MiB).
If the length of the yanked string is larger than the limit, it will not be stored.
'';
continuous_sync = helpers.defaultNullOpts.mkBool false ''
continuous_sync = lib.nixvim.defaultNullOpts.mkBool false ''
If set to `true`, the runtime history is synced with the persistent storage everytime it's
changed or queried.
@ -42,12 +41,12 @@ lib.nixvim.plugins.mkNeovimPlugin {
[README](https://github.com/AckslD/nvim-neoclip.lua#custom-actions).
'';
db_path = helpers.defaultNullOpts.mkStr (lib.nixvim.literalLua "vim.fn.stdpath('data') .. '/databases/neoclip.sqlite3'") ''
db_path = lib.nixvim.defaultNullOpts.mkStr (lib.nixvim.literalLua "vim.fn.stdpath('data') .. '/databases/neoclip.sqlite3'") ''
The path to the sqlite database to store history if `enable_persistent_history=true`.
Defaults to `$XDG_DATA_HOME/nvim/databases/neoclip.sqlite3`.
'';
filter = helpers.defaultNullOpts.mkLuaFn null ''
filter = lib.nixvim.defaultNullOpts.mkLuaFn null ''
A function to filter what entries to store (default all are stored).
This function filter should return `true` (include the yanked entry) or `false` (don't include
it) based on a table as the only argument, which has the following keys:
@ -57,7 +56,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
- `buffer_name`: The name of the buffer where the yank happened.
'';
preview = helpers.defaultNullOpts.mkBool true ''
preview = lib.nixvim.defaultNullOpts.mkBool true ''
Whether to show a preview (default) of the current entry or not.
Useful for for example multiline yanks.
When yanking the filetype is recorded in order to enable correct syntax highlighting in the
@ -67,32 +66,32 @@ lib.nixvim.plugins.mkNeovimPlugin {
need to configure `telescope` with the `dynamic_preview_title = true` option.
'';
prompt = helpers.defaultNullOpts.mkStr null ''
prompt = lib.nixvim.defaultNullOpts.mkStr null ''
The prompt string used by the picker (`telescope`/`fzf-lua`).
'';
default_register =
helpers.defaultNullOpts.mkNullable (with lib.types; either str (listOf str)) "\""
lib.nixvim.defaultNullOpts.mkNullable (with lib.types; either str (listOf str)) "\""
''
What register to use by default when not specified (e.g. `Telescope neoclip`).
Can be a string such as `"\""` (single register) or a table of strings such as
`["\"" "+" "*"]`.
'';
default_register_macros = helpers.defaultNullOpts.mkStr "q" ''
default_register_macros = lib.nixvim.defaultNullOpts.mkStr "q" ''
What register to use for macros by default when not specified (e.g. `Telescope macroscope`).
'';
enable_macro_history = helpers.defaultNullOpts.mkBool true ''
enable_macro_history = lib.nixvim.defaultNullOpts.mkBool true ''
If true (default) any recorded macro will be saved, see
[macros](https://github.com/AckslD/nvim-neoclip.lua#macros).
'';
content_spec_column = helpers.defaultNullOpts.mkBool false ''
content_spec_column = lib.nixvim.defaultNullOpts.mkBool false ''
Can be set to `true` to use instead of the preview.
'';
disable_keycodes_parsing = helpers.defaultNullOpts.mkBool false ''
disable_keycodes_parsing = lib.nixvim.defaultNullOpts.mkBool false ''
If set to true, macroscope will display the internal byte representation, instead of a proper
string that can be used in a map.
@ -101,46 +100,46 @@ lib.nixvim.plugins.mkNeovimPlugin {
'';
on_select = {
move_to_front = helpers.defaultNullOpts.mkBool false ''
move_to_front = lib.nixvim.defaultNullOpts.mkBool false ''
If the entry should be set to last in the list when pressing the key to select a yank.
'';
close_telescope = helpers.defaultNullOpts.mkBool true ''
close_telescope = lib.nixvim.defaultNullOpts.mkBool true ''
If telescope should close whenever an item is selected.
'';
};
on_paste = {
set_reg = helpers.defaultNullOpts.mkBool false ''
set_reg = lib.nixvim.defaultNullOpts.mkBool false ''
If the register should be populated when pressing the key to paste directly.
'';
move_to_front = helpers.defaultNullOpts.mkBool false ''
move_to_front = lib.nixvim.defaultNullOpts.mkBool false ''
If the entry should be set to last in the list when pressing the key to paste directly.
'';
close_telescope = helpers.defaultNullOpts.mkBool true ''
close_telescope = lib.nixvim.defaultNullOpts.mkBool true ''
If `telescope` should close whenever a yank is pasted.
'';
};
on_replay = {
set_reg = helpers.defaultNullOpts.mkBool false ''
set_reg = lib.nixvim.defaultNullOpts.mkBool false ''
If the register should be populated when pressing the key to replay a recorded macro.
'';
move_to_front = helpers.defaultNullOpts.mkBool false ''
move_to_front = lib.nixvim.defaultNullOpts.mkBool false ''
If the entry should be set to last in the list when pressing the key to replay a recorded
macro.
'';
close_telescope = helpers.defaultNullOpts.mkBool true ''
close_telescope = lib.nixvim.defaultNullOpts.mkBool true ''
If telescope should close whenever a macro is replayed.
'';
};
on_custom_action = {
close_telescope = helpers.defaultNullOpts.mkBool true ''
close_telescope = lib.nixvim.defaultNullOpts.mkBool true ''
If telescope should close whenever a custom action is executed.
'';
};
@ -149,7 +148,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
telescope =
# Using `anything` here because of the annoying `custom` key (and also, a mapping can target several keys):
# https://github.com/AckslD/nvim-neoclip.lua?tab=readme-ov-file#custom-actions
helpers.defaultNullOpts.mkAttrsOf (with types; attrsOf anything)
lib.nixvim.defaultNullOpts.mkAttrsOf (with types; attrsOf anything)
{
i = {
select = "<cr>";
@ -182,7 +181,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
'';
fzf =
helpers.defaultNullOpts.mkAttrsOf types.anything
lib.nixvim.defaultNullOpts.mkAttrsOf types.anything
{
select = "default";
paste = "ctrl-p";

19
plugins/by-name/neoscroll/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
with lib;
@ -13,7 +12,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
settingsOptions = {
mappings =
helpers.defaultNullOpts.mkListOf types.str
lib.nixvim.defaultNullOpts.mkListOf types.str
[
"<C-u>"
"<C-d>"
@ -33,25 +32,25 @@ lib.nixvim.plugins.mkNeovimPlugin {
```
'';
hide_cursor = helpers.defaultNullOpts.mkBool true ''
hide_cursor = lib.nixvim.defaultNullOpts.mkBool true ''
If 'termguicolors' is set, hide the cursor while scrolling.
'';
step_eof = helpers.defaultNullOpts.mkBool true ''
step_eof = lib.nixvim.defaultNullOpts.mkBool true ''
When `move_cursor` is `true` scrolling downwards will stop when the bottom line of the
window is the last line of the file.
'';
respect_scrolloff = helpers.defaultNullOpts.mkBool false ''
respect_scrolloff = lib.nixvim.defaultNullOpts.mkBool false ''
The cursor stops at the scrolloff margin.
Try combining this option with either `stop_eof` or `cursor_scrolls_alone` (or both).
'';
cursor_scrolls_alone = helpers.defaultNullOpts.mkBool true ''
cursor_scrolls_alone = lib.nixvim.defaultNullOpts.mkBool true ''
The cursor will keep on scrolling even if the window cannot scroll further.
'';
easing_function = helpers.mkNullOrStr ''
easing_function = lib.nixvim.mkNullOrStr ''
Name of the easing function to use by default in all scrolling animamtions.
`scroll()` that don't provide the optional `easing` argument will use this easing
function.
@ -59,7 +58,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
(constant scrolling speed).
'';
pre_hook = helpers.mkNullOrLuaFn ''
pre_hook = lib.nixvim.mkNullOrLuaFn ''
Function to run before the scrolling animation starts.
The function will be called with the `info` parameter which can be optionally passed to
`scroll()` (or any of the provided wrappers).
@ -67,11 +66,11 @@ lib.nixvim.plugins.mkNeovimPlugin {
animations.
'';
post_hook = helpers.mkNullOrLuaFn ''
post_hook = lib.nixvim.mkNullOrLuaFn ''
Equivalent to `pre_hook` but the function will run after the scrolling animation ends.
'';
performance_mode = helpers.defaultNullOpts.mkBool false ''
performance_mode = lib.nixvim.defaultNullOpts.mkBool false ''
Option to enable "Performance Mode" on all buffers.
'';
};

59
plugins/by-name/nvim-autopairs/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
config,
...
}:
@ -12,56 +11,56 @@ lib.nixvim.plugins.mkNeovimPlugin {
maintainers = [ maintainers.GaetanLepage ];
settingsOptions = {
disable_filetype = helpers.defaultNullOpts.mkListOf types.str [
disable_filetype = lib.nixvim.defaultNullOpts.mkListOf types.str [
"TelescopePrompt"
"spectre_panel"
] "Disabled filetypes.";
disable_in_macro = helpers.defaultNullOpts.mkBool false ''
disable_in_macro = lib.nixvim.defaultNullOpts.mkBool false ''
Disable when recording or executing a macro.
'';
disable_in_visualblock = helpers.defaultNullOpts.mkBool false ''
disable_in_visualblock = lib.nixvim.defaultNullOpts.mkBool false ''
Disable when insert after visual block mode.
'';
disable_in_replace_mode = helpers.defaultNullOpts.mkBool true ''
disable_in_replace_mode = lib.nixvim.defaultNullOpts.mkBool true ''
Disable in replace mode.
'';
ignored_next_char = helpers.defaultNullOpts.mkLua "[=[[%w%%%'%[%\"%.%`%$]]=]" ''
ignored_next_char = lib.nixvim.defaultNullOpts.mkLua "[=[[%w%%%'%[%\"%.%`%$]]=]" ''
Regexp to ignore if it matches the next character.
'';
enable_moveright = helpers.defaultNullOpts.mkBool true ''
enable_moveright = lib.nixvim.defaultNullOpts.mkBool true ''
Enable moveright.
'';
enable_afterquote = helpers.defaultNullOpts.mkBool true ''
enable_afterquote = lib.nixvim.defaultNullOpts.mkBool true ''
Add bracket pairs after quote.
'';
enable_check_bracket_line = helpers.defaultNullOpts.mkBool true ''
enable_check_bracket_line = lib.nixvim.defaultNullOpts.mkBool true ''
Check bracket in same line.
'';
enable_bracket_in_quote = helpers.defaultNullOpts.mkBool true ''
enable_bracket_in_quote = lib.nixvim.defaultNullOpts.mkBool true ''
Enable bracket in quote.
'';
enable_abbr = helpers.defaultNullOpts.mkBool false ''
enable_abbr = lib.nixvim.defaultNullOpts.mkBool false ''
Trigger abbreviation.
'';
break_undo = helpers.defaultNullOpts.mkBool true ''
break_undo = lib.nixvim.defaultNullOpts.mkBool true ''
Switch for basic rule break undo sequence.
'';
check_ts = helpers.defaultNullOpts.mkBool false ''
check_ts = lib.nixvim.defaultNullOpts.mkBool false ''
Use treesitter to check for a pair.
'';
ts_config = helpers.defaultNullOpts.mkAttrsOf types.anything {
ts_config = lib.nixvim.defaultNullOpts.mkAttrsOf types.anything {
lua = [
"string"
"source"
@ -73,29 +72,29 @@ lib.nixvim.plugins.mkNeovimPlugin {
];
} "Configuration for TreeSitter.";
map_cr = helpers.defaultNullOpts.mkBool true ''
map_cr = lib.nixvim.defaultNullOpts.mkBool true ''
Map the `<CR>` key to confirm the completion.
'';
map_bs = helpers.defaultNullOpts.mkBool true ''
map_bs = lib.nixvim.defaultNullOpts.mkBool true ''
Map the `<BS>` key to delete the pair.
'';
map_c_h = helpers.defaultNullOpts.mkBool false ''
map_c_h = lib.nixvim.defaultNullOpts.mkBool false ''
Map the `<C-h>` key to delete a pair.
'';
map_c_w = helpers.defaultNullOpts.mkBool false ''
map_c_w = lib.nixvim.defaultNullOpts.mkBool false ''
Map the `<C-w>` key to delete a pair if possible.
'';
fast_wrap = {
map = helpers.defaultNullOpts.mkStr "<M-e>" ''
map = lib.nixvim.defaultNullOpts.mkStr "<M-e>" ''
The key to trigger fast_wrap.
'';
chars =
helpers.defaultNullOpts.mkListOf types.str
lib.nixvim.defaultNullOpts.mkListOf types.str
[
"{"
"["
@ -107,41 +106,41 @@ lib.nixvim.plugins.mkNeovimPlugin {
Characters for which to enable fast wrap.
'';
pattern = helpers.defaultNullOpts.mkLua ''[=[[%'%"%>%]%)%}%,%`]]=]'' ''
pattern = lib.nixvim.defaultNullOpts.mkLua ''[=[[%'%"%>%]%)%}%,%`]]=]'' ''
The pattern to match against.
'';
end_key = helpers.defaultNullOpts.mkStr "$" ''
end_key = lib.nixvim.defaultNullOpts.mkStr "$" ''
End key.
'';
before_key = helpers.defaultNullOpts.mkStr "h" ''
before_key = lib.nixvim.defaultNullOpts.mkStr "h" ''
Before key.
'';
after_key = helpers.defaultNullOpts.mkStr "l" ''
after_key = lib.nixvim.defaultNullOpts.mkStr "l" ''
After key.
'';
cursor_pos_before = helpers.defaultNullOpts.mkBool true ''
cursor_pos_before = lib.nixvim.defaultNullOpts.mkBool true ''
Whether the cursor should be placed before or after the substitution.
'';
keys = helpers.defaultNullOpts.mkStr "qwertyuiopzxcvbnmasdfghjkl" '''';
keys = lib.nixvim.defaultNullOpts.mkStr "qwertyuiopzxcvbnmasdfghjkl" '''';
highlight = helpers.defaultNullOpts.mkStr "Search" ''
highlight = lib.nixvim.defaultNullOpts.mkStr "Search" ''
Which highlight group to use for the match.
'';
highlight_grey = helpers.defaultNullOpts.mkStr "Comment" ''
highlight_grey = lib.nixvim.defaultNullOpts.mkStr "Comment" ''
Which highlight group to use for the grey part.
'';
manual_position = helpers.defaultNullOpts.mkBool true ''
manual_position = lib.nixvim.defaultNullOpts.mkBool true ''
Whether to enable manual position.
'';
use_virt_lines = helpers.defaultNullOpts.mkBool true ''
use_virt_lines = lib.nixvim.defaultNullOpts.mkBool true ''
Whether to use `virt_lines`.
'';
};

3
plugins/by-name/nvim-tree/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
config,
...
}:
@ -145,7 +144,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
autoCmd =
(lib.optional autoOpenEnabled {
event = "VimEnter";
callback = helpers.mkRaw "open_nvim_tree";
callback = lib.nixvim.mkRaw "open_nvim_tree";
})
++ (lib.optional cfg.autoClose {
event = "BufEnter";

13
plugins/by-name/otter/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
config,
...
}:
@ -18,7 +17,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
settingsOptions = {
lsp = {
hover = {
border = helpers.defaultNullOpts.mkListOf lib.types.str [
border = lib.nixvim.defaultNullOpts.mkListOf lib.types.str [
"╭"
"─"
"╮"
@ -30,7 +29,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
] "";
};
diagnostic_update_events = helpers.defaultNullOpts.mkListOf' {
diagnostic_update_events = lib.nixvim.defaultNullOpts.mkListOf' {
type = lib.types.str;
pluginDefault = [ "BufWritePost" ];
description = ''
@ -47,13 +46,13 @@ lib.nixvim.plugins.mkNeovimPlugin {
};
buffers = {
set_filetype = helpers.defaultNullOpts.mkBool false ''
set_filetype = lib.nixvim.defaultNullOpts.mkBool false ''
If set to true, the filetype of the otterbuffers will be set.
Otherwise only the autocommand of lspconfig that attaches
the language server will be executed without setting the filetype.
'';
write_to_disk = helpers.defaultNullOpts.mkBool false ''
write_to_disk = lib.nixvim.defaultNullOpts.mkBool false ''
Write `<path>.otter.<embedded language extension>` files
to disk on save of main buffer.
Useful for some linters that require actual files,
@ -61,13 +60,13 @@ lib.nixvim.plugins.mkNeovimPlugin {
'';
};
strip_wrapping_quote_characters = helpers.defaultNullOpts.mkListOf lib.types.str [
strip_wrapping_quote_characters = lib.nixvim.defaultNullOpts.mkListOf lib.types.str [
"'"
"\""
"\`"
] "";
handle_leading_whitespace = helpers.defaultNullOpts.mkBool false ''
handle_leading_whitespace = lib.nixvim.defaultNullOpts.mkBool false ''
Otter may not work the way you expect when entire code blocks are indented (eg. in Org files).
When true, otter handles these cases fully. This is a (minor) performance hit.
'';

5
plugins/by-name/parinfer-rust/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
lib.nixvim.plugins.mkVimPlugin {
@ -12,7 +11,7 @@ lib.nixvim.plugins.mkVimPlugin {
settingsOptions = {
mode =
helpers.defaultNullOpts.mkEnumFirstDefault
lib.nixvim.defaultNullOpts.mkEnumFirstDefault
[
"smart"
"indent"
@ -22,7 +21,7 @@ lib.nixvim.plugins.mkVimPlugin {
The mode used to process buffer changes.
'';
force_balance = helpers.defaultNullOpts.mkBool false ''
force_balance = lib.nixvim.defaultNullOpts.mkBool false ''
In smart mode and indent mode, parinfer will sometimes leave unbalanced brackets around the
cursor and fix them when the cursor moves away.
When this option is set to `true`, the brackets will be fixed immediately (and fixed again

13
plugins/by-name/qmk/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
with lib;
@ -41,7 +40,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
};
variant =
helpers.defaultNullOpts.mkEnumFirstDefault
lib.nixvim.defaultNullOpts.mkEnumFirstDefault
[
"qmk"
"zmk"
@ -50,17 +49,17 @@ lib.nixvim.plugins.mkNeovimPlugin {
Chooses the expected hardware target.
'';
timeout = helpers.defaultNullOpts.mkUnsignedInt 5000 ''
timeout = lib.nixvim.defaultNullOpts.mkUnsignedInt 5000 ''
Duration of `vim.notify` timeout if using `nvim-notify`.
'';
auto_format_pattern = helpers.defaultNullOpts.mkStr "*keymap.c" ''
auto_format_pattern = lib.nixvim.defaultNullOpts.mkStr "*keymap.c" ''
The autocommand file pattern to use when applying `QMKFormat` on save.
'';
comment_preview = {
position =
helpers.defaultNullOpts.mkEnumFirstDefault
lib.nixvim.defaultNullOpts.mkEnumFirstDefault
[
"top"
"bottom"
@ -72,13 +71,13 @@ lib.nixvim.plugins.mkNeovimPlugin {
`variant=qmk`).
'';
keymap_overrides = helpers.defaultNullOpts.mkAttrsOf types.str { } ''
keymap_overrides = lib.nixvim.defaultNullOpts.mkAttrsOf types.str { } ''
A dictionary of key codes to text replacements, any provided value will be merged with the
existing dictionary, see [key_map.lua](https://github.com/codethread/qmk.nvim/blob/main/lua/qmk/config/key_map.lua) for details.
'';
symbols =
helpers.defaultNullOpts.mkAttrsOf types.str
lib.nixvim.defaultNullOpts.mkAttrsOf types.str
{
space = " ";
horz = "─";

13
plugins/by-name/refactoring/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
config,
...
}:
@ -31,7 +30,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
settingsOptions = with lib.types; {
prompt_func_return_type =
helpers.defaultNullOpts.mkAttrsOf bool
lib.nixvim.defaultNullOpts.mkAttrsOf bool
{
go = false;
java = false;
@ -60,7 +59,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
'';
prompt_func_param_type =
helpers.defaultNullOpts.mkAttrsOf bool
lib.nixvim.defaultNullOpts.mkAttrsOf bool
{
go = false;
java = false;
@ -87,7 +86,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
}
'';
printf_statements = helpers.defaultNullOpts.mkAttrsOf (listOf (maybeRaw str)) { } ''
printf_statements = lib.nixvim.defaultNullOpts.mkAttrsOf (listOf (maybeRaw str)) { } ''
In any custom printf statement, it is possible to optionally add a **max of one `%s` pattern**, which is where the debug path will go.
For an example custom printf statement, go to [this folder][folder], select your language, and click on `multiple-statements/printf.config`.
@ -106,7 +105,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
[folder]: https://github.com/ThePrimeagen/refactoring.nvim/blob/master/lua/refactoring/tests/debug/printf
'';
print_var_statements = helpers.defaultNullOpts.mkAttrsOf (listOf (maybeRaw str)) { } ''
print_var_statements = lib.nixvim.defaultNullOpts.mkAttrsOf (listOf (maybeRaw str)) { } ''
In any custom print var statement, it is possible to optionally add a **max of two `%s` patterns**, which is where the debug path and
the actual variable reference will go, respectively. To add a literal `"%s"` to the string, escape the sequence like this: `%%s`.
For an example custom print var statement, go to [this folder][folder], select your language, and view `multiple-statements/print_var.config`.
@ -126,7 +125,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
[folder]: https://github.com/ThePrimeagen/refactoring.nvim/blob/master/lua/refactoring/tests/debug/print_var
'';
extract_var_statements = helpers.defaultNullOpts.mkAttrsOf str { } ''
extract_var_statements = lib.nixvim.defaultNullOpts.mkAttrsOf str { } ''
When performing an `extract_var` refactor operation, you can custom how the new variable would be declared by setting configuration
like the below example.
@ -140,7 +139,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
```
'';
show_success_message = helpers.defaultNullOpts.mkBool false ''
show_success_message = lib.nixvim.defaultNullOpts.mkBool false ''
Shows a message with information about the refactor on success. Such as:
```

3
plugins/by-name/rustaceanvim/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
config,
...
}:
@ -21,7 +20,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
})
];
settingsOptions = import ./settings-options.nix { inherit lib helpers; };
settingsOptions = import ./settings-options.nix { inherit lib; };
settingsExample = {
server = {

74
plugins/by-name/rustaceanvim/settings-options.nix
View file

@ -1,4 +1,4 @@
{ lib, helpers }:
{ lib }:
with lib;
{
tools =
@ -13,7 +13,7 @@ with lib;
testExecutors = executors ++ [ "background" ];
executorSubmodule = types.submodule {
options = {
execute_command = helpers.mkNullOrLuaFn ''
execute_command = lib.nixvim.mkNullOrLuaFn ''
```lua
fun(cmd:string,args:string[],cwd:string|nil,opts?:RustaceanExecutorOpts)
@ -37,7 +37,7 @@ with lib;
in
{
executor =
helpers.defaultNullOpts.mkNullable (with types; either (enum executors) executorSubmodule)
lib.nixvim.defaultNullOpts.mkNullable (with types; either (enum executors) executorSubmodule)
"termopen"
''
The executor to use for runnables/debuggables.
@ -45,67 +45,67 @@ with lib;
'';
test_executor =
helpers.mkNullOrOption (with types; either (enum testExecutors) executorSubmodule)
lib.nixvim.mkNullOrOption (with types; either (enum testExecutors) executorSubmodule)
''
The executor to use for runnables that are tests/testables
Either a test executor alias or an attrs with the `execute_command` key.
'';
crate_test_executor =
helpers.mkNullOrOption (with types; either (enum testExecutors) executorSubmodule)
lib.nixvim.mkNullOrOption (with types; either (enum testExecutors) executorSubmodule)
''
The executor to use for runnables that are crate test suites (`--all-targets`).
Either a test executor alias or an attrs with the `execute_command` key.
'';
cargo_override = helpers.mkNullOrStr ''
cargo_override = lib.nixvim.mkNullOrStr ''
Set this to override the 'cargo' command for runnables, debuggables (etc., e.g. to `"cross"`).
If set, this takes precedence over `enable_nextest`.
'';
enable_nextest = helpers.defaultNullOpts.mkBool true ''
enable_nextest = lib.nixvim.defaultNullOpts.mkBool true ''
Whether to enable nextest.
If enabled, `cargo test` commands will be transformed to `cargo nextest run` commands.
Defaults to `true` if cargo-nextest is detected.
Ignored if `cargo_override` is set.
'';
enable_clippy = helpers.defaultNullOpts.mkBool true ''
enable_clippy = lib.nixvim.defaultNullOpts.mkBool true ''
Whether to enable clippy checks on save if a clippy installation is detected.
'';
on_initialized = helpers.mkNullOrLuaFn ''
on_initialized = lib.nixvim.mkNullOrLuaFn ''
`fun(health:RustAnalyzerInitializedStatus)`
Function that is invoked when the LSP server has finished initializing.
'';
reload_workspace_from_cargo_toml = helpers.defaultNullOpts.mkBool true ''
reload_workspace_from_cargo_toml = lib.nixvim.defaultNullOpts.mkBool true ''
Automatically call `RustReloadWorkspace` when writing to a `Cargo.toml` file.
'';
hover_actions = {
replace_builtin_hover = helpers.defaultNullOpts.mkBool true ''
replace_builtin_hover = lib.nixvim.defaultNullOpts.mkBool true ''
Whether to replace Neovim's built-in `vim.lsp.buf.hover` with hover actions.
'';
};
code_actions = {
group_icon = helpers.defaultNullOpts.mkStr " ▶" ''
group_icon = lib.nixvim.defaultNullOpts.mkStr " ▶" ''
Text appended to a group action.
'';
ui_select_fallback = helpers.defaultNullOpts.mkBool false ''
ui_select_fallback = lib.nixvim.defaultNullOpts.mkBool false ''
Whether to fall back to `vim.ui.select` if there are no grouped code actions.
'';
};
float_win_config = {
auto_focus = helpers.defaultNullOpts.mkBool false ''
auto_focus = lib.nixvim.defaultNullOpts.mkBool false ''
Whether the window gets automatically focused.
'';
open_split =
helpers.defaultNullOpts.mkEnumFirstDefault
lib.nixvim.defaultNullOpts.mkEnumFirstDefault
[
"horizontal"
"vertical"
@ -116,23 +116,23 @@ with lib;
};
crate_graph = {
backend = helpers.defaultNullOpts.mkStr "x11" ''
backend = lib.nixvim.defaultNullOpts.mkStr "x11" ''
Backend used for displaying the graph.
See: https://graphviz.org/docs/outputs
'';
output = helpers.mkNullOrStr ''
output = lib.nixvim.mkNullOrStr ''
Where to store the output.
No output if unset.
Relative path from `cwd`.
'';
full = helpers.defaultNullOpts.mkBool true ''
full = lib.nixvim.defaultNullOpts.mkBool true ''
`true` for all crates.io and external crates, false only the local crates.
'';
enabled_graphviz_backends =
helpers.defaultNullOpts.mkListOf types.str
lib.nixvim.defaultNullOpts.mkListOf types.str
[
"bmp"
"cgimage"
@ -193,20 +193,20 @@ with lib;
Override the enabled graphviz backends list, used for input validation and autocompletion.
'';
pipe = helpers.mkNullOrStr ''
pipe = lib.nixvim.mkNullOrStr ''
Override the pipe symbol in the shell command.
Useful if using a shell that is not supported by this plugin.
'';
};
open_url = helpers.defaultNullOpts.mkLuaFn "require('rustaceanvim.os').open_url" ''
open_url = lib.nixvim.defaultNullOpts.mkLuaFn "require('rustaceanvim.os').open_url" ''
If set, overrides how to open URLs.
`fun(url:string):nil`
'';
};
server = {
auto_attach = helpers.mkNullOrStrLuaFnOr types.bool ''
auto_attach = lib.nixvim.mkNullOrStrLuaFnOr types.bool ''
Whether to automatically attach the LSP client.
Defaults to `true` if the `rust-analyzer` executable is found.
@ -230,9 +230,9 @@ with lib;
```
'';
on_attach = helpers.defaultNullOpts.mkLuaFn null "Function to call when rustaceanvim attaches to a buffer.";
on_attach = lib.nixvim.defaultNullOpts.mkLuaFn null "Function to call when rustaceanvim attaches to a buffer.";
cmd = helpers.mkNullOrStrLuaFnOr (with types; listOf str) ''
cmd = lib.nixvim.mkNullOrStrLuaFnOr (with types; listOf str) ''
Command and arguments for starting rust-analyzer.
This can also be the definition of a function:
@ -247,7 +247,7 @@ with lib;
'';
default_settings =
helpers.mkNullOrStrLuaFnOr
lib.nixvim.mkNullOrStrLuaFnOr
(types.submodule {
options.rust-analyzer = import ../../lsp/language-servers/rust-analyzer-config.nix lib;
freeformType = with types; attrsOf anything;
@ -268,23 +268,23 @@ with lib;
```
'';
standalone = helpers.defaultNullOpts.mkBool true ''
standalone = lib.nixvim.defaultNullOpts.mkBool true ''
Standalone file support (enabled by default).
Disabling it may improve rust-analyzer's startup time.
'';
logfile = helpers.defaultNullOpts.mkStr (lib.nixvim.literalLua "vim.fn.tempname() .. '-rust-analyzer.log'") ''
logfile = lib.nixvim.defaultNullOpts.mkStr (lib.nixvim.literalLua "vim.fn.tempname() .. '-rust-analyzer.log'") ''
The path to the rust-analyzer log file.
'';
load_vscode_settings = helpers.defaultNullOpts.mkBool false ''
load_vscode_settings = lib.nixvim.defaultNullOpts.mkBool false ''
Whether to search (upward from the buffer) for rust-analyzer settings in `.vscode/settings` json.
If found, loaded settings will override configured options.
'';
};
dap = {
autoload_configurations = helpers.defaultNullOpts.mkBool true ''
autoload_configurations = lib.nixvim.defaultNullOpts.mkBool true ''
Whether to autoload nvim-dap configurations when rust-analyzer has attached.
'';
@ -302,31 +302,31 @@ with lib;
description = "The type for the debug adapter.";
};
name = helpers.mkNullOrStr "The name of this adapter.";
name = lib.nixvim.mkNullOrStr "The name of this adapter.";
# Executable
command = helpers.defaultNullOpts.mkStr "lldb-vscode" ''
command = lib.nixvim.defaultNullOpts.mkStr "lldb-vscode" ''
The command to run for this adapter.
'';
args = helpers.mkNullOrStr "Its arguments.";
args = lib.nixvim.mkNullOrStr "Its arguments.";
# Server
host = helpers.mkNullOrStr "The host to connect to.";
host = lib.nixvim.mkNullOrStr "The host to connect to.";
port = helpers.mkNullOrStr "The port to connect to.";
port = lib.nixvim.mkNullOrStr "The port to connect to.";
executable = {
command = helpers.mkNullOrStr "The command for the executable.";
command = lib.nixvim.mkNullOrStr "The command for the executable.";
args = helpers.mkNullOrOption (with lib.types; maybeRaw (listOf str)) ''
args = lib.nixvim.mkNullOrOption (with lib.types; maybeRaw (listOf str)) ''
Its arguments.
'';
};
};
};
in
helpers.mkNullOrStrLuaFnOr (with types; either (enum [ false ]) dapConfig) ''
lib.nixvim.mkNullOrStrLuaFnOr (with types; either (enum [ false ]) dapConfig) ''
Defaults to creating the `rt_lldb` adapter, which is a `DapServerConfig` if `codelldb`
is detected, and a `DapExecutableConfig` if `lldb` is detected.
Set to `false` to disable.

3
plugins/by-name/sandwich/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
with lib;
@ -32,7 +31,7 @@ lib.nixvim.plugins.mkVimPlugin {
maintainers = [ maintainers.GaetanLepage ];
settingsOptions = {
no_default_key_mappings = helpers.defaultNullOpts.mkFlagInt 0 ''
no_default_key_mappings = lib.nixvim.defaultNullOpts.mkFlagInt 0 ''
Whether to disable the default mappings.
'';
};

17
plugins/by-name/schemastore/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
config,
...
}:
@ -22,10 +21,10 @@ lib.nixvim.plugins.mkVimPlugin {
description = "The name of the schema.";
};
description = helpers.mkNullOrStr "A description for this schema.";
description = lib.nixvim.mkNullOrStr "A description for this schema.";
fileMatch =
helpers.mkNullOrOption (with lib.types; maybeRaw (either str (listOf (maybeRaw str))))
lib.nixvim.mkNullOrOption (with lib.types; maybeRaw (either str (listOf (maybeRaw str))))
''
Which filename to match against for this schema.
'';
@ -38,7 +37,7 @@ lib.nixvim.plugins.mkVimPlugin {
};
schemaOpts = {
select = helpers.defaultNullOpts.mkListOf types.str [ ] ''
select = lib.nixvim.defaultNullOpts.mkListOf types.str [ ] ''
A list of strings representing the names of schemas to select.
If this option is not present, all schemas are returned.
If it is present, only the selected schemas are returned.
@ -47,21 +46,21 @@ lib.nixvim.plugins.mkVimPlugin {
See the [schema catalog](https://github.com/SchemaStore/schemastore/blob/master/src/api/json/catalog.json).
'';
ignore = helpers.defaultNullOpts.mkListOf types.str [ ] ''
ignore = lib.nixvim.defaultNullOpts.mkListOf types.str [ ] ''
A list of strings representing the names of schemas to ignore.
`select` and `ignore` are mutually exclusive.
See the [schema catalog](https://github.com/SchemaStore/schemastore/blob/master/src/api/json/catalog.json).
'';
replace = helpers.defaultNullOpts.mkAttrsOf schemaEntry { } ''
replace = lib.nixvim.defaultNullOpts.mkAttrsOf schemaEntry { } ''
An attrs of elements representing schemas to replace with a custom schema.
The string key is the name of the schema to replace, the table value is the schema definition.
If a schema with the given name isn't found, the custom schema will not be returned.
'';
extra = helpers.defaultNullOpts.mkListOf schemaEntry [ ] ''
extra = lib.nixvim.defaultNullOpts.mkListOf schemaEntry [ ] ''
Additional schemas to include.
'';
};
@ -75,7 +74,7 @@ lib.nixvim.plugins.mkVimPlugin {
description = "Whether to enable the json schemas in jsonls.";
};
settings = helpers.mkSettingsOption {
settings = lib.nixvim.mkSettingsOption {
options = schemaOpts;
description = "Options supplied to the `require('schemastore').json.schemas` function.";
example = {
@ -114,7 +113,7 @@ lib.nixvim.plugins.mkVimPlugin {
description = "Whether to enable the yaml schemas in yamlls.";
};
settings = helpers.mkSettingsOption {
settings = lib.nixvim.mkSettingsOption {
options = schemaOpts;
description = "Options supplied to the `require('schemastore').yaml.schemas` function.";
};

5
plugins/by-name/sleuth/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
lib.nixvim.plugins.mkVimPlugin {
@ -12,7 +11,7 @@ lib.nixvim.plugins.mkVimPlugin {
maintainers = [ lib.maintainers.GaetanLepage ];
settingsOptions = {
heuristics = helpers.defaultNullOpts.mkFlagInt 1 ''
heuristics = lib.nixvim.defaultNullOpts.mkFlagInt 1 ''
Whether to enable/disable heuristics by default.
You can also disable heuristics for individual filetypes:
@ -24,7 +23,7 @@ lib.nixvim.plugins.mkVimPlugin {
```
'';
no_filetype_indent_on = helpers.defaultNullOpts.mkFlagInt 0 ''
no_filetype_indent_on = lib.nixvim.defaultNullOpts.mkFlagInt 0 ''
Sleuth forces `|:filetype-indent-on|` by default, which enables file-type specific indenting
algorithms and is highly recommended.
'';

45
plugins/by-name/sniprun/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
with lib;
@ -15,19 +14,19 @@ lib.nixvim.plugins.mkNeovimPlugin {
# https://michaelb.github.io/sniprun/sources/README.html#configuration
settingsOptions = {
selected_interpreters = helpers.defaultNullOpts.mkListOf types.str [ ] ''
selected_interpreters = lib.nixvim.defaultNullOpts.mkListOf types.str [ ] ''
Use those instead of the default for the current filetype.
'';
repl_enable = helpers.defaultNullOpts.mkListOf types.str [ ] ''
repl_enable = lib.nixvim.defaultNullOpts.mkListOf types.str [ ] ''
Enable REPL-like behavior for the given interpreters.
'';
repl_disable = helpers.defaultNullOpts.mkListOf types.str [ ] ''
repl_disable = lib.nixvim.defaultNullOpts.mkListOf types.str [ ] ''
Disable REPL-like behavior for the given interpreters.
'';
interpreter_options = helpers.defaultNullOpts.mkAttrsOf' {
interpreter_options = lib.nixvim.defaultNullOpts.mkAttrsOf' {
type = types.anything;
pluginDefault = { };
description = ''
@ -51,7 +50,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
'';
};
display = helpers.defaultNullOpts.mkListOf' {
display = lib.nixvim.defaultNullOpts.mkListOf' {
type = types.str;
pluginDefault = [
"Classic"
@ -77,43 +76,43 @@ lib.nixvim.plugins.mkNeovimPlugin {
'';
};
live_display = helpers.defaultNullOpts.mkListOf types.str [
live_display = lib.nixvim.defaultNullOpts.mkListOf types.str [
"VirtualTextOk"
] "Display modes used in `live_mode`.";
display_options = {
terminal_scrollback = helpers.defaultNullOpts.mkUnsignedInt (lib.nixvim.literalLua "vim.o.scrollback") ''
terminal_scrollback = lib.nixvim.defaultNullOpts.mkUnsignedInt (lib.nixvim.literalLua "vim.o.scrollback") ''
Change terminal display scrollback lines.
'';
terminal_line_number = helpers.defaultNullOpts.mkBool false ''
terminal_line_number = lib.nixvim.defaultNullOpts.mkBool false ''
Whether show line number in terminal window.
'';
terminal_signcolumn = helpers.defaultNullOpts.mkBool false ''
terminal_signcolumn = lib.nixvim.defaultNullOpts.mkBool false ''
Whether show signcolumn in terminal window.
'';
terminal_position = helpers.defaultNullOpts.mkEnumFirstDefault [
terminal_position = lib.nixvim.defaultNullOpts.mkEnumFirstDefault [
"vertical"
"horizontal"
] "Terminal split position.";
terminal_width = helpers.defaultNullOpts.mkUnsignedInt 45 ''
terminal_width = lib.nixvim.defaultNullOpts.mkUnsignedInt 45 ''
Change the terminal display option width (if vertical).
'';
terminal_height = helpers.defaultNullOpts.mkUnsignedInt 20 ''
terminal_height = lib.nixvim.defaultNullOpts.mkUnsignedInt 20 ''
Change the terminal display option height (if horizontal).
'';
notification_timeout = helpers.defaultNullOpts.mkUnsignedInt 5 ''
notification_timeout = lib.nixvim.defaultNullOpts.mkUnsignedInt 5 ''
Timeout for nvim_notify output.
'';
};
show_no_output =
helpers.defaultNullOpts.mkListOf types.str
lib.nixvim.defaultNullOpts.mkListOf types.str
[
"Classic"
"TempFloatingWindow"
@ -135,13 +134,13 @@ lib.nixvim.plugins.mkNeovimPlugin {
ctermfg ? "",
}:
{
bg = helpers.defaultNullOpts.mkStr fg "Background color";
fg = helpers.defaultNullOpts.mkStr bg "Foreground color";
ctermbg = helpers.defaultNullOpts.mkStr ctermbg "Foreground color";
ctermfg = helpers.defaultNullOpts.mkStr ctermfg "Foreground color";
bg = lib.nixvim.defaultNullOpts.mkStr fg "Background color";
fg = lib.nixvim.defaultNullOpts.mkStr bg "Foreground color";
ctermbg = lib.nixvim.defaultNullOpts.mkStr ctermbg "Foreground color";
ctermfg = lib.nixvim.defaultNullOpts.mkStr ctermfg "Foreground color";
};
in
helpers.defaultNullOpts.mkNullable' {
lib.nixvim.defaultNullOpts.mkNullable' {
description = ''
Customize highlight groups (setting this overrides colorscheme)
any parameters of `nvim_set_hl()` can be passed as-is.
@ -173,18 +172,18 @@ lib.nixvim.plugins.mkNeovimPlugin {
};
};
live_mode_toggle = helpers.defaultNullOpts.mkStr "off" ''
live_mode_toggle = lib.nixvim.defaultNullOpts.mkStr "off" ''
Live mode toggle, see [Usage - Running] for more info.
[Usage - Running]: https://michaelb.github.io/sniprun/sources/README.html#running
'';
inline_messages = helpers.defaultNullOpts.mkBool false ''
inline_messages = lib.nixvim.defaultNullOpts.mkBool false ''
Boolean toggle for a one-line way to display messages
to workaround sniprun not being able to display anything.
'';
borders = helpers.defaultNullOpts.mkEnum [
borders = lib.nixvim.defaultNullOpts.mkEnum [
"none"
"single"
"double"

23
plugins/by-name/specs/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
with lib;
@ -12,50 +11,50 @@ lib.nixvim.plugins.mkNeovimPlugin {
maintainers = [ maintainers.GaetanLepage ];
settingsOptions = {
show_jumps = helpers.defaultNullOpts.mkBool true ''
show_jumps = lib.nixvim.defaultNullOpts.mkBool true ''
Whether to show an animation each time the cursor jumps.
'';
min_jump = helpers.defaultNullOpts.mkUnsignedInt 30 ''
min_jump = lib.nixvim.defaultNullOpts.mkUnsignedInt 30 ''
Minimum jump distance to trigger the animation.
'';
popup = {
delay_ms = helpers.defaultNullOpts.mkUnsignedInt 10 ''
delay_ms = lib.nixvim.defaultNullOpts.mkUnsignedInt 10 ''
Delay before popup displays.
'';
inc_ms = helpers.defaultNullOpts.mkUnsignedInt 5 ''
inc_ms = lib.nixvim.defaultNullOpts.mkUnsignedInt 5 ''
Time increments used for fade/resize effects.
'';
blend = helpers.defaultNullOpts.mkUnsignedInt 10 ''
blend = lib.nixvim.defaultNullOpts.mkUnsignedInt 10 ''
Starting blend, between 0 (opaque) and 100 (transparent), see `:h winblend`.
'';
width = helpers.defaultNullOpts.mkUnsignedInt 20 ''
width = lib.nixvim.defaultNullOpts.mkUnsignedInt 20 ''
Width of the popup.
'';
winhl = helpers.defaultNullOpts.mkStr "PMenu" ''
winhl = lib.nixvim.defaultNullOpts.mkStr "PMenu" ''
The name of the window highlight group of the popup.
'';
fader = helpers.defaultNullOpts.mkLuaFn "require('specs').exp_fader" ''
fader = lib.nixvim.defaultNullOpts.mkLuaFn "require('specs').exp_fader" ''
The fader function to use.
'';
resizer = helpers.defaultNullOpts.mkLuaFn "require('specs').shrink_resizer" ''
resizer = lib.nixvim.defaultNullOpts.mkLuaFn "require('specs').shrink_resizer" ''
The resizer function to use.
'';
};
ignore_filetypes = helpers.defaultNullOpts.mkAttrsOf types.bool { } ''
ignore_filetypes = lib.nixvim.defaultNullOpts.mkAttrsOf types.bool { } ''
An attrs where keys are filetypes and values are a boolean stating whether animation should be
enabled or not for this filetype.
'';
ignore_buftypes = helpers.defaultNullOpts.mkAttrsOf types.bool { nofile = true; } ''
ignore_buftypes = lib.nixvim.defaultNullOpts.mkAttrsOf types.bool { nofile = true; } ''
An attrs where keys are buftypes and values are a boolean stating whether animation should be
enabled or not for this buftype.
'';

45
plugins/by-name/spectre/default.nix
View file

@ -1,7 +1,6 @@
{
lib,
config,
helpers,
...
}:
with lib;
@ -50,7 +49,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
let
mkEngineOption =
type:
helpers.mkNullOrOption
lib.nixvim.mkNullOrOption
(
with types;
attrsOf (submodule {
@ -61,11 +60,11 @@ lib.nixvim.plugins.mkNeovimPlugin {
description = "Executable to run.";
};
args = helpers.defaultNullOpts.mkListOf types.str [ ] ''
args = lib.nixvim.defaultNullOpts.mkListOf types.str [ ] ''
List of arguments to provide to the engine.
'';
options = helpers.defaultNullOpts.mkAttrsOf (types.submodule {
options = lib.nixvim.defaultNullOpts.mkAttrsOf (types.submodule {
options = {
value = mkOption {
type = types.str;
@ -79,7 +78,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
description = "The option icon.";
};
desc = helpers.mkNullOrStr ''
desc = lib.nixvim.mkNullOrStr ''
The description for this option.
'';
};
@ -94,31 +93,31 @@ lib.nixvim.plugins.mkNeovimPlugin {
'';
in
{
color_devicons = helpers.defaultNullOpts.mkBool true ''
color_devicons = lib.nixvim.defaultNullOpts.mkBool true ''
Whether to enable color devicons.
'';
open_cmd = helpers.defaultNullOpts.mkStr "vnew" ''
open_cmd = lib.nixvim.defaultNullOpts.mkStr "vnew" ''
The open command.
'';
live_update = helpers.defaultNullOpts.mkBool false ''
live_update = lib.nixvim.defaultNullOpts.mkBool false ''
Auto execute search again when you write to any file in vim.
'';
lnum_for_results = helpers.defaultNullOpts.mkBool false ''
lnum_for_results = lib.nixvim.defaultNullOpts.mkBool false ''
Show line number for search/replace results.
'';
line_sep_start = helpers.defaultNullOpts.mkStr "┌──────────────────────────────────────────────────────" "Start of the line separator";
line_sep_start = lib.nixvim.defaultNullOpts.mkStr "┌──────────────────────────────────────────────────────" "Start of the line separator";
result_padding = helpers.defaultNullOpts.mkStr "│ " ''
result_padding = lib.nixvim.defaultNullOpts.mkStr "│ " ''
Result padding string.
'';
line_sep = helpers.defaultNullOpts.mkStr "└──────────────────────────────────────────────────────" "Line separator.";
line_sep = lib.nixvim.defaultNullOpts.mkStr "└──────────────────────────────────────────────────────" "Line separator.";
highlight = helpers.defaultNullOpts.mkAttrsOf types.str {
highlight = lib.nixvim.defaultNullOpts.mkAttrsOf types.str {
headers = "SpectreHeader";
ui = "SpectreBody";
filename = "SpectreFile";
@ -129,7 +128,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
} "Highlight groups.";
mapping =
helpers.mkNullOrOption
lib.nixvim.mkNullOrOption
(
with types;
attrsOf (submodule {
@ -145,7 +144,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
example = "<cmd>lua require('spectre').tab()<cr>";
};
desc = helpers.mkNullOrStr ''
desc = lib.nixvim.mkNullOrStr ''
Description for this mapping.
'';
};
@ -163,39 +162,39 @@ lib.nixvim.plugins.mkNeovimPlugin {
default = {
find = {
cmd = helpers.defaultNullOpts.mkStr "rg" ''
cmd = lib.nixvim.defaultNullOpts.mkStr "rg" ''
Which find engine to use. Pick one from the `find_engine` list.
'';
options = helpers.defaultNullOpts.mkListOf types.str [ "ignore-case" ] ''
options = lib.nixvim.defaultNullOpts.mkListOf types.str [ "ignore-case" ] ''
Options to use for this engine.
'';
};
replace = {
cmd = helpers.defaultNullOpts.mkStr "rg" ''
cmd = lib.nixvim.defaultNullOpts.mkStr "rg" ''
Which find engine to use. Pick one from the `replace_engine` list.
'';
options = helpers.defaultNullOpts.mkListOf types.str [ ] ''
options = lib.nixvim.defaultNullOpts.mkListOf types.str [ ] ''
Options to use for this engine.
'';
};
};
replace_vim_cmd = helpers.defaultNullOpts.mkStr "cdo" ''
replace_vim_cmd = lib.nixvim.defaultNullOpts.mkStr "cdo" ''
The replace command to use within vim.
'';
is_open_target_win = helpers.defaultNullOpts.mkBool true ''
is_open_target_win = lib.nixvim.defaultNullOpts.mkBool true ''
Open file on opener window.
'';
is_insert_mode = helpers.defaultNullOpts.mkBool false ''
is_insert_mode = lib.nixvim.defaultNullOpts.mkBool false ''
Start open panel in insert mode.
'';
is_block_ui_break = helpers.defaultNullOpts.mkBool false ''
is_block_ui_break = lib.nixvim.defaultNullOpts.mkBool false ''
Mapping backspace and enter key to avoid ui break.
'';
};

3
plugins/by-name/startify/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
with lib;
@ -13,7 +12,7 @@ mkVimPlugin {
maintainers = [ maintainers.GaetanLepage ];
settingsOptions = import ./settings-options.nix { inherit lib helpers; };
settingsOptions = import ./settings-options.nix { inherit lib; };
# TODO
settingsExample = {

66
plugins/by-name/startify/settings-options.nix
View file

@ -1,7 +1,7 @@
{ lib, helpers }:
{ lib }:
with lib;
{
session_dir = helpers.defaultNullOpts.mkStr "~/.vim/session" ''
session_dir = lib.nixvim.defaultNullOpts.mkStr "~/.vim/session" ''
The directory to save/load sessions to/from.
'';
@ -18,12 +18,12 @@ with lib;
example = "files";
};
header = helpers.mkNullOrOption (with lib.types; listOf (maybeRaw str)) ''
header = lib.nixvim.mkNullOrOption (with lib.types; listOf (maybeRaw str)) ''
The 'header' is a list of strings, whereas each string will be put on its own
line in the header.
'';
indices = helpers.mkNullOrOption (with lib.types; listOf (maybeRaw str)) ''
indices = lib.nixvim.mkNullOrOption (with lib.types; listOf (maybeRaw str)) ''
The 'indices' is a list of strings, which act as indices for the current list.
Opposed to the global `custom_indices`, this is limited to the current list.
'';
@ -64,7 +64,7 @@ with lib;
};
bookmarks =
helpers.defaultNullOpts.mkListOf
lib.nixvim.defaultNullOpts.mkListOf
(
with lib.types;
oneOf [
@ -81,7 +81,7 @@ with lib;
'';
commands =
helpers.defaultNullOpts.mkListOf
lib.nixvim.defaultNullOpts.mkListOf
(
with types;
oneOf [
@ -107,16 +107,16 @@ with lib;
```
'';
files_number = helpers.defaultNullOpts.mkUnsignedInt 10 ''
files_number = lib.nixvim.defaultNullOpts.mkUnsignedInt 10 ''
The number of files to list.
'';
update_oldfiles = helpers.defaultNullOpts.mkBool false ''
update_oldfiles = lib.nixvim.defaultNullOpts.mkBool false ''
Usually `|v:oldfiles|` only gets updated when Vim exits.
Using this option updates it on-the-fly, so that `:Startify` is always up-to-date.
'';
session_autoload = helpers.defaultNullOpts.mkBool false ''
session_autoload = lib.nixvim.defaultNullOpts.mkBool false ''
If this option is enabled and you start Vim in a directory that contains a `Session.vim`,
that session will be loaded automatically.
Otherwise it will be shown as the top entry in the Startify buffer.
@ -131,19 +131,19 @@ with lib;
NOTE: This option is affected by `session_delete_buffers`.
'';
session_before_save = helpers.defaultNullOpts.mkListOf types.str [ ] ''
session_before_save = lib.nixvim.defaultNullOpts.mkListOf types.str [ ] ''
This is a list of commands to be executed before saving a session.
Example: `["silent! tabdo NERDTreeClose"]`
'';
session_persistence = helpers.defaultNullOpts.mkBool false ''
session_persistence = lib.nixvim.defaultNullOpts.mkBool false ''
Automatically update sessions in two cases:
- Before leaving Vim
- Before loading a new session via `:SLoad`
'';
session_delete_buffers = helpers.defaultNullOpts.mkBool true ''
session_delete_buffers = lib.nixvim.defaultNullOpts.mkBool true ''
Delete all buffers when loading or closing a session:
- When using `|startify-:SLoad|`.
- When using `|startify-:SClose|`.
@ -153,7 +153,7 @@ with lib;
NOTE: Buffers with unsaved changes are silently ignored.
'';
change_to_dir = helpers.defaultNullOpts.mkBool true ''
change_to_dir = lib.nixvim.defaultNullOpts.mkBool true ''
When opening a file or bookmark, change to its directory.
You want to disable this, if you're using `|'autochdir'|` as well.
@ -162,14 +162,14 @@ with lib;
introduced.
'';
change_to_vcs_root = helpers.defaultNullOpts.mkBool false ''
change_to_vcs_root = lib.nixvim.defaultNullOpts.mkBool false ''
When opening a file or bookmark, seek and change to the root directory of the VCS (if there is
one).
At the moment only git, hg, bzr and svn are supported.
'';
change_cmd = helpers.defaultNullOpts.mkStr "lcd" ''
change_cmd = lib.nixvim.defaultNullOpts.mkStr "lcd" ''
The default command for switching directories.
Valid values:
@ -180,7 +180,7 @@ with lib;
Affects `change_to_dir` and `change_to_vcs_root`.
'';
skiplist = helpers.defaultNullOpts.mkListOf types.str [ ] ''
skiplist = lib.nixvim.defaultNullOpts.mkListOf types.str [ ] ''
A list of Vim regular expressions that is used to filter recently used files.
See `|pattern.txt|` for what patterns can be used.
@ -210,7 +210,7 @@ with lib;
```
'';
fortune_use_unicode = helpers.defaultNullOpts.mkBool false ''
fortune_use_unicode = lib.nixvim.defaultNullOpts.mkBool false ''
By default, the fortune header uses ASCII characters, because they work for everyone.
If you set this option to `true` and your 'encoding' is "utf-8", Unicode box-drawing characters
will be used instead.
@ -222,22 +222,22 @@ with lib;
For more information: http://unicode.org/reports/tr11
'';
padding_left = helpers.defaultNullOpts.mkUnsignedInt 3 ''
padding_left = lib.nixvim.defaultNullOpts.mkUnsignedInt 3 ''
The number of spaces used for left padding.
'';
skiplist_server = helpers.defaultNullOpts.mkListOf (with lib.types; maybeRaw str) [ ] ''
skiplist_server = lib.nixvim.defaultNullOpts.mkListOf (with lib.types; maybeRaw str) [ ] ''
Do not create the startify buffer, if this is a Vim server instance with a name contained in
this list.
Example: `["GVIM"]`
'';
enable_special = helpers.defaultNullOpts.mkBool true ''
enable_special = lib.nixvim.defaultNullOpts.mkBool true ''
Show `<empty buffer>` and `<quit>`.
'';
enable_unsafe = helpers.defaultNullOpts.mkBool false ''
enable_unsafe = lib.nixvim.defaultNullOpts.mkBool false ''
Enable the option only in case you think Vim starts too slowly (because of `:Startify`) or if
you often edit files on remote filesystems.
@ -254,7 +254,7 @@ with lib;
- don't filter through the bookmark list
'';
session_remove_lines = helpers.defaultNullOpts.mkListOf types.str [ ] ''
session_remove_lines = lib.nixvim.defaultNullOpts.mkListOf types.str [ ] ''
Lines matching any of the patterns in this list, will be removed from the session file.
Example:
@ -271,7 +271,7 @@ with lib;
probably get problems when trying to load it.
'';
session_savevars = helpers.defaultNullOpts.mkListOf types.str [ ] ''
session_savevars = lib.nixvim.defaultNullOpts.mkListOf types.str [ ] ''
Include a list of variables in here which you would like Startify to save into the session file
in addition to what Vim normally saves into the session file.
@ -285,7 +285,7 @@ with lib;
```
'';
session_savecmds = helpers.defaultNullOpts.mkListOf types.str [ ] ''
session_savecmds = lib.nixvim.defaultNullOpts.mkListOf types.str [ ] ''
Include a list of cmdline commands which Vim will run upon loading the session.
Example:
@ -296,17 +296,17 @@ with lib;
```
'';
session_number = helpers.defaultNullOpts.mkUnsignedInt 999 ''
session_number = lib.nixvim.defaultNullOpts.mkUnsignedInt 999 ''
The maximum number of sessions to display.
Makes the most sense together with `session_sort`.
'';
session_sort = helpers.defaultNullOpts.mkBool false ''
session_sort = lib.nixvim.defaultNullOpts.mkBool false ''
Sort sessions by modification time (when the session files were written) rather than
alphabetically.
'';
custom_indices = helpers.defaultNullOpts.mkListOf' {
custom_indices = lib.nixvim.defaultNullOpts.mkListOf' {
type = types.str;
pluginDefault = [ ];
description = ''
@ -324,7 +324,7 @@ with lib;
];
};
custom_header = helpers.defaultNullOpts.mkListOf' {
custom_header = lib.nixvim.defaultNullOpts.mkListOf' {
type = types.str;
description = ''
Define your own header.
@ -343,7 +343,7 @@ with lib;
];
};
custom_header_quotes = helpers.defaultNullOpts.mkListOf' {
custom_header_quotes = lib.nixvim.defaultNullOpts.mkListOf' {
type = with types; listOf str;
pluginDefault = [ ];
description = ''
@ -363,19 +363,19 @@ with lib;
];
};
custom_footer = helpers.defaultNullOpts.mkListOf' {
custom_footer = lib.nixvim.defaultNullOpts.mkListOf' {
type = types.str;
description = ''
Same as the custom header, but shown at the bottom of the startify buffer.
'';
};
disable_at_vimenter = helpers.defaultNullOpts.mkBool false ''
disable_at_vimenter = lib.nixvim.defaultNullOpts.mkBool false ''
Don't run Startify at Vim startup.
You can still call it anytime via `:Startify`.
'';
relative_path = helpers.defaultNullOpts.mkBool false ''
relative_path = lib.nixvim.defaultNullOpts.mkBool false ''
If the file is in or below the current working directory, use a relative path.
Otherwise an absolute path is used.
The latter prevents hard to grasp entries like `../../../../../foo`.
@ -383,7 +383,7 @@ with lib;
NOTE: This only applies to the "files" list, since the "dir" list is relative by nature.
'';
use_env = helpers.defaultNullOpts.mkBool false ''
use_env = lib.nixvim.defaultNullOpts.mkBool false ''
Show environment variables in path, if their name is shorter than their value.
See `|startify-colors|` for highlighting them.

37
plugins/by-name/statuscol/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
with lib;
@ -12,26 +11,26 @@ lib.nixvim.plugins.mkNeovimPlugin {
maintainers = [ maintainers.GaetanLepage ];
settingsOptions = {
setopt = helpers.defaultNullOpts.mkBool true ''
setopt = lib.nixvim.defaultNullOpts.mkBool true ''
Whether to set the `statuscolumn` option, may be set to false for those who want to use the
click handlers in their own `statuscolumn`: `_G.Sc[SFL]a()`.
Although I recommend just using the segments field below to build your statuscolumn to
benefit from the performance optimizations in this plugin.
'';
thousands = helpers.defaultNullOpts.mkNullable (with types; either str (enum [ false ])) false ''
thousands = lib.nixvim.defaultNullOpts.mkNullable (with types; either str (enum [ false ])) false ''
`false` or line number thousands separator string ("." / ",").
'';
relculright = helpers.defaultNullOpts.mkBool false ''
relculright = lib.nixvim.defaultNullOpts.mkBool false ''
Whether to right-align the cursor line number with `relativenumber` set.
'';
ft_ignore = helpers.defaultNullOpts.mkListOf types.str null ''
ft_ignore = lib.nixvim.defaultNullOpts.mkListOf types.str null ''
Lua table with 'filetype' values for which `statuscolumn` will be unset.
'';
bt_ignore = helpers.defaultNullOpts.mkListOf types.str null ''
bt_ignore = lib.nixvim.defaultNullOpts.mkListOf types.str null ''
Lua table with 'buftype' values for which `statuscolumn` will be unset.
'';
@ -47,56 +46,56 @@ lib.nixvim.plugins.mkNeovimPlugin {
example = [ "%C" ];
};
click = helpers.mkNullOrStr ''
click = lib.nixvim.mkNullOrStr ''
`%@` click function label, applies to each text element.
'';
hl = helpers.mkNullOrStr ''
hl = lib.nixvim.mkNullOrStr ''
`%#` highlight group label, applies to each text element.
'';
condition = helpers.mkNullOrOption (
condition = lib.nixvim.mkNullOrOption (
with lib.types; listOf (either bool rawLua)
) "Table of booleans or functions returning a boolean.";
sign = {
name = helpers.defaultNullOpts.mkListOf types.str [ ] ''
name = lib.nixvim.defaultNullOpts.mkListOf types.str [ ] ''
List of lua patterns to match the sign name against.
'';
text = helpers.defaultNullOpts.mkListOf types.str [ ] ''
text = lib.nixvim.defaultNullOpts.mkListOf types.str [ ] ''
List of lua patterns to match the extmark sign text against.
'';
namespace = helpers.defaultNullOpts.mkListOf types.str [ ] ''
namespace = lib.nixvim.defaultNullOpts.mkListOf types.str [ ] ''
List of lua patterns to match the extmark sign namespace against.
'';
maxwidth = helpers.defaultNullOpts.mkUnsignedInt 1 ''
maxwidth = lib.nixvim.defaultNullOpts.mkUnsignedInt 1 ''
Maximum number of signs that will be displayed in this segment
'';
colwidth = helpers.defaultNullOpts.mkUnsignedInt 2 ''
colwidth = lib.nixvim.defaultNullOpts.mkUnsignedInt 2 ''
Maximum number of display cells per sign in this segment.
'';
auto = helpers.defaultNullOpts.mkBool false ''
auto = lib.nixvim.defaultNullOpts.mkBool false ''
When true, the segment will not be drawn if no signs matching the pattern are
currently placed in the buffer.
'';
fillchar = helpers.defaultNullOpts.mkStr " " ''
fillchar = lib.nixvim.defaultNullOpts.mkStr " " ''
Character used to fill a segment with less signs than maxwidth.
'';
fillcharhl = helpers.mkNullOrStr ''
fillcharhl = lib.nixvim.mkNullOrStr ''
Highlight group used for fillchar (SignColumn/CursorLineSign if omitted).
'';
};
};
};
in
helpers.defaultNullOpts.mkListOf segmentType [
lib.nixvim.defaultNullOpts.mkListOf segmentType [
{
text = [ "%C" ];
click = "v:lua.ScFa";
@ -118,7 +117,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
}
] "The statuscolumn can be customized through the `segments` option.";
clickmod = helpers.defaultNullOpts.mkStr "c" ''
clickmod = lib.nixvim.defaultNullOpts.mkStr "c" ''
Modifier used for certain actions in the builtin clickhandlers:
`a` for Alt, `c` for Ctrl and `m` for Meta.
'';

17
plugins/by-name/tmux-navigator/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
with lib;
@ -97,7 +96,7 @@ lib.nixvim.plugins.mkVimPlugin {
settingsOptions = {
save_on_switch =
helpers.mkNullOrOption
lib.nixvim.mkNullOrOption
(types.enum [
1
2
@ -110,14 +109,14 @@ lib.nixvim.plugins.mkVimPlugin {
2: `:wall` (write all buffers)
'';
disable_when_zoomed = helpers.defaultNullOpts.mkFlagInt 0 ''
disable_when_zoomed = lib.nixvim.defaultNullOpts.mkFlagInt 0 ''
By default, if you zoom the tmux pane running vim and then attempt to navigate "past" the edge of the vim session, tmux will unzoom the pane.
This is the default tmux behavior, but may be confusing if you've become accustomed to navigation "wrapping" around the sides due to this plugin.
This option disables the unzooming behavior, keeping all navigation within vim until the tmux pane is explicitly unzoomed.
'';
preserve_zoom = helpers.defaultNullOpts.mkFlagInt 0 ''
preserve_zoom = lib.nixvim.defaultNullOpts.mkFlagInt 0 ''
As noted in `disable_when_zoomed`, navigating from a vim pane to another tmux pane normally causes the window to be unzoomed.
Some users may prefer the behavior of tmux's `-Z` option to `select-pane`, which keeps the window zoomed if it was zoomed.
@ -126,7 +125,7 @@ lib.nixvim.plugins.mkVimPlugin {
Naturally, if `disable_when_zoomed` is enabled, this option will have no effect.
'';
no_wrap = helpers.defaultNullOpts.mkFlagInt 0 ''
no_wrap = lib.nixvim.defaultNullOpts.mkFlagInt 0 ''
By default, if you try to move past the edge of the screen, tmux/vim will "wrap" around to the opposite side.
This option disables "wrapping" in vim, but tmux will need to be configured separately.
@ -149,7 +148,7 @@ lib.nixvim.plugins.mkVimPlugin {
```
'';
no_mappings = helpers.defaultNullOpts.mkFlagInt 0 ''
no_mappings = lib.nixvim.defaultNullOpts.mkFlagInt 0 ''
By default `<C-h>`, `<C-j>`, `<C-k>`, `<C-l>`, & `<C-\\>`
are mapped to navigating left, down, up, right, & previous, respectively.
@ -196,7 +195,7 @@ lib.nixvim.plugins.mkVimPlugin {
];
default = [ ];
type = types.listOf (
helpers.keymaps.mkMapOptionSubmodule {
lib.nixvim.keymaps.mkMapOptionSubmodule {
action = {
description = "The direction in which to navigate.";
type = types.enum [
@ -211,13 +210,13 @@ lib.nixvim.plugins.mkVimPlugin {
lua = true;
}
);
apply = map helpers.keymaps.removeDeprecatedMapAttrs;
apply = map lib.nixvim.keymaps.removeDeprecatedMapAttrs;
};
};
extraConfig = cfg: {
keymaps = map (
mapping: mapping // { action = "<cmd>TmuxNavigate${helpers.upperFirstChar mapping.action}<cr>"; }
mapping: mapping // { action = "<cmd>TmuxNavigate${lib.nixvim.upperFirstChar mapping.action}<cr>"; }
) cfg.keymaps;
};
}

7
plugins/by-name/transparent/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
with lib;
@ -13,7 +12,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
settingsOptions = {
groups =
helpers.defaultNullOpts.mkListOf types.str
lib.nixvim.defaultNullOpts.mkListOf types.str
[
"Normal"
"NormalNC"
@ -45,11 +44,11 @@ lib.nixvim.plugins.mkNeovimPlugin {
The list of transparent groups.
'';
extra_groups = helpers.defaultNullOpts.mkListOf types.str [ ] ''
extra_groups = lib.nixvim.defaultNullOpts.mkListOf types.str [ ] ''
Additional groups that should be cleared.
'';
exclude_groups = helpers.defaultNullOpts.mkListOf types.str [ ] ''
exclude_groups = lib.nixvim.defaultNullOpts.mkListOf types.str [ ] ''
Groups that you don't want to clear.
'';
};

25
plugins/by-name/treesitter/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
config,
options,
...
@ -208,13 +207,13 @@ lib.nixvim.plugins.mkNeovimPlugin {
}) buildGrammarDeps;
settingsOptions = {
auto_install = helpers.defaultNullOpts.mkBool false ''
auto_install = lib.nixvim.defaultNullOpts.mkBool false ''
Whether to automatically install missing parsers when entering a buffer.
'';
highlight = {
additional_vim_regex_highlighting =
helpers.defaultNullOpts.mkNullableWithRaw (with lib.types; either bool (listOf (maybeRaw str)))
lib.nixvim.defaultNullOpts.mkNullableWithRaw (with lib.types; either bool (listOf (maybeRaw str)))
false
''
Setting this to true will run `syntax` and tree-sitter at the same time. \
@ -225,22 +224,22 @@ lib.nixvim.plugins.mkNeovimPlugin {
Instead of true, it can also be a list of languages.
'';
enable = helpers.defaultNullOpts.mkBool false ''
enable = lib.nixvim.defaultNullOpts.mkBool false ''
Whether to enable treesitter highlighting.
'';
disable = helpers.defaultNullOpts.mkStrLuaFnOr (with lib.types; listOf (maybeRaw str)) null ''
disable = lib.nixvim.defaultNullOpts.mkStrLuaFnOr (with lib.types; listOf (maybeRaw str)) null ''
Can either be a list of the names of parsers you wish to disable or
a lua function that returns a boolean indicating the parser should be disabled.
'';
custom_captures = helpers.defaultNullOpts.mkAttrsOf types.str { } ''
custom_captures = lib.nixvim.defaultNullOpts.mkAttrsOf types.str { } ''
Custom capture group highlighting.
'';
};
incremental_selection = {
enable = helpers.defaultNullOpts.mkBool false ''
enable = lib.nixvim.defaultNullOpts.mkBool false ''
Incremental selection based on the named nodes from the grammar.
'';
@ -248,7 +247,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
let
mkKeymap =
default:
helpers.defaultNullOpts.mkNullableWithRaw (
lib.nixvim.defaultNullOpts.mkNullableWithRaw (
with types; either str bool
) default "Key shortcut or false to unset.";
in
@ -261,12 +260,12 @@ lib.nixvim.plugins.mkNeovimPlugin {
};
indent = {
enable = helpers.defaultNullOpts.mkBool false ''
enable = lib.nixvim.defaultNullOpts.mkBool false ''
Whether to enable treesitter indentation.
'';
};
ensure_installed = helpers.defaultNullOpts.mkNullable' {
ensure_installed = lib.nixvim.defaultNullOpts.mkNullable' {
type =
with lib.types;
oneOf [
@ -280,11 +279,11 @@ lib.nixvim.plugins.mkNeovimPlugin {
'';
};
ignore_install = helpers.defaultNullOpts.mkListOf types.str [ ] ''
ignore_install = lib.nixvim.defaultNullOpts.mkListOf types.str [ ] ''
List of parsers to ignore installing. Used when `ensure_installed` is set to `"all"`.
'';
parser_install_dir = helpers.mkNullOrOption' {
parser_install_dir = lib.nixvim.mkNullOrOption' {
type = with lib.types; maybeRaw str;
# Backport the default from nvim-treesitter 1.0
# The current default doesn't work on nix, as it is readonly
@ -298,7 +297,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
'';
};
sync_install = helpers.defaultNullOpts.mkBool false ''
sync_install = lib.nixvim.defaultNullOpts.mkBool false ''
Install parsers synchronously (only applied to `ensure_installed`).
'';
};

11
plugins/by-name/ts-autotag/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
config,
...
}:
@ -23,15 +22,15 @@ lib.nixvim.plugins.mkNeovimPlugin {
settingsOptions =
let
opts = {
enable_close = helpers.defaultNullOpts.mkBool true ''
enable_close = lib.nixvim.defaultNullOpts.mkBool true ''
Whether or not to auto close tags.
'';
enable_rename = helpers.defaultNullOpts.mkBool true ''
enable_rename = lib.nixvim.defaultNullOpts.mkBool true ''
Whether or not to auto rename paired tags.
'';
enable_close_on_slash = helpers.defaultNullOpts.mkBool true ''
enable_close_on_slash = lib.nixvim.defaultNullOpts.mkBool true ''
Whether or not to auto close tags when a `/` is inserted.
'';
};
@ -39,7 +38,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
{
inherit opts;
aliases = helpers.defaultNullOpts.mkAttrsOf types.str {
aliases = lib.nixvim.defaultNullOpts.mkAttrsOf types.str {
"astro" = "html";
"eruby" = "html";
"vue" = "html";
@ -59,7 +58,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
"rust" = "rust";
} "Filetype aliases.";
per_filetype = helpers.defaultNullOpts.mkAttrsOf (types.submodule {
per_filetype = lib.nixvim.defaultNullOpts.mkAttrsOf (types.submodule {
freeformType = with types; attrsOf anything;
options = opts;
}) { } "Per filetype config overrides.";

17
plugins/by-name/twilight/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
config,
...
}:
@ -14,12 +13,12 @@ lib.nixvim.plugins.mkNeovimPlugin {
settingsOptions = {
dimming = {
alpha = helpers.defaultNullOpts.mkProportion 0.25 ''
alpha = lib.nixvim.defaultNullOpts.mkProportion 0.25 ''
Amount of dimming.
'';
color =
helpers.defaultNullOpts.mkListOf types.str
lib.nixvim.defaultNullOpts.mkListOf types.str
[
"Normal"
"#ffffff"
@ -28,33 +27,33 @@ lib.nixvim.plugins.mkNeovimPlugin {
Highlight groups / colors to use.
'';
term_bg = helpers.defaultNullOpts.mkStr "#000000" ''
term_bg = lib.nixvim.defaultNullOpts.mkStr "#000000" ''
If `guibg=NONE`, this will be used to calculate text color.
'';
inactive = helpers.defaultNullOpts.mkBool false ''
inactive = lib.nixvim.defaultNullOpts.mkBool false ''
When true, other windows will be fully dimmed (unless they contain the same buffer).
'';
};
context = helpers.defaultNullOpts.mkUnsignedInt 10 ''
context = lib.nixvim.defaultNullOpts.mkUnsignedInt 10 ''
Amount of lines we will try to show around the current line.
'';
treesitter = helpers.defaultNullOpts.mkBool true ''
treesitter = lib.nixvim.defaultNullOpts.mkBool true ''
Use `treesitter` when available for the filetype.
`treesitter` is used to automatically expand the visible text, but you can further control
the types of nodes that should always be fully expanded.
'';
expand = helpers.defaultNullOpts.mkListOf types.str [
expand = lib.nixvim.defaultNullOpts.mkListOf types.str [
"function"
"method"
"table"
"if_statement"
] "For treesitter, we will always try to expand to the top-most ancestor with these types.";
exclude = helpers.defaultNullOpts.mkListOf types.str [ ] ''
exclude = lib.nixvim.defaultNullOpts.mkListOf types.str [ ] ''
Exclude these filetypes.
'';
};

13
plugins/by-name/typst-vim/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
with lib;
@ -29,14 +28,14 @@ lib.nixvim.plugins.mkVimPlugin {
default = false;
};
watch = helpers.mkNullOrOption types.str "Keymap to preview the document and recompile on change.";
watch = lib.nixvim.mkNullOrOption types.str "Keymap to preview the document and recompile on change.";
};
};
extraConfig = cfg: {
keymaps =
with cfg.keymaps;
helpers.keymaps.mkKeymaps
lib.nixvim.keymaps.mkKeymaps
{
mode = "n";
options.silent = silent;
@ -51,21 +50,21 @@ lib.nixvim.plugins.mkVimPlugin {
};
settingsOptions = {
cmd = helpers.defaultNullOpts.mkStr "typst" ''
cmd = lib.nixvim.defaultNullOpts.mkStr "typst" ''
Specifies the location of the Typst executable.
'';
pdf_viewer = helpers.mkNullOrOption types.str ''
pdf_viewer = lib.nixvim.mkNullOrOption types.str ''
Specifies pdf viewer that `typst watch --open` will use.
'';
conceal_math = helpers.defaultNullOpts.mkFlagInt 0 ''
conceal_math = lib.nixvim.defaultNullOpts.mkFlagInt 0 ''
Enable concealment for math symbols in math mode (i.e. replaces symbols with their actual
unicode character).
Warning: this can affect performance
'';
auto_close_toc = helpers.defaultNullOpts.mkFlagInt 0 ''
auto_close_toc = lib.nixvim.defaultNullOpts.mkFlagInt 0 ''
Specifies whether TOC will be automatically closed after using it.
'';
};

17
plugins/by-name/vim-slime/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
with lib;
@ -13,7 +12,7 @@ mkVimPlugin {
maintainers = [ maintainers.GaetanLepage ];
settingsOptions = {
target = helpers.defaultNullOpts.mkEnum [
target = lib.nixvim.defaultNullOpts.mkEnum [
"dtach"
"kitty"
"neovim"
@ -26,25 +25,25 @@ mkVimPlugin {
"zellij"
] "screen" "Which backend vim-slime should use.";
vimterminal_cmd = helpers.mkNullOrStr ''
vimterminal_cmd = lib.nixvim.mkNullOrStr ''
The vim terminal command to execute.
'';
no_mappings = helpers.defaultNullOpts.mkFlagInt 0 ''
no_mappings = lib.nixvim.defaultNullOpts.mkFlagInt 0 ''
Whether to disable the default mappings.
'';
paste_file = helpers.defaultNullOpts.mkStr "$HOME/.slime_paste" ''
paste_file = lib.nixvim.defaultNullOpts.mkStr "$HOME/.slime_paste" ''
Required to transfer data from vim to GNU screen or tmux.
Setting this explicitly can work around some occasional portability issues.
whimrepl does not require or support this setting.
'';
preserve_curpos = helpers.defaultNullOpts.mkFlagInt 1 ''
preserve_curpos = lib.nixvim.defaultNullOpts.mkFlagInt 1 ''
Whether to preserve cursor position when sending a line or paragraph.
'';
default_config = helpers.mkNullOrOption (with lib.types; attrsOf (either str rawLua)) ''
default_config = lib.nixvim.mkNullOrOption (with lib.types; attrsOf (either str rawLua)) ''
Pre-filled prompt answer.
Examples:
@ -64,11 +63,11 @@ mkVimPlugin {
```
'';
dont_ask_default = helpers.defaultNullOpts.mkFlagInt 0 ''
dont_ask_default = lib.nixvim.defaultNullOpts.mkFlagInt 0 ''
Whether to bypass the prompt and use the specified default configuration options.
'';
bracketed_paste = helpers.defaultNullOpts.mkFlagInt 0 ''
bracketed_paste = lib.nixvim.defaultNullOpts.mkFlagInt 0 ''
Sometimes REPL are too smart for their own good, e.g. autocompleting a bracket that should
not be autocompleted when pasting code from a file.
In this case it can be useful to rely on bracketed-paste

21
plugins/by-name/windsurf-vim/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
pkgs,
...
}:
@ -53,7 +52,7 @@ lib.nixvim.plugins.mkVimPlugin {
};
filetypes =
helpers.defaultNullOpts.mkAttrsOf types.bool
lib.nixvim.defaultNullOpts.mkAttrsOf types.bool
{
help = false;
gitcommit = false;
@ -65,30 +64,30 @@ lib.nixvim.plugins.mkVimPlugin {
This can be used to opt out of completions for certain filetypes.
'';
manual = helpers.defaultNullOpts.mkBool false ''
manual = lib.nixvim.defaultNullOpts.mkBool false ''
If true, codeium completions will never automatically trigger.
'';
no_map_tab = helpers.defaultNullOpts.mkBool false ''
no_map_tab = lib.nixvim.defaultNullOpts.mkBool false ''
Whether to disable the `<Tab>` keybinding.
'';
idle_delay = helpers.defaultNullOpts.mkPositiveInt 75 ''
idle_delay = lib.nixvim.defaultNullOpts.mkPositiveInt 75 ''
Delay in milliseconds before autocompletions are shown (limited by language server to a
minimum of 75).
'';
render = helpers.defaultNullOpts.mkBool true ''
render = lib.nixvim.defaultNullOpts.mkBool true ''
A global boolean flag that controls whether codeium renders are enabled or disabled.
'';
tab_fallback = helpers.mkNullOrOption types.str ''
tab_fallback = lib.nixvim.mkNullOrOption types.str ''
The fallback key when there is no suggestion display in `codeium#Accept()`.
Default: "\<C-N>" when a popup menu is visible, else "\t".
'';
disable_bindings = helpers.defaultNullOpts.mkBool false ''
disable_bindings = lib.nixvim.defaultNullOpts.mkBool false ''
Whether to disable default keybindings.
'';
};
@ -96,7 +95,7 @@ lib.nixvim.plugins.mkVimPlugin {
extraOptions = {
keymaps = mapAttrs (
optionName: v:
helpers.defaultNullOpts.mkStr v.default ''
lib.nixvim.defaultNullOpts.mkStr v.default ''
${v.description}
Command: `${v.command}`
''
@ -116,7 +115,7 @@ lib.nixvim.plugins.mkVimPlugin {
let
inherit (keymapsDefinitions.${optionName}) command;
in
helpers.mkRaw "function() ${command} end";
lib.nixvim.mkRaw "function() ${command} end";
};
keymapsList = flatten (mapAttrsToList processKeymap cfg.keymaps);
@ -129,6 +128,6 @@ lib.nixvim.plugins.mkVimPlugin {
};
};
in
helpers.keymaps.mkKeymaps defaults keymapsList;
lib.nixvim.keymaps.mkKeymaps defaults keymapsList;
};
}

41
plugins/by-name/yanky/default.nix
View file

@ -1,7 +1,6 @@
{
lib,
config,
helpers,
...
}:
with lib;
@ -23,12 +22,12 @@ lib.nixvim.plugins.mkNeovimPlugin {
'';
settingsOptions = {
ring = {
history_length = helpers.defaultNullOpts.mkUnsignedInt 100 ''
history_length = lib.nixvim.defaultNullOpts.mkUnsignedInt 100 ''
Define the number of yanked items that will be saved and used for ring.
'';
storage =
helpers.defaultNullOpts.mkEnumFirstDefault
lib.nixvim.defaultNullOpts.mkEnumFirstDefault
[
"shada"
"sqlite"
@ -52,11 +51,11 @@ lib.nixvim.plugins.mkNeovimPlugin {
You can change the storage path using `ring.storagePath` option.
'';
storage_path = helpers.defaultNullOpts.mkStr {
storage_path = lib.nixvim.defaultNullOpts.mkStr {
__raw = "vim.fn.stdpath('data') .. '/databases/yanky.db'";
} "Only for sqlite storage.";
sync_with_numbered_registers = helpers.defaultNullOpts.mkBool true ''
sync_with_numbered_registers = lib.nixvim.defaultNullOpts.mkBool true ''
History can also be synchronized with numbered registers.
Every time the yank history changes the numbered registers 1 - 9 will be updated to sync
with the first 9 entries in the yank history.
@ -64,7 +63,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
'';
cancel_event =
helpers.defaultNullOpts.mkEnumFirstDefault
lib.nixvim.defaultNullOpts.mkEnumFirstDefault
[
"update"
"move"
@ -75,12 +74,12 @@ lib.nixvim.plugins.mkNeovimPlugin {
cursor or content changed.
'';
ignore_registers = helpers.defaultNullOpts.mkListOf types.str [ "_" ] ''
ignore_registers = lib.nixvim.defaultNullOpts.mkListOf types.str [ "_" ] ''
Define registers to be ignored.
By default the black hole register is ignored.
'';
update_register_on_cycle = helpers.defaultNullOpts.mkBool false ''
update_register_on_cycle = lib.nixvim.defaultNullOpts.mkBool false ''
If true, when you cycle through the ring, the contents of the register used to update will
be updated with the last content cycled.
'';
@ -88,7 +87,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
picker = {
select = {
action = helpers.defaultNullOpts.mkLuaFn' {
action = lib.nixvim.defaultNullOpts.mkLuaFn' {
pluginDefault = null;
description = ''
This define the action that should be done when selecting an item in the
@ -101,25 +100,25 @@ lib.nixvim.plugins.mkNeovimPlugin {
};
telescope = {
use_default_mappings = helpers.defaultNullOpts.mkBool true ''
use_default_mappings = lib.nixvim.defaultNullOpts.mkBool true ''
This define or overrides the mappings available in Telescope.
If you set this option to `true`, mappings will be merged with default mappings.
'';
mappings = helpers.defaultNullOpts.mkAttrsOf' {
mappings = lib.nixvim.defaultNullOpts.mkAttrsOf' {
type = with lib.types; either strLuaFn (attrsOf strLuaFn);
apply =
mappings:
helpers.ifNonNull' mappings (
lib.nixvim.ifNonNull' mappings (
mapAttrs (
_: v:
if isString v then
# `mappings.default` is a lua function
helpers.mkRaw v
lib.nixvim.mkRaw v
else
# `mappings.<mode>` is an attrs of lua function
mapAttrs (_: helpers.mkRaw) v
mapAttrs (_: lib.nixvim.mkRaw) v
) mappings
);
pluginDefault = null;
@ -149,7 +148,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
};
system_clipboard = {
sync_with_ring = helpers.defaultNullOpts.mkBool true ''
sync_with_ring = lib.nixvim.defaultNullOpts.mkBool true ''
Yanky can automatically adds to ring history yanks that occurs outside of Neovim.
This works regardless to your `&clipboard` setting.
@ -166,35 +165,35 @@ lib.nixvim.plugins.mkNeovimPlugin {
Also note that the syncing happens when neovim gains focus.
'';
clipboard_register = helpers.defaultNullOpts.mkStr null ''
clipboard_register = lib.nixvim.defaultNullOpts.mkStr null ''
Choose the register that is synced with ring (from above).
If `&clipboard` is empty then `*` is used.
'';
};
highlight = {
on_put = helpers.defaultNullOpts.mkBool true ''
on_put = lib.nixvim.defaultNullOpts.mkBool true ''
Define if highlight put text feature is enabled.
'';
on_yank = helpers.defaultNullOpts.mkBool true ''
on_yank = lib.nixvim.defaultNullOpts.mkBool true ''
Define if highlight yanked text feature is enabled.
'';
timer = helpers.defaultNullOpts.mkUnsignedInt 500 ''
timer = lib.nixvim.defaultNullOpts.mkUnsignedInt 500 ''
Define the duration of highlight.
'';
};
preserve_cursor_position = {
enabled = helpers.defaultNullOpts.mkBool true ''
enabled = lib.nixvim.defaultNullOpts.mkBool true ''
Whether cursor position should be preserved on yank.
This works only if mappings has been defined.
'';
};
textobj = {
enabled = helpers.defaultNullOpts.mkBool true ''
enabled = lib.nixvim.defaultNullOpts.mkBool true ''
Yanky comes with a text object corresponding to last put text.
To use it, you have to enable it and set a keymap.
'';

9
plugins/by-name/zellij/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
lib.nixvim.plugins.mkNeovimPlugin {
@ -11,19 +10,19 @@ lib.nixvim.plugins.mkNeovimPlugin {
maintainers = [ lib.maintainers.hmajid2301 ];
settingsOptions = {
path = helpers.defaultNullOpts.mkStr "zellij" ''
path = lib.nixvim.defaultNullOpts.mkStr "zellij" ''
Path to the zellij binary.
'';
replaceVimWindowNavigationKeybinds = helpers.defaultNullOpts.mkBool false ''
replaceVimWindowNavigationKeybinds = lib.nixvim.defaultNullOpts.mkBool false ''
Will set keybinds like `<C-w>h` to left.
'';
vimTmuxNavigatorKeybinds = helpers.defaultNullOpts.mkBool false ''
vimTmuxNavigatorKeybinds = lib.nixvim.defaultNullOpts.mkBool false ''
Will set keybinds like `<C-h>` to left.
'';
debug = helpers.defaultNullOpts.mkBool false ''
debug = lib.nixvim.defaultNullOpts.mkBool false ''
Will log things to `/tmp/zellij.nvim`.
'';
};

15
plugins/by-name/zen-mode/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
...
}:
with lib;
@ -14,13 +13,13 @@ lib.nixvim.plugins.mkNeovimPlugin {
# Optionally, explicitly declare some options. You don't have to.
settingsOptions = {
window = {
backdrop = helpers.defaultNullOpts.mkProportion 0.95 ''
backdrop = lib.nixvim.defaultNullOpts.mkProportion 0.95 ''
Shade the backdrop of the Zen window.
Set to 1 to keep the same as Normal.
'';
width =
helpers.defaultNullOpts.mkNullable
lib.nixvim.defaultNullOpts.mkNullable
(
with lib.types;
oneOf [
@ -40,7 +39,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
'';
height =
helpers.defaultNullOpts.mkNullable
lib.nixvim.defaultNullOpts.mkNullable
(
with lib.types;
oneOf [
@ -59,7 +58,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
- a function that returns the width or the height
'';
options = helpers.defaultNullOpts.mkAttrsOf types.anything { } ''
options = lib.nixvim.defaultNullOpts.mkAttrsOf types.anything { } ''
By default, no options are changed for the Zen window.
You can set any `vim.wo` option here.
@ -79,7 +78,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
};
plugins = {
options =
helpers.defaultNullOpts.mkAttrsOf types.anything
lib.nixvim.defaultNullOpts.mkAttrsOf types.anything
{
enabled = true;
ruler = false;
@ -91,11 +90,11 @@ lib.nixvim.plugins.mkNeovimPlugin {
'';
};
on_open = helpers.defaultNullOpts.mkLuaFn "function(win) end" ''
on_open = lib.nixvim.defaultNullOpts.mkLuaFn "function(win) end" ''
Callback where you can add custom code when the Zen window opens.
'';
on_close = helpers.defaultNullOpts.mkLuaFn "function(win) end" ''
on_close = lib.nixvim.defaultNullOpts.mkLuaFn "function(win) end" ''
Callback where you can add custom code when the Zen window closes.
'';
};

15
plugins/by-name/zk/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
config,
...
}:
@ -24,7 +23,7 @@ lib.nixvim.plugins.mkNeovimPlugin {
settingsOptions = {
picker =
helpers.defaultNullOpts.mkEnumFirstDefault
lib.nixvim.defaultNullOpts.mkEnumFirstDefault
[
"select"
"fzf"
@ -39,20 +38,20 @@ lib.nixvim.plugins.mkNeovimPlugin {
lsp = {
config =
helpers.defaultNullOpts.mkNullable
lib.nixvim.defaultNullOpts.mkNullable
(types.submodule {
freeformType = with types; attrsOf anything;
options = {
cmd = helpers.defaultNullOpts.mkListOf types.str [
cmd = lib.nixvim.defaultNullOpts.mkListOf types.str [
"zk"
"lsp"
] "Command to start the language server.";
name = helpers.defaultNullOpts.mkStr "zk" ''
name = lib.nixvim.defaultNullOpts.mkStr "zk" ''
The name for this server.
'';
on_attach = helpers.mkNullOrLuaFn ''
on_attach = lib.nixvim.mkNullOrLuaFn ''
Command to run when the client is attached.
'';
};
@ -69,11 +68,11 @@ lib.nixvim.plugins.mkNeovimPlugin {
'';
auto_attach = {
enabled = helpers.defaultNullOpts.mkBool true ''
enabled = lib.nixvim.defaultNullOpts.mkBool true ''
Automatically attach buffers in a zk notebook.
'';
filetypes = helpers.defaultNullOpts.mkListOf types.str [ "markdown" ] ''
filetypes = lib.nixvim.defaultNullOpts.mkListOf types.str [ "markdown" ] ''
Filetypes for which zk should automatically attach.
'';
};

27
plugins/lsp/language-servers/default.nix
View file

@ -1,6 +1,5 @@
{
lib,
helpers,
pkgs,
...
}:
@ -11,7 +10,7 @@ let
lspExtraArgs = {
dartls = {
settingsOptions = import ./dartls-settings.nix { inherit lib helpers; };
settingsOptions = import ./dartls-settings.nix { inherit lib; };
settings = cfg: { dart = cfg; };
};
gopls = {
@ -39,23 +38,23 @@ let
settings = cfg: { json = cfg; };
};
jsonnet_ls = {
settingsOptions = import ./jsonnet-ls-settings.nix { inherit lib helpers; };
settingsOptions = import ./jsonnet-ls-settings.nix { inherit lib; };
};
ltex = {
settingsOptions = import ./ltex-settings.nix { inherit lib helpers; };
settingsOptions = import ./ltex-settings.nix { inherit lib; };
settings = cfg: { ltex = cfg; };
};
lua_ls = {
settingsOptions = import ./lua-ls-settings.nix { inherit lib helpers; };
settingsOptions = import ./lua-ls-settings.nix { inherit lib; };
settings = cfg: { Lua = cfg; };
};
nil_ls = {
settingsOptions = import ./nil-ls-settings.nix { inherit lib helpers; };
settingsOptions = import ./nil-ls-settings.nix { inherit lib; };
settings = cfg: { nil = cfg; };
};
nixd = {
settings = cfg: { nixd = cfg; };
settingsOptions = import ./nixd-settings.nix { inherit lib helpers; };
settingsOptions = import ./nixd-settings.nix { inherit lib; };
extraConfig = cfg: {
extraPackages = optional (cfg.settings.formatting.command == [ "nixpkgs-fmt" ]) pkgs.nixpkgs-fmt;
};
@ -63,12 +62,12 @@ let
omnisharp = {
settings = cfg: { omnisharp = cfg; };
settingsOptions = {
enableEditorConfigSupport = helpers.defaultNullOpts.mkBool true ''
enableEditorConfigSupport = lib.nixvim.defaultNullOpts.mkBool true ''
Enables support for reading code style, naming convention and analyzer settings from
`.editorconfig`.
'';
enableMsBuildLoadProjectsOnDemand = helpers.defaultNullOpts.mkBool false ''
enableMsBuildLoadProjectsOnDemand = lib.nixvim.defaultNullOpts.mkBool false ''
If true, MSBuild project system will only load projects for files that were opened in the
editor.
This setting is useful for big C# codebases and allows for faster initialization of code
@ -77,7 +76,7 @@ let
incomplete reference lists for symbols.
'';
enableRoslynAnalyzers = helpers.defaultNullOpts.mkBool false ''
enableRoslynAnalyzers = lib.nixvim.defaultNullOpts.mkBool false ''
If true, MSBuild project system will only load projects for files that were opened in the
editor.
This setting is useful for big C# codebases and allows for faster initialization of code
@ -86,12 +85,12 @@ let
incomplete reference lists for symbols.
'';
organizeImportsOnFormat = helpers.defaultNullOpts.mkBool false ''
organizeImportsOnFormat = lib.nixvim.defaultNullOpts.mkBool false ''
Specifies whether 'using' directives should be grouped and sorted during document
formatting.
'';
enableImportCompletion = helpers.defaultNullOpts.mkBool false ''
enableImportCompletion = lib.nixvim.defaultNullOpts.mkBool false ''
Enables support for showing unimported types and unimported extension methods in
completion lists.
When committed, the appropriate using directive will be added at the top of the current
@ -100,12 +99,12 @@ let
for the first few completion sessions after opening a solution.
'';
sdkIncludePrereleases = helpers.defaultNullOpts.mkBool true ''
sdkIncludePrereleases = lib.nixvim.defaultNullOpts.mkBool true ''
Specifies whether to include preview versions of the .NET SDK when determining which
version to use for project loading.
'';
analyzeOpenDocumentsOnly = helpers.defaultNullOpts.mkBool true ''
analyzeOpenDocumentsOnly = lib.nixvim.defaultNullOpts.mkBool true ''
Only run analyzers against open files when 'enableRoslynAnalyzers' is true.
'';
};

6
tests/test-sources/modules/keymaps.nix
View file

@ -1,4 +1,4 @@
{ helpers, ... }:
{ lib, ... }:
{
example = {
keymaps = [
@ -19,7 +19,7 @@
mkKeymaps = {
keymaps =
helpers.keymaps.mkKeymaps
lib.nixvim.keymaps.mkKeymaps
{
mode = "x";
options.silent = true;
@ -60,7 +60,7 @@
mkKeymapsOnEvents = {
keymapsOnEvents = {
"InsertEnter" =
helpers.keymaps.mkKeymaps
lib.nixvim.keymaps.mkKeymaps
{
mode = "x";
options.silent = true;

6
tests/test-sources/modules/output.nix
View file

@ -79,7 +79,7 @@
};
files-default-empty =
{ config, helpers, ... }:
{ config, lib, ... }:
{
files = {
# lua type
@ -90,11 +90,11 @@
assertions = [
{
assertion = !helpers.hasContent config.files."test.lua".content;
assertion = !lib.nixvim.hasContent config.files."test.lua".content;
message = "Default content of test.lua file is expected to be empty.";
}
{
assertion = !helpers.hasContent config.files."test.vim".content;
assertion = !lib.nixvim.hasContent config.files."test.vim".content;
message = "Default content of test.vim file is expected to be empty.";
}
];

4
tests/test-sources/plugins/by-name/flash/default.nix
View file

@ -1,4 +1,4 @@
{ helpers, ... }:
{ lib, ... }:
{
empty = {
plugins.flash.enable = true;
@ -21,7 +21,7 @@
"cmp_menu"
"noice"
"flash_prompt"
(helpers.mkRaw ''
(lib.nixvim.mkRaw ''
function(win)
-- exclude non-focusable windows
return not vim.api.nvim_win_get_config(win).focusable