lazy.nvim/doc/lazy.nvim.txt

1012 lines
43 KiB
Plaintext
Raw Normal View History

2024-06-02 20:49:18 +08:00
*lazy.nvim.txt* For Neovim >= 0.8.0 Last change: 2024 June 02
2022-11-29 22:42:57 +08:00
==============================================================================
Table of Contents *lazy.nvim-table-of-contents*
1. lazy.nvim |lazy.nvim-lazy.nvim|
2023-02-20 15:31:46 +08:00
- Features |lazy.nvim-lazy.nvim-features|
- Requirements |lazy.nvim-lazy.nvim-requirements|
- Installation |lazy.nvim-lazy.nvim-installation|
- Plugin Spec |lazy.nvim-lazy.nvim-plugin-spec|
- Configuration |lazy.nvim-lazy.nvim-configuration|
- Usage |lazy.nvim-lazy.nvim-usage|
- Lockfile lazy-lock.json |lazy.nvim-lazy.nvim-lockfile-lazy-lock.json|
- Performance |lazy.nvim-lazy.nvim-performance|
- Debug |lazy.nvim-lazy.nvim-debug|
- Startup Sequence |lazy.nvim-lazy.nvim-startup-sequence|
- Structuring Your Plugins |lazy.nvim-lazy.nvim-structuring-your-plugins|
- Migration Guide |lazy.nvim-lazy.nvim-migration-guide|
- Uninstalling |lazy.nvim-lazy.nvim-uninstalling|
- Highlight Groups |lazy.nvim-lazy.nvim-highlight-groups|
2023-07-01 00:29:13 +08:00
- Plugin Authors |lazy.nvim-lazy.nvim-plugin-authors|
2023-02-20 15:31:46 +08:00
- Other Neovim Plugin Managers in Lua|lazy.nvim-lazy.nvim-other-neovim-plugin-managers-in-lua|
2024-03-28 19:16:10 +08:00
2. Links |lazy.nvim-links|
2022-11-29 22:42:57 +08:00
==============================================================================
1. lazy.nvim *lazy.nvim-lazy.nvim*
2022-12-15 05:11:38 +08:00
**lazy.nvim** is a modern plugin manager for Neovim.
2022-12-15 04:05:17 +08:00
2022-12-15 04:06:06 +08:00
2023-02-20 15:31:46 +08:00
FEATURES *lazy.nvim-lazy.nvim-features*
2022-11-29 22:42:57 +08:00
2022-12-20 04:06:18 +08:00
- Manage all your Neovim plugins with a powerful UI
2023-02-28 14:28:08 +08:00
- Fast startup times thanks to automatic caching and bytecode compilation of Lua modules
2022-12-15 04:05:17 +08:00
- Partial clones instead of shallow clones
2023-02-28 14:28:08 +08:00
- Automatic lazy-loading of Lua modules and lazy-loading on events, commands, filetypes, and key mappings
2022-12-20 04:28:48 +08:00
- Automatically install missing plugins before starting up Neovim, allowing you to start using it right away
2022-12-15 04:05:17 +08:00
- Async execution for improved performance
- No need to manually compile plugins
- Correct sequencing of dependencies
- Configurable in multiple files
2022-12-15 21:36:25 +08:00
- Generates helptags of the headings in `README.md` files for plugins that dont have vimdocs
2022-12-15 05:11:38 +08:00
- Dev options and patterns for using local plugins
2022-12-15 04:05:17 +08:00
- Profiling tools to optimize performance
2022-12-15 05:11:38 +08:00
- Lockfile `lazy-lock.json` to keep track of installed plugins
2022-12-15 04:05:17 +08:00
- Automatically check for updates
- Commit, branch, tag, version, and full Semver <https://devhints.io/semver> support
- Statusline component to see the number of pending updates
2022-12-22 20:50:12 +08:00
- Automatically lazy-loads colorschemes
2022-12-15 04:05:17 +08:00
2023-02-20 15:31:46 +08:00
REQUIREMENTS *lazy.nvim-lazy.nvim-requirements*
2022-12-15 04:42:10 +08:00
2022-12-18 18:59:37 +08:00
- Neovim >= **0.8.0** (needs to be built with **LuaJIT**)
- Git >= **2.19.0** (for partial clones support)
2023-02-20 15:31:46 +08:00
- a Nerd Font <https://www.nerdfonts.com/> **(optional)**
2022-12-15 04:42:10 +08:00
2023-02-20 15:31:46 +08:00
INSTALLATION *lazy.nvim-lazy.nvim-installation*
2022-12-15 04:42:10 +08:00
2022-12-21 04:16:27 +08:00
You can add the following Lua code to your `init.lua` to bootstrap
**lazy.nvim**
2022-12-15 04:42:10 +08:00
2022-12-15 16:07:46 +08:00
>lua
2022-12-15 07:23:54 +08:00
local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
2024-03-27 16:23:55 +08:00
if not (vim.uv or vim.loop).fs_stat(lazypath) then
2022-12-31 16:45:05 +08:00
vim.fn.system({
"git",
"clone",
"--filter=blob:none",
"https://github.com/folke/lazy.nvim.git",
"--branch=stable", -- latest stable release
lazypath,
})
2022-12-21 18:43:46 +08:00
end
2022-12-30 06:37:17 +08:00
vim.opt.rtp:prepend(lazypath)
2022-12-15 04:42:10 +08:00
<
2023-02-28 14:28:08 +08:00
Nextstep is to add **lazy.nvim** below the code added in the prior step in
2023-02-06 16:25:32 +08:00
`init.lua`
2022-12-15 04:55:03 +08:00
2022-12-15 16:07:46 +08:00
>lua
2022-12-20 04:06:18 +08:00
require("lazy").setup(plugins, opts)
2022-12-15 04:55:03 +08:00
<
2023-02-20 15:31:46 +08:00
- **plugins**this should be a `table` or a `string`
- `table`a list with your |lazy.nvim-plugin-spec|
- `string`a Lua module name that contains your |lazy.nvim-plugin-spec|. See |lazy.nvim-structuring-your-plugins|
- **opts**see |lazy.nvim-configuration| **(optional)**
2022-12-20 04:06:18 +08:00
>lua
2023-02-28 14:28:08 +08:00
-- Example using a list of specs with the default options
vim.g.mapleader = " " -- Make sure to set `mapleader` before lazy so your mappings are correct
2024-03-08 00:32:44 +08:00
vim.g.maplocalleader = "\\" -- Same for `maplocalleader`
2022-12-21 04:16:27 +08:00
2022-12-20 04:06:18 +08:00
require("lazy").setup({
"folke/which-key.nvim",
{ "folke/neoconf.nvim", cmd = "Neoconf" },
"folke/neodev.nvim",
})
<
2023-02-28 14:28:08 +08:00
It is recommended to run `:checkhealth lazy` after installation.
2022-12-18 21:50:01 +08:00
2022-12-15 07:30:02 +08:00
2023-02-20 15:31:46 +08:00
PLUGIN SPEC *lazy.nvim-lazy.nvim-plugin-spec*
2023-10-13 18:38:26 +08:00
------------------------------------------------------------------------------------------------------------------------------------
Property Type Description
-------------- ---------------------------------------------------------------- ----------------------------------------------------
[1] string? Short plugin url. Will be expanded using
config.git.url_format
2023-02-20 15:31:46 +08:00
2023-10-13 18:38:26 +08:00
dir string? A directory pointing to a local plugin
2023-02-20 15:31:46 +08:00
2023-10-13 18:38:26 +08:00
url string? A custom git url where the plugin is hosted
2023-02-20 15:31:46 +08:00
2023-10-13 18:38:26 +08:00
name string? A custom name for the plugin used for the local
plugin directory and as the display name
2023-02-20 15:31:46 +08:00
2023-10-13 18:38:26 +08:00
dev boolean? When true, a local plugin directory will be used
instead. See config.dev
2023-02-20 15:31:46 +08:00
2023-10-13 18:38:26 +08:00
lazy boolean? When true, the plugin will only be loaded when
needed. Lazy-loaded plugins are automatically loaded
when their Lua modules are required, or when one of
the lazy-loading handlers triggers
2023-02-20 15:31:46 +08:00
2023-10-13 18:38:26 +08:00
enabled boolean? or fun():boolean When false, or if the function returns false, then
this plugin will not be included in the spec
2023-02-20 15:31:46 +08:00
2023-10-13 18:38:26 +08:00
cond boolean? or fun(LazyPlugin):boolean When false, or if the function returns false, then
this plugin will not be loaded. Useful to disable
some plugins in vscode, or firenvim for example.
2023-02-20 15:31:46 +08:00
2023-10-13 18:38:26 +08:00
dependencies LazySpec[] A list of plugin names or plugin specs that should
be loaded when the plugin loads. Dependencies are
always lazy-loaded unless specified otherwise. When
specifying a name, make sure the plugin spec has
been defined somewhere else.
2023-02-20 15:31:46 +08:00
2023-10-13 18:38:26 +08:00
init fun(LazyPlugin) init functions are always executed during startup
2023-02-20 15:31:46 +08:00
2023-10-13 18:38:26 +08:00
opts table or fun(LazyPlugin, opts:table) opts should be a table (will be merged with parent
specs), return a table (replaces parent specs) or
should change a table. The table will be passed to
the Plugin.config() function. Setting this value
will imply Plugin.config()
2023-02-20 15:31:46 +08:00
2023-10-13 18:38:26 +08:00
config fun(LazyPlugin, opts:table) or true config is executed when the plugin loads. The
default implementation will automatically run
2024-05-12 15:52:52 +08:00
require(MAIN).setup(opts) if opts or config = true
is set. Lazy uses several heuristics to determine
the plugins MAIN module automatically based on the
plugins name. See also opts. To use the default
implementation without opts set config to true.
2023-02-20 15:31:46 +08:00
2023-10-13 18:38:26 +08:00
main string? You can specify the main module to use for config()
and opts(), in case it can not be determined
automatically. See config()
2023-03-18 15:58:04 +08:00
2023-10-13 18:38:26 +08:00
build fun(LazyPlugin) or string or a list of build commands build is executed when a plugin is installed or
updated. Before running build, a plugin is first
loaded. If its a string it will be ran as a shell
command. When prefixed with : it is a Neovim
command. You can also specify a list to executed
multiple build commands. Some plugins provide their
own build.lua which is automatically used by lazy.
So no need to specify a build step for those
plugins.
2023-02-20 15:31:46 +08:00
2023-10-13 18:38:26 +08:00
branch string? Branch of the repository
2023-02-20 15:31:46 +08:00
2023-10-13 18:38:26 +08:00
tag string? Tag of the repository
2023-02-20 15:31:46 +08:00
2023-10-13 18:38:26 +08:00
commit string? Commit of the repository
2023-02-20 15:31:46 +08:00
2023-10-13 18:38:26 +08:00
version string? or false to override the default Version to use from the repository. Full Semver
ranges are supported
2023-02-20 15:31:46 +08:00
2023-10-13 18:38:26 +08:00
pin boolean? When true, this plugin will not be included in
updates
2023-02-20 15:31:46 +08:00
2023-10-13 18:38:26 +08:00
submodules boolean? When false, git submodules will not be fetched.
Defaults to true
2023-02-20 15:31:46 +08:00
2023-10-13 18:38:26 +08:00
event string? or string[] or Lazy-load on event. Events can be specified as
fun(self:LazyPlugin, event:string[]):string[] or BufEnter or with a pattern like BufEnter *.lua
{event:string[]\|string, pattern?:string[]\|string}
2023-02-20 15:31:46 +08:00
2023-10-13 18:38:26 +08:00
cmd string? or string[] or Lazy-load on command
fun(self:LazyPlugin, cmd:string[]):string[]
2023-02-20 15:31:46 +08:00
2023-10-13 18:38:26 +08:00
ft string? or string[] or Lazy-load on filetype
fun(self:LazyPlugin, ft:string[]):string[]
2023-02-20 15:31:46 +08:00
2023-10-13 18:38:26 +08:00
keys string? or string[] or LazyKeysSpec[] or Lazy-load on key mapping
fun(self:LazyPlugin, keys:string[]):(string \| LazyKeysSpec)[]
2023-02-20 15:31:46 +08:00
2023-10-13 18:38:26 +08:00
module false? Do not automatically load this Lua module when its
required somewhere
2023-02-20 15:31:46 +08:00
2023-10-13 18:38:26 +08:00
priority number? Only useful for start plugins (lazy=false) to force
loading certain plugins first. Default priority is
50. Its recommended to set this to a high number
for colorschemes.
2023-05-23 14:58:38 +08:00
2023-10-13 18:38:26 +08:00
optional boolean? When a spec is tagged optional, it will only be
included in the final spec, when the same plugin has
been specified at least once somewhere else without
optional. This is mainly useful for Neovim distros,
to allow setting options on plugins that may/may not
be part of the users plugins
------------------------------------------------------------------------------------------------------------------------------------
2022-12-15 07:30:02 +08:00
2022-12-18 21:29:46 +08:00
LAZY LOADING ~
**lazy.nvim** automagically lazy-loads Lua modules, so it is not needed to
2023-02-28 14:28:08 +08:00
specify `module=...` everywhere in your plugin specification. This means that
if you have a plugin `A` that is lazy-loaded and a plugin `B` that requires a
2022-12-18 21:29:46 +08:00
module of plugin `A`, then plugin `A` will be loaded on demand as expected.
2022-12-19 21:57:32 +08:00
If you dont want this behavior for a certain plugin, you can specify that
with `module=false`. You can then manually load the plugin with `:Lazy load
foobar.nvim`.
2022-12-20 04:06:18 +08:00
You can configure **lazy.nvim** to lazy-load all plugins by default with
`config.defaults.lazy = true`.
2022-12-18 21:29:46 +08:00
Additionally, you can also lazy-load on **events**, **commands**, **file
types** and **key mappings**.
2023-02-20 15:31:46 +08:00
Plugins will be lazy-loaded when one of the following is `true`
2022-12-18 21:29:46 +08:00
2023-02-28 14:28:08 +08:00
- Theplugin only exists as a dependency in your spec
- It has an `event`, `cmd`, `ft` or `keys` key
2022-12-18 21:29:46 +08:00
- `config.defaults.lazy == true`
2023-02-20 15:31:46 +08:00
COLORSCHEMES
2022-12-28 00:25:37 +08:00
2023-02-20 15:31:46 +08:00
Colorscheme plugins can be configured with `lazy=true`. The plugin will
automagically load when doing `colorscheme foobar`.
2022-12-28 00:25:37 +08:00
**NOTE:** since **start** plugins can possibly change existing highlight
groups, its important to make sure that your main **colorscheme** is loaded
2023-02-20 15:31:46 +08:00
first. To ensure this you can use the `priority=1000` field. **(see the
examples)**
2022-12-22 17:33:10 +08:00
2023-02-20 15:31:46 +08:00
LAZY KEY MAPPINGS
2022-12-22 17:33:10 +08:00
2023-02-20 15:31:46 +08:00
The `keys` property can be a `string` or `string[]` for simple normal-mode
2023-10-13 19:15:19 +08:00
mappings, or it can be a `LazyKeysSpec` table with the following key-value
pairs:
2022-12-22 17:33:10 +08:00
2023-02-20 15:31:46 +08:00
- **[1]**(`string`) lhs **(required)**
- **[2]**(`string|fun()`) rhs **(optional)**
- **mode**(`string|string[]`) mode **(optional, defaults to "n")**
2023-10-05 20:01:02 +08:00
- **ft**(`string|string[]`) `filetype` for buffer-local keymaps **(optional)**
2022-12-22 17:33:10 +08:00
- any other option valid for `vim.keymap.set`
Key mappings will load the plugin the first time they get executed.
When `[2]` is `nil`, then the real mapping has to be created by the `config()`
function.
>lua
-- Example for neo-tree.nvim
{
"nvim-neo-tree/neo-tree.nvim",
keys = {
{ "<leader>ft", "<cmd>Neotree toggle<cr>", desc = "NeoTree" },
},
config = function()
require("neo-tree").setup()
2022-12-25 21:41:45 +08:00
end,
2022-12-22 17:33:10 +08:00
}
<
2022-12-18 21:29:46 +08:00
VERSIONING ~
If you want to install a specific revision of a plugin, you can use `commit`,
`tag`, `branch`, `version`.
2022-12-20 04:06:18 +08:00
The `version` property supports Semver <https://semver.org/> ranges.
2023-02-20 15:31:46 +08:00
Click to see some examples ~
2022-12-18 21:29:46 +08:00
2023-09-27 18:40:28 +08:00
- `*`latest stable version (this excludes pre-release versions)
2023-02-20 15:31:46 +08:00
- `1.2.x`any version that starts with `1.2`, such as `1.2.0`, `1.2.3`, etc.
- `^1.2.3`any version that is compatible with `1.2.3`, such as `1.3.0`, `1.4.5`, etc., but not `2.0.0`.
- `~1.2.3`any version that is compatible with `1.2.3`, such as `1.2.4`, `1.2.5`, but not `1.3.0`.
- `>1.2.3`any version that is greater than `1.2.3`, such as `1.3.0`, `1.4.5`, etc.
- `>=1.2.3`any version that is greater than or equal to `1.2.3`, such as `1.2.3`, `1.3.0`, `1.4.5`, etc.
- `<1.2.3`any version that is less than `1.2.3`, such as `1.1.0`, `1.0.5`, etc.
- `<=1.2.3`any version that is less than or equal to `1.2.3`, such as `1.2.3`, `1.1.0`, `1.0.5`, etc
2022-12-18 21:29:46 +08:00
2023-09-27 18:40:28 +08:00
You can set `config.defaults.version = "*"` to install the latest stable
version of plugins that support Semver.
2022-12-18 21:29:46 +08:00
2023-02-20 15:31:46 +08:00
2022-12-18 21:29:46 +08:00
EXAMPLES ~
2022-12-15 16:07:46 +08:00
>lua
2022-12-15 07:23:54 +08:00
return {
-- the colorscheme should be available when starting Neovim
2022-12-28 00:25:37 +08:00
{
"folke/tokyonight.nvim",
lazy = false, -- make sure we load this during startup if it is your main colorscheme
priority = 1000, -- make sure to load this before all the other start plugins
config = function()
-- load the colorscheme here
vim.cmd([[colorscheme tokyonight]])
end,
},
2022-12-15 07:23:54 +08:00
-- I have a separate config.mappings file where I require which-key.
-- With lazy the plugin will be automatically loaded when it is required somewhere
{ "folke/which-key.nvim", lazy = true },
{
"nvim-neorg/neorg",
-- lazy-load on filetype
ft = "norg",
2023-03-18 15:58:04 +08:00
-- options for neorg. This will automatically call `require("neorg").setup(opts)`
opts = {
load = {
["core.defaults"] = {},
},
},
2022-12-23 05:50:05 +08:00
},
2022-12-15 07:23:54 +08:00
{
"dstein64/vim-startuptime",
-- lazy-load on a command
cmd = "StartupTime",
2023-03-18 15:58:04 +08:00
-- init is called during startup. Configuration for vim plugins typically should be set in an init function
init = function()
vim.g.startuptime_tries = 10
end,
2022-12-15 07:23:54 +08:00
},
{
"hrsh7th/nvim-cmp",
-- load cmp on InsertEnter
event = "InsertEnter",
-- these dependencies will only be loaded when cmp loads
-- dependencies are always lazy-loaded unless specified otherwise
dependencies = {
"hrsh7th/cmp-nvim-lsp",
"hrsh7th/cmp-buffer",
},
config = function()
-- ...
end,
},
2023-03-18 15:58:04 +08:00
-- if some code requires a module from an unloaded plugin, it will be automatically loaded.
-- So for api plugins like devicons, we can always set lazy=true
{ "nvim-tree/nvim-web-devicons", lazy = true },
2022-12-15 07:23:54 +08:00
-- you can use the VeryLazy event for things that can
2022-12-20 17:27:34 +08:00
-- load later and are not important for the initial UI
{ "stevearc/dressing.nvim", event = "VeryLazy" },
2022-12-15 07:23:54 +08:00
{
2023-03-18 15:58:04 +08:00
"Wansmer/treesj",
keys = {
{ "J", "<cmd>TSJToggle<cr>", desc = "Join Toggle" },
},
opts = { use_default_keymaps = false, max_join_length = 150 },
2022-12-15 07:23:54 +08:00
},
{
"monaqa/dial.nvim",
-- lazy-load on keys
2022-12-24 02:04:19 +08:00
-- mode is `n` by default. For more advanced options, check the section on key mappings
keys = { "<C-a>", { "<C-x>", mode = "n" } },
2022-12-15 07:23:54 +08:00
},
2022-12-19 20:38:06 +08:00
-- local plugins need to be explicitly configured with dir
2022-12-15 07:23:54 +08:00
{ dir = "~/projects/secret.nvim" },
-- you can use a custom url to fetch a plugin
{ url = "git@github.com:folke/noice.nvim.git" },
-- local plugins can also be configure with the dev option.
2022-12-20 21:02:51 +08:00
-- This will use {config.dev.path}/noice.nvim/ instead of fetching it from Github
2022-12-15 07:23:54 +08:00
-- With the dev option, you can easily switch between the local and installed version of a plugin
{ "folke/noice.nvim", dev = true },
}
<
2023-02-20 15:31:46 +08:00
CONFIGURATION *lazy.nvim-lazy.nvim-configuration*
2022-12-15 04:55:03 +08:00
**lazy.nvim** comes with the following defaults:
2022-12-15 16:07:46 +08:00
>lua
2022-12-15 04:55:03 +08:00
{
root = vim.fn.stdpath("data") .. "/lazy", -- directory where plugins will be installed
defaults = {
lazy = false, -- should plugins be lazy-loaded?
version = nil,
2023-03-14 18:20:47 +08:00
-- default `cond` you can use to globally disable a lot of plugins
-- when running inside vscode for example
cond = nil, ---@type boolean|fun(self:LazyPlugin):boolean|nil
2023-09-27 18:40:28 +08:00
-- version = "*", -- enable this to try installing the latest stable versions of plugins
2022-12-15 04:55:03 +08:00
},
2023-01-06 14:13:06 +08:00
-- leave nil when passing the spec as the first argument to setup()
spec = nil, ---@type LazySpec
2024-05-26 22:44:42 +08:00
local_spec = true, -- load project specific .lazy.lua spec files. They will be added at the end of the spec.
2022-12-15 04:55:03 +08:00
lockfile = vim.fn.stdpath("config") .. "/lazy-lock.json", -- lockfile generated after running update.
2024-03-27 02:52:53 +08:00
---@type number? limit the maximum amount of concurrent tasks
concurrency = jit.os:find("Windows") and (vim.uv.available_parallelism() * 2) or nil,
2022-12-15 04:55:03 +08:00
git = {
-- defaults for the `Lazy log` command
2024-03-27 02:52:53 +08:00
-- log = { "--since=3 days ago" }, -- show commits from the last 3 days
log = { "-8" }, -- show the last 8 commits
2022-12-15 04:55:03 +08:00
timeout = 120, -- kill processes that take more than 2 minutes
url_format = "https://github.com/%s.git",
2023-01-25 06:01:59 +08:00
-- lazy.nvim requires git >=2.19.0. If you really want to use lazy with an older version,
2023-03-06 14:41:03 +08:00
-- then set the below to false. This should work, but is NOT supported and will
2023-01-25 06:01:59 +08:00
-- increase downloads a lot.
filter = true,
2022-12-15 04:55:03 +08:00
},
dev = {
2024-01-20 21:19:39 +08:00
---@type string | fun(plugin: LazyPlugin): string directory where you store your local plugin projects
2022-12-20 17:27:34 +08:00
path = "~/projects",
2022-12-15 04:55:03 +08:00
---@type string[] plugins that match these patterns will use your local versions instead of being fetched from GitHub
patterns = {}, -- For example {"folke"}
2023-01-25 05:56:22 +08:00
fallback = false, -- Fallback to git when local plugin doesn't exist
2022-12-15 04:55:03 +08:00
},
install = {
-- install missing plugins on startup. This doesn't increase startup time.
missing = true,
-- try to load one of these colorschemes when starting an installation during startup
colorscheme = { "habamax" },
},
ui = {
2022-12-21 02:30:15 +08:00
-- a number <1 is a percentage., >1 is a fixed size
size = { width = 0.8, height = 0.8 },
2023-01-20 05:09:52 +08:00
wrap = true, -- wrap the lines in the ui
2022-12-15 04:55:03 +08:00
-- The border to use for the UI window. Accepts same border values as |nvim_open_win()|.
border = "none",
2024-03-27 02:52:53 +08:00
-- The backdrop opacity. 0 is fully opaque, 100 is fully transparent.
backdrop = 60,
2023-05-27 20:28:58 +08:00
title = nil, ---@type string only works when border is not "none"
title_pos = "center", ---@type "center" | "left" | "right"
2023-07-21 05:49:43 +08:00
-- Show pills on top of the Lazy window
pills = true, ---@type boolean
2022-12-15 04:55:03 +08:00
icons = {
2023-09-27 18:40:28 +08:00
cmd = " ",
config = "",
2024-03-27 02:52:53 +08:00
event = " ",
2023-09-27 18:40:28 +08:00
ft = " ",
init = " ",
import = " ",
keys = " ",
2023-02-13 19:02:38 +08:00
lazy = "󰒲 ",
2023-09-27 18:40:28 +08:00
loaded = "●",
not_loaded = "○",
plugin = " ",
runtime = " ",
2023-10-09 18:39:27 +08:00
require = "󰢱 ",
2023-09-27 18:40:28 +08:00
source = " ",
2024-03-27 02:52:53 +08:00
start = " ",
2023-09-27 18:40:28 +08:00
task = "✔ ",
2022-12-26 17:25:34 +08:00
list = {
2023-09-27 18:40:28 +08:00
"●",
"➜",
"★",
2022-12-26 17:25:34 +08:00
"",
},
2022-12-15 04:55:03 +08:00
},
2022-12-31 03:42:08 +08:00
-- leave nil, to automatically select a browser depending on your OS.
-- If you want to use a specific browser, you can define it here
browser = nil, ---@type string?
2022-12-15 04:55:03 +08:00
throttle = 20, -- how frequently should the ui process render events
2022-12-24 18:31:06 +08:00
custom_keys = {
-- You can define custom key maps here. If present, the description will
-- be shown in the help menu.
-- To disable one of the defaults, set it to false.
2023-10-12 13:19:35 +08:00
["<localleader>l"] = {
function(plugin)
require("lazy.util").float_term({ "lazygit", "log" }, {
cwd = plugin.dir,
})
end,
desc = "Open lazygit log",
},
2023-10-12 13:19:35 +08:00
["<localleader>t"] = {
function(plugin)
require("lazy.util").float_term(nil, {
cwd = plugin.dir,
})
end,
desc = "Open terminal in plugin dir",
},
2022-12-24 18:31:06 +08:00
},
},
diff = {
-- diff command <d> can be one of:
2023-09-27 18:40:28 +08:00
-- * browser: opens the github compare view. Note that this is always mapped to <K> as well,
2022-12-24 18:31:06 +08:00
-- so you can have a different command for diff <d>
2023-09-27 18:40:28 +08:00
-- * git: will run git diff and open a buffer with filetype git
-- * terminal_git: will open a pseudo terminal with git diff
-- * diffview.nvim: will open Diffview to show the diff
2022-12-24 18:31:06 +08:00
cmd = "git",
2022-12-15 04:55:03 +08:00
},
checker = {
2022-12-19 20:38:06 +08:00
-- automatically check for plugin updates
2022-12-15 04:55:03 +08:00
enabled = false,
concurrency = nil, ---@type number? set to 1 to check for updates very slowly
notify = true, -- get a notification when new updates are found
frequency = 3600, -- check for updates every hour
2023-10-23 13:53:33 +08:00
check_pinned = false, -- check for pinned packages that can't be updated
2022-12-15 04:55:03 +08:00
},
2022-12-21 02:39:54 +08:00
change_detection = {
-- automatically check for config file changes and reload the ui
enabled = true,
notify = true, -- get a notification when changes are found
},
2022-12-15 04:55:03 +08:00
performance = {
2022-12-15 04:59:50 +08:00
cache = {
enabled = true,
},
2022-12-15 04:55:03 +08:00
reset_packpath = true, -- reset the package path to improve startup time
rtp = {
reset = true, -- reset the runtime path to $VIMRUNTIME and your config directory
2022-12-21 22:19:58 +08:00
---@type string[]
2023-01-25 06:01:59 +08:00
paths = {}, -- add any custom paths here that you want to includes in the rtp
2022-12-15 04:55:03 +08:00
---@type string[] list any plugins you want to disable here
disabled_plugins = {
-- "gzip",
-- "matchit",
-- "matchparen",
-- "netrwPlugin",
-- "tarPlugin",
-- "tohtml",
-- "tutor",
-- "zipPlugin",
},
},
},
2022-12-15 21:44:45 +08:00
-- lazy can generate helptags from the headings in markdown readme files,
-- so :help works even for plugins that don't have vim docs.
-- when the readme opens with :help it will be correctly displayed as markdown
readme = {
2023-03-17 23:18:52 +08:00
enabled = true,
2022-12-15 21:44:45 +08:00
root = vim.fn.stdpath("state") .. "/lazy/readme",
2023-09-27 18:40:28 +08:00
files = { "README.md", "lua/**/README.md" },
2022-12-15 21:44:45 +08:00
-- only generate markdown helptags for plugins that dont have docs
skip_if_doc_exists = true,
},
2023-01-20 05:09:52 +08:00
state = vim.fn.stdpath("state") .. "/lazy/state.json", -- state info for checker and other things
2023-07-01 03:20:17 +08:00
build = {
-- Plugins can provide a `build.lua` file that will be executed when the plugin is installed
-- or updated. When the plugin spec also has a `build` command, the plugin's `build.lua` not be
-- executed. In this case, a warning message will be shown.
warn_on_override = true,
},
2023-10-09 18:39:27 +08:00
-- Enable profiling of lazy.nvim. This will add some overhead,
-- so only enable this when you are debugging lazy.nvim
profiling = {
-- Enables extra stats on the debug tab related to the loader cache.
-- Additionally gathers stats about all package.loaders
loader = false,
-- Track each new require in the Lazy profiling tab
require = false,
},
2022-12-15 04:55:03 +08:00
}
<
2023-02-20 15:31:46 +08:00
If you dont want to use a Nerd Font, you can replace the icons with Unicode symbols. ~
2022-12-20 02:10:49 +08:00
>lua
{
ui = {
icons = {
cmd = "⌘",
2023-09-27 18:40:28 +08:00
config = "🛠",
event = "📅",
ft = "📂",
init = "⚙",
keys = "🗝",
plugin = "🔌",
runtime = "💻",
2023-10-11 00:59:52 +08:00
require = "🌙",
2023-09-27 18:40:28 +08:00
source = "📄",
start = "🚀",
task = "📌",
lazy = "💤 ",
2022-12-20 02:10:49 +08:00
},
},
}
<
2023-02-20 15:31:46 +08:00
USAGE *lazy.nvim-lazy.nvim-usage*
2022-12-15 04:58:18 +08:00
2022-12-20 04:06:18 +08:00
Plugins are managed with the `:Lazy` command. Open the help with `<?>` to see
all the key mappings.
You can press `<CR>` on a plugin to show its details. Most properties can be
2022-12-20 17:56:46 +08:00
hovered with `<K>` to open links, help files, readmes, git commits and git
issues.
2022-12-20 04:06:18 +08:00
2022-12-21 02:44:49 +08:00
Lazy can automatically check for updates in the background. This feature can be
enabled with `config.checker.enabled = true`.
Any operation can be started from the UI, with a sub command or an API
function:
2022-12-18 18:44:05 +08:00
2024-05-26 22:44:42 +08:00
--------------------------------------------------------------------------------------------------------------
2024-03-28 19:16:10 +08:00
Command Lua Description
2024-05-26 22:44:42 +08:00
------------------------- -------------------------------- ---------------------------------------------------
2024-03-28 19:16:10 +08:00
:Lazy build {plugins} require("lazy").build(opts) Rebuild a plugin
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
:Lazy check [plugins] require("lazy").check(opts?) Check for updates and show the log (git fetch)
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
:Lazy clean [plugins] require("lazy").clean(opts?) Clean plugins that are no longer needed
2022-12-22 05:28:58 +08:00
2024-03-28 19:16:10 +08:00
:Lazy clear require("lazy").clear() Clear finished tasks
2022-12-22 05:28:58 +08:00
2024-03-28 19:16:10 +08:00
:Lazy debug require("lazy").debug() Show debug information
2023-02-20 15:31:46 +08:00
2024-03-28 19:16:10 +08:00
:Lazy health require("lazy").health() Run :checkhealth lazy
2023-02-20 15:31:46 +08:00
2024-03-28 19:16:10 +08:00
:Lazy help require("lazy").help() Toggle this help page
2023-02-20 15:31:46 +08:00
2024-03-28 19:16:10 +08:00
:Lazy home require("lazy").home() Go back to plugin list
2023-02-20 15:31:46 +08:00
2024-03-28 19:16:10 +08:00
:Lazy install [plugins] require("lazy").install(opts?) Install missing plugins
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
:Lazy load {plugins} require("lazy").load(opts) Load a plugin that has not been loaded yet. Similar
to :packadd. Like :Lazy load foo.nvim. Use
:Lazy! load to skip cond checks.
2023-02-20 15:31:46 +08:00
2024-03-28 19:16:10 +08:00
:Lazy log [plugins] require("lazy").log(opts?) Show recent updates
2023-02-20 15:31:46 +08:00
2024-03-28 19:16:10 +08:00
:Lazy profile require("lazy").profile() Show detailed profiling
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
:Lazy reload {plugins} require("lazy").reload(opts) Reload a plugin (experimental!!)
2023-07-01 03:20:17 +08:00
2024-05-26 22:44:42 +08:00
:Lazy restore [plugins] require("lazy").restore(opts?) Updates all plugins to the state in the lockfile.
For a single plugin: restore it to the state in the
lockfile or to a given commit under the cursor
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
:Lazy sync [plugins] require("lazy").sync(opts?) Run install, clean and update
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
:Lazy update [plugins] require("lazy").update(opts?) Update plugins. This will also update the lockfile
--------------------------------------------------------------------------------------------------------------
2022-12-22 05:28:58 +08:00
Any command can have a **bang** to make the command wait till it finished. For
example, if you want to sync lazy from the cmdline, you can use:
2022-12-30 16:18:51 +08:00
>shell
2024-03-08 00:32:44 +08:00
nvim --headless "+Lazy! sync" +qa
2022-12-22 05:28:58 +08:00
<
`opts` is a table with the following key-values:
2023-02-20 15:31:46 +08:00
- **wait**when true, then the call will wait till the operation completed
- **show**when false, the UI will not be shown
- **plugins**a list of plugin names to run the operation on
- **concurrency**limit the `number` of concurrently running tasks
2022-12-18 18:44:05 +08:00
2022-12-27 20:35:05 +08:00
Stats API (`require("lazy").stats()`):
2022-12-20 18:40:52 +08:00
>lua
2022-12-27 20:35:05 +08:00
{
-- startuptime in milliseconds till UIEnter
startuptime = 0,
-- when true, startuptime is the accurate cputime for the Neovim process. (Linux & Macos)
-- this is more accurate than `nvim --startuptime`, and as such will be slightly higher
-- when false, startuptime is calculated based on a delta with a timestamp when lazy started.
2023-01-06 14:13:06 +08:00
real_cputime = false,
2022-12-27 20:35:05 +08:00
count = 0, -- total number of plugins
loaded = 0, -- number of loaded plugins
2023-01-06 14:13:06 +08:00
---@type table<string, number>
times = {},
2022-12-27 20:35:05 +08:00
}
2022-12-20 18:40:52 +08:00
<
**lazy.nvim** provides a statusline component that you can use to show the
number of pending updates. Make sure to enable `config.checker.enabled = true`
to make this work.
2023-02-20 15:31:46 +08:00
Example of configuring lualine.nvim ~
2022-12-20 18:40:52 +08:00
>lua
require("lualine").setup({
sections = {
lualine_x = {
{
require("lazy.status").updates,
cond = require("lazy.status").has_updates,
2023-09-27 18:40:28 +08:00
color = { fg = "#ff9e64" },
2022-12-20 18:40:52 +08:00
},
},
},
})
<
2022-12-24 18:56:27 +08:00
USER EVENTS ~
The following user events will be triggered:
2023-02-20 15:31:46 +08:00
- **LazyDone**when lazy has finished starting up and loaded your config
- **LazySync**after running sync
- **LazyInstall**after an install
- **LazyUpdate**after an update
- **LazyClean**after a clean
- **LazyCheck**after checking for updates
- **LazyLog**after running log
2023-07-12 23:22:18 +08:00
- **LazyLoad**after loading a plugin. The `data` attribute will contain the plugin name.
2023-06-17 14:38:16 +08:00
- **LazySyncPre**before running sync
- **LazyInstallPre**before an install
- **LazyUpdatePre**before an update
- **LazyCleanPre**before a clean
- **LazyCheckPre**before checking for updates
- **LazyLogPre**before running log
2023-02-20 15:31:46 +08:00
- **LazyReload**triggered by change detection after reloading plugin specs
- **VeryLazy**triggered after `LazyDone` and processing `VimEnter` auto commands
- **LazyVimStarted**triggered after `UIEnter` when `require("lazy").stats().startuptime` has been calculated.
2022-12-27 20:35:05 +08:00
Useful to update the startuptime on your dashboard.
2022-12-24 18:56:27 +08:00
2023-02-20 15:31:46 +08:00
LOCKFILE LAZY-LOCK.JSON *lazy.nvim-lazy.nvim-lockfile-lazy-lock.json*
2022-12-18 21:34:41 +08:00
After every **update**, the local lockfile is updated with the installed
revisions. It is recommended to have this file under version control.
If you use your Neovim config on multiple machines, using the lockfile, you can
ensure that the same version of every plugin is installed.
2022-12-23 14:51:44 +08:00
If you are on another machine, you can do `:Lazy restore`, to update all your
plugins to the version from the lockfile.
2022-12-18 21:34:41 +08:00
2023-02-20 15:31:46 +08:00
PERFORMANCE *lazy.nvim-lazy.nvim-performance*
2022-12-15 04:07:51 +08:00
2022-12-20 17:56:46 +08:00
Great care has been taken to make the startup code (`lazy.core`) as efficient
2022-12-23 14:51:44 +08:00
as possible. During startup, all Lua files used before `VimEnter` or
2022-12-20 17:56:46 +08:00
`BufReadPre` are byte-compiled and cached, similar to what impatient.nvim
<https://github.com/lewis6991/impatient.nvim> does.
2022-12-20 18:40:52 +08:00
My config for example loads in about `11ms` with `93` plugins. I do a lot of
lazy-loading though :)
2022-12-20 17:56:46 +08:00
**lazy.nvim** comes with an advanced profiler `:Lazy profile` to help you
improve performance. The profiling view shows you why and how long it took to
load your plugins.
2022-12-15 04:11:48 +08:00
2022-12-15 04:07:51 +08:00
2023-02-20 15:31:46 +08:00
DEBUG *lazy.nvim-lazy.nvim-debug*
2022-12-15 04:11:48 +08:00
See an overview of active lazy-loading handlers and whats in the module
2023-02-28 14:28:08 +08:00
cache.
2022-12-15 04:11:48 +08:00
2022-12-15 04:09:17 +08:00
2023-02-20 15:31:46 +08:00
STARTUP SEQUENCE *lazy.nvim-lazy.nvim-startup-sequence*
2022-12-16 22:11:06 +08:00
**lazy.nvim** does **NOT** use Neovim packages and even disables plugin loading
completely (`vim.go.loadplugins = false`). It takes over the complete startup
sequence for more flexibility and better performance.
2022-12-18 18:44:05 +08:00
In practice this means that step 10 of |Neovim Initialization| is done by Lazy:
2023-05-10 23:26:00 +08:00
1. All the plugins `init()` functions are executed
2. All plugins with `lazy=false` are loaded. This includes sourcing `/plugin` and `/ftdetect` files. (`/after` will not be sourced yet)
2024-01-20 22:09:14 +08:00
3. All files from `/plugin` and `/ftdetect` directories in your rtp are sourced (excluding `/after`)
2023-05-10 23:26:00 +08:00
4. All `/after/plugin` files are sourced (this includes `/after` from plugins)
2022-12-18 18:44:05 +08:00
Files from runtime directories are always sourced in alphabetical order.
2022-12-16 22:11:06 +08:00
2023-02-20 15:31:46 +08:00
STRUCTURING YOUR PLUGINS *lazy.nvim-lazy.nvim-structuring-your-plugins*
2022-12-20 04:06:18 +08:00
Some users may want to split their plugin specs in multiple files. Instead of
2022-12-23 14:51:44 +08:00
passing a spec table to `setup()`, you can use a Lua module. The specs from the
2022-12-25 21:31:44 +08:00
**module** and any top-level **sub-modules** will be merged together in the
final spec, so it is not needed to add `require` calls in your main plugin file
to the other files.
2022-12-20 04:06:18 +08:00
The benefits of using this approach:
2023-02-28 14:28:08 +08:00
- Simple to **add** new plugin specs. Just create a new file in your plugins module.
- Allows for **caching** of all your plugin specs. This becomes important if you have a lot of smaller plugin specs.
- Spec changes will automatically be **reloaded** when theyre updated, so the `:Lazy` UI is always up to date.
2022-12-20 04:06:18 +08:00
Example:
- `~/.config/nvim/init.lua`
>lua
require("lazy").setup("plugins")
<
2023-02-20 15:31:46 +08:00
- `~/.config/nvim/lua/plugins.lua` or `~/.config/nvim/lua/plugins/init.lua` **(this file is optional)**
2022-12-20 04:06:18 +08:00
>lua
return {
"folke/neodev.nvim",
2023-01-18 15:35:12 +08:00
"folke/which-key.nvim",
{ "folke/neoconf.nvim", cmd = "Neoconf" },
2022-12-20 04:06:18 +08:00
}
<
2023-09-27 18:40:28 +08:00
- Any lua file in `~/.config/nvim/lua/plugins/*.lua` will be automatically merged in the main plugin spec
2022-12-20 04:06:18 +08:00
2023-01-05 21:29:20 +08:00
For a real-life example, you can check LazyVim
2023-01-07 19:11:08 +08:00
<https://github.com/LazyVim/LazyVim> and more specifically:
2022-12-20 18:03:19 +08:00
2023-01-07 19:09:20 +08:00
- lazyvim.plugins <https://github.com/LazyVim/LazyVim/tree/main/lua/lazyvim/plugins> contains all the plugin specs that will be loaded
2022-12-20 18:03:19 +08:00
2022-12-20 17:56:46 +08:00
2023-02-20 15:31:46 +08:00
IMPORTING SPECS, CONFIG & OPTS ~
2023-01-08 22:02:50 +08:00
As part of a spec, you can add `import` statements to import additional plugin
modules. Both of the `setup()` calls are equivalent:
>lua
require("lazy").setup("plugins")
2023-02-28 14:28:08 +08:00
-- Same as:
2023-01-08 22:02:50 +08:00
require("lazy").setup({{import = "plugins"}})
<
2023-03-18 15:39:22 +08:00
To import multiple modules from a plugin, add additional specs for each import.
For example, to import LazyVim core plugins and an optional plugin:
>lua
require("lazy").setup({
spec = {
{ "LazyVim/LazyVim", import = "lazyvim.plugins" },
{ import = "lazyvim.plugins.extras.coding.copilot" },
}
2023-07-30 17:09:38 +08:00
})
2023-03-18 15:39:22 +08:00
<
2023-01-08 22:02:50 +08:00
When you import specs, you can override them by simply adding a spec for the
same plugin to your local specs, adding any keys you want to override / merge.
`opts`, `dependencies`, `cmd`, `event`, `ft` and `keys` are always merged with
the parent spec. Any other property will override the property from the parent
spec.
2022-11-29 22:42:57 +08:00
2023-02-20 15:31:46 +08:00
MIGRATION GUIDE *lazy.nvim-lazy.nvim-migration-guide*
PACKER.NVIM ~
2022-11-29 22:42:57 +08:00
2022-12-20 17:25:55 +08:00
- `setup` `init`
- `requires` `dependencies`
- `as` `name`
- `opt` `lazy`
- `run` `build`
- `lock` `pin`
2022-12-23 04:08:10 +08:00
- `disable=true` `enabled = false`
2023-09-27 18:40:28 +08:00
- `tag='*'` `version="*"`
2024-01-20 22:09:14 +08:00
- `after` is **not needed** for most use-cases. Use `dependencies` otherwise.
- `wants` is **not needed** for most use-cases. Use `dependencies` otherwise.
2022-12-29 15:03:28 +08:00
- `config` dont support string type, use `fun(LazyPlugin)` instead.
2022-12-20 17:25:55 +08:00
- `module` is auto-loaded. No need to specify
2022-12-23 19:27:29 +08:00
- `keys` spec is |lazy.nvim-different|
2022-12-31 07:14:42 +08:00
- `rtp` can be accomplished with:
2022-12-31 07:33:10 +08:00
>lua
config = function(plugin)
vim.opt.rtp:append(plugin.dir .. "/custom-rtp")
end
<
2022-12-20 17:25:55 +08:00
2022-12-24 02:52:21 +08:00
With packer `wants`, `requires` and `after` can be used to manage dependencies.
2023-02-28 14:28:08 +08:00
With lazy, this isnt needed for most of the Lua dependencies. They can be
2022-12-24 02:53:40 +08:00
installed just like normal plugins (even with `lazy=true`) and will be loaded
when other plugins need them. The `dependencies` key can be used to group those
required plugins with the one that requires them. The plugins which are added
as `dependencies` will always be lazy-loaded and loaded when the plugin is
loaded.
2022-12-24 02:52:21 +08:00
2023-02-20 15:31:46 +08:00
PAQ-NVIM ~
2022-12-20 17:25:55 +08:00
- `as` `name`
- `opt` `lazy`
- `run` `build`
2022-11-29 22:42:57 +08:00
2023-02-20 15:31:46 +08:00
UNINSTALLING *lazy.nvim-lazy.nvim-uninstalling*
2022-12-19 21:31:18 +08:00
To uninstall **lazy.nvim**, you need to remove the following files and
directories:
2023-02-20 15:31:46 +08:00
- **data**`~/.local/share/nvim/lazy`
- **state**`~/.local/state/nvim/lazy`
- **lockfile**`~/.config/nvim/lazy-lock.json`
2022-12-19 21:31:18 +08:00
2023-02-28 14:28:08 +08:00
Paths can differ if you changed `XDG` environment variables.
2022-12-19 21:31:18 +08:00
2023-02-20 15:31:46 +08:00
HIGHLIGHT GROUPS *lazy.nvim-lazy.nvim-highlight-groups*
Click to see all highlight groups ~
2024-05-26 22:44:42 +08:00
---------------------------------------------------------------------------------
Highlight Group Default Group Description
------------------- ------------------------ ------------------------------------
LazyButton CursorLine
2023-10-09 18:39:27 +08:00
2024-05-26 22:44:42 +08:00
LazyButtonActive Visual
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
LazyComment Comment
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
LazyCommit _@variable.builtin_ commitref
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
LazyCommitIssue Number
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
LazyCommitScope Italic conventional commit scope
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
LazyCommitType Title conventional commit type
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
LazyDimmed Conceal property
2022-12-19 21:31:18 +08:00
2024-05-26 22:44:42 +08:00
LazyDir _@markup.link_ directory
2023-03-06 14:41:03 +08:00
2024-05-26 22:44:42 +08:00
LazyH1 IncSearch homebutton
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
LazyH2 Bold titles
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
LazyLocal Constant
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
LazyNoCond DiagnosticWarn unloaded icon for a plugin where
cond() was false
2023-05-27 20:28:58 +08:00
2024-05-26 22:44:42 +08:00
LazyNormal NormalFloat
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
LazyProgressDone Constant progress bar done
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
LazyProgressTodo LineNr progress bar todo
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
LazyProp Conceal property
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
LazyReasonCmd Operator
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
LazyReasonEvent Constant
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
LazyReasonFt Character
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
LazyReasonImport Identifier
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
LazyReasonKeys Statement
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
LazyReasonPlugin Special
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
LazyReasonRequire _@variable.parameter_
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
LazyReasonRuntime _@macro_
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
LazyReasonSource Character
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
LazyReasonStart _@variable.member_
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
LazySpecial _@punctuation.special_
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
LazyTaskError ErrorMsg taskerrors
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
LazyTaskOutput MsgArea task output
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
LazyUrl _@markup.link_ url
2023-02-20 15:31:46 +08:00
2024-05-26 22:44:42 +08:00
LazyValue _@string_ valueof a property
---------------------------------------------------------------------------------
2023-02-20 15:31:46 +08:00
2023-07-01 00:29:13 +08:00
PLUGIN AUTHORS *lazy.nvim-lazy.nvim-plugin-authors*
If your plugin needs a build step, you can create a file `build.lua` or
`build/init.lua` in the root of your repo. This file will be loaded when the
plugin is installed or updated.
2024-01-20 22:09:14 +08:00
This makes it easier for users, as they no longer need to specify a `build`
2023-07-01 00:29:13 +08:00
command.
2023-02-20 15:31:46 +08:00
OTHER NEOVIM PLUGIN MANAGERS IN LUA*lazy.nvim-lazy.nvim-other-neovim-plugin-managers-in-lua*
2022-12-01 06:16:15 +08:00
2023-08-26 23:22:34 +08:00
- pckr.nvim <https://github.com/lewis6991/pckr.nvim>
2022-12-01 06:16:15 +08:00
- packer.nvim <https://github.com/wbthomason/packer.nvim>
- paq-nvim <https://github.com/savq/paq-nvim>
- neopm <https://github.com/ii14/neopm>
- dep <https://github.com/chiyadev/dep>
- optpack.nvim <https://github.com/notomo/optpack.nvim>
2022-12-04 00:47:26 +08:00
- pact.nvim <https://github.com/rktjmp/pact.nvim>
2022-12-01 06:16:15 +08:00
2023-02-20 15:31:46 +08:00
==============================================================================
2. Links *lazy.nvim-links*
1. *image*: https://user-images.githubusercontent.com/292349/208301737-68fb279c-ba70-43ef-a369-8c3e8367d6b1.png
2. *image*: https://user-images.githubusercontent.com/292349/208301766-5c400561-83c3-4811-9667-1ec4bb3c43b8.png
3. *image*: https://user-images.githubusercontent.com/292349/208301790-7eedbfa5-d202-4e70-852e-de68aa47233b.png
2022-12-01 06:16:15 +08:00
2022-11-29 22:42:57 +08:00
Generated by panvimdoc <https://github.com/kdheepak/panvimdoc>
vim:tw=78:ts=8:noet:ft=help:norl: