init.lua

-- Based on:
--
-- - https://github.com/mjlbach/defaults.nvim
-- - https://github.com/shift-d/nv/
-- - https://github.com/NvChad/NvChad




-- Sane defaults

vim.wo.number = true -- Make line numbers default
vim.o.hidden = true -- Do not save when switching buffers
vim.o.mouse = "a" -- Enable mouse mode
vim.o.breakindent = true -- Enable break indent
vim.o.updatetime = 250 -- --Decrease update time
vim.o.lazyredraw = true -- handy when running macros on big files
vim.wo.signcolumn = "yes" -- always show the signcolumn
vim.o.termguicolors = true -- using highlight attributes
vim.o.ignorecase = true -- case insensitive searching UNLESS /C ...
vim.o.smartcase = true -- or capital in search

vim.cmd [[set undofile]] -- Save undo history

-- Personal settings

vim.opt.swapfile = false
vim.opt.writebackup = false
vim.g.netrw_banner = 0
vim.o.shiftwidth = 2
vim.o.softtabstop = 2
vim.o.tabstop = 2
vim.o.expandtab = true
vim.o.scrolloff = 5
vim.o.colorcolumn = "80"
vim.api.nvim_command("highlight! link ColorColumn CursorLine") -- make cursorline same color as colorcolumn
vim.o.cursorline = true
vim.o.completeopt = "menuone,noselect" -- no auto selection, also show for 1 option
vim.o.background = "dark"
vim.cmd("colorscheme tokyonight")
-- o.rtp = o.rtp .. ",/usr/local/opt/fzf" -- required for fzf


-- Personal mappings

-- disable entering Ex mode
vim.api.nvim_set_keymap("n", "Q", "<Nop>", {})
vim.api.nvim_set_keymap("v", "Q", "<Nop>", {})

vim.api.nvim_set_keymap("n", "<c-t>", ":tabnew<cr>", {})
vim.api.nvim_set_keymap("n", "<tab>", ":tabn<cr>", {})
vim.api.nvim_set_keymap("n", "<S-tab>", ":tabp<cr>", {})

--  retain visual selection after indent
vim.api.nvim_set_keymap("v", ">", ">gv", {})
vim.api.nvim_set_keymap("v", "<", "<gv", {})

-- highlight until end of line
vim.api.nvim_set_keymap("n", "Y", "y$", {})

-- keeps window centered on finding next / prev
vim.api.nvim_set_keymap("n", "n", "nzzzv", {})
vim.api.nvim_set_keymap("n", "N", "Nzzzv", {})

 -- esc twice to remove hlsearch
vim.api.nvim_set_keymap("n", "<esc><esc>", ":nohlsearch<cr>", {})

--Remap space as leader key
vim.api.nvim_set_keymap("", "<Space>", "<Nop>", {noremap = true, silent = true})
vim.g.mapleader = " "
vim.g.maplocalleader = " "

--Remap for dealing with word wrap
vim.api.nvim_set_keymap("n", "k", "v:count == 0 ? 'gk' : 'k'", {noremap = true, expr = true, silent = true})
vim.api.nvim_set_keymap("n", "j", "v:count == 0 ? 'gj' : 'j'", {noremap = true, expr = true, silent = true})

-- Highlight on yank
vim.api.nvim_exec(
    [[
  augroup YankHighlight
    autocmd!
    autocmd TextYankPost * silent! lua vim.highlight.on_yank()
  augroup end
]],
    false
)

-- Y yank until the end of line
vim.api.nvim_set_keymap("n", "Y", "y$", {noremap = true})




-- disable some builtin vim plugins
local disabled_built_ins = {
    "2html_plugin",
    "getscript",
    "getscriptPlugin",
    "gzip",
    "logipat",
    "netrw",
    "netrwPlugin",
    "netrwSettings",
    "netrwFileHandlers",
    "matchit",
    "tar",
    "tarPlugin",
    "rrhelper",
    "spellfile_plugin",
    "vimball",
    "vimballPlugin",
    "zip",
    "zipPlugin"
}

for _, plugin in pairs(disabled_built_ins) do
    vim.g["loaded_" .. plugin] = 1
end




-- Install & setup package manager packer.nvim
-- First time run `:PackerSync`

local install_path = vim.fn.stdpath "data" .. "/site/pack/packer/start/packer.nvim"

if vim.fn.empty(vim.fn.glob(install_path)) > 0 then
    vim.fn.execute("!git clone https://github.com/wbthomason/packer.nvim " .. install_path)
end

vim.api.nvim_exec(
    [[
  augroup Packer
    autocmd!
    autocmd BufWritePost init.lua PackerCompile
  augroup end
]],
    false
)

require("packer").startup(
    function(use)
        -- Configure packages
        use {"wbthomason/packer.nvim"} -- package manager
        use {"nvim-lua/plenary.nvim"} -- utility functions

        use {
            "nvim-telescope/telescope.nvim", -- ui to select things (files, grep results, open buffers...)
            requires = {{"nvim-lua/popup.nvim"}, {"nvim-lua/plenary.nvim"}},
            config = function()
                require("telescope").setup {
                    defaults = {
                        -- mappings = {
                        --   i = {
                        --     ['<C-u>'] = false,
                        --     ['<C-d>'] = false,
                        --   },
                        -- },
                        vimgrep_arguments = {
                            "rg",
                            "--color=never",
                            "--no-heading",
                            "--with-filename",
                            "--line-number",
                            "--column",
                            "--smart-case"
                        },
                        -- prompt_prefix = "   ",
                        selection_caret = "  ",
                        entry_prefix = "  ",
                        initial_mode = "insert",
                        selection_strategy = "reset",
                        sorting_strategy = "ascending",
                        layout_strategy = "horizontal",
                        layout_config = {
                            horizontal = {
                                prompt_position = "top",
                                preview_width = 0.55,
                                results_width = 0.8
                            },
                            vertical = {
                                mirror = false
                            },
                            width = 0.87,
                            height = 0.80,
                            preview_cutoff = 120
                        },
                        file_sorter = require("telescope.sorters").get_fuzzy_file,
                        file_ignore_patterns = {},
                        generic_sorter = require("telescope.sorters").get_generic_fuzzy_sorter,
                        path_display = {"absolute"},
                        winblend = 0,
                        border = {},
                        borderchars = {"─", "│", "─", "│", "╭", "╮", "╯", "╰"},
                        color_devicons = true,
                        use_less = true,
                        set_env = {["COLORTERM"] = "truecolor"}, -- default = nil,
                        file_previewer = require("telescope.previewers").vim_buffer_cat.new,
                        grep_previewer = require("telescope.previewers").vim_buffer_vimgrep.new,
                        qflist_previewer = require("telescope.previewers").vim_buffer_qflist.new,
                        -- Developer configurations: Not meant for general override
                        buffer_previewer_maker = require("telescope.previewers").buffer_previewer_maker
                    }
                }
                vim.api.nvim_set_keymap(
                    "n",
                    "<leader><space>",
                    [[<cmd>lua require('telescope.builtin').buffers()<cr>]],
                    {noremap = true, silent = true}
                )
                vim.api.nvim_set_keymap(
                    "n",
                    "<leader>sf",
                    [[<cmd>lua require('telescope.builtin').find_files()<cr>]],
                    {noremap = true, silent = true}
                )
                -- vim.api.nvim_set_keymap('n', '<leader>sb', [[<cmd>lua require('telescope.builtin').current_buffer_fuzzy_find()<cr>]], { noremap = true, silent = true })
                vim.api.nvim_set_keymap(
                    "n",
                    "<leader>sh",
                    [[<cmd>lua require('telescope.builtin').help_tags()<cr>]],
                    {noremap = true, silent = true}
                )
                -- vim.api.nvim_set_keymap('n', '<leader>st', [[<cmd>lua require('telescope.builtin').tags()<cr>]], { noremap = true, silent = true })
                -- vim.api.nvim_set_keymap('n', '<leader>sd', [[<cmd>lua require('telescope.builtin').grep_string()<cr>]], { noremap = true, silent = true })
                vim.api.nvim_set_keymap(
                    "n",
                    "<leader>sp",
                    [[<cmd>lua require('telescope.builtin').live_grep()<cr>]],
                    {noremap = true, silent = true}
                )
                -- vim.api.nvim_set_keymap('n', '<leader>so', [[<cmd>lua require('telescope.builtin').tags{ only_current_buffer = true }<cr>]], { noremap = true, silent = true })
                -- vim.api.nvim_set_keymap('n', '<leader>?', [[<cmd>lua require('telescope.builtin').oldfiles()<cr>]], { noremap = true, silent = true })
            end
        }

        -- color schemes
        -- use {
        --     "shaunsingh/nord.nvim",
        --     config = function()
        --         -- vim.g.nord_contrast = true -- make sidebars and popup menus like nvim-tree and telescope have a different background
        --         vim.g.nord_borders = true -- enable the border between verticaly split windows visable
        --         -- vim.g.nord_disable_background = false -- disable the setting of background color so that NeoVim can use your terminal background
        --         -- vim.g.nord_cursorline_transparent = false -- set the cursorline transparent/visible
        --         -- vim.g.nord_enable_sidebar_background = false -- re-enables the backgrond of the sidebar if you disabled the background of everything
        --         vim.g.nord_italic = true -- enables/disables italics
        --         -- vim.cmd("colorscheme nord")
        --     end
        -- }
        use {
            "folke/tokyonight.nvim",
            -- config = function()
            --     -- vim.g.tokyonight_style = "storm" -- storm / night / day
            -- end
        }
        -- use {
        --     "ishan9299/nvim-solarized-lua",
        --     config = function()
        --         -- vim.g.solarized_visibility = "normal" -- low / normal / high -- visibility SpecialChars (like trailing whitespace and tabs) visibility
        --         -- vim.cmd("colorscheme solarized") -- solarized-flat / solarized-low / solarized / solarized-high
        --     end
        -- }
        -- use {
        --     "projekt0n/github-nvim-theme",
        --     config = function()
        --         require('github-theme').setup({
        --             themeStyle = "light", -- dark / dimmed / light
        --         })
        --     end
        -- }
        -- use "pappasam/papercolor-theme-slim"
        -- use { "junegunn/seoul256.vim", config = function()
        --     -- seoul256 (dark):
        --     --   Range:   233 (darkest) ~ 239 (lightest)
        --     --   Default: 237
        --     -- vim.g.seoul256_background = 236

        --     -- seoul256 (light):
        --     --   Range:   252 (darkest) ~ 256 (lightest)
        --     --   Default: 253
        --     -- vim.g.seoul256_background = 252
        --     -- vim.cmd("colorscheme seoul256") -- seoul256 / seoul256-light
        -- end }


        use { "itchyny/lightline.vim", config = function()
            vim.g.lightline = {
                colorscheme = "tokyonight"
                -- colorscheme = "github"
                -- active = { left = { { 'mode', 'paste' }, { 'gitbranch', 'readonly', 'filename', 'modified' } } },
                -- component_function = { gitbranch = 'fugitive#head' },
            }
        end} -- Fancier statusline

        -- file manager
        use {
            'kyazdani42/nvim-tree.lua',
            config = function()
                vim.g.nvim_tree_side = "right"
                vim.g.nvim_tree_width = 50
                vim.g.nvim_tree_follow_update_path = 1
                vim.g.nvim_tree_update_cwd = 1
                vim.api.nvim_set_keymap("n", "<C-n>", ":NvimTreeToggle<CR>", {})
            end,
            requires = 'kyazdani42/nvim-web-devicons',
        }



        -- Highlight, edit, and navigate code using a fast incremental parsing library
        -- use { 'nvim-treesitter/nvim-treesitter', branch = '0.5-compat', config = function()
        use {
            "nvim-treesitter/nvim-treesitter",
            config = function()
                require("nvim-treesitter.configs").setup {
                    highlight = {
                        enable = true -- false will disable the whole extension
                    },
                    incremental_selection = {
                        enable = true,
                        keymaps = {
                            init_selection = "gnn",
                            node_incremental = "grn",
                            scope_incremental = "grc",
                            node_decremental = "grm"
                        }
                    },
                    indent = {
                        enable = true
                    },
                    textobjects = {
                        select = {
                            enable = true,
                            lookahead = true, -- Automatically jump forward to textobj, similar to targets.vim
                            keymaps = {
                                -- You can use the capture groups defined in textobjects.scm
                                ["af"] = "@function.outer",
                                ["if"] = "@function.inner",
                                ["ac"] = "@class.outer",
                                ["ic"] = "@class.inner"
                            }
                        },
                        move = {
                            enable = true,
                            set_jumps = true, -- whether to set jumps in the jumplist
                            goto_next_start = {
                                ["]m"] = "@function.outer",
                                ["]]"] = "@class.outer"
                            },
                            goto_next_end = {
                                ["]M"] = "@function.outer",
                                ["]["] = "@class.outer"
                            },
                            goto_previous_start = {
                                ["[m"] = "@function.outer",
                                ["[["] = "@class.outer"
                            },
                            goto_previous_end = {
                                ["[M"] = "@function.outer",
                                ["[]"] = "@class.outer"
                            }
                        }
                    }
                }
            end
        }
        -- Add git related info in the signs columns and popups
        use {
            "lewis6991/gitsigns.nvim",
            requires = {"nvim-lua/plenary.nvim"},
            event = 'BufRead',
            config = function()
                require("gitsigns").setup {
                    keymaps = {
                        -- Default keymap options
                        buffer = true,
                        noremap = true,
                        ["n ]c"] = {expr = true, '&diff ? \']c\' : \'<cmd>lua require"gitsigns".next_hunk()<CR>\''},
                        ["n [c"] = {expr = true, '&diff ? \'[c\' : \'<cmd>lua require"gitsigns".prev_hunk()<CR>\''},
                        ["n <leader>hs"] = '<cmd>lua require"gitsigns".stage_hunk()<CR>',
                        ["n <leader>hu"] = '<cmd>lua require"gitsigns".undo_stage_hunk()<CR>',
                        ["n <leader>hr"] = '<cmd>lua require"gitsigns".reset_hunk()<CR>',
                        ["n <leader>hp"] = '<cmd>lua require"gitsigns".preview_hunk()<CR>',
                        ["n <leader>hb"] = '<cmd>lua require"gitsigns".blame_line()<CR>'
                    },
                    numhl = false,
                    sign_priority = 5,
                    signs = {
                        add = {hl = "DiffAdd", text = "│", numhl = "GitSignsAddNr"},
                        change = {hl = "DiffChange", text = "│", numhl = "GitSignsChangeNr"},
                        changedelete = {hl = "DiffChange", text = "~", numhl = "GitSignsChangeNr"},
                        delete = {hl = "DiffDelete", text = "_", numhl = "GitSignsDeleteNr"},
                        topdelete = {hl = "DiffDelete", text = "‾", numhl = "GitSignsDeleteNr"}
                    },
                    status_formatter = nil, -- Use default
                    watch_index = {
                        interval = 100
                    }
                }
            end
        }

        -- Additional textobjects for treesitter
        use {
            "nvim-treesitter/nvim-treesitter-textobjects",
            branch = "0.5-compat",
            requires = "nvim-treesitter/nvim-treesitter"
        }

        -- comments for combined syntaxes like jsx / tsx
        use {
            "JoosepAlviste/nvim-ts-context-commentstring",
            requires = {"tpope/vim-commentary", "nvim-treesitter/nvim-treesitter"},
            config = function()
                require "nvim-treesitter.configs".setup {
                    context_commentstring = {
                        enable = true
                    }
                }
            end
        }

        -- Add indentation guides even on blank lines
        use {
            "lukas-reineke/indent-blankline.nvim",
            event = "BufRead",
            after = { "nvim-treesitter", "telescope.nvim" },
            setup = function()
                --Map blankline
                vim.g.indent_blankline_char = "|"
                vim.g.indent_blankline_filetype_exclude = {"help", "packer"}
                vim.g.indent_blankline_buftype_exclude = {"terminal", "nofile"}
                -- g.indent_blankline_char_highlight = 'LineNr'
                -- g.indent_blankline_show_trailing_blankline_indent = false
                vim.api.nvim_command("highlight! link IndentBlanklineChar Conceal")
            end,
            config = function()
                require("indent_blankline").setup {
                    indentLine_enabled = 1,
                    char = "▏",
                    filetype_exclude = {
                        "help",
                        "terminal",
                        "dashboard",
                        "packer",
                        "lspinfo",
                        "TelescopePrompt",
                        "TelescopeResults"
                    },
                    buftype_exclude = {"terminal"},
                    show_trailing_blankline_indent = false,
                    show_first_indent_level = false
                }
            end
        }

        -- snippets
        use {
            'L3MON4D3/LuaSnip',
            -- after = 'nvim-cmp',
        }

        -- completion engine
        use {
            'hrsh7th/nvim-cmp',
            -- event = "BufRead",
            requires = {
                { 'hrsh7th/cmp-buffer' },
                { 'hrsh7th/cmp-nvim-lsp'},
                { 'saadparwaiz1/cmp_luasnip' },
            },
            config = function()
                local cmp = require("cmp")
                if not cmp then
                    return
                end

                local luasnip = require("luasnip")
                if not luasnip then return end
                local lsp_symbols = {
                    Text = "   (Text) ",
                    Method = "   (Method)",
                    Function = "   (Function)",
                    Constructor = "   (Constructor)",
                    Field = " ﴲ  (Field)",
                    Variable = "[] (Variable)",
                    Class = "   (Class)",
                    Interface = " ﰮ  (Interface)",
                    Module = "   (Module)",
                    Property = " 襁 (Property)",
                    Unit = "   (Unit)",
                    Value = "   (Value)",
                    Enum = " 練 (Enum)",
                    Keyword = "   (Keyword)",
                    Snippet = "   (Snippet)",
                    Color = "   (Color)",
                    File = "   (File)",
                    Reference = "   (Reference)",
                    Folder = "   (Folder)",
                    EnumMember = "   (EnumMember)",
                    Constant = " ﲀ  (Constant)",
                    Struct = " ﳤ  (Struct)",
                    Event = "   (Event)",
                    Operator = "   (Operator)",
                    TypeParameter = "   (TypeParameter)",
                }

                cmp.setup({
                    sources = {
                        { name = "buffer" },
                        { name = "nvim_lsp" },
                        { name = "path" },
                        { name = "luasnip" },
                    },
                    -- mapping = {
                    --     ["<cr>"] = cmp.mapping.confirm({select = true}),
                    --     ["<s-tab>"] = cmp.mapping.select_prev_item(),
                    --     ["<tab>"] = cmp.mapping.select_next_item(),
                    -- },
                    mapping = {
                        ["<C-p>"] = cmp.mapping.select_prev_item(),
                        ["<C-n>"] = cmp.mapping.select_next_item(),
                        ["<C-d>"] = cmp.mapping.scroll_docs(-4),
                        ["<C-f>"] = cmp.mapping.scroll_docs(4),
                        ["<C-Space>"] = cmp.mapping.complete(),
                        ["<C-e>"] = cmp.mapping.close(),
                        ["<CR>"] = cmp.mapping.confirm {
                            behavior = cmp.ConfirmBehavior.Replace,
                            select = true
                        },
                        ["<Tab>"] = function(fallback)
                            if vim.fn.pumvisible() == 1 then
                                vim.fn.feedkeys(vim.api.nvim_replace_termcodes("<C-n>", true, true, true), "n")
                            elseif luasnip.expand_or_jumpable() then
                                vim.fn.feedkeys(vim.api.nvim_replace_termcodes("<Plug>luasnip-expand-or-jump", true, true, true), "")
                            else
                                fallback()
                            end
                        end,
                        ["<S-Tab>"] = function(fallback)
                            if vim.fn.pumvisible() == 1 then
                                vim.fn.feedkeys(vim.api.nvim_replace_termcodes("<C-p>", true, true, true), "n")
                            elseif luasnip.jumpable(-1) then
                                vim.fn.feedkeys(vim.api.nvim_replace_termcodes("<Plug>luasnip-jump-prev", true, true, true), "")
                            else
                                fallback()
                            end
                        end
                    },
                    formatting = {
                        format = function(entry, item)
                            item.kind = lsp_symbols[item.kind]
                            item.menu = ({
                                buffer = "[Buffer]",
                                nvim_lsp = "[LSP]",
                                path = "[Path]",
                                luasnip = "[Snippet]",
                            })[entry.source.name]

                            return item
                        end,
                    },
                    snippet = {
                        expand = function(args)
                            luasnip.lsp_expand(args.body)
                        end,
                    },
                })
            end,
        }

        -- lsp

        use {
            "jose-elias-alvarez/null-ls.nvim",
            requires = { "nvim-lua/plenary.nvim"},
        }
        use {"jose-elias-alvarez/nvim-lsp-ts-utils", after = {"null-ls.nvim"} }
        use {
            "ray-x/lsp_signature.nvim",
            after = {"nvim-lspconfig" , "null-ls.nvim" },
            config = function()
                require "lsp_signature".setup()
            end
        }

        use {
            "neovim/nvim-lspconfig",
            after = { "cmp-nvim-lsp", "nvim-lsp-ts-utils" },
            config = function()
                local nvim_lsp = require "lspconfig"

                require("null-ls").config({ debug = false })
                nvim_lsp["null-ls"].setup { debug = false }

                -- replace the default lsp diagnostic symbols
                local function lspSymbol(name, icon)
                    vim.fn.sign_define("LspDiagnosticsSign" .. name, {text = icon, numhl = "LspDiagnosticsDefaul" .. name})
                end

                lspSymbol("Error", "")
                lspSymbol("Information", "")
                lspSymbol("Hint", "")
                lspSymbol("Warning", "")


                local on_attach_default = function(_, bufnr)
                    local border = {
                          {"╭", "FloatBorder"},
                          {"─", "FloatBorder"},
                          {"╮", "FloatBorder"},
                          {"│", "FloatBorder"},
                          {"╯", "FloatBorder"},
                          {"─", "FloatBorder"},
                          {"╰", "FloatBorder"},
                          {"│", "FloatBorder"},
                    }
                    vim.lsp.handlers["textDocument/hover"] =  vim.lsp.with(vim.lsp.handlers.hover, {border = border})
                    vim.lsp.handlers["textDocument/signatureHelp"] =  vim.lsp.with(vim.lsp.handlers.signature_help, {border = border})
                    vim.lsp.handlers['textDocument/publishDiagnostics'] = vim.lsp.with(vim.lsp.diagnostic.on_publish_diagnostics, {
                        virtual_text = false,
                        signs = true,
                        underline = true,
                        update_in_insert = false,
                    })

                    vim.api.nvim_buf_set_option(bufnr, "omnifunc", "v:lua.vim.lsp.omnifunc")

                    -- set mappings only in current buffer with lsp enabled
                    local function buf_set_keymap(...)
                        vim.api.nvim_buf_set_keymap(bufnr, ...)
                    end

                    local opts = {noremap = true, silent = true}

                    -- vim.api.nvim_buf_set_keymap(bufnr, "n", "gD", "<Cmd>lua vim.lsp.buf.declaration()<CR>", opts)
                    -- vim.api.nvim_buf_set_keymap(bufnr, "n", "gd", "<Cmd>lua vim.lsp.buf.definition()<CR>", opts)
                    -- vim.api.nvim_buf_set_keymap(bufnr, "n", "K", "<Cmd>lua vim.lsp.buf.hover()<CR>", opts)
                    -- vim.api.nvim_buf_set_keymap(bufnr, "n", "gi", "<cmd>lua vim.lsp.buf.implementation()<CR>", opts)
                    -- vim.api.nvim_buf_set_keymap(bufnr, "n", "<C-k>", "<cmd>lua vim.lsp.buf.signature_help()<CR>", opts)
                    -- vim.api.nvim_buf_set_keymap(bufnr, "n", "<leader>wa", "<cmd>lua vim.lsp.buf.add_workspace_folder()<CR>", opts)
                    -- vim.api.nvim_buf_set_keymap(bufnr, "n", "<leader>wr", "<cmd>lua vim.lsp.buf.remove_workspace_folder()<CR>", opts)
                    -- vim.api.nvim_buf_set_keymap(
                    --     bufnr,
                    --     "n",
                    --     "<leader>wl",
                    --     "<cmd>lua print(vim.inspect(vim.lsp.buf.list_workspace_folders()))<CR>",
                    --     opts
                    -- )
                    -- vim.api.nvim_buf_set_keymap(bufnr, "n", "<leader>D", "<cmd>lua vim.lsp.buf.type_definition()<CR>", opts)
                    -- vim.api.nvim_buf_set_keymap(bufnr, "n", "<leader>rn", "<cmd>lua vim.lsp.buf.rename()<CR>", opts)
                    -- vim.api.nvim_buf_set_keymap(bufnr, "n", "gr", "<cmd>lua vim.lsp.buf.references()<CR>", opts)
                    -- vim.api.nvim_buf_set_keymap(bufnr, "n", "<leader>ca", "<cmd>lua vim.lsp.buf.code_action()<CR>", opts)
                    -- -- vim.api.nvim_buf_set_keymap(bufnr, 'v', '<leader>ca', '<cmd>lua vim.lsp.buf.range_code_action()<CR>', opts)
                    -- vim.api.nvim_buf_set_keymap(
                    --     bufnr,
                    --     "n",
                    --     "<leader>e",
                    --     "<cmd>lua vim.lsp.diagnostic.show_line_diagnostics()<CR>",
                    --     opts
                    -- )
                    -- vim.api.nvim_buf_set_keymap(bufnr, "n", "[d", "<cmd>lua vim.lsp.diagnostic.goto_prev()<CR>", opts)
                    -- vim.api.nvim_buf_set_keymap(bufnr, "n", "]d", "<cmd>lua vim.lsp.diagnostic.goto_next()<CR>", opts)
                    -- vim.api.nvim_buf_set_keymap(bufnr, "n", "<leader>q", "<cmd>lua vim.lsp.diagnostic.set_loclist()<CR>", opts)

                    buf_set_keymap("n", "gD", "<cmd>lua vim.lsp.buf.declaration()<CR>", opts)
                    buf_set_keymap("n", "gd", "<cmd>lua vim.lsp.buf.definition()<CR>", opts)
                    buf_set_keymap("n", "gi", "<cmd>lua vim.lsp.buf.implementation()<CR>", opts)
                    buf_set_keymap("n", "<leader>wa", "<cmd>lua vim.lsp.buf.add_workspace_folder()<CR>", opts)
                    buf_set_keymap("n", "<leader>wr", "<cmd>lua vim.lsp.buf.remove_workspace_folder()<CR>", opts)
                    buf_set_keymap("n", "<leader>wl", "<cmd>lua print(vim.inspect(vim.lsp.buf.list_workspace_folders()))<CR>", opts)
                    buf_set_keymap("n", "<leader>D", "<cmd>lua vim.lsp.buf.type_definition()<CR>", opts)
                    buf_set_keymap("n", "gr", "<cmd>lua vim.lsp.buf.references()<CR>", opts)
                    buf_set_keymap("n", "<leader>Q", "<cmd>lua vim.lsp.diagnostic.set_loclist()<CR>", opts)
                    buf_set_keymap("n", "<leader>f", "<cmd>lua vim.lsp.buf.formatting()<CR>", opts)

                    buf_set_keymap("n", "gh", "<cmd>Lspsaga lsp_finder<CR>", opts)
                    buf_set_keymap("n", "<leader>ca", "<cmd>Lspsaga code_action<CR>", opts)
                    buf_set_keymap("v", "<leader>ca", "<cmd>Lspsaga range_code_action<CR>", opts)
                    buf_set_keymap("n", "K", "<cmd>Lspsaga hover_doc<CR>", opts)
                    buf_set_keymap("n", "<C-f>", "<cmd>lua require('lspsaga.action').smart_scroll_with_saga(1)<CR>", opts)
                    buf_set_keymap("n", "<C-b>", "<cmd>lua require('lspsaga.action').smart_scroll_with_saga(-1)<CR>", opts)
                    -- buf_set_keymap("n", "gs", "<cmd>Lspsaga signature_help<CR>", opts)
                    buf_set_keymap("n", "<leader>rn", "<cmd>Lspsaga rename<CR>", opts)
                    -- buf_set_keymap("n", "gp", "<cmd>Lspsaga preview_definition<CR>", opts)
                    buf_set_keymap("n", "<leader>cd", "<cmd>Lspsaga show_line_diagnostics<CR>", opts)
                    buf_set_keymap("n", "<leader>cc", "<cmd>Lspsaga show_cursor_diagnostics<CR>", opts)
                    buf_set_keymap("n", "[d", "<cmd>Lspsaga diagnostic_jump_prev<CR>", opts)
                    buf_set_keymap("n", "]d", "<cmd>Lspsaga diagnostic_jump_next<CR>", opts)

                    buf_set_keymap("n", "<leader>so", "<cmd>lua require('telescope.builtin').lsp_document_symbols()<CR>", opts)

                    vim.cmd [[ command! Format execute 'lua vim.lsp.buf.formatting()' ]]
                end

                local on_attach_typescript = function(client, bufnr)
                    -- disable tsserver formatting if you plan on formatting via null-ls
                    client.resolved_capabilities.document_formatting = false
                    client.resolved_capabilities.document_range_formatting = false

                    local ts_utils = require("nvim-lsp-ts-utils")

                    -- defaults
                    ts_utils.setup {
                        debug = false,
                        disable_commands = false,
                        enable_import_on_completion = false,
                        -- import all
                        import_all_timeout = 5000, -- ms
                        import_all_priorities = {
                            buffers = 4, -- loaded buffer names
                            buffer_content = 3, -- loaded buffer content
                            local_files = 2, -- git files or files with relative path markers
                            same_file = 1 -- add to existing import statement
                        },
                        import_all_scan_buffers = 100,
                        import_all_select_source = false,
                        -- eslint
                        eslint_enable_code_actions = true,
                        eslint_enable_disable_comments = true,
                        eslint_bin = "eslint_d",
                        eslint_enable_config_fallback = nil,
                        eslint_enable_diagnostics = true,
                        -- eslint_opts = {},
                        -- formatting
                        enable_formatting = true,
                        formatter = "eslint_d",
                        formatter_config_fallback = nil,
                        -- formatter_opts = {},

                        -- parentheses completion
                        complete_parens = true,
                        signature_help_in_parens = true,
                        -- update imports on file move
                        update_imports_on_move = false,
                        require_confirmation_on_move = false,
                        watch_dir = nil,
                        -- filter diagnostics
                        filter_out_diagnostics_by_severity = {},
                        filter_out_diagnostics_by_code = {}
                    }

                    -- required to fix code action ranges and filter diagnostics
                    ts_utils.setup_client(client)

                    -- no default maps, so you may want to define some here
                    -- local opts = { silent = true }
                    -- vim.api.nvim_buf_set_keymap(bufnr, "n", "gs", ":TSLspOrganize<CR>", opts)
                    -- vim.api.nvim_buf_set_keymap(bufnr, "n", "gr", ":TSLspRenameFile<CR>", opts)
                    vim.api.nvim_buf_set_keymap(bufnr, "n", "gs", ":TSLspOrganize<CR>", {silent = true})
                    vim.api.nvim_buf_set_keymap(bufnr, "n", "gq", ":TSLspFixCurrent<CR>", {silent = true})
                    vim.api.nvim_buf_set_keymap(bufnr, "n", "<leader>rf", ":TSLspRenameFile<CR>", {silent = true})
                    vim.api.nvim_buf_set_keymap(bufnr, "n", "<leader>ia", ":TSLspImportAll<CR>", {silent = true}) -- vim.api.nvim_buf_set_keymap(bufnr, "n", "gi", ":TSLspImportAll<CR>", opts)

                    vim.api.nvim_exec(
                        [[
                        augroup auto_format
                          autocmd!
                          autocmd BufWritePre * lua vim.lsp.buf.formatting_sync(nil, 3000)
                        augroup end
                      ]],
                        false
                    )
                end

                -- nvim-cmp supports additional completion capabilities
                local capabilities = vim.lsp.protocol.make_client_capabilities()
                capabilities = require("cmp_nvim_lsp").update_capabilities(capabilities)

                -- Enable the following language servers
                -- local servers = { 'tsserver', 'jsonls', 'html', 'cssls', 'tailwindcss' }
                -- local servers = { 'tsserver', 'jsonls', 'html', 'cssls' }
                -- local default_servers = {"jsonls", "html", "cssls"}
                -- local default_servers = {"html", "cssls"}
                -- for _, lsp in ipairs(default_servers) do
                --     nvim_lsp[lsp].setup {
                --         on_attach = on_attach_default,
                --         capabilities = capabilities
                --     }
                -- end

                nvim_lsp.html.setup {
                  cmd = { "vscode-html-language-server", "--stdio" },
                  on_attach = on_attach_default,
                  capabilities = capabilities
                }
                nvim_lsp.cssls.setup {
                  cmd = { "vscode-css-language-server", "--stdio" },
                  on_attach = on_attach_default,
                  capabilities = capabilities
                }
                nvim_lsp.jsonls.setup {
                  cmd = { "vscode-json-language-server", "--stdio" },
                  on_attach = on_attach_default,
                  capabilities = capabilities
                }

                nvim_lsp.tsserver.setup {
                    on_attach = function(client, bufnr)
                        on_attach_default(client, bufnr)
                        on_attach_typescript(client, bufnr)
                    end,
                    capabilities = capabilities
                }
            end
        }

        -- great ui for lsp
        use {
            'glepnir/lspsaga.nvim',
            after = 'nvim-lspconfig',
            -- config = function()
            -- end,
        }

        use {"tpope/vim-unimpaired", opt = true} --, event = 'VimEnter'}  -- extra mappings like [q for quickfix navigations
        use {"tpope/vim-repeat",  event = 'BufModifiedSet'  } -- repeat plugin maps as a whole
        use {"tpope/vim-abolish", event = "CmdlineEnter"} -- replace variations of lower/upper case
        use {"machakann/vim-sandwich", event = "BufRead"} --, event = 'CursorMoved' } -- better add, replace, delete surrounds
        use {"ntpeters/vim-better-whitespace", event = "BufRead"} --, event = 'CursorMoved' } -- highlight trailing whitespaces
        use {"tpope/vim-commentary", event = "BufRead"} --, event = 'VimEnter' } -- "gc" to comment visual regions/lines
        use {"jeffkreeftmeijer/vim-numbertoggle", event = "BufRead"} --, event = 'VimEnter' } -- show relative line numbers
        -- TODO: matchup ?
        use {
            "andymass/vim-matchup",
            after = { "nvim-treesitter" },
            config = function()
              require'nvim-treesitter.configs'.setup {
                matchup = {
                  enable = true,
                },
              }
            end
        }
        -- use { 'mhinz/vim-grepper' } --, event = 'CmdlineEnter' } -- find / replace
    end
)