From dad19c12387c50b459cab6eeca2b452bc76ef4e0 Mon Sep 17 00:00:00 2001 From: Matt Sturgeon Date: Wed, 19 Nov 2025 11:39:41 +0000 Subject: [PATCH] treewide: remove internal use of `helpers` module arg --- modules/commands.nix | 31 +++-- modules/files.nix | 3 +- modules/filetype.nix | 11 +- modules/keymaps.nix | 20 ++-- modules/opts.nix | 9 +- modules/output.nix | 19 ++-- modules/top-level/output.nix | 5 +- plugins/by-name/arrow/default.nix | 68 ++++++----- plugins/by-name/better-escape/default.nix | 7 +- plugins/by-name/bufdelete/default.nix | 3 +- plugins/by-name/chatgpt/default.nix | 9 +- plugins/by-name/codesnap/default.nix | 32 +++--- plugins/by-name/comment/default.nix | 31 +++-- plugins/by-name/copilot-vim/default.nix | 5 +- plugins/by-name/dashboard/default.nix | 83 +++++++------- plugins/by-name/debugprint/default.nix | 15 ++- plugins/by-name/edgy/default.nix | 49 ++++---- plugins/by-name/flash/default.nix | 107 +++++++++--------- plugins/by-name/fzf-lua/default.nix | 11 +- plugins/by-name/git-conflict/default.nix | 15 ++- plugins/by-name/gitignore/default.nix | 5 +- plugins/by-name/godot/default.nix | 3 +- plugins/by-name/goyo/default.nix | 7 +- plugins/by-name/hydra/default.nix | 5 +- plugins/by-name/hydra/hydras-option.nix | 36 +++--- plugins/by-name/hydra/settings-options.nix | 38 +++---- plugins/by-name/improved-search/default.nix | 7 +- plugins/by-name/instant/default.nix | 25 ++-- plugins/by-name/julia-cell/default.nix | 9 +- plugins/by-name/lsp-signature/default.nix | 4 +- plugins/by-name/lspkind/default.nix | 3 +- plugins/by-name/ltex-extra/default.nix | 9 +- plugins/by-name/magma-nvim/default.nix | 15 ++- plugins/by-name/neoclip/default.nix | 49 ++++---- plugins/by-name/neoscroll/default.nix | 19 ++-- plugins/by-name/nvim-autopairs/default.nix | 59 +++++----- plugins/by-name/nvim-tree/default.nix | 3 +- plugins/by-name/otter/default.nix | 13 +-- plugins/by-name/parinfer-rust/default.nix | 5 +- plugins/by-name/qmk/default.nix | 13 +-- plugins/by-name/refactoring/default.nix | 13 +-- plugins/by-name/rustaceanvim/default.nix | 3 +- .../by-name/rustaceanvim/settings-options.nix | 74 ++++++------ plugins/by-name/sandwich/default.nix | 3 +- plugins/by-name/schemastore/default.nix | 17 ++- plugins/by-name/sleuth/default.nix | 5 +- plugins/by-name/sniprun/default.nix | 45 ++++---- plugins/by-name/specs/default.nix | 23 ++-- plugins/by-name/spectre/default.nix | 45 ++++---- plugins/by-name/startify/default.nix | 3 +- plugins/by-name/startify/settings-options.nix | 66 +++++------ plugins/by-name/statuscol/default.nix | 37 +++--- plugins/by-name/tmux-navigator/default.nix | 17 ++- plugins/by-name/transparent/default.nix | 7 +- plugins/by-name/treesitter/default.nix | 25 ++-- plugins/by-name/ts-autotag/default.nix | 11 +- plugins/by-name/twilight/default.nix | 17 ++- plugins/by-name/typst-vim/default.nix | 13 +-- plugins/by-name/vim-slime/default.nix | 17 ++- plugins/by-name/windsurf-vim/default.nix | 21 ++-- plugins/by-name/yanky/default.nix | 41 ++++--- plugins/by-name/zellij/default.nix | 9 +- plugins/by-name/zen-mode/default.nix | 15 ++- plugins/by-name/zk/default.nix | 15 ++- plugins/lsp/language-servers/default.nix | 27 +++-- tests/test-sources/modules/keymaps.nix | 6 +- tests/test-sources/modules/output.nix | 6 +- .../plugins/by-name/flash/default.nix | 4 +- 68 files changed, 687 insertions(+), 758 deletions(-) diff --git a/modules/commands.nix b/modules/commands.nix index b0fda39f..7b4878b4 100644 --- a/modules/commands.nix +++ b/modules/commands.nix @@ -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 {}) diff --git a/modules/files.nix b/modules/files.nix index 54d543f9..cc7b8c0b 100644 --- a/modules/files.nix +++ b/modules/files.nix @@ -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 = { diff --git a/modules/filetype.nix b/modules/filetype.nix index 943ae732..01a9249b 100644 --- a/modules/filetype.nix +++ b/modules/filetype.nix @@ -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. diff --git a/modules/keymaps.nix b/modules/keymaps.nix index 05e630ba..fe5b8d0d 100644 --- a/modules/keymaps.nix +++ b/modules/keymaps.nix @@ -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 = ""` or `action = helpers.mkRaw ""`. + e.g. `action.__raw = ""` or `action = lib.nixvim.mkRaw ""`. ${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 }) diff --git a/modules/opts.nix b/modules/opts.nix index 9aca2bef..f9481059 100644 --- a/modules/opts.nix +++ b/modules/opts.nix @@ -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: { diff --git a/modules/output.nix b/modules/output.nix index 172ff283..a06b8d31 100644 --- a/modules/output.nix +++ b/modules/output.nix @@ -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 ] diff --git a/modules/top-level/output.nix b/modules/top-level/output.nix index f1247b60..e41be416 100644 --- a/modules/top-level/output.nix +++ b/modules/top-level/output.nix @@ -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 ]; diff --git a/plugins/by-name/arrow/default.nix b/plugins/by-name/arrow/default.nix index 0ad66946..44e0992c 100644 --- a/plugins/by-name/arrow/default.nix +++ b/plugins/by-name/arrow/default.nix @@ -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 ''; }; diff --git a/plugins/by-name/better-escape/default.nix b/plugins/by-name/better-escape/default.nix index 86f11c31..7648d452 100644 --- a/plugins/by-name/better-escape/default.nix +++ b/plugins/by-name/better-escape/default.nix @@ -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 = { diff --git a/plugins/by-name/bufdelete/default.nix b/plugins/by-name/bufdelete/default.nix index 21438396..c56101c1 100644 --- a/plugins/by-name/bufdelete/default.nix +++ b/plugins/by-name/bufdelete/default.nix @@ -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. diff --git a/plugins/by-name/chatgpt/default.nix b/plugins/by-name/chatgpt/default.nix index 933e144d..eb84d1bd 100644 --- a/plugins/by-name/chatgpt/default.nix +++ b/plugins/by-name/chatgpt/default.nix @@ -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. ''; }; diff --git a/plugins/by-name/codesnap/default.nix b/plugins/by-name/codesnap/default.nix index de8f1d25..46cfb7a9 100644 --- a/plugins/by-name/codesnap/default.nix +++ b/plugins/by-name/codesnap/default.nix @@ -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. ''; }; diff --git a/plugins/by-name/comment/default.nix b/plugins/by-name/comment/default.nix index 296de125..fb2215ba 100644 --- a/plugins/by-name/comment/default.nix +++ b/plugins/by-name/comment/default.nix @@ -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. ''; }; diff --git a/plugins/by-name/copilot-vim/default.nix b/plugins/by-name/copilot-vim/default.nix index cba3d6a4..66612939 100644 --- a/plugins/by-name/copilot-vim/default.nix +++ b/plugins/by-name/copilot-vim/default.nix @@ -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. diff --git a/plugins/by-name/dashboard/default.nix b/plugins/by-name/dashboard/default.nix index 28fa7279..33d6a31b 100644 --- a/plugins/by-name/dashboard/default.nix +++ b/plugins/by-name/dashboard/default.nix @@ -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`, ``, ``, ``, `` ''; - 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. ''; }; diff --git a/plugins/by-name/debugprint/default.nix b/plugins/by-name/debugprint/default.nix index 59c6e6c1..bebdd660 100644 --- a/plugins/by-name/debugprint/default.nix +++ b/plugins/by-name/debugprint/default.nix @@ -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`. ''; diff --git a/plugins/by-name/edgy/default.nix b/plugins/by-name/edgy/default.nix index 915274c0..15c1f3a9 100644 --- a/plugins/by-name/edgy/default.nix +++ b/plugins/by-name/edgy/default.nix @@ -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. ''; }; diff --git a/plugins/by-name/flash/default.nix b/plugins/by-name/flash/default.nix index 98f38d2f..753320cb 100644 --- a/plugins/by-name/flash/default.nix +++ b/plugins/by-name/flash/default.nix @@ -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 `` ''; 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. ''; diff --git a/plugins/by-name/fzf-lua/default.nix b/plugins/by-name/fzf-lua/default.nix index 154b8234..7a6e0d29 100644 --- a/plugins/by-name/fzf-lua/default.nix +++ b/plugins/by-name/fzf-lua/default.nix @@ -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; }; }) ); diff --git a/plugins/by-name/git-conflict/default.nix b/plugins/by-name/git-conflict/default.nix index 88ad8390..94b84e0f 100644 --- a/plugins/by-name/git-conflict/default.nix +++ b/plugins/by-name/git-conflict/default.nix @@ -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` diff --git a/plugins/by-name/gitignore/default.nix b/plugins/by-name/gitignore/default.nix index cf01fc25..4eac56ae 100644 --- a/plugins/by-name/gitignore/default.nix +++ b/plugins/by-name/gitignore/default.nix @@ -1,6 +1,5 @@ { lib, - helpers, ... }: with lib; @@ -26,9 +25,9 @@ lib.nixvim.plugins.mkVimPlugin { example = "gi"; }; - mode = helpers.keymaps.mkModeOption "n"; + mode = lib.nixvim.keymaps.mkModeOption "n"; - options = helpers.keymaps.mapConfigOptions; + options = lib.nixvim.keymaps.mapConfigOptions; }; }) ); diff --git a/plugins/by-name/godot/default.nix b/plugins/by-name/godot/default.nix index 0681ddab..8f50c3c8 100644 --- a/plugins/by-name/godot/default.nix +++ b/plugins/by-name/godot/default.nix @@ -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. ''; }; diff --git a/plugins/by-name/goyo/default.nix b/plugins/by-name/goyo/default.nix index f14cf7ac..a225c387 100644 --- a/plugins/by-name/goyo/default.nix +++ b/plugins/by-name/goyo/default.nix @@ -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. ''; }; diff --git a/plugins/by-name/hydra/default.nix b/plugins/by-name/hydra/default.nix index 806e4390..82b9f4e5 100644 --- a/plugins/by-name/hydra/default.nix +++ b/plugins/by-name/hydra/default.nix @@ -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; diff --git a/plugins/by-name/hydra/hydras-option.nix b/plugins/by-name/hydra/hydras-option.nix index 008d3389..2bbaa0b4 100644 --- a/plugins/by-name/hydra/hydras-option.nix +++ b/plugins/by-name/hydra/hydras-option.nix @@ -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] diff --git a/plugins/by-name/hydra/settings-options.nix b/plugins/by-name/hydra/settings-options.nix index d4b6a2ea..20b99b94 100644 --- a/plugins/by-name/hydra/settings-options.nix +++ b/plugins/by-name/hydra/settings-options.nix @@ -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"; diff --git a/plugins/by-name/improved-search/default.nix b/plugins/by-name/improved-search/default.nix index c2ec9c44..110a352f 100644 --- a/plugins/by-name/improved-search/default.nix +++ b/plugins/by-name/improved-search/default.nix @@ -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; diff --git a/plugins/by-name/instant/default.nix b/plugins/by-name/instant/default.nix index b64251b8..bb6ead2f 100644 --- a/plugins/by-name/instant/default.nix +++ b/plugins/by-name/instant/default.nix @@ -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. ''; }; diff --git a/plugins/by-name/julia-cell/default.nix b/plugins/by-name/julia-cell/default.nix index 45627215..ea01c3b9 100644 --- a/plugins/by-name/julia-cell/default.nix +++ b/plugins/by-name/julia-cell/default.nix @@ -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: { diff --git a/plugins/by-name/lsp-signature/default.nix b/plugins/by-name/lsp-signature/default.nix index b2f99c24..112fbaf1 100644 --- a/plugins/by-name/lsp-signature/default.nix +++ b/plugins/by-name/lsp-signature/default.nix @@ -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 = '' diff --git a/plugins/by-name/lspkind/default.nix b/plugins/by-name/lspkind/default.nix index 8455f6e3..31300c2a 100644 --- a/plugins/by-name/lspkind/default.nix +++ b/plugins/by-name/lspkind/default.nix @@ -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)"; }; }; diff --git a/plugins/by-name/ltex-extra/default.nix b/plugins/by-name/ltex-extra/default.nix index 5ea93050..69d77083 100644 --- a/plugins/by-name/ltex-extra/default.nix +++ b/plugins/by-name/ltex-extra/default.nix @@ -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" diff --git a/plugins/by-name/magma-nvim/default.nix b/plugins/by-name/magma-nvim/default.nix index 6c005020..20c178d7 100644 --- a/plugins/by-name/magma-nvim/default.nix +++ b/plugins/by-name/magma-nvim/default.nix @@ -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. diff --git a/plugins/by-name/neoclip/default.nix b/plugins/by-name/neoclip/default.nix index 48048d2e..cc896d97 100644 --- a/plugins/by-name/neoclip/default.nix +++ b/plugins/by-name/neoclip/default.nix @@ -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 = ""; @@ -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"; diff --git a/plugins/by-name/neoscroll/default.nix b/plugins/by-name/neoscroll/default.nix index 11834732..c5a191f7 100644 --- a/plugins/by-name/neoscroll/default.nix +++ b/plugins/by-name/neoscroll/default.nix @@ -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 [ "" "" @@ -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. ''; }; diff --git a/plugins/by-name/nvim-autopairs/default.nix b/plugins/by-name/nvim-autopairs/default.nix index 9acac02d..b3904029 100644 --- a/plugins/by-name/nvim-autopairs/default.nix +++ b/plugins/by-name/nvim-autopairs/default.nix @@ -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 `` key to confirm the completion. ''; - map_bs = helpers.defaultNullOpts.mkBool true '' + map_bs = lib.nixvim.defaultNullOpts.mkBool true '' Map the `` key to delete the pair. ''; - map_c_h = helpers.defaultNullOpts.mkBool false '' + map_c_h = lib.nixvim.defaultNullOpts.mkBool false '' Map the `` key to delete a pair. ''; - map_c_w = helpers.defaultNullOpts.mkBool false '' + map_c_w = lib.nixvim.defaultNullOpts.mkBool false '' Map the `` key to delete a pair if possible. ''; fast_wrap = { - map = helpers.defaultNullOpts.mkStr "" '' + map = lib.nixvim.defaultNullOpts.mkStr "" '' 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`. ''; }; diff --git a/plugins/by-name/nvim-tree/default.nix b/plugins/by-name/nvim-tree/default.nix index 7debd20f..3401b3d3 100644 --- a/plugins/by-name/nvim-tree/default.nix +++ b/plugins/by-name/nvim-tree/default.nix @@ -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"; diff --git a/plugins/by-name/otter/default.nix b/plugins/by-name/otter/default.nix index 446e9fab..d459c78b 100644 --- a/plugins/by-name/otter/default.nix +++ b/plugins/by-name/otter/default.nix @@ -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 `.otter.` 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. ''; diff --git a/plugins/by-name/parinfer-rust/default.nix b/plugins/by-name/parinfer-rust/default.nix index 3855aad1..5504d1f3 100644 --- a/plugins/by-name/parinfer-rust/default.nix +++ b/plugins/by-name/parinfer-rust/default.nix @@ -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 diff --git a/plugins/by-name/qmk/default.nix b/plugins/by-name/qmk/default.nix index 3148c4d8..b66c997d 100644 --- a/plugins/by-name/qmk/default.nix +++ b/plugins/by-name/qmk/default.nix @@ -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 = "─"; diff --git a/plugins/by-name/refactoring/default.nix b/plugins/by-name/refactoring/default.nix index 10e2d1c6..458329f4 100644 --- a/plugins/by-name/refactoring/default.nix +++ b/plugins/by-name/refactoring/default.nix @@ -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: ``` diff --git a/plugins/by-name/rustaceanvim/default.nix b/plugins/by-name/rustaceanvim/default.nix index 2b52e0bc..39947c3e 100644 --- a/plugins/by-name/rustaceanvim/default.nix +++ b/plugins/by-name/rustaceanvim/default.nix @@ -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 = { diff --git a/plugins/by-name/rustaceanvim/settings-options.nix b/plugins/by-name/rustaceanvim/settings-options.nix index 7a27b7cc..83071586 100644 --- a/plugins/by-name/rustaceanvim/settings-options.nix +++ b/plugins/by-name/rustaceanvim/settings-options.nix @@ -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. diff --git a/plugins/by-name/sandwich/default.nix b/plugins/by-name/sandwich/default.nix index 4fa1b6ea..19d45f08 100644 --- a/plugins/by-name/sandwich/default.nix +++ b/plugins/by-name/sandwich/default.nix @@ -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. ''; }; diff --git a/plugins/by-name/schemastore/default.nix b/plugins/by-name/schemastore/default.nix index cf4a9115..b29a2b0a 100644 --- a/plugins/by-name/schemastore/default.nix +++ b/plugins/by-name/schemastore/default.nix @@ -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."; }; diff --git a/plugins/by-name/sleuth/default.nix b/plugins/by-name/sleuth/default.nix index bfb0ab47..803f9883 100644 --- a/plugins/by-name/sleuth/default.nix +++ b/plugins/by-name/sleuth/default.nix @@ -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. ''; diff --git a/plugins/by-name/sniprun/default.nix b/plugins/by-name/sniprun/default.nix index 1383c2d4..d03461a7 100644 --- a/plugins/by-name/sniprun/default.nix +++ b/plugins/by-name/sniprun/default.nix @@ -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" diff --git a/plugins/by-name/specs/default.nix b/plugins/by-name/specs/default.nix index fb89e847..59a8816f 100644 --- a/plugins/by-name/specs/default.nix +++ b/plugins/by-name/specs/default.nix @@ -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. ''; diff --git a/plugins/by-name/spectre/default.nix b/plugins/by-name/spectre/default.nix index f4de2ae3..2efc03d3 100644 --- a/plugins/by-name/spectre/default.nix +++ b/plugins/by-name/spectre/default.nix @@ -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 = "lua require('spectre').tab()"; }; - 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. ''; }; diff --git a/plugins/by-name/startify/default.nix b/plugins/by-name/startify/default.nix index ece5b516..b53a36ea 100644 --- a/plugins/by-name/startify/default.nix +++ b/plugins/by-name/startify/default.nix @@ -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 = { diff --git a/plugins/by-name/startify/settings-options.nix b/plugins/by-name/startify/settings-options.nix index bda501e3..14cd81ee 100644 --- a/plugins/by-name/startify/settings-options.nix +++ b/plugins/by-name/startify/settings-options.nix @@ -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 `` and ``. ''; - 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. diff --git a/plugins/by-name/statuscol/default.nix b/plugins/by-name/statuscol/default.nix index 9df8636f..37935bad 100644 --- a/plugins/by-name/statuscol/default.nix +++ b/plugins/by-name/statuscol/default.nix @@ -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. ''; diff --git a/plugins/by-name/tmux-navigator/default.nix b/plugins/by-name/tmux-navigator/default.nix index 1e0b98ed..56cf1eae 100644 --- a/plugins/by-name/tmux-navigator/default.nix +++ b/plugins/by-name/tmux-navigator/default.nix @@ -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 ``, ``, ``, ``, & `` 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 = "TmuxNavigate${helpers.upperFirstChar mapping.action}"; } + mapping: mapping // { action = "TmuxNavigate${lib.nixvim.upperFirstChar mapping.action}"; } ) cfg.keymaps; }; } diff --git a/plugins/by-name/transparent/default.nix b/plugins/by-name/transparent/default.nix index a4626377..e05ceff3 100644 --- a/plugins/by-name/transparent/default.nix +++ b/plugins/by-name/transparent/default.nix @@ -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. ''; }; diff --git a/plugins/by-name/treesitter/default.nix b/plugins/by-name/treesitter/default.nix index 3502ec72..75bf49f1 100644 --- a/plugins/by-name/treesitter/default.nix +++ b/plugins/by-name/treesitter/default.nix @@ -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`). ''; }; diff --git a/plugins/by-name/ts-autotag/default.nix b/plugins/by-name/ts-autotag/default.nix index 469bbdfa..1d71858c 100644 --- a/plugins/by-name/ts-autotag/default.nix +++ b/plugins/by-name/ts-autotag/default.nix @@ -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."; diff --git a/plugins/by-name/twilight/default.nix b/plugins/by-name/twilight/default.nix index 9aa49dd7..c5b666e7 100644 --- a/plugins/by-name/twilight/default.nix +++ b/plugins/by-name/twilight/default.nix @@ -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. ''; }; diff --git a/plugins/by-name/typst-vim/default.nix b/plugins/by-name/typst-vim/default.nix index 5d6372b8..8b831bcf 100644 --- a/plugins/by-name/typst-vim/default.nix +++ b/plugins/by-name/typst-vim/default.nix @@ -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. ''; }; diff --git a/plugins/by-name/vim-slime/default.nix b/plugins/by-name/vim-slime/default.nix index 946b0181..96ed4b9a 100644 --- a/plugins/by-name/vim-slime/default.nix +++ b/plugins/by-name/vim-slime/default.nix @@ -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 diff --git a/plugins/by-name/windsurf-vim/default.nix b/plugins/by-name/windsurf-vim/default.nix index 38279b03..5b5b416f 100644 --- a/plugins/by-name/windsurf-vim/default.nix +++ b/plugins/by-name/windsurf-vim/default.nix @@ -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 `` 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: "\" 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; }; } diff --git a/plugins/by-name/yanky/default.nix b/plugins/by-name/yanky/default.nix index 25ea7a42..9afc0104 100644 --- a/plugins/by-name/yanky/default.nix +++ b/plugins/by-name/yanky/default.nix @@ -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.` 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. ''; diff --git a/plugins/by-name/zellij/default.nix b/plugins/by-name/zellij/default.nix index 0d860932..f460b3e8 100644 --- a/plugins/by-name/zellij/default.nix +++ b/plugins/by-name/zellij/default.nix @@ -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 `h` to left. ''; - vimTmuxNavigatorKeybinds = helpers.defaultNullOpts.mkBool false '' + vimTmuxNavigatorKeybinds = lib.nixvim.defaultNullOpts.mkBool false '' Will set keybinds like `` to left. ''; - debug = helpers.defaultNullOpts.mkBool false '' + debug = lib.nixvim.defaultNullOpts.mkBool false '' Will log things to `/tmp/zellij.nvim`. ''; }; diff --git a/plugins/by-name/zen-mode/default.nix b/plugins/by-name/zen-mode/default.nix index 3eec600a..085beaa1 100644 --- a/plugins/by-name/zen-mode/default.nix +++ b/plugins/by-name/zen-mode/default.nix @@ -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. ''; }; diff --git a/plugins/by-name/zk/default.nix b/plugins/by-name/zk/default.nix index ee392988..69821f3c 100644 --- a/plugins/by-name/zk/default.nix +++ b/plugins/by-name/zk/default.nix @@ -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. ''; }; diff --git a/plugins/lsp/language-servers/default.nix b/plugins/lsp/language-servers/default.nix index 06500656..a07c4445 100644 --- a/plugins/lsp/language-servers/default.nix +++ b/plugins/lsp/language-servers/default.nix @@ -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. ''; }; diff --git a/tests/test-sources/modules/keymaps.nix b/tests/test-sources/modules/keymaps.nix index 09ecfa4e..c212d5c5 100644 --- a/tests/test-sources/modules/keymaps.nix +++ b/tests/test-sources/modules/keymaps.nix @@ -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; diff --git a/tests/test-sources/modules/output.nix b/tests/test-sources/modules/output.nix index d45acb89..41167c01 100644 --- a/tests/test-sources/modules/output.nix +++ b/tests/test-sources/modules/output.nix @@ -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."; } ]; diff --git a/tests/test-sources/plugins/by-name/flash/default.nix b/tests/test-sources/plugins/by-name/flash/default.nix index f3cd80bf..3ac58e87 100644 --- a/tests/test-sources/plugins/by-name/flash/default.nix +++ b/tests/test-sources/plugins/by-name/flash/default.nix @@ -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