LazyVim

https://www.lazyvim.org/
Admin
LazyVim is a Neovim setup powered by lazy.nvim, designed to transform Neovim into a full-fledged,...
Tokens:251,230
Snippets:1,281
Trust Score:9.1
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### LazyVim configuration example

Source: https://www.lazyvim.org/configuration/examples

Example LazyVim configuration snippet showing how to add custom lualine config, import extras like mini-starter and json, and ensure tools are installed via mason.nvim.

```lua
--[[add your custom lualine config here]]  
}  
end,  
},  

-- use mini.starter instead of alpha  
{ import = "lazyvim.plugins.extras.ui.mini-starter" },  

-- add jsonls and schemastore packages, and setup treesitter for json, json5 and jsonc  
{ import = "lazyvim.plugins.extras.lang.json" },  

-- add any tools you want to have installed below  
{  
  "williamboman/mason.nvim",  
  opts = {  
    ensure_installed = {  
      "stylua",  
      "shellcheck",  
      "shfmt",  
      "flake8",  
    },  
  },  
},  
}  
```

--------------------------------

### Start Neovim (Linux/MacOS)

Source: https://www.lazyvim.org/installation

Starts Neovim with the LazyVim starter configuration.

```bash
nvim  

```

--------------------------------

### Return fzf-lua setup options

Source: https://www.lazyvim.org/extras/editor/fzf

Returns the fzf-lua setup options table: enables fzf_colors, disables scrollbar, uses dirname_first formatter, configures image previewers for common formats, customizes vim.ui.select with a centered title and codeaction-specific layout, sets window size/position, and adds toggle_ignore/toggle_hidden actions for files and grep. Also configures LSP symbol highlighting and code action previewer (uses codeaction_native when delta is installed).

```lua
return {
  "default-title",
  fzf_colors = true,
  fzf_opts = {
    ["--no-scrollbar"] = true,
  },
  defaults = {
    -- formatter = "path.filename_first",
    formatter = "path.dirname_first",
  },
  previewers = {
    builtin = {
      extensions = {
        ["png"] = img_previewer,
        ["jpg"] = img_previewer,
        ["jpeg"] = img_previewer,
        ["gif"] = img_previewer,
        ["webp"] = img_previewer,
      },
      ueberzug_scaler = "fit_contain",
    },
  },
  -- Custom LazyVim option to configure vim.ui.select
  ui_select = function(fzf_opts, items)
    return vim.tbl_deep_extend("force", fzf_opts, {
      prompt = " ",
      winopts = {
        title = " " .. vim.trim((fzf_opts.prompt or "Select"):gsub("%s*:%s*$", "")) .. " ",
        title_pos = "center",
      },
    }, fzf_opts.kind == "codeaction" and {
      winopts = {
        layout = "vertical",
        -- height is number of items minus 15 lines for the preview, with a max of 80% screen height
        height = math.floor(math.min(vim.o.lines * 0.8 - 16, #items + 4) + 0.5) + 16,
        width = 0.5,
        preview = not vim.tbl_isempty(vim.lsp.get_clients({ bufnr = 0, name = "vtsls" })) and {
          layout = "vertical",
          vertical = "down:15,border-top",
          hidden = "hidden",
        } or {
          layout = "vertical",
          vertical = "down:15,border-top",
        },
      },
    } or {
      winopts = {
        width = 0.5,
        -- height is number of items, with a max of 80% screen height
        height = math.floor(math.min(vim.o.lines * 0.8, #items + 4) + 0.5),
      },
    })
  end,
  winopts = {
    width = 0.8,
    height = 0.8,
    row = 0.5,
    col = 0.5,
    preview = {
      scrollchars = { "┃", "" },
    },
  },
  files = {
    cwd_prompt = false,
    actions = {
      ["alt-i"] = { actions.toggle_ignore },
      ["alt-h"] = { actions.toggle_hidden },
    },
  },
  grep = {
    actions = {
      ["alt-i"] = { actions.toggle_ignore },
      ["alt-h"] = { actions.toggle_hidden },
    },
  },
  lsp = {
    symbols = {
      symbol_hl = function(s)
        return "TroubleIcon" .. s
      end,
      symbol_fmt = function(s)
        return s:lower() .. "\t"
      end,
      child_prefix = false,
    },
    code_actions = {
      previewer = vim.fn.executable("delta") == 1 and "codeaction_native" or nil,
    },
  },
}
```

--------------------------------

### Try LazyVim with Docker

Source: https://www.lazyvim.org/installation

Runs LazyVim in a Docker container using a Fedora image. Installs required dependencies, clones the starter, and starts Neovim.

```bash
docker run -w /root -it --rm fedora:latest sh -uelic '  
  dnf copr enable -y dejan/lazygit  
  dnf install -y git lazygit fd-find curl ripgrep tree-sitter-cli neovim  
  git clone https://github.com/LazyVim/starter ~/.config/nvim  
  cd ~/.config/nvim  
  nvim  
'  

```

--------------------------------

### nvim-lspconfig: Configure jdtls server (Options)

Source: https://www.lazyvim.org/extras/lang/java

Options for the nvim-lspconfig plugin to configure the jdtls server. It ensures mason installs the server and avoids duplicate servers by returning true in the setup function.

```lua
opts = {  
  -- make sure mason installs the server  
  servers = {  
    jdtls = {},  
  },  
  setup = {  
    jdtls = function()  
      return true -- avoid duplicate servers  
    end,  
  },  
}  
```

--------------------------------

### mason.nvim: Install Java debug adapter and test (Options)

Source: https://www.lazyvim.org/extras/lang/java

Options for the mason.nvim plugin to ensure java-debug-adapter and java-test are installed. This is the 'Options' tab of the mason.nvim section.

```lua
opts = { ensure_installed = { "java-debug-adapter", "java-test" } }  
```

--------------------------------

### Configure nvim-lspconfig with keymaps and lua_ls settings

Source: https://www.lazyvim.org/plugins/lsp

LazyVim LSP configuration for nvim-lspconfig, including keymaps for common LSP actions, lua_ls settings, and a setup hook for additional server configuration. The keymaps use `has` conditions to only enable when the server supports the capability. The `lua_ls` settings configure workspace, codeLens, completion, doc, and hint options. The `setup` table allows per-server overrides, with a commented example for typescript.nvim.

```lua
didRename = true,  
willRename = true,  
},  
},  
},  
-- stylua: ignore  
keys = {  
  { "<leader>cl", function() Snacks.picker.lsp_config() end, desc = "Lsp Info" },  
  { "gd", vim.lsp.buf.definition, desc = "Goto Definition", has = "definition" },  
  { "gr", vim.lsp.buf.references, desc = "References", nowait = true },  
  { "gI", vim.lsp.buf.implementation, desc = "Goto Implementation" },  
  { "gy", vim.lsp.buf.type_definition, desc = "Goto T[y]pe Definition" },  
  { "gD", vim.lsp.buf.declaration, desc = "Goto Declaration" },  
  { "K", function() return vim.lsp.buf.hover() end, desc = "Hover" },  
  { "gK", function() return vim.lsp.buf.signature_help() end, desc = "Signature Help", has = "signatureHelp" },  
  { "<c-k>", function() return vim.lsp.buf.signature_help() end, mode = "i", desc = "Signature Help", has = "signatureHelp" },  
  { "<leader>ca", vim.lsp.buf.code_action, desc = "Code Action", mode = { "n", "x" }, has = "codeAction" },  
  { "<leader>cc", vim.lsp.codelens.run, desc = "Run Codelens", mode = { "n", "x" }, has = "codeLens" },  
  { "<leader>cC", vim.lsp.codelens.refresh, desc = "Refresh & Display Codelens", mode = { "n" }, has = "codeLens" },  
  { "<leader>cR", function() Snacks.rename.rename_file() end, desc = "Rename File", mode ={"n"}, has = { "workspace/didRenameFiles", "workspace/willRenameFiles" } },  
  { "<leader>cr", vim.lsp.buf.rename, desc = "Rename", has = "rename" },  
  { "<leader>cA", LazyVim.lsp.action.source, desc = "Source Action", has = "codeAction" },  
  { "]]", function() Snacks.words.jump(vim.v.count1) end, has = "documentHighlight",  
    desc = "Next Reference", enabled = function() return Snacks.words.is_enabled() end },  
  { "[[", function() Snacks.words.jump(-vim.v.count1) end, has = "documentHighlight",  
    desc = "Prev Reference", enabled = function() return Snacks.words.is_enabled() end },  
  { "<a-n>", function() Snacks.words.jump(vim.v.count1, true) end, has = "documentHighlight",  
    desc = "Next Reference", enabled = function() return Snacks.words.is_enabled() end },  
  { "<a-p>", function() Snacks.words.jump(-vim.v.count1, true) end, has = "documentHighlight",  
    desc = "Prev Reference", enabled = function() return Snacks.words.is_enabled() end },  
  {  
    "<leader>co",  
    LazyVim.lsp.action["source.organizeImports"],  
    desc = "Organize Imports",  
    has = "codeAction",  
    enabled = function(buf)  
      local code_actions = vim.tbl_filter(function(action)  
        return action:find("^source%.organizeImports%.?$")  
      end, LazyVim.lsp.code_actions({ bufnr = buf }))  
      return #code_actions > 0  
    end  
  },  
},  
},  
stylua = { enabled = false },  
lua_ls = {  
  -- mason = false, -- set to false if you don't want this server to be installed with mason  
  -- Use this to add any additional keymaps  
  -- for specific lsp servers  
  -- ---@type LazyKeysSpec[]  
  -- keys = {},  
  settings = {  
    Lua = {  
      workspace = {  
        checkThirdParty = false,  
      },  
      codeLens = {  
        enable = true,  
      },  
      completion = {  
        callSnippet = "Replace",  
      },  
      doc = {  
        privateName = { "^_" },  
      },  
      hint = {  
        enable = true,  
        setType = false,  
        paramType = true,  
        paramName = "Disable",  
        semicolon = "Disable",  
        arrayIndex = "Disable",  
      },  
    },  
  },  
},  
},  
-- you can do any additional lsp server setup here  
-- return true if you don't want this server to be setup with lspconfig  
---@type table<string, fun(server:string, opts: vim.lsp.Config):boolean?>  
setup = {  
  -- example to setup with typescript.nvim  
  -- tsserver = function(_, opts)  
  --   require("typescript").setup({ server = opts })  
  --   return true  
  -- end,  
  -- Specify * to use this function as a fallback for any server  
  -- ["*"] = function(server, opts) end,  
},  
}  
return ret  
end,  
---@param opts PluginLspOpts  
config = function(_, opts)  
  -- setup autoformat  
  LazyVim.format.register(LazyVim.lsp.formatter())  
  
  -- setup keymaps  
```

--------------------------------

### Install oxfmt formatter with mason.nvim

Source: https://www.lazyvim.org/extras/lang/typescript/oxc

Install the oxfmt formatter via mason.nvim by adding it to the ensure_installed list. The full spec includes the plugin name and the opts table.

```lua
opts = { ensure_installed = { "oxfmt" } }  
```

```lua
{  
  "mason-org/mason.nvim",  
  opts = { ensure_installed = { "oxfmt" } },  
}  
```

--------------------------------

### mason.nvim: ensure_installed haskell-language-server (Options)

Source: https://www.lazyvim.org/extras/lang/haskell

Minimal options to install haskell-language-server via mason.nvim.

```lua
opts = { ensure_installed = { "haskell-language-server" } }
```

--------------------------------

### mason.nvim: Install golangci-lint

Source: https://www.lazyvim.org/extras/lang/go

Configures mason.nvim to ensure the Go linter golangci-lint is installed. The first block is the opts table; the second is the full plugin spec.

```lua
opts = { ensure_installed = { "golangci-lint" } }  
```

```lua
{  
  "mason-org/mason.nvim",  
  opts = { ensure_installed = { "golangci-lint" } },  
}  
```

--------------------------------

### mason.nvim ensure_installed options

Source: https://www.lazyvim.org/plugins/lsp

Options for mason.nvim to ensure stylua and shfmt are installed.

```lua
opts = {
  ensure_installed = {
    "stylua",
    "shfmt",
  },
}
```

--------------------------------

### mason.nvim: ensure_installed haskell-debug-adapter (Options)

Source: https://www.lazyvim.org/extras/lang/haskell

Minimal options to install haskell-debug-adapter via mason.nvim.

```lua
opts = { ensure_installed = { "haskell-debug-adapter" } }
```

--------------------------------

### Install codelldb and bacon via mason.nvim for Rust

Source: https://www.lazyvim.org/extras/lang/rust

Ensures the Rust debugger (codelldb) is installed via mason.nvim. The Options block shows the opts function; the Full Spec block wraps it in a plugin specification for mason-org/mason.nvim, marked optional. When diagnostics == "bacon-ls", it also installs bacon.

```lua
opts = function(_, opts)  
  opts.ensure_installed = opts.ensure_installed or {}  
  vim.list_extend(opts.ensure_installed, { "codelldb" })  
  if diagnostics == "bacon-ls" then  
    vim.list_extend(opts.ensure_installed, { "bacon" })  
  end  
end  

```

```lua
{  
  "mason-org/mason.nvim",  
  optional = true,  
  opts = function(_, opts)  
    opts.ensure_installed = opts.ensure_installed or {}  
    vim.list_extend(opts.ensure_installed, { "codelldb" })  
    if diagnostics == "bacon-ls" then  
      vim.list_extend(opts.ensure_installed, { "bacon" })  
    end  
  end,  
}  

```

--------------------------------

### mason.nvim: ensure_installed haskell-language-server (Full Spec)

Source: https://www.lazyvim.org/extras/lang/haskell

Full spec for mason.nvim to install haskell-language-server.

```lua
{
  "mason-org/mason.nvim",
  opts = { ensure_installed = { "haskell-language-server" } },
}
```

--------------------------------

### mason.nvim: ensure ktlint installed

Source: https://www.lazyvim.org/extras/lang/kotlin

Configures mason.nvim to install the ktlint package for Kotlin linting. The first block shows the minimal options table, and the second shows the full plugin spec with the plugin name and opts.

```lua
opts = { ensure_installed = { "ktlint" } }  
```

```lua
{  
  "mason-org/mason.nvim",  
  opts = { ensure_installed = { "ktlint" } },  
}  
```

--------------------------------

### Configure mini.starter with custom logo and menu items

Source: https://www.lazyvim.org/extras/ui/mini-starter

LazyVim configuration for the mini.starter plugin. Sets up a custom startup screen with a logo, menu items (find file, recent files, etc.), and content hooks. Includes logic to close Lazy and reopen it when the starter is ready, and updates the footer with plugin load stats after LazyVim starts.

```lua
{  
  "nvim-mini/mini.starter",  
  version = false, -- wait till new 0.7.0 release to put it back on semver  
  event = "VimEnter",  
  opts = function()  
    local logo = table.concat({  
      "            ██╗      █████╗ ███████╗██╗   ██╗██╗   ██╗██╗███╗   ███╗          Z",  
      "            ██║     ██╔══██╗╚══███╔╝╚██╗ ██╔╝██║   ██║██║████╗ ████║      Z    ",  
      "            ██║     ███████║  ███╔╝  ╚████╔╝ ██║   ██║██║██╔████╔██║   z       ",  
      "            ██║     ██╔══██║ ███╔╝    ╚██╔╝  ╚██╗ ██╔╝██║██║╚██╔╝██║ z         ",  
      "            ███████╗██║  ██║███████╗   ██║    ╚████╔╝ ██║██║ ╚═╝ ██║           ",  
      "            ╚══════╝╚═╝  ╚═╝╚══════╝   ╚═╝     ╚═══╝  ╚═╝╚═╝     ╚═╝           ",  
    }, "\n")  
    local pad = string.rep(" ", 22)  
    local new_section = function(name, action, section)  
      return { name = name, action = action, section = pad .. section }  
    end  
  
    local starter = require("mini.starter")  
    --stylua: ignore  
    local config = {  
      evaluate_single = true,  
      header = logo,  
      items = {  
        new_section("Find file",       LazyVim.pick(),                        "Telescope"),  
        new_section("New file",        "ene | startinsert",                   "Built-in"),  
        new_section("Recent files",    LazyVim.pick("oldfiles"),              "Telescope"),  
        new_section("Find text",       LazyVim.pick("live_grep"),             "Telescope"),  
        new_section("Config",          LazyVim.pick.config_files(),           "Config"),  
        new_section("Restore session", [[lua require("persistence").load()]], "Session"),  
        new_section("Lazy Extras",     "LazyExtras",                          "Config"),  
        new_section("Lazy",            "Lazy",                                "Config"),  
        new_section("Quit",            "qa",                                  "Built-in"),  
      },  
      content_hooks = {  
        starter.gen_hook.adding_bullet(pad .. "░ ", false),  
        starter.gen_hook.aligning("center", "center"),  
      },  
    }  
    return config  
  end,  
  config = function(_, config)  
    -- close Lazy and re-open when starter is ready  
    if vim.o.filetype == "lazy" then  
      vim.cmd.close()  
      vim.api.nvim_create_autocmd("User", {  
        pattern = "MiniStarterOpened",  
        callback = function()  
          require("lazy").show()  
        end,  
      })  
    end  
  
    local starter = require("mini.starter")  
    starter.setup(config)  
  
    vim.api.nvim_create_autocmd("User", {  
      pattern = "LazyVimStarted",  
      callback = function(ev)  
        local stats = require("lazy").stats()  
        local ms = (math.floor(stats.startuptime * 100 + 0.5) / 100)  
        local pad_footer = string.rep(" ", 8)  
        starter.config.footer = pad_footer .. "⚡ Neovim loaded " .. stats.count .. " plugins in " .. ms .. "ms"  
        -- INFO: based on @nvim-mini's recommendation (thanks a lot!!!)  
        if vim.bo[ev.buf].filetype == "ministarter" then  
          pcall(starter.refresh)  
        end  
      end,  
    })  
  end,  
}  

```

--------------------------------

### Configure mini.starter options

Source: https://www.lazyvim.org/extras/ui/mini-starter

Options function that configures mini.starter with a custom logo, item sections, and content hooks. It sets evaluate_single to true and uses LazyVim.pick for common actions.

```lua
opts = function()  
  local logo = table.concat({  
    "            ██╗      █████╗ ███████╗██╗   ██╗██╗   ██╗██╗███╗   ███╗          Z",  
    "            ██║     ██╔══██╗╚══███╔╝╚██╗ ██╔╝██║   ██║██║████╗ ████║      Z    ",  
    "            ██║     ███████║  ███╔╝  ╚████╔╝ ██║   ██║██║██╔████╔██║   z       ",  
    "            ██║     ██╔══██║ ███╔╝    ╚██╔╝  ╚██╗ ██╔╝██║██║╚██╔╝██║ z         ",  
    "            ███████╗██║  ██║███████╗   ██║    ╚████╔╝ ██║██║ ╚═╝ ██║           ",  
    "            ╚══════╝╚═╝  ╚═╝╚══════╝   ╚═╝     ╚═══╝  ╚═╝╚═╝     ╚═╝           ",  
  }, "\n")  
  local pad = string.rep(" ", 22)  
  local new_section = function(name, action, section)  
    return { name = name, action = action, section = pad .. section }  
  end  
  
  local starter = require("mini.starter")  
  --stylua: ignore  
  local config = {  
    evaluate_single = true,  
    header = logo,  
    items = {  
      new_section("Find file",       LazyVim.pick(),                        "Telescope"),  
      new_section("New file",        "ene | startinsert",                   "Built-in"),  
      new_section("Recent files",    LazyVim.pick("oldfiles"),              "Telescope"),  
      new_section("Find text",       LazyVim.pick("live_grep"),             "Telescope"),  
      new_section("Config",          LazyVim.pick.config_files(),           "Config"),  
      new_section("Restore session", [[lua require("persistence").load()]], "Session"),  
      new_section("Lazy Extras",     "LazyExtras",                          "Config"),  
      new_section("Lazy",            "Lazy",                                "Config"),  
      new_section("Quit",            "qa",                                  "Built-in"),  
    },  
    content_hooks = {  
      starter.gen_hook.adding_bullet(pad .. "░ ", false),  
      starter.gen_hook.aligning("center", "center"),  
    },  
  }  
  return config  
end  
```

--------------------------------

### Add a plugin (lua/plugins/lsp.lua)

Source: https://www.lazyvim.org/configuration/plugins

Add a new plugin by placing its spec in a file under lua/plugins/*.lua. This example adds symbols-outline with a command, a keymap, and custom options passed to setup().

```lua
return {  
  -- add symbols-outline  
  {  
    "simrat39/symbols-outline.nvim",  
    cmd = "SymbolsOutline",  
    keys = { { "<leader>cs", "<cmd>SymbolsOutline<cr>", desc = "Symbols Outline" } },  
    opts = {  
      -- add your options that should be passed to the setup() function here  
      position = "right",  
    },  
  },  
}  

```

--------------------------------

### nvim-treesitter Zig parser setup

Source: https://www.lazyvim.org/extras/lang/zig

Configures nvim-treesitter to install the Zig parser. The first block shows the minimal opts table; the second shows the full plugin spec with the same opts.

```lua
opts = { ensure_installed = { "zig" } }  
```

```lua
{  
  "nvim-treesitter/nvim-treesitter",  
  opts = { ensure_installed = { "zig" } },  
}  
```

--------------------------------

### nvim-treesitter Prisma parser setup

Source: https://www.lazyvim.org/extras/lang/prisma

Configures nvim-treesitter to install the Prisma parser. The first block shows the minimal opts table; the second shows the full plugin spec with the plugin name.

```lua
opts = {  
  ensure_installed = { "prisma" },  
}  
```

```lua
{  
  "nvim-treesitter/nvim-treesitter",  
  opts = {  
    ensure_installed = { "prisma" },  
  },  
}  
```

--------------------------------

### LazyVim plugin configuration example

Source: https://www.lazyvim.org/configuration/examples

Example LazyVim plugin configuration file showing how to add, disable, and override plugins. It demonstrates adding gruvbox, changing trouble options, disabling trouble, extending nvim-cmp with cmp-emoji, customizing telescope keymaps and options, adding pyright and tsserver to lspconfig, importing the typescript extra, adding treesitter parsers, and modifying lualine sections. Note that the final lualine opts function is incomplete in the source.

```lua
-- every spec file under the "plugins" directory will be loaded automatically by lazy.nvim  
--  
-- In your plugin files, you can:  
-- * add extra plugins  
-- * disable/enabled LazyVim plugins  
-- * override the configuration of LazyVim plugins  
return {  
  -- add gruvbox  
  { "ellisonleao/gruvbox.nvim" },  
  
  -- Configure LazyVim to load gruvbox  
  {  
    "LazyVim/LazyVim",  
    opts = {  
      colorscheme = "gruvbox",  
    },  
  },  
  
  -- change trouble config  
  {  
    "folke/trouble.nvim",  
    -- opts will be merged with the parent spec  
    opts = { use_diagnostic_signs = true },  
  },  
  
  -- disable trouble  
  { "folke/trouble.nvim", enabled = false },  
  
  -- override nvim-cmp and add cmp-emoji  
  {  
    "hrsh7th/nvim-cmp",  
    dependencies = { "hrsh7th/cmp-emoji" },  
    ---@param opts cmp.ConfigSchema  
    opts = function(_, opts)  
      table.insert(opts.sources, { name = "emoji" })  
    end,  
  },  
  
  -- change some telescope options and a keymap to browse plugin files  
  {  
    "nvim-telescope/telescope.nvim",  
    keys = {  
      -- add a keymap to browse plugin files  
      -- stylua: ignore  
      {  
        "<leader>fp",  
        function() require("telescope.builtin").find_files({ cwd = require("lazy.core.config").options.root }) end,  
        desc = "Find Plugin File",  
      },  
    },  
    -- change some options  
    opts = {  
      defaults = {  
        layout_strategy = "horizontal",  
        layout_config = { prompt_position = "top" },  
        sorting_strategy = "ascending",  
        winblend = 0,  
      },  
    },  
  },  
  
  -- add pyright to lspconfig  
  {  
    "neovim/nvim-lspconfig",  
    ---@class PluginLspOpts  
    opts = {  
      ---@type lspconfig.options  
      servers = {  
        -- pyright will be automatically installed with mason and loaded with lspconfig  
        pyright = {},  
      },  
    },  
  },  
  
  -- add tsserver and setup with typescript.nvim instead of lspconfig  
  {  
    "neovim/nvim-lspconfig",  
    dependencies = {  
      "jose-elias-alvarez/typescript.nvim",  
      init = function()  
        require("lazyvim.util").lsp.on_attach(function(_, buffer)  
          -- stylua: ignore  
          vim.keymap.set( "n", "<leader>co", "TypescriptOrganizeImports", { buffer = buffer, desc = "Organize Imports" })  
          vim.keymap.set("n", "<leader>cR", "TypescriptRenameFile", { desc = "Rename File", buffer = buffer })  
        end)  
      end,  
    },  
    ---@class PluginLspOpts  
    opts = {  
      ---@type lspconfig.options  
      servers = {  
        -- tsserver will be automatically installed with mason and loaded with lspconfig  
        tsserver = {},  
      },  
      -- you can do any additional lsp server setup here  
      -- return true if you don't want this server to be setup with lspconfig  
      ---@type table<string, fun(server:string, opts:_.lspconfig.options):boolean?>  
      setup = {  
        -- example to setup with typescript.nvim  
        tsserver = function(_, opts)  
          require("typescript").setup({ server = opts })  
          return true  
        end,  
        -- Specify * to use this function as a fallback for any server  
        -- ["*"] = function(server, opts) end,  
      },  
    },  
  },  
  
  -- for typescript, LazyVim also includes extra specs to properly setup lspconfig,  
  -- treesitter, mason and typescript.nvim. So instead of the above, you can use:  
  { import = "lazyvim.plugins.extras.lang.typescript" },  
  
  -- add more treesitter parsers  
  {  
    "nvim-treesitter/nvim-treesitter",  
    opts = {  
      ensure_installed = {  
        "bash",  
        "html",  
        "javascript",  
        "json",  
        "lua",  
        "markdown",  
        "markdown_inline",  
        "python",  
        "query",  
        "regex",  
        "tsx",  
        "typescript",  
        "vim",  
        "yaml",  
      },  
    },  
  },  
  
  -- since `vim.tbl_deep_extend`, can only merge tables and not lists, the code above  
  -- would overwrite `ensure_installed` with the new value.  
  -- If you'd rather extend the default config, use the code below instead:  
  {  
    "nvim-treesitter/nvim-treesitter",  
    opts = function(_, opts)  
      -- add tsx and treesitter  
      vim.list_extend(opts.ensure_installed, {  
        "tsx",  
        "typescript",  
      })  
    end,  
  },  
  
  -- the opts function can also be used to change the default opts:  
  {  
    "nvim-lualine/lualine.nvim",  
    event = "VeryLazy",  
    opts = function(_, opts)  
      table.insert(opts.sections.lualine_x, {  
        function()  
          return "😄"  
        end,  
      })  
    end,  
  },  
  
  -- or you can return new options to override all the defaults  
  {  
    "nvim-lualine/lualine.nvim",  
    event = "VeryLazy",  
    opts = function()  
      return {  

```

--------------------------------

### nvim-treesitter Angular and SCSS support

Source: https://www.lazyvim.org/extras/lang/angular

Configures nvim-treesitter to install 'angular' and 'scss' parsers and starts the Angular parser for .component.html and .container.html files. The first block is the options table; the second is the full plugin spec.

```lua
opts = function(_, opts)  
  if type(opts.ensure_installed) == "table" then  
    vim.list_extend(opts.ensure_installed, { "angular", "scss" })  
  end  
  vim.api.nvim_create_autocmd({ "BufReadPost", "BufNewFile" }, {  
    pattern = { "*.component.html", "*.container.html" },  
    callback = function()  
      vim.treesitter.start(nil, "angular")  
    end,  
  })  
end  

```

```lua
{  
  "nvim-treesitter",  
  opts = function(_, opts)  
    if type(opts.ensure_installed) == "table" then  
      vim.list_extend(opts.ensure_installed, { "angular", "scss" })  
    end  
    vim.api.nvim_create_autocmd({ "BufReadPost", "BufNewFile" }, {  
      pattern = { "*.component.html", "*.container.html" },  
      callback = function()  
        vim.treesitter.start(nil, "angular")  
      end,  
    })  
  end,  
}  

```

--------------------------------

### Configure persistence.nvim with session keymaps

Source: https://www.lazyvim.org/plugins/util

Set up persistence.nvim for session management. The first block shows the empty opts table; the second shows the full plugin spec with keymaps to load, select, restore last, and stop saving sessions.

```lua
opts = {}  
```

```lua
{  
  "folke/persistence.nvim",  
  event = "BufReadPre",  
  opts = {},  
  -- stylua: ignore  
  keys = {  
    { "<leader>qs", function() require("persistence").load() end, desc = "Restore Session" },  
    { "<leader>qS", function() require("persistence").select() end,desc = "Select Session" },  
    { "<leader>ql", function() require("persistence").load({ last = true }) end, desc = "Restore Last Session" },  
    { "<leader>qd", function() require("persistence").stop() end, desc = "Don't Save Current Session" },  
  },  
}  
```

--------------------------------

### nvim-lspconfig: Configure jdtls server (Full Spec)

Source: https://www.lazyvim.org/extras/lang/java

Full spec for the nvim-lspconfig plugin to configure the jdtls server. It ensures mason installs the server and avoids duplicate servers by returning true in the setup function.

```lua
{  
  "neovim/nvim-lspconfig",  
  opts = {  
    -- make sure mason installs the server  
    servers = {  
      jdtls = {},  
    },  
    setup = {  
      jdtls = function()  
        return true -- avoid duplicate servers  
      end,  
    },  
  },  
}  
```

--------------------------------

### mason-nvim-dap.nvim options

Source: https://www.lazyvim.org/extras/dap/core

Options for mason-nvim-dap.nvim. Enables automatic installation of debuggers and provides handlers and ensure_installed lists.

```lua
opts = {  
  -- Makes a best effort to setup the various debuggers with  
  -- reasonable debug configurations  
  automatic_installation = true,  
  
  -- You can provide additional configuration to the handlers,  
  -- see mason-nvim-dap README for more information  
  handlers = {},  
  
  -- You'll need to check that you have the required things installed  
  -- online, please don't ask me how to install them :)  
  ensure_installed = {  
    -- Update this to ensure that you have the debuggers for the langs you want  
  },  
}  
```

--------------------------------

### Configure nvim-dap for Haskell debugging

Source: https://www.lazyvim.org/extras/lang/haskell

Optional nvim-dap setup for Haskell debugging. The Options form sets opts to nil; the Full Spec form marks nvim-dap optional and installs the haskell-debug-adapter via mason.nvim.

```lua
opts = nil  

```

```lua
{  
  "mfussenegger/nvim-dap",  
  optional = true,  
  dependencies = {  
    {  
      "mason-org/mason.nvim",  
      opts = { ensure_installed = { "haskell-debug-adapter" } },  
    },  
  },  
}  

```

--------------------------------

### nvim-treesitter Glimmer parser setup

Source: https://www.lazyvim.org/extras/lang/ember

Configures nvim-treesitter to install parsers for CSS and Glimmer (including JavaScript and TypeScript variants). The first block shows the opts table; the second shows the full plugin spec.

```lua
opts = { ensure_installed = { "css", "glimmer", "glimmer_javascript", "glimmer_typescript" } }  
```

```lua
{  
  "nvim-treesitter/nvim-treesitter",  
  opts = { ensure_installed = { "css", "glimmer", "glimmer_javascript", "glimmer_typescript" } },  
}  
```

--------------------------------

### Add Projects item to mini.starter with Snacks.picker.projects

Source: https://www.lazyvim.org/extras/editor/snacks_picker

Optional configuration for nvim-mini/mini.starter. The first block shows the opts function that adds a Projects item invoking Snacks.picker.projects(). The second block is the full spec that applies the same opts function and extends the starter items with the new entry.

```lua
opts = function(_, opts)  
  local items = {  
    {  
      name = "Projects",  
      action = [[lua Snacks.picker.projects()]],  
      section = string.rep(" ", 22) .. "Telescope",  
    },  
  }  
  vim.list_extend(opts.items, items)  
end  
```

```lua
{  
  "nvim-mini/mini.starter",  
  optional = true,  
  opts = function(_, opts)  
    local items = {  
      {  
        name = "Projects",  
        action = [[lua Snacks.picker.projects()]],  
        section = string.rep(" ", 22) .. "Telescope",  
      },  
    }  
    vim.list_extend(opts.items, items)  
  end,  
}  
```

--------------------------------

### Configure jsonls with nvim-lspconfig

Source: https://www.lazyvim.org/extras/lang/json

Sets up nvim-lspconfig for jsonls, ensuring mason installs the server and lazy-loading schemastore via before_init. The first block shows the opts table; the second shows the full plugin spec for neovim/nvim-lspconfig.

```lua
opts = {  
  -- make sure mason installs the server  
  servers = {  
    jsonls = {  
      -- lazy-load schemastore when needed  
      before_init = function(_, new_config)  
        new_config.settings.json.schemas = new_config.settings.json.schemas or {}  
        vim.list_extend(new_config.settings.json.schemas, require("schemastore").json.schemas())  
      end,  
      settings = {  
        json = {  
          format = {  
            enable = true,  
          },  
          validate = { enable = true },  
        },  
      },  
    },  
  },  
}  
```

```lua
{  
  "neovim/nvim-lspconfig",  
  opts = {  
    -- make sure mason installs the server  
    servers = {  
      jsonls = {  
        -- lazy-load schemastore when needed  
        before_init = function(_, new_config)  
          new_config.settings.json.schemas = new_config.settings.json.schemas or {}  
          vim.list_extend(new_config.settings.json.schemas, require("schemastore").json.schemas())  
        end,  
        settings = {  
          json = {  
            format = {  
              enable = true,  
            },  
            validate = { enable = true },  
          },  
        },  
      },  
    },  
  },  
}  
```

--------------------------------

### Lazy.nvim spec for gitsigns.nvim with event and opts

Source: https://www.lazyvim.org/plugins/editor

Full Lazy.nvim plugin spec for gitsigns.nvim, loading on LazyFile event and passing the same opts table as the standalone example. Includes custom signs, staged signs, and the on_attach keymap setup.

```lua
{  
  "lewis6991/gitsigns.nvim",  
  event = "LazyFile",  
  opts = {  
    signs = {  
      add = { text = "▎" },  
      change = { text = "▎" },  
      delete = { text = "" },  
      topdelete = { text = "" },  
      changedelete = { text = "▎" },  
      untracked = { text = "▎" },  
    },  
    signs_staged = {  
      add = { text = "▎" },  
      change = { text = "▎" },  
      delete = { text = "" },  
      topdelete = { text = "" },  
      changedelete = { text = "▎" },  
    },  
    on_attach = function(buffer)  
      local gs = package.loaded.gitsigns  
  
      local function map(mode, l, r, desc)  
        vim.keymap.set(mode, l, r, { buffer = buffer, desc = desc, silent = true })  
      end  
  
      -- stylua: ignore start  
      map("n", "]h", function()  
        if vim.wo.diff then  
          vim.cmd.normal({ "]c", bang = true })  
        else  
          gs.nav_hunk("next")  
        end  
      end, "Next Hunk")  
      map("n", "[h", function()  
        if vim.wo.diff then  
          vim.cmd.normal({ "[c", bang = true })  
        else  
          gs.nav_hunk("prev")  
        end  
      end, "Prev Hunk")  
      map("n", "]H", function() gs.nav_hunk("last") end, "Last Hunk")  
      map("n", "[H", function() gs.nav_hunk("first") end, "First Hunk")  
      map({ "n", "x" }, "<leader>ghs", ":Gitsigns stage_hunk<CR>", "Stage Hunk")  
      map({ "n", "x" }, "<leader>ghr", ":Gitsigns reset_hunk<CR>", "Reset Hunk")  
      map("n", "<leader>ghS", gs.stage_buffer, "Stage Buffer")  
      map("n", "<leader>ghu", gs.undo_stage_hunk, "Undo Stage Hunk")  
      map("n", "<leader>ghR", gs.reset_buffer, "Reset Buffer")  
      map("n", "<leader>ghp", gs.preview_hunk_inline, "Preview Hunk Inline")  
      map("n", "<leader>ghb", function() gs.blame_line({ full = true }) end, "Blame Line")  
      map("n", "<leader>ghB", function() gs.blame() end, "Blame Buffer")  
      map("n", "<leader>ghd", gs.diffthis, "Diff This")  
      map("n", "<leader>ghD", function() gs.diffthis("~") end, "Diff This ~")  
      map({ "o", "x" }, "ih", ":<C-U>Gitsigns select_hunk<CR>", "GitSigns Select Hunk")  
    end,  
  },  
}  
```

--------------------------------

### conform.nvim Solidity formatter options and full spec

Source: https://www.lazyvim.org/extras/lang/solidity

Sets up conform.nvim to format Solidity files with forge_fmt. The plugin is marked optional, so it is only configured if installed. The first block shows the minimal opts table; the second shows the full plugin spec.

```lua
opts = {  
  formatters_by_ft = {  
    solidity = { "forge_fmt" },  
  },  
}  
```

```lua
{  
  "stevearc/conform.nvim",  
  optional = true,  
  opts = {  
    formatters_by_ft = {  
      solidity = { "forge_fmt" },  
    },  
  },  
}  
```

--------------------------------

### mason.nvim ensure_installed prettier (Options)

Source: https://www.lazyvim.org/extras/formatting/prettier

Default mason.nvim options to ensure Prettier is installed. Shown for reference; you don't need to copy it.

```lua
opts = { ensure_installed = { "prettier" } }  

```

--------------------------------

### Clone LazyVim starter (Linux/MacOS)

Source: https://www.lazyvim.org/installation

Clones the LazyVim starter template into the Neovim configuration directory.

```bash
git clone https://github.com/LazyVim/starter ~/.config/nvim  

```

--------------------------------

### mason.nvim: Install delve

Source: https://www.lazyvim.org/extras/lang/go

Configures mason.nvim to ensure the Go debugger delve is installed. The first block is the opts table; the second is the full plugin spec.

```lua
opts = { ensure_installed = { "delve" } }  
```

```lua
{  
  "mason-org/mason.nvim",  
  opts = { ensure_installed = { "delve" } },  
}  
```

--------------------------------

### nvim-dap-go: Default configuration

Source: https://www.lazyvim.org/extras/lang/go

Sets up nvim-dap-go with an empty opts table. The first block is the opts table; the second is the full plugin spec.

```lua
opts = {}  
```

```lua
{  
  "leoluz/nvim-dap-go",  
  opts = {},  
}  
```
Tokens:
Raw