Merge branch 'main' into toggles

## Description

Being able to select from the yank history is useful if you want to
paste over something else by first selecting the stuff you want to
remove in visual mode.

## Checklist

- [x] I've read the
[CONTRIBUTING](https://github.com/LazyVim/LazyVim/blob/main/CONTRIBUTING.md)
guidelines.

.github/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "12.28.0"
+  ".": "12.29.2"
 }

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -17,6 +17,8 @@ body:
       options:
         - label: I have read all the LazyVim docs
           required: true
+        - label: I have updated the plugin to the latest version before submitting this issue
+          required: true
         - label: I have searched the existing issues of LazyVim
           required: true
         - label: I have searched the existing issues of plugins related to this issue

CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## [12.29.2](https://github.com/LazyVim/LazyVim/compare/v12.29.1...v12.29.2) (2024-07-14)
+
+
+### Bug Fixes
+
+* **telescope:** better find_command. Fixes [#4031](https://github.com/LazyVim/LazyVim/issues/4031) ([d39cdb0](https://github.com/LazyVim/LazyVim/commit/d39cdb059624b1200f2ef762f30c6e3b74066bc5))
+
+## [12.29.1](https://github.com/LazyVim/LazyVim/compare/v12.29.0...v12.29.1) (2024-07-14)
+
+
+### Bug Fixes
+
+* **omnisharp:** don't detach coreclr debug adapter ([#4023](https://github.com/LazyVim/LazyVim/issues/4023)) ([b3e746b](https://github.com/LazyVim/LazyVim/commit/b3e746b637a0d43aa0195cc1ff3d8adf1fedfaf6))
+* **pick:** get rid of "auto" picker and set better defaults for telescope find_files ([#4024](https://github.com/LazyVim/LazyVim/issues/4024)) ([337e9dd](https://github.com/LazyVim/LazyVim/commit/337e9ddc007d32c624433b5c6f0af6e8697dfcc6))
+* **tailwind:** additional tailwind completion settings for phoenix projects ([#3961](https://github.com/LazyVim/LazyVim/issues/3961)) ([9bce054](https://github.com/LazyVim/LazyVim/commit/9bce054fafcd631ec133a82ada1ecbbd23ca5510))
+
+## [12.29.0](https://github.com/LazyVim/LazyVim/compare/v12.28.0...v12.29.0) (2024-07-14)
+
+
+### Features
+
+* **java:** new java mappings format for which-key v3 ([#4013](https://github.com/LazyVim/LazyVim/issues/4013)) ([28a7f81](https://github.com/LazyVim/LazyVim/commit/28a7f8126c1b46b41ca58845ee081b67ce6981f2))
+* shorter keymap descriptions for mini.ai / yanky ([75ff149](https://github.com/LazyVim/LazyVim/commit/75ff1496bd4209784a4250e59920d24d75a3e3b0))
+
+
+### Bug Fixes
+
+* **flit:** use which-key preset keymap descriptions ([#4000](https://github.com/LazyVim/LazyVim/issues/4000)) ([ca37162](https://github.com/LazyVim/LazyVim/commit/ca37162cb7452dce32cf3f0ad661bcd1245286c0))
+
 ## [12.28.0](https://github.com/LazyVim/LazyVim/compare/v12.27.0...v12.28.0) (2024-07-12)
 
 

doc/LazyVim.txt

@@ -1,4 +1,4 @@
-*LazyVim.txt*               For Neovim               Last change: 2024 July 13
+*LazyVim.txt*               For Neovim               Last change: 2024 July 15
 
 ==============================================================================
 Table of Contents                                  *LazyVim-table-of-contents*

lua/lazyvim/config/init.lua

@@ -3,7 +3,7 @@ _G.LazyVim = require("lazyvim.util")
 ---@class LazyVimConfig: LazyVimOptions
 local M = {}
 
-M.version = "12.28.0" -- x-release-please-version
+M.version = "12.29.2" -- x-release-please-version
 LazyVim.config = M
 
 ---@class LazyVimOptions

lua/lazyvim/config/keymaps.lua

@@ -115,20 +115,19 @@ map("n", "[w", diagnostic_goto(false, "WARN"), { desc = "Prev Warning" })
 -- stylua: ignore start
 
 -- toggle options
-map("n", "<leader>uf", function() LazyVim.format.toggle() end, { desc = "Toggle Auto Format (Global)" })
-map("n", "<leader>uF", function() LazyVim.format.toggle(true) end, { desc = "Toggle Auto Format (Buffer)" })
-map("n", "<leader>us", function() LazyVim.toggle("spell") end, { desc = "Toggle Spelling" })
-map("n", "<leader>uw", function() LazyVim.toggle("wrap") end, { desc = "Toggle Word Wrap" })
-map("n", "<leader>uL", function() LazyVim.toggle("relativenumber") end, { desc = "Toggle Relative Line Numbers" })
-map("n", "<leader>ul", function() LazyVim.toggle.number() end, { desc = "Toggle Line Numbers" })
-map("n", "<leader>ud", function() LazyVim.toggle.diagnostics() end, { desc = "Toggle Diagnostics" })
-local conceallevel = vim.o.conceallevel > 0 and vim.o.conceallevel or 3
-map("n", "<leader>uc", function() LazyVim.toggle("conceallevel", false, {0, conceallevel}) end, { desc = "Toggle Conceal" })
-if vim.lsp.buf.inlay_hint or vim.lsp.inlay_hint then
-  map( "n", "<leader>uh", function() LazyVim.toggle.inlay_hints() end, { desc = "Toggle Inlay Hints" })
+LazyVim.toggle.map("<leader>uf", LazyVim.toggle.format())
+LazyVim.toggle.map("<leader>uF", LazyVim.toggle.format(true))
+LazyVim.toggle.map("<leader>us", LazyVim.toggle("spell", { name = "Spelling" }))
+LazyVim.toggle.map("<leader>uw", LazyVim.toggle("wrap", { name = "Wrap" }))
+LazyVim.toggle.map("<leader>uL", LazyVim.toggle("relativenumber", { name = "Relative Number" }))
+LazyVim.toggle.map("<leader>ud", LazyVim.toggle.diagnostics)
+LazyVim.toggle.map("<leader>ul", LazyVim.toggle.number)
+LazyVim.toggle.map( "<leader>uc", LazyVim.toggle("conceallevel", { values = { 0, vim.o.conceallevel > 0 and vim.o.conceallevel or 2 } }))
+LazyVim.toggle.map("<leader>uT", LazyVim.toggle.treesitter)
+LazyVim.toggle.map("<leader>ub", LazyVim.toggle("background", { values = { "light", "dark" }, name = "Background" }))
+if vim.lsp.inlay_hint then
+  LazyVim.toggle.map("<leader>uh", LazyVim.toggle.inlay_hints)
 end
-map("n", "<leader>uT", function() if vim.b.ts_highlight then vim.treesitter.stop() else vim.treesitter.start() end end, { desc = "Toggle Treesitter Highlight" })
-map("n", "<leader>ub", function() LazyVim.toggle("background", false, {"light", "dark"}) end, { desc = "Toggle Background" })
 
 -- lazygit
 map("n", "<leader>gg", function() LazyVim.lazygit( { cwd = LazyVim.root.git() }) end, { desc = "Lazygit (Root Dir)" })
@@ -181,7 +180,7 @@ map("n", "<leader>w-", "<C-W>s", { desc = "Split Window Below", remap = true })
 map("n", "<leader>w|", "<C-W>v", { desc = "Split Window Right", remap = true })
 map("n", "<leader>-", "<C-W>s", { desc = "Split Window Below", remap = true })
 map("n", "<leader>|", "<C-W>v", { desc = "Split Window Right", remap = true })
-map("n", "<leader>wm", function() LazyVim.toggle.maximize() end, { desc = "Maximize Toggle" })
+LazyVim.toggle.map("<leader>wm", LazyVim.toggle.maximize)
 
 -- tabs
 map("n", "<leader><tab>l", "<cmd>tablast<cr>", { desc = "Last Tab" })

lua/lazyvim/plugins/coding.lua

@@ -140,20 +140,6 @@ return {
       -- better deal with markdown code blocks
       markdown = true,
     },
-    keys = {
-      {
-        "<leader>up",
-        function()
-          vim.g.minipairs_disable = not vim.g.minipairs_disable
-          if vim.g.minipairs_disable then
-            LazyVim.warn("Disabled auto pairs", { title = "Option" })
-          else
-            LazyVim.info("Enabled auto pairs", { title = "Option" })
-          end
-        end,
-        desc = "Toggle Auto Pairs",
-      },
-    },
     config = function(_, opts)
       LazyVim.mini.pairs(opts)
     end,
@@ -171,9 +157,6 @@ return {
     "echasnovski/mini.ai",
     event = "VeryLazy",
     opts = function()
-      LazyVim.on_load("which-key.nvim", function()
-        vim.schedule(LazyVim.mini.ai_whichkey)
-      end)
       local ai = require("mini.ai")
       return {
         n_lines = 500,
@@ -197,6 +180,14 @@ return {
         },
       }
     end,
+    config = function(_, opts)
+      require("mini.ai").setup(opts)
+      LazyVim.on_load("which-key.nvim", function()
+        vim.schedule(function()
+          LazyVim.mini.ai_whichkey(opts)
+        end)
+      end)
+    end,
   },
 
   {

lua/lazyvim/plugins/editor.lua

@@ -176,9 +176,9 @@ return {
           { "<leader>gh", group = "hunks" },
           { "<leader>q", group = "quit/session" },
           { "<leader>s", group = "search" },
-          { "<leader>u", group = "ui" },
+          { "<leader>u", group = "ui", icon = { icon = "󰙵 ", color = "cyan" } },
           { "<leader>w", group = "windows" },
-          { "<leader>x", group = "diagnostics/quickfix" },
+          { "<leader>x", group = "diagnostics/quickfix", icon = { icon = "󱖫 ", color = "green" } },
           { "[", group = "prev" },
           { "]", group = "next" },
           { "g", group = "goto" },
@@ -193,7 +193,7 @@ return {
         function()
           require("which-key").show({ global = false })
         end,
-        desc = "Buffer Local Keymaps (which-key)",
+        desc = "Buffer Keymaps (which-key)",
       },
     },
     config = function(_, opts)

lua/lazyvim/plugins/extras/coding/luasnip.lua

@@ -1,6 +1,7 @@
 return {
   {
     "L3MON4D3/LuaSnip",
+    lazy = true,
     build = (not LazyVim.is_win())
         and "echo 'NOTE: jsregexp is optional, so not a big deal if it fails to build'; make install_jsregexp"
       or nil,

lua/lazyvim/plugins/extras/coding/yanky.lua

@@ -17,14 +17,15 @@ return {
           vim.cmd([[YankyRingHistory]])
         end
       end,
+      mode = { "n", "x" },
       desc = "Open Yank History",
     },
         -- stylua: ignore
     { "y", "<Plug>(YankyYank)", mode = { "n", "x" }, desc = "Yank Text" },
-    { "p", "<Plug>(YankyPutAfter)", mode = { "n", "x" }, desc = "Put Yanked Text After Cursor" },
-    { "P", "<Plug>(YankyPutBefore)", mode = { "n", "x" }, desc = "Put Yanked Text Before Cursor" },
-    { "gp", "<Plug>(YankyGPutAfter)", mode = { "n", "x" }, desc = "Put Yanked Text After Selection" },
-    { "gP", "<Plug>(YankyGPutBefore)", mode = { "n", "x" }, desc = "Put Yanked Text Before Selection" },
+    { "p", "<Plug>(YankyPutAfter)", mode = { "n", "x" }, desc = "Put Text After Cursor" },
+    { "P", "<Plug>(YankyPutBefore)", mode = { "n", "x" }, desc = "Put Text Before Cursor" },
+    { "gp", "<Plug>(YankyGPutAfter)", mode = { "n", "x" }, desc = "Put Text After Selection" },
+    { "gP", "<Plug>(YankyGPutBefore)", mode = { "n", "x" }, desc = "Put Text Before Selection" },
     { "[y", "<Plug>(YankyCycleForward)", desc = "Cycle Forward Through Yank History" },
     { "]y", "<Plug>(YankyCycleBackward)", desc = "Cycle Backward Through Yank History" },
     { "]p", "<Plug>(YankyPutIndentAfterLinewise)", desc = "Put Indented After Cursor (Linewise)" },

lua/lazyvim/plugins/extras/editor/fzf.lua

@@ -211,12 +211,12 @@ return {
       },
       { "<leader>/", LazyVim.pick("live_grep"), desc = "Grep (Root Dir)" },
       { "<leader>:", "<cmd>FzfLua command_history<cr>", desc = "Command History" },
-      { "<leader><space>", LazyVim.pick("auto"), desc = "Find Files (Root Dir)" },
+      { "<leader><space>", LazyVim.pick("files"), desc = "Find Files (Root Dir)" },
       -- find
       { "<leader>fb", "<cmd>FzfLua buffers sort_mru=true sort_lastused=true<cr>", desc = "Buffers" },
       { "<leader>fc", LazyVim.pick.config_files(), desc = "Find Config File" },
-      { "<leader>ff", LazyVim.pick("auto"), desc = "Find Files (Root Dir)" },
-      { "<leader>fF", LazyVim.pick("auto", { root = false }), desc = "Find Files (cwd)" },
+      { "<leader>ff", LazyVim.pick("files"), desc = "Find Files (Root Dir)" },
+      { "<leader>fF", LazyVim.pick("files", { root = false }), desc = "Find Files (cwd)" },
       { "<leader>fg", "<cmd>FzfLua git_files<cr>", desc = "Find Files (git-files)" },
       { "<leader>fr", "<cmd>FzfLua oldfiles<cr>", desc = "Recent" },
       { "<leader>fR", LazyVim.pick("oldfiles", { cwd = vim.uv.cwd() }), desc = "Recent (cwd)" },

lua/lazyvim/plugins/extras/editor/telescope.lua

@@ -92,12 +92,12 @@ return {
       },
       { "<leader>/", LazyVim.pick("live_grep"), desc = "Grep (Root Dir)" },
       { "<leader>:", "<cmd>Telescope command_history<cr>", desc = "Command History" },
-      { "<leader><space>", LazyVim.pick("auto"), desc = "Find Files (Root Dir)" },
+      { "<leader><space>", LazyVim.pick("files"), desc = "Find Files (Root Dir)" },
       -- find
       { "<leader>fb", "<cmd>Telescope buffers sort_mru=true sort_lastused=true<cr>", desc = "Buffers" },
       { "<leader>fc", LazyVim.pick.config_files(), desc = "Find Config File" },
-      { "<leader>ff", LazyVim.pick("auto"), desc = "Find Files (Root Dir)" },
-      { "<leader>fF", LazyVim.pick("auto", { root = false }), desc = "Find Files (cwd)" },
+      { "<leader>ff", LazyVim.pick("files"), desc = "Find Files (Root Dir)" },
+      { "<leader>fF", LazyVim.pick("files", { root = false }), desc = "Find Files (cwd)" },
       { "<leader>fg", "<cmd>Telescope git_files<cr>", desc = "Find Files (git-files)" },
       { "<leader>fr", "<cmd>Telescope oldfiles<cr>", desc = "Recent" },
       { "<leader>fR", LazyVim.pick("oldfiles", { cwd = vim.uv.cwd() }), desc = "Recent (cwd)" },
@@ -165,6 +165,20 @@ return {
         LazyVim.pick("find_files", { hidden = true, default_text = line })()
       end
 
+      local function find_command()
+        if 1 == vim.fn.executable("rg") then
+          return { "rg", "--files", "--color", "never", "-g", "!.git" }
+        elseif 1 == vim.fn.executable("fd") then
+          return { "fd", "--type", "f", "--color", "never", "-E", ".git" }
+        elseif 1 == vim.fn.executable("fdfind") then
+          return { "fdfind", "--type", "f", "--color", "never", "-E", ".git" }
+        elseif 1 == vim.fn.executable("find") and vim.fn.has("win32") == 0 then
+          return { "find", ".", "-type", "f" }
+        elseif 1 == vim.fn.executable("where") then
+          return { "where", "/r", ".", "*" }
+        end
+      end
+
       return {
         defaults = {
           prompt_prefix = " ",
@@ -198,6 +212,12 @@ return {
             },
           },
         },
+        pickers = {
+          find_files = {
+            find_command = find_command,
+            hidden = true,
+          },
+        },
       }
     end,
   },

lua/lazyvim/plugins/extras/lang/omnisharp.lua

@@ -75,6 +75,9 @@ return {
           type = "executable",
           command = vim.fn.exepath("netcoredbg"),
           args = { "--interpreter=vscode" },
+          options = {
+            detached = false,
+          },
         }
       end
       for _, lang in ipairs({ "cs", "fsharp", "vb" }) do

lua/lazyvim/plugins/extras/lang/tailwind.lua

@@ -40,6 +40,17 @@ return {
             return not vim.tbl_contains(opts.filetypes_exclude or {}, ft)
           end, opts.filetypes)
 
+          -- Additional settings for Phoenix projects
+          opts.settings = {
+            tailwindCSS = {
+              includeLanguages = {
+                elixir = "html-eex",
+                eelixir = "html-eex",
+                heex = "html-eex",
+              },
+            },
+          }
+
           -- Add additional filetypes
           vim.list_extend(opts.filetypes, opts.filetypes_include or {})
         end,

lua/lazyvim/plugins/extras/ui/mini-animate.lua

@@ -14,6 +14,16 @@ return {
       end, { expr = true })
     end
 
+    LazyVim.toggle.map("<leader>ua", {
+      name = "Mini Animate",
+      get = function()
+        return not vim.g.minianimate_disable
+      end,
+      set = function(state)
+        vim.g.minianimate_disable = not state
+      end,
+    })
+
     local animate = require("mini.animate")
     return {
       resize = {

lua/lazyvim/plugins/lsp/init.lua

@@ -7,9 +7,9 @@ return {
       "mason.nvim",
       { "williamboman/mason-lspconfig.nvim", config = function() end },
     },
-    ---@class PluginLspOpts
     opts = function()
-      return {
+      ---@class PluginLspOpts
+      local ret = {
         -- options for vim.diagnostic.config()
         ---@type vim.diagnostic.Opts
         diagnostics = {
@@ -114,6 +114,7 @@ return {
           -- ["*"] = function(server, opts) end,
         },
       }
+      return ret
     end,
     ---@param opts PluginLspOpts
     config = function(_, opts)
@@ -150,7 +151,7 @@ return {
               and vim.bo[buffer].buftype == ""
               and not vim.tbl_contains(opts.inlay_hints.exclude, vim.bo[buffer].filetype)
             then
-              LazyVim.toggle.inlay_hints(buffer, true)
+              vim.lsp.inlay_hint.enable(true, { bufnr = buffer })
             end
           end)
         end

lua/lazyvim/plugins/lsp/keymaps.lua

@@ -14,10 +14,10 @@ function M.get()
     -- stylua: ignore
     M._keys =  {
       { "<leader>cl", "<cmd>LspInfo<cr>", 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.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", vim.lsp.buf.hover, desc = "Hover" },
       { "gK", vim.lsp.buf.signature_help, desc = "Signature Help", has = "signatureHelp" },

lua/lazyvim/plugins/treesitter.lua

@@ -1,4 +1,14 @@
 return {
+  {
+    "folke/which-key.nvim",
+    opts = {
+      spec = {
+        { "<BS>", desc = "Decrement Selection", mode = "x" },
+        { "<c-space>", desc = "Increment Selection", mode = { "x", "n" } },
+      },
+    },
+  },
+
   -- Treesitter is a new parser generator tool that we can
   -- use in Neovim to power faster and more accurate
   -- syntax highlighting.

lua/lazyvim/plugins/util.lua

@@ -6,7 +6,7 @@ return {
   {
     "folke/persistence.nvim",
     event = "BufReadPre",
-    opts = { options = vim.opt.sessionoptions:get() },
+    opts = {},
     -- stylua: ignore
     keys = {
       { "<leader>qs", function() require("persistence").load() end, desc = "Restore Session" },

lua/lazyvim/util/format.lua

@@ -97,10 +97,19 @@ end
 
 ---@param buf? boolean
 function M.toggle(buf)
+  M.enable(not M.enabled(), buf)
+end
+
+---@param enable? boolean
+---@param buf? boolean
+function M.enable(enable, buf)
+  if enable == nil then
+    enable = true
+  end
   if buf then
-    vim.b.autoformat = not M.enabled()
+    vim.b.autoformat = enable
   else
-    vim.g.autoformat = not M.enabled()
+    vim.g.autoformat = enable
     vim.b.autoformat = nil
   end
   M.info()

lua/lazyvim/util/mini.lua

@@ -60,48 +60,59 @@ function M.ai_buffer(ai_type)
 end
 
 -- register all text objects with which-key
-function M.ai_whichkey()
+---@param opts table
+function M.ai_whichkey(opts)
   local objects = {
     { " ", desc = "whitespace" },
-    { '"', desc = 'balanced "' },
-    { "'", desc = "balanced '" },
-    { "(", desc = "balanced (" },
-    { ")", desc = "balanced ) including white-space" },
-    { "<", desc = "balanced <" },
-    { ">", desc = "balanced > including white-space" },
+    { '"', desc = '" string' },
+    { "'", desc = "' string" },
+    { "(", desc = "() block" },
+    { ")", desc = "() block with ws" },
+    { "<", desc = "<> block" },
+    { ">", desc = "<> block with ws" },
     { "?", desc = "user prompt" },
-    { "U", desc = "use/call without dot in name" },
-    { "[", desc = "balanced [" },
-    { "]", desc = "balanced ] including white-space" },
+    { "U", desc = "use/call without dot" },
+    { "[", desc = "[] block" },
+    { "]", desc = "[] block with ws" },
     { "_", desc = "underscore" },
-    { "`", desc = "balanced `" },
+    { "`", desc = "` string" },
     { "a", desc = "argument" },
-    { "b", desc = "balanced )]}" },
+    { "b", desc = ")]} block" },
     { "c", desc = "class" },
     { "d", desc = "digit(s)" },
-    { "e", desc = "word in CamelCase & snake_case" },
+    { "e", desc = "CamelCase / snake_case" },
     { "f", desc = "function" },
     { "g", desc = "entire file" },
     { "i", desc = "indent" },
     { "o", desc = "block, conditional, loop" },
     { "q", desc = "quote `\"'" },
     { "t", desc = "tag" },
-    { "u", desc = "use/call function & method" },
-    { "{", desc = "balanced {" },
-    { "}", desc = "balanced } including white-space" },
+    { "u", desc = "use/call" },
+    { "{", desc = "{} block" },
+    { "}", desc = "{} with ws" },
   }
 
   local ret = { mode = { "o", "x" } }
-  for prefix, name in pairs({
-    i = "inside",
-    a = "around",
-    il = "last",
-    ["in"] = "next",
-    al = "last",
-    an = "next",
-  }) do
+  ---@type table<string, string>
+  local mappings = vim.tbl_extend("force", {}, {
+    around = "a",
+    inside = "i",
+    around_next = "an",
+    inside_next = "in",
+    around_last = "al",
+    inside_last = "il",
+  }, opts.mappings or {})
+  mappings.goto_left = nil
+  mappings.goto_right = nil
+
+  for name, prefix in pairs(mappings) do
+    name = name:gsub("^around_", ""):gsub("^inside_", "")
     ret[#ret + 1] = { prefix, group = name }
     for _, obj in ipairs(objects) do
+      local desc = obj.desc
+      if prefix:sub(1, 1) == "i" then
+        desc = desc:gsub(" with ws", "")
+      end
       ret[#ret + 1] = { prefix .. obj[1], desc = obj.desc }
     end
   end
@@ -110,6 +121,15 @@ end
 
 ---@param opts {skip_next: string, skip_ts: string[], skip_unbalanced: boolean, markdown: boolean}
 function M.pairs(opts)
+  LazyVim.toggle.map("<leader>up", {
+    name = "Mini Pairs",
+    get = function()
+      return not vim.g.minipairs_disable
+    end,
+    set = function(state)
+      vim.g.minipairs_disable = not state
+    end,
+  })
   local pairs = require("mini.pairs")
   pairs.setup(opts)
   local open = pairs.open

lua/lazyvim/util/pick.lua

@@ -57,7 +57,7 @@ function M.open(command, opts)
     return LazyVim.error("LazyVim.pick: picker not set")
   end
 
-  command = command or "auto"
+  command = command ~= "auto" and command or "files"
   opts = opts or {}
 
   opts = vim.deepcopy(opts)
@@ -71,21 +71,6 @@ function M.open(command, opts)
     opts.cwd = LazyVim.root({ buf = opts.buf })
   end
 
-  local cwd = opts.cwd or vim.uv.cwd()
-  if command == "auto" then
-    command = "files"
-    if
-      vim.uv.fs_stat(cwd .. "/.git")
-      and not vim.uv.fs_stat(cwd .. "/.ignore")
-      and not vim.uv.fs_stat(cwd .. "/.rgignore")
-    then
-      command = "git_files"
-      if opts.show_untracked == nil then
-        opts.show_untracked = true
-        opts.recurse_submodules = false
-      end
-    end
-  end
   command = M.picker.commands[command] or command
   M.picker.open(command, opts)
 end

lua/lazyvim/util/toggle.lua

@@ -1,114 +1,176 @@
 ---@class lazyvim.util.toggle
 local M = {}
 
----@param silent boolean?
----@param values? {[1]:any, [2]:any}
-function M.option(option, silent, values)
-  if values then
-    if vim.opt_local[option]:get() == values[1] then
-      ---@diagnostic disable-next-line: no-unknown
-      vim.opt_local[option] = values[2]
+---@class lazyvim.Toggle
+---@field name string
+---@field get fun():boolean
+---@field set fun(state:boolean)
+---@overload fun()
+local T = {}
+T.__index = T
+
+---@param lhs string
+---@param toggle lazyvim.Toggle
+function M.map(lhs, toggle)
+  LazyVim.safe_keymap_set("n", lhs, function()
+    local state = not toggle.get()
+    toggle.set(state)
+    if state then
+      LazyVim.info("Enabled " .. toggle.name, { title = toggle.name })
     else
-      ---@diagnostic disable-next-line: no-unknown
-      vim.opt_local[option] = values[1]
+      LazyVim.warn("Disabled " .. toggle.name, { title = toggle.name })
     end
-    return LazyVim.info("Set " .. option .. " to " .. vim.opt_local[option]:get(), { title = "Option" })
+  end, { desc = "Toggle" .. toggle.name })
+  M.wk(lhs, toggle)
+end
+
+function M.wk(lhs, toggle)
+  if not LazyVim.has("which-key.nvim") then
+    return
   end
-  ---@diagnostic disable-next-line: no-unknown
-  vim.opt_local[option] = not vim.opt_local[option]:get()
-  if not silent then
-    if vim.opt_local[option]:get() then
-      LazyVim.info("Enabled " .. option, { title = "Option" })
+  require("which-key").add({
+    {
+      lhs,
+      icon = function()
+        return toggle.get() and { icon = " ", color = "green" } or { icon = " ", color = "yellow" }
+      end,
+      desc = function()
+        return (toggle.get() and "Disable " or "Enable ") .. toggle.name
+      end,
+    },
+  })
+end
+
+---@type lazyvim.Toggle
+M.treesitter = {
+  name = "Treesitter Highlight",
+  get = function()
+    return vim.b.ts_highlight
+  end,
+  set = function(state)
+    if state then
+      vim.treesitter.start()
     else
-      LazyVim.warn("Disabled " .. option, { title = "Option" })
+      vim.treesitter.stop()
     end
-  end
+  end,
+}
+
+---@param buf? boolean
+function M.format(buf)
+  ---@type lazyvim.Toggle
+  local ret = {
+    name = "Auto Format (" .. (buf and "Buffer" or "Global") .. ")",
+    get = function()
+      if not buf then
+        return vim.g.autoformat == nil or vim.g.autoformat
+      end
+      return LazyVim.format.enabled()
+    end,
+    set = function(state)
+      LazyVim.format.enable(state, buf)
+    end,
+  }
+  return ret
+end
+
+---@param opts? {values?: {[1]:any, [2]:any}, name?: string}
+function M.option(option, opts)
+  opts = opts or {}
+  local name = opts.name or option
+  local on = opts.values and opts.values[2] or true
+  local off = opts.values and opts.values[1] or false
+  ---@type lazyvim.Toggle
+  local ret = {
+    name = name,
+    get = function()
+      return vim.opt_local[option]:get() == on
+    end,
+    set = function(state)
+      vim.opt_local[option] = state and on or off
+    end,
+  }
+  return ret
 end
 
 local nu = { number = true, relativenumber = true }
-function M.number()
-  if vim.opt_local.number:get() or vim.opt_local.relativenumber:get() then
-    nu = { number = vim.opt_local.number:get(), relativenumber = vim.opt_local.relativenumber:get() }
-    vim.opt_local.number = false
-    vim.opt_local.relativenumber = false
-    LazyVim.warn("Disabled line numbers", { title = "Option" })
-  else
-    vim.opt_local.number = nu.number
-    vim.opt_local.relativenumber = nu.relativenumber
-    LazyVim.info("Enabled line numbers", { title = "Option" })
-  end
-end
-
-local enabled = true
-function M.diagnostics()
-  -- if this Neovim version supports checking if diagnostics are enabled
-  -- then use that for the current state
-  if vim.diagnostic.is_enabled then
-    enabled = vim.diagnostic.is_enabled()
-  elseif vim.diagnostic.is_disabled then
-    enabled = not vim.diagnostic.is_disabled()
-  end
-  enabled = not enabled
-
-  if enabled then
-    vim.diagnostic.enable()
-    LazyVim.info("Enabled diagnostics", { title = "Diagnostics" })
-  else
-    vim.diagnostic.disable()
-    LazyVim.warn("Disabled diagnostics", { title = "Diagnostics" })
-  end
-end
-
----@param buf? number
----@param value? boolean
-function M.inlay_hints(buf, value)
-  local ih = vim.lsp.buf.inlay_hint or vim.lsp.inlay_hint
-  if type(ih) == "function" then
-    ih(buf, value)
-  elseif type(ih) == "table" and ih.enable then
-    if value == nil then
-      value = not ih.is_enabled({ bufnr = buf or 0 })
+---@type lazyvim.Toggle
+M.number = {
+  name = "Line Numbers",
+  get = function()
+    return vim.opt_local.number:get() or vim.opt_local.relativenumber:get()
+  end,
+  set = function(state)
+    if state then
+      vim.opt_local.number = nu.number
+      vim.opt_local.relativenumber = nu.relativenumber
+    else
+      nu = { number = vim.opt_local.number:get(), relativenumber = vim.opt_local.relativenumber:get() }
+      vim.opt_local.number = false
+      vim.opt_local.relativenumber = false
     end
-    ih.enable(value, { bufnr = buf })
-  end
-end
+  end,
+}
+
+---@type lazyvim.Toggle
+M.diagnostics = {
+  name = "Diagnostics",
+  get = function()
+    return vim.diagnostic.is_enabled and vim.diagnostic.is_enabled()
+  end,
+  set = vim.diagnostic.enable,
+}
+
+---@type lazyvim.Toggle
+M.inlay_hints = {
+  name = "Inlay Hints",
+  get = function()
+    return vim.lsp.inlay_hint.is_enabled({ bufnr = 0 })
+  end,
+  set = function(state)
+    vim.lsp.inlay_hint.enable(state, { bufnr = 0 })
+  end,
+}
 
 ---@type {k:string, v:any}[]
 M._maximized = nil
----@param state boolean?
-function M.maximize(state)
-  if state == (M._maximized ~= nil) then
-    return
-  end
-  if M._maximized then
-    for _, opt in ipairs(M._maximized) do
-      vim.o[opt.k] = opt.v
+---@type lazyvim.Toggle
+M.maximize = {
+  name = "Maximize",
+  get = function()
+    return M._maximized ~= nil
+  end,
+  set = function(state)
+    if state then
+      M._maximized = {}
+      local function set(k, v)
+        table.insert(M._maximized, 1, { k = k, v = vim.o[k] })
+        vim.o[k] = v
+      end
+      set("winwidth", 999)
+      set("winheight", 999)
+      set("winminwidth", 10)
+      set("winminheight", 4)
+      vim.cmd("wincmd =")
+      -- `QuitPre` seems to be executed even if we quit a normal window, so we don't want that
+      -- `VimLeavePre` might be another consideration? Not sure about differences between the 2
+      vim.api.nvim_create_autocmd("ExitPre", {
+        once = true,
+        group = vim.api.nvim_create_augroup("lazyvim_restore_max_exit_pre", { clear = true }),
+        desc = "Restore width/height when close Neovim while maximized",
+        callback = function()
+          M.maximize.set(false)
+        end,
+      })
+    else
+      for _, opt in ipairs(M._maximized) do
+        vim.o[opt.k] = opt.v
+      end
+      M._maximized = nil
+      vim.cmd("wincmd =")
     end
-    M._maximized = nil
-    vim.cmd("wincmd =")
-  else
-    M._maximized = {}
-    local function set(k, v)
-      table.insert(M._maximized, 1, { k = k, v = vim.o[k] })
-      vim.o[k] = v
-    end
-    set("winwidth", 999)
-    set("winheight", 999)
-    set("winminwidth", 10)
-    set("winminheight", 4)
-    vim.cmd("wincmd =")
-  end
-  -- `QuitPre` seems to be executed even if we quit a normal window, so we don't want that
-  -- `VimLeavePre` might be another consideration? Not sure about differences between the 2
-  vim.api.nvim_create_autocmd("ExitPre", {
-    once = true,
-    group = vim.api.nvim_create_augroup("lazyvim_restore_max_exit_pre", { clear = true }),
-    desc = "Restore width/height when close Neovim while maximized",
-    callback = function()
-      M.maximize(false)
-    end,
-  })
-end
+  end,
+}
 
 setmetatable(M, {
   __call = function(m, ...)