Last active
April 25, 2024 09:14
-
-
Save logotip4ik/5e7796a48ef104e5cb2452647f67d689 to your computer and use it in GitHub Desktop.
my nvim config
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim" | |
if not vim.loop.fs_stat(lazypath) then | |
vim.fn.system({ | |
"git", | |
"clone", | |
"--filter=blob:none", | |
"https://github.com/folke/lazy.nvim.git", | |
"--branch=stable", -- latest stable release | |
lazypath, | |
}) | |
end | |
vim.opt.rtp:prepend(lazypath) | |
vim.opt.compatible = false | |
vim.opt.backspace = 'indent,eol,start' | |
vim.opt.incsearch = true | |
vim.opt.laststatus = 2 | |
vim.opt.ruler = true | |
vim.opt.wildmenu = true | |
vim.opt.sidescroll = 1 | |
vim.opt.sidescrolloff = 2 | |
vim.opt.autoread = true | |
vim.opt.langremap = false | |
vim.opt.cursorline = true | |
vim.opt.ignorecase = true | |
vim.opt.signcolumn = 'yes' | |
vim.opt.laststatus = 0 | |
vim.opt.mouse = 'a' | |
vim.opt.breakindent = true | |
vim.opt.inccommand = 'split' | |
vim.opt.smarttab = true | |
vim.opt.number = true | |
vim.opt.wrap = false | |
vim.opt.smartcase = true | |
vim.opt.autoindent = true | |
vim.opt.cindent = true | |
vim.opt.expandtab = true | |
vim.opt.shiftwidth = 2 | |
vim.opt.smartindent = true | |
vim.opt.softtabstop = 2 | |
vim.opt.list = true | |
vim.opt.listchars = { tab = '» ', trail = '·', nbsp = '␣' } | |
vim.opt.background = "dark" | |
vim.opt.termguicolors = true | |
vim.opt.ttyfast = true | |
vim.opt.backup = false | |
vim.opt.writebackup = false | |
vim.opt.spell = true | |
vim.opt.updatetime = 100 | |
vim.opt.signcolumn = "yes" | |
vim.opt.foldenable = false | |
vim.opt.foldlevel = 20 | |
vim.opt.hlsearch = true | |
vim.o.scrolloff = 6 | |
vim.g.have_nerd_font = true | |
local keyset = vim.keymap.set | |
-- vnoremap <C-r> "hy:%s/<C-r>h//gc<left><left><left> | |
keyset('v', '<C-r>', '"hy:%s/<C-r>h//gc<left><left><left>') | |
-- disable highlight for last search | |
keyset('n', '<Esc>', ':noh<CR>', { silent = true }) | |
function _G.check_back_space() | |
local col = vim.fn.col('.') - 1 | |
return col == 0 or vim.fn.getline('.'):sub(col, col):match('%s') ~= nil | |
end | |
local opts = { silent = true, noremap = true, expr = true, replace_keycodes = false } | |
keyset("i", "<TAB>", 'coc#pum#visible() ? coc#pum#next(1) : v:lua.check_back_space() ? "<TAB>" : coc#refresh()', opts) | |
keyset("i", "<S-TAB>", [[coc#pum#visible() ? coc#pum#prev(1) : "\<C-h>"]], opts) | |
-- Make <CR> to accept selected completion item or notify coc.nvim to format | |
-- <C-g>u breaks current undo, please make your own choice | |
keyset("i", "<cr>", [[coc#pum#visible() ? coc#pum#confirm() : "\<C-g>u\<CR>\<c-r>=coc#on_enter()\<CR>"]], opts) | |
-- Use <c-j> to trigger snippets | |
keyset("i", "<c-j>", "<Plug>(coc-snippets-expand-jump)") | |
-- trigger completion | |
keyset("i", "<C-`>", "coc#refresh()", {silent = true, expr = true}) | |
-- Use `[g` and `]g` to navigate diagnostics | |
-- Use `:CocDiagnostics` to get all diagnostics of current buffer in location list | |
keyset("n", "[g", "<Plug>(coc-diagnostic-prev)", {silent = true}) | |
keyset("n", "]g", "<Plug>(coc-diagnostic-next)", {silent = true}) | |
-- GoTo code navigation | |
keyset("n", "gd", "<Plug>(coc-definition)", {silent = true}) | |
keyset("n", "gy", "<Plug>(coc-type-definition)", {silent = true}) | |
keyset("n", "gi", "<Plug>(coc-implementation)", {silent = true}) | |
keyset("n", "gr", "<Plug>(coc-references)", {silent = true}) | |
-- Use K to show documentation in preview window | |
function _G.show_docs() | |
local cw = vim.fn.expand('<cword>') | |
if vim.fn.index({'vim', 'help'}, vim.bo.filetype) >= 0 then | |
vim.api.nvim_command('h ' .. cw) | |
elseif vim.api.nvim_eval('coc#rpc#ready()') then | |
vim.fn.CocActionAsync('doHover') | |
else | |
vim.api.nvim_command('!' .. vim.o.keywordprg .. ' ' .. cw) | |
end | |
end | |
keyset("n", "K", '<CMD>lua _G.show_docs()<CR>', {silent = true}) | |
-- Highlight the symbol and its references on a CursorHold event(cursor is idle) | |
vim.api.nvim_create_augroup("CocGroup", {}) | |
vim.api.nvim_create_autocmd("CursorHold", { | |
group = "CocGroup", | |
command = "silent call CocActionAsync('highlight')", | |
desc = "Highlight symbol under cursor on CursorHold" | |
}) | |
-- Symbol renaming | |
keyset("n", "<leader>rn", "<Plug>(coc-rename)", {silent = true}) | |
-- Formatting selected code | |
keyset("x", "<leader>f", "<Plug>(coc-format-selected)", {silent = true}) | |
keyset("n", "<leader>f", "<Plug>(coc-format-selected)", {silent = true}) | |
-- Setup formatexpr specified filetype(s) | |
vim.api.nvim_create_autocmd("FileType", { | |
group = "CocGroup", | |
pattern = "typescript,json", | |
command = "setl formatexpr=CocAction('formatSelected')", | |
desc = "Setup formatexpr specified filetype(s)." | |
}) | |
-- Update signature help on jump placeholder | |
vim.api.nvim_create_autocmd("User", { | |
group = "CocGroup", | |
pattern = "CocJumpPlaceholder", | |
command = "call CocActionAsync('showSignatureHelp')", | |
desc = "Update signature help on jump placeholder" | |
}) | |
-- Apply codeAction to the selected region | |
-- Example: `<leader>aap` for current paragraph | |
local opts = {silent = true, nowait = true} | |
keyset("x", "<leader>a", "<Plug>(coc-codeaction-selected)", opts) | |
keyset("n", "<leader>a", "<Plug>(coc-codeaction-selected)", opts) | |
-- Remap keys for apply code actions at the cursor position. | |
keyset("n", "<leader>aa", "<Plug>(coc-codeaction-cursor)", opts) | |
-- Remap keys for apply source code actions for current file. | |
keyset("n", "<leader>as", "<Plug>(coc-codeaction-source)", opts) | |
-- Apply the most preferred quickfix action on the current line. | |
keyset("n", "<leader>qf", "<Plug>(coc-fix-current)", opts) | |
-- Remap keys for apply refactor code actions. | |
keyset("n", "<leader>re", "<Plug>(coc-codeaction-refactor)", { silent = true }) | |
keyset("x", "<leader>r", "<Plug>(coc-codeaction-refactor-selected)", { silent = true }) | |
keyset("n", "<leader>r", "<Plug>(coc-codeaction-refactor-selected)", { silent = true }) | |
-- Run the Code Lens actions on the current line | |
keyset("n", "<leader>cl", "<Plug>(coc-codelens-action)", opts) | |
-- Map function and class text objects | |
-- NOTE: Requires 'textDocument.documentSymbol' support from the language server | |
keyset("x", "if", "<Plug>(coc-funcobj-i)", opts) | |
keyset("o", "if", "<Plug>(coc-funcobj-i)", opts) | |
keyset("x", "af", "<Plug>(coc-funcobj-a)", opts) | |
keyset("o", "af", "<Plug>(coc-funcobj-a)", opts) | |
keyset("x", "ic", "<Plug>(coc-classobj-i)", opts) | |
keyset("o", "ic", "<Plug>(coc-classobj-i)", opts) | |
keyset("x", "ac", "<Plug>(coc-classobj-a)", opts) | |
keyset("o", "ac", "<Plug>(coc-classobj-a)", opts) | |
-- Remap <C-f> and <C-b> to scroll float windows/popups | |
---@diagnostic disable-next-line: redefined-local | |
local opts = {silent = true, nowait = true, expr = true} | |
keyset("n", "<C-f>", 'coc#float#has_scroll() ? coc#float#scroll(1) : "<C-f>"', opts) | |
keyset("n", "<C-b>", 'coc#float#has_scroll() ? coc#float#scroll(0) : "<C-b>"', opts) | |
keyset("i", "<C-f>", | |
'coc#float#has_scroll() ? "<c-r>=coc#float#scroll(1)<cr>" : "<Right>"', opts) | |
keyset("i", "<C-b>", | |
'coc#float#has_scroll() ? "<c-r>=coc#float#scroll(0)<cr>" : "<Left>"', opts) | |
keyset("v", "<C-f>", 'coc#float#has_scroll() ? coc#float#scroll(1) : "<C-f>"', opts) | |
keyset("v", "<C-b>", 'coc#float#has_scroll() ? coc#float#scroll(0) : "<C-b>"', opts) | |
-- Use CTRL-S for selections ranges | |
-- Requires 'textDocument/selectionRange' support of language server | |
keyset("n", "<C-s>", "<Plug>(coc-range-select)", {silent = true}) | |
keyset("x", "<C-s>", "<Plug>(coc-range-select)", {silent = true}) | |
-- Add `:Format` command to format current buffer | |
vim.api.nvim_create_user_command("Format", "call CocAction('format')", {}) | |
-- " Add `:Fold` command to fold current buffer | |
vim.api.nvim_create_user_command("Fold", "call CocAction('fold', <f-args>)", {nargs = '?'}) | |
-- Add `:OR` command for organize imports of the current buffer | |
vim.api.nvim_create_user_command("OR", "call CocActionAsync('runCommand', 'editor.action.organizeImport')", {}) | |
-- Add (Neo)Vim's native statusline support | |
-- NOTE: Please see `:h coc-status` for integrations with external plugins that | |
-- provide custom statusline: lightline.vim, vim-airline | |
-- vim.opt.statusline:prepend("%{coc#status()}%{get(b:,'coc_current_function','')}") | |
-- Mappings for CoCList | |
-- code actions and coc stuff | |
---@diagnostic disable-next-line: redefined-local | |
local opts = {silent = true, nowait = true} | |
-- Show all diagnostics | |
keyset("n", "<space>a", ":<C-u>CocList diagnostics<cr>", opts) | |
-- Manage extensions | |
keyset("n", "<space>e", ":<C-u>CocList extensions<cr>", opts) | |
-- Show commands | |
keyset("n", "<space>c", ":<C-u>CocList commands<cr>", opts) | |
-- Find symbol of current document | |
keyset("n", "<space>o", ":<C-u>CocList outline<cr>", opts) | |
-- Search workspace symbols | |
keyset("n", "<space>s", ":<C-u>CocList -I symbols<cr>", opts) | |
-- Do default action for next item | |
keyset("n", "<space>j", ":<C-u>CocNext<cr>", opts) | |
-- Do default action for previous item | |
keyset("n", "<space>k", ":<C-u>CocPrev<cr>", opts) | |
-- Resume latest coc list | |
keyset("n", "<space>p", ":<C-u>CocListResume<cr>", opts) | |
require("lazy").setup({ | |
{ | |
"neoclide/coc.nvim", | |
branch = "release", | |
lazy = false, | |
config = function() | |
keyset('n', '<leader>esf', '<cmd>CocCommand eslint.executeAutofix<cr>') | |
end, | |
}, | |
{ | |
'nvim-telescope/telescope.nvim', | |
dependencies = { | |
'nvim-lua/plenary.nvim', | |
'nvim-tree/nvim-web-devicons', | |
'nvim-telescope/telescope-ui-select.nvim', | |
{ | |
'nvim-telescope/telescope-fzf-native.nvim', | |
build = 'make', | |
}, | |
}, | |
config = function() | |
require('telescope').setup { | |
extensions = { | |
['ui-select'] = { | |
require('telescope.themes').get_dropdown(), | |
}, | |
fzf = { | |
fuzzy = true, | |
override_generic_sorter = true, | |
override_file_sorter = true, | |
}, | |
}, | |
} | |
pcall(require('telescope').load_extension, 'fzf') | |
pcall(require('telescope').load_extension, 'ui-select') | |
local builtin = require('telescope.builtin') | |
keyset('n', '<C-p>', builtin.find_files, {}) | |
keyset('n', '<leader>ff', builtin.find_files, {}) | |
keyset('n', '<leader>fg', builtin.live_grep, {}) | |
keyset('n', '<leader>fb', builtin.buffers, {}) | |
keyset('n', '<leader>fh', builtin.help_tags, {}) | |
keyset('n', '<leader>fr', builtin.resume, {}) | |
end, | |
}, | |
{ | |
'nvim-tree/nvim-web-devicons', | |
opts = {}, | |
}, | |
{ | |
'nvim-tree/nvim-tree.lua', | |
opts = { | |
update_cwd = true, | |
hijack_cursor = true, | |
update_focused_file = { | |
enable = true, | |
update_cwd = false, | |
ignore_list = {} | |
}, | |
view = { | |
width = 40 | |
}, | |
filters = { | |
dotfiles = true, | |
}, | |
}, | |
}, | |
{ | |
'akinsho/bufferline.nvim', | |
version = '*', | |
config = function() | |
require("bufferline").setup { | |
options = { | |
themable = true, | |
diagnostics = "coc", | |
offsets = { | |
{ | |
filetype = 'NvimTree', | |
text = "Explorer", | |
text_align = "left", | |
separator = true, | |
} | |
}, | |
} | |
} | |
keyset('n', '[b', function () require('bufferline').cycle(-1) end, { silent = true }) | |
keyset('n', ']b', function () require('bufferline').cycle(1) end, { silent = true }) | |
end, | |
}, | |
{ | |
'bluz71/vim-moonfly-colors', | |
name = 'moonfly', | |
lazy = true, | |
-- priority = 1000, | |
-- config = function() | |
-- vim.cmd.colorscheme('moonfly') | |
-- end, | |
}, | |
{ | |
'catppuccin/nvim', | |
lazy = true, | |
-- priority = 1000, | |
config = function() | |
require("catppuccin").setup({ | |
flavour = "mocha", -- latte, frappe, macchiato, mocha | |
transparent_background = true, -- disables setting the background color. | |
show_end_of_buffer = false, -- shows the '~' characters after the end of buffers | |
styles = { -- Handles the styles of general hi groups (see `:h highlight-args`): | |
comments = { 'italic' }, -- Change the style of comments | |
conditionals = { 'italic' }, | |
keywords = { 'italic' } | |
}, | |
integrations = { | |
nvimtree = true, | |
coc_nvim = true, | |
}, | |
}) | |
-- vim.cmd.colorscheme('catppuccin') | |
end, | |
}, | |
{ | |
'datsfilipe/vesper.nvim', | |
lazy = false, | |
config = function() | |
require('vesper').setup { | |
transparent = true, | |
italics = { | |
comments = true, | |
keywords = true, | |
functions = false, | |
strings = false, | |
variables = true, | |
} | |
} | |
vim.cmd.colorscheme('vesper') | |
end, | |
}, | |
{ | |
"kdheepak/lazygit.nvim", | |
dependencies = { "nvim-lua/plenary.nvim" }, | |
keys = { | |
{ "<leader>gg", "<cmd>:LazyGit<cr>", silent = true }, | |
}, | |
}, | |
{ | |
'wakatime/vim-wakatime', | |
lazy = false | |
}, | |
{ | |
'echasnovski/mini.nvim', | |
version = '*', | |
config = function() | |
require('mini.pairs').setup { | |
mappings = { | |
['('] = { action = 'open', pair = '()', neigh_pattern = '[^\\].', register = { cr = false } }, | |
['['] = { action = 'open', pair = '[]', neigh_pattern = '[^\\].', register = { cr = false } }, | |
['{'] = { action = 'open', pair = '{}', neigh_pattern = '[^\\].', register = { cr = false } }, | |
[')'] = { action = 'close', pair = '()', neigh_pattern = '[^\\].', register = { cr = false } }, | |
[']'] = { action = 'close', pair = '[]', neigh_pattern = '[^\\].', register = { cr = false } }, | |
['}'] = { action = 'close', pair = '{}', neigh_pattern = '[^\\].', register = { cr = false } }, | |
['"'] = { action = 'closeopen', pair = '""', neigh_pattern = '[^\\].', register = { cr = false } }, | |
["'"] = { action = 'closeopen', pair = "''", neigh_pattern = '[^%a\\].', register = { cr = false } }, | |
['`'] = { action = 'closeopen', pair = '``', neigh_pattern = '[^\\].', register = { cr = false } }, | |
}, | |
} | |
require('mini.comment').setup { | |
options = { | |
ignore_blank_line = true, | |
} | |
} | |
local bufremove = require('mini.bufremove') | |
bufremove.setup() | |
keyset('n', '<C-e>', bufremove.delete) | |
require('mini.cursorword').setup() | |
require('mini.move').setup() | |
require('mini.splitjoin').setup() | |
require('mini.surround').setup() | |
end, | |
}, | |
{ | |
'nvim-treesitter/nvim-treesitter', | |
build = ':TSUpdate', | |
event = { 'BufReadPost', 'BufNewFile' }, | |
opts = { | |
-- idk, but these don't work | |
-- highlight = { | |
-- enabled = true | |
-- }, | |
-- indent = { | |
-- enabled = true | |
-- }, | |
ensure_installed = { | |
'javascript', | |
'typescript', | |
'tsx', | |
'vue', | |
'html', | |
'css', | |
'scss', | |
}, | |
}, | |
config = function() | |
vim.cmd(':TSEnable highlight') | |
vim.cmd(':TSEnable indent') | |
vim.opt.foldmethod = 'expr' | |
vim.opt.foldexpr = 'nvim_treesitter#foldexpr()' | |
end, | |
}, | |
{ | |
'lewis6991/gitsigns.nvim', | |
event = { 'BufReadPost', 'BufNewFile' }, | |
config = function() | |
local gs = require('gitsigns') | |
gs.setup() | |
keyset("n", "<leader>hp", gs.preview_hunk_inline) | |
keyset("n", "<leader>hr", gs.reset_hunk) | |
end, | |
}, | |
}) |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment