1735 lines
40 KiB
Lua
1735 lines
40 KiB
Lua
---@module "data.keys"
|
|
--- This module contains the keymaps for the plugins and commands.
|
|
--- Keymaps use the add_keymap function from data.func for flexible
|
|
--- keybinding functionality.
|
|
-- ╭─────────────────────────────────────────────────────────╮
|
|
-- │ KEYS DATA │
|
|
-- ╰─────────────────────────────────────────────────────────╯
|
|
|
|
local M = {}
|
|
|
|
-- Load utils
|
|
local rootiest = require('config.rootiest')
|
|
|
|
M.alternate = {
|
|
{ -- Toggle Alternate
|
|
'<leader>A',
|
|
'<cmd>Alternate<cr>',
|
|
desc = 'Toggle Alternate',
|
|
},
|
|
}
|
|
|
|
M.autosave = function()
|
|
local group = vim.api.nvim_create_augroup('autosave', {})
|
|
|
|
vim.api.nvim_create_autocmd('User', {
|
|
pattern = 'AutoSaveEnable',
|
|
group = group,
|
|
callback = function()
|
|
vim.g.auto_save_enabled = true
|
|
end,
|
|
})
|
|
|
|
vim.api.nvim_create_autocmd('User', {
|
|
pattern = 'AutoSaveDisable',
|
|
group = group,
|
|
callback = function()
|
|
vim.g.auto_save_enabled = false
|
|
end,
|
|
})
|
|
|
|
require('snacks.toggle')
|
|
.new({
|
|
id = 'autosave',
|
|
name = 'Auto-Write',
|
|
get = function()
|
|
return vim.g.auto_save_enabled
|
|
end,
|
|
set = function()
|
|
require('auto-save').toggle()
|
|
end,
|
|
})
|
|
:map('<leader>uW')
|
|
end
|
|
|
|
M.blink = function()
|
|
require('snacks.toggle')
|
|
.new({
|
|
name = 'Completion',
|
|
which_key = true,
|
|
get = function()
|
|
if vim.g.cmp_auto_show == false then
|
|
return false
|
|
end
|
|
return true
|
|
end,
|
|
|
|
set = function(state)
|
|
if state then
|
|
vim.g.cmp_auto_show = true
|
|
else
|
|
vim.g.cmp_auto_show = false
|
|
end
|
|
end,
|
|
})
|
|
:map('<leader>uB')
|
|
end
|
|
|
|
M.capsword = {
|
|
{
|
|
'<C-s>',
|
|
function()
|
|
require('caps-word').toggle()
|
|
end,
|
|
desc = 'Toggle CapsWord',
|
|
mode = { 'i', 'n' },
|
|
},
|
|
}
|
|
|
|
M.chatgpt = {
|
|
func = function()
|
|
-- Add ChatGPT menu
|
|
require('data.func').add_keymap(M.group.chatgpt)
|
|
-- Add ChatGPT keys
|
|
return M.chatgpt.keys
|
|
end,
|
|
keys = {
|
|
{
|
|
'<leader>cxc',
|
|
'<cmd>ChatGPT<cr>',
|
|
desc = 'ChatGPT',
|
|
},
|
|
{
|
|
'<leader>cxe',
|
|
'<cmd>ChatGPTEditWithInstruction<cr>',
|
|
desc = 'Edit with instruction',
|
|
mode = { 'n', 'v' },
|
|
},
|
|
{
|
|
'<leader>cxg',
|
|
'<cmd>ChatGPTRun grammar_correction<cr>',
|
|
desc = 'Grammar Correction',
|
|
mode = { 'n', 'v' },
|
|
},
|
|
{
|
|
'<leader>cxt',
|
|
'<cmd>ChatGPTRun translate<cr>',
|
|
desc = 'Translate',
|
|
mode = { 'n', 'v' },
|
|
},
|
|
{
|
|
'<leader>cxk',
|
|
'<cmd>ChatGPTRun keywords<cr>',
|
|
desc = 'Keywords',
|
|
mode = { 'n', 'v' },
|
|
},
|
|
{
|
|
'<leader>cxd',
|
|
'<cmd>ChatGPTRun docstring<cr>',
|
|
desc = 'Docstring',
|
|
mode = { 'n', 'v' },
|
|
},
|
|
{
|
|
'<leader>cxa',
|
|
'<cmd>ChatGPTRun add_tests<cr>',
|
|
desc = 'Add Tests',
|
|
mode = { 'n', 'v' },
|
|
},
|
|
{
|
|
'<leader>cxo',
|
|
'<cmd>ChatGPTRun optimize_code<cr>',
|
|
desc = 'Optimize Code',
|
|
mode = { 'n', 'v' },
|
|
},
|
|
{
|
|
'<leader>cxs',
|
|
'<cmd>ChatGPTRun summarize<cr>',
|
|
desc = 'Summarize',
|
|
mode = { 'n', 'v' },
|
|
},
|
|
{
|
|
'<leader>cxf',
|
|
'<cmd>ChatGPTRun fix_bugs<cr>',
|
|
desc = 'Fix Bugs',
|
|
mode = { 'n', 'v' },
|
|
},
|
|
{
|
|
'<leader>cxr',
|
|
'<cmd>ChatGPTRun explain_code<cr>',
|
|
desc = 'Explain Code',
|
|
mode = { 'n', 'v' },
|
|
},
|
|
{
|
|
'<leader>cxr',
|
|
'<cmd>ChatGPTRun roxygen_edit<cr>',
|
|
desc = 'Roxygen Edit',
|
|
mode = { 'n', 'v' },
|
|
},
|
|
{
|
|
'<leader>cxl',
|
|
'<cmd>ChatGPTRun code_readability_analysis<cr>',
|
|
desc = 'Code Readability Analysis',
|
|
mode = { 'n', 'v' },
|
|
},
|
|
},
|
|
}
|
|
|
|
M.codesnap = {
|
|
{ -- Save selected code snapshot into clipboard
|
|
'<leader>cy',
|
|
'<cmd>CodeSnap<cr>',
|
|
desc = 'Save selected code snapshot into clipboard',
|
|
mode = 'x',
|
|
},
|
|
{ -- Save selected code snapshot in ~/Pictures
|
|
'<leader>cs',
|
|
'<cmd>CodeSnapSave<cr>',
|
|
desc = 'Save selected code snapshot in ~/Pictures',
|
|
mode = 'x',
|
|
},
|
|
{ -- Highlight and snapshot selected code into clipboard
|
|
'<leader>ch',
|
|
'<cmd>CodeSnapHighlight<cr>',
|
|
desc = 'Highlight and snapshot selected code into clipboard',
|
|
mode = 'x',
|
|
},
|
|
{ -- Save ASCII code snapshot into clipboard
|
|
'<leader>ci',
|
|
'<cmd>CodeSnapASCII<cr>',
|
|
desc = 'Save ASCII code snapshot into clipboard',
|
|
mode = 'x',
|
|
},
|
|
}
|
|
|
|
M.easyalign = {
|
|
{ -- EasyAlign
|
|
'<leader>g\\',
|
|
'<Plug>(EasyAlign)',
|
|
desc = 'EasyAlign',
|
|
mode = { 'n', 'x' },
|
|
},
|
|
}
|
|
|
|
M.cipher = {
|
|
base64 = {
|
|
{
|
|
lhs = 'g?',
|
|
rhs = function()
|
|
require('data.func').base64_encode_text()
|
|
end,
|
|
desc = 'Base64 Encode',
|
|
mode = 'n',
|
|
},
|
|
{
|
|
lhs = 'g?',
|
|
rhs = function()
|
|
require('data.func').base64_encode_visual()
|
|
end,
|
|
desc = 'Base64 Encode',
|
|
mode = 'v',
|
|
},
|
|
{
|
|
lhs = 'g/',
|
|
rhs = function()
|
|
require('data.func').base64_decode_text()
|
|
end,
|
|
desc = 'Base64 Decode',
|
|
mode = 'n',
|
|
},
|
|
{
|
|
lhs = 'g/',
|
|
rhs = function()
|
|
require('data.func').base64_decode_visual()
|
|
end,
|
|
desc = 'Base64 Decode',
|
|
mode = 'v',
|
|
},
|
|
},
|
|
hex = {
|
|
{
|
|
lhs = 'g?',
|
|
rhs = function()
|
|
require('data.func').hex_encode_text()
|
|
end,
|
|
desc = 'Hex Encode',
|
|
mode = 'n',
|
|
},
|
|
{
|
|
lhs = 'g?',
|
|
rhs = function()
|
|
require('data.func').hex_encode_visual()
|
|
end,
|
|
desc = 'Hex Encode',
|
|
mode = 'v',
|
|
},
|
|
{
|
|
lhs = 'g/',
|
|
rhs = function()
|
|
require('data.func').hex_decode_text()
|
|
end,
|
|
desc = 'Hex Decode',
|
|
mode = 'n',
|
|
},
|
|
{
|
|
lhs = 'g/',
|
|
rhs = function()
|
|
require('data.func').hex_decode_visual()
|
|
end,
|
|
desc = 'Hex Decode',
|
|
mode = 'v',
|
|
},
|
|
},
|
|
rot47 = {
|
|
{
|
|
lhs = 'g?',
|
|
rhs = function()
|
|
require('data.func').rot47_text()
|
|
end,
|
|
desc = 'ROT47 Encode',
|
|
mode = 'n',
|
|
},
|
|
{
|
|
lhs = 'g?',
|
|
rhs = function()
|
|
require('data.func').rot47_visual()
|
|
end,
|
|
desc = 'ROT47 Encode',
|
|
mode = 'v',
|
|
},
|
|
},
|
|
}
|
|
|
|
M.cmd_mode = function()
|
|
if not require('data.func').is_installed('which_key', { load = true }) then
|
|
-- Disable the original `q:` mapping
|
|
vim.keymap.set('n', 'q:', '<Nop>', { noremap = true, silent = true })
|
|
|
|
-- Remap `q:` functionality to `<Leader>q:`
|
|
vim.keymap.set(
|
|
'n',
|
|
'<Leader>q:',
|
|
'q:',
|
|
{ noremap = true, silent = false, desc = 'Command Mode' }
|
|
)
|
|
else
|
|
-- Disable the original `q:` mapping and hide it from which-key
|
|
require('which-key').add({
|
|
lhs = 'q:',
|
|
rhs = '<Nop>',
|
|
mode = 'n',
|
|
hidden = true,
|
|
noremap = true,
|
|
silent = true,
|
|
})
|
|
|
|
-- Remap `q:` functionality to `<Leader>q:`
|
|
require('which-key').add({
|
|
lhs = '<Leader>q:',
|
|
rhs = 'q:',
|
|
mode = 'n',
|
|
noremap = true,
|
|
silent = false,
|
|
desc = 'Command Mode',
|
|
})
|
|
end
|
|
end
|
|
|
|
M.cpp_picker = {
|
|
{ -- Cpp Picker
|
|
'<leader>fC',
|
|
function()
|
|
require('data.func').search_cpp_files()
|
|
end,
|
|
desc = 'Pick C++ and H files',
|
|
},
|
|
}
|
|
|
|
M.flash = {
|
|
{ -- Flash jump to next
|
|
'<CR>',
|
|
function()
|
|
require('flash').jump()
|
|
end,
|
|
desc = 'Flash jump',
|
|
mode = { 'n', 'o', 'v' },
|
|
},
|
|
}
|
|
|
|
M.minimap = {
|
|
func = function()
|
|
-- Add NeoMiniMap menu
|
|
require('data.func').add_keymap(M.group.minimap)
|
|
-- Add NeoMiniMap keys
|
|
return M.minimap.keys
|
|
end,
|
|
keys = {
|
|
{ -- Toggle minimap
|
|
'<leader>nt',
|
|
'<cmd>Neominimap toggle<cr>',
|
|
desc = 'Toggle minimap',
|
|
},
|
|
{ -- Enable minimap
|
|
'<leader>no',
|
|
'<cmd>Neominimap on<cr>',
|
|
desc = 'Enable minimap',
|
|
},
|
|
{ -- Disable minimap
|
|
'<leader>nc',
|
|
'<cmd>Neominimap off<cr>',
|
|
desc = 'Disable minimap',
|
|
},
|
|
{ -- Refresh minimap
|
|
'<leader>nf',
|
|
'<cmd>Neominimap focus<cr>',
|
|
desc = 'Focus on minimap',
|
|
},
|
|
{ -- Unfocus minimap
|
|
'<leader>nu',
|
|
'<cmd>Neominimap unfocus<cr>',
|
|
desc = 'Unfocus minimap',
|
|
},
|
|
{ -- Toggle focus
|
|
'<leader>ns',
|
|
'<cmd>Neominimap toggleFocus<cr>',
|
|
desc = 'Toggle focus on minimap',
|
|
},
|
|
{ -- Toggle minimap for current window
|
|
'<leader>nwt',
|
|
'<cmd>Neominimap winToggle<cr>',
|
|
desc = 'Toggle minimap for current window',
|
|
},
|
|
{ -- Refresh minimap for current window
|
|
'<leader>nwr',
|
|
'<cmd>Neominimap winRefresh<cr>',
|
|
desc = 'Refresh minimap for current window',
|
|
},
|
|
{ -- Enable minimap for current window
|
|
'<leader>nwo',
|
|
'<cmd>Neominimap winOn<cr>',
|
|
desc = 'Enable minimap for current window',
|
|
},
|
|
{ -- Disable minimap for current window
|
|
'<leader>nwc',
|
|
'<cmd>Neominimap winOff<cr>',
|
|
desc = 'Disable minimap for current window',
|
|
},
|
|
{ -- Toggle minimap for current buffer
|
|
'<leader>nbt',
|
|
'<cmd>Neominimap bufToggle<cr>',
|
|
desc = 'Toggle minimap for current buffer',
|
|
},
|
|
{ -- Refresh minimap for current buffer
|
|
'<leader>nbr',
|
|
'<cmd>Neominimap bufRefresh<cr>',
|
|
desc = 'Refresh minimap for current buffer',
|
|
},
|
|
{ -- Enable minimap for current buffer
|
|
'<leader>nbo',
|
|
'<cmd>Neominimap bufOn<cr>',
|
|
desc = 'Enable minimap for current buffer',
|
|
},
|
|
{ -- Disable minimap for current buffer
|
|
'<leader>nbc',
|
|
'<cmd>Neominimap bufOff<cr>',
|
|
desc = 'Disable minimap for current buffer',
|
|
},
|
|
},
|
|
}
|
|
|
|
M.neocodeium = {
|
|
{ -- Accept suggestion
|
|
'<c-y>',
|
|
function()
|
|
require('neocodeium').accept()
|
|
end,
|
|
desc = 'Accept suggestion',
|
|
mode = 'i',
|
|
},
|
|
{ -- Accept word
|
|
'<c-w>',
|
|
function()
|
|
require('neocodeium').accept_word()
|
|
end,
|
|
desc = 'Accept word',
|
|
mode = 'i',
|
|
},
|
|
{ -- Accept line
|
|
'<c-l>',
|
|
function()
|
|
require('neocodeium').accept_line()
|
|
end,
|
|
desc = 'Accept line',
|
|
mode = 'i',
|
|
},
|
|
{ -- Cycle or complete (previous)
|
|
'<c-p>',
|
|
function()
|
|
require('neocodeium').cycle_or_complete(-1)
|
|
end,
|
|
desc = 'Cycle or complete (previous)',
|
|
mode = 'i',
|
|
},
|
|
{ -- Cycle or complete (next)
|
|
'<c-n>',
|
|
function()
|
|
require('neocodeium').cycle_or_complete()
|
|
end,
|
|
desc = 'Cycle or complete (next)',
|
|
mode = 'i',
|
|
},
|
|
{ -- NeoCodeium Chat
|
|
'<leader>ch',
|
|
function()
|
|
require('neocodeium').chat()
|
|
end,
|
|
desc = 'NeoCodeium Chat',
|
|
},
|
|
}
|
|
|
|
M.foldnav = {
|
|
{ -- Goto Start
|
|
'<C-h>',
|
|
function()
|
|
require('foldnav').goto_start()
|
|
end,
|
|
},
|
|
{ -- Goto Next
|
|
'<C-j>',
|
|
function()
|
|
require('foldnav').goto_next()
|
|
end,
|
|
},
|
|
{ -- Goto Prev
|
|
'<C-k>',
|
|
function()
|
|
require('foldnav').goto_prev_start()
|
|
end,
|
|
},
|
|
{ -- Goto End
|
|
'<C-l>',
|
|
function()
|
|
require('foldnav').goto_end()
|
|
end,
|
|
},
|
|
}
|
|
|
|
M.gitlinker = {
|
|
{ -- Yank git link
|
|
'<leader>gy',
|
|
'<cmd>GitLink<cr>',
|
|
mode = { 'n', 'v' },
|
|
desc = 'Yank git link',
|
|
},
|
|
{ -- Open git link
|
|
'<leader>gY',
|
|
'<cmd>GitLink!<cr>',
|
|
mode = { 'n', 'v' },
|
|
desc = 'Open git link',
|
|
},
|
|
}
|
|
|
|
M.gitgraph = {
|
|
{ -- gitgraph_toggle
|
|
'<leader>gm',
|
|
function()
|
|
require('utils.git').gitgraph_toggle()
|
|
end,
|
|
desc = 'GitGraph - Toggle',
|
|
},
|
|
}
|
|
|
|
M.gist = {
|
|
func = function()
|
|
-- Add gists menu
|
|
require('data.func').add_keymap(M.group.gist)
|
|
-- Add gists keys
|
|
return M.gist.keys
|
|
end,
|
|
keys = {
|
|
{ -- Create Gist
|
|
'<leader>gnc',
|
|
'<cmd>GistCreate<cr>',
|
|
desc = 'Create Gist',
|
|
mode = { 'n', 'x' },
|
|
},
|
|
{ -- Find Gists
|
|
'<leader>gnf',
|
|
'<cmd>GistList<cr>',
|
|
desc = 'Find Gists',
|
|
},
|
|
},
|
|
}
|
|
|
|
M.undotree = function()
|
|
require('data.func').add_keymap(
|
|
'<leader>uu',
|
|
'<cmd>UndotreeToggle<cr>',
|
|
'Toggle UndoTree'
|
|
)
|
|
end
|
|
|
|
M.gp = {
|
|
func = function()
|
|
-- Use which-key directly
|
|
if pcall(require, 'which-key') then
|
|
require('which-key').add(M.gp.keys)
|
|
end
|
|
end,
|
|
keys = {
|
|
-- VISUAL mode mappings
|
|
-- s, x, v modes are handled the same way by which_key
|
|
{
|
|
mode = { 'v' },
|
|
nowait = true,
|
|
remap = false,
|
|
{
|
|
'<C-g><C-t>',
|
|
":<C-u>'<,'>GpChatNew tabnew<cr>",
|
|
desc = 'ChatNew tabnew',
|
|
},
|
|
{
|
|
'<C-g><C-v>',
|
|
":<C-u>'<,'>GpChatNew vsplit<cr>",
|
|
desc = 'ChatNew vsplit',
|
|
},
|
|
{
|
|
'<C-g><C-x>',
|
|
":<C-u>'<,'>GpChatNew split<cr>",
|
|
desc = 'ChatNew split',
|
|
},
|
|
{ '<C-g>a', ":<C-u>'<,'>GpAppend<cr>", desc = 'Visual Append (after)' },
|
|
{
|
|
'<C-g>b',
|
|
":<C-u>'<,'>GpPrepend<cr>",
|
|
desc = 'Visual Prepend (before)',
|
|
},
|
|
{ '<C-g>c', ":<C-u>'<,'>GpChatNew<cr>", desc = 'Visual Chat New' },
|
|
{ '<C-g>g', group = 'generate into new ..' },
|
|
{ '<C-g>ge', ":<C-u>'<,'>GpEnew<cr>", desc = 'Visual GpEnew' },
|
|
{ '<C-g>gn', ":<C-u>'<,'>GpNew<cr>", desc = 'Visual GpNew' },
|
|
{ '<C-g>gp', ":<C-u>'<,'>GpPopup<cr>", desc = 'Visual Popup' },
|
|
{ '<C-g>gt', ":<C-u>'<,'>GpTabnew<cr>", desc = 'Visual GpTabnew' },
|
|
{ '<C-g>gv', ":<C-u>'<,'>GpVnew<cr>", desc = 'Visual GpVnew' },
|
|
{ '<C-g>i', ":<C-u>'<,'>GpImplement<cr>", desc = 'Implement selection' },
|
|
{ '<C-g>n', '<cmd>GpNextAgent<cr>', desc = 'Next Agent' },
|
|
{ '<C-g>p', ":<C-u>'<,'>GpChatPaste<cr>", desc = 'Visual Chat Paste' },
|
|
{ '<C-g>r', ":<C-u>'<,'>GpRewrite<cr>", desc = 'Visual Rewrite' },
|
|
{ '<C-g>s', '<cmd>GpStop<cr>', desc = 'GpStop' },
|
|
{ '<C-g>t', ":<C-u>'<,'>GpChatToggle<cr>", desc = 'Visual Toggle Chat' },
|
|
{ '<C-g>w', group = 'Whisper' },
|
|
{ '<C-g>wa', ":<C-u>'<,'>GpWhisperAppend<cr>", desc = 'Whisper Append' },
|
|
{
|
|
'<C-g>wb',
|
|
":<C-u>'<,'>GpWhisperPrepend<cr>",
|
|
desc = 'Whisper Prepend',
|
|
},
|
|
{ '<C-g>we', ":<C-u>'<,'>GpWhisperEnew<cr>", desc = 'Whisper Enew' },
|
|
{ '<C-g>wn', ":<C-u>'<,'>GpWhisperNew<cr>", desc = 'Whisper New' },
|
|
{ '<C-g>wp', ":<C-u>'<,'>GpWhisperPopup<cr>", desc = 'Whisper Popup' },
|
|
{
|
|
'<C-g>wr',
|
|
":<C-u>'<,'>GpWhisperRewrite<cr>",
|
|
desc = 'Whisper Rewrite',
|
|
},
|
|
{ '<C-g>wt', ":<C-u>'<,'>GpWhisperTabnew<cr>", desc = 'Whisper Tabnew' },
|
|
{ '<C-g>wv', ":<C-u>'<,'>GpWhisperVnew<cr>", desc = 'Whisper Vnew' },
|
|
{ '<C-g>ww', ":<C-u>'<,'>GpWhisper<cr>", desc = 'Whisper' },
|
|
{ '<C-g>x', ":<C-u>'<,'>GpContext<cr>", desc = 'Visual GpContext' },
|
|
},
|
|
|
|
-- NORMAL mode mappings
|
|
{
|
|
mode = { 'n' },
|
|
nowait = true,
|
|
remap = false,
|
|
{ '<C-g><C-t>', '<cmd>GpChatNew tabnew<cr>', desc = 'New Chat tabnew' },
|
|
{ '<C-g><C-v>', '<cmd>GpChatNew vsplit<cr>', desc = 'New Chat vsplit' },
|
|
{ '<C-g><C-x>', '<cmd>GpChatNew split<cr>', desc = 'New Chat split' },
|
|
{ '<C-g>a', '<cmd>GpAppend<cr>', desc = 'Append (after)' },
|
|
{ '<C-g>b', '<cmd>GpPrepend<cr>', desc = 'Prepend (before)' },
|
|
{ '<C-g>c', '<cmd>GpChatNew<cr>', desc = 'New Chat' },
|
|
{ '<C-g>f', '<cmd>GpChatFinder<cr>', desc = 'Chat Finder' },
|
|
{ '<C-g>g', group = 'generate into new ..' },
|
|
{ '<C-g>ge', '<cmd>GpEnew<cr>', desc = 'GpEnew' },
|
|
{ '<C-g>gn', '<cmd>GpNew<cr>', desc = 'GpNew' },
|
|
{ '<C-g>gp', '<cmd>GpPopup<cr>', desc = 'Popup' },
|
|
{ '<C-g>gt', '<cmd>GpTabnew<cr>', desc = 'GpTabnew' },
|
|
{ '<C-g>gv', '<cmd>GpVnew<cr>', desc = 'GpVnew' },
|
|
{ '<C-g>n', '<cmd>GpNextAgent<cr>', desc = 'Next Agent' },
|
|
{ '<C-g>r', '<cmd>GpRewrite<cr>', desc = 'Inline Rewrite' },
|
|
{ '<C-g>s', '<cmd>GpStop<cr>', desc = 'GpStop' },
|
|
{ '<C-g>t', '<cmd>GpChatToggle<cr>', desc = 'Toggle Chat' },
|
|
{ '<C-g>w', group = 'Whisper' },
|
|
{
|
|
'<C-g>wa',
|
|
'<cmd>GpWhisperAppend<cr>',
|
|
desc = 'Whisper Append (after)',
|
|
},
|
|
{
|
|
'<C-g>wb',
|
|
'<cmd>GpWhisperPrepend<cr>',
|
|
desc = 'Whisper Prepend (before)',
|
|
},
|
|
{ '<C-g>we', '<cmd>GpWhisperEnew<cr>', desc = 'Whisper Enew' },
|
|
{ '<C-g>wn', '<cmd>GpWhisperNew<cr>', desc = 'Whisper New' },
|
|
{ '<C-g>wp', '<cmd>GpWhisperPopup<cr>', desc = 'Whisper Popup' },
|
|
{
|
|
'<C-g>wr',
|
|
'<cmd>GpWhisperRewrite<cr>',
|
|
desc = 'Whisper Inline Rewrite',
|
|
},
|
|
{ '<C-g>wt', '<cmd>GpWhisperTabnew<cr>', desc = 'Whisper Tabnew' },
|
|
{ '<C-g>wv', '<cmd>GpWhisperVnew<cr>', desc = 'Whisper Vnew' },
|
|
{ '<C-g>ww', '<cmd>GpWhisper<cr>', desc = 'Whisper' },
|
|
{ '<C-g>x', '<cmd>GpContext<cr>', desc = 'Toggle GpContext' },
|
|
},
|
|
|
|
-- INSERT mode mappings
|
|
{
|
|
mode = { 'i' },
|
|
nowait = true,
|
|
remap = false,
|
|
{ '<C-g><C-t>', '<cmd>GpChatNew tabnew<cr>', desc = 'New Chat tabnew' },
|
|
{ '<C-g><C-v>', '<cmd>GpChatNew vsplit<cr>', desc = 'New Chat vsplit' },
|
|
{ '<C-g><C-x>', '<cmd>GpChatNew split<cr>', desc = 'New Chat split' },
|
|
{ '<C-g>a', '<cmd>GpAppend<cr>', desc = 'Append (after)' },
|
|
{ '<C-g>b', '<cmd>GpPrepend<cr>', desc = 'Prepend (before)' },
|
|
{ '<C-g>c', '<cmd>GpChatNew<cr>', desc = 'New Chat' },
|
|
{ '<C-g>f', '<cmd>GpChatFinder<cr>', desc = 'Chat Finder' },
|
|
{ '<C-g>g', group = 'generate into new ..' },
|
|
{ '<C-g>ge', '<cmd>GpEnew<cr>', desc = 'GpEnew' },
|
|
{ '<C-g>gn', '<cmd>GpNew<cr>', desc = 'GpNew' },
|
|
{ '<C-g>gp', '<cmd>GpPopup<cr>', desc = 'Popup' },
|
|
{ '<C-g>gt', '<cmd>GpTabnew<cr>', desc = 'GpTabnew' },
|
|
{ '<C-g>gv', '<cmd>GpVnew<cr>', desc = 'GpVnew' },
|
|
{ '<C-g>n', '<cmd>GpNextAgent<cr>', desc = 'Next Agent' },
|
|
{ '<C-g>r', '<cmd>GpRewrite<cr>', desc = 'Inline Rewrite' },
|
|
{ '<C-g>s', '<cmd>GpStop<cr>', desc = 'GpStop' },
|
|
{ '<C-g>t', '<cmd>GpChatToggle<cr>', desc = 'Toggle Chat' },
|
|
{ '<C-g>w', group = 'Whisper' },
|
|
{
|
|
'<C-g>wa',
|
|
'<cmd>GpWhisperAppend<cr>',
|
|
desc = 'Whisper Append (after)',
|
|
},
|
|
{
|
|
'<C-g>wb',
|
|
'<cmd>GpWhisperPrepend<cr>',
|
|
desc = 'Whisper Prepend (before)',
|
|
},
|
|
{ '<C-g>we', '<cmd>GpWhisperEnew<cr>', desc = 'Whisper Enew' },
|
|
{ '<C-g>wn', '<cmd>GpWhisperNew<cr>', desc = 'Whisper New' },
|
|
{ '<C-g>wp', '<cmd>GpWhisperPopup<cr>', desc = 'Whisper Popup' },
|
|
{
|
|
'<C-g>wr',
|
|
'<cmd>GpWhisperRewrite<cr>',
|
|
desc = 'Whisper Inline Rewrite',
|
|
},
|
|
{ '<C-g>wt', '<cmd>GpWhisperTabnew<cr>', desc = 'Whisper Tabnew' },
|
|
{ '<C-g>wv', '<cmd>GpWhisperVnew<cr>', desc = 'Whisper Vnew' },
|
|
{ '<C-g>ww', '<cmd>GpWhisper<cr>', desc = 'Whisper' },
|
|
{ '<C-g>x', '<cmd>GpContext<cr>', desc = 'Toggle GpContext' },
|
|
},
|
|
},
|
|
}
|
|
|
|
M.group = {
|
|
avante = {
|
|
{ -- Avante
|
|
lhs = '<leader>a',
|
|
icon = { icon = '', color = 'red' },
|
|
group = 'Avante',
|
|
},
|
|
},
|
|
chatgpt = { -- ChatGPT
|
|
lhs = '<leader>cx',
|
|
group = 'ChatGPT',
|
|
icon = { icon = '', color = 'blue' },
|
|
},
|
|
gist = { -- Gists menu
|
|
lhs = '<leader>gn',
|
|
group = 'Gists',
|
|
icon = { icon = '', color = 'orange' },
|
|
},
|
|
minimap = { -- MiniMap menu
|
|
lhs = '<leader>n',
|
|
group = 'MiniMap',
|
|
icon = { icon = '', color = 'green' },
|
|
},
|
|
nvimup = {
|
|
{ -- Neovim Updater menu
|
|
lhs = '<leader>qu',
|
|
group = 'Neovim Updater',
|
|
icon = { icon = '', color = 'red' },
|
|
},
|
|
{ -- Neovim Updater Commits menu
|
|
lhs = '<leader>quc',
|
|
group = 'New Commits',
|
|
icon = { icon = '', color = 'green' },
|
|
},
|
|
{ -- MultiCursor
|
|
lhs = '<leader>m',
|
|
group = 'MultiCursor',
|
|
icon = { icon = '', color = 'green' },
|
|
},
|
|
},
|
|
}
|
|
|
|
M.groups = {
|
|
{ -- Lazy menu
|
|
lhs = '<leader>l',
|
|
group = 'Lazy',
|
|
icon = { icon = '', color = 'red' },
|
|
},
|
|
}
|
|
|
|
M.help = {
|
|
{ -- Lookup word
|
|
lhs = '<leader>h',
|
|
rhs = "<cmd>execute 'help ' . expand('<cword>')<cr>",
|
|
desc = 'Lookup word',
|
|
},
|
|
{ -- Lookup selection
|
|
lhs = '<leader>h',
|
|
rhs = function()
|
|
require('data.func').help_lookup_visual()
|
|
end,
|
|
desc = 'Lookup selection',
|
|
mode = 'v',
|
|
},
|
|
}
|
|
|
|
M.multicursor = {
|
|
{
|
|
'<leader><up>',
|
|
function()
|
|
require('multicursor-nvim').addCursor('k')
|
|
end,
|
|
mode = { 'n', 'v' },
|
|
desc = 'Add Cursor Above',
|
|
},
|
|
{
|
|
'<leader><down>',
|
|
function()
|
|
require('multicursor-nvim').addCursor('j')
|
|
end,
|
|
mode = { 'n', 'v' },
|
|
desc = 'Add Cursor Below',
|
|
},
|
|
{
|
|
'<leader><c-n>',
|
|
function()
|
|
require('multicursor-nvim').addCursor('*')
|
|
end,
|
|
desc = 'Add Cursor and Skip Word',
|
|
mode = { 'n', 'v' },
|
|
},
|
|
{
|
|
'<leader><c-s>',
|
|
function()
|
|
require('multicursor-nvim').skipCursor('*')
|
|
end,
|
|
desc = 'Skip Word',
|
|
mode = { 'n', 'v' },
|
|
},
|
|
{
|
|
'<leader><left>',
|
|
function()
|
|
require('multicursor-nvim').nextCursor()
|
|
end,
|
|
desc = 'Next Cursor',
|
|
mode = { 'n', 'v' },
|
|
},
|
|
{
|
|
'<leader><right>',
|
|
function()
|
|
require('multicursor-nvim').prevCursor()
|
|
end,
|
|
desc = 'Previous Cursor',
|
|
mode = { 'n', 'v' },
|
|
},
|
|
{
|
|
'<leader>mx',
|
|
function()
|
|
require('multicursor-nvim').deleteCursor()
|
|
end,
|
|
desc = 'Delete Cursor',
|
|
mode = { 'n', 'v' },
|
|
},
|
|
{
|
|
'<c-leftmouse>',
|
|
function()
|
|
require('multicursor-nvim').handleMouse()
|
|
end,
|
|
desc = 'Add/Remove Cursor',
|
|
mode = 'n',
|
|
},
|
|
{
|
|
'<leader><c-q>',
|
|
function()
|
|
if require('multicursor-nvim').cursorsEnabled() then
|
|
require('multicursor-nvim').disableCursors() -- Stop other cursors from moving, allowing main cursor repositioning.
|
|
else
|
|
require('multicursor-nvim').addCursor() -- Add a cursor if none are enabled.
|
|
end
|
|
end,
|
|
desc = 'Add Cursor',
|
|
mode = { 'n', 'v' },
|
|
},
|
|
{
|
|
'<esc>',
|
|
function()
|
|
if not require('multicursor-nvim').cursorsEnabled() then
|
|
require('multicursor-nvim').enableCursors() -- Enable cursors.
|
|
elseif require('multicursor-nvim').hasCursors() then
|
|
require('multicursor-nvim').clearCursors() -- Clear all cursors.
|
|
else
|
|
-- Default <esc> handler can be defined here if needed.
|
|
end
|
|
end,
|
|
desc = 'Escape Handler',
|
|
mode = 'n',
|
|
},
|
|
{
|
|
'<leader>ma',
|
|
function()
|
|
require('multicursor-nvim').alignCursors()
|
|
end,
|
|
desc = 'Align Cursors',
|
|
mode = 'n',
|
|
},
|
|
{
|
|
'<leader>mS',
|
|
function()
|
|
require('multicursor-nvim').splitCursors()
|
|
end,
|
|
desc = 'Split Cursors',
|
|
mode = 'v',
|
|
},
|
|
{
|
|
'<leader>mI',
|
|
function()
|
|
require('multicursor-nvim').insertVisual()
|
|
end,
|
|
desc = 'Insert Visual',
|
|
mode = 'v',
|
|
},
|
|
{
|
|
'<leader>mA',
|
|
function()
|
|
require('multicursor-nvim').appendVisual()
|
|
end,
|
|
desc = 'Append Visual',
|
|
mode = 'v',
|
|
},
|
|
{
|
|
'<leader>mM',
|
|
function()
|
|
require('multicursor-nvim').matchCursors()
|
|
end,
|
|
desc = 'Match Cursors',
|
|
mode = 'v',
|
|
},
|
|
{
|
|
'<leader>mt',
|
|
function()
|
|
require('multicursor-nvim').transposeCursors(1)
|
|
end,
|
|
desc = 'Transpose Cursors ',
|
|
mode = 'v',
|
|
},
|
|
{
|
|
'<leader>mT',
|
|
function()
|
|
require('multicursor-nvim').transposeCursors(-1)
|
|
end,
|
|
desc = 'Transpose Cursors ',
|
|
mode = 'v',
|
|
},
|
|
}
|
|
|
|
M.nvimup = {
|
|
{ -- Update Neovim from source
|
|
'<Leader>quU',
|
|
':UpdateNeovim<CR>',
|
|
desc = 'Update Neovim',
|
|
},
|
|
{ -- Update Neovim from source in debug mode
|
|
'<Leader>quD',
|
|
function()
|
|
require('nvim_updater').update_neovim({ build_type = 'Debug' })
|
|
end,
|
|
desc = 'Debug Build Neovim',
|
|
},
|
|
{ -- Update Neovim from source in release mode
|
|
'<Leader>quR',
|
|
function()
|
|
require('nvim_updater').update_neovim({ build_type = 'Release' })
|
|
end,
|
|
desc = 'Release Build Neovim',
|
|
},
|
|
{ -- Remove Neovim Source directory
|
|
'<Leader>quX',
|
|
function()
|
|
require('nvim_updater').remove_source_dir()
|
|
end,
|
|
desc = 'Remove Neovim Source',
|
|
},
|
|
{ -- Show new nvim source commits in Telescope
|
|
'<Leader>quct',
|
|
function()
|
|
require('nvim_updater').show_new_commits_in_telescope()
|
|
end,
|
|
desc = 'Show New Commits in Telescope',
|
|
},
|
|
{ -- Show new nvim source commits in DiffView
|
|
'<Leader>qucd',
|
|
function()
|
|
require('nvim_updater').show_new_commits_in_diffview()
|
|
end,
|
|
desc = 'Show New Commits in DiffView',
|
|
},
|
|
{ -- Show new nvim source commits in terminal
|
|
'<Leader>qucc',
|
|
function()
|
|
require('nvim_updater').show_new_commits()
|
|
end,
|
|
desc = 'Show New Commits in terminal',
|
|
},
|
|
}
|
|
|
|
M.gx = {
|
|
{ -- Open URL/Link
|
|
'gx',
|
|
'<cmd>Browse<cr>',
|
|
mode = { 'n', 'x' },
|
|
desc = 'Open URL/Link',
|
|
},
|
|
}
|
|
|
|
M.indentor = {
|
|
{ -- Indentor
|
|
'<C-i>',
|
|
function()
|
|
require('utils.indentor').insert_previous_line_indentation()
|
|
end,
|
|
'Insert Previous Line Indentation',
|
|
{ 'i', 'n' },
|
|
},
|
|
}
|
|
|
|
M.lazygit = {
|
|
{ -- LazyGit
|
|
'<leader>lg',
|
|
function()
|
|
require('data.func').open_lazygit_popup()
|
|
end,
|
|
desc = 'LazyGit',
|
|
},
|
|
}
|
|
|
|
---@function Helper function to toggle mini.files explorer
|
|
---@param ... any Optional arguments to pass to mini.files.open
|
|
local minifiles_toggle = function(...)
|
|
if not require('mini.files').close() then
|
|
require('mini.files').open(...)
|
|
end
|
|
end
|
|
|
|
--- MiniFiles keymaps
|
|
M.minifiles = {
|
|
{
|
|
'<leader>fm',
|
|
function()
|
|
minifiles_toggle(vim.api.nvim_buf_get_name(0), true)
|
|
end,
|
|
desc = 'Open mini.files',
|
|
},
|
|
{
|
|
'<leader>fM',
|
|
function()
|
|
minifiles_toggle(vim.uv.cwd(), true)
|
|
end,
|
|
desc = 'Open mini.files (CWD)',
|
|
},
|
|
{ -- Mini.files
|
|
'<leader>\\',
|
|
function()
|
|
minifiles_toggle(vim.api.nvim_buf_get_name(0), true)
|
|
end,
|
|
desc = 'Open mini.files',
|
|
},
|
|
{ -- Mini.files
|
|
'<leader>sf',
|
|
function()
|
|
minifiles_toggle(vim.api.nvim_buf_get_name(0), true)
|
|
end,
|
|
desc = 'Open mini.files',
|
|
},
|
|
}
|
|
|
|
--- Misc keymaps
|
|
M.misc = {
|
|
{ -- jk in insert and visual to escape
|
|
'jk',
|
|
'<esc>',
|
|
mode = { 'i', 'v' },
|
|
desc = 'Escape',
|
|
},
|
|
{ -- Clear search highlight
|
|
'<leader>s<Esc>',
|
|
'<cmd>noh<cr><esc>',
|
|
desc = 'Clear search',
|
|
},
|
|
{ -- Modeline
|
|
'<leader>cM',
|
|
function()
|
|
require('data.func').append_modeline()
|
|
end,
|
|
desc = 'Add Modeline',
|
|
},
|
|
{ -- Yank line (without whitespace)
|
|
lhs = 'yo',
|
|
rhs = function()
|
|
rootiest.yank_line()
|
|
end,
|
|
desc = 'Yank Line-text',
|
|
},
|
|
{ -- Yank and trim selection
|
|
lhs = '<leader>y',
|
|
rhs = function()
|
|
require('data.func').trim_yank()
|
|
end,
|
|
desc = 'Yank and trim selection',
|
|
},
|
|
{ -- Hardmode
|
|
lhs = '<leader>uH',
|
|
rhs = function()
|
|
rootiest.toggle_hardmode()
|
|
end,
|
|
desc = 'Toggle Hardmode',
|
|
},
|
|
{ -- Reload config
|
|
lhs = '<leader>qr',
|
|
rhs = function()
|
|
require('data.func').reload_config()
|
|
end,
|
|
desc = 'Reload Config',
|
|
},
|
|
{ -- Yank buffer
|
|
lhs = '<leader>Y',
|
|
rhs = '<cmd>%y<cr>',
|
|
desc = 'Yank buffer contents',
|
|
},
|
|
{ -- Select all
|
|
lhs = '<C-a>',
|
|
rhs = '<cmd>norm ggVG<cr>',
|
|
desc = 'Select all',
|
|
},
|
|
{ -- Explorer
|
|
lhs = '<C-S-\\>',
|
|
rhs = '<cmd>lua Snacks.picker.explorer()<cr>',
|
|
desc = 'Toggle Snacks Explorer',
|
|
},
|
|
{ -- Explorer
|
|
lhs = '<leader>F',
|
|
rhs = function()
|
|
if require('data.cond').neotree() then
|
|
vim.cmd('Neotree reveal toggle')
|
|
else
|
|
Pick('explorer')
|
|
end
|
|
end,
|
|
desc = 'File Explorer',
|
|
},
|
|
{ -- Split Window Vertically
|
|
lhs = '\\',
|
|
rhs = '<C-W>v',
|
|
desc = 'Split Window Right',
|
|
},
|
|
{ -- Split Window Vertically
|
|
lhs = '|',
|
|
rhs = '<C-W>v',
|
|
desc = 'Split Window Right',
|
|
},
|
|
{ -- Smart Pick Files
|
|
lhs = '<leader><leader>',
|
|
rhs = function()
|
|
Pick('smart')
|
|
end,
|
|
desc = 'Find Files',
|
|
},
|
|
{ -- Grep files
|
|
lhs = '<leader>/',
|
|
rhs = function()
|
|
Pick({ cmd = 'grep' })
|
|
end,
|
|
desc = 'Grep Files',
|
|
},
|
|
{ -- Exit Neovim
|
|
lhs = '<leader>Q',
|
|
rhs = "<cmd>lua require('data').func.exit()<cr>",
|
|
desc = 'Exit Neovim',
|
|
},
|
|
{ -- LazyVim
|
|
lhs = '<leader>lv',
|
|
rhs = '<cmd>Lazy<cr>',
|
|
desc = 'LazyVim',
|
|
},
|
|
{ -- LazyExtras
|
|
lhs = '<leader>lx',
|
|
rhs = '<cmd>LazyExtras<cr>',
|
|
desc = 'LazyExtras',
|
|
},
|
|
{ -- De-map Ctrl+Shift+LeftClick to avoid conflicts with WezTerm
|
|
lhs = '<C-S-LeftMouse>',
|
|
rhs = '<Nop>',
|
|
desc = 'Prevent conflict with WezTerm hyperlinks',
|
|
mode = 'n',
|
|
hidden = true,
|
|
},
|
|
{ -- Visual mode: Move selected block of text up
|
|
lhs = 'K',
|
|
rhs = function()
|
|
local count = vim.v.count1
|
|
require('data.func').move_visual(true, count)
|
|
end,
|
|
desc = 'Move block of text up',
|
|
mode = 'v',
|
|
},
|
|
{ -- Visual mode: Move selected block of text down
|
|
lhs = 'J',
|
|
rhs = function()
|
|
local count = vim.v.count1
|
|
require('data.func').move_visual(false, count)
|
|
end,
|
|
desc = 'Move block of text down',
|
|
mode = 'v',
|
|
},
|
|
{ -- Test Prompt: Enter your name
|
|
lhs = '<leader>qP',
|
|
rhs = function()
|
|
require('data.func').InputPrompt('Enter your name: ', function(input)
|
|
if input then
|
|
-- trim whitespace from end of input
|
|
input = input:gsub('%s+$', '')
|
|
print('👋😎 Hello ' .. input .. '!')
|
|
else
|
|
print('Input was canceled')
|
|
end
|
|
end)
|
|
end,
|
|
desc = 'Test Prompt',
|
|
},
|
|
{ -- Paste over text with overwrite
|
|
lhs = '<leader>cp',
|
|
rhs = function()
|
|
require('data.func').paste_overwrite()
|
|
end,
|
|
desc = 'Paste overwrite',
|
|
mode = 'n',
|
|
},
|
|
{ -- Dump buffer contents to a table in register
|
|
lhs = '<leader>bY',
|
|
rhs = function()
|
|
require('data.func').dump_buffer_to_table('+')
|
|
end,
|
|
desc = 'Yank buffer as table',
|
|
mode = 'n',
|
|
},
|
|
{ -- Yank buffer
|
|
lhs = '<leader>by',
|
|
rhs = '<cmd>%y<cr>',
|
|
desc = 'Yank buffer',
|
|
mode = 'n',
|
|
},
|
|
}
|
|
|
|
M.nekifoch = {
|
|
{ -- List Fonts
|
|
'<leader>u,l',
|
|
'<cmd>Nekifoch list<cr>',
|
|
desc = 'Fonts list',
|
|
},
|
|
{ -- Check Font
|
|
'<leader>u,c',
|
|
'<cmd>Nekifoch check<cr>',
|
|
desc = 'Check current font settings',
|
|
},
|
|
{ -- Set Font Family
|
|
'<leader>u,f',
|
|
function()
|
|
require('nekifoch.nui_set_font')()
|
|
end,
|
|
desc = 'Set font family',
|
|
},
|
|
{ -- Set Font Size
|
|
'<leader>u,s',
|
|
function()
|
|
require('nekifoch.nui_set_size')()
|
|
end,
|
|
desc = 'Set font size',
|
|
},
|
|
}
|
|
|
|
M.precog = {
|
|
{ -- Toggle Precognition
|
|
'zk',
|
|
function()
|
|
require('config.rootiest').toggle_precognition()
|
|
end,
|
|
desc = 'Toggle Precognition',
|
|
},
|
|
}
|
|
|
|
M.qalc = {
|
|
-- { -- Open Qalc
|
|
-- "<leader>qc",
|
|
-- "<cmd>Qalc<cr>",
|
|
-- desc = "Qalc",
|
|
-- },
|
|
{ -- Set a key mapping to run :Qalc and enter insert mode
|
|
'<leader>qc',
|
|
function()
|
|
-- Run the Qalc command
|
|
vim.cmd('Qalc')
|
|
-- Enter insert mode directly
|
|
vim.cmd('startinsert')
|
|
end,
|
|
desc = 'Qalc',
|
|
},
|
|
}
|
|
|
|
M.recorder = {
|
|
{ 'q', desc = ' Start Recording' },
|
|
{ 'Q', desc = ' Play Recording' },
|
|
}
|
|
|
|
M.ripsub = {
|
|
{ -- Rip Substitute
|
|
'<leader>fs',
|
|
function()
|
|
require('rip-substitute').sub()
|
|
end,
|
|
mode = { 'n', 'x' },
|
|
desc = 'Rip Substitute',
|
|
},
|
|
}
|
|
|
|
M.smearcursor = function()
|
|
require('snacks.toggle')
|
|
.new({
|
|
id = 'smearcursor',
|
|
name = 'Smear-Cursor',
|
|
get = function()
|
|
return require('smear_cursor').enabled
|
|
end,
|
|
set = function()
|
|
require('smear_cursor').toggle()
|
|
end,
|
|
})
|
|
:map('<leader>uW')
|
|
end
|
|
|
|
M.snacksterm = {
|
|
-- { -- Toggle Terminal
|
|
-- lhs = '<C-/>',
|
|
-- rhs = function()
|
|
-- require('snacks.terminal').toggle()
|
|
-- end,
|
|
-- desc = 'Toggle Terminal',
|
|
-- },
|
|
}
|
|
|
|
M.splitjoin = {
|
|
toggle = 'gJ',
|
|
}
|
|
|
|
M.splits = {
|
|
resize = {
|
|
{ -- Resize split leftwards
|
|
'<A-h>',
|
|
function()
|
|
require('smart-splits').resize_left()
|
|
end,
|
|
desc = 'Resize split left',
|
|
},
|
|
{ -- Resize split downwards
|
|
'<A-j>',
|
|
function()
|
|
require('smart-splits').resize_down()
|
|
end,
|
|
desc = 'Resize split down',
|
|
},
|
|
{ -- Resize split upwards
|
|
'<A-k>',
|
|
function()
|
|
require('smart-splits').resize_up()
|
|
end,
|
|
desc = 'Resize split up',
|
|
},
|
|
{ -- Resize split rightwards
|
|
'<A-l>',
|
|
function()
|
|
require('smart-splits').resize_right()
|
|
end,
|
|
desc = 'Resize split right',
|
|
},
|
|
{ -- Start interactive split resizing
|
|
'<A-r>',
|
|
function()
|
|
require('smart-splits').start_resize_mode()
|
|
end,
|
|
desc = 'Resize split interactively',
|
|
},
|
|
},
|
|
move = {
|
|
{ -- Move cursor to split left
|
|
'<C-S-h>',
|
|
function()
|
|
require('smart-splits').move_cursor_left()
|
|
end,
|
|
desc = 'Move to split left',
|
|
},
|
|
{ -- Move cursor to split below
|
|
'<C-S-j>',
|
|
function()
|
|
require('smart-splits').move_cursor_down()
|
|
end,
|
|
desc = 'Move to split below',
|
|
},
|
|
{ -- Move cursor to split above
|
|
'<C-S-k>',
|
|
function()
|
|
require('smart-splits').move_cursor_up()
|
|
end,
|
|
desc = 'Move to split above',
|
|
},
|
|
{ -- Move cursor to split right
|
|
'<C-S-l>',
|
|
function()
|
|
require('smart-splits').move_cursor_right()
|
|
end,
|
|
desc = 'Move to split right',
|
|
},
|
|
{ -- Move cursor to previous split
|
|
'<C-\\>',
|
|
function()
|
|
require('smart-splits').move_cursor_previous()
|
|
end,
|
|
desc = 'Move to previous split',
|
|
},
|
|
},
|
|
swap = {
|
|
{ -- Swap buffer with the one to the left
|
|
'<A-S-h>',
|
|
function()
|
|
require('smart-splits').swap_buf_left()
|
|
end,
|
|
desc = 'Swap buffer left',
|
|
},
|
|
{ -- Swap buffer with the one below
|
|
'<A-S-j>',
|
|
function()
|
|
require('smart-splits').swap_buf_down()
|
|
end,
|
|
desc = 'Swap buffer down',
|
|
},
|
|
{ -- Swap buffer with the one above
|
|
'<A-S-k>',
|
|
function()
|
|
require('smart-splits').swap_buf_up()
|
|
end,
|
|
desc = 'Swap buffer up',
|
|
},
|
|
{ -- Swap buffer with the one to the right
|
|
'<A-S-l>',
|
|
function()
|
|
require('smart-splits').swap_buf_right()
|
|
end,
|
|
desc = 'Swap buffer right',
|
|
},
|
|
},
|
|
}
|
|
|
|
M.substitute = {
|
|
{ -- Substitute operator in normal mode
|
|
'x',
|
|
function()
|
|
require('substitute').operator()
|
|
end,
|
|
desc = 'Substitute operator',
|
|
},
|
|
{ -- Substitute line in normal mode
|
|
'xx',
|
|
function()
|
|
require('substitute').line()
|
|
end,
|
|
desc = 'Substitute line',
|
|
},
|
|
{ -- Substitute end of line in normal mode
|
|
'X',
|
|
function()
|
|
require('substitute').eol()
|
|
end,
|
|
desc = 'Substitute end of line',
|
|
},
|
|
{ -- Substitute visual selection in visual mode
|
|
'x',
|
|
function()
|
|
require('substitute').visual()
|
|
end,
|
|
desc = 'Substitute visual selection',
|
|
mode = 'x',
|
|
},
|
|
{ -- Substitute visual selection in visual mode
|
|
'<leader>m',
|
|
function()
|
|
require('substitute').visual()
|
|
end,
|
|
desc = 'Substitute',
|
|
mode = 'x',
|
|
},
|
|
}
|
|
|
|
M.overrides = {
|
|
{ -- De-map 's' to avoid conflicts with mini.surround
|
|
lhs = 's',
|
|
rhs = '<Nop>', -- This disables the keymap
|
|
desc = 'Surround',
|
|
mode = { 'n', 'x' },
|
|
},
|
|
{ -- Stop snippet when leaving insert mode
|
|
lhs = '<Esc>',
|
|
rhs = function()
|
|
vim.snippet.stop()
|
|
return '<Esc>'
|
|
end,
|
|
},
|
|
}
|
|
|
|
M.telescope = {
|
|
cmdline = {
|
|
{
|
|
':',
|
|
function()
|
|
require('telescope').extensions.cmdline.cmdline()
|
|
end,
|
|
desc = 'Cmdline',
|
|
},
|
|
},
|
|
lazy = {
|
|
{
|
|
'<leader>fz',
|
|
function()
|
|
require('telescope').extensions.lazy.lazy()
|
|
end,
|
|
desc = 'Lazy Picker',
|
|
},
|
|
},
|
|
symbols = {
|
|
{ -- Telescope Symbols
|
|
'<leader>f.',
|
|
function()
|
|
require('telescope.builtin').symbols({
|
|
sources = {
|
|
'nerd',
|
|
'emoji',
|
|
'kaomoji',
|
|
'gitmoji',
|
|
'math',
|
|
'latex',
|
|
'julia',
|
|
},
|
|
})
|
|
end,
|
|
desc = 'Pick Icons',
|
|
},
|
|
{ -- Pick Icon in insert mode
|
|
'<C-.>',
|
|
function()
|
|
require('telescope.builtin').symbols({
|
|
sources = {
|
|
'nerd',
|
|
'emoji',
|
|
'kaomoji',
|
|
'gitmoji',
|
|
'math',
|
|
'latex',
|
|
'julia',
|
|
},
|
|
})
|
|
end,
|
|
desc = 'Pick Icon',
|
|
mode = 'i',
|
|
},
|
|
},
|
|
toggleterm = {
|
|
{ -- Pick ToggleTerms
|
|
'<leader>ft',
|
|
function()
|
|
require('toggleterm-manager').open({})
|
|
end,
|
|
desc = 'Pick Terminals',
|
|
mode = 'n',
|
|
},
|
|
},
|
|
filebrowser = {
|
|
{
|
|
'<leader>e',
|
|
function()
|
|
require('telescope').extensions.file_browser.file_browser()
|
|
end,
|
|
desc = 'Telescope File Browser',
|
|
mode = 'n',
|
|
},
|
|
{
|
|
'<leader>sF',
|
|
function()
|
|
require('telescope').extensions.file_browser.file_browser()
|
|
end,
|
|
desc = 'Telescope File Browser',
|
|
mode = 'n',
|
|
},
|
|
},
|
|
}
|
|
|
|
M.toggleterm = {
|
|
{ -- Toggle Terminal
|
|
'<c-/>',
|
|
'<cmd>ToggleTerm<cr>',
|
|
desc = 'Toggle Terminal',
|
|
mode = 'n',
|
|
},
|
|
}
|
|
|
|
M.transparent = {
|
|
{
|
|
'<leader>wt',
|
|
function()
|
|
require('transparent').toggle()
|
|
end,
|
|
desc = 'Toggle Transparency',
|
|
},
|
|
}
|
|
|
|
M.yanky = {
|
|
{ -- Yanky put after
|
|
'P',
|
|
'<Plug>(YankyPutAfter)',
|
|
desc = 'Yanky put after',
|
|
mode = { 'n', 'x' },
|
|
},
|
|
{ -- Yanky put before
|
|
'p',
|
|
'<Plug>(YankyPutBefore)',
|
|
desc = 'Yanky put before',
|
|
mode = { 'n', 'x' },
|
|
},
|
|
{ -- Yanky gput after
|
|
'gP',
|
|
'<Plug>(YankyGPutAfter)',
|
|
desc = 'Yanky gput after',
|
|
mode = { 'n', 'x' },
|
|
},
|
|
{ -- Yanky gput before
|
|
'gp',
|
|
'<Plug>(YankyGPutBefore)',
|
|
desc = 'Yanky gput before',
|
|
mode = { 'n', 'x' },
|
|
},
|
|
{ -- Yanky previous entry
|
|
'<c-p>',
|
|
'<Plug>(YankyPreviousEntry)',
|
|
desc = 'Yanky previous entry',
|
|
mode = 'n',
|
|
},
|
|
{ -- Yanky next entry
|
|
'<c-n>',
|
|
'<Plug>(YankyNextEntry)',
|
|
desc = 'Yanky next entry',
|
|
mode = 'n',
|
|
},
|
|
{ -- Put indent after linewise
|
|
']p',
|
|
'<Plug>(YankyPutIndentAfterLinewise)',
|
|
desc = 'Put indent after linewise',
|
|
},
|
|
{ -- Put indent before linewise
|
|
'[p',
|
|
'<Plug>(YankyPutIndentBeforeLinewise',
|
|
desc = 'Put indent before linewise',
|
|
},
|
|
{ -- Put indent after linewise (uppercase)
|
|
']P',
|
|
'<Plug>(YankyPutIndentAfterLinewise)',
|
|
desc = 'Put indent after linewise (uppercase)',
|
|
},
|
|
{ -- Put indent before linewise (uppercase)
|
|
'[P',
|
|
'<Plug>(YankyPutIndentBeforeLinewise)',
|
|
desc = 'Put indent before linewise (uppercase)',
|
|
},
|
|
{ -- Put indent after shift right
|
|
'>p',
|
|
'<Plug>(YankyPutIndentAfterShiftRight)',
|
|
desc = 'Put indent after shift right',
|
|
},
|
|
{ -- Put indent after shift left
|
|
'<p',
|
|
'<Plug>(YankyPutIndentAfterShiftLeft)',
|
|
desc = 'Put indent after shift left',
|
|
},
|
|
{ -- Put indent before shift right
|
|
'>P',
|
|
'<Plug>(YankyPutIndentBeforeShiftRight)',
|
|
desc = 'Put indent before shift right',
|
|
},
|
|
{ -- Put indent before shift left
|
|
'<P',
|
|
'<Plug>(YankyPutIndentBeforeShiftLeft)',
|
|
desc = 'Put indent before shift left',
|
|
},
|
|
{ -- Put after filter
|
|
'=p',
|
|
'<Plug>(YankyPutAfterFilter)',
|
|
desc = 'Put after filter',
|
|
},
|
|
{ -- Put before filter
|
|
'=P',
|
|
'<Plug>(YankyPutBeforeFilter)',
|
|
desc = 'Put before filter',
|
|
},
|
|
{ -- Last put in operator-pending mode
|
|
'lp', -- Left-hand side (key combination)
|
|
function()
|
|
require('yanky.textobj').last_put()
|
|
end,
|
|
desc = 'Last put',
|
|
mode = { 'x', 'o' },
|
|
},
|
|
{ -- Open Yank History
|
|
'<leader>p', -- Left-hand side (key combination)
|
|
function()
|
|
if pcall(require, 'telescope') then
|
|
require('telescope').extensions.yank_history.yank_history()
|
|
else
|
|
vim.cmd('YankyRingHistory')
|
|
end
|
|
end,
|
|
desc = 'Yank History',
|
|
},
|
|
}
|
|
|
|
M.zen = {
|
|
{ -- Toggle ZenMode
|
|
'<leader>z',
|
|
function()
|
|
require('zen-mode').toggle()
|
|
end,
|
|
desc = 'Toggle ZenMode',
|
|
},
|
|
}
|
|
|
|
return M
|