mroot/lazyvim
1
0
Fork 0
mirror of https://github.com/LazyVim/LazyVim.git synced 2026-07-25 14:01:06 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

feat(keymaps): allow more dynamic keymaps structure for ease of modularization

Browse source 
This commit is for encouraging modularization and facilitate ease of use

**Simplify Keymap Configuration**

Previously, users had to specify the entire keymap structure to modify
key mappings. For example:

```lua
{
  keymaps = {
    window = {
      window_left = "keys1",
      window_lower = "keys2"
    },
    resize_window = {
      size_increase_height = "keys3"
    }
  },
}
```

Now, users can still specify the structure for better organization, but
they can directly specify the key mappings without needing to follow the
nested structure. The new approach allows for more flexibility and
simplicity:

```lua
{
  window_left = "keys1",
  size_increase_height = "keys3"
}
```

Additionally, users can group keys into tables for better organization
if desired:

```lua
{
  {
    window_left = "keys1",
    window_lower = "keys2"
  }
}
```

This change ensures that only the `keys = "keys"` mappings matter,
making the configuration process more straightforward and user-friendly.
This commit is contained in:
dunix241 2024-11-01 13:43:53 +07:00
parent fc4484f2dc
commit 600f7e03b0
56 changed files with 1327 additions and 1278 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

146
lua/lazyvim/config/keymaps.lua
View file

@ -3,7 +3,7 @@
-- DO NOT USE `LazyVim.safe_keymap_set` IN YOUR OWN CONFIG!!
-- use `vim.keymap.set` instead
local map = LazyVim.safe_keymap_set
local k = require("lazyvim.keymaps").get_keymaps().keymaps
local k = require("lazyvim.keymaps").get_keymaps()
-- better up/down
map({ "n", "x" }, "j", "v:count == 0 ? 'gj' : 'j'", { desc = "Down", expr = true, silent = true })
@ -12,34 +12,34 @@ map({ "n", "x" }, "k", "v:count == 0 ? 'gk' : 'k'", { desc = "Up", expr = true,
map({ "n", "x" }, "<Up>", "v:count == 0 ? 'gk' : 'k'", { desc = "Up", expr = true, silent = true })
-- Move to window using the <ctrl> hjkl keys
map("n", k.window.left, "<C-w>h", { desc = "Go to Left Window", remap = true })
map("n", k.window.lower, "<C-w>j", { desc = "Go to Lower Window", remap = true })
map("n", k.window.upper, "<C-w>k", { desc = "Go to Upper Window", remap = true })
map("n", k.window.right, "<C-w>l", { desc = "Go to Right Window", remap = true })
map("n", k.window_left, "<C-w>h", { desc = "Go to Left Window", remap = true })
map("n", k.window_lower, "<C-w>j", { desc = "Go to Lower Window", remap = true })
map("n", k.window_upper, "<C-w>k", { desc = "Go to Upper Window", remap = true })
map("n", k.window_right, "<C-w>l", { desc = "Go to Right Window", remap = true })
-- Resize window using <ctrl> arrow keys
map("n", k.resize_window.increase_height, "<cmd>resize +2<cr>", { desc = "Increase Window Height" })
map("n", k.resize_window.decrease_height, "<cmd>resize -2<cr>", { desc = "Decrease Window Height" })
map("n", k.resize_window.decrease_width, "<cmd>vertical resize -2<cr>", { desc = "Decrease Window Width" })
map("n", k.resize_window.increase_width, "<cmd>vertical resize +2<cr>", { desc = "Increase Window Width" })
map("n", k.size_increase_height, "<cmd>resize +2<cr>", { desc = "Increase Window Height" })
map("n", k.size_decrease_height, "<cmd>resize -2<cr>", { desc = "Decrease Window Height" })
map("n", k.size_decrease_width, "<cmd>vertical resize -2<cr>", { desc = "Decrease Window Width" })
map("n", k.size_increase_width, "<cmd>vertical resize +2<cr>", { desc = "Increase Window Width" })
-- Move Lines
map("n", k.move_lines.down, "<cmd>execute 'move .+' . v:count1<cr>==", { desc = "Move Down" })
map("n", k.move_lines.up, "<cmd>execute 'move .-' . (v:count1 + 1)<cr>==", { desc = "Move Up" })
map("i", k.move_lines.down, "<esc><cmd>m .+1<cr>==gi", { desc = "Move Down" })
map("i", k.move_lines.up, "<esc><cmd>m .-2<cr>==gi", { desc = "Move Up" })
map("v", k.move_lines.down, ":<C-u>execute \"'<,'>move '>+\" . v:count1<cr>gv=gv", { desc = "Move Down" })
map("v", k.move_lines.up, ":<C-u>execute \"'<,'>move '<-\" . (v:count1 + 1)<cr>gv=gv", { desc = "Move Up" })
map("n", k.move_down, "<cmd>execute 'move .+' . v:count1<cr>==", { desc = "Move Down" })
map("n", k.move_up, "<cmd>execute 'move .-' . (v:count1 + 1)<cr>==", { desc = "Move Up" })
map("i", k.move_down, "<esc><cmd>m .+1<cr>==gi", { desc = "Move Down" })
map("i", k.move_up, "<esc><cmd>m .-2<cr>==gi", { desc = "Move Up" })
map("v", k.move_down, ":<C-u>execute \"'<,'>move '>+\" . v:count1<cr>gv=gv", { desc = "Move Down" })
map("v", k.move_up, ":<C-u>execute \"'<,'>move '<-\" . (v:count1 + 1)<cr>gv=gv", { desc = "Move Up" })
-- buffers
map("n", k.buffers.prev, "<cmd>bprevious<cr>", { desc = "Prev Buffer" })
map("n", k.buffers.next, "<cmd>bnext<cr>", { desc = "Next Buffer" })
map("n", k.buffers.prev_alt, "<cmd>bprevious<cr>", { desc = "Prev Buffer" })
map("n", k.buffers.next_alt, "<cmd>bnext<cr>", { desc = "Next Buffer" })
map("n", k.buffers.switch_to_other, "<cmd>e #<cr>", { desc = "Switch to Other Buffer" })
map("n", k.buffers.switch_to_other_alt, "<cmd>e #<cr>", { desc = "Switch to Other Buffer" })
map("n", k.buffers.delete, LazyVim.ui.bufremove, { desc = "Delete Buffer" })
map("n", k.buffers.delete_and_close, "<cmd>:bd<cr>", { desc = "Delete Buffer and Window" })
map("n", k.buf_prev, "<cmd>bprevious<cr>", { desc = "Prev Buffer" })
map("n", k.buf_next, "<cmd>bnext<cr>", { desc = "Next Buffer" })
map("n", k.buf_prev_alt, "<cmd>bprevious<cr>", { desc = "Prev Buffer" })
map("n", k.buf_next_alt, "<cmd>bnext<cr>", { desc = "Next Buffer" })
map("n", k.buf_switch_to_other, "<cmd>e #<cr>", { desc = "Switch to Other Buffer" })
map("n", k.buf_switch_to_other_alt, "<cmd>e #<cr>", { desc = "Switch to Other Buffer" })
map("n", k.buf_delete, LazyVim.ui.bufremove, { desc = "Delete Buffer" })
map("n", k.buf_delete_and_close, "<cmd>:bd<cr>", { desc = "Delete Buffer and Window" })
-- Clear search with <esc>
map({ "i", "n" }, "<esc>", "<cmd>noh<cr><esc>", { desc = "Escape and Clear hlsearch" })
@ -77,8 +77,8 @@ map("v", "<", "<gv")
map("v", ">", ">gv")
-- commenting
map("n", k.commenting.add_comment_below, "o<esc>Vcx<esc><cmd>normal gcc<cr>fxa<bs>", { desc = "Add Comment Below" })
map("n", k.commenting.add_comment_above, "O<esc>Vcx<esc><cmd>normal gcc<cr>fxa<bs>", { desc = "Add Comment Above" })
map("n", k.comment_add_below, "o<esc>Vcx<esc><cmd>normal gcc<cr>fxa<bs>", { desc = "Add Comment Below" })
map("n", k.comment_add_above, "O<esc>Vcx<esc><cmd>normal gcc<cr>fxa<bs>", { desc = "Add Comment Above" })
-- lazy
map("n", k.lazy, "<cmd>Lazy<cr>", { desc = "Lazy" })
@ -105,46 +105,46 @@ local diagnostic_goto = function(next, severity)
go({ severity = severity })
end
end
map("n", k.diagnostics.line_diagnostics, vim.diagnostic.open_float, { desc = "Line Diagnostics" })
map("n", k.diagnostics.next_diagnostic, diagnostic_goto(true), { desc = "Next Diagnostic" })
map("n", k.diagnostics.prev_diagnostic, diagnostic_goto(false), { desc = "Prev Diagnostic" })
map("n", k.diagnostics.next_error, diagnostic_goto(true, "ERROR"), { desc = "Next Error" })
map("n", k.diagnostics.prev_error, diagnostic_goto(false, "ERROR"), { desc = "Prev Error" })
map("n", k.diagnostics.next_warning, diagnostic_goto(true, "WARN"), { desc = "Next Warning" })
map("n", k.diagnostics.prev_warning, diagnostic_goto(false, "WARN"), { desc = "Prev Warning" })
map("n", k.diagnostic_line_diagnostics, vim.diagnostic.open_float, { desc = "Line Diagnostics" })
map("n", k.diagnostic_next_diagnostic, diagnostic_goto(true), { desc = "Next Diagnostic" })
map("n", k.diagnostic_prev_diagnostic, diagnostic_goto(false), { desc = "Prev Diagnostic" })
map("n", k.diagnostic_next_error, diagnostic_goto(true, "ERROR"), { desc = "Next Error" })
map("n", k.diagnostic_prev_error, diagnostic_goto(false, "ERROR"), { desc = "Prev Error" })
map("n", k.diagnostic_next_warning, diagnostic_goto(true, "WARN"), { desc = "Next Warning" })
map("n", k.diagnostic_prev_warning, diagnostic_goto(false, "WARN"), { desc = "Prev Warning" })
-- stylua: ignore start
-- toggle options
LazyVim.toggle.map(k.toggle_options.auto_format_buffer, LazyVim.toggle.format())
LazyVim.toggle.map(k.toggle_options.auto_format_global, LazyVim.toggle.format(true))
LazyVim.toggle.map(k.toggle_options.spelling, LazyVim.toggle("spell", { name = "Spelling" }))
LazyVim.toggle.map(k.toggle_options.wrap, LazyVim.toggle("wrap", { name = "Wrap" }))
LazyVim.toggle.map(k.toggle_options.relativenumber, LazyVim.toggle("relativenumber", { name = "Relative Number" }))
LazyVim.toggle.map(k.toggle_options.diagnostics, LazyVim.toggle.diagnostics)
LazyVim.toggle.map(k.toggle_options.number, LazyVim.toggle.number)
LazyVim.toggle.map(k.toggle_options.conceallevel, LazyVim.toggle("conceallevel", { values = { 0, vim.o.conceallevel > 0 and vim.o.conceallevel or 2 } }))
LazyVim.toggle.map(k.toggle_options.treesitter, LazyVim.toggle.treesitter)
LazyVim.toggle.map(k.toggle_options.background, LazyVim.toggle("background", { values = { "light", "dark" }, name = "Background" }))
LazyVim.toggle.map(k.toggle_auto_format_buffer, LazyVim.toggle.format())
LazyVim.toggle.map(k.toggle_auto_format_global, LazyVim.toggle.format(true))
LazyVim.toggle.map(k.toggle_spelling, LazyVim.toggle("spell", { name = "Spelling" }))
LazyVim.toggle.map(k.toggle_wrap, LazyVim.toggle("wrap", { name = "Wrap" }))
LazyVim.toggle.map(k.toggle_relativenumber, LazyVim.toggle("relativenumber", { name = "Relative Number" }))
LazyVim.toggle.map(k.toggle_diagnostics, LazyVim.toggle.diagnostics)
LazyVim.toggle.map(k.toggle_number, LazyVim.toggle.number)
LazyVim.toggle.map(k.toggle_conceallevel, LazyVim.toggle("conceallevel", { values = { 0, vim.o.conceallevel > 0 and vim.o.conceallevel or 2 } }))
LazyVim.toggle.map(k.toggle_treesitter, LazyVim.toggle.treesitter)
LazyVim.toggle.map(k.toggle_background, LazyVim.toggle("background", { values = { "light", "dark" }, name = "Background" }))
if vim.lsp.inlay_hint then
LazyVim.toggle.map(k.toggle_options.inlay_hints, LazyVim.toggle.inlay_hints)
LazyVim.toggle.map(k.toggle_inlay_hints, LazyVim.toggle.inlay_hints)
end
-- lazygit
map("n", k.lazygit.toggle_root, function() LazyVim.lazygit( { cwd = LazyVim.root.git() }) end, { desc = "Lazygit (Root Dir)" })
map("n", k.lazygit.toggle_cwd, function() LazyVim.lazygit() end, { desc = "Lazygit (cwd)" })
map("n", k.lazygit.blame_line, LazyVim.lazygit.blame_line, { desc = "Git Blame Line" })
map("n", k.lazygit.browse, LazyVim.lazygit.browse, { desc = "Git Browse" })
map("n", k.lazygit_toggle_root, function() LazyVim.lazygit( { cwd = LazyVim.root.git() }) end, { desc = "Lazygit (Root Dir)" })
map("n", k.lazygit_toggle_cwd, function() LazyVim.lazygit() end, { desc = "Lazygit (cwd)" })
map("n", k.lazygit_blame_line, LazyVim.lazygit.blame_line, { desc = "Git Blame Line" })
map("n", k.lazygit_browse, LazyVim.lazygit.browse, { desc = "Git Browse" })
map("n", k.lazygit.current_file_history, function()
map("n", k.lazygit_current_file_history, function()
local git_path = vim.api.nvim_buf_get_name(0)
LazyVim.lazygit({args = { "-f", vim.trim(git_path) }})
end, { desc = "Lazygit Current File History" })
map("n", k.lazygit.git_log_root, function()
map("n", k.lazygit_git_log_root, function()
LazyVim.lazygit({ args = { "log" }, cwd = LazyVim.root.git() })
end, { desc = "Lazygit Log" })
map("n", k.lazygit.git_log_cwd, function()
map("n", k.lazygit_git_log_cwd, function()
LazyVim.lazygit({ args = { "log" } })
end, { desc = "Lazygit Log (cwd)" })
@ -160,32 +160,32 @@ map("n", k.lazyvim_changelog, function() LazyVim.news.changelog() end, { desc =
-- floating terminal
local lazyterm = function() LazyVim.terminal(nil, { cwd = LazyVim.root() }) end
map("n", k.terminal.floating_terminal.toggle_root, lazyterm, { desc = "Terminal (Root Dir)" })
map("n", k.terminal.floating_terminal.toggle_cwd, function() LazyVim.terminal() end, { desc = "Terminal (cwd)" })
map("n", k.terminal.floating_terminal.toggle_root_alt_1, lazyterm, { desc = "Terminal (Root Dir)" })
map("n", k.terminal.floating_terminal.toggle_root_alt_2, lazyterm, { desc = "which_key_ignore" })
map("n", k.terminal_toggle_root, lazyterm, { desc = "Terminal (Root Dir)" })
map("n", k.terminal_toggle_cwd, function() LazyVim.terminal() end, { desc = "Terminal (cwd)" })
map("n", k.terminal_toggle_root_alt_1, lazyterm, { desc = "Terminal (Root Dir)" })
map("n", k.terminal_toggle_root_alt_2, lazyterm, { desc = "which_key_ignore" })
-- Terminal Mappings
map("t", k.terminal.enter_normal_mode, "<c-\\><c-n>", { desc = "Enter Normal Mode" })
map("t", k.window.left, "<cmd>wincmd h<cr>", { desc = "Go to Left Window" })
map("t", k.window.lower, "<cmd>wincmd j<cr>", { desc = "Go to Lower Window" })
map("t", k.window.upper, "<cmd>wincmd k<cr>", { desc = "Go to Upper Window" })
map("t", k.window.right, "<cmd>wincmd l<cr>", { desc = "Go to Right Window" })
map("t", k.terminal.hide_terminal, "<cmd>close<cr>", { desc = "Hide Terminal" })
map("t", k.terminal.hide_terminal_alt, "<cmd>close<cr>", { desc = "which_key_ignore" })
map("t", k.terminal_enter_normal_mode, "<c-\\><c-n>", { desc = "Enter Normal Mode" })
map("t", k.window_left, "<cmd>wincmd h<cr>", { desc = "Go to Left Window" })
map("t", k.window_lower, "<cmd>wincmd j<cr>", { desc = "Go to Lower Window" })
map("t", k.window_upper, "<cmd>wincmd k<cr>", { desc = "Go to Upper Window" })
map("t", k.window_right, "<cmd>wincmd l<cr>", { desc = "Go to Right Window" })
map("t", k.terminal_hide_terminal, "<cmd>close<cr>", { desc = "Hide Terminal" })
map("t", k.terminal_hide_terminal_alt, "<cmd>close<cr>", { desc = "which_key_ignore" })
-- windows
map("n", k.windows.windows, "<c-w>", { desc = "Windows", remap = true })
map("n", k.windows.split_window_below, "<C-W>s", { desc = "Split Window Below", remap = true })
map("n", k.windows.split_window_right, "<C-W>v", { desc = "Split Window Right", remap = true })
map("n", k.windows.delete_window, "<C-W>c", { desc = "Delete Window", remap = true })
LazyVim.toggle.map(k.windows.toggle_maximize_window, LazyVim.toggle.maximize)
map("n", k.window_prefix, "<c-w>", { desc = "Windows", remap = true })
map("n", k.window_split_window_below, "<C-W>s", { desc = "Split Window Below", remap = true })
map("n", k.window_split_window_right, "<C-W>v", { desc = "Split Window Right", remap = true })
map("n", k.window_delete_window, "<C-W>c", { desc = "Delete Window", remap = true })
LazyVim.toggle.map(k.window_toggle_maximize_window, LazyVim.toggle.maximize)
-- tabs
map("n", k.tabs.last_tab, "<cmd>tablast<cr>", { desc = "Last Tab" })
map("n", k.tabs.close_other_tabs, "<cmd>tabonly<cr>", { desc = "Close Other Tabs" })
map("n", k.tabs.first_tab, "<cmd>tabfirst<cr>", { desc = "First Tab" })
map("n", k.tabs.new_tab, "<cmd>tabnew<cr>", { desc = "New Tab" })
map("n", k.tabs.new_tab, "<cmd>tabnext<cr>", { desc = "Next Tab" })
map("n", k.tabs.close_other_tabs, "<cmd>tabclose<cr>", { desc = "Close Tab" })
map("n", k.tabs.previous_tab, "<cmd>tabprevious<cr>", { desc = "Previous Tab" })
map("n", k.tab_last_tab, "<cmd>tablast<cr>", { desc = "Last Tab" })
map("n", k.tab_close_other_tabs, "<cmd>tabonly<cr>", { desc = "Close Other Tabs" })
map("n", k.tab_first_tab, "<cmd>tabfirst<cr>", { desc = "First Tab" })
map("n", k.tab_new_tab, "<cmd>tabnew<cr>", { desc = "New Tab" })
map("n", k.tab_new_tab, "<cmd>tabnext<cr>", { desc = "Next Tab" })
map("n", k.tab_close_other_tabs, "<cmd>tabclose<cr>", { desc = "Close Tab" })
map("n", k.tab_previous_tab, "<cmd>tabprevious<cr>", { desc = "Previous Tab" })

1317
lua/lazyvim/keymaps.lua
View file

File diff suppressed because it is too large Load diff

30
lua/lazyvim/plugins/coding.lua
View file

@ -1,4 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().coding
local k = require("lazyvim.keymaps").get_keymaps()
return {
@ -28,16 +28,16 @@ return {
local auto_select = true
local mappings = {}
local actions = {
{ k.cmp.scroll_docs_backward, cmp.mapping.scroll_docs(-4) },
{ k.cmp.complete, cmp.mapping.complete() },
{ k.cmp.confirm_auto_select, LazyVim.cmp.confirm({ select = auto_select }) },
{ k.cmp.confirm_select, LazyVim.cmp.confirm({ select = true }) },
{ k.cmp.select_prev_item, cmp.mapping.select_prev_item({ behavior = cmp.SelectBehavior.Insert }) },
{ k.cmp.scroll_docs_forward, cmp.mapping.scroll_docs(4) },
{ k.cmp.select_next_item, cmp.mapping.select_next_item({ behavior = cmp.SelectBehavior.Insert }) },
{ k.cmp.confirm_replace, LazyVim.cmp.confirm({ behavior = cmp.ConfirmBehavior.Replace }) }, -- Accept currently selected item. Set `select` to `false` to only confirm explicitly selected items.
{ k.cmp_scroll_docs_backward, cmp.mapping.scroll_docs(-4) },
{ k.cmp_complete, cmp.mapping.complete() },
{ k.cmp_confirm_auto_select, LazyVim.cmp.confirm({ select = auto_select }) },
{ k.cmp_confirm_select, LazyVim.cmp.confirm({ select = true }) },
{ k.cmp_select_prev_item, cmp.mapping.select_prev_item({ behavior = cmp.SelectBehavior.Insert }) },
{ k.cmp_scroll_docs_forward, cmp.mapping.scroll_docs(4) },
{ k.cmp_select_next_item, cmp.mapping.select_next_item({ behavior = cmp.SelectBehavior.Insert }) },
{ k.cmp_confirm_replace, LazyVim.cmp.confirm({ behavior = cmp.ConfirmBehavior.Replace }) }, -- Accept currently selected item. Set `select` to `false` to only confirm explicitly selected items.
{
k.cmp.abort,
k.cmp_abort,
function(fallback)
cmp.abort()
fallback()
@ -56,7 +56,7 @@ return {
completeopt = "menu,menuone,noinsert" .. (auto_select and "" or ",noselect"),
},
preselect = auto_select and cmp.PreselectMode.Item or cmp.PreselectMode.None,
mapping = cmp.mapping.preset.insert({ mappings }),
mapping = cmp.mapping.preset.insert(mappings),
sources = cmp.config.sources({
{ name = "nvim_lsp" },
{ name = "path" },
@ -120,7 +120,7 @@ return {
end,
keys = {
{
k.cmp.snippet.jump_prev,
k.snippet_jump_prev,
function()
return vim.snippet.active({ direction = 1 }) and "<cmd>lua vim.snippet.jump(1)<cr>" or "<Tab>"
end,
@ -129,7 +129,7 @@ return {
mode = { "i", "s" },
},
{
k.cmp.snippet.jump_next,
k.snippet_jump_next,
function()
return vim.snippet.active({ direction = -1 }) and "<cmd>lua vim.snippet.jump(-1)<cr>" or "<S-Tab>"
end,
@ -178,8 +178,8 @@ return {
n_lines = 500,
custom_textobjects = {
o = ai.gen_spec.treesitter({ -- code block
a = { "@block.outer", "@conditional.outer", "@loop.outer" },
i = { "@block.inner", "@conditional.inner", "@loop.inner" },
a = { "@block", "@conditional.outer", "@loop.outer" },
i = { "@block", "@conditional.inner", "@loop.inner" },
}),
f = ai.gen_spec.treesitter({ a = "@function.outer", i = "@function.inner" }), -- function
c = ai.gen_spec.treesitter({ a = "@class.outer", i = "@class.inner" }), -- class

139
lua/lazyvim/plugins/editor.lua
View file

@ -1,5 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().editor
local s = require("lazyvim.keymaps").get_keymaps().extras.coding.mini_surround
local k = require("lazyvim.keymaps").get_keymaps()
return {
@ -10,40 +9,40 @@ return {
keys = function()
return {
{
k.neo_tree.toggle_root,
k.neotree_toggle_root,
function()
require("neo-tree.command").execute({ toggle = true, dir = LazyVim.root() })
end,
desc = "Explorer NeoTree (Root Dir)",
},
{
k.neo_tree.toggle_cwd,
k.neotree_toggle_cwd,
function()
require("neo-tree.command").execute({ toggle = true, dir = vim.uv.cwd() })
end,
desc = "Explorer NeoTree (cwd)",
},
{
k.neo_tree.toggle_root_alt,
k.neo_tree.toggle_root,
k.neotree_toggle_root_alt,
k.neotree_toggle_root,
desc = "Explorer NeoTree (Root Dir)",
remap = true,
},
{
k.neo_tree.toggle_cwd_alt,
k.neo_tree.toggle_cwd,
k.neotree_toggle_cwd_alt,
k.neotree_toggle_cwd,
desc = "Explorer NeoTree (cwd)",
remap = true,
},
{
k.neo_tree.toggle_git_status,
k.neotree_toggle_git_status,
function()
require("neo-tree.command").execute({ source = "git_status", toggle = true })
end,
desc = "Git Explorer",
},
{
k.neo_tree.toggle_buffers,
k.neotree_toggle_buffers,
function()
require("neo-tree.command").execute({ source = "buffers", toggle = true })
end,
@ -76,10 +75,10 @@ return {
opts = function()
local neo_tree_mappings = {}
local neo_tree_actions = {
[k.neo_tree.window.open] = "open",
[k.neo_tree.window.close_node] = "close_node",
[k.neotree_win_open] = "open",
[k.neotree_win_close_node] = "close_node",
["<space>"] = "none",
[k.neo_tree.window.copy_path_to_clipboard] = {
[k.neotree_win_copy_path_to_clipboard] = {
function(state)
local node = state.tree:get_node()
local path = node:get_id()
@ -87,13 +86,13 @@ return {
end,
desc = "Copy Path to Clipboard",
},
[k.neo_tree.window.open_with_system_application] = {
[k.neotree_win_open_with_system_application] = {
function(state)
require("lazy.util").open(state.tree:get_node().path, { system = true })
end,
desc = "Open with System Application",
},
[k.neo_tree.window.toggle_preview] = { "toggle_preview", config = { use_float = false } },
[k.neotree_win_toggle_preview] = { "toggle_preview", config = { use_float = false } },
}
for key, value in pairs(neo_tree_actions) do
if key and key ~= "" then
@ -158,7 +157,7 @@ return {
cmd = "GrugFar",
keys = {
{
k.grug_far.open,
k.grugfar_open,
function()
local grug = require("grug-far")
local ext = vim.bo.buftype == "" and vim.fn.expand("%:e")
@ -186,11 +185,11 @@ return {
opts = {},
-- stylua: ignore
keys = {
{k.flash.jump, mode = { "n", "x", "o" }, function() require("flash").jump() end, desc = "Flash" },
{k.flash.treesitter, mode = { "n", "o", "x" }, function() require("flash").treesitter() end, desc = "Flash Treesitter" },
{k.flash.remote, mode = "o", function() require("flash").remote() end, desc = "Remote Flash" },
{k.flash.treesitter_search, mode = { "o", "x" }, function() require("flash").treesitter_search() end, desc = "Treesitter Search" },
{k.flash.toggle, mode = { "c" }, function() require("flash").toggle() end, desc = "Toggle Flash Search" },
{k.flash_jump, mode = { "n", "x", "o" }, function() require("flash").jump() end, desc = "Flash" },
{k.flash_treesitter, mode = { "n", "o", "x" }, function() require("flash").treesitter() end, desc = "Flash Treesitter" },
{k.flash_remote, mode = "o", function() require("flash").remote() end, desc = "Remote Flash" },
{k.flash_treesitter_search, mode = { "o", "x" }, function() require("flash").treesitter_search() end, desc = "Treesitter Search" },
{k.flash_toggle, mode = { "c" }, function() require("flash").toggle() end, desc = "Toggle Flash Search" },
},
},
@ -205,33 +204,33 @@ return {
spec = {
{
mode = { "n", "v" },
{ k.which_key.group.tabs, group = "tabs" },
{ k.which_key.group.code, group = "code" },
{ k.which_key.group.file_find, group = "file/find" },
{ k.which_key.group.git, group = "git" },
{ k.which_key.group.hunks, group = "hunks" },
{ k.which_key.group.quit_session, group = "quit/session" },
{ k.which_key.group.search, group = "search" },
{ k.which_key.group.ui, group = "ui", icon = { icon = "󰙵 ", color = "cyan" } },
{ k.tabs_prefix, group = "tabs" },
{ k.code_prefix, group = "code" },
{ k.file_find_prefix, group = "file/find" },
{ k.git_prefix, group = "git" },
{ k.hunks_prefix, group = "hunks" },
{ k.quit_session_prefix, group = "quit/session" },
{ k.search_prefix, group = "search" },
{ k.ui_prefix, group = "ui", icon = { icon = "󰙵 ", color = "cyan" } },
{
k.which_key.group.diagnostics_quickfix,
k.diagnostics_quickfix_prefix,
group = "diagnostics/quickfix",
icon = { icon = "󱖫 ", color = "green" },
},
{ "[", group = "prev" },
{ "]", group = "next" },
{ "g", group = "goto" },
{ s.prefix, group = "surround" },
{ k.minisurround_prefix, group = "surround" },
{ "z", group = "fold" },
k.which_key.group.buffer == "" and {} or {
k.which_key.group.buffer,
k.buffer_prefix == "" and {} or {
k.buffer_prefix,
group = "buffer",
expand = function()
return require("which-key.extras").expand.buf()
end,
},
k.which_key.group.windows == "" and {} or {
k.which_key.group.windows,
k.windows_prefix == "" and {} or {
k.windows_prefix,
group = "windows",
proxy = "<c-w>",
expand = function()
@ -245,14 +244,14 @@ return {
},
keys = {
{
k.which_key.buffer_keymaps,
k.buffer_keymaps,
function()
require("which-key").show({ global = false })
end,
desc = "Buffer Keymaps (which-key)",
},
{
k.which_key.window_hydra_mode,
k.window_hydra_mode,
function()
require("which-key").show({ keys = "<c-w>", loop = true })
end,
@ -299,33 +298,33 @@ return {
end
-- stylua: ignore start
map("n", k.gitsigns.next_hunk, function()
map("n", k.gitsigns_next_hunk, function()
if vim.wo.diff then
vim.cmd.normal({ "]c", bang = true })
else
gs.nav_hunk("next")
end
end, "Next Hunk")
map("n", k.gitsigns.prev_hunk, function()
map("n", k.gitsigns_prev_hunk, function()
if vim.wo.diff then
vim.cmd.normal({ "[c", bang = true })
else
gs.nav_hunk("prev")
end
end, "Prev Hunk")
map("n", k.gitsigns.last_hunk, function() gs.nav_hunk("last") end, "Last Hunk")
map("n", k.gitsigns.first_hunk, function() gs.nav_hunk("first") end, "First Hunk")
map({ "n", "v" }, k.gitsigns.stage_hunk, ":Gitsigns stage_hunk<CR>", "Stage Hunk")
map({ "n", "v" }, k.gitsigns.reset_hunk, ":Gitsigns reset_hunk<CR>", "Reset Hunk")
map("n", k.gitsigns.stage_buffer, gs.stage_buffer, "Stage Buffer")
map("n", k.gitsigns.undo_stage_hunk, gs.undo_stage_hunk, "Undo Stage Hunk")
map("n", k.gitsigns.reset_buffer, gs.reset_buffer, "Reset Buffer")
map("n", k.gitsigns.preview_hunk_inline, gs.preview_hunk_inline, "Preview Hunk Inline")
map("n", k.gitsigns.blame_line, function() gs.blame_line({ full = true }) end, "Blame Line")
map("n", k.gitsigns.blame_buffer, function() gs.blame() end, "Blame Buffer")
map("n", k.gitsigns.diff_index, gs.diffthis, "Diff This")
map("n", k.gitsigns.diff_commit, function() gs.diffthis("~") end, "Diff This ~")
map({ "o", "x" }, k.gitsigns.select_hunk, ":<C-U>Gitsigns select_hunk<CR>", "GitSigns Select Hunk")
map("n", k.gitsigns_last_hunk, function() gs.nav_hunk("last") end, "Last Hunk")
map("n", k.gitsigns_first_hunk, function() gs.nav_hunk("first") end, "First Hunk")
map({ "n", "v" }, k.gitsigns_stage_hunk, ":Gitsigns stage_hunk<CR>", "Stage Hunk")
map({ "n", "v" }, k.gitsigns_reset_hunk, ":Gitsigns reset_hunk<CR>", "Reset Hunk")
map("n", k.gitsigns_stage_buffer, gs.stage_buffer, "Stage Buffer")
map("n", k.gitsigns_undo_stage_hunk, gs.undo_stage_hunk, "Undo Stage Hunk")
map("n", k.gitsigns_reset_buffer, gs.reset_buffer, "Reset Buffer")
map("n", k.gitsigns_preview_hunk_inline, gs.preview_hunk_inline, "Preview Hunk Inline")
map("n", k.gitsigns_blame_line, function() gs.blame_line({ full = true }) end, "Blame Line")
map("n", k.gitsigns_blame_buffer, function() gs.blame() end, "Blame Buffer")
map("n", k.gitsigns_diff_index, gs.diffthis, "Diff This")
map("n", k.gitsigns_diff_commit, function() gs.diffthis("~") end, "Diff This ~")
map({ "o", "x" }, k.gitsigns_select_hunk, ":<C-U>Gitsigns select_hunk<CR>", "GitSigns Select Hunk")
end,
},
},
@ -342,18 +341,22 @@ return {
},
},
keys = {
{ k.trouble.diagnostics_toggle, "<cmd>Trouble diagnostics toggle<cr>", desc = "Diagnostics (Trouble)" },
{ k.trouble_diagnostics_toggle, "<cmd>Trouble diagnostics toggle<cr>", desc = "Diagnostics (Trouble)" },
{
k.trouble.diagnostics_buffer_toggle,
k.trouble_diagnostics_buffer_toggle,
"<cmd>Trouble diagnostics toggle filter.buf=0<cr>",
desc = "Buffer Diagnostics (Trouble)",
},
{ k.trouble.symbols_toggle, "<cmd>Trouble symbols toggle<cr>", desc = "Symbols (Trouble)" },
{ k.trouble.lsp_toggle, "<cmd>Trouble lsp toggle<cr>", desc = "LSP references/definitions/... (Trouble)" },
{ k.trouble.loclist_toggle, "<cmd>Trouble loclist toggle<cr>", desc = "Location List (Trouble)" },
{ k.trouble.qflist_toggle, "<cmd>Trouble qflist toggle<cr>", desc = "Quickfix List (Trouble)" },
{ k.trouble_symbols_toggle, "<cmd>Trouble symbols toggle<cr>", desc = "Symbols (Trouble)" },
{
k.trouble.previous_trouble,
k.trouble_lsp_toggle,
"<cmd>Trouble lsp toggle<cr>",
desc = "LSP references/definitions/... (Trouble)",
},
{ k.trouble_loclist_toggle, "<cmd>Trouble loclist toggle<cr>", desc = "Location List (Trouble)" },
{ k.trouble_qflist_toggle, "<cmd>Trouble qflist toggle<cr>", desc = "Quickfix List (Trouble)" },
{
k.trouble_previous_trouble,
function()
if require("trouble").is_open() then
require("trouble").prev({ skip_groups = true, jump = true })
@ -367,7 +370,7 @@ return {
desc = "Previous Trouble/Quickfix Item",
},
{
k.trouble.next_trouble,
k.trouble_next_trouble,
function()
if require("trouble").is_open() then
require("trouble").next({ skip_groups = true, jump = true })
@ -392,25 +395,25 @@ return {
opts = {},
-- stylua: ignore
keys = {
{ k.todo_comments.next_todo, function() require("todo-comments").jump_next() end, desc = "Next Todo Comment" },
{ k.todo_comments.prev_todo, function() require("todo-comments").jump_prev() end, desc = "Previous Todo Comment" },
{ k.todo_comments.todo_trouble, "<cmd>Trouble todo toggle<cr>", desc = "Todo (Trouble)" },
{ k.todo_comments.todo_fix_fixme_trouble, "<cmd>Trouble todo toggle filter = {tag = {TODO,FIX,FIXME}}<cr>", desc = "Todo/Fix/Fixme (Trouble)" },
{ k.todo_comments.todo_telescope, "<cmd>TodoTelescope<cr>", desc = "Todo" },
{ k.todo_comments.todo_fix_fixme_telescope, "<cmd>TodoTelescope keywords=TODO,FIX,FIXME<cr>", desc = "Todo/Fix/Fixme" },
{ k.todo_next_todo, function() require("todo-comments").jump_next() end, desc = "Next Todo Comment" },
{ k.todo_prev_todo, function() require("todo-comments").jump_prev() end, desc = "Previous Todo Comment" },
{ k.todo_trouble, "<cmd>Trouble todo toggle<cr>", desc = "Todo (Trouble)" },
{ k.todo_fix_fixme_trouble, "<cmd>Trouble todo toggle filter = {tag = {TODO,FIX,FIXME}}<cr>", desc = "Todo/Fix/Fixme (Trouble)" },
{ k.todo_telescope, "<cmd>TodoTelescope<cr>", desc = "Todo" },
{ k.todo_fix_fixme_telescope, "<cmd>TodoTelescope keywords=TODO,FIX,FIXME<cr>", desc = "Todo/Fix/Fixme" },
},
},
{
import = "lazyvim.plugins.extras.editor.fzf",
enabled = function()
return LazyVim.pick.want() == "fzf"
return LazyVim.pick() == "fzf"
end,
},
{
import = "lazyvim.plugins.extras.editor.telescope",
enabled = function()
return LazyVim.pick.want() == "telescope"
return LazyVim.pick() == "telescope"
end,
},
}

16
lua/lazyvim/plugins/extras/coding/copilot-chat.lua
View file

@ -1,5 +1,5 @@
local M = {}
local k = require("lazyvim.keymaps").get_keymaps().extras.coding.copilot_chat
local k = require("lazyvim.keymaps").get_keymaps()
---@param kind string
function M.pick(kind)
@ -38,10 +38,10 @@ return {
}
end,
keys = {
{ k.submit_prompt, "<CR>", ft = "copilot-chat", desc = "Submit Prompt", remap = true },
{ k.prefix, "", desc = "+ai", mode = { "n", "v" } },
{ k.copilotchat_submit_prompt, "<CR>", ft = "copilot-chat", desc = "Submit Prompt", remap = true },
{ k.copilotchat_prefix, "", desc = "+ai", mode = { "n", "v" } },
{
k.toggle,
k.copilotchat_toggle,
function()
return require("CopilotChat").toggle()
end,
@ -49,7 +49,7 @@ return {
mode = { "n", "v" },
},
{
k.clear,
k.copilotchat_clear,
function()
return require("CopilotChat").reset()
end,
@ -57,7 +57,7 @@ return {
mode = { "n", "v" },
},
{
k.quick_chat,
k.copilotchat_quick_chat,
function()
local input = vim.fn.input("Quick Chat: ")
if input ~= "" then
@ -68,9 +68,9 @@ return {
mode = { "n", "v" },
},
-- Show help actions with telescope
{ k.diagnostic_help, M.pick("help"), desc = "Diagnostic Help (CopilotChat)", mode = { "n", "v" } },
{ k.copilotchat_diagnostic_help, M.pick("help"), desc = "Diagnostic Help (CopilotChat)", mode = { "n", "v" } },
-- Show prompts actions with telescope
{ k.prompt_actions, M.pick("prompt"), desc = "Prompt Actions (CopilotChat)", mode = { "n", "v" } },
{ k.copilotchat_prompt_actionsr, M.pick("prompt"), desc = "Prompt Actions (CopilotChat)", mode = { "n", "v" } },
},
config = function(_, opts)
local chat = require("CopilotChat")

8
lua/lazyvim/plugins/extras/coding/luasnip.lua
View file

@ -1,4 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.coding.luasnip
local k = require("lazyvim.keymaps").get_keymaps()
return {
{
@ -39,14 +39,14 @@ return {
-- stylua: ignore
keys = {
{
k.jump_next,
k.snippet_jump_next,
function()
return require("luasnip").jumpable(1) and "<Plug>luasnip-jump-next" or "<tab>"
end,
expr = true, silent = true, mode = "i",
},
{ k.jump_next, function() require("luasnip").jump(1) end, mode = "s" },
{ k.jump_prev, function() require("luasnip").jump(-1) end, mode = { "i", "s" } },
{ k.snippet_jump_next, function() require("luasnip").jump(1) end, mode = "s" },
{ k.snippet_jump_prev, function() require("luasnip").jump(-1) end, mode = { "i", "s" } },
},
},
{

16
lua/lazyvim/plugins/extras/coding/mini-surround.lua
View file

@ -2,7 +2,7 @@
-- surrounding characters like brackets or quotes, this allows you
-- to select the text inside, change or modify the surrounding characters,
-- and more.
local k = require("lazyvim.keymaps").get_keymaps().extras.coding.mini_surround
local k = require("lazyvim.keymaps").get_keymaps()
return {
"echasnovski/mini.surround",
@ -26,13 +26,13 @@ return {
end,
opts = {
mappings = {
add = k.add, -- Add surrounding in Normal and Visual modes
delete = k.delete, -- Delete surrounding
find = k.find, -- Find surrounding (to the right)
find_left = k.find_left, -- Find surrounding (to the left)
highlight = k.highlight, -- Highlight surrounding
replace = k.replace, -- Replace surrounding
update_n_lines = k.update_n_lines, -- Update `n_lines`
add = k.minisurround_add, -- Add surrounding in Normal and Visual modes
delete = k.minisurround_delete, -- Delete surrounding
find = k.minisurround_find, -- Find surrounding (to the right)
find_left = k.minisurround_find_left, -- Find surrounding (to the left)
highlight = k.minisurround_highlight, -- Highlight surrounding
replace = k.minisurround_replace, -- Replace surrounding
update_n_lines = k.minisurround_update_n_lines, -- Update `n_lines`
},
},
}

48
lua/lazyvim/plugins/extras/coding/yanky.lua
View file

@ -1,5 +1,5 @@
-- better yank/paste
local k = require("lazyvim.keymaps").get_keymaps().extras.coding.yanky
local k = require("lazyvim.keymaps").get_keymaps()
return {
"gbprod/yanky.nvim",
recommended = true,
@ -10,7 +10,7 @@ return {
},
keys = {
{
k.yank_history,
k.yanky_yank_history,
function()
if LazyVim.pick.picker.name == "telescope" then
require("telescope").extensions.yank_history.yank_history({})
@ -22,38 +22,48 @@ return {
desc = "Open Yank History",
},
-- stylua: ignore
{ k.yank, "<Plug>(YankyYank)", mode = { "n", "x" }, desc = "Yank Text" },
{ k.put_text_after_cursor, "<Plug>(YankyPutAfter)", mode = { "n", "x" }, desc = "Put Text After Cursor" },
{ k.put_text_before_cursor, "<Plug>(YankyPutBefore)", mode = { "n", "x" }, desc = "Put Text Before Cursor" },
{ k.put_text_after_selection, "<Plug>(YankyGPutAfter)", mode = { "n", "x" }, desc = "Put Text After Selection" },
{ k.put_text_before_selection, "<Plug>(YankyGPutBefore)", mode = { "n", "x" }, desc = "Put Text Before Selection" },
{ k.cycle_forward_yank_history, "<Plug>(YankyCycleForward)", desc = "Cycle Forward Through Yank History" },
{ k.cycle_backward_yank_history, "<Plug>(YankyCycleBackward)", desc = "Cycle Backward Through Yank History" },
{ k.yanky_yank, "<Plug>(YankyYank)", mode = { "n", "x" }, desc = "Yank Text" },
{ k.yanky_put_text_after_cursor, "<Plug>(YankyPutAfter)", mode = { "n", "x" }, desc = "Put Text After Cursor" },
{ k.yanky_put_text_before_cursor, "<Plug>(YankyPutBefore)", mode = { "n", "x" }, desc = "Put Text Before Cursor" },
{
k.put_indent_after_cursor_linewise,
k.yanky_put_text_after_selection,
"<Plug>(YankyGPutAfter)",
mode = { "n", "x" },
desc = "Put Text After Selection",
},
{
k.yanky_put_text_before_selection,
"<Plug>(YankyGPutBefore)",
mode = { "n", "x" },
desc = "Put Text Before Selection",
},
{ k.yanky_cycle_forward_yank_history, "<Plug>(YankyCycleForward)", desc = "Cycle Forward Through Yank History" },
{ k.yanky_cycle_backward_yank_history, "<Plug>(YankyCycleBackward)", desc = "Cycle Backward Through Yank History" },
{
k.yanky_put_indent_after_cursor_linewise,
"<Plug>(YankyPutIndentAfterLinewise)",
desc = "Put Indented After Cursor (Linewise)",
},
{
k.put_indent_before_cursor_linewise,
k.yanky_put_indent_before_cursor_linewise,
"<Plug>(YankyPutIndentBeforeLinewise)",
desc = "Put Indented Before Cursor (Linewise)",
},
{
k.put_indent_after_cursor_linewise_alt,
k.yanky_put_indent_after_cursor_linewise_alt,
"<Plug>(YankyPutIndentAfterLinewise)",
desc = "Put Indented After Cursor (Linewise)",
},
{
k.put_indent_before_cursor_linewise_alt,
k.yanky_put_indent_before_cursor_linewise_alt,
"<Plug>(YankyPutIndentBeforeLinewise)",
desc = "Put Indented Before Cursor (Linewise)",
},
{ k.put_and_indent_right, "<Plug>(YankyPutIndentAfterShiftRight)", desc = "Put and Indent Right" },
{ k.put_and_indent_left, "<Plug>(YankyPutIndentAfterShiftLeft)", desc = "Put and Indent Left" },
{ k.put_before_indent_right, "<Plug>(YankyPutIndentBeforeShiftRight)", desc = "Put Before and Indent Right" },
{ k.put_before_indent_left, "<Plug>(YankyPutIndentBeforeShiftLeft)", desc = "Put Before and Indent Left" },
{ k.put_after_filter, "<Plug>(YankyPutAfterFilter)", desc = "Put After Applying a Filter" },
{ k.put_before_filter, "<Plug>(YankyPutBeforeFilter)", desc = "Put Before Applying a Filter" },
{ k.yanky_put_and_indent_right, "<Plug>(YankyPutIndentAfterShiftRight)", desc = "Put and Indent Right" },
{ k.yanky_put_and_indent_left, "<Plug>(YankyPutIndentAfterShiftLeft)", desc = "Put and Indent Left" },
{ k.yanky_put_before_indent_right, "<Plug>(YankyPutIndentBeforeShiftRight)", desc = "Put Before and Indent Right" },
{ k.yanky_put_before_indent_left, "<Plug>(YankyPutIndentBeforeShiftLeft)", desc = "Put Before and Indent Left" },
{ k.yanky_put_after_filter, "<Plug>(YankyPutAfterFilter)", desc = "Put After Applying a Filter" },
{ k.yanky_put_before_filter, "<Plug>(YankyPutBeforeFilter)", desc = "Put Before Applying a Filter" },
},
}

42
lua/lazyvim/plugins/extras/dap/core.lua
View file

@ -1,4 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.dap.core
local k = require("lazyvim.keymaps").get_keymaps()
---@param config {args?:string[]|fun():string[]?}
local function get_args(config)
@ -29,24 +29,24 @@ return {
-- stylua: ignore
keys = {
{ k.nvim_dap.prefix, "", desc = "+debug", mode = {"n", "v"} },
{ k.nvim_dap.breakpoint_condition, function() require("dap").set_breakpoint(vim.fn.input('Breakpoint condition: ')) end, desc = "Breakpoint Condition" },
{ k.nvim_dap.toggle_breakpoint, function() require("dap").toggle_breakpoint() end, desc = "Toggle Breakpoint" },
{ k.nvim_dap.continue, function() require("dap").continue() end, desc = "Continue" },
{ k.nvim_dap.run_with_args, function() require("dap").continue({ before = get_args }) end, desc = "Run with Args" },
{ k.nvim_dap.run_to_cursor, function() require("dap").run_to_cursor() end, desc = "Run to Cursor" },
{ k.nvim_dap.go_to_line_no_execute, function() require("dap").goto_() end, desc = "Go to Line (No Execute)" },
{ k.nvim_dap.step_into, function() require("dap").step_into() end, desc = "Step Into" },
{ k.nvim_dap.down, function() require("dap").down() end, desc = "Down" },
{ k.nvim_dap.up, function() require("dap").up() end, desc = "Up" },
{ k.nvim_dap.run_last, function() require("dap").run_last() end, desc = "Run Last" },
{ k.nvim_dap.step_out, function() require("dap").step_out() end, desc = "Step Out" },
{ k.nvim_dap.step_over, function() require("dap").step_over() end, desc = "Step Over" },
{ k.nvim_dap.pause, function() require("dap").pause() end, desc = "Pause" },
{ k.nvim_dap.toggle_repl, function() require("dap").repl.toggle() end, desc = "Toggle REPL" },
{ k.nvim_dap.session, function() require("dap").session() end, desc = "Session" },
{ k.nvim_dap.terminate, function() require("dap").terminate() end, desc = "Terminate" },
{ k.nvim_dap.widgets, function() require("dap.ui.widgets").hover() end, desc = "Widgets" },
{ k.dap_prefix, "", desc = "+debug", mode = {"n", "v"} },
{ k.dap_breakpoint_condition, function() require("dap").set_breakpoint(vim.fn.input('Breakpoint condition: ')) end, desc = "Breakpoint Condition" },
{ k.dap_toggle_breakpoint, function() require("dap").toggle_breakpoint() end, desc = "Toggle Breakpoint" },
{ k.dap_continue, function() require("dap").continue() end, desc = "Continue" },
{ k.dap_run_with_args, function() require("dap").continue({ before = get_args }) end, desc = "Run with Args" },
{ k.dap_run_to_cursor, function() require("dap").run_to_cursor() end, desc = "Run to Cursor" },
{ k.dap_go_to_line_no_execute, function() require("dap").goto_() end, desc = "Go to Line (No Execute)" },
{ k.dap_step_into, function() require("dap").step_into() end, desc = "Step Into" },
{ k.dap_down, function() require("dap").down() end, desc = "Down" },
{ k.dap_up, function() require("dap").up() end, desc = "Up" },
{ k.dap_run_last, function() require("dap").run_last() end, desc = "Run Last" },
{ k.dap_step_out, function() require("dap").step_out() end, desc = "Step Out" },
{ k.dap_step_over, function() require("dap").step_over() end, desc = "Step Over" },
{ k.dap_pause, function() require("dap").pause() end, desc = "Pause" },
{ k.dap_toggle_repl, function() require("dap").repl.toggle() end, desc = "Toggle REPL" },
{ k.dap_session, function() require("dap").session() end, desc = "Session" },
{ k.dap_terminate, function() require("dap").terminate() end, desc = "Terminate" },
{ k.dap_widgets, function() require("dap.ui.widgets").hover() end, desc = "Widgets" },
},
config = function()
@ -80,8 +80,8 @@ return {
dependencies = { "nvim-neotest/nvim-nio" },
-- stylua: ignore
keys = {
{ k.nvim_dap_ui.toggle_dap_ui, function() require("dapui").toggle({ }) end, desc = "Dap UI" },
{ k.nvim_dap_ui.eval_dap_ui, function() require("dapui").eval() end, desc = "Eval", mode = {"n", "v"} },
{ k.toggle_dap_ui, function() require("dapui").toggle({ }) end, desc = "Dap UI" },
{ k.dap_eval_dap_ui, function() require("dapui").eval() end, desc = "Eval", mode = {"n", "v"} },
},
opts = {},
config = function(_, opts)

10
lua/lazyvim/plugins/extras/editor/aerial.lua
View file

@ -1,6 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.editor.aerial
local p = require("lazyvim.keymaps").get_keymaps().extras.editor.picker
local t = require("lazyvim.keymaps").get_keymaps().editor.trouble
local k = require("lazyvim.keymaps").get_keymaps()
return {
desc = "Aerial Symbol Browser",
@ -47,7 +45,7 @@ return {
return opts
end,
keys = {
{ k.toggle, "<cmd>AerialToggle<cr>", desc = "Aerial (Symbols)" },
{ k.aerial_toggle, "<cmd>AerialToggle<cr>", desc = "Aerial (Symbols)" },
},
},
@ -55,7 +53,7 @@ return {
"folke/trouble.nvim",
optional = true,
keys = {
{ t.symbols_toggle, false },
{ k.trouble_symbols_toggle, false },
},
},
@ -70,7 +68,7 @@ return {
end,
keys = {
{
p.go_to_symbol,
k.picker_go_to_symbol,
"<cmd>Telescope aerial<cr>",
desc = "Goto Symbol (Aerial)",
},

8
lua/lazyvim/plugins/extras/editor/dial.lua
View file

@ -1,5 +1,5 @@
local M = {}
local k = require("lazyvim.keymaps").get_keymaps().extras.editor.dial
local k = require("lazyvim.keymaps").get_keymaps()
---@param increment boolean
---@param g? boolean
@ -19,9 +19,9 @@ return {
-- stylua: ignore
keys = {
{ k.increase, function() return M.dial(true) end, expr = true, desc = "Increment", mode = {"n", "v"} },
{ k.decrement, function() return M.dial(false) end, expr = true, desc = "Decrement", mode = {"n", "v"} },
{ k.increment_g, function() return M.dial(true, true) end, expr = true, desc = "Increment", mode = {"n", "v"} },
{ k.decrement_g, function() return M.dial(false, true) end, expr = true, desc = "Decrement", mode = {"n", "v"} },
{ k.dial_decrement, function() return M.dial(false) end, expr = true, desc = "Decrement", mode = {"n", "v"} },
{ k.dial_increment_g, function() return M.dial(true, true) end, expr = true, desc = "Increment", mode = {"n", "v"} },
{ k.dial_decrement_g, function() return M.dial(false, true) end, expr = true, desc = "Decrement", mode = {"n", "v"} },
},
opts = function()
local augend = require("dial.augend")

105
lua/lazyvim/plugins/extras/editor/fzf.lua
View file

@ -1,6 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.editor.picker
local lang = require("lazyvim.keymaps").get_keymaps().extras.lang
local t = require("lazyvim.keymaps").get_keymaps().editor.todo_comments
local k = require("lazyvim.keymaps").get_keymaps()
if lazyvim_docs then
-- In case you don't want to use `:LazyExtras`,
@ -103,8 +101,8 @@ return {
end
local default_keymaps = {
[k.actions.find_files_no_ignore] = { actions.toggle_ignore },
[k.actions.find_files_with_hidden] = { actions.toggle_hidden },
[k.picker_find_files_no_ignore] = { actions.toggle_ignore },
[k.picker_find_files_with_hidden] = { actions.toggle_hidden },
}
local keymaps = {}
@ -215,50 +213,59 @@ return {
{ "<c-j>", "<c-j>", ft = "fzf", mode = "t", nowait = true },
{ "<c-k>", "<c-k>", ft = "fzf", mode = "t", nowait = true },
{
k.switch_buffer,
k.picker_switch_buffer,
"<cmd>FzfLua buffers sort_mru=true sort_lastused=true<cr>",
desc = "Switch Buffer",
},
{ k.grep_root, LazyVim.pick("live_grep"), desc = "Grep (Root Dir)" },
{ k.command_history, "<cmd>FzfLua command_history<cr>", desc = "Command History" },
{ k.find_files_root, LazyVim.pick("files"), desc = "Find Files (Root Dir)" },
{ k.picker_grep_root, LazyVim.pick("live_grep"), desc = "Grep (Root Dir)" },
{ k.picker_command_history, "<cmd>FzfLua command_history<cr>", desc = "Command History" },
{ k.picker_find_files_root, LazyVim.pick("files"), desc = "Find Files (Root Dir)" },
-- find
{ k.find_buffers, "<cmd>FzfLua buffers sort_mru=true sort_lastused=true<cr>", desc = "Buffers" },
{ k.find_config_file, LazyVim.pick.config_files(), desc = "Find Config File" },
{ k.find_files_root_alt, LazyVim.pick("files"), desc = "Find Files (Root Dir)" },
{ k.find_files_cwd, LazyVim.pick("files", { root = false }), desc = "Find Files (cwd)" },
{ k.find_git_files, "<cmd>FzfLua git_files<cr>", desc = "Find Files (git-files)" },
{ k.find_recent_files, "<cmd>FzfLua oldfiles<cr>", desc = "Recent" },
{ k.find_recent_files_cwd, LazyVim.pick("oldfiles", { cwd = vim.uv.cwd() }), desc = "Recent (cwd)" },
{ k.picker_find_buffers, "<cmd>FzfLua buffers sort_mru=true sort_lastused=true<cr>", desc = "Buffers" },
{ k.picker_find_config_file, LazyVim.pick.config_files(), desc = "Find Config File" },
{ k.picker_find_files_root_alt, LazyVim.pick("files"), desc = "Find Files (Root Dir)" },
{ k.picker_find_files_cwd, LazyVim.pick("files", { root = false }), desc = "Find Files (cwd)" },
{ k.picker_find_git_files, "<cmd>FzfLua git_files<cr>", desc = "Find Files (git-files)" },
{ k.picker_find_recent_files, "<cmd>FzfLua oldfiles<cr>", desc = "Recent" },
{ k.picker_find_recent_files_cwd, LazyVim.pick("oldfiles", { cwd = vim.uv.cwd() }), desc = "Recent (cwd)" },
-- git
{ k.git_commits, "<cmd>FzfLua git_commits<CR>", desc = "Commits" },
{ k.git_status, "<cmd>FzfLua git_status<CR>", desc = "Status" },
{ k.picker_git_commits, "<cmd>FzfLua git_commits<CR>", desc = "Commits" },
{ k.picker_git_status, "<cmd>FzfLua git_status<CR>", desc = "Status" },
-- search
{ k.search_registers, "<cmd>FzfLua registers<cr>", desc = "Registers" },
{ k.search_autocommands, "<cmd>FzfLua autocmds<cr>", desc = "Auto Commands" },
{ k.search_buffer, "<cmd>FzfLua grep_curbuf<cr>", desc = "Buffer" },
{ k.search_command_history, "<cmd>FzfLua command_history<cr>", desc = "Command History" },
{ k.search_commands, "<cmd>FzfLua commands<cr>", desc = "Commands" },
{ k.search_document_diagnostics, "<cmd>FzfLua diagnostics_document<cr>", desc = "Document Diagnostics" },
{ k.search_workspace_diagnostics, "<cmd>FzfLua diagnostics_workspace<cr>", desc = "Workspace Diagnostics" },
{ k.search_grep_root, LazyVim.pick("live_grep"), desc = "Grep (Root Dir)" },
{ k.search_grep_cwd, LazyVim.pick("live_grep", { root = false }), desc = "Grep (cwd)" },
{ k.search_help_pages, "<cmd>FzfLua help_tags<cr>", desc = "Help Pages" },
{ k.search_highlight_groups, "<cmd>FzfLua highlights<cr>", desc = "Search Highlight Groups" },
{ k.search_jumplist, "<cmd>FzfLua jumps<cr>", desc = "Jumplist" },
{ k.search_keymaps, "<cmd>FzfLua keymaps<cr>", desc = "Key Maps" },
{ k.search_loclist, "<cmd>FzfLua loclist<cr>", desc = "Location List" },
{ k.search_man_pages, "<cmd>FzfLua man_pages<cr>", desc = "Man Pages" },
{ k.search_marks, "<cmd>FzfLua marks<cr>", desc = "Jump to Mark" },
{ k.search_resume, "<cmd>FzfLua resume<cr>", desc = "Resume" },
{ k.search_quickfix, "<cmd>FzfLua quickfix<cr>", desc = "Quickfix List" },
{ k.search_word_root, LazyVim.pick("grep_cword"), desc = "Word (Root Dir)" },
{ k.search_word_cwd, LazyVim.pick("grep_cword", { root = false }), desc = "Word (cwd)" },
{ k.search_selection_root, LazyVim.pick("grep_visual"), mode = "v", desc = "Selection (Root Dir)" },
{ k.search_selection_cwd, LazyVim.pick("grep_visual", { root = false }), mode = "v", desc = "Selection (cwd)" },
{ k.colorscheme_preview, LazyVim.pick("colorschemes"), desc = "Colorscheme with Preview" },
{ k.picker_search_registers, "<cmd>FzfLua registers<cr>", desc = "Registers" },
{ k.picker_search_autocommands, "<cmd>FzfLua autocmds<cr>", desc = "Auto Commands" },
{ k.picker_search_buffer, "<cmd>FzfLua grep_curbuf<cr>", desc = "Buffer" },
{ k.picker_search_command_history, "<cmd>FzfLua command_history<cr>", desc = "Command History" },
{ k.picker_search_commands, "<cmd>FzfLua commands<cr>", desc = "Commands" },
{ k.picker_search_document_diagnostics, "<cmd>FzfLua diagnostics_document<cr>", desc = "Document Diagnostics" },
{
k.go_to_symbol,
k.picker_search_workspace_diagnostics,
"<cmd>FzfLua diagnostics_workspace<cr>",
desc = "Workspace Diagnostics",
},
{ k.picker_search_grep_root, LazyVim.pick("live_grep"), desc = "Grep (Root Dir)" },
{ k.picker_search_grep_cwd, LazyVim.pick("live_grep", { root = false }), desc = "Grep (cwd)" },
{ k.picker_search_help_pages, "<cmd>FzfLua help_tags<cr>", desc = "Help Pages" },
{ k.picker_search_highlight_groups, "<cmd>FzfLua highlights<cr>", desc = "Search Highlight Groups" },
{ k.picker_search_jumplist, "<cmd>FzfLua jumps<cr>", desc = "Jumplist" },
{ k.picker_search_keymaps, "<cmd>FzfLua keymaps<cr>", desc = "Key Maps" },
{ k.picker_search_loclist, "<cmd>FzfLua loclist<cr>", desc = "Location List" },
{ k.picker_search_man_pages, "<cmd>FzfLua man_pages<cr>", desc = "Man Pages" },
{ k.picker_search_marks, "<cmd>FzfLua marks<cr>", desc = "Jump to Mark" },
{ k.picker_search_resume, "<cmd>FzfLua resume<cr>", desc = "Resume" },
{ k.picker_search_quickfix, "<cmd>FzfLua quickfix<cr>", desc = "Quickfix List" },
{ k.picker_search_word_root, LazyVim.pick("grep_cword"), desc = "Word (Root Dir)" },
{ k.picker_search_word_cwd, LazyVim.pick("grep_cword", { root = false }), desc = "Word (cwd)" },
{ k.picker_search_selection_root, LazyVim.pick("grep_visual"), mode = "v", desc = "Selection (Root Dir)" },
{
k.picker_search_selection_cwd,
LazyVim.pick("grep_visual", { root = false }),
mode = "v",
desc = "Selection (cwd)",
},
{ k.picker_colorscheme_preview, LazyVim.pick("colorschemes"), desc = "Colorscheme with Preview" },
{
k.picker_go_to_symbol,
function()
require("fzf-lua").lsp_document_symbols({
regex_filter = symbols_filter,
@ -267,7 +274,7 @@ return {
desc = "Goto Symbol",
},
{
k.go_to_symbol_workspace,
k.picker_go_to_symbol_workspace,
function()
require("fzf-lua").lsp_live_workspace_symbols({
regex_filter = symbols_filter,
@ -283,8 +290,8 @@ return {
optional = true,
-- stylua: ignore
keys = {
{ t.todo_telescope, function() require("todo-comments.fzf").todo() end, desc = "Todo" },
{ t.todo_fix_fixme_telescope, function () require("todo-comments.fzf").todo({ keywords = { "TODO", "FIX", "FIXME" } }) end, desc = "Todo/Fix/Fixme" },
{ k.todo_telescope, function() require("todo-comments.fzf").todo() end, desc = "Todo" },
{ k.todo_fix_fixme_telescope, function () require("todo-comments.fzf").todo({ keywords = { "TODO", "FIX", "FIXME" } }) end, desc = "Todo/Fix/Fixme" },
},
},
@ -294,10 +301,10 @@ return {
local Keys = require("lazyvim.plugins.lsp.keymaps").get()
-- stylua: ignore
vim.list_extend(Keys, {
{ lang.go_to_definition, "<cmd>FzfLua lsp_definitions jump_to_single_result=true ignore_current_line=true<cr>", desc = "Goto Definition", has = "definition" },
{ lang.references, "<cmd>FzfLua lsp_references jump_to_single_result=true ignore_current_line=true<cr>", desc = "References", nowait = true },
{ lang.go_to_implementation, "<cmd>FzfLua lsp_implementations jump_to_single_result=true ignore_current_line=true<cr>", desc = "Goto Implementation" },
{ lang.go_to_type_definition, "<cmd>FzfLua lsp_typedefs jump_to_single_result=true ignore_current_line=true<cr>", desc = "Goto T[y]pe Definition" },
{ k.lang_go_to_definition, "<cmd>FzfLua lsp_definitions jump_to_single_result=true ignore_current_line=true<cr>", desc = "Goto Definition", has = "definition" },
{ k.lang_references, "<cmd>FzfLua lsp_references jump_to_single_result=true ignore_current_line=true<cr>", desc = "References", nowait = true },
{ k.lang_go_to_implementation, "<cmd>FzfLua lsp_implementations jump_to_single_result=true ignore_current_line=true<cr>", desc = "Goto Implementation" },
{ k.lang_go_to_type_definition, "<cmd>FzfLua lsp_typedefs jump_to_single_result=true ignore_current_line=true<cr>", desc = "Goto T[y]pe Definition" },
})
end,
},

2
lua/lazyvim/plugins/extras/editor/harpoon2.lua
View file

@ -1,4 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.editor.harpoon2
local k = require("lazyvim.keymaps").get_keymaps()
return {
"ThePrimeagen/harpoon",

14
lua/lazyvim/plugins/extras/editor/illuminate.lua
View file

@ -1,7 +1,7 @@
-- Automatically highlights other instances of the word under your cursor.
-- This works with LSP, Treesitter, and regexp matching to find the other
-- instances.
local k = require("lazyvim.keymaps").get_keymaps().extras.editor.vim_illuminate
local k = require("lazyvim.keymaps").get_keymaps()
return {
{
@ -23,21 +23,21 @@ return {
end, { desc = dir:sub(1, 1):upper() .. dir:sub(2) .. " Reference", buffer = buffer })
end
map(k.next, "next")
map(k.prev, "prev")
map(k.illuminate_next, "next")
map(k.illuminate_prev, "prev")
-- also set it after loading ftplugins, since a lot overwrite [[ and ]]
vim.api.nvim_create_autocmd("FileType", {
callback = function()
local buffer = vim.api.nvim_get_current_buf()
map(k.next, "next", buffer)
map(k.prev, "prev", buffer)
map(k.illuminate_next, "next", buffer)
map(k.illuminate_prev, "prev", buffer)
end,
})
end,
keys = {
{ k.next, desc = "Next Reference" },
{ k.prev, desc = "Prev Reference" },
{ k.illuminate_next, desc = "Next Reference" },
{ k.illuminate_prev, desc = "Prev Reference" },
},
},
{

4
lua/lazyvim/plugins/extras/editor/inc-rename.lua
View file

@ -1,4 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.editor.inc_rename
local k = require("lazyvim.keymaps").get_keymaps()
return {
@ -17,7 +17,7 @@ return {
opts = function()
local keys = require("lazyvim.plugins.lsp.keymaps").get()
keys[#keys + 1] = {
k.rename,
k.increname_rename,
function()
local inc_rename = require("inc_rename")
return ":" .. inc_rename.config.cmd_name .. " " .. vim.fn.expand("<cword>")

32
lua/lazyvim/plugins/extras/editor/leap.lua
View file

@ -1,6 +1,5 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.editor.leap
local m = require("lazyvim.keymaps").get_keymaps().extras.coding.mini_surround
local default = require("lazyvim.keymaps").default_keymaps.extras.coding.mini_surround
local k = require("lazyvim.keymaps").get_keymaps()
local default = require("lazyvim.keymaps").default_keymaps
return {
-- disable flash
@ -24,9 +23,9 @@ return {
"ggandor/leap.nvim",
enabled = true,
keys = {
{ k.next, mode = { "n", "x", "o" }, desc = "Leap Forward to" },
{ k.prev, mode = { "n", "x", "o" }, desc = "Leap Backward to" },
{ k.from_windows, mode = { "n", "x", "o" }, desc = "Leap from Windows" },
{ k.leap_next, mode = { "n", "x", "o" }, desc = "Leap Forward to" },
{ k.leap_prev, mode = { "n", "x", "o" }, desc = "Leap Backward to" },
{ k.leap_from_windows, mode = { "n", "x", "o" }, desc = "Leap from Windows" },
},
config = function(_, opts)
local leap = require("leap")
@ -45,17 +44,22 @@ return {
optional = true,
opts = {
mappings = {
add = m.add == default.add and "gza" or m.add, -- Add surrounding in Normal and Visual modes
delete = m.delete == default.delete and "gzd" or m.delete, -- Delete surrounding
find = m.find == default.find and "gzf" or m.find, -- Find surrounding (to the right)
find_left = m.find_left == default.find_left and "gzF" or m.find_left, -- Find surrounding (to the left)
highlight = m.highlight == default.highlight and "gzh" or m.highlight, -- Highlight surrounding
replace = m.replace == default.replace and "gzr" or m.replace, -- Replace surrounding
update_n_lines = m.update_n_lines == default.update_n_lines and "gzn" or m.update_n_lines, -- Update `n_lines`
add = k.minisurround_add == default.minisurround_add and "gza" or k.minisurround_add, -- Add surrounding in Normal and Visual modes
delete = k.minisurround_delete == default.minisurround_delete and "gzd" or k.minisurround_delete, -- Delete surrounding
find = k.minisurround_find == default.minisurround_find and "gzf" or k.minisurround_find, -- Find surrounding (to the right)
find_left = k.minisurround_find_left == default.minisurround_find_left and "gzF" or k.minisurround_find_left, -- Find surrounding (to the left)
highlight = k.minisurround_highlight == default.minisurround_highlight and "gzh" or k.minisurround_highlight, -- Highlight surrounding
replace = k.minisurround_replace == default.minisurround_replace and "gzr" or k.minisurround_replace, -- Replace surrounding
update_n_lines = k.minisurround_update_n_lines == default.minisurround_update_n_lines and "gzn"
or k.minisurround_update_n_lines, -- Update `n_lines`
},
},
keys = {
{ m.prefix == default.prefix and "gz" or m.prefix, "", desc = "+surround" },
{
k.minisurround_prefix == default.minisurround_prefix and "gz" or k.minisurround_prefix,
"",
desc = "+surround",
},
},
},

4
lua/lazyvim/plugins/extras/editor/mini-diff.lua
View file

@ -1,4 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.editor.mini_diff
local k = require("lazyvim.keymaps").get_keymaps()
return {
-- disable gitsigns.nvim
@ -13,7 +13,7 @@ return {
event = "VeryLazy",
keys = {
{
k.toggle_overlay,
k.minidiff_toggle_overlay,
function()
require("mini.diff").toggle_overlay(0)
end,

6
lua/lazyvim/plugins/extras/editor/mini-files.lua
View file

@ -1,5 +1,5 @@
local map = LazyVim.keymap_set
local k = require("lazyvim.keymaps").get_keymaps().extras.editor.mini_files
local k = require("lazyvim.keymaps").get_keymaps()
return {
"echasnovski/mini.files",
@ -17,14 +17,14 @@ return {
},
keys = {
{
k.open_current_file_dir,
k.minifiles_open_current_file_dir,
function()
require("mini.files").open(vim.api.nvim_buf_get_name(0), true)
end,
desc = "Open mini.files (Directory of Current File)",
},
{
k.open_cwd,
k.minifiles_open_cwd,
function()
require("mini.files").open(vim.uv.cwd(), true)
end,

11
lua/lazyvim/plugins/extras/editor/outline.lua
View file

@ -1,5 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().editor.trouble
local o = require("lazyvim.keymaps").get_keymaps().extras.editor.outline
local k = require("lazyvim.keymaps").get_keymaps()
return {
-- Disable `<leader>cs` keymap so it doesn't conflict with `outline.nvim`
@ -7,12 +6,12 @@ return {
"folke/trouble.nvim",
optional = true,
keys = {
{ k.symbols_toggle, false },
{ k.trouble_symbols_toggle, false },
},
},
{
"hedyhli/outline.nvim",
keys = { { k.symbols_toggle, "<cmd>Outline<cr>", desc = "Toggle Outline" } },
keys = { { k.trouble_symbols_toggle, "<cmd>Outline<cr>", desc = "Toggle Outline" } },
cmd = "Outline",
opts = function()
local defaults = require("outline.config").defaults
@ -25,8 +24,8 @@ return {
}
local keymaps = {
up_and_jump = o.up_and_jump,
down_and_jump = o.down_and_jump,
up_and_jump = k.outline_up_and_jump,
down_and_jump = k.outline_down_and_jump,
}
for key, value in pairs(keymaps) do
if value and value ~= "" then

18
lua/lazyvim/plugins/extras/editor/overseer.lua
View file

@ -1,4 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.editor.overseer
local k = require("lazyvim.keymaps").get_keymaps()
return {
{
@ -53,13 +53,13 @@ return {
},
-- stylua: ignore
keys = {
{ k.toggle, "<cmd>OverseerToggle<cr>", desc = "Task list" },
{ k.run, "<cmd>OverseerRun<cr>", desc = "Run task" },
{ k.quick_action, "<cmd>OverseerQuickAction<cr>", desc = "Action recent task" },
{ k.info, "<cmd>OverseerInfo<cr>", desc = "Overseer Info" },
{ k.build, "<cmd>OverseerBuild<cr>", desc = "Task builder" },
{ k.task_action, "<cmd>OverseerTaskAction<cr>", desc = "Task action" },
{ k.clear_cache, "<cmd>OverseerClearCache<cr>", desc = "Clear cache" },
{ k.overseer_toggle, "<cmd>OverseerToggle<cr>", desc = "Task list" },
{ k.overseer_run, "<cmd>OverseerRun<cr>", desc = "Run task" },
{ k.overseer_quick_action, "<cmd>OverseerQuickAction<cr>", desc = "Action recent task" },
{ k.overseer_info, "<cmd>OverseerInfo<cr>", desc = "Overseer Info" },
{ k.overseer_build, "<cmd>OverseerBuild<cr>", desc = "Task builder" },
{ k.overseer_task_action, "<cmd>OverseerTaskAction<cr>", desc = "Task action" },
{ k.overseer_clear_cache, "<cmd>OverseerClearCache<cr>", desc = "Clear cache" },
},
},
{
@ -67,7 +67,7 @@ return {
optional = true,
opts = {
spec = {
k.prefix == "" and {} or { k.prefix, group = "overseer" },
k.overseer_prefix == "" and {} or { k.overseer_prefix, group = "overseer" },
},
},
},

26
lua/lazyvim/plugins/extras/editor/refactoring.lua
View file

@ -1,4 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.editor.refactoring
local k = require("lazyvim.keymaps").get_keymaps()
local pick = function()
if LazyVim.pick.picker.name == "telescope" then
@ -30,15 +30,15 @@ return {
"nvim-treesitter/nvim-treesitter",
},
keys = {
{ k.prefix, "", desc = "+refactor", mode = { "n", "v" } },
{ k.refactoring_prefix, "", desc = "+refactor", mode = { "n", "v" } },
{
k.refactor,
k.refactoring_refactor,
pick,
mode = "v",
desc = "Refactor",
},
{
k.inline_variable,
k.refactoring_inline_variable,
function()
require("refactoring").refactor("Inline Variable")
end,
@ -46,42 +46,42 @@ return {
desc = "Inline Variable",
},
{
k.extract_block,
k.refactoring_extract_block,
function()
require("refactoring").refactor("Extract Block")
end,
desc = "Extract Block",
},
{
k.extract_block_to_file,
k.refactoring_extract_block_to_file,
function()
require("refactoring").refactor("Extract Block To File")
end,
desc = "Extract Block To File",
},
{
k.debug_print,
k.refactoring_debug_print,
function()
require("refactoring").debug.printf({ below = false })
end,
desc = "Debug Print",
},
{
k.debug_print_variable,
k.refactoring_debug_print_variable,
function()
require("refactoring").debug.print_var({ normal = true })
end,
desc = "Debug Print Variable",
},
{
k.debug_cleanup,
k.refactoring_debug_cleanup,
function()
require("refactoring").debug.cleanup({})
end,
desc = "Debug Cleanup",
},
{
k.extract_function,
k.refactoring_extract_function,
function()
require("refactoring").refactor("Extract Function")
end,
@ -89,7 +89,7 @@ return {
desc = "Extract Function",
},
{
k.extract_function_to_file,
k.refactoring_extract_function_to_file,
function()
require("refactoring").refactor("Extract Function To File")
end,
@ -97,7 +97,7 @@ return {
desc = "Extract Function To File",
},
{
k.extract_variable,
k.refactoring_extract_variable,
function()
require("refactoring").refactor("Extract Variable")
end,
@ -105,7 +105,7 @@ return {
desc = "Extract Variable",
},
{
k.debug_print_variable,
k.refactoring_debug_print_variable,
function()
require("refactoring").debug.print_var()
end,

121
lua/lazyvim/plugins/extras/editor/telescope.lua
View file

@ -1,6 +1,4 @@
local extras = require("lazyvim.keymaps").get_keymaps().extras
local k = extras.editor.picker
local lang = extras.lang
local k = require("lazyvim.keymaps").get_keymaps()
if lazyvim_docs then
-- In case you don't want to use `:LazyExtras`,
@ -90,55 +88,64 @@ return {
},
keys = {
{
k.switch_buffer,
k.picker_switch_buffer,
"<cmd>Telescope buffers sort_mru=true sort_lastused=true<cr>",
desc = "Switch Buffer",
},
{ k.grep_root, LazyVim.pick("live_grep"), desc = "Grep (Root Dir)" },
{ k.command_history, "<cmd>Telescope command_history<cr>", desc = "Command History" },
{ k.find_files_root, LazyVim.pick("files"), desc = "Find Files (Root Dir)" },
{ k.picker_grep_root, LazyVim.pick("live_grep"), desc = "Grep (Root Dir)" },
{ k.picker_command_history, "<cmd>Telescope command_history<cr>", desc = "Command History" },
{ k.picker_find_files_root, LazyVim.pick("files"), desc = "Find Files (Root Dir)" },
-- find
{ k.find_buffers, "<cmd>Telescope buffers sort_mru=true sort_lastused=true<cr>", desc = "Buffers" },
{ k.find_config_file, LazyVim.pick.config_files(), desc = "Find Config File" },
{ k.find_files_root_alt, LazyVim.pick("files"), desc = "Find Files (Root Dir)" },
{ k.find_files_cwd, LazyVim.pick("files", { root = false }), desc = "Find Files (cwd)" },
{ k.find_git_files, "<cmd>Telescope git_files<cr>", desc = "Find Files (git-files)" },
{ k.find_recent_files, "<cmd>Telescope oldfiles<cr>", desc = "Recent" },
{ k.find_files_cwd, LazyVim.pick("oldfiles", { cwd = vim.uv.cwd() }), desc = "Recent (cwd)" },
{ k.picker_find_buffers, "<cmd>Telescope buffers sort_mru=true sort_lastused=true<cr>", desc = "Buffers" },
{ k.picker_find_config_file, LazyVim.pick.config_files(), desc = "Find Config File" },
{ k.picker_find_files_root_alt, LazyVim.pick("files"), desc = "Find Files (Root Dir)" },
{ k.picker_find_files_cwd, LazyVim.pick("files", { root = false }), desc = "Find Files (cwd)" },
{ k.picker_find_git_files, "<cmd>Telescope git_files<cr>", desc = "Find Files (git-files)" },
{ k.picker_find_recent_files, "<cmd>Telescope oldfiles<cr>", desc = "Recent" },
{ k.picker_find_files_cwd, LazyVim.pick("oldfiles", { cwd = vim.uv.cwd() }), desc = "Recent (cwd)" },
-- git
{ k.git_commits, "<cmd>Telescope git_commits<CR>", desc = "Commits" },
{ k.git_status, "<cmd>Telescope git_status<CR>", desc = "Status" },
{ k.picker_git_commits, "<cmd>Telescope git_commits<CR>", desc = "Commits" },
{ k.picker_git_status, "<cmd>Telescope git_status<CR>", desc = "Status" },
-- search
{ k.search_registers, "<cmd>Telescope registers<cr>", desc = "Registers" },
{ k.search_autocommands, "<cmd>Telescope autocommands<cr>", desc = "Auto Commands" },
{ k.search_buffer, "<cmd>Telescope current_buffer_fuzzy_find<cr>", desc = "Buffer" },
{ k.search_command_history, "<cmd>Telescope command_history<cr>", desc = "Command History" },
{ k.search_commands, "<cmd>Telescope commands<cr>", desc = "Commands" },
{ k.search_document_diagnostics, "<cmd>Telescope diagnostics bufnr=0<cr>", desc = "Document Diagnostics" },
{ k.search_workspace_diagnostics, "<cmd>Telescope diagnostics<cr>", desc = "Workspace Diagnostics" },
{ k.search_grep_root, LazyVim.pick("live_grep"), desc = "Grep (Root Dir)" },
{ k.search_grep_cwd, LazyVim.pick("live_grep", { root = false }), desc = "Grep (cwd)" },
{ k.search_help_pages, "<cmd>Telescope help_tags<cr>", desc = "Help Pages" },
{ k.search_highlight_groups, "<cmd>Telescope highlights<cr>", desc = "Search Highlight Groups" },
{ k.search_jumplist, "<cmd>Telescope jumplist<cr>", desc = "Jumplist" },
{ k.search_keymaps, "<cmd>Telescope keymaps<cr>", desc = "Key Maps" },
{ k.search_loclist, "<cmd>Telescope loclist<cr>", desc = "Location List" },
{ k.search_man_pages, "<cmd>Telescope man_pages<cr>", desc = "Man Pages" },
{ k.search_marks, "<cmd>Telescope marks<cr>", desc = "Jump to Mark" },
{ k.search_options, "<cmd>Telescope vim_options<cr>", desc = "Options" },
{ k.search_resume, "<cmd>Telescope resume<cr>", desc = "Resume" },
{ k.search_quickfix, "<cmd>Telescope quickfix<cr>", desc = "Quickfix List" },
{ k.search_word_root, LazyVim.pick("grep_string", { word_match = "-w" }), desc = "Word (Root Dir)" },
{ k.search_word_cwd, LazyVim.pick("grep_string", { root = false, word_match = "-w" }), desc = "Word (cwd)" },
{ k.search_selection_root, LazyVim.pick("grep_string"), mode = "v", desc = "Selection (Root Dir)" },
{ k.search_selection_cwd, LazyVim.pick("grep_string", { root = false }), mode = "v", desc = "Selection (cwd)" },
{ k.picker_search_registers, "<cmd>Telescope registers<cr>", desc = "Registers" },
{ k.picker_search_autocommands, "<cmd>Telescope autocommands<cr>", desc = "Auto Commands" },
{ k.picker_search_buffer, "<cmd>Telescope current_buffer_fuzzy_find<cr>", desc = "Buffer" },
{ k.picker_search_command_history, "<cmd>Telescope command_history<cr>", desc = "Command History" },
{ k.picker_search_commands, "<cmd>Telescope commands<cr>", desc = "Commands" },
{ k.picker_search_document_diagnostics, "<cmd>Telescope diagnostics bufnr=0<cr>", desc = "Document Diagnostics" },
{ k.picker_search_workspace_diagnostics, "<cmd>Telescope diagnostics<cr>", desc = "Workspace Diagnostics" },
{ k.picker_search_grep_root, LazyVim.pick("live_grep"), desc = "Grep (Root Dir)" },
{ k.picker_search_grep_cwd, LazyVim.pick("live_grep", { root = false }), desc = "Grep (cwd)" },
{ k.picker_search_help_pages, "<cmd>Telescope help_tags<cr>", desc = "Help Pages" },
{ k.picker_search_highlight_groups, "<cmd>Telescope highlights<cr>", desc = "Search Highlight Groups" },
{ k.picker_search_jumplist, "<cmd>Telescope jumplist<cr>", desc = "Jumplist" },
{ k.picker_search_keymaps, "<cmd>Telescope keymaps<cr>", desc = "Key Maps" },
{ k.picker_search_loclist, "<cmd>Telescope loclist<cr>", desc = "Location List" },
{ k.picker_search_man_pages, "<cmd>Telescope man_pages<cr>", desc = "Man Pages" },
{ k.picker_search_marks, "<cmd>Telescope marks<cr>", desc = "Jump to Mark" },
{ k.picker_search_options, "<cmd>Telescope vim_options<cr>", desc = "Options" },
{ k.picker_search_resume, "<cmd>Telescope resume<cr>", desc = "Resume" },
{ k.picker_search_quickfix, "<cmd>Telescope quickfix<cr>", desc = "Quickfix List" },
{ k.picker_search_word_root, LazyVim.pick("grep_string", { word_match = "-w" }), desc = "Word (Root Dir)" },
{
k.colorscheme_preview,
k.picker_search_word_cwd,
LazyVim.pick("grep_string", { root = false, word_match = "-w" }),
desc = "Word (cwd)",
},
{ k.picker_search_selection_root, LazyVim.pick("grep_string"), mode = "v", desc = "Selection (Root Dir)" },
{
k.picker_search_selection_cwd,
LazyVim.pick("grep_string", { root = false }),
mode = "v",
desc = "Selection (cwd)",
},
{
k.picker_colorscheme_preview,
LazyVim.pick("colorscheme", { enable_preview = true }),
desc = "Colorscheme with Preview",
},
{
k.go_to_symbol,
k.picker_go_to_symbol,
function()
require("telescope.builtin").lsp_document_symbols({
symbols = LazyVim.config.get_kind_filter(),
@ -147,7 +154,7 @@ return {
desc = "Goto Symbol",
},
{
k.go_to_symbol_workspace,
k.picker_go_to_symbol_workspace,
function()
require("telescope.builtin").lsp_dynamic_workspace_symbols({
symbols = LazyVim.config.get_kind_filter(),
@ -189,17 +196,17 @@ return {
local keymaps = {
i = {
{ k.actions.open_with_trouble, open_with_trouble },
{ k.actions.open_with_trouble_alt, open_with_trouble },
{ k.actions.find_files_no_ignore, find_files_no_ignore },
{ k.actions.find_files_with_hidden, find_files_with_hidden },
{ k.actions.cycle_history_next, actions.cycle_history_next },
{ k.actions.cycle_history_prev, actions.cycle_history_prev },
{ k.actions.preview_scrolling_down, actions.preview_scrolling_down },
{ k.actions.preview_scrolling_up, actions.preview_scrolling_up },
{ k.picker_open_with_trouble, open_with_trouble },
{ k.picker_open_with_trouble_alt, open_with_trouble },
{ k.picker_find_files_no_ignore, find_files_no_ignore },
{ k.picker_find_files_with_hidden, find_files_with_hidden },
{ k.picker_cycle_history_next, actions.cycle_history_next },
{ k.picker_cycle_history_prev, actions.cycle_history_prev },
{ k.picker_preview_scrolling_down, actions.preview_scrolling_down },
{ k.picker_preview_scrolling_up, actions.preview_scrolling_up },
},
n = {
{ k.actions.close, actions.close },
{ k.picker_close, actions.close },
},
}
local mappings = {
@ -273,8 +280,8 @@ return {
end
opts.defaults = vim.tbl_deep_extend("force", opts.defaults or {}, {
mappings = {
n = k.flash.normal == "" and {} or { [k.flash.normal] = flash },
i = k.flash.insert == "" and {} or { [k.flash.insert] = flash },
n = k.flash_normal == "" and {} or { [k.flash_normal] = flash },
i = k.flash_insert == "" and {} or { [k.flash_insert] = flash },
},
})
end,
@ -310,10 +317,10 @@ return {
local Keys = require("lazyvim.plugins.lsp.keymaps").get()
-- stylua: ignore
vim.list_extend(Keys, {
{ lang.go_to_definition, function() require("telescope.builtin").lsp_definitions({ reuse_win = true }) end, desc = "Goto Definition", has = "definition" },
{ lang.references, "<cmd>Telescope lsp_references<cr>", desc = "References", nowait = true },
{ lang.go_to_implementation, function() require("telescope.builtin").lsp_implementations({ reuse_win = true }) end, desc = "Goto Implementation" },
{ lang.go_to_type_definition, function() require("telescope.builtin").lsp_type_definitions({ reuse_win = true }) end, desc = "Goto T[y]pe Definition" },
{ k.lang_go_to_definition, function() require("telescope.builtin").lsp_definitions({ reuse_win = true }) end, desc = "Goto Definition", has = "definition" },
{ k.lang_references, "<cmd>Telescope lsp_references<cr>", desc = "References", nowait = true },
{ k.lang_go_to_implementation, function() require("telescope.builtin").lsp_implementations({ reuse_win = true }) end, desc = "Goto Implementation" },
{ k.lang_go_to_type_definition, function() require("telescope.builtin").lsp_type_definitions({ reuse_win = true }) end, desc = "Goto T[y]pe Definition" },
})
end,
},

2
lua/lazyvim/plugins/extras/lang/ansible.lua
View file

@ -1,4 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.lang.ansible
local k = require("lazyvim.keymaps").get_keymaps()
return {
recommended = function()

9
lua/lazyvim/plugins/extras/lang/clangd.lua
View file

@ -1,4 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.lang.clangd
local k = require("lazyvim.keymaps").get_keymaps()
return {
recommended = function()
return LazyVim.extras.wants({
@ -59,8 +59,11 @@ return {
-- Ensure mason installs the server
clangd = {
keys = {
k.switch_source_header == "" and {}
or { k.switch_source_header, "<cmd>ClangdSwitchSourceHeader<cr>", desc = "Switch Source/Header (C/C++)" },
k.clangd_switch_source_header == "" and {} or {
k.clangd_switch_source_header,
"<cmd>ClangdSwitchSourceHeader<cr>",
desc = "Switch Source/Header (C/C++)",
},
},
root_dir = function(fname)
return require("lspconfig.util").root_pattern(

6
lua/lazyvim/plugins/extras/lang/clojure.lua
View file

@ -1,5 +1,5 @@
local map = LazyVim.keymap_set
local k = require("lazyvim.keymaps").get_keymaps().extras.lang.clojure
local k = require("lazyvim.keymaps").get_keymaps()
return {
recommended = function()
@ -80,13 +80,13 @@ return {
map(
{ "n", "v" },
k.jump_prev_evaluation_output,
k.clojure_jump_prev_evaluation_output,
"<CMD>call search('^; -\\+$', 'bw')<CR>",
{ silent = true, buffer = true, desc = "Jumps to the beginning of previous evaluation output." }
)
map(
{ "n", "v" },
k.jump_next_evaluation_output,
k.clojure_jump_next_evaluation_output,
"<CMD>call search('^; -\\+$', 'w')<CR>",
{ silent = true, buffer = true, desc = "Jumps to the beginning of next evaluation output." }
)

6
lua/lazyvim/plugins/extras/lang/elixir.lua
View file

@ -1,4 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.lang.elixir
local k = require("lazyvim.keymaps").get_keymaps()
return {
recommended = function()
@ -14,7 +14,7 @@ return {
elixirls = {
keys = {
{
k.to_pipe,
k.elixir_to_pipe,
function()
local params = vim.lsp.util.make_position_params()
LazyVim.lsp.execute({
@ -25,7 +25,7 @@ return {
desc = "To Pipe",
},
{
k.from_pipe,
k.elixir_from_pipe,
function()
local params = vim.lsp.util.make_position_params()
LazyVim.lsp.execute({

32
lua/lazyvim/plugins/extras/lang/java.lua
View file

@ -1,7 +1,6 @@
-- This is the same as in lspconfig.configs.jdtls, but avoids
-- needing to require that when this module loads.
local k = require("lazyvim.keymaps").get_keymaps().extras.lang
local t = require("lazyvim.keymaps").get_keymaps().extras.test.core
local k = require("lazyvim.keymaps").get_keymaps()
local java_filetypes = { "java" }
@ -197,31 +196,32 @@ return {
{
mode = "n",
buffer = args.buf,
{ k.extract.prefix, group = "extract" },
{ k.extract.variable, require("jdtls").extract_variable_all, desc = "Extract Variable" },
{ k.extract.constant, require("jdtls").extract_constant, desc = "Extract Constant" },
{ k.go_to_super, require("jdtls").super_implementation, desc = "Goto Super" },
{ k.go_to_subjects, require("jdtls.tests").goto_subjects, desc = "Goto Subjects" },
{ k.organize_imports, require("jdtls").organize_imports, desc = "Organize Imports" },
{ k.lang_extract_prefix, group = "extract" },
{ k.lang_extract_variable, require("jdtls").extract_variable_all, desc = "Extract Variable" },
{ k.lang_extract_constant, require("jdtls").extract_constant, desc = "Extract Constant" },
{ k.lang_go_to_super, require("jdtls").super_implementation, desc = "Goto Super" },
{ k.lang_go_to_subjects, require("jdtls.tests").goto_subjects, desc = "Goto Subjects" },
{ k.lang_organize_imports, require("jdtls").organize_imports, desc = "Organize Imports" },
},
})
wk.add({
{
mode = "v",
buffer = args.buf,
{ k.extract.prefix, group = "extract" },
{ k.lang_extract_prefix, group = "extract" },
{
k.extract.method,
k.lang_extract_method,
[[<ESC><CMD>lua require('jdtls').extract_method(true)<CR>]],
desc = "Extract Method",
},
{
k.extract.variable,
k.lang_extract_variable,
[[<ESC><CMD>lua require('jdtls').extract_variable_all(true)<CR>]],
desc = "Extract Variable",
},
{
k.extract.constant([[<ESC><CMD>lua require('jdtls').extract_constant(true)<CR>]]),
k.lang_extract_constant,
[[<ESC><CMD>lua require('jdtls').extract_constant(true)<CR>]],
desc = "Extract Constant",
},
},
@ -239,9 +239,9 @@ return {
{
mode = "n",
buffer = args.buf,
{ t.prefix, group = "test" },
{ k.test_prefix, group = "test" },
{
t.run_all_test_files,
k.test_run_all_test_files,
function()
require("jdtls.dap").test_class({
config_overrides = type(opts.test) ~= "boolean" and opts.test.config_overrides or nil,
@ -250,7 +250,7 @@ return {
desc = "Run All Test",
},
{
t.run_nearest,
k.test_run_nearest,
function()
require("jdtls.dap").test_nearest_method({
config_overrides = type(opts.test) ~= "boolean" and opts.test.config_overrides or nil,
@ -258,7 +258,7 @@ return {
end,
desc = "Run Nearest Test",
},
{ t.run_file, require("jdtls.dap").pick_test, desc = "Run Test" },
{ k.test_run_file, require("jdtls.dap").pick_test, desc = "Run Test" },
},
})
end

4
lua/lazyvim/plugins/extras/lang/lean.lua
View file

@ -1,4 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.lang.lean
local k = require("lazyvim.keymaps").get_keymaps()
return {
recommended = function()
@ -62,7 +62,7 @@ return {
},
-- Change if you don't like the backslash
-- (comma is a popular choice on French keyboards)
leader = k.abbreviations_leader,
leader = k.lean_abbreviations_leader,
},
-- Enable suggested mappings?

4
lua/lazyvim/plugins/extras/lang/markdown.lua
View file

@ -1,4 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.lang.markdown
local k = require("lazyvim.keymaps").get_keymaps()
LazyVim.on_very_lazy(function()
vim.filetype.add({
@ -110,7 +110,7 @@ return {
ft = { "markdown", "norg", "rmd", "org" },
config = function(_, opts)
require("render-markdown").setup(opts)
LazyVim.toggle.map(k.render_markdown_toggle, {
LazyVim.toggle.map(k.markdown_render_markdown_toggle, {
name = "Render Markdown",
get = function()
return require("render-markdown.state").enabled

4
lua/lazyvim/plugins/extras/lang/omnisharp.lua
View file

@ -1,4 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.lang
local k = require("lazyvim.keymaps")
return {
recommended = function()
@ -53,7 +53,7 @@ return {
},
keys = {
{
k.go_to_definition,
k.lang_go_to_definition,
LazyVim.has("telescope.nvim") and function()
require("omnisharp_extended").telescope_lsp_definitions()
end or function()

12
lua/lazyvim/plugins/extras/lang/python.lua
View file

@ -1,4 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.lang
local k = require("lazyvim.keymaps").get_keymaps()
if lazyvim_docs then
-- LSP Server to use for Python.
@ -42,7 +42,7 @@ return {
},
keys = {
{
k.organize_imports,
k.lang_organize_imports,
LazyVim.lsp.action["source.organizeImports"],
desc = "Organize Imports",
},
@ -51,7 +51,7 @@ return {
ruff_lsp = {
keys = {
{
k.organize_imports,
k.lang_organize_imports,
LazyVim.lsp.action["source.organizeImports"],
desc = "Organize Imports",
},
@ -101,8 +101,8 @@ return {
"mfussenegger/nvim-dap-python",
-- stylua: ignore
keys = {
{ k.python.debug_method, function() require('dap-python').test_method() end, desc = "Debug Method", ft = "python" },
{ k.python.debug_class, function() require('dap-python').test_class() end, desc = "Debug Class", ft = "python" },
{ k.python_debug_method, function() require('dap-python').test_method() end, desc = "Debug Method", ft = "python" },
{ k.python_debug_class, function() require('dap-python').test_class() end, desc = "Debug Class", ft = "python" },
},
config = function()
if vim.fn.has("win32") == 1 then
@ -130,7 +130,7 @@ return {
},
-- Call config for python files and load the cached venv automatically
ft = "python",
keys = { { k.python.select_virtual_env, "<cmd>:VenvSelect<cr>", desc = "Select VirtualEnv", ft = "python" } },
keys = { { k.python_select_virtual_env, "<cmd>:VenvSelect<cr>", desc = "Select VirtualEnv", ft = "python" } },
},
{

32
lua/lazyvim/plugins/extras/lang/r.lua
View file

@ -1,5 +1,5 @@
local map = LazyVim.keymap_set
local k = require("lazyvim.keymaps").get_keymaps().extras.lang.r
local k = require("lazyvim.keymaps").get_keymaps()
return {
recommended = function()
@ -19,25 +19,25 @@ return {
-- This function will be called at the FileType event
-- of files supported by R.nvim. This is an
-- opportunity to create mappings local to buffers.
map("n", k.send, "<Plug>RDSendLine", { buffer = true })
map("v", k.send, "<Plug>RSendSelection", { buffer = true })
map("n", k.r_send, "<Plug>RDSendLine", { buffer = true })
map("v", k.r_send, "<Plug>RSendSelection", { buffer = true })
local wk = require("which-key")
wk.add({
buffer = true,
{ k.send_all, group = "all" },
{ k.send_between_marks, group = "between marks" },
{ k.send_chunks, group = "chunks" },
{ k.send_functions, group = "functions" },
{ k.send_goto, group = "goto" },
{ k.send_install, group = "install" },
{ k.send_knit, group = "knit" },
{ k.send_paragraph, group = "paragraph" },
{ k.send_quarto, group = "quarto" },
{ k.send_general, group = "r general" },
{ k.send_split_or_send, group = "split or send" },
{ k.send_terminal, group = "terminal" },
{ k.send_view, group = "view" },
{ k.r_send_all, group = "all" },
{ k.r_send_between_marks, group = "between marks" },
{ k.r_send_chunks, group = "chunks" },
{ k.r_send_functions, group = "functions" },
{ k.r_send_goto, group = "goto" },
{ k.r_send_install, group = "install" },
{ k.r_send_knit, group = "knit" },
{ k.r_send_paragraph, group = "paragraph" },
{ k.r_send_quarto, group = "quarto" },
{ k.r_send_general, group = "r general" },
{ k.r_send_split_or_send, group = "split or send" },
{ k.r_send_terminal, group = "terminal" },
{ k.r_send_view, group = "view" },
})
end,
},

8
lua/lazyvim/plugins/extras/lang/rust.lua
View file

@ -1,5 +1,5 @@
local map = LazyVim.keymap_set
local k = require("lazyvim.keymaps").get_keymaps().extras.lang.rust
local k = require("lazyvim.keymaps").get_keymaps()
return {
recommended = function()
@ -51,10 +51,10 @@ return {
opts = {
server = {
on_attach = function(_, bufnr)
map("n", k.code_action, function()
map("n", k.rust_code_action, function()
vim.cmd.RustLsp("codeAction")
end, { desc = "Code Action", buffer = bufnr })
map("n", k.debuggables, function()
map("n", k.rust_debuggables, function()
vim.cmd.RustLsp("debuggables")
end, { desc = "Rust Debuggables", buffer = bufnr })
end,
@ -101,7 +101,7 @@ return {
taplo = {
keys = {
{
k.show_crate_documentation,
k.rust_show_crate_documentation,
function()
if vim.fn.expand("%:t") == "Cargo.toml" and require("crates").popup_available() then
require("crates").show_popup()

6
lua/lazyvim/plugins/extras/lang/scala.lua
View file

@ -1,4 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.lang.scala
local k = require("lazyvim.keymaps").get_keymaps()
return {
recommended = function()
@ -23,14 +23,14 @@ return {
metals = {
keys = {
{
k.metals_commands,
k.scala_metals_commands,
function()
require("telescope").extensions.metals.commands()
end,
desc = "Metals commands",
},
{
k.metals_compile_cascade,
k.scala_metals_compile_cascade,
function()
require("metals").compile_cascade()
end,

4
lua/lazyvim/plugins/extras/lang/sql.lua
View file

@ -1,4 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.lang.sql
local k = require("lazyvim.keymaps").get_keymaps()
if lazyvim_docs then
-- The setup below will automatically configure connections without the need for manual input each time.
@ -73,7 +73,7 @@ return {
cmd = { "DBUI", "DBUIToggle", "DBUIAddConnection", "DBUIFindBuffer" },
dependencies = "vim-dadbod",
keys = {
{ k.toggle_dbui, "<cmd>DBUIToggle<CR>", desc = "Toggle DBUI" },
{ k.sql_toggle_dbui, "<cmd>DBUIToggle<CR>", desc = "Toggle DBUI" },
},
init = function()
local data_path = vim.fn.stdpath("data")

4
lua/lazyvim/plugins/extras/lang/svelte.lua
View file

@ -1,4 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.lang
local k = require("lazyvim.keymaps").get_keymaps()
return {
recommended = function()
@ -28,7 +28,7 @@ return {
svelte = {
keys = {
{
k.organize_imports,
k.lang_organize_imports,
LazyVim.lsp.action["source.organizeImports"],
desc = "Organize Imports",
},

6
lua/lazyvim/plugins/extras/lang/tex.lua
View file

@ -1,4 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.lang.tex
local k = require("lazyvim.keymaps").get_keymaps()
return {
recommended = function()
@ -32,7 +32,7 @@ return {
vim.g.vimtex_quickfix_method = vim.fn.executable("pplatex") == 1 and "pplatex" or "latexlog"
end,
keys = {
{ k.prefix, "", desc = "+vimtex" },
{ k.tex_prefix, "", desc = "+vimtex" },
},
},
@ -44,7 +44,7 @@ return {
servers = {
texlab = {
keys = {
{ k.vimtex_docs, "<plug>(vimtex-doc-package)", desc = "Vimtex Docs", silent = true },
{ k.tex_vimtex_docs, "<plug>(vimtex-doc-package)", desc = "Vimtex Docs", silent = true },
},
},
},

16
lua/lazyvim/plugins/extras/lang/typescript.lua
View file

@ -1,4 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.lang
local k = require("lazyvim.keymaps").get_keymaps()
return {
recommended = function()
@ -68,7 +68,7 @@ return {
},
keys = {
{
k.typescript.go_to_source_definition,
k.typescript_go_to_source_definition,
function()
local params = vim.lsp.util.make_position_params()
LazyVim.lsp.execute({
@ -80,7 +80,7 @@ return {
desc = "Goto Source Definition",
},
{
k.file_references,
k.lang_file_references,
function()
LazyVim.lsp.execute({
command = "typescript.findAllFileReferences",
@ -91,27 +91,27 @@ return {
desc = "File References",
},
{
k.organize_imports,
k.lang_organize_imports,
LazyVim.lsp.action["source.organizeImports"],
desc = "Organize Imports",
},
{
k.add_missing_imports,
k.lang_add_missing_imports,
LazyVim.lsp.action["source.addMissingImports.ts"],
desc = "Add missing imports",
},
{
k.remove_unused_imports,
k.lang_remove_unused_imports,
LazyVim.lsp.action["source.removeUnused.ts"],
desc = "Remove unused imports",
},
{
k.fix_all_diagnostics,
k.lang_fix_all_diagnostics,
LazyVim.lsp.action["source.fixAll.ts"],
desc = "Fix all diagnostics",
},
{
k.select_lang_version,
k.lang_select_lang_version,
function()
LazyVim.lsp.execute({ command = "typescript.selectTypeScriptVersion" })
end,

24
lua/lazyvim/plugins/extras/test/core.lua
View file

@ -1,4 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.test.core
local k = require("lazyvim.keymaps").get_keymaps()
return {
recommended = true,
@ -107,16 +107,16 @@ return {
end,
-- stylua: ignore
keys = {
{ k.prefix, "", desc = "+test"},
{ k.run_file, function() require("neotest").run.run(vim.fn.expand("%")) end, desc = "Run File" },
{ k.run_all_test_files, function() require("neotest").run.run(vim.uv.cwd()) end, desc = "Run All Test Files" },
{ k.run_nearest, function() require("neotest").run.run() end, desc = "Run Nearest" },
{ k.run_last, function() require("neotest").run.run_last() end, desc = "Run Last" },
{ k.toggle_summary, function() require("neotest").summary.toggle() end, desc = "Toggle Summary" },
{ k.show_output, function() require("neotest").output.open({ enter = true, auto_close = true }) end, desc = "Show Output" },
{ k.toggle_output_panel, function() require("neotest").output_panel.toggle() end, desc = "Toggle Output Panel" },
{ k.stop, function() require("neotest").run.stop() end, desc = "Stop" },
{ k.toggle_watch, function() require("neotest").watch.toggle(vim.fn.expand("%")) end, desc = "Toggle Watch" },
{ k.test_prefix, "", desc = "+test"},
{ k.test_run_file, function() require("neotest").run.run(vim.fn.expand("%")) end, desc = "Run File" },
{ k.test_run_all_test_files, function() require("neotest").run.run(vim.uv.cwd()) end, desc = "Run All Test Files" },
{ k.test_run_nearest, function() require("neotest").run.run() end, desc = "Run Nearest" },
{ k.test_run_last, function() require("neotest").run.run_last() end, desc = "Run Last" },
{ k.test_toggle_summary, function() require("neotest").summary.toggle() end, desc = "Toggle Summary" },
{ k.test_show_output, function() require("neotest").output.open({ enter = true, auto_close = true }) end, desc = "Show Output" },
{ k.test_toggle_output_panel, function() require("neotest").output_panel.toggle() end, desc = "Toggle Output Panel" },
{ k.test_stop, function() require("neotest").run.stop() end, desc = "Stop" },
{ k.test_toggle_watch, function() require("neotest").watch.toggle(vim.fn.expand("%")) end, desc = "Toggle Watch" },
},
},
{
@ -124,7 +124,7 @@ return {
optional = true,
-- stylua: ignore
keys = {
{ k.debug_nearest, function() require("neotest").run.run({strategy = "dap"}) end, desc = "Debug Nearest" },
{ k.test_debug_nearest, function() require("neotest").run.run({strategy = "dap"}) end, desc = "Debug Nearest" },
},
},
}

20
lua/lazyvim/plugins/extras/ui/alpha.lua
View file

@ -1,4 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().ui.dashboard
local k = require("lazyvim.keymaps").get_keymaps()
return {
@ -26,15 +26,15 @@ return {
-- stylua: ignore
dashboard.section.buttons.val = {}
local actions = {
{ k.find_file, "" .. " Find file", LazyVim.pick() },
{ k.new_file, "" .. " New file", [[<cmd> ene <BAR> startinsert <cr>]] },
{ k.recent_files, "" .. " Recent files", LazyVim.pick("oldfiles") },
{ k.find_text, "" .. " Find text", LazyVim.pick("live_grep") },
{ k.config, "" .. " Config", LazyVim.pick.config_files() },
{ k.restore_session, "" .. " Restore Session", [[<cmd> lua require("persistence").load() <cr>]] },
{ k.lazy_extras, "" .. " Lazy Extras", "<cmd> LazyExtras <cr>" },
{ k.lazy, "󰒲 " .. " Lazy", "<cmd> Lazy <cr>" },
{ k.quit, "" .. " Quit", "<cmd> qa <cr>" },
{ k.dashboard_find_file, "" .. " Find file", LazyVim.pick() },
{ k.dashboard_new_file, "" .. " New file", [[<cmd> ene <BAR> startinsert <cr>]] },
{ k.dashboard_recent_files, "" .. " Recent files", LazyVim.pick("oldfiles") },
{ k.dashboard_find_text, "" .. " Find text", LazyVim.pick("live_grep") },
{ k.dashboard_config, "" .. " Config", LazyVim.pick.config_files() },
{ k.dashboard_restore_session, "" .. " Restore Session", [[<cmd> lua require("persistence").load() <cr>]] },
{ k.dashboard_lazy_extras, "" .. " Lazy Extras", "<cmd> LazyExtras <cr>" },
{ k.dashboard_lazy, "󰒲 " .. " Lazy", "<cmd> Lazy <cr>" },
{ k.dashboard_quit, "" .. " Quit", "<cmd> qa <cr>" },
}
for _, action in ipairs(actions) do

15
lua/lazyvim/plugins/extras/ui/edgy.lua
View file

@ -1,5 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.ui.edgy
local r = require("lazyvim.keymaps").get_keymaps().keymaps.resize_window
local k = require("lazyvim.keymaps").get_keymaps()
return {
-- edgy
@ -8,32 +7,32 @@ return {
event = "VeryLazy",
keys = {
{
k.toggle,
k.edgy_toggle,
function()
require("edgy").toggle()
end,
desc = "Edgy Toggle",
},
-- stylua: ignore
{ k.select_window, function() require("edgy").select() end, desc = "Edgy Select Window" },
{ k.edgy_select_window, function() require("edgy").select() end, desc = "Edgy Select Window" },
},
opts = function()
local keys = {}
local actions = {
-- increase width
[r.increase_width] = function(win)
[k.size_increase_width] = function(win)
win:resize("width", 2)
end,
-- decrease width
[r.decrease_width] = function(win)
[k.size_decrease_width] = function(win)
win:resize("width", -2)
end,
-- increase height
[r.increase_height] = function(win)
[k.size_increase_height] = function(win)
win:resize("height", 2)
end,
-- decrease height
[r.decrease_height] = function(win)
[k.size_decrease_height] = function(win)
win:resize("height", -2)
end,
}

4
lua/lazyvim/plugins/extras/ui/mini-animate.lua
View file

@ -1,5 +1,5 @@
-- animations
local k = require("lazyvim.keymaps").get_keymaps().extras.ui.mini_animate
local k = require("lazyvim.keymaps").get_keymaps()
return {
"echasnovski/mini.animate",
@ -23,7 +23,7 @@ return {
end,
})
LazyVim.toggle.map(k.toggle, {
LazyVim.toggle.map(k.minianimae_toggle, {
name = "Mini Animate",
get = function()
return not vim.g.minianimate_disable

4
lua/lazyvim/plugins/extras/ui/treesitter-context.lua
View file

@ -1,5 +1,5 @@
-- Show context of the current function
local k = require("lazyvim.keymaps").get_keymaps().extras.ui.treesitter_context
local k = require("lazyvim.keymaps").get_keymaps()
return {
"nvim-treesitter/nvim-treesitter-context",
@ -7,7 +7,7 @@ return {
opts = function()
local tsc = require("treesitter-context")
LazyVim.toggle.map(k.toggle, {
LazyVim.toggle.map(k.tscontext_toggle, {
name = "Treesitter Context",
get = tsc.enabled,
set = function(state)

10
lua/lazyvim/plugins/extras/util/chezmoi.lua
View file

@ -1,4 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.util.chezmoi
local k = require("lazyvim.keymaps").get_keymaps()
local pick_chezmoi = function()
if LazyVim.pick.picker.name == "telescope" then
@ -37,7 +37,7 @@ return {
"xvzc/chezmoi.nvim",
keys = {
{
k.pick_chezmoi,
k.chezmoi_pick_chezmoi,
pick_chezmoi,
desc = "Chezmoi",
},
@ -53,7 +53,7 @@ return {
on_watch = false,
},
telescope = {
select = k.select == "" and {} or { k.select },
select = k.chezmoi_select == "" and {} or { k.chezmoi_select },
},
},
init = function()
@ -70,7 +70,7 @@ return {
"nvimdev/dashboard-nvim",
optional = true,
opts = function(_, opts)
if not k.key or k.key == "" then
if not k.chezmoi_key or k.chezmoi_key == "" then
return opts
end
@ -78,7 +78,7 @@ return {
action = pick_chezmoi,
desc = " Config",
icon = "",
key = k.key,
key = k.chezmoi_key,
}
projects.desc = projects.desc .. string.rep(" ", 43 - #projects.desc)

6
lua/lazyvim/plugins/extras/util/gitui.lua
View file

@ -1,4 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().keymaps.lazygit
local k = require("lazyvim.keymaps").get_keymaps()
return {
@ -8,14 +8,14 @@ return {
opts = { ensure_installed = { "gitui" } },
keys = {
{
k.toggle_cwd,
k.lazygit_toggle_cwd,
function()
LazyVim.terminal.open({ "gitui" }, { esc_esc = false, ctrl_hjkl = false })
end,
desc = "GitUi (cwd)",
},
{
k.toggle_root,
k.lazygit_toggle_root,
function()
LazyVim.terminal.open({ "gitui" }, { cwd = LazyVim.root.get(), esc_esc = false, ctrl_hjkl = false })
end,

32
lua/lazyvim/plugins/extras/util/octo.lua
View file

@ -1,4 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.util.octo
local k = require("lazyvim.keymaps").get_keymaps()
return {
@ -17,22 +17,22 @@ return {
picker = "telescope",
},
keys = {
{ k.issue_list, "<cmd>Octo issue list<CR>", desc = "List Issues (Octo)" },
{ k.issue_search, "<cmd>Octo issue search<CR>", desc = "Search Issues (Octo)" },
{ k.pr_list, "<cmd>Octo pr list<CR>", desc = "List PRs (Octo)" },
{ k.pr_search, "<cmd>Octo pr search<CR>", desc = "Search PRs (Octo)" },
{ k.repo_list, "<cmd>Octo repo list<CR>", desc = "List Repos (Octo)" },
{ k.search, "<cmd>Octo search<CR>", desc = "Search (Octo)" },
{ k.octo_issue_list, "<cmd>Octo issue list<CR>", desc = "List Issues (Octo)" },
{ k.octo_issue_search, "<cmd>Octo issue search<CR>", desc = "Search Issues (Octo)" },
{ k.octo_pr_list, "<cmd>Octo pr list<CR>", desc = "List PRs (Octo)" },
{ k.octo_pr_search, "<cmd>Octo pr search<CR>", desc = "Search PRs (Octo)" },
{ k.octo_repo_list, "<cmd>Octo repo list<CR>", desc = "List Repos (Octo)" },
{ k.octo_search, "<cmd>Octo search<CR>", desc = "Search (Octo)" },
{ k.assignee, "", desc = "+assignee (Octo)", ft = "octo" },
{ k.comment_code, "", desc = "+comment/code (Octo)", ft = "octo" },
{ k.label, "", desc = "+label (Octo)", ft = "octo" },
{ k.issue, "", desc = "+issue (Octo)", ft = "octo" },
{ k.react, "", desc = "+react (Octo)", ft = "octo" },
{ k.pr, "", desc = "+pr (Octo)", ft = "octo" },
{ k.review, "", desc = "+review (Octo)", ft = "octo" },
{ k.insert_at, "@<C-x><C-o>", mode = "i", ft = "octo", silent = true },
{ k.insert_hashtag, "#<C-x><C-o>", mode = "i", ft = "octo", silent = true },
{ k.octo_assignee, "", desc = "+assignee (Octo)", ft = "octo" },
{ k.octo_comment_code, "", desc = "+comment/code (Octo)", ft = "octo" },
{ k.octo_label, "", desc = "+label (Octo)", ft = "octo" },
{ k.octo_issue, "", desc = "+issue (Octo)", ft = "octo" },
{ k.octo_react, "", desc = "+react (Octo)", ft = "octo" },
{ k.octo_pr, "", desc = "+pr (Octo)", ft = "octo" },
{ k.octo_review, "", desc = "+review (Octo)", ft = "octo" },
{ k.octo_insert_at, "@<C-x><C-o>", mode = "i", ft = "octo", silent = true },
{ k.octo_insert_hashtag, "#<C-x><C-o>", mode = "i", ft = "octo", silent = true },
},
},

11
lua/lazyvim/plugins/extras/util/project.lua
View file

@ -1,5 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.editor.picker
local d = require("lazyvim.keymaps").get_keymaps().ui.dashboard
local k = require("lazyvim.keymaps").get_keymaps()
local pick = nil
@ -104,7 +103,7 @@ return {
"nvim-telescope/telescope.nvim",
optional = true,
keys = {
{ k.find_projects, pick, desc = "Projects" },
{ k.picker_find_projects, pick, desc = "Projects" },
},
},
@ -112,7 +111,7 @@ return {
"ibhagwan/fzf-lua",
optional = true,
keys = {
{ k.find_projects, pick, desc = "Projects" },
{ k.picker_find_projects, pick, desc = "Projects" },
},
},
@ -146,7 +145,7 @@ return {
"nvimdev/dashboard-nvim",
optional = true,
opts = function(_, opts)
if not d.projects or d.projects == "" then
if not k.dashboard_projects or k.dashboard_projects == "" then
return opts
end
@ -154,7 +153,7 @@ return {
action = pick,
desc = " Projects",
icon = "",
key = d.projects,
key = k.dashboard_projects,
}
projects.desc = projects.desc .. string.rep(" ", 43 - #projects.desc)

16
lua/lazyvim/plugins/extras/util/rest.lua
View file

@ -1,4 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.util.rest.kulala
local k = require("lazyvim.keymaps").get_keymaps()
vim.filetype.add({
extension = {
@ -10,11 +10,15 @@ return {
"mistweaverco/kulala.nvim",
ft = "http",
keys = {
{ k.prefix, "", desc = "+Rest" },
{ k.send_request, "<cmd>lua require('kulala').run()<cr>", desc = "Send the request" },
{ k.toggle_view, "<cmd>lua require('kulala').toggle_view()<cr>", desc = "Toggle headers/body" },
{ k.jump_to_previous_request, "<cmd>lua require('kulala').jump_prev()<cr>", desc = "Jump to previous request" },
{ k.jump_to_next_request, "<cmd>lua require('kulala').jump_next()<cr>", desc = "Jump to next request" },
{ k.kulala_prefix, "", desc = "+Rest" },
{ k.kulala_send_request, "<cmd>lua require('kulala').run()<cr>", desc = "Send the request" },
{ k.kulala_toggle_view, "<cmd>lua require('kulala').toggle_view()<cr>", desc = "Toggle headers/body" },
{
k.kulala_jump_to_previous_request,
"<cmd>lua require('kulala').jump_prev()<cr>",
desc = "Jump to previous request",
},
{ k.kulala_jump_to_next_request, "<cmd>lua require('kulala').jump_next()<cr>", desc = "Jump to next request" },
},
opts = {},
},

8
lua/lazyvim/plugins/extras/vscode.lua
View file

@ -29,15 +29,15 @@ Config.options.defaults.cond = function(plugin)
end
local map = LazyVim.keymap_set
local k = require("lazyvim.keymaps").get_keymaps().extras.vscode
local k = require("lazyvim.keymaps").get_keymaps()
-- Add some vscode specific keymaps
vim.api.nvim_create_autocmd("User", {
pattern = "LazyVimKeymapsDefaults",
callback = function()
map("n", k.find, "<cmd>Find<cr>")
map("n", k.find_in_files, [[<cmd>lua require('vscode').action('workbench.action.findInFiles')<cr>]])
map("n", k.go_to_symbol, [[<cmd>lua require('vscode').action('workbench.action.gotoSymbol')<cr>]])
map("n", k.vscode_find, "<cmd>Find<cr>")
map("n", k.vscode_find_in_files, [[<cmd>lua require('vscode').action('workbench.action.findInFiles')<cr>]])
map("n", k.vscode_go_to_symbol, [[<cmd>lua require('vscode').action('workbench.action.gotoSymbol')<cr>]])
end,
})

4
lua/lazyvim/plugins/formatting.lua
View file

@ -1,5 +1,5 @@
local M = {}
local k = require("lazyvim.keymaps").get_keymaps().formatting
local k = require("lazyvim.keymaps").get_keymaps()
---@param opts conform.setupOpts
function M.setup(_, opts)
@ -26,7 +26,7 @@ return {
cmd = "ConformInfo",
keys = {
{
k.conform.format,
k.conform_format,
function()
require("conform").format({ formatters = { "injected" }, timeout_ms = 3000 })
end,

4
lua/lazyvim/plugins/lsp/init.lua
View file

@ -1,4 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.lang
local k = require("lazyvim.keymaps").get_keymaps()
return {
-- lspconfig
{
@ -264,7 +264,7 @@ return {
"williamboman/mason.nvim",
cmd = "Mason",
keys = { { k.mason, "<cmd>Mason<cr>", desc = "Mason" } },
keys = { { k.lang_mason, "<cmd>Mason<cr>", desc = "Mason" } },
build = ":MasonUpdate",
opts_extend = { "ensure_installed" },
opts = {

46
lua/lazyvim/plugins/lsp/keymaps.lua
View file

@ -1,5 +1,5 @@
local M = {}
local k = require("lazyvim.keymaps").get_keymaps().extras.lang
local k = require("lazyvim.keymaps").get_keymaps()
---@type LazyKeysLspSpec[]|nil
M._keys = nil
@ -13,35 +13,41 @@ function M.get()
return M._keys
end
local actions = {
{ k.lsp_info, "<cmd>LspInfo<cr>", desc = "Lsp Info" },
{ k.go_to_definition, vim.lsp.buf.definition, desc = "Goto Definition", has = "definition" },
{ k.references, vim.lsp.buf.references, desc = "References", nowait = true },
{ k.go_to_implementation, vim.lsp.buf.implementation, desc = "Goto Implementation" },
{ k.go_to_type_definition, vim.lsp.buf.type_definition, desc = "Goto T[y]pe Definition" },
{ k.go_to_declaration, vim.lsp.buf.declaration, desc = "Goto Declaration" },
{ k.hover, vim.lsp.buf.hover, desc = "Hover" },
{ k.signature_help, vim.lsp.buf.signature_help, desc = "Signature Help", has = "signatureHelp" },
{ k.insert_signature_help, vim.lsp.buf.signature_help, mode = "i", desc = "Signature Help", has = "signatureHelp" },
{ k.code_action, vim.lsp.buf.code_action, desc = "Code Action", mode = { "n", "v" }, has = "codeAction" },
{ k.run_codelens, vim.lsp.codelens.run, desc = "Run Codelens", mode = { "n", "v" }, has = "codeLens" },
{ k.lang_lsp_info, "<cmd>LspInfo<cr>", desc = "Lsp Info" },
{ k.lang_go_to_definition, vim.lsp.buf.definition, desc = "Goto Definition", has = "definition" },
{ k.lang_references, vim.lsp.buf.references, desc = "References", nowait = true },
{ k.lang_go_to_implementation, vim.lsp.buf.implementation, desc = "Goto Implementation" },
{ k.lang_go_to_type_definition, vim.lsp.buf.type_definition, desc = "Goto T[y]pe Definition" },
{ k.lang_go_to_declaration, vim.lsp.buf.declaration, desc = "Goto Declaration" },
{ k.lang_hover, vim.lsp.buf.hover, desc = "Hover" },
{ k.lang_signature_help, vim.lsp.buf.signature_help, desc = "Signature Help", has = "signatureHelp" },
{
k.refresh_codelens,
k.lang_insert_signature_help,
vim.lsp.buf.signature_help,
mode = "i",
desc = "Signature Help",
has = "signatureHelp",
},
{ k.lang_code_action, vim.lsp.buf.code_action, desc = "Code Action", mode = { "n", "v" }, has = "codeAction" },
{ k.lang_run_codelens, vim.lsp.codelens.run, desc = "Run Codelens", mode = { "n", "v" }, has = "codeLens" },
{
k.lang_refresh_codelens,
vim.lsp.codelens.refresh,
desc = "Refresh & Display Codelens",
mode = { "n" },
has = "codeLens",
},
{
k.rename_file,
k.lang_rename_file,
LazyVim.lsp.rename_file,
desc = "Rename File",
mode = { "n" },
has = { "workspace/didRenameFiles", "workspace/willRenameFiles" },
},
{ k.rename, vim.lsp.buf.rename, desc = "Rename", has = "rename" },
{ k.source_action, LazyVim.lsp.action.source, desc = "Source Action", has = "codeAction" },
{ k.lang_rename, vim.lsp.buf.rename, desc = "Rename", has = "rename" },
{ k.lang_source_action, LazyVim.lsp.action.source, desc = "Source Action", has = "codeAction" },
{
k.next_reference,
k.lang_next_reference,
function()
LazyVim.lsp.words.jump(vim.v.count1)
end,
@ -52,7 +58,7 @@ function M.get()
end,
},
{
k.prev_reference,
k.lang_prev_reference,
function()
LazyVim.lsp.words.jump(-vim.v.count1)
end,
@ -63,7 +69,7 @@ function M.get()
end,
},
{
k.cycle_next_reference,
k.lang_cycle_next_reference,
function()
LazyVim.lsp.words.jump(vim.v.count1, true)
end,
@ -74,7 +80,7 @@ function M.get()
end,
},
{
k.cycle_prev_reference,
k.lang_cycle_prev_reference,
function()
LazyVim.lsp.words.jump(-vim.v.count1, true)
end,

43
lua/lazyvim/plugins/treesitter.lua
View file

@ -1,12 +1,12 @@
local k = require("lazyvim.keymaps").get_keymaps().treesitter
local k = require("lazyvim.keymaps").get_keymaps()
return {
{
"folke/which-key.nvim",
opts = {
spec = {
{ k.decrement_selection, desc = "Decrement Selection", mode = "x" },
{ k.increment_selection, desc = "Increment Selection", mode = { "x", "n" } },
{ k.ts_decrement_selection, desc = "Decrement Selection", mode = "x" },
{ k.ts_increment_selection, desc = "Increment Selection", mode = { "x", "n" } },
},
},
},
@ -31,8 +31,8 @@ return {
end,
cmd = { "TSUpdateSync", "TSUpdate", "TSInstall" },
keys = {
{ k.increment_selection, desc = "Increment Selection" },
{ k.decrement_selection, desc = "Decrement Selection", mode = "x" },
{ k.ts_increment_selection, desc = "Increment Selection" },
{ k.ts_decrement_selection, desc = "Decrement Selection", mode = "x" },
},
opts_extend = { "ensure_installed" },
---@type TSConfig
@ -69,34 +69,37 @@ return {
incremental_selection = {
enable = true,
keymaps = {
init_selection = (k.increment_selection and k.increment_selection ~= "") and k.increment_selection or false,
node_incremental = (k.increment_selection and k.increment_selection ~= "") and k.increment_selection or false,
init_selection = (k.ts_increment_selection and k.ts_increment_selection ~= "") and k.ts_increment_selection
or false,
node_incremental = (k.ts_increment_selection and k.ts_increment_selection ~= "") and k.ts_increment_selection
or false,
scope_incremental = false,
node_decremental = (k.decrement_selection and k.decrement_selection ~= "") and k.decrement_selection or false,
node_decremental = (k.ts_decrement_selection and k.ts_decrement_selection ~= "") and k.ts_decrement_selection
or false,
},
},
textobjects = {
move = {
enable = true,
goto_next_start = {
[k.textobjects.goto_next_start.function_outer] = "@function.outer",
[k.textobjects.goto_next_start.class_outer] = "@class.outer",
[k.textobjects.goto_next_start.parameter_inner] = "@parameter.inner",
[k.ts_ns_function_outer] = "@function.outer",
[k.ts_ns_class_outer] = "@class.outer",
[k.ts_ns_parameter_inner] = "@parameter.inner",
},
goto_next_end = {
[k.textobjects.goto_next_end.function_outer] = "@function.outer",
[k.textobjects.goto_next_end.class_outer] = "@class.outer",
[k.textobjects.goto_next_end.parameter_inner] = "@parameter.inner",
[k.ts_ne_function_outer] = "@function.outer",
[k.ts_ne_class_outer] = "@class.outer",
[k.ts_ne_parameter_inner] = "@parameter.inner",
},
goto_previous_start = {
[k.textobjects.goto_previous_start.function_outer] = "@function.outer",
[k.textobjects.goto_previous_start.class_outer] = "@class.outer",
[k.textobjects.goto_previous_start.parameter_inner] = "@parameter.inner",
[k.ts_ps_function_outer] = "@function.outer",
[k.ts_ps_class_outer] = "@class.outer",
[k.ts_ps_parameter_inner] = "@parameter.inner",
},
goto_previous_end = {
[k.textobjects.goto_previous_end.function_outer] = "@function.outer",
[k.textobjects.goto_previous_end.class_outer] = "@class.outer",
[k.textobjects.goto_previous_end.parameter_inner] = "@parameter.inner",
[k.ts_pe_function_outer] = "@function.outer",
[k.ts_pe_class_outer] = "@class.outer",
[k.ts_pe_parameter_inner] = "@parameter.inner",
},
},
},

66
lua/lazyvim/plugins/ui.lua
View file

@ -1,4 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().ui
local k = require("lazyvim.keymaps").get_keymaps()
return {
-- Better `vim.notify()`
@ -6,7 +6,7 @@ return {
"rcarriga/nvim-notify",
keys = {
{
k.nvim_notify.dismiss_all_notifications,
k.nvimnotify_dismiss_all_notifications,
function()
require("notify").dismiss({ silent = true, pending = true })
end,
@ -42,29 +42,29 @@ return {
"akinsho/bufferline.nvim",
event = "VeryLazy",
keys = {
{ k.bufferline.toggle_pin, "<Cmd>BufferLineTogglePin<CR>", desc = "Toggle Pin" },
{ k.bufferline_toggle_pin, "<Cmd>BufferLineTogglePin<CR>", desc = "Toggle Pin" },
{
k.bufferline.delete_non_pinned_buffers,
k.bufferline_delete_non_pinned_buffers,
"<Cmd>BufferLineGroupClose ungrouped<CR>",
desc = "Delete Non-Pinned Buffers",
},
{ k.bufferline.delete_other_buffers, "<Cmd>BufferLineCloseOthers<CR>", desc = "Delete Other Buffers" },
{ k.bufferline_delete_other_buffers, "<Cmd>BufferLineCloseOthers<CR>", desc = "Delete Other Buffers" },
{
k.bufferline.delete_buffers_to_the_right,
k.bufferline_delete_buffers_to_the_right,
"<Cmd>BufferLineCloseRight<CR>",
desc = "Delete Buffers to the Right",
},
{
k.bufferline.delete_buffers_to_the_left,
k.bufferline_delete_buffers_to_the_left,
"<Cmd>BufferLineCloseLeft<CR>",
desc = "Delete Buffers to the Left",
},
{ k.bufferline.prev_buffer, "<cmd>BufferLineCyclePrev<cr>", desc = "Prev Buffer" },
{ k.bufferline.next_buffer, "<cmd>BufferLineCycleNext<cr>", desc = "Next Buffer" },
{ k.bufferline.prev_buffer_alt, "<cmd>BufferLineCyclePrev<cr>", desc = "Prev Buffer" },
{ k.bufferline.next_buffer_alt, "<cmd>BufferLineCycleNext<cr>", desc = "Next Buffer" },
{ k.bufferline.move_buffer_prev, "<cmd>BufferLineMovePrev<cr>", desc = "Move buffer prev" },
{ k.bufferline.move_buffer_next, "<cmd>BufferLineMoveNext<cr>", desc = "Move buffer next" },
{ k.bufferline_prev_buffer, "<cmd>BufferLineCyclePrev<cr>", desc = "Prev Buffer" },
{ k.bufferline_next_buffer, "<cmd>BufferLineCycleNext<cr>", desc = "Next Buffer" },
{ k.bufferline_prev_buffer_alt, "<cmd>BufferLineCyclePrev<cr>", desc = "Prev Buffer" },
{ k.bufferline_next_buffer_alt, "<cmd>BufferLineCycleNext<cr>", desc = "Next Buffer" },
{ k.bufferline_move_buffer_prev, "<cmd>BufferLineMovePrev<cr>", desc = "Move buffer prev" },
{ k.bufferline_move_buffer_next, "<cmd>BufferLineMoveNext<cr>", desc = "Move buffer next" },
},
opts = {
options = {
@ -240,7 +240,7 @@ return {
"lukas-reineke/indent-blankline.nvim",
event = "LazyFile",
opts = function()
LazyVim.toggle.map(k.indent_blankline.toggle, {
LazyVim.toggle.map(k.indentblankline_toggle, {
name = "Indention Guides",
get = function()
return require("ibl.config").get_config(0).enabled
@ -309,15 +309,15 @@ return {
},
-- stylua: ignore
keys = {
{ k.noice.prefix, "", desc = "+noice"},
{ k.noice.redirect_cmdline, function() require("noice").redirect(vim.fn.getcmdline()) end, mode = "c", desc = "Redirect Cmdline" },
{ k.noice.last_message, function() require("noice").cmd("last") end, desc = "Noice Last Message" },
{ k.noice.history, function() require("noice").cmd("history") end, desc = "Noice History" },
{ k.noice.all, function() require("noice").cmd("all") end, desc = "Noice All" },
{ k.noice.dismiss, function() require("noice").cmd("dismiss") end, desc = "Dismiss All" },
{ k.noice.pick, function() require("noice").cmd("pick") end, desc = "Noice Picker (Telescope/FzfLua)" },
{ k.noice.scroll_forward, function() if not require("noice.lsp").scroll(4) then return "<c-f>" end end, silent = true, expr = true, desc = "Scroll Forward", mode = {"i", "n", "s"} },
{ k.noice.scroll_backward, function() if not require("noice.lsp").scroll(-4) then return "<c-b>" end end, silent = true, expr = true, desc = "Scroll Backward", mode = {"i", "n", "s"}},
{ k.noice_prefix, "", desc = "+noice"},
{ k.noice_redirect_cmdline, function() require("noice").redirect(vim.fn.getcmdline()) end, mode = "c", desc = "Redirect Cmdline" },
{ k.noice_last_message, function() require("noice").cmd("last") end, desc = "Noice Last Message" },
{ k.noice_history, function() require("noice").cmd("history") end, desc = "Noice History" },
{ k.noice_all, function() require("noice").cmd("all") end, desc = "Noice All" },
{ k.noice_dismiss, function() require("noice").cmd("dismiss") end, desc = "Dismiss All" },
{ k.noice_pick, function() require("noice").cmd("pick") end, desc = "Noice Picker (Telescope/FzfLua)" },
{ k.noice_scroll_forward, function() if not require("noice.lsp").scroll(4) then return "<c-f>" end end, silent = true, expr = true, desc = "Scroll Forward", mode = {"i", "n", "s"} },
{ k.noice_scroll_backward, function() if not require("noice.lsp").scroll(-4) then return "<c-b>" end end, silent = true, expr = true, desc = "Scroll Backward", mode = {"i", "n", "s"}},
},
config = function(_, opts)
-- HACK: noice shows messages from before it was enabled,
@ -374,49 +374,49 @@ return {
action = "lua LazyVim.pick()()",
desc = " Find File",
icon = "",
key = k.dashboard.find_file,
key = k.dashboard_find_file,
},
{
action = "ene | startinsert",
desc = " New File",
icon = "",
key = k.dashboard.new_file,
key = k.dashboard_new_file,
},
{
action = 'lua LazyVim.pick("oldfiles")()',
desc = " Recent Files",
icon = "",
key = k.dashboard.recent_files,
key = k.dashboard_recent_files,
},
{
action = 'lua LazyVim.pick("live_grep")()',
desc = " Find Text",
icon = "",
key = k.dashboard.find_text,
key = k.dashboard_find_text,
},
{
action = "lua LazyVim.pick.config_files()()",
action = "lua LazyVim.pick()()",
desc = " Config",
icon = "",
key = k.dashboard.config,
key = k.dashboard_config,
},
{
action = 'lua require("persistence").load()',
desc = " Restore Session",
icon = "",
key = k.dashboard.restore_session,
key = k.dashboard_restore_session,
},
{
action = "LazyExtras",
desc = " Lazy Extras",
icon = "",
key = k.dashboard.lazy_extras,
key = k.dashboard_lazy_extras,
},
{
action = "Lazy",
desc = " Lazy",
icon = "󰒲 ",
key = k.dashboard.lazy,
key = k.dashboard_lazy,
},
{
action = function()
@ -424,7 +424,7 @@ return {
end,
desc = " Quit",
icon = "",
key = k.dashboard.quit,
key = k.dashboard_quit,
},
}

10
lua/lazyvim/plugins/util.lua
View file

@ -1,4 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().util.persistence
local k = require("lazyvim.keymaps").get_keymaps()
return {
@ -11,10 +11,10 @@ return {
opts = {},
-- stylua: ignore
keys = {
{ k.restore_session, function() require("persistence").load() end, desc = "Restore Session" },
{ k.select_session, function() require("persistence").select() end,desc = "Select Session" },
{ k.restore_last_session, function() require("persistence").load({ last = true }) end, desc = "Restore Last Session" },
{ k.skip_current_session, function() require("persistence").stop() end, desc = "Don't Save Current Session" },
{ k.persistence_restore_session, function() require("persistence").load() end, desc = "Restore Session" },
{ k.persistence_select_session, function() require("persistence").select() end,desc = "Select Session" },
{ k.persistence_restore_last_session, function() require("persistence").load({ last = true }) end, desc = "Restore Last Session" },
{ k.persistence_skip_current_session, function() require("persistence").stop() end, desc = "Don't Save Current Session" },
},
},

4
lua/lazyvim/util/mini.lua
View file

@ -1,4 +1,4 @@
local k = require("lazyvim.keymaps").get_keymaps().util.mini_pairs
local k = require("lazyvim.keymaps").get_keymaps()
---@class lazyvim.util.mini
local M = {}
@ -123,7 +123,7 @@ end
---@param opts {skip_next: string, skip_ts: string[], skip_unbalanced: boolean, markdown: boolean}
function M.pairs(opts)
LazyVim.toggle.map(k.toggle, {
LazyVim.toggle.map(k.minipairs_toggle, {
name = "Mini Pairs",
get = function()
return not vim.g.minipairs_disable