-- NOTE: Must happen before plugins are loaded (otherwise wrong leader will be used)

vim.g.mapleader = ' '

vim.g.maplocalleader = ' '

-- Set to true if you have a Nerd Font installed and selected in the terminal

vim.g.have_nerd_font = true

require 'custom.core.keymaps'

-- [[ Setting options ]]

-- See `:help vim.o`

-- NOTE: You can change these options as you wish!

-- For more options, you can see `:help option-list`

-- Make line numbers default

vim.o.number = true

-- You can also add relative line numbers, to help with jumping.

-- Experiment for yourself to see if you like it!

vim.o.relativenumber = true

-- enable termguicolors

vim.opt.termguicolors = true

-- Enable mouse mode, can be useful for resizing splits for example!

vim.o.mouse = 'a'

-- Don't show the mode, since it's already in the status line

vim.o.showmode = false

-- Sync clipboard between OS and Neovim.

-- Schedule the setting after `UiEnter` because it can increase startup-time.

-- Remove this option if you want your OS clipboard to remain independent.

-- See `:help 'clipboard'`

vim.schedule(function() vim.o.clipboard = 'unnamedplus' end)

-- Enable break indent

vim.o.breakindent = true

-- Enable undo/redo changes even after closing and reopening a file

vim.o.undofile = true

-- Case-insensitive searching UNLESS \C or one or more capital letters in the search term

vim.o.ignorecase = true

vim.o.smartcase = true

-- Keep signcolumn on by default

vim.o.signcolumn = 'yes'

-- Decrease update time

vim.o.updatetime = 250

-- Decrease mapped sequence wait time

vim.o.timeoutlen = 300

-- Configure how new splits should be opened

vim.o.splitright = true

vim.o.splitbelow = true

-- Sets how neovim will display certain whitespace characters in the editor.

-- See `:help 'list'`

-- and `:help 'listchars'`

--

-- Notice listchars is set using `vim.opt` instead of `vim.o`.

-- It is very similar to `vim.o` but offers an interface for conveniently interacting with tables.

-- See `:help lua-options`

-- and `:help lua-guide-options`

vim.o.list = true

vim.opt.listchars = { tab = '» ', trail = '·', nbsp = '␣' }

-- Preview substitutions live, as you type!

vim.o.inccommand = 'split'

-- Show which line your cursor is on

vim.o.cursorline = true

-- Minimal number of screen lines to keep above and below the cursor.

vim.o.scrolloff = 10

-- if performing an operation that would fail due to unsaved changes in the buffer (like `:q`),

-- instead raise a dialog asking if you wish to save the current file(s)

-- See `:help 'confirm'`

vim.o.confirm = true

-- [[ Basic Keymaps ]]

-- See `:help vim.keymap.set()`

-- Clear highlights on search when pressing <Esc> in normal mode

-- See `:help hlsearch`

vim.keymap.set('n', '<Esc>', '<cmd>nohlsearch<CR>')

-- Diagnostic Config & Keymaps

-- See :help vim.diagnostic.Opts

local severity = vim.diagnostic.severity

vim.diagnostic.config {

update_in_insert = false,

severity_sort = true,

float = { border = 'rounded', source = 'if_many' },

underline = { severity = { min = vim.diagnostic.severity.WARN } },

signs = {

text = {

[severity.ERROR] = ' ',

[severity.WARN] = ' ',

[severity.HINT] = '󰠠 ',

[severity.INFO] = ' ',

},

},

-- Can switch between these as you prefer

virtual_text = true, -- Text shows up at the end of the line

virtual_lines = false, -- Text shows up underneath the line, with virtual lines

-- Auto open the float, so you can easily read the errors when jumping with `[d` and `]d`

-- jump = { float = true },

}

vim.keymap.set('n', '<leader>d', vim.diagnostic.setloclist, { desc = 'Open diagnostic [Q]uickfix list' })

-- Exit terminal mode in the builtin terminal with a shortcut that is a bit easier

-- for people to discover. Otherwise, you normally need to press <C-\><C-n>, which

-- is not what someone will guess without a bit more experience.

--

-- NOTE: This won't work in all terminal emulators/tmux/etc. Try your own mapping

-- or just use <C-\><C-n> to exit terminal mode

vim.keymap.set('t', '<Esc><Esc>', '<C-\\><C-n>', { desc = 'Exit terminal mode' })

-- TIP: Disable arrow keys in normal mode

-- vim.keymap.set('n', '<left>', '<cmd>echo "Use h to move!!"<CR>')

-- vim.keymap.set('n', '<right>', '<cmd>echo "Use l to move!!"<CR>')

-- vim.keymap.set('n', '<up>', '<cmd>echo "Use k to move!!"<CR>')

-- vim.keymap.set('n', '<down>', '<cmd>echo "Use j to move!!"<CR>')

-- Keybinds to make split navigation easier.

-- Use CTRL+<hjkl> to switch between windows

--

-- See `:help wincmd` for a list of all window commands

vim.keymap.set('n', '<C-h>', '<C-w><C-h>', { desc = 'Move focus to the left window' })

vim.keymap.set('n', '<C-l>', '<C-w><C-l>', { desc = 'Move focus to the right window' })

vim.keymap.set('n', '<C-j>', '<C-w><C-j>', { desc = 'Move focus to the lower window' })

-- Visual Mode Moving selected text up and down

vim.keymap.set('v', 'J', ":m '>+1<CR>gv=gv")

vim.keymap.set('v', 'K', ":m '<-2<CR>gv=gv")

-- paste without loosing current yank

vim.keymap.set('x', '<leader>p', '"_dP')

-- NOTE: Some terminals have colliding keymaps or are not able to send distinct keycodes

-- vim.keymap.set("n", "<C-S-h>", "<C-w>H", { desc = "Move window to the left" })

-- vim.keymap.set("n", "<C-S-l>", "<C-w>L", { desc = "Move window to the right" })

-- vim.keymap.set("n", "<C-S-j>", "<C-w>J", { desc = "Move window to the lower" })

-- vim.keymap.set("n", "<C-S-k>", "<C-w>K", { desc = "Move window to the upper" })

-- [[ Basic Autocommands ]]

-- See `:help lua-guide-autocommands`

-- Highlight when yanking (copying) text

-- Try it with `yap` in normal mode

-- See `:help vim.hl.on_yank()`

vim.api.nvim_create_autocmd('TextYankPost', {

desc = 'Highlight when yanking (copying) text',

group = vim.api.nvim_create_augroup('kickstart-highlight-yank', { clear = true }),

callback = function() vim.hl.on_yank() end,

})

-- [[ Install `lazy.nvim` plugin manager ]]

-- See `:help lazy.nvim.txt` or https://github.com/folke/lazy.nvim for more info

local lazypath = vim.fn.stdpath 'data' .. '/lazy/lazy.nvim'

if not (vim.uv or vim.loop).fs_stat(lazypath) then

local lazyrepo = 'https://github.com/folke/lazy.nvim.git'

local out = vim.fn.system { 'git', 'clone', '--filter=blob:none', '--branch=stable', lazyrepo, lazypath }

if vim.v.shell_error ~= 0 then error('Error cloning lazy.nvim:\n' .. out) end

end

---@type vim.Option

local rtp = vim.opt.rtp

rtp:prepend(lazypath)

-- [[ Configure and install plugins ]]

--

-- To check the current status of your plugins, run

-- :Lazy

--

-- You can press `?` in this menu for help. Use `:q` to close the window

--

-- To update plugins you can run

-- :Lazy update

--

-- NOTE: Here is where you install your plugins.

require('lazy').setup({

-- NOTE: Plugins can be added via a link or github org/name. To run setup automatically, use `opts = {}`

{ 'NMAC427/guess-indent.nvim', opts = {} },

-- Alternatively, use `config = function() ... end` for full control over the configuration.

-- If you prefer to call `setup` explicitly, use:

-- {

-- 'lewis6991/gitsigns.nvim',

-- config = function()

-- require('gitsigns').setup({

-- -- Your gitsigns configuration here

-- })

-- end,

-- }

--

-- Here is a more advanced example where we pass configuration

-- options to `gitsigns.nvim`.

--

-- See `:help gitsigns` to understand what the configuration keys do

{ -- Adds git related signs to the gutter, as well as utilities for managing changes

'lewis6991/gitsigns.nvim',

---@module 'gitsigns'

---@type Gitsigns.Config

---@diagnostic disable-next-line: missing-fields

opts = {

signs = {

add = { text = '+' }, ---@diagnostic disable-line: missing-fields

change = { text = '~' }, ---@diagnostic disable-line: missing-fields

delete = { text = '_' }, ---@diagnostic disable-line: missing-fields

topdelete = { text = '‾' }, ---@diagnostic disable-line: missing-fields

changedelete = { text = '~' }, ---@diagnostic disable-line: missing-fields

},

},

},

-- NOTE: Plugins can also be configured to run Lua code when they are loaded.

--

-- This is often very useful to both group configuration, as well as handle

-- lazy loading plugins that don't need to be loaded immediately at startup.

--

-- For example, in the following configuration, we use:

-- event = 'VimEnter'

--

-- which loads which-key before all the UI elements are loaded. Events can be

-- normal autocommands events (`:help autocmd-events`).

--

-- Then, because we use the `opts` key (recommended), the configuration runs

-- after the plugin has been loaded as `require(MODULE).setup(opts)`.

{ -- Useful plugin to show you pending keybinds.

'folke/which-key.nvim',

event = 'VimEnter',

---@module 'which-key'

---@type wk.Opts

---@diagnostic disable-next-line: missing-fields

opts = {

-- delay between pressing a key and opening which-key (milliseconds)

delay = 500,

icons = { mappings = vim.g.have_nerd_font },

-- Document existing key chains

spec = {

{ '<leader>f', group = '[F]ind', mode = { 'n', 'v' } },

{ '<leader>s', group = '[S]plit', mode = { 'n', 'v' } },

{ '<leader>w', group = '[W]orkspace', mode = { 'n', 'v' } },

{ '<leader>l', group = '[L]azygit', mode = { 'n', 'v' } },

{ '<leader>d', group = '[D]iagnostics', mode = { 'n', 'v' } },

{ '<leader>e', group = '[E]xplorer', mode = { 'n', 'v' } },

{ '<leader>t', group = '[T]oggle' },

{ '<leader>h', group = 'Git [H]unk', mode = { 'n', 'v' } },

{ 'gr', group = 'LSP Actions', mode = { 'n' } },

},

},

},

-- NOTE: Plugins can specify dependencies.

--

-- The dependencies are proper plugin specifications as well - anything

-- you do for a plugin at the top level, you can do for a dependency.

--

-- Use the `dependencies` key to specify the dependencies of a particular plugin

-- LSP Plugins

{

-- Main LSP Configuration

'neovim/nvim-lspconfig',

dependencies = {

-- Automatically install LSPs and related tools to stdpath for Neovim

-- Mason must be loaded before its dependents so we need to set it up here.

-- NOTE: `opts = {}` is the same as calling `require('mason').setup({})`

{

'mason-org/mason.nvim',

---@module 'mason.settings'

---@type MasonSettings

---@diagnostic disable-next-line: missing-fields

opts = {},

},

-- Maps LSP server names between nvim-lspconfig and Mason package names.

'mason-org/mason-lspconfig.nvim',

'WhoIsSethDaniel/mason-tool-installer.nvim',

-- Useful status updates for LSP.

-- { 'j-hui/fidget.nvim', opts = {} },

},

config = function()

-- Brief aside: **What is LSP?**

--

-- LSP is an initialism you've probably heard, but might not understand what it is.

-- LSP stands for Language Server Protocol. It's a protocol that helps editors

-- and language tooling communicate in a standardized fashion.

--

-- In general, you have a "server" which is some tool built to understand a particular

-- language (such as `gopls`, `lua_ls`, `rust_analyzer`, etc.). These Language Servers

-- (sometimes called LSP servers, but that's kind of like ATM Machine) are standalone

-- processes that communicate with some "client" - in this case, Neovim!

--

-- LSP provides Neovim with features like:

-- - Go to definition

-- - Find references

-- - Autocompletion

-- - Symbol Search

-- - and more!

--

-- Thus, Language Servers are external tools that must be installed separately from

-- Neovim. This is where `mason` and related plugins come into play.

--

-- If you're wondering about lsp vs treesitter, you can check out the wonderfully

-- and elegantly composed help section, `:help lsp-vs-treesitter`

-- This function gets run when an LSP attaches to a particular buffer.

-- That is to say, every time a new file is opened that is associated with

-- an lsp (for example, opening `main.rs` is associated with `rust_analyzer`) this

-- function will be executed to configure the current buffer

vim.api.nvim_create_autocmd('LspAttach', {

group = vim.api.nvim_create_augroup('kickstart-lsp-attach', { clear = true }),

callback = function(event)

-- VS Code like Colorizer for css

vim.lsp.document_color.enable(true, nil, { style = 'virtual' })

-- NOTE: Remember that Lua is a real programming language, and as such it is possible

-- to define small helper and utility functions so you don't have to repeat yourself.

--

-- In this case, we create a function that lets us more easily define mappings specific

-- for LSP related items. It sets the mode, buffer and description for us each time.

local map = function(keys, func, desc, mode)

mode = mode or 'n'

vim.keymap.set(mode, keys, func, { buffer = event.buf, desc = 'LSP: ' .. desc })

end

-- Rename the variable under your cursor.

-- Most Language Servers support renaming across files, etc.

-- Execute a code action, usually your cursor needs to be on top of an error

-- or a suggestion from your LSP for this to activate.

map('gra', vim.lsp.buf.code_action, '[G]oto Code [A]ction', { 'n', 'x' })

-- WARN: This is not Goto Definition, this is Goto Declaration.

-- For example, in C this would take you to the header.

map('grD', vim.lsp.buf.declaration, '[G]oto [D]eclaration')

-- The following two autocommands are used to highlight references of the

-- word under your cursor when your cursor rests there for a little while.

-- See `:help CursorHold` for information about when this is executed

--

-- When you move your cursor, the highlights will be cleared (the second autocommand).

local client = vim.lsp.get_client_by_id(event.data.client_id)

if client and client:supports_method('textDocument/documentHighlight', event.buf) then

local highlight_augroup = vim.api.nvim_create_augroup('kickstart-lsp-highlight', { clear = false })

vim.api.nvim_create_autocmd({ 'CursorHold', 'CursorHoldI' }, {

buffer = event.buf,

group = highlight_augroup,

callback = vim.lsp.buf.document_highlight,

})

vim.api.nvim_create_autocmd({ 'CursorMoved', 'CursorMovedI' }, {

buffer = event.buf,

group = highlight_augroup,

callback = vim.lsp.buf.clear_references,

})

vim.api.nvim_create_autocmd('LspDetach', {

group = vim.api.nvim_create_augroup('kickstart-lsp-detach', { clear = true }),

callback = function(event2)

vim.lsp.buf.clear_references()

vim.api.nvim_clear_autocmds { group = 'kickstart-lsp-highlight', buffer = event2.buf }

end,

})

end

-- The following code creates a keymap to toggle inlay hints in your

-- code, if the language server you are using supports them

--

-- This may be unwanted, since they displace some of your code

if client and client:supports_method('textDocument/inlayHint', event.buf) then

map('<leader>th', function() vim.lsp.inlay_hint.enable(not vim.lsp.inlay_hint.is_enabled { bufnr = event.buf }) end, '[T]oggle Inlay [H]ints')

end

end,

})

-- Enable the following language servers

-- Feel free to add/remove any LSPs that you want here. They will automatically be installed.

-- See `:help lsp-config` for information about keys and how to configure

---@type table<string, vim.lsp.Config>

local servers = {

html = {},

cssls = {},

graphql = {},

eslint = {},

-- clangd = {},

-- gopls = {},

-- pyright = {},

-- rust_analyzer = {},

--

-- Some languages (like typescript) have entire language plugins that can be useful:

-- https://github.com/pmizio/typescript-tools.nvim

-- But for many setups, the LSP (`ts_ls`) will work just fine

ts_ls = {},

stylua = {}, -- Used to format Lua code

-- Special Lua Config, as recommended by neovim help docs

lua_ls = {

on_init = function(client)

if client.workspace_folders then

local path = client.workspace_folders[1].name

if path ~= vim.fn.stdpath 'config' and (vim.uv.fs_stat(path .. '/.luarc.json') or vim.uv.fs_stat(path .. '/.luarc.jsonc')) then return end

end

client.config.settings.Lua = vim.tbl_deep_extend('force', client.config.settings.Lua, {

runtime = {

version = 'LuaJIT',

path = { 'lua/?.lua', 'lua/?/init.lua' },

},

workspace = {

checkThirdParty = false,

-- NOTE: this is a lot slower and will cause issues when working on your own configuration.

-- See https://github.com/neovim/nvim-lspconfig/issues/3189

library = vim.tbl_extend('force', vim.api.nvim_get_runtime_file('', true), {

'${3rd}/luv/library',

'${3rd}/busted/library',

}),

},

})

end,

settings = {

Lua = {},

},

},

}

-- Ensure the servers and tools above are installed

--

-- To check the current status of installed tools and/or manually install

-- other tools, you can run

-- :Mason

--

-- You can press `g?` for help in this menu.

local ensure_installed = vim.tbl_keys(servers or {})

vim.list_extend(ensure_installed, {

-- You can add other tools here that you want Mason to install

})

require('mason-tool-installer').setup { ensure_installed = ensure_installed }

for name, server in pairs(servers) do

vim.lsp.config(name, server)

vim.lsp.enable(name)

end

end,

},

{ -- Autoformat

'stevearc/conform.nvim',

event = { 'BufWritePre' },

cmd = { 'ConformInfo' },

keys = {

{

'<A-F>',

function() require('conform').format { async = true, lsp_format = 'fallback' } end,

mode = 'i',

desc = '[F]ormat buffer',

},

},

---@module 'conform'

---@type conform.setupOpts

opts = {

notify_on_error = false,

format_on_save = function(bufnr)

-- Disable "format_on_save lsp_fallback" for languages that don't

-- have a well standardized coding style. You can add additional

-- languages here or re-enable it for the disabled ones.

local disable_filetypes = { c = true, cpp = true }

if disable_filetypes[vim.bo[bufnr].filetype] then

return nil

else

return {

timeout_ms = 500,

lsp_format = 'fallback',

}

end

end,

formatters_by_ft = {

lua = { 'stylua' },

-- Conform can also run multiple formatters sequentially

-- python = { "isort", "black" },

--

-- You can use 'stop_after_first' to run the first available formatter from the list

javascript = { 'prettierd', 'prettier', stop_after_first = true },

},

},

},

-- Highlight todo, notes, etc in comments

{

'folke/todo-comments.nvim',

event = 'VimEnter',

dependencies = { 'nvim-lua/plenary.nvim' },

---@module 'todo-comments'

---@type TodoOptions

---@diagnostic disable-next-line: missing-fields

opts = { signs = false },

},

{ -- Collection of various small independent plugins/modules

'nvim-mini/mini.nvim',

config = function()

-- Better Around/Inside textobjects

--

-- Examples:

-- - va) - [V]isually select [A]round [)]paren

-- - yinq - [Y]ank [I]nside [N]ext [Q]uote

-- - ci' - [C]hange [I]nside [']quote

require('mini.ai').setup { n_lines = 500 }

-- Add/delete/replace surroundings (brackets, quotes, etc.)

--

-- - saiw) - [S]urround [A]dd [I]nner [W]ord [)]Paren

-- - sd' - [S]urround [D]elete [']quotes

-- - sr)' - [S]urround [R]eplace [)] [']

require('mini.surround').setup()

-- Simple and easy statusline.

-- You could remove this setup call if you don't like it,

-- and try some other statusline plugin

-- local statusline = require 'mini.statusline'

-- set use_icons to true if you have a Nerd Font

-- statusline.setup { use_icons = vim.g.have_nerd_font }

-- You can configure sections in the statusline by overriding their

-- default behavior. For example, here we set the section for

-- cursor location to LINE:COLUMN

---@diagnostic disable-next-line: duplicate-set-field

-- statusline.section_location = function() return '%2l:%-2v' end

-- ... and there is more!

-- Check out: https://github.com/nvim-mini/mini.nvim

end,

},

{ -- Highlight, edit, and navigate code

'nvim-treesitter/nvim-treesitter',

lazy = false,

build = ':TSUpdate',

branch = 'main',

-- [[ Configure Treesitter ]] See `:help nvim-treesitter-intro`

config = function()

local parsers = { 'bash', 'c', 'diff', 'html', 'lua', 'luadoc', 'markdown', 'markdown_inline', 'query', 'vim', 'vimdoc' }

require('nvim-treesitter').install(parsers)

vim.api.nvim_create_autocmd('FileType', {

callback = function(args)

local buf, filetype = args.buf, args.match

local language = vim.treesitter.language.get_lang(filetype)

if not language then return end

-- check if parser exists and load it

if not vim.treesitter.language.add(language) then return end

-- enables syntax highlighting and other treesitter features

vim.treesitter.start(buf, language)

-- enables treesitter based indentation

vim.bo.indentexpr = "v:lua.require'nvim-treesitter'.indentexpr()"

end,

})

end,

},

{ import = 'custom.plugins' },

-- For additional information with loading, sourcing and examples see `:help lazy.nvim-🔌-plugin-spec`

-- Or use telescope!

-- In normal mode type `<space>sh` then write `lazy.nvim-plugin`

-- you can continue same window with `<space>sr` which resumes last telescope search

}, { ---@diagnostic disable-line: missing-fields

ui = {

-- If you are using a Nerd Font: set icons to an empty table which will use the

-- default lazy.nvim defined Nerd Font icons, otherwise define a unicode icons table

icons = vim.g.have_nerd_font and {} or {

cmd = '⌘',

config = '🛠',

event = '📅',

ft = '📂',

init = '⚙',

keys = '🗝',

plugin = '🔌',

runtime = '💻',

require = '🌙',

source = '📄',

start = '🚀',

task = '📌',

lazy = '💤 ',

},

},

})

-- The line beneath this is called `modeline`. See `:help modeline`

-- vim: ts=2 sts=2 sw=2 et