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): enable modifying and disabling keymaps

Browse source
This commit is contained in:
dunix241 2024-10-28 19:04:40 +07:00
parent cb40a09538
commit e0fdcfa86d
58 changed files with 1729 additions and 674 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
lua/lazyvim/config/autocmds.lua
View file

@ -1,5 +1,7 @@
-- This file is automatically loaded by lazyvim.config.init.
local k = require("lazyvim.keymaps").get_keymaps()
local function augroup(name)
return vim.api.nvim_create_augroup("lazyvim_" .. name, { clear = true })
end
@ -73,7 +75,7 @@ vim.api.nvim_create_autocmd("FileType", {
callback = function(event)
vim.bo[event.buf].buflisted = false
vim.schedule(function()
vim.keymap.set("n", "q", function()
LazyVim.keymap_set("n", k.quit_buffer, function()
vim.cmd("close")
pcall(vim.api.nvim_buf_delete, event.buf, { force = true })
end, {

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

@ -3,6 +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
-- better up/down
map({ "n", "x" }, "j", "v:count == 0 ? 'gj' : 'j'", { desc = "Down", expr = true, silent = true })
@ -11,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", "<C-h>", "<C-w>h", { desc = "Go to Left Window", remap = true })
map("n", "<C-j>", "<C-w>j", { desc = "Go to Lower Window", remap = true })
map("n", "<C-k>", "<C-w>k", { desc = "Go to Upper Window", remap = true })
map("n", "<C-l>", "<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", "<C-Up>", "<cmd>resize +2<cr>", { desc = "Increase Window Height" })
map("n", "<C-Down>", "<cmd>resize -2<cr>", { desc = "Decrease Window Height" })
map("n", "<C-Left>", "<cmd>vertical resize -2<cr>", { desc = "Decrease Window Width" })
map("n", "<C-Right>", "<cmd>vertical resize +2<cr>", { desc = "Increase Window Width" })
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" })
-- Move Lines
map("n", "<A-j>", "<cmd>execute 'move .+' . v:count1<cr>==", { desc = "Move Down" })
map("n", "<A-k>", "<cmd>execute 'move .-' . (v:count1 + 1)<cr>==", { desc = "Move Up" })
map("i", "<A-j>", "<esc><cmd>m .+1<cr>==gi", { desc = "Move Down" })
map("i", "<A-k>", "<esc><cmd>m .-2<cr>==gi", { desc = "Move Up" })
map("v", "<A-j>", ":<C-u>execute \"'<,'>move '>+\" . v:count1<cr>gv=gv", { desc = "Move Down" })
map("v", "<A-k>", ":<C-u>execute \"'<,'>move '<-\" . (v:count1 + 1)<cr>gv=gv", { desc = "Move Up" })
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" })
-- buffers
map("n", "<S-h>", "<cmd>bprevious<cr>", { desc = "Prev Buffer" })
map("n", "<S-l>", "<cmd>bnext<cr>", { desc = "Next Buffer" })
map("n", "[b", "<cmd>bprevious<cr>", { desc = "Prev Buffer" })
map("n", "]b", "<cmd>bnext<cr>", { desc = "Next Buffer" })
map("n", "<leader>bb", "<cmd>e #<cr>", { desc = "Switch to Other Buffer" })
map("n", "<leader>`", "<cmd>e #<cr>", { desc = "Switch to Other Buffer" })
map("n", "<leader>bd", LazyVim.ui.bufremove, { desc = "Delete Buffer" })
map("n", "<leader>bD", "<cmd>:bd<cr>", { desc = "Delete Buffer and Window" })
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" })
-- Clear search with <esc>
map({ "i", "n" }, "<esc>", "<cmd>noh<cr><esc>", { desc = "Escape and Clear hlsearch" })
@ -47,7 +48,7 @@ map({ "i", "n" }, "<esc>", "<cmd>noh<cr><esc>", { desc = "Escape and Clear hlsea
-- taken from runtime/lua/_editor.lua
map(
"n",
"<leader>ur",
k.clear_search_diff_update_and_redraw,
"<Cmd>nohlsearch<Bar>diffupdate<Bar>normal! <C-L><CR>",
{ desc = "Redraw / Clear hlsearch / Diff Update" }
)
@ -66,33 +67,33 @@ map("i", ".", ".<c-g>u")
map("i", ";", ";<c-g>u")
-- save file
map({ "i", "x", "n", "s" }, "<C-s>", "<cmd>w<cr><esc>", { desc = "Save File" })
map({ "i", "x", "n", "s" }, k.save_file, "<cmd>w<cr><esc>", { desc = "Save File" })
--keywordprg
map("n", "<leader>K", "<cmd>norm! K<cr>", { desc = "Keywordprg" })
map("n", k.keywordprg, "<cmd>norm! K<cr>", { desc = "Keywordprg" })
-- better indenting
map("v", "<", "<gv")
map("v", ">", ">gv")
-- commenting
map("n", "gco", "o<esc>Vcx<esc><cmd>normal gcc<cr>fxa<bs>", { desc = "Add Comment Below" })
map("n", "gcO", "O<esc>Vcx<esc><cmd>normal gcc<cr>fxa<bs>", { desc = "Add Comment Above" })
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" })
-- lazy
map("n", "<leader>l", "<cmd>Lazy<cr>", { desc = "Lazy" })
map("n", k.lazy, "<cmd>Lazy<cr>", { desc = "Lazy" })
-- new file
map("n", "<leader>fn", "<cmd>enew<cr>", { desc = "New File" })
map("n", k.new_file, "<cmd>enew<cr>", { desc = "New File" })
map("n", "<leader>xl", "<cmd>lopen<cr>", { desc = "Location List" })
map("n", "<leader>xq", "<cmd>copen<cr>", { desc = "Quickfix List" })
map("n", k.location_list, "<cmd>lopen<cr>", { desc = "Location List" })
map("n", k.quickfix_list, "<cmd>copen<cr>", { desc = "Quickfix List" })
map("n", "[q", vim.cmd.cprev, { desc = "Previous Quickfix" })
map("n", "]q", vim.cmd.cnext, { desc = "Next Quickfix" })
map("n", k.previous_quickfix, vim.cmd.cprev, { desc = "Previous Quickfix" })
map("n", k.next_quickfix, vim.cmd.cnext, { desc = "Next Quickfix" })
-- formatting
map({ "n", "v" }, "<leader>cf", function()
map({ "n", "v" }, k.format, function()
LazyVim.format({ force = true })
end, { desc = "Format" })
@ -104,87 +105,87 @@ local diagnostic_goto = function(next, severity)
go({ severity = severity })
end
end
map("n", "<leader>cd", vim.diagnostic.open_float, { desc = "Line Diagnostics" })
map("n", "]d", diagnostic_goto(true), { desc = "Next Diagnostic" })
map("n", "[d", diagnostic_goto(false), { desc = "Prev Diagnostic" })
map("n", "]e", diagnostic_goto(true, "ERROR"), { desc = "Next Error" })
map("n", "[e", diagnostic_goto(false, "ERROR"), { desc = "Prev Error" })
map("n", "]w", diagnostic_goto(true, "WARN"), { desc = "Next Warning" })
map("n", "[w", diagnostic_goto(false, "WARN"), { desc = "Prev Warning" })
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" })
-- stylua: ignore start
-- toggle options
LazyVim.toggle.map("<leader>uf", LazyVim.toggle.format())
LazyVim.toggle.map("<leader>uF", LazyVim.toggle.format(true))
LazyVim.toggle.map("<leader>us", LazyVim.toggle("spell", { name = "Spelling" }))
LazyVim.toggle.map("<leader>uw", LazyVim.toggle("wrap", { name = "Wrap" }))
LazyVim.toggle.map("<leader>uL", LazyVim.toggle("relativenumber", { name = "Relative Number" }))
LazyVim.toggle.map("<leader>ud", LazyVim.toggle.diagnostics)
LazyVim.toggle.map("<leader>ul", LazyVim.toggle.number)
LazyVim.toggle.map( "<leader>uc", LazyVim.toggle("conceallevel", { values = { 0, vim.o.conceallevel > 0 and vim.o.conceallevel or 2 } }))
LazyVim.toggle.map("<leader>uT", LazyVim.toggle.treesitter)
LazyVim.toggle.map("<leader>ub", LazyVim.toggle("background", { values = { "light", "dark" }, name = "Background" }))
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" }))
if vim.lsp.inlay_hint then
LazyVim.toggle.map("<leader>uh", LazyVim.toggle.inlay_hints)
LazyVim.toggle.map(k.toggle_options.inlay_hints, LazyVim.toggle.inlay_hints)
end
-- lazygit
map("n", "<leader>gg", function() LazyVim.lazygit( { cwd = LazyVim.root.git() }) end, { desc = "Lazygit (Root Dir)" })
map("n", "<leader>gG", function() LazyVim.lazygit() end, { desc = "Lazygit (cwd)" })
map("n", "<leader>gb", LazyVim.lazygit.blame_line, { desc = "Git Blame Line" })
map("n", "<leader>gB", 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", "<leader>gf", 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", "<leader>gl", function()
map("n", k.lazygit.git_log_root, function()
LazyVim.lazygit({ args = { "log" }, cwd = LazyVim.root.git() })
end, { desc = "Lazygit Log" })
map("n", "<leader>gL", function()
map("n", k.lazygit.git_log_cwd, function()
LazyVim.lazygit({ args = { "log" } })
end, { desc = "Lazygit Log (cwd)" })
-- quit
map("n", "<leader>qq", "<cmd>qa<cr>", { desc = "Quit All" })
map("n", k.quit_all, "<cmd>qa<cr>", { desc = "Quit All" })
-- highlights under cursor
map("n", "<leader>ui", vim.show_pos, { desc = "Inspect Pos" })
map("n", "<leader>uI", "<cmd>InspectTree<cr>", { desc = "Inspect Tree" })
map("n", k.inspect_pos, vim.show_pos, { desc = "Inspect Pos" })
map("n", k.inspect_tree, "<cmd>InspectTree<cr>", { desc = "Inspect Tree" })
-- LazyVim Changelog
map("n", "<leader>L", function() LazyVim.news.changelog() end, { desc = "LazyVim Changelog" })
map("n", k.lazyvim_changelog, function() LazyVim.news.changelog() end, { desc = "LazyVim Changelog" })
-- floating terminal
local lazyterm = function() LazyVim.terminal(nil, { cwd = LazyVim.root() }) end
map("n", "<leader>ft", lazyterm, { desc = "Terminal (Root Dir)" })
map("n", "<leader>fT", function() LazyVim.terminal() end, { desc = "Terminal (cwd)" })
map("n", "<c-/>", lazyterm, { desc = "Terminal (Root Dir)" })
map("n", "<c-_>", lazyterm, { desc = "which_key_ignore" })
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" })
-- Terminal Mappings
map("t", "<esc><esc>", "<c-\\><c-n>", { desc = "Enter Normal Mode" })
map("t", "<C-h>", "<cmd>wincmd h<cr>", { desc = "Go to Left Window" })
map("t", "<C-j>", "<cmd>wincmd j<cr>", { desc = "Go to Lower Window" })
map("t", "<C-k>", "<cmd>wincmd k<cr>", { desc = "Go to Upper Window" })
map("t", "<C-l>", "<cmd>wincmd l<cr>", { desc = "Go to Right Window" })
map("t", "<C-/>", "<cmd>close<cr>", { desc = "Hide Terminal" })
map("t", "<c-_>", "<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", "<leader>w", "<c-w>", { desc = "Windows", remap = true })
map("n", "<leader>-", "<C-W>s", { desc = "Split Window Below", remap = true })
map("n", "<leader>|", "<C-W>v", { desc = "Split Window Right", remap = true })
map("n", "<leader>wd", "<C-W>c", { desc = "Delete Window", remap = true })
LazyVim.toggle.map("<leader>wm", LazyVim.toggle.maximize)
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)
-- tabs
map("n", "<leader><tab>l", "<cmd>tablast<cr>", { desc = "Last Tab" })
map("n", "<leader><tab>o", "<cmd>tabonly<cr>", { desc = "Close Other Tabs" })
map("n", "<leader><tab>f", "<cmd>tabfirst<cr>", { desc = "First Tab" })
map("n", "<leader><tab><tab>", "<cmd>tabnew<cr>", { desc = "New Tab" })
map("n", "<leader><tab>]", "<cmd>tabnext<cr>", { desc = "Next Tab" })
map("n", "<leader><tab>d", "<cmd>tabclose<cr>", { desc = "Close Tab" })
map("n", "<leader><tab>[", "<cmd>tabprevious<cr>", { desc = "Previous Tab" })
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" })

673
lua/lazyvim/keymaps.lua Normal file
View file

@ -0,0 +1,673 @@
local M = {}
---@class LazyVimKeymaps
local keymaps = nil
---@class LazyVimKeymaps
M.default_keymaps = {
keymaps = {
window = {
left = "<C-h>",
lower = "<C-j>",
upper = "<C-k>",
right = "<C-l>",
},
resize_window = {
increase_height = "<C-Up>",
decrease_height = "<C-Down>",
decrease_width = "<C-Left>",
increase_width = "<C-Right>",
},
move_lines = {
down = "<A-j>",
up = "<A-k>",
},
buffers = {
prev = "<S-h>",
next = "<S-l>",
prev_alt = "[b",
next_alt = "]b",
switch_to_other = "<leader>bb",
switch_to_other_alt = "<leader>`",
delete = "<leader>bd",
delete_and_close = "<leader>bD",
},
clear_search_diff_update_and_redraw = "<leader>ur",
save_file = "<C-s>",
keywordprg = "<leader>K",
commenting = {
add_comment_below = "gco",
add_comment_above = "gcO",
},
lazy = "<leader>l",
new_file = "<leader>fn",
location_list = "<leader>xl",
quickfix_list = "<leader>xq",
previous_quickfix = "[q",
next_quickfix = "]q",
format = "<leader>cf",
diagnostics = {
line_diagnostics = "<leader>cd",
next_diagnostic = "]d",
prev_diagnostic = "[d",
next_error = "]e",
prev_error = "[e",
next_warning = "]w",
prev_warning = "[w",
},
toggle_options = {
auto_format_buffer = "<leader>uf",
auto_format_global = "<leader>uF",
spelling = "<leader>us",
wrap = "<leader>uw",
relativenumber = "<leader>uL",
diagnostics = "<leader>ud",
number = "<leader>ul",
conceallevel = "<leader>uc",
treesitter = "<leader>uT",
background = "<leader>ub",
inlay_hints = "<leader>uh",
},
lazygit = {
toggle_root = "<leader>gg",
toggle_cwd = "<leader>gG",
blame_line = "<leader>gb",
browse = "<leader>gB",
current_file_history = "<leader>gf",
git_log_root = "<leader>gl",
git_log_cwd = "<leader>gL",
},
quit_all = "<leader>qq",
inspect_pos = "<leader>ui",
inspect_tree = "<leader>uI",
lazyvim_changelog = "<leader>L",
terminal = {
floating_terminal = {
toggle_root = "<leader>ft",
toggle_cwd = "<leader>fT",
toggle_root_alt_1 = "<c-/>",
toggle_root_alt_2 = "<c-_>",
},
enter_normal_mode = "<esc><esc>",
hide_terminal = "<C-/>",
hide_terminal_alt = "<c-_>",
},
windows = {
windows = "<leader>w",
split_window_below = "<leader>-",
split_window_right = "<leader>|",
delete_window = "<leader>wd",
toggle_maximize_window = "<leader>wm",
},
tabs = {
last_tab = "<leader><tab>l",
close_other_tabs = "<leader><tab>o",
first_tab = "<leader><tab>f",
new_tab = "<leader><tab><tab>",
next_tab = "<leader><tab>]",
close_tab = "<leader><tab>d",
previous_tab = "<leader><tab>[",
},
},
quit_buffer = "q",
coding = {
cmp = {
scroll_docs_backward = "<C-b>",
scroll_docs_forward = "<C-f>",
select_next_item = "<C-n>",
select_prev_item = "<C-p>",
complete = "<C-Space>",
confirm_auto_select = "<CR>",
confirm_select = "<C-y>",
confirm_replace = "<S-CR>",
abort = "<C-CR>",
snippet = {
jump_prev = "<Tab>",
jump_next = "<S-Tab>",
},
},
},
editor = {
neo_tree = {
toggle_root = "<leader>fe",
toggle_cwd = "<leader>fE",
toggle_root_alt = "<leader>e",
toggle_cwd_alt = "<leader>E",
toggle_git_status = "<leader>ge",
toggle_buffers = "<leader>be",
window = {
open = "l",
close_node = "h",
copy_path_to_clipboard = "Y",
open_with_system_application = "O",
toggle_preview = "P",
},
},
grug_far = {
open = "<leader>sr",
},
flash = {
jump = "s",
treesitter = "S",
remote = "r",
treesitter_search = "R",
toggle = "<c-s>",
},
which_key = {
group = {
tabs = "<leader><tab>",
code = "<leader>c",
file_find = "<leader>f",
git = "<leader>g",
hunks = "<leader>gh",
quit_session = "<leader>q",
search = "<leader>s",
ui = "<leader>u",
diagnostics_quickfix = "<leader>x",
buffer = "<leader>b",
windows = "<leader>w",
},
buffer_keymaps = "<leader>?",
window_hydra_mode = "<c-w><space>",
},
gitsigns = {
next_hunk = "]h",
prev_hunk = "[h",
last_hunk = "]H",
first_hunk = "[H",
stage_hunk = "<leader>ghs",
reset_hunk = "<leader>ghr",
stage_buffer = "<leader>ghS",
undo_stage_hunk = "<leader>ghu",
reset_buffer = "<leader>ghR",
preview_hunk_inline = "<leader>ghp",
blame_line = "<leader>ghb",
blame_buffer = "<leader>ghB",
diff_index = "<leader>ghd",
diff_commit = "<leader>ghD",
select_hunk = "ih",
},
trouble = {
diagnostics_toggle = "<leader>xx",
diagnostics_buffer_toggle = "<leader>xX",
symbols_toggle = "<leader>cs",
lsp_toggle = "<leader>cS",
loclist_toggle = "<leader>xL",
qflist_toggle = "<leader>xQ",
previous_trouble = "[q",
next_trouble = "]q",
},
todo_comments = {
next_todo = "]t",
prev_todo = "[t",
todo_trouble = "<leader>xt",
todo_fix_fixme_trouble = "<leader>xT",
todo_telescope = "<leader>st",
todo_fix_fixme_telescope = "<leader>sT",
},
},
formatting = {
conform = {
format = "<leader>cF",
},
},
treesitter = {
increment_selection = "<C-Space>",
decrement_selection = "<BS>",
textobjects = {
goto_next_start = {
function_outer = "]f",
class_outer = "]c",
parameter_inner = "]a",
},
goto_next_end = {
function_outer = "]F",
class_outer = "]C",
parameter_inner = "]A",
},
goto_previous_start = {
function_outer = "[f",
class_outer = "[c",
parameter_inner = "[a",
},
goto_previous_end = {
function_outer = "[F",
class_outer = "[C",
parameter_inner = "[A",
},
},
},
ui = {
nvim_notify = {
dismiss_all_notifications = "<leader>un",
},
bufferline = {
toggle_pin = "<leader>bp",
delete_non_pinned_buffers = "<leader>bP",
delete_other_buffers = "<leader>bo",
delete_buffers_to_the_right = "<leader>br",
delete_buffers_to_the_left = "<leader>bl",
prev_buffer = "<S-h>",
next_buffer = "<S-l>",
prev_buffer_alt = "[b",
next_buffer_alt = "]b",
move_buffer_prev = "[B",
move_buffer_next = "]B",
},
indent_blankline = {
toggle = "<leader>ug",
},
noice = {
prefix = "<leader>sn",
redirect_cmdline = "<S-Enter>",
last_message = "<leader>snl",
history = "<leader>snh",
all = "<leader>sna",
dismiss = "<leader>snd",
pick = "<leader>snt",
scroll_forward = "<c-f>",
scroll_backward = "<c-b>",
},
dashboard = {
find_file = "f",
new_file = "n",
recent_files = "r",
find_text = "g",
config = "c",
restore_session = "s",
lazy_extras = "x",
lazy = "l",
quit = "q",
projects = "p",
},
},
util = {
persistence = {
restore_session = "<leader>qs",
select_session = "<leader>qS",
restore_last_session = "<leader>ql",
skip_current_session = "<leader>qd",
},
mini_pairs = {
toggle = "<leader>up",
},
},
extras = {
coding = {
copilot_chat = {
submit_prompt = "<c-s>",
prefix = "<leader>a",
toggle = "<leader>aa",
clear = "<leader>ax",
quick_chat = "<leader>aq",
diagnostic_help = "<leader>ad",
prompt_actions = "<leader>ap",
},
luasnip = {
jump_next = "<tab>",
jump_prev = "<s-tab>",
},
mini_surround = {
prefix = "gs",
add = "gsa",
delete = "gsd",
find = "gsf",
find_left = "gsF",
highlight = "gsh",
replace = "gsr",
update_n_lines = "gsn",
alt = {
prefix = "gz",
add = "gza",
delete = "gzd",
find = "gzf",
find_left = "gzF",
highlight = "gzh",
replace = "gzr",
update_n_lines = "gzn",
},
},
yanky = {
yank_history = "<leader>p",
yank = "y",
put_text_after_cursor = "p",
put_text_before_cursor = "P",
put_text_after_selection = "gp",
put_text_before_selection = "gP",
cycle_forward_yank_history = "[y",
cycle_backward_yank_history = "]y",
put_indent_after_cursor_linewise = "]p",
put_indent_before_cursor_linewise = "[p",
put_indent_after_cursor_linewise_alt = "]P",
put_indent_before_cursor_linewise_alt = "[P",
put_and_indent_right = ">p",
put_and_indent_left = "<p",
put_before_indent_right = ">P",
put_before_indent_left = "<P",
put_after_filter = "=p",
put_before_filter = "=P",
},
},
dap = {
core = {
nvim_dap = {
prefix = "<leader>d",
breakpoint_condition = "<leader>dB",
toggle_breakpoint = "<leader>db",
continue = "<leader>dc",
run_with_args = "<leader>da",
run_to_cursor = "<leader>dC",
go_to_line_no_execute = "<leader>dg",
step_into = "<leader>di",
down = "<leader>dj",
up = "<leader>dk",
run_last = "<leader>dl",
step_out = "<leader>do",
step_over = "<leader>dO",
pause = "<leader>dp",
toggle_repl = "<leader>dr",
session = "<leader>ds",
terminate = "<leader>dt",
widgets = "<leader>dw",
},
nvim_dap_ui = {
toggle_dap_ui = "<leader>du",
eval_dap_ui = "<leader>de",
},
},
},
editor = {
aerial = {
toggle = "<leader>cs",
aerial_telescope = "<leader>ss",
},
dial = {
increment = "<C-a>",
decrement = "<C-x>",
increment_g = "g<C-a>",
decrement_g = "g<C-x>",
},
harpoon2 = {
harpoon_file = "<leader>H",
harpoon_quick_menu = "<leader>h",
harpoon_to_file_prefix = "<leader>",
},
vim_illuminate = {
next = "]]",
prev = "[[",
},
inc_rename = {
rename = "<leader>cr",
},
leap = {
next = "s",
prev = "S",
from_windows = "gs",
},
mini_diff = {
toggle_overlay = "<leader>go",
},
mini_files = {
open_current_file_dir = "<leader>fm",
open_cwd = "<leader>fM",
},
outline = {
up_and_jump = "<up>",
down_and_jump = "<down>",
},
overseer = {
prefix = "<leader>o",
toggle = "<leader>ow",
quick_action = "<leader>oq",
run = "<leader>oo",
info = "<leader>oi",
build = "<leader>ob",
task_action = "<leader>ot",
clear_cache = "<leader>oc",
},
refactoring = {
prefix = "<leader>r",
refactor = "<leader>rs",
inline_variable = "<leader>ri",
extract_block = "<leader>rb",
extract_block_to_file = "<leader>rf",
debug_print = "<leader>rP",
debug_print_variable = "<leader>rp",
debug_cleanup = "<leader>rc",
extract_function = "<leader>rf",
extract_function_to_file = "<leader>rF",
extract_variable = "<leader>rx",
},
picker = {
switch_buffer = "<leader>,",
grep_root = "<leader>/",
command_history = "<leader>:",
find_files_root = "<leader><space>",
find_buffers = "<leader>fb",
find_config_file = "<leader>fc",
find_files_root_alt = "<leader>ff",
find_files_cwd = "<leader>fF",
find_git_files = "<leader>fg",
find_recent_files = "<leader>fr",
find_recent_files_cwd = "<leader>fR",
find_projects = "<leader>fp",
git_commits = "<leader>gc",
git_status = "<leader>gs",
search_registers = '<leader>s"',
search_autocommands = "<leader>sa",
search_buffer = "<leader>sb",
search_command_history = "<leader>sc",
search_commands = "<leader>sC",
search_document_diagnostics = "<leader>sd",
search_workspace_diagnostics = "<leader>sD",
search_grep_root = "<leader>sg",
search_grep_cwd = "<leader>sG",
search_help_pages = "<leader>sh",
search_highlight_groups = "<leader>sH",
search_jumplist = "<leader>sj",
search_keymaps = "<leader>sk",
search_loclist = "<leader>sl",
search_man_pages = "<leader>sM",
search_marks = "<leader>sm",
search_options = "<leader>so",
search_resume = "<leader>sR",
search_quickfix = "<leader>sq",
search_word_root = "<leader>sw",
search_word_cwd = "<leader>sW",
search_selection_root = "<leader>sw",
search_selection_cwd = "<leader>sW",
colorscheme_preview = "<leader>uC",
go_to_symbol = "<leader>ss",
go_to_symbol_workspace = "<leader>sS",
actions = {
open_with_trouble = "<c-t>",
open_with_trouble_alt = "<a-t>",
find_files_no_ignore = "<a-i>",
find_files_with_hidden = "<a-h>",
cycle_history_next = "<C-Down>",
cycle_history_prev = "<C-Up>",
preview_scrolling_down = "<C-f>",
preview_scrolling_up = "<C-b>",
close = "q",
},
flash = {
normal = "s",
insert = "<c-s>",
},
},
},
test = {
core = {
prefix = "<leader>t",
run_file = "<leader>tt",
run_all_test_files = "<leader>tT",
run_nearest = "<leader>tr",
run_last = "<leader>tl",
toggle_summary = "<leader>ts",
show_output = "<leader>to",
toggle_output_panel = "<leader>tO",
stop = "<leader>tS",
toggle_watch = "<leader>tw",
debug_nearest = "<leader>td",
},
},
lang = {
lsp_info = "<leader>cl",
mason = "<leader>cm",
go_to_definition = "gd",
go_to_declaration = "gD",
references = "gr",
file_references = "gR",
go_to_implementation = "gI",
go_to_type_definition = "gy",
go_to_super = "gs",
go_to_subjects = "gS",
hover = "K",
signature_help = "gK",
insert_signature_help = "<c-k>",
code_action = "<leader>ca",
run_codelens = "<leader>cc",
refresh_codelens = "<leader>cC",
rename_file = "<leader>cR",
rename = "<leader>cr",
source_action = "<leader>cA",
next_reference = "]]",
prev_reference = "[[",
cycle_next_reference = "<a-n>",
cycle_prev_reference = "<a-p>",
organize_imports = "<leader>co",
add_missing_imports = "<leader>cM",
remove_unused_imports = "<leader>cu",
fix_all_diagnostics = "<leader>cD",
select_lang_version = "<leader>cV",
extract = {
prefix = "<leader>cx",
method = "<leader>cxm",
variable = "<leader>cxv",
constant = "<leader>cxc",
},
ansible = {
ansible_run_playbook_role = "<leader>ta",
},
clangd = {
switch_source_header = "<leader>cs",
},
clojure = {
jump_prev_evaluation_output = "[c",
jump_next_evaluation_output = "]c",
},
elixir = {
to_pipe = "<leader>cp",
from_pipe = "<leader>cP",
},
lean = {
abbreviations_leader = "\\",
},
markdown = {
markdown_preview_toggle = "<leader>cp",
render_markdown_toggle = "<leader>um",
},
python = {
debug_method = "<leader>dPt",
debug_class = "<leader>dPc",
select_virtual_env = "<leader>cv",
},
r = {
send = "<Enter>",
send_all = "<localleader>a",
send_between_marks = "<localleader>b",
send_chunks = "<localleader>c",
send_functions = "<localleader>f",
send_goto = "<localleader>g",
send_install = "<localleader>i",
send_knit = "<localleader>k",
send_paragraph = "<localleader>p",
send_quarto = "<localleader>q",
send_general = "<localleader>r",
send_split_or_send = "<localleader>s",
send_terminal = "<localleader>t",
send_view = "<localleader>v",
},
rust = {
code_action = "<leader>cR",
debuggables = "<leader>dr",
show_crate_documentation = "K",
},
scala = {
metals_commands = "<leader>me",
metals_compile_cascade = "<leader>mc",
},
sql = {
toggle_dbui = "<leader>D",
},
tex = {
prefix = "<localLeader>l",
vimtex_docs = "<Leader>K",
},
typescript = {
go_to_source_definition = "gD",
},
},
ui = {
edgy = {
toggle = "<leader>ue",
select_window = "<leader>uE",
},
mini_animate = {
toggle = "<leader>ua",
},
treesitter_context = {
toggle = "<leader>ut",
},
},
util = {
chezmoi = {
pick_chezmoi = "<leader>sz",
select = "<CR>",
key = "c",
},
octo = {
issue_list = "<leader>gi",
issue_search = "<leader>gI",
pr_list = "<leader>gp",
pr_search = "<leader>gP",
repo_list = "<leader>gr",
search = "<leader>gS",
assignee = "<leader>a",
comment_code = "<leader>c",
label = "<leader>l",
issue = "<leader>i",
react = "<leader>r",
pr = "<leader>p",
review = "<leader>v",
insert_at = "@",
insert_hashtag = "#",
},
rest = {
kulala = {
prefix = "<leader>R",
send_request = "<leader>Rs",
toggle_view = "<leader>Rt",
jump_to_previous_request = "<leader>Rp",
jump_to_next_request = "<leader>Rn",
},
},
},
vscode = {
find = "<leader><space>",
find_in_files = "<leader>/",
go_to_symbol = "<leader>ss",
},
},
}
---@return LazyVimKeymaps
M.get_keymaps = function()
if keymaps == nil then
keymaps = vim.tbl_deep_extend("force", {}, M.default_keymaps, vim.g.lazyvim_keymaps)
vim.g.lazyvim_keymaps = keymaps -- update global for retrieval
end
return keymaps
end
return M

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

@ -1,3 +1,5 @@
local k = require("lazyvim.keymaps").get_keymaps().coding
return {
-- auto completion
@ -24,26 +26,37 @@ return {
local cmp = require("cmp")
local defaults = require("cmp.config.default")()
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.abort,
function(fallback)
cmp.abort()
fallback()
end,
},
}
for _, action in ipairs(actions) do
if action[1] and action[1] ~= "" then
mappings[action[1]] = action[2]
end
end
return {
auto_brackets = {}, -- configure any filetype to auto add brackets
completion = {
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({
["<C-b>"] = cmp.mapping.scroll_docs(-4),
["<C-f>"] = cmp.mapping.scroll_docs(4),
["<C-n>"] = cmp.mapping.select_next_item({ behavior = cmp.SelectBehavior.Insert }),
["<C-p>"] = cmp.mapping.select_prev_item({ behavior = cmp.SelectBehavior.Insert }),
["<C-Space>"] = cmp.mapping.complete(),
["<CR>"] = LazyVim.cmp.confirm({ select = auto_select }),
["<C-y>"] = LazyVim.cmp.confirm({ select = true }),
["<S-CR>"] = LazyVim.cmp.confirm({ behavior = cmp.ConfirmBehavior.Replace }), -- Accept currently selected item. Set `select` to `false` to only confirm explicitly selected items.
["<C-CR>"] = function(fallback)
cmp.abort()
fallback()
end,
}),
mapping = cmp.mapping.preset.insert({ mappings }),
sources = cmp.config.sources({
{ name = "nvim_lsp" },
{ name = "path" },
@ -107,7 +120,7 @@ return {
end,
keys = {
{
"<Tab>",
k.cmp.snippet.jump_prev,
function()
return vim.snippet.active({ direction = 1 }) and "<cmd>lua vim.snippet.jump(1)<cr>" or "<Tab>"
end,
@ -116,7 +129,7 @@ return {
mode = { "i", "s" },
},
{
"<S-Tab>",
k.cmp.snippet.jump_next,
function()
return vim.snippet.active({ direction = -1 }) and "<cmd>lua vim.snippet.jump(-1)<cr>" or "<S-Tab>"
end,

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

@ -1,41 +1,56 @@
local k = require("lazyvim.keymaps").get_keymaps().editor
local s = require("lazyvim.keymaps").get_keymaps().extras.coding.mini_surround
return {
-- file explorer
{
"nvim-neo-tree/neo-tree.nvim",
cmd = "Neotree",
keys = {
keys = function()
return {
{
"<leader>fe",
k.neo_tree.toggle_root,
function()
require("neo-tree.command").execute({ toggle = true, dir = LazyVim.root() })
end,
desc = "Explorer NeoTree (Root Dir)",
},
{
"<leader>fE",
k.neo_tree.toggle_cwd,
function()
require("neo-tree.command").execute({ toggle = true, dir = vim.uv.cwd() })
end,
desc = "Explorer NeoTree (cwd)",
},
{ "<leader>e", "<leader>fe", desc = "Explorer NeoTree (Root Dir)", remap = true },
{ "<leader>E", "<leader>fE", desc = "Explorer NeoTree (cwd)", remap = true },
{
"<leader>ge",
k.neo_tree.toggle_root_alt,
k.neo_tree.toggle_root,
desc = "Explorer NeoTree (Root Dir)",
remap = true,
},
{
k.neo_tree.toggle_cwd_alt,
k.neo_tree.toggle_cwd,
desc = "Explorer NeoTree (cwd)",
remap = true,
},
{
k.neo_tree.toggle_git_status,
function()
require("neo-tree.command").execute({ source = "git_status", toggle = true })
end,
desc = "Git Explorer",
},
{
"<leader>be",
k.neo_tree.toggle_buffers,
function()
require("neo-tree.command").execute({ source = "buffers", toggle = true })
end,
desc = "Buffer Explorer",
},
},
}
end,
deactivate = function()
vim.cmd([[Neotree close]])
end,
@ -58,7 +73,35 @@ return {
end,
})
end,
opts = {
opts = function()
local neo_tree_mappings = {}
local neo_tree_actions = {
[k.neo_tree.window.open] = "open",
[k.neo_tree.window.close_node] = "close_node",
["<space>"] = "none",
[k.neo_tree.window.copy_path_to_clipboard] = {
function(state)
local node = state.tree:get_node()
local path = node:get_id()
vim.fn.setreg("+", path, "c")
end,
desc = "Copy Path to Clipboard",
},
[k.neo_tree.window.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 } },
}
for key, value in pairs(neo_tree_actions) do
if key and key ~= "" then
neo_tree_mappings[key] = value
end
end
return {
sources = { "filesystem", "buffers", "git_status" },
open_files_do_not_replace_types = { "terminal", "Trouble", "trouble", "qf", "Outline" },
filesystem = {
@ -67,26 +110,7 @@ return {
use_libuv_file_watcher = true,
},
window = {
mappings = {
["l"] = "open",
["h"] = "close_node",
["<space>"] = "none",
["Y"] = {
function(state)
local node = state.tree:get_node()
local path = node:get_id()
vim.fn.setreg("+", path, "c")
end,
desc = "Copy Path to Clipboard",
},
["O"] = {
function(state)
require("lazy.util").open(state.tree:get_node().path, { system = true })
end,
desc = "Open with System Application",
},
["P"] = { "toggle_preview", config = { use_float = false } },
},
mappings = neo_tree_mappings,
},
default_component_configs = {
indent = {
@ -102,7 +126,8 @@ return {
},
},
},
},
}
end,
config = function(_, opts)
local function on_move(data)
LazyVim.lsp.on_rename(data.source, data.destination)
@ -133,7 +158,7 @@ return {
cmd = "GrugFar",
keys = {
{
"<leader>sr",
k.grug_far.open,
function()
local grug = require("grug-far")
local ext = vim.bo.buftype == "" and vim.fn.expand("%:e")
@ -161,11 +186,11 @@ return {
opts = {},
-- stylua: ignore
keys = {
{ "s", mode = { "n", "x", "o" }, function() require("flash").jump() end, desc = "Flash" },
{ "S", mode = { "n", "o", "x" }, function() require("flash").treesitter() end, desc = "Flash Treesitter" },
{ "r", mode = "o", function() require("flash").remote() end, desc = "Remote Flash" },
{ "R", mode = { "o", "x" }, function() require("flash").treesitter_search() end, desc = "Treesitter Search" },
{ "<c-s>", 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" },
},
},
@ -180,29 +205,33 @@ return {
spec = {
{
mode = { "n", "v" },
{ "<leader><tab>", group = "tabs" },
{ "<leader>c", group = "code" },
{ "<leader>f", group = "file/find" },
{ "<leader>g", group = "git" },
{ "<leader>gh", group = "hunks" },
{ "<leader>q", group = "quit/session" },
{ "<leader>s", group = "search" },
{ "<leader>u", group = "ui", icon = { icon = "󰙵 ", color = "cyan" } },
{ "<leader>x", group = "diagnostics/quickfix", icon = { icon = "󱖫 ", color = "green" } },
{ 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.which_key.group.diagnostics_quickfix,
group = "diagnostics/quickfix",
icon = { icon = "󱖫 ", color = "green" },
},
{ "[", group = "prev" },
{ "]", group = "next" },
{ "g", group = "goto" },
{ "gs", group = "surround" },
{ s.prefix, group = "surround" },
{ "z", group = "fold" },
{
"<leader>b",
k.which_key.group.buffer == "" and {} or {
k.which_key.group.buffer,
group = "buffer",
expand = function()
return require("which-key.extras").expand.buf()
end,
},
{
"<leader>w",
k.which_key.group.windows == "" and {} or {
k.which_key.group.windows,
group = "windows",
proxy = "<c-w>",
expand = function()
@ -216,14 +245,14 @@ return {
},
keys = {
{
"<leader>?",
k.which_key.buffer_keymaps,
function()
require("which-key").show({ global = false })
end,
desc = "Buffer Keymaps (which-key)",
},
{
"<c-w><space>",
k.which_key.window_hydra_mode,
function()
require("which-key").show({ keys = "<c-w>", loop = true })
end,
@ -266,37 +295,37 @@ return {
local gs = package.loaded.gitsigns
local function map(mode, l, r, desc)
vim.keymap.set(mode, l, r, { buffer = buffer, desc = desc })
LazyVim.keymap_set(mode, l, r, { buffer = buffer, desc = desc })
end
-- stylua: ignore start
map("n", "]h", 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", "[h", 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", "]H", function() gs.nav_hunk("last") end, "Last Hunk")
map("n", "[H", function() gs.nav_hunk("first") end, "First Hunk")
map({ "n", "v" }, "<leader>ghs", ":Gitsigns stage_hunk<CR>", "Stage Hunk")
map({ "n", "v" }, "<leader>ghr", ":Gitsigns reset_hunk<CR>", "Reset Hunk")
map("n", "<leader>ghS", gs.stage_buffer, "Stage Buffer")
map("n", "<leader>ghu", gs.undo_stage_hunk, "Undo Stage Hunk")
map("n", "<leader>ghR", gs.reset_buffer, "Reset Buffer")
map("n", "<leader>ghp", gs.preview_hunk_inline, "Preview Hunk Inline")
map("n", "<leader>ghb", function() gs.blame_line({ full = true }) end, "Blame Line")
map("n", "<leader>ghB", function() gs.blame() end, "Blame Buffer")
map("n", "<leader>ghd", gs.diffthis, "Diff This")
map("n", "<leader>ghD", function() gs.diffthis("~") end, "Diff This ~")
map({ "o", "x" }, "ih", ":<C-U>Gitsigns select_hunk<CR>", "GitSigns Select Hunk")
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,
},
},
@ -313,14 +342,18 @@ return {
},
},
keys = {
{ "<leader>xx", "<cmd>Trouble diagnostics toggle<cr>", desc = "Diagnostics (Trouble)" },
{ "<leader>xX", "<cmd>Trouble diagnostics toggle filter.buf=0<cr>", desc = "Buffer Diagnostics (Trouble)" },
{ "<leader>cs", "<cmd>Trouble symbols toggle<cr>", desc = "Symbols (Trouble)" },
{ "<leader>cS", "<cmd>Trouble lsp toggle<cr>", desc = "LSP references/definitions/... (Trouble)" },
{ "<leader>xL", "<cmd>Trouble loclist toggle<cr>", desc = "Location List (Trouble)" },
{ "<leader>xQ", "<cmd>Trouble qflist toggle<cr>", desc = "Quickfix List (Trouble)" },
{ k.trouble.diagnostics_toggle, "<cmd>Trouble diagnostics toggle<cr>", desc = "Diagnostics (Trouble)" },
{
"[q",
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.previous_trouble,
function()
if require("trouble").is_open() then
require("trouble").prev({ skip_groups = true, jump = true })
@ -334,7 +367,7 @@ return {
desc = "Previous Trouble/Quickfix Item",
},
{
"]q",
k.trouble.next_trouble,
function()
if require("trouble").is_open() then
require("trouble").next({ skip_groups = true, jump = true })
@ -359,12 +392,12 @@ return {
opts = {},
-- stylua: ignore
keys = {
{ "]t", function() require("todo-comments").jump_next() end, desc = "Next Todo Comment" },
{ "[t", function() require("todo-comments").jump_prev() end, desc = "Previous Todo Comment" },
{ "<leader>xt", "<cmd>Trouble todo toggle<cr>", desc = "Todo (Trouble)" },
{ "<leader>xT", "<cmd>Trouble todo toggle filter = {tag = {TODO,FIX,FIXME}}<cr>", desc = "Todo/Fix/Fixme (Trouble)" },
{ "<leader>st", "<cmd>TodoTelescope<cr>", desc = "Todo" },
{ "<leader>sT", "<cmd>TodoTelescope keywords=TODO,FIX,FIXME<cr>", desc = "Todo/Fix/Fixme" },
{ 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" },
},
},

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

@ -1,4 +1,5 @@
local M = {}
local k = require("lazyvim.keymaps").get_keymaps().extras.coding.copilot_chat
---@param kind string
function M.pick(kind)
@ -37,10 +38,10 @@ return {
}
end,
keys = {
{ "<c-s>", "<CR>", ft = "copilot-chat", desc = "Submit Prompt", remap = true },
{ "<leader>a", "", desc = "+ai", mode = { "n", "v" } },
{ k.submit_prompt, "<CR>", ft = "copilot-chat", desc = "Submit Prompt", remap = true },
{ k.prefix, "", desc = "+ai", mode = { "n", "v" } },
{
"<leader>aa",
k.toggle,
function()
return require("CopilotChat").toggle()
end,
@ -48,7 +49,7 @@ return {
mode = { "n", "v" },
},
{
"<leader>ax",
k.clear,
function()
return require("CopilotChat").reset()
end,
@ -56,7 +57,7 @@ return {
mode = { "n", "v" },
},
{
"<leader>aq",
k.quick_chat,
function()
local input = vim.fn.input("Quick Chat: ")
if input ~= "" then
@ -67,9 +68,9 @@ return {
mode = { "n", "v" },
},
-- Show help actions with telescope
{ "<leader>ad", M.pick("help"), desc = "Diagnostic Help (CopilotChat)", mode = { "n", "v" } },
{ k.diagnostic_help, M.pick("help"), desc = "Diagnostic Help (CopilotChat)", mode = { "n", "v" } },
-- Show prompts actions with telescope
{ "<leader>ap", M.pick("prompt"), desc = "Prompt Actions (CopilotChat)", mode = { "n", "v" } },
{ k.prompt_actions, 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,3 +1,5 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.coding.luasnip
return {
{
"L3MON4D3/LuaSnip",
@ -37,14 +39,14 @@ return {
-- stylua: ignore
keys = {
{
"<tab>",
k.jump_next,
function()
return require("luasnip").jumpable(1) and "<Plug>luasnip-jump-next" or "<tab>"
end,
expr = true, silent = true, mode = "i",
},
{ "<tab>", function() require("luasnip").jump(1) end, mode = "s" },
{ "<s-tab>", function() require("luasnip").jump(-1) end, mode = { "i", "s" } },
{ k.jump_next, function() require("luasnip").jump(1) end, mode = "s" },
{ k.jump_prev, function() require("luasnip").jump(-1) end, mode = { "i", "s" } },
},
},
{

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

@ -2,6 +2,8 @@
-- 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
return {
"echasnovski/mini.surround",
recommended = true,
@ -24,13 +26,13 @@ return {
end,
opts = {
mappings = {
add = "gsa", -- Add surrounding in Normal and Visual modes
delete = "gsd", -- Delete surrounding
find = "gsf", -- Find surrounding (to the right)
find_left = "gsF", -- Find surrounding (to the left)
highlight = "gsh", -- Highlight surrounding
replace = "gsr", -- Replace surrounding
update_n_lines = "gsn", -- Update `n_lines`
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`
},
},
}

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

@ -1,4 +1,5 @@
-- better yank/paste
local k = require("lazyvim.keymaps").get_keymaps().extras.coding.yanky
return {
"gbprod/yanky.nvim",
recommended = true,
@ -9,7 +10,7 @@ return {
},
keys = {
{
"<leader>p",
k.yank_history,
function()
if LazyVim.pick.picker.name == "telescope" then
require("telescope").extensions.yank_history.yank_history({})
@ -21,22 +22,38 @@ return {
desc = "Open Yank History",
},
-- stylua: ignore
{ "y", "<Plug>(YankyYank)", mode = { "n", "x" }, desc = "Yank Text" },
{ "p", "<Plug>(YankyPutAfter)", mode = { "n", "x" }, desc = "Put Text After Cursor" },
{ "P", "<Plug>(YankyPutBefore)", mode = { "n", "x" }, desc = "Put Text Before Cursor" },
{ "gp", "<Plug>(YankyGPutAfter)", mode = { "n", "x" }, desc = "Put Text After Selection" },
{ "gP", "<Plug>(YankyGPutBefore)", mode = { "n", "x" }, desc = "Put Text Before Selection" },
{ "[y", "<Plug>(YankyCycleForward)", desc = "Cycle Forward Through Yank History" },
{ "]y", "<Plug>(YankyCycleBackward)", desc = "Cycle Backward Through Yank History" },
{ "]p", "<Plug>(YankyPutIndentAfterLinewise)", desc = "Put Indented After Cursor (Linewise)" },
{ "[p", "<Plug>(YankyPutIndentBeforeLinewise)", desc = "Put Indented Before Cursor (Linewise)" },
{ "]P", "<Plug>(YankyPutIndentAfterLinewise)", desc = "Put Indented After Cursor (Linewise)" },
{ "[P", "<Plug>(YankyPutIndentBeforeLinewise)", desc = "Put Indented Before Cursor (Linewise)" },
{ ">p", "<Plug>(YankyPutIndentAfterShiftRight)", desc = "Put and Indent Right" },
{ "<p", "<Plug>(YankyPutIndentAfterShiftLeft)", desc = "Put and Indent Left" },
{ ">P", "<Plug>(YankyPutIndentBeforeShiftRight)", desc = "Put Before and Indent Right" },
{ "<P", "<Plug>(YankyPutIndentBeforeShiftLeft)", desc = "Put Before and Indent Left" },
{ "=p", "<Plug>(YankyPutAfterFilter)", desc = "Put After Applying a Filter" },
{ "=P", "<Plug>(YankyPutBeforeFilter)", desc = "Put Before Applying a Filter" },
{ 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.put_indent_after_cursor_linewise,
"<Plug>(YankyPutIndentAfterLinewise)",
desc = "Put Indented After Cursor (Linewise)",
},
{
k.put_indent_before_cursor_linewise,
"<Plug>(YankyPutIndentBeforeLinewise)",
desc = "Put Indented Before Cursor (Linewise)",
},
{
k.put_indent_after_cursor_linewise_alt,
"<Plug>(YankyPutIndentAfterLinewise)",
desc = "Put Indented After Cursor (Linewise)",
},
{
k.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" },
},
}

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

@ -1,3 +1,5 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.dap.core
---@param config {args?:string[]|fun():string[]?}
local function get_args(config)
local args = type(config.args) == "function" and (config.args() or {}) or config.args or {}
@ -27,24 +29,24 @@ return {
-- stylua: ignore
keys = {
{ "<leader>d", "", desc = "+debug", mode = {"n", "v"} },
{ "<leader>dB", function() require("dap").set_breakpoint(vim.fn.input('Breakpoint condition: ')) end, desc = "Breakpoint Condition" },
{ "<leader>db", function() require("dap").toggle_breakpoint() end, desc = "Toggle Breakpoint" },
{ "<leader>dc", function() require("dap").continue() end, desc = "Continue" },
{ "<leader>da", function() require("dap").continue({ before = get_args }) end, desc = "Run with Args" },
{ "<leader>dC", function() require("dap").run_to_cursor() end, desc = "Run to Cursor" },
{ "<leader>dg", function() require("dap").goto_() end, desc = "Go to Line (No Execute)" },
{ "<leader>di", function() require("dap").step_into() end, desc = "Step Into" },
{ "<leader>dj", function() require("dap").down() end, desc = "Down" },
{ "<leader>dk", function() require("dap").up() end, desc = "Up" },
{ "<leader>dl", function() require("dap").run_last() end, desc = "Run Last" },
{ "<leader>do", function() require("dap").step_out() end, desc = "Step Out" },
{ "<leader>dO", function() require("dap").step_over() end, desc = "Step Over" },
{ "<leader>dp", function() require("dap").pause() end, desc = "Pause" },
{ "<leader>dr", function() require("dap").repl.toggle() end, desc = "Toggle REPL" },
{ "<leader>ds", function() require("dap").session() end, desc = "Session" },
{ "<leader>dt", function() require("dap").terminate() end, desc = "Terminate" },
{ "<leader>dw", function() require("dap.ui.widgets").hover() end, desc = "Widgets" },
{ 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" },
},
config = function()
@ -78,8 +80,8 @@ return {
dependencies = { "nvim-neotest/nvim-nio" },
-- stylua: ignore
keys = {
{ "<leader>du", function() require("dapui").toggle({ }) end, desc = "Dap UI" },
{ "<leader>de", function() require("dapui").eval() end, desc = "Eval", mode = {"n", "v"} },
{ 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"} },
},
opts = {},
config = function(_, opts)

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

@ -1,3 +1,7 @@
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
return {
desc = "Aerial Symbol Browser",
{
@ -43,7 +47,7 @@ return {
return opts
end,
keys = {
{ "<leader>cs", "<cmd>AerialToggle<cr>", desc = "Aerial (Symbols)" },
{ k.toggle, "<cmd>AerialToggle<cr>", desc = "Aerial (Symbols)" },
},
},
@ -51,7 +55,7 @@ return {
"folke/trouble.nvim",
optional = true,
keys = {
{ "<leader>cs", false },
{ t.symbols_toggle, false },
},
},
@ -66,7 +70,7 @@ return {
end,
keys = {
{
"<leader>ss",
p.go_to_symbol,
"<cmd>Telescope aerial<cr>",
desc = "Goto Symbol (Aerial)",
},

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

@ -1,4 +1,5 @@
local M = {}
local k = require("lazyvim.keymaps").get_keymaps().extras.editor.dial
---@param increment boolean
---@param g? boolean
@ -17,10 +18,10 @@ return {
desc = "Increment and decrement numbers, dates, and more",
-- stylua: ignore
keys = {
{ "<C-a>", function() return M.dial(true) end, expr = true, desc = "Increment", mode = {"n", "v"} },
{ "<C-x>", function() return M.dial(false) end, expr = true, desc = "Decrement", mode = {"n", "v"} },
{ "g<C-a>", function() return M.dial(true, true) end, expr = true, desc = "Increment", mode = {"n", "v"} },
{ "g<C-x>", function() return M.dial(false, true) end, expr = true, desc = "Decrement", mode = {"n", "v"} },
{ 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"} },
},
opts = function()
local augend = require("dial.augend")

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

@ -1,3 +1,7 @@
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
if lazyvim_docs then
-- In case you don't want to use `:LazyExtras`,
-- then you need to set the option below.
@ -98,6 +102,18 @@ return {
end
end
local default_keymaps = {
[k.actions.find_files_no_ignore] = { actions.toggle_ignore },
[k.actions.find_files_with_hidden] = { actions.toggle_hidden },
}
local keymaps = {}
for key, value in pairs(default_keymaps) do
if key and key ~= "" then
keymaps[key] = value
end
end
return vim.tbl_deep_extend("force", defaults, {
fzf_colors = true,
fzf_opts = {
@ -161,16 +177,10 @@ return {
},
files = {
cwd_prompt = false,
actions = {
["alt-i"] = { actions.toggle_ignore },
["alt-h"] = { actions.toggle_hidden },
},
actions = keymaps,
},
grep = {
actions = {
["alt-i"] = { actions.toggle_ignore },
["alt-h"] = { actions.toggle_hidden },
},
actions = keymaps,
},
lsp = {
symbols = {
@ -205,50 +215,50 @@ return {
{ "<c-j>", "<c-j>", ft = "fzf", mode = "t", nowait = true },
{ "<c-k>", "<c-k>", ft = "fzf", mode = "t", nowait = true },
{
"<leader>,",
k.switch_buffer,
"<cmd>FzfLua buffers sort_mru=true sort_lastused=true<cr>",
desc = "Switch Buffer",
},
{ "<leader>/", LazyVim.pick("live_grep"), desc = "Grep (Root Dir)" },
{ "<leader>:", "<cmd>FzfLua command_history<cr>", desc = "Command History" },
{ "<leader><space>", LazyVim.pick("files"), desc = "Find Files (Root Dir)" },
{ 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)" },
-- find
{ "<leader>fb", "<cmd>FzfLua buffers sort_mru=true sort_lastused=true<cr>", desc = "Buffers" },
{ "<leader>fc", LazyVim.pick.config_files(), desc = "Find Config File" },
{ "<leader>ff", LazyVim.pick("files"), desc = "Find Files (Root Dir)" },
{ "<leader>fF", LazyVim.pick("files", { root = false }), desc = "Find Files (cwd)" },
{ "<leader>fg", "<cmd>FzfLua git_files<cr>", desc = "Find Files (git-files)" },
{ "<leader>fr", "<cmd>FzfLua oldfiles<cr>", desc = "Recent" },
{ "<leader>fR", LazyVim.pick("oldfiles", { cwd = vim.uv.cwd() }), desc = "Recent (cwd)" },
{ 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)" },
-- git
{ "<leader>gc", "<cmd>FzfLua git_commits<CR>", desc = "Commits" },
{ "<leader>gs", "<cmd>FzfLua git_status<CR>", desc = "Status" },
{ k.git_commits, "<cmd>FzfLua git_commits<CR>", desc = "Commits" },
{ k.git_status, "<cmd>FzfLua git_status<CR>", desc = "Status" },
-- search
{ '<leader>s"', "<cmd>FzfLua registers<cr>", desc = "Registers" },
{ "<leader>sa", "<cmd>FzfLua autocmds<cr>", desc = "Auto Commands" },
{ "<leader>sb", "<cmd>FzfLua grep_curbuf<cr>", desc = "Buffer" },
{ "<leader>sc", "<cmd>FzfLua command_history<cr>", desc = "Command History" },
{ "<leader>sC", "<cmd>FzfLua commands<cr>", desc = "Commands" },
{ "<leader>sd", "<cmd>FzfLua diagnostics_document<cr>", desc = "Document Diagnostics" },
{ "<leader>sD", "<cmd>FzfLua diagnostics_workspace<cr>", desc = "Workspace Diagnostics" },
{ "<leader>sg", LazyVim.pick("live_grep"), desc = "Grep (Root Dir)" },
{ "<leader>sG", LazyVim.pick("live_grep", { root = false }), desc = "Grep (cwd)" },
{ "<leader>sh", "<cmd>FzfLua help_tags<cr>", desc = "Help Pages" },
{ "<leader>sH", "<cmd>FzfLua highlights<cr>", desc = "Search Highlight Groups" },
{ "<leader>sj", "<cmd>FzfLua jumps<cr>", desc = "Jumplist" },
{ "<leader>sk", "<cmd>FzfLua keymaps<cr>", desc = "Key Maps" },
{ "<leader>sl", "<cmd>FzfLua loclist<cr>", desc = "Location List" },
{ "<leader>sM", "<cmd>FzfLua man_pages<cr>", desc = "Man Pages" },
{ "<leader>sm", "<cmd>FzfLua marks<cr>", desc = "Jump to Mark" },
{ "<leader>sR", "<cmd>FzfLua resume<cr>", desc = "Resume" },
{ "<leader>sq", "<cmd>FzfLua quickfix<cr>", desc = "Quickfix List" },
{ "<leader>sw", LazyVim.pick("grep_cword"), desc = "Word (Root Dir)" },
{ "<leader>sW", LazyVim.pick("grep_cword", { root = false }), desc = "Word (cwd)" },
{ "<leader>sw", LazyVim.pick("grep_visual"), mode = "v", desc = "Selection (Root Dir)" },
{ "<leader>sW", LazyVim.pick("grep_visual", { root = false }), mode = "v", desc = "Selection (cwd)" },
{ "<leader>uC", LazyVim.pick("colorschemes"), desc = "Colorscheme with Preview" },
{ 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" },
{
"<leader>ss",
k.go_to_symbol,
function()
require("fzf-lua").lsp_document_symbols({
regex_filter = symbols_filter,
@ -257,7 +267,7 @@ return {
desc = "Goto Symbol",
},
{
"<leader>sS",
k.go_to_symbol_workspace,
function()
require("fzf-lua").lsp_live_workspace_symbols({
regex_filter = symbols_filter,
@ -273,8 +283,8 @@ return {
optional = true,
-- stylua: ignore
keys = {
{ "<leader>st", function() require("todo-comments.fzf").todo() end, desc = "Todo" },
{ "<leader>sT", function () require("todo-comments.fzf").todo({ keywords = { "TODO", "FIX", "FIXME" } }) end, desc = "Todo/Fix/Fixme" },
{ 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" },
},
},
@ -284,10 +294,10 @@ return {
local Keys = require("lazyvim.plugins.lsp.keymaps").get()
-- stylua: ignore
vim.list_extend(Keys, {
{ "gd", "<cmd>FzfLua lsp_definitions jump_to_single_result=true ignore_current_line=true<cr>", desc = "Goto Definition", has = "definition" },
{ "gr", "<cmd>FzfLua lsp_references jump_to_single_result=true ignore_current_line=true<cr>", desc = "References", nowait = true },
{ "gI", "<cmd>FzfLua lsp_implementations jump_to_single_result=true ignore_current_line=true<cr>", desc = "Goto Implementation" },
{ "gy", "<cmd>FzfLua lsp_typedefs jump_to_single_result=true ignore_current_line=true<cr>", desc = "Goto T[y]pe Definition" },
{ 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" },
})
end,
},

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

@ -1,3 +1,5 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.editor.harpoon2
return {
"ThePrimeagen/harpoon",
branch = "harpoon2",
@ -12,14 +14,14 @@ return {
keys = function()
local keys = {
{
"<leader>H",
k.harpoon_file,
function()
require("harpoon"):list():add()
end,
desc = "Harpoon File",
},
{
"<leader>h",
k.harpoon_quick_menu,
function()
local harpoon = require("harpoon")
harpoon.ui:toggle_quick_menu(harpoon:list())
@ -30,7 +32,7 @@ return {
for i = 1, 5 do
table.insert(keys, {
"<leader>" .. i,
k.harpoon_to_file_prefix .. i,
function()
require("harpoon"):list():select(i)
end,

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

@ -1,6 +1,8 @@
-- 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
return {
{
"RRethy/vim-illuminate",
@ -16,26 +18,26 @@ return {
require("illuminate").configure(opts)
local function map(key, dir, buffer)
vim.keymap.set("n", key, function()
LazyVim.keymap_set("n", key, function()
require("illuminate")["goto_" .. dir .. "_reference"](false)
end, { desc = dir:sub(1, 1):upper() .. dir:sub(2) .. " Reference", buffer = buffer })
end
map("]]", "next")
map("[[", "prev")
map(k.next, "next")
map(k.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("]]", "next", buffer)
map("[[", "prev", buffer)
map(k.next, "next", buffer)
map(k.prev, "prev", buffer)
end,
})
end,
keys = {
{ "]]", desc = "Next Reference" },
{ "[[", desc = "Prev Reference" },
{ k.next, desc = "Next Reference" },
{ k.prev, desc = "Prev Reference" },
},
},
{

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

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

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

@ -1,3 +1,7 @@
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
return {
-- disable flash
{ "folke/flash.nvim", enabled = false, optional = true },
@ -20,9 +24,9 @@ return {
"ggandor/leap.nvim",
enabled = true,
keys = {
{ "s", mode = { "n", "x", "o" }, desc = "Leap Forward to" },
{ "S", mode = { "n", "x", "o" }, desc = "Leap Backward to" },
{ "gs", mode = { "n", "x", "o" }, desc = "Leap from Windows" },
{ 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" },
},
config = function(_, opts)
local leap = require("leap")
@ -41,17 +45,17 @@ return {
optional = true,
opts = {
mappings = {
add = "gza", -- Add surrounding in Normal and Visual modes
delete = "gzd", -- Delete surrounding
find = "gzf", -- Find surrounding (to the right)
find_left = "gzF", -- Find surrounding (to the left)
highlight = "gzh", -- Highlight surrounding
replace = "gzr", -- Replace surrounding
update_n_lines = "gzn", -- Update `n_lines`
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`
},
},
keys = {
{ "gz", "", desc = "+surround" },
{ m.prefix == default.prefix and "gz" or m.prefix, "", desc = "+surround" },
},
},

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

@ -1,3 +1,5 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.editor.mini_diff
return {
-- disable gitsigns.nvim
{
@ -11,7 +13,7 @@ return {
event = "VeryLazy",
keys = {
{
"<leader>go",
k.toggle_overlay,
function()
require("mini.diff").toggle_overlay(0)
end,

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

@ -1,3 +1,6 @@
local map = LazyVim.keymap_set
local k = require("lazyvim.keymaps").get_keymaps().extras.editor.mini_files
return {
"echasnovski/mini.files",
opts = {
@ -14,14 +17,14 @@ return {
},
keys = {
{
"<leader>fm",
k.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)",
},
{
"<leader>fM",
k.open_cwd,
function()
require("mini.files").open(vim.uv.cwd(), true)
end,
@ -64,7 +67,7 @@ return {
if close_on_file then
desc = desc .. " and close"
end
vim.keymap.set("n", lhs, rhs, { buffer = buf_id, desc = desc })
map("n", lhs, rhs, { buffer = buf_id, desc = desc })
end
local files_set_cwd = function()
@ -80,14 +83,14 @@ return {
callback = function(args)
local buf_id = args.data.buf_id
vim.keymap.set(
map(
"n",
opts.mappings and opts.mappings.toggle_hidden or "g.",
toggle_dotfiles,
{ buffer = buf_id, desc = "Toggle hidden files" }
)
vim.keymap.set(
map(
"n",
opts.mappings and opts.mappings.change_cwd or "gc",
files_set_cwd,

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

@ -1,15 +1,18 @@
local k = require("lazyvim.keymaps").get_keymaps().editor.trouble
local o = require("lazyvim.keymaps").get_keymaps().extras.editor.outline
return {
-- Disable `<leader>cs` keymap so it doesn't conflict with `outline.nvim`
{
"folke/trouble.nvim",
optional = true,
keys = {
{ "<leader>cs", false },
{ k.symbols_toggle, false },
},
},
{
"hedyhli/outline.nvim",
keys = { { "<leader>cs", "<cmd>Outline<cr>", desc = "Toggle Outline" } },
keys = { { k.symbols_toggle, "<cmd>Outline<cr>", desc = "Toggle Outline" } },
cmd = "Outline",
opts = function()
local defaults = require("outline.config").defaults
@ -18,12 +21,19 @@ return {
icons = {},
filter = vim.deepcopy(LazyVim.config.kind_filter),
},
keymaps = {
up_and_jump = "<up>",
down_and_jump = "<down>",
},
keymaps = {},
}
local keymaps = {
up_and_jump = o.up_and_jump,
down_and_jump = o.down_and_jump,
}
for key, value in pairs(keymaps) do
if value and value ~= "" then
opts.keymaps[key] = value
end
end
for kind, symbol in pairs(defaults.symbols.icons) do
opts.symbols.icons[kind] = {
icon = LazyVim.config.icons.kinds[kind] or symbol.icon,

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

@ -1,3 +1,5 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.editor.overseer
return {
{
"catppuccin",
@ -51,13 +53,13 @@ return {
},
-- stylua: ignore
keys = {
{ "<leader>ow", "<cmd>OverseerToggle<cr>", desc = "Task list" },
{ "<leader>oo", "<cmd>OverseerRun<cr>", desc = "Run task" },
{ "<leader>oq", "<cmd>OverseerQuickAction<cr>", desc = "Action recent task" },
{ "<leader>oi", "<cmd>OverseerInfo<cr>", desc = "Overseer Info" },
{ "<leader>ob", "<cmd>OverseerBuild<cr>", desc = "Task builder" },
{ "<leader>ot", "<cmd>OverseerTaskAction<cr>", desc = "Task action" },
{ "<leader>oc", "<cmd>OverseerClearCache<cr>", desc = "Clear cache" },
{ 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" },
},
},
{
@ -65,7 +67,7 @@ return {
optional = true,
opts = {
spec = {
{ "<leader>o", group = "overseer" },
k.prefix == "" and {} or { k.prefix, group = "overseer" },
},
},
},

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

@ -1,3 +1,5 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.editor.refactoring
local pick = function()
if LazyVim.pick.picker.name == "telescope" then
return require("telescope").extensions.refactoring.refactors()
@ -28,15 +30,15 @@ return {
"nvim-treesitter/nvim-treesitter",
},
keys = {
{ "<leader>r", "", desc = "+refactor", mode = { "n", "v" } },
{ k.prefix, "", desc = "+refactor", mode = { "n", "v" } },
{
"<leader>rs",
k.refactor,
pick,
mode = "v",
desc = "Refactor",
},
{
"<leader>ri",
k.inline_variable,
function()
require("refactoring").refactor("Inline Variable")
end,
@ -44,42 +46,42 @@ return {
desc = "Inline Variable",
},
{
"<leader>rb",
k.extract_block,
function()
require("refactoring").refactor("Extract Block")
end,
desc = "Extract Block",
},
{
"<leader>rf",
k.extract_block_to_file,
function()
require("refactoring").refactor("Extract Block To File")
end,
desc = "Extract Block To File",
},
{
"<leader>rP",
k.debug_print,
function()
require("refactoring").debug.printf({ below = false })
end,
desc = "Debug Print",
},
{
"<leader>rp",
k.debug_print_variable,
function()
require("refactoring").debug.print_var({ normal = true })
end,
desc = "Debug Print Variable",
},
{
"<leader>rc",
k.debug_cleanup,
function()
require("refactoring").debug.cleanup({})
end,
desc = "Debug Cleanup",
},
{
"<leader>rf",
k.extract_function,
function()
require("refactoring").refactor("Extract Function")
end,
@ -87,7 +89,7 @@ return {
desc = "Extract Function",
},
{
"<leader>rF",
k.extract_function_to_file,
function()
require("refactoring").refactor("Extract Function To File")
end,
@ -95,7 +97,7 @@ return {
desc = "Extract Function To File",
},
{
"<leader>rx",
k.extract_variable,
function()
require("refactoring").refactor("Extract Variable")
end,
@ -103,7 +105,7 @@ return {
desc = "Extract Variable",
},
{
"<leader>rp",
k.debug_print_variable,
function()
require("refactoring").debug.print_var()
end,

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

@ -1,3 +1,7 @@
local extras = require("lazyvim.keymaps").get_keymaps().extras
local k = extras.editor.picker
local lang = extras.lang
if lazyvim_docs then
-- In case you don't want to use `:LazyExtras`,
-- then you need to set the option below.
@ -86,51 +90,55 @@ return {
},
keys = {
{
"<leader>,",
k.switch_buffer,
"<cmd>Telescope buffers sort_mru=true sort_lastused=true<cr>",
desc = "Switch Buffer",
},
{ "<leader>/", LazyVim.pick("live_grep"), desc = "Grep (Root Dir)" },
{ "<leader>:", "<cmd>Telescope command_history<cr>", desc = "Command History" },
{ "<leader><space>", LazyVim.pick("files"), desc = "Find Files (Root Dir)" },
{ 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)" },
-- find
{ "<leader>fb", "<cmd>Telescope buffers sort_mru=true sort_lastused=true<cr>", desc = "Buffers" },
{ "<leader>fc", LazyVim.pick.config_files(), desc = "Find Config File" },
{ "<leader>ff", LazyVim.pick("files"), desc = "Find Files (Root Dir)" },
{ "<leader>fF", LazyVim.pick("files", { root = false }), desc = "Find Files (cwd)" },
{ "<leader>fg", "<cmd>Telescope git_files<cr>", desc = "Find Files (git-files)" },
{ "<leader>fr", "<cmd>Telescope oldfiles<cr>", desc = "Recent" },
{ "<leader>fR", LazyVim.pick("oldfiles", { cwd = vim.uv.cwd() }), desc = "Recent (cwd)" },
{ 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)" },
-- git
{ "<leader>gc", "<cmd>Telescope git_commits<CR>", desc = "Commits" },
{ "<leader>gs", "<cmd>Telescope git_status<CR>", desc = "Status" },
{ k.git_commits, "<cmd>Telescope git_commits<CR>", desc = "Commits" },
{ k.git_status, "<cmd>Telescope git_status<CR>", desc = "Status" },
-- search
{ '<leader>s"', "<cmd>Telescope registers<cr>", desc = "Registers" },
{ "<leader>sa", "<cmd>Telescope autocommands<cr>", desc = "Auto Commands" },
{ "<leader>sb", "<cmd>Telescope current_buffer_fuzzy_find<cr>", desc = "Buffer" },
{ "<leader>sc", "<cmd>Telescope command_history<cr>", desc = "Command History" },
{ "<leader>sC", "<cmd>Telescope commands<cr>", desc = "Commands" },
{ "<leader>sd", "<cmd>Telescope diagnostics bufnr=0<cr>", desc = "Document Diagnostics" },
{ "<leader>sD", "<cmd>Telescope diagnostics<cr>", desc = "Workspace Diagnostics" },
{ "<leader>sg", LazyVim.pick("live_grep"), desc = "Grep (Root Dir)" },
{ "<leader>sG", LazyVim.pick("live_grep", { root = false }), desc = "Grep (cwd)" },
{ "<leader>sh", "<cmd>Telescope help_tags<cr>", desc = "Help Pages" },
{ "<leader>sH", "<cmd>Telescope highlights<cr>", desc = "Search Highlight Groups" },
{ "<leader>sj", "<cmd>Telescope jumplist<cr>", desc = "Jumplist" },
{ "<leader>sk", "<cmd>Telescope keymaps<cr>", desc = "Key Maps" },
{ "<leader>sl", "<cmd>Telescope loclist<cr>", desc = "Location List" },
{ "<leader>sM", "<cmd>Telescope man_pages<cr>", desc = "Man Pages" },
{ "<leader>sm", "<cmd>Telescope marks<cr>", desc = "Jump to Mark" },
{ "<leader>so", "<cmd>Telescope vim_options<cr>", desc = "Options" },
{ "<leader>sR", "<cmd>Telescope resume<cr>", desc = "Resume" },
{ "<leader>sq", "<cmd>Telescope quickfix<cr>", desc = "Quickfix List" },
{ "<leader>sw", LazyVim.pick("grep_string", { word_match = "-w" }), desc = "Word (Root Dir)" },
{ "<leader>sW", LazyVim.pick("grep_string", { root = false, word_match = "-w" }), desc = "Word (cwd)" },
{ "<leader>sw", LazyVim.pick("grep_string"), mode = "v", desc = "Selection (Root Dir)" },
{ "<leader>sW", LazyVim.pick("grep_string", { root = false }), mode = "v", desc = "Selection (cwd)" },
{ "<leader>uC", LazyVim.pick("colorscheme", { enable_preview = true }), desc = "Colorscheme with Preview" },
{ 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)" },
{
"<leader>ss",
k.colorscheme_preview,
LazyVim.pick("colorscheme", { enable_preview = true }),
desc = "Colorscheme with Preview",
},
{
k.go_to_symbol,
function()
require("telescope.builtin").lsp_document_symbols({
symbols = LazyVim.config.get_kind_filter(),
@ -139,7 +147,7 @@ return {
desc = "Goto Symbol",
},
{
"<leader>sS",
k.go_to_symbol_workspace,
function()
require("telescope.builtin").lsp_dynamic_workspace_symbols({
symbols = LazyVim.config.get_kind_filter(),
@ -179,6 +187,35 @@ return {
end
end
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 },
},
n = {
{ k.actions.close, actions.close },
},
}
local mappings = {
i = {},
n = {},
}
local function filter_keymaps(_keymaps, source)
for _, keymap in ipairs(_keymaps) do
if keymap[1] and keymap[1] ~= "" then
source[keymap[1]] = keymap[2]
end
end
end
filter_keymaps(keymaps.i, mappings.i)
filter_keymaps(keymaps.n, mappings.n)
return {
defaults = {
prompt_prefix = "",
@ -196,21 +233,7 @@ return {
end
return 0
end,
mappings = {
i = {
["<c-t>"] = open_with_trouble,
["<a-t>"] = open_with_trouble,
["<a-i>"] = find_files_no_ignore,
["<a-h>"] = find_files_with_hidden,
["<C-Down>"] = actions.cycle_history_next,
["<C-Up>"] = actions.cycle_history_prev,
["<C-f>"] = actions.preview_scrolling_down,
["<C-b>"] = actions.preview_scrolling_up,
},
n = {
["q"] = actions.close,
},
},
mappings = mappings,
},
pickers = {
find_files = {
@ -249,7 +272,7 @@ return {
})
end
opts.defaults = vim.tbl_deep_extend("force", opts.defaults or {}, {
mappings = { n = { s = flash }, i = { ["<c-s>"] = flash } },
mappings = { n = k.flash.normal == "" and {} or { [k.flash.normal] = flash }, i = k.flash.insert == "" and {} or { [k.flash.insert] = flash } },
})
end,
},
@ -284,10 +307,10 @@ return {
local Keys = require("lazyvim.plugins.lsp.keymaps").get()
-- stylua: ignore
vim.list_extend(Keys, {
{ "gd", function() require("telescope.builtin").lsp_definitions({ reuse_win = true }) end, desc = "Goto Definition", has = "definition" },
{ "gr", "<cmd>Telescope lsp_references<cr>", desc = "References", nowait = true },
{ "gI", function() require("telescope.builtin").lsp_implementations({ reuse_win = true }) end, desc = "Goto Implementation" },
{ "gy", function() require("telescope.builtin").lsp_type_definitions({ reuse_win = true }) end, desc = "Goto T[y]pe Definition" },
{ 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" },
})
end,
},

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

@ -1,3 +1,5 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.lang.ansible
return {
recommended = function()
return LazyVim.extras.wants({
@ -22,7 +24,7 @@ return {
ft = {},
keys = {
{
"<leader>ta",
k.ansible_run_playbook_role,
function()
require("ansible").run()
end,

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

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

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

@ -1,3 +1,6 @@
local map = LazyVim.keymap_set
local k = require("lazyvim.keymaps").get_keymaps().extras.lang.clojure
return {
recommended = function()
return LazyVim.extras.wants({
@ -75,17 +78,17 @@ return {
vim.g.conjure_baleia.automatically(buffer)
end
vim.keymap.set(
map(
{ "n", "v" },
"[c",
k.jump_prev_evaluation_output,
"<CMD>call search('^; -\\+$', 'bw')<CR>",
{ silent = true, buffer = true, desc = "Jumps to the begining of previous evaluation output." }
{ silent = true, buffer = true, desc = "Jumps to the beginning of previous evaluation output." }
)
vim.keymap.set(
map(
{ "n", "v" },
"]c",
k.jump_next_evaluation_output,
"<CMD>call search('^; -\\+$', 'w')<CR>",
{ silent = true, buffer = true, desc = "Jumps to the begining of next evaluation output." }
{ silent = true, buffer = true, desc = "Jumps to the beginning of next evaluation output." }
)
end,
})

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

@ -1,3 +1,5 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.lang.elixir
return {
recommended = function()
return LazyVim.extras.wants({
@ -12,7 +14,7 @@ return {
elixirls = {
keys = {
{
"<leader>cp",
k.to_pipe,
function()
local params = vim.lsp.util.make_position_params()
LazyVim.lsp.execute({
@ -23,7 +25,7 @@ return {
desc = "To Pipe",
},
{
"<leader>cP",
k.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,5 +1,8 @@
-- 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 java_filetypes = { "java" }
-- Utility function to extend or override a config table, similar to the way
@ -194,32 +197,31 @@ return {
{
mode = "n",
buffer = args.buf,
{ "<leader>cx", group = "extract" },
{ "<leader>cxv", require("jdtls").extract_variable_all, desc = "Extract Variable" },
{ "<leader>cxc", require("jdtls").extract_constant, desc = "Extract Constant" },
{ "gs", require("jdtls").super_implementation, desc = "Goto Super" },
{ "gS", require("jdtls.tests").goto_subjects, desc = "Goto Subjects" },
{ "<leader>co", require("jdtls").organize_imports, desc = "Organize Imports" },
{ 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" },
},
})
wk.add({
{
mode = "v",
buffer = args.buf,
{ "<leader>cx", group = "extract" },
{ k.extract.prefix, group = "extract" },
{
"<leader>cxm",
k.extract.method,
[[<ESC><CMD>lua require('jdtls').extract_method(true)<CR>]],
desc = "Extract Method",
},
{
"<leader>cxv",
k.extract.variable,
[[<ESC><CMD>lua require('jdtls').extract_variable_all(true)<CR>]],
desc = "Extract Variable",
},
{
"<leader>cxc",
[[<ESC><CMD>lua require('jdtls').extract_constant(true)<CR>]],
k.extract.constant([[<ESC><CMD>lua require('jdtls').extract_constant(true)<CR>]]),
desc = "Extract Constant",
},
},
@ -237,9 +239,9 @@ return {
{
mode = "n",
buffer = args.buf,
{ "<leader>t", group = "test" },
{ t.prefix, group = "test" },
{
"<leader>tt",
t.run_all_test_files,
function()
require("jdtls.dap").test_class({
config_overrides = type(opts.test) ~= "boolean" and opts.test.config_overrides or nil,
@ -248,7 +250,7 @@ return {
desc = "Run All Test",
},
{
"<leader>tr",
t.run_nearest,
function()
require("jdtls.dap").test_nearest_method({
config_overrides = type(opts.test) ~= "boolean" and opts.test.config_overrides or nil,
@ -256,7 +258,7 @@ return {
end,
desc = "Run Nearest Test",
},
{ "<leader>tT", require("jdtls.dap").pick_test, desc = "Run Test" },
{ t.run_file, require("jdtls.dap").pick_test, desc = "Run Test" },
},
})
end

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

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

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

@ -1,3 +1,5 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.lang.markdown
LazyVim.on_very_lazy(function()
vim.filetype.add({
extension = { mdx = "markdown.mdx" },
@ -81,7 +83,7 @@ return {
end,
keys = {
{
"<leader>cp",
k.markdown_preview_toggle,
ft = "markdown",
"<cmd>MarkdownPreviewToggle<cr>",
desc = "Markdown Preview",
@ -108,7 +110,7 @@ return {
ft = { "markdown", "norg", "rmd", "org" },
config = function(_, opts)
require("render-markdown").setup(opts)
LazyVim.toggle.map("<leader>um", {
LazyVim.toggle.map(k.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,3 +1,5 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.lang
return {
recommended = function()
return LazyVim.extras.wants({
@ -51,7 +53,7 @@ return {
},
keys = {
{
"gd",
k.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,3 +1,5 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.lang
if lazyvim_docs then
-- LSP Server to use for Python.
-- Set to "basedpyright" to use basedpyright instead of pyright.
@ -40,7 +42,7 @@ return {
},
keys = {
{
"<leader>co",
k.organize_imports,
LazyVim.lsp.action["source.organizeImports"],
desc = "Organize Imports",
},
@ -49,7 +51,7 @@ return {
ruff_lsp = {
keys = {
{
"<leader>co",
k.organize_imports,
LazyVim.lsp.action["source.organizeImports"],
desc = "Organize Imports",
},
@ -99,8 +101,8 @@ return {
"mfussenegger/nvim-dap-python",
-- stylua: ignore
keys = {
{ "<leader>dPt", function() require('dap-python').test_method() end, desc = "Debug Method", ft = "python" },
{ "<leader>dPc", 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
@ -128,7 +130,7 @@ return {
},
-- Call config for python files and load the cached venv automatically
ft = "python",
keys = { { "<leader>cv", "<cmd>:VenvSelect<cr>", desc = "Select VirtualEnv", ft = "python" } },
keys = { { k.python.select_virtual_env, "<cmd>:VenvSelect<cr>", desc = "Select VirtualEnv", ft = "python" } },
},
{

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

@ -1,3 +1,6 @@
local map = LazyVim.keymap_set
local k = require("lazyvim.keymaps").get_keymaps().extras.lang.r
return {
recommended = function()
return LazyVim.extras.wants({
@ -16,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.
vim.keymap.set("n", "<Enter>", "<Plug>RDSendLine", { buffer = true })
vim.keymap.set("v", "<Enter>", "<Plug>RSendSelection", { buffer = true })
map("n", k.send, "<Plug>RDSendLine", { buffer = true })
map("v", k.send, "<Plug>RSendSelection", { buffer = true })
local wk = require("which-key")
wk.add({
buffer = true,
{ "<localleader>a", group = "all" },
{ "<localleader>b", group = "between marks" },
{ "<localleader>c", group = "chunks" },
{ "<localleader>f", group = "functions" },
{ "<localleader>g", group = "goto" },
{ "<localleader>i", group = "install" },
{ "<localleader>k", group = "knit" },
{ "<localleader>p", group = "paragraph" },
{ "<localleader>q", group = "quarto" },
{ "<localleader>r", group = "r general" },
{ "<localleader>s", group = "split or send" },
{ "<localleader>t", group = "terminal" },
{ "<localleader>v", group = "view" },
{ 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" },
})
end,
},

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

@ -1,3 +1,6 @@
local map = LazyVim.keymap_set
local k = require("lazyvim.keymaps").get_keymaps().extras.lang.rust
return {
recommended = function()
return LazyVim.extras.wants({
@ -48,10 +51,10 @@ return {
opts = {
server = {
on_attach = function(_, bufnr)
vim.keymap.set("n", "<leader>cR", function()
map("n", k.code_action, function()
vim.cmd.RustLsp("codeAction")
end, { desc = "Code Action", buffer = bufnr })
vim.keymap.set("n", "<leader>dr", function()
map("n", k.debuggables, function()
vim.cmd.RustLsp("debuggables")
end, { desc = "Rust Debuggables", buffer = bufnr })
end,
@ -98,7 +101,7 @@ return {
taplo = {
keys = {
{
"K",
k.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,3 +1,5 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.lang.scala
return {
recommended = function()
return LazyVim.extras.wants({
@ -21,14 +23,14 @@ return {
metals = {
keys = {
{
"<leader>me",
k.metals_commands,
function()
require("telescope").extensions.metals.commands()
end,
desc = "Metals commands",
},
{
"<leader>mc",
k.metals_compile_cascade,
function()
require("metals").compile_cascade()
end,

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

@ -1,3 +1,5 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.lang.sql
if lazyvim_docs then
-- The setup below will automatically configure connections without the need for manual input each time.
@ -71,7 +73,7 @@ return {
cmd = { "DBUI", "DBUIToggle", "DBUIAddConnection", "DBUIFindBuffer" },
dependencies = "vim-dadbod",
keys = {
{ "<leader>D", "<cmd>DBUIToggle<CR>", desc = "Toggle DBUI" },
{ k.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,3 +1,5 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.lang
return {
recommended = function()
return LazyVim.extras.wants({
@ -26,7 +28,7 @@ return {
svelte = {
keys = {
{
"<leader>co",
k.organize_imports,
LazyVim.lsp.action["source.organizeImports"],
desc = "Organize Imports",
},

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

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

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

@ -1,3 +1,5 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.lang
return {
recommended = function()
return LazyVim.extras.wants({
@ -66,7 +68,7 @@ return {
},
keys = {
{
"gD",
k.typescript.go_to_source_definition,
function()
local params = vim.lsp.util.make_position_params()
LazyVim.lsp.execute({
@ -78,7 +80,7 @@ return {
desc = "Goto Source Definition",
},
{
"gR",
k.file_references,
function()
LazyVim.lsp.execute({
command = "typescript.findAllFileReferences",
@ -89,27 +91,27 @@ return {
desc = "File References",
},
{
"<leader>co",
k.organize_imports,
LazyVim.lsp.action["source.organizeImports"],
desc = "Organize Imports",
},
{
"<leader>cM",
k.add_missing_imports,
LazyVim.lsp.action["source.addMissingImports.ts"],
desc = "Add missing imports",
},
{
"<leader>cu",
k.remove_unused_imports,
LazyVim.lsp.action["source.removeUnused.ts"],
desc = "Remove unused imports",
},
{
"<leader>cD",
k.fix_all_diagnostics,
LazyVim.lsp.action["source.fixAll.ts"],
desc = "Fix all diagnostics",
},
{
"<leader>cV",
k.select_lang_version,
function()
LazyVim.lsp.execute({ command = "typescript.selectTypeScriptVersion" })
end,

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

@ -1,3 +1,5 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.test.core
return {
recommended = true,
desc = "Neotest support. Requires language specific adapters to be configured. (see lang extras)",
@ -105,16 +107,16 @@ return {
end,
-- stylua: ignore
keys = {
{"<leader>t", "", desc = "+test"},
{ "<leader>tt", function() require("neotest").run.run(vim.fn.expand("%")) end, desc = "Run File" },
{ "<leader>tT", function() require("neotest").run.run(vim.uv.cwd()) end, desc = "Run All Test Files" },
{ "<leader>tr", function() require("neotest").run.run() end, desc = "Run Nearest" },
{ "<leader>tl", function() require("neotest").run.run_last() end, desc = "Run Last" },
{ "<leader>ts", function() require("neotest").summary.toggle() end, desc = "Toggle Summary" },
{ "<leader>to", function() require("neotest").output.open({ enter = true, auto_close = true }) end, desc = "Show Output" },
{ "<leader>tO", function() require("neotest").output_panel.toggle() end, desc = "Toggle Output Panel" },
{ "<leader>tS", function() require("neotest").run.stop() end, desc = "Stop" },
{ "<leader>tw", function() require("neotest").watch.toggle(vim.fn.expand("%")) end, desc = "Toggle Watch" },
{ 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" },
},
},
{
@ -122,7 +124,7 @@ return {
optional = true,
-- stylua: ignore
keys = {
{ "<leader>td", function() require("neotest").run.run({strategy = "dap"}) end, desc = "Debug Nearest" },
{ k.debug_nearest, function() require("neotest").run.run({strategy = "dap"}) end, desc = "Debug Nearest" },
},
},
}

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

@ -1,3 +1,5 @@
local k = require("lazyvim.keymaps").get_keymaps().ui.dashboard
return {
{ "nvimdev/dashboard-nvim", enabled = false },
@ -22,17 +24,25 @@ return {
dashboard.section.header.val = vim.split(logo, "\n")
-- stylua: ignore
dashboard.section.buttons.val = {
dashboard.button("f", "" .. " Find file", LazyVim.pick()),
dashboard.button("n", "" .. " New file", [[<cmd> ene <BAR> startinsert <cr>]]),
dashboard.button("r", "" .. " Recent files", LazyVim.pick("oldfiles")),
dashboard.button("g", "" .. " Find text", LazyVim.pick("live_grep")),
dashboard.button("c", "" .. " Config", LazyVim.pick.config_files()),
dashboard.button("s", "" .. " Restore Session", [[<cmd> lua require("persistence").load() <cr>]]),
dashboard.button("x", "" .. " Lazy Extras", "<cmd> LazyExtras <cr>"),
dashboard.button("l", "󰒲 " .. " Lazy", "<cmd> Lazy <cr>"),
dashboard.button("q", "" .. " Quit", "<cmd> qa <cr>"),
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>" },
}
for _, action in ipairs(actions) do
if action[1] and action[1] ~= "" then
table.insert(dashboard.section.buttons.val, dashboard.button(action[1], action[2], action[3]))
end
end
for _, button in ipairs(dashboard.section.buttons.val) do
button.opts.hl = "AlphaButtons"
button.opts.hl_shortcut = "AlphaShortcut"

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

@ -1,3 +1,6 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.ui.edgy
local r = require("lazyvim.keymaps").get_keymaps().keymaps.resize_window
return {
-- edgy
{
@ -5,16 +8,42 @@ return {
event = "VeryLazy",
keys = {
{
"<leader>ue",
k.toggle,
function()
require("edgy").toggle()
end,
desc = "Edgy Toggle",
},
-- stylua: ignore
{ "<leader>uE", function() require("edgy").select() end, desc = "Edgy Select Window" },
{ k.select_window, function() require("edgy").select() end, desc = "Edgy Select Window" },
},
opts = function()
local keys = {}
local actions = {
-- increase width
[r.increase_width] = function(win)
win:resize("width", 2)
end,
-- decrease width
[r.decrease_width] = function(win)
win:resize("width", -2)
end,
-- increase height
[r.increase_height] = function(win)
win:resize("height", 2)
end,
-- decrease height
[r.decrease_height] = function(win)
win:resize("height", -2)
end,
}
for key, action in pairs(actions) do
if key and key ~= "" then
keys[key] = action
end
end
local opts = {
bottom = {
{
@ -59,24 +88,7 @@ return {
right = {
{ title = "Grug Far", ft = "grug-far", size = { width = 0.4 } },
},
keys = {
-- increase width
["<c-Right>"] = function(win)
win:resize("width", 2)
end,
-- decrease width
["<c-Left>"] = function(win)
win:resize("width", -2)
end,
-- increase height
["<c-Up>"] = function(win)
win:resize("height", 2)
end,
-- decrease height
["<c-Down>"] = function(win)
win:resize("height", -2)
end,
},
keys = keys,
}
if LazyVim.has("neo-tree.nvim") then

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

@ -1,4 +1,6 @@
-- animations
local k = require("lazyvim.keymaps").get_keymaps().extras.ui.mini_animate
return {
"echasnovski/mini.animate",
recommended = true,
@ -21,7 +23,7 @@ return {
end,
})
LazyVim.toggle.map("<leader>ua", {
LazyVim.toggle.map(k.toggle, {
name = "Mini Animate",
get = function()
return not vim.g.minianimate_disable

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

@ -1,11 +1,13 @@
-- Show context of the current function
local k = require("lazyvim.keymaps").get_keymaps().extras.ui.treesitter_context
return {
"nvim-treesitter/nvim-treesitter-context",
event = "VeryLazy",
opts = function()
local tsc = require("treesitter-context")
LazyVim.toggle.map("<leader>ut", {
LazyVim.toggle.map(k.toggle, {
name = "Treesitter Context",
get = tsc.enabled,
set = function(state)

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

@ -1,3 +1,5 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.util.chezmoi
local pick_chezmoi = function()
if LazyVim.pick.picker.name == "telescope" then
require("telescope").extensions.chezmoi.find_files()
@ -35,7 +37,7 @@ return {
"xvzc/chezmoi.nvim",
keys = {
{
"<leader>sz",
k.pick_chezmoi,
pick_chezmoi,
desc = "Chezmoi",
},
@ -51,7 +53,7 @@ return {
on_watch = false,
},
telescope = {
select = { "<CR>" },
select = k.select == "" and {} or { k.select },
},
},
init = function()
@ -68,11 +70,15 @@ return {
"nvimdev/dashboard-nvim",
optional = true,
opts = function(_, opts)
if not k.key or k.key == "" then
return opts
end
local projects = {
action = pick_chezmoi,
desc = " Config",
icon = "",
key = "c",
key = k.key,
}
projects.desc = projects.desc .. string.rep(" ", 43 - #projects.desc)

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

@ -1,3 +1,5 @@
local k = require("lazyvim.keymaps").get_keymaps().keymaps.lazygit
return {
-- Ensure GitUI tool is installed
@ -6,14 +8,14 @@ return {
opts = { ensure_installed = { "gitui" } },
keys = {
{
"<leader>gG",
k.toggle_cwd,
function()
LazyVim.terminal.open({ "gitui" }, { esc_esc = false, ctrl_hjkl = false })
end,
desc = "GitUi (cwd)",
},
{
"<leader>gg",
k.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,3 +1,5 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.util.octo
return {
-- depends on the git extra for highlighting and auto-completion of github issues/prs
@ -15,22 +17,22 @@ return {
picker = "telescope",
},
keys = {
{ "<leader>gi", "<cmd>Octo issue list<CR>", desc = "List Issues (Octo)" },
{ "<leader>gI", "<cmd>Octo issue search<CR>", desc = "Search Issues (Octo)" },
{ "<leader>gp", "<cmd>Octo pr list<CR>", desc = "List PRs (Octo)" },
{ "<leader>gP", "<cmd>Octo pr search<CR>", desc = "Search PRs (Octo)" },
{ "<leader>gr", "<cmd>Octo repo list<CR>", desc = "List Repos (Octo)" },
{ "<leader>gS", "<cmd>Octo search<CR>", desc = "Search (Octo)" },
{ 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)" },
{ "<leader>a", "", desc = "+assignee (Octo)", ft = "octo" },
{ "<leader>c", "", desc = "+comment/code (Octo)", ft = "octo" },
{ "<leader>l", "", desc = "+label (Octo)", ft = "octo" },
{ "<leader>i", "", desc = "+issue (Octo)", ft = "octo" },
{ "<leader>r", "", desc = "+react (Octo)", ft = "octo" },
{ "<leader>p", "", desc = "+pr (Octo)", ft = "octo" },
{ "<leader>v", "", desc = "+review (Octo)", ft = "octo" },
{ "@", "@<C-x><C-o>", mode = "i", ft = "octo", silent = true },
{ "#", "#<C-x><C-o>", mode = "i", ft = "octo", silent = true },
{ 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 },
},
},

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

@ -1,3 +1,6 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.editor.picker
local d = require("lazyvim.keymaps").get_keymaps().ui.dashboard
local pick = nil
pick = function()
@ -101,7 +104,7 @@ return {
"nvim-telescope/telescope.nvim",
optional = true,
keys = {
{ "<leader>fp", pick, desc = "Projects" },
{ k.find_projects, pick, desc = "Projects" },
},
},
@ -109,7 +112,7 @@ return {
"ibhagwan/fzf-lua",
optional = true,
keys = {
{ "<leader>fp", pick, desc = "Projects" },
{ k.find_projects, pick, desc = "Projects" },
},
},
@ -143,11 +146,15 @@ return {
"nvimdev/dashboard-nvim",
optional = true,
opts = function(_, opts)
if not d.projects or d.projects == "" then
return opts
end
local projects = {
action = pick,
desc = " Projects",
icon = "",
key = "p",
key = d.projects,
}
projects.desc = projects.desc .. string.rep(" ", 43 - #projects.desc)

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

@ -1,3 +1,5 @@
local k = require("lazyvim.keymaps").get_keymaps().extras.util.rest.kulala
vim.filetype.add({
extension = {
["http"] = "http",
@ -8,11 +10,11 @@ return {
"mistweaverco/kulala.nvim",
ft = "http",
keys = {
{ "<leader>R", "", desc = "+Rest" },
{ "<leader>Rs", "<cmd>lua require('kulala').run()<cr>", desc = "Send the request" },
{ "<leader>Rt", "<cmd>lua require('kulala').toggle_view()<cr>", desc = "Toggle headers/body" },
{ "<leader>Rp", "<cmd>lua require('kulala').jump_prev()<cr>", desc = "Jump to previous request" },
{ "<leader>Rn", "<cmd>lua require('kulala').jump_next()<cr>", desc = "Jump to next request" },
{ 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" },
},
opts = {},
},

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

@ -28,13 +28,16 @@ Config.options.defaults.cond = function(plugin)
return vim.tbl_contains(enabled, plugin.name) or plugin.vscode
end
local map = LazyVim.keymap_set
local k = require("lazyvim.keymaps").get_keymaps().extras.vscode
-- Add some vscode specific keymaps
vim.api.nvim_create_autocmd("User", {
pattern = "LazyVimKeymapsDefaults",
callback = function()
vim.keymap.set("n", "<leader><space>", "<cmd>Find<cr>")
vim.keymap.set("n", "<leader>/", [[<cmd>lua require('vscode').action('workbench.action.findInFiles')<cr>]])
vim.keymap.set("n", "<leader>ss", [[<cmd>lua require('vscode').action('workbench.action.gotoSymbol')<cr>]])
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>]])
end,
})

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

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

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

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

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

@ -1,4 +1,5 @@
local M = {}
local k = require("lazyvim.keymaps").get_keymaps().extras.lang
---@type LazyKeysLspSpec[]|nil
M._keys = nil
@ -11,32 +12,86 @@ function M.get()
if M._keys then
return M._keys
end
-- stylua: ignore
M._keys = {
{ "<leader>cl", "<cmd>LspInfo<cr>", desc = "Lsp Info" },
{ "gd", vim.lsp.buf.definition, desc = "Goto Definition", has = "definition" },
{ "gr", vim.lsp.buf.references, desc = "References", nowait = true },
{ "gI", vim.lsp.buf.implementation, desc = "Goto Implementation" },
{ "gy", vim.lsp.buf.type_definition, desc = "Goto T[y]pe Definition" },
{ "gD", vim.lsp.buf.declaration, desc = "Goto Declaration" },
{ "K", vim.lsp.buf.hover, desc = "Hover" },
{ "gK", vim.lsp.buf.signature_help, desc = "Signature Help", has = "signatureHelp" },
{ "<c-k>", vim.lsp.buf.signature_help, mode = "i", desc = "Signature Help", has = "signatureHelp" },
{ "<leader>ca", vim.lsp.buf.code_action, desc = "Code Action", mode = { "n", "v" }, has = "codeAction" },
{ "<leader>cc", vim.lsp.codelens.run, desc = "Run Codelens", mode = { "n", "v" }, has = "codeLens" },
{ "<leader>cC", vim.lsp.codelens.refresh, desc = "Refresh & Display Codelens", mode = { "n" }, has = "codeLens" },
{ "<leader>cR", LazyVim.lsp.rename_file, desc = "Rename File", mode ={"n"}, has = { "workspace/didRenameFiles", "workspace/willRenameFiles" } },
{ "<leader>cr", vim.lsp.buf.rename, desc = "Rename", has = "rename" },
{ "<leader>cA", LazyVim.lsp.action.source, desc = "Source Action", has = "codeAction" },
{ "]]", function() LazyVim.lsp.words.jump(vim.v.count1) end, has = "documentHighlight",
desc = "Next Reference", cond = function() return LazyVim.lsp.words.enabled end },
{ "[[", function() LazyVim.lsp.words.jump(-vim.v.count1) end, has = "documentHighlight",
desc = "Prev Reference", cond = function() return LazyVim.lsp.words.enabled end },
{ "<a-n>", function() LazyVim.lsp.words.jump(vim.v.count1, true) end, has = "documentHighlight",
desc = "Next Reference", cond = function() return LazyVim.lsp.words.enabled end },
{ "<a-p>", function() LazyVim.lsp.words.jump(-vim.v.count1, true) end, has = "documentHighlight",
desc = "Prev Reference", cond = function() return LazyVim.lsp.words.enabled 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.refresh_codelens,
vim.lsp.codelens.refresh,
desc = "Refresh & Display Codelens",
mode = { "n" },
has = "codeLens",
},
{
k.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.next_reference,
function()
LazyVim.lsp.words.jump(vim.v.count1)
end,
has = "documentHighlight",
desc = "Next Reference",
cond = function()
return LazyVim.lsp.words.enabled
end,
},
{
k.prev_reference,
function()
LazyVim.lsp.words.jump(-vim.v.count1)
end,
has = "documentHighlight",
desc = "Prev Reference",
cond = function()
return LazyVim.lsp.words.enabled
end,
},
{
k.cycle_next_reference,
function()
LazyVim.lsp.words.jump(vim.v.count1, true)
end,
has = "documentHighlight",
desc = "Next Reference",
cond = function()
return LazyVim.lsp.words.enabled
end,
},
{
k.cycle_prev_reference,
function()
LazyVim.lsp.words.jump(-vim.v.count1, true)
end,
has = "documentHighlight",
desc = "Prev Reference",
cond = function()
return LazyVim.lsp.words.enabled
end,
},
}
M._keys = {}
for _, action in ipairs(actions) do
if action[1] and action[1] ~= "" then
table.insert(M._keys, action)
end
end
return M._keys
end
@ -91,7 +146,7 @@ function M.on_attach(_, buffer)
opts.has = nil
opts.silent = opts.silent ~= false
opts.buffer = buffer
vim.keymap.set(keys.mode or "n", keys.lhs, keys.rhs, opts)
LazyVim.keymap_set(keys.mode or "n", keys.lhs, keys.rhs, opts)
end
end
end

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

@ -1,10 +1,12 @@
local k = require("lazyvim.keymaps").get_keymaps().treesitter
return {
{
"folke/which-key.nvim",
opts = {
spec = {
{ "<BS>", desc = "Decrement Selection", mode = "x" },
{ "<c-space>", desc = "Increment Selection", mode = { "x", "n" } },
{ k.decrement_selection, desc = "Decrement Selection", mode = "x" },
{ k.increment_selection, desc = "Increment Selection", mode = { "x", "n" } },
},
},
},
@ -29,8 +31,8 @@ return {
end,
cmd = { "TSUpdateSync", "TSUpdate", "TSInstall" },
keys = {
{ "<c-space>", desc = "Increment Selection" },
{ "<bs>", desc = "Decrement Selection", mode = "x" },
{ k.increment_selection, desc = "Increment Selection" },
{ k.decrement_selection, desc = "Decrement Selection", mode = "x" },
},
opts_extend = { "ensure_installed" },
---@type TSConfig
@ -67,19 +69,35 @@ return {
incremental_selection = {
enable = true,
keymaps = {
init_selection = "<C-space>",
node_incremental = "<C-space>",
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,
scope_incremental = false,
node_decremental = "<bs>",
node_decremental = (k.decrement_selection and k.decrement_selection ~= "") and k.decrement_selection or false,
},
},
textobjects = {
move = {
enable = true,
goto_next_start = { ["]f"] = "@function.outer", ["]c"] = "@class.outer", ["]a"] = "@parameter.inner" },
goto_next_end = { ["]F"] = "@function.outer", ["]C"] = "@class.outer", ["]A"] = "@parameter.inner" },
goto_previous_start = { ["[f"] = "@function.outer", ["[c"] = "@class.outer", ["[a"] = "@parameter.inner" },
goto_previous_end = { ["[F"] = "@function.outer", ["[C"] = "@class.outer", ["[A"] = "@parameter.inner" },
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",
},
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",
},
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",
},
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",
},
},
},
},

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

@ -1,10 +1,12 @@
local k = require("lazyvim.keymaps").get_keymaps().ui
return {
-- Better `vim.notify()`
{
"rcarriga/nvim-notify",
keys = {
{
"<leader>un",
k.nvim_notify.dismiss_all_notifications,
function()
require("notify").dismiss({ silent = true, pending = true })
end,
@ -40,17 +42,29 @@ return {
"akinsho/bufferline.nvim",
event = "VeryLazy",
keys = {
{ "<leader>bp", "<Cmd>BufferLineTogglePin<CR>", desc = "Toggle Pin" },
{ "<leader>bP", "<Cmd>BufferLineGroupClose ungrouped<CR>", desc = "Delete Non-Pinned Buffers" },
{ "<leader>bo", "<Cmd>BufferLineCloseOthers<CR>", desc = "Delete Other Buffers" },
{ "<leader>br", "<Cmd>BufferLineCloseRight<CR>", desc = "Delete Buffers to the Right" },
{ "<leader>bl", "<Cmd>BufferLineCloseLeft<CR>", desc = "Delete Buffers to the Left" },
{ "<S-h>", "<cmd>BufferLineCyclePrev<cr>", desc = "Prev Buffer" },
{ "<S-l>", "<cmd>BufferLineCycleNext<cr>", desc = "Next Buffer" },
{ "[b", "<cmd>BufferLineCyclePrev<cr>", desc = "Prev Buffer" },
{ "]b", "<cmd>BufferLineCycleNext<cr>", desc = "Next Buffer" },
{ "[B", "<cmd>BufferLineMovePrev<cr>", desc = "Move buffer prev" },
{ "]B", "<cmd>BufferLineMoveNext<cr>", desc = "Move buffer next" },
{ k.bufferline.toggle_pin, "<Cmd>BufferLineTogglePin<CR>", desc = "Toggle Pin" },
{
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_buffers_to_the_right,
"<Cmd>BufferLineCloseRight<CR>",
desc = "Delete Buffers to the Right",
},
{
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" },
},
opts = {
options = {
@ -226,7 +240,7 @@ return {
"lukas-reineke/indent-blankline.nvim",
event = "LazyFile",
opts = function()
LazyVim.toggle.map("<leader>ug", {
LazyVim.toggle.map(k.indent_blankline.toggle, {
name = "Indention Guides",
get = function()
return require("ibl.config").get_config(0).enabled
@ -295,15 +309,15 @@ return {
},
-- stylua: ignore
keys = {
{ "<leader>sn", "", desc = "+noice"},
{ "<S-Enter>", function() require("noice").redirect(vim.fn.getcmdline()) end, mode = "c", desc = "Redirect Cmdline" },
{ "<leader>snl", function() require("noice").cmd("last") end, desc = "Noice Last Message" },
{ "<leader>snh", function() require("noice").cmd("history") end, desc = "Noice History" },
{ "<leader>sna", function() require("noice").cmd("all") end, desc = "Noice All" },
{ "<leader>snd", function() require("noice").cmd("dismiss") end, desc = "Dismiss All" },
{ "<leader>snt", function() require("noice").cmd("pick") end, desc = "Noice Picker (Telescope/FzfLua)" },
{ "<c-f>", 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"} },
{ "<c-b>", 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,
@ -355,6 +369,69 @@ return {
logo = string.rep("\n", 8) .. logo .. "\n\n"
local actions = {
{
action = "lua LazyVim.pick()()",
desc = " Find File",
icon = "",
key = k.dashboard.find_file,
},
{
action = "ene | startinsert",
desc = " New File",
icon = "",
key = k.dashboard.new_file,
},
{
action = 'lua LazyVim.pick("oldfiles")()',
desc = " Recent Files",
icon = "",
key = k.dashboard.recent_files,
},
{
action = 'lua LazyVim.pick("live_grep")()',
desc = " Find Text",
icon = "",
key = k.dashboard.find_text,
},
{
action = "lua LazyVim.pick.config_files()()",
desc = " Config",
icon = "",
key = k.dashboard.config,
},
{
action = 'lua require("persistence").load()',
desc = " Restore Session",
icon = "",
key = k.dashboard.restore_session,
},
{
action = "LazyExtras",
desc = " Lazy Extras",
icon = "",
key = k.dashboard.lazy_extras,
},
{
action = "Lazy",
desc = " Lazy",
icon = "󰒲 ",
key = k.dashboard.lazy,
},
{
action = function()
vim.api.nvim_input("<cmd>qa<cr>")
end,
desc = " Quit",
icon = "",
key = k.dashboard.quit,
},
}
actions = vim.tbl_filter(function(action)
return action.key and action.key ~= ""
end, actions)
local opts = {
theme = "doom",
hide = {
@ -365,17 +442,7 @@ return {
config = {
header = vim.split(logo, "\n"),
-- stylua: ignore
center = {
{ action = 'lua LazyVim.pick()()', desc = " Find File", icon = "", key = "f" },
{ action = "ene | startinsert", desc = " New File", icon = "", key = "n" },
{ action = 'lua LazyVim.pick("oldfiles")()', desc = " Recent Files", icon = "", key = "r" },
{ action = 'lua LazyVim.pick("live_grep")()', desc = " Find Text", icon = "", key = "g" },
{ action = 'lua LazyVim.pick.config_files()()', desc = " Config", icon = "", key = "c" },
{ action = 'lua require("persistence").load()', desc = " Restore Session", icon = "", key = "s" },
{ action = "LazyExtras", desc = " Lazy Extras", icon = "", key = "x" },
{ action = "Lazy", desc = " Lazy", icon = "󰒲 ", key = "l" },
{ action = function() vim.api.nvim_input("<cmd>qa<cr>") end, desc = " Quit", icon = "", key = "q" },
},
center = actions,
footer = function()
local stats = require("lazy").stats()
local ms = (math.floor(stats.startuptime * 100 + 0.5) / 100)

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

@ -1,3 +1,5 @@
local k = require("lazyvim.keymaps").get_keymaps().util.persistence
return {
-- Session management. This saves your session in the background,
@ -9,10 +11,10 @@ return {
opts = {},
-- stylua: ignore
keys = {
{ "<leader>qs", function() require("persistence").load() end, desc = "Restore Session" },
{ "<leader>qS", function() require("persistence").select() end,desc = "Select Session" },
{ "<leader>ql", function() require("persistence").load({ last = true }) end, desc = "Restore Last Session" },
{ "<leader>qd", function() require("persistence").stop() end, desc = "Don't Save Current Session" },
{ 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" },
},
},

15
lua/lazyvim/util/init.lua
View file

@ -194,7 +194,7 @@ function M.on_load(name, fn)
end
end
-- Wrapper around vim.keymap.set that will
-- Wrapper around LazyVim.keymap_set that will
-- not create a keymap if a lazy key handler exists.
-- It will also set `silent` to true by default.
function M.safe_keymap_set(mode, lhs, rhs, opts)
@ -215,10 +215,21 @@ function M.safe_keymap_set(mode, lhs, rhs, opts)
---@diagnostic disable-next-line: no-unknown
opts.remap = nil
end
vim.keymap.set(modes, lhs, rhs, opts)
M.keymap_set(modes, lhs, rhs, opts)
end
end
-- Wrapper around vim.keymap.set that will
-- not create a keymap if lhs or rhs is empty.
-- This is useful in case `lhs` is dynamic
-- and users can set it to empty to disable the keymap.
function M.keymap_set(mode, lhs, rhs, opts)
if not lhs or lhs == "" or not rhs or rhs == "" then
return
end
vim.keymap.set(mode, lhs, rhs, opts)
end
---@generic T
---@param list T[]
---@return T[]

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

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