nix/home-manager/common/software/cli/neovim.nix

{ config, pkgs, ... }: {
  programs.neovim = {
    enable = true;
    defaultEditor = true;
    viAlias = true;
    vimAlias = true;
    vimdiffAlias = true;
    plugins = with pkgs.vimPlugins; [
      nvchad
      nvchad-ui
    ];
  };

  # Files for nvchad:
  # I know there are better ways to do this.  Don't judge me.
  home.files.".config/nvim/" = {
    "init.lua".text = ''
      require "core"

      local custom_init_path = vim.api.nvim_get_runtime_file("lua/custom/init.lua", false)[1]

      if custom_init_path then
        dofile(custom_init_path)
      end

      require("core.utils").load_mappings()

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

      -- bootstrap lazy.nvim!
      if not vim.loop.fs_stat(lazypath) then
        require("core.bootstrap").gen_chadrc_template()
        require("core.bootstrap").lazy(lazypath)
      end

      dofile(vim.g.base46_cache .. "defaults")
      vim.opt.rtp:prepend(lazypath)
      require "plugins"
    '';
    "lua/" = {
      "core/" = {
        "bootstrap.lua".text = ''
          local M = {}

          M.echo = function(str)
            vim.cmd "redraw"
            vim.api.nvim_echo({ { str, "Bold" } }, true, {})
          end

          local function shell_call(args)
            local output = vim.fn.system(args)
            assert(vim.v.shell_error == 0, "External call failed with error code: " .. vim.v.shell_error .. "\n" .. output)
          end

          M.lazy = function(install_path)
            ------------- base46 ---------------
            local lazy_path = vim.fn.stdpath "data" .. "/lazy/base46"

            M.echo "  Compiling base46 theme to bytecode ..."

            local base46_repo = "https://github.com/NvChad/base46"
            shell_call { "git", "clone", "--depth", "1", "-b", "v2.0", base46_repo, lazy_path }
            vim.opt.rtp:prepend(lazy_path)

            require("base46").compile()

            --------- lazy.nvim ---------------
            M.echo "  Installing lazy.nvim & plugins ..."
            local repo = "https://github.com/folke/lazy.nvim.git"
            shell_call { "git", "clone", "--filter=blob:none", "--branch=stable", repo, install_path }
            vim.opt.rtp:prepend(install_path)

            -- install plugins
            require "plugins"

            -- mason packages & show post_boostrap screen
            require "nvchad.post_install"()
          end

          M.gen_chadrc_template = function()
            if not vim.api.nvim_get_runtime_file("lua/custom/chadrc.lua", false)[1] then
              local path = vim.fn.stdpath "config" .. "/lua/custom/"
              local input = "N"

              if next(vim.api.nvim_list_uis()) then
                input = vim.fn.input "Do you want to install example custom config? (y/N) : "
              end

              -- clone example_config repo
              if input == "y" then
                M.echo "cloning example custom config repo ..."
                shell_call { "git", "clone", "--depth", "1", "https://github.com/NvChad/example_config", path }
                vim.fn.delete(path .. ".git", "rf")
              else
                -- use very minimal chadrc
                vim.fn.mkdir(path, "p")

                local file = io.open(path .. "chadrc.lua", "w")
                file:write "---@type ChadrcConfig \n local M = {}\n M.ui = {theme = 'onedark'}\n return M"
                file:close()
              end
            end
          end

          return M
        '';
        "default_config.lua".text = ''
          local M = {}

          M.options = {
            nvchad_branch = "v2.0",
          }

          M.ui = {
            ------------------------------- base46 -------------------------------------
            -- hl = highlights
            hl_add = {},
            hl_override = {},
            changed_themes = {},
            theme_toggle = { "onedark", "one_light" },
            theme = "onedark", -- default theme
            transparency = false,
            lsp_semantic_tokens = false, -- needs nvim v0.9, just adds highlight groups for lsp semantic tokens

            -- https://github.com/NvChad/base46/tree/v2.0/lua/base46/extended_integrations
            extended_integrations = {}, -- these aren't compiled by default, ex: "alpha", "notify"

            -- cmp themeing
            cmp = {
              icons = true,
              lspkind_text = true,
              style = "default", -- default/flat_light/flat_dark/atom/atom_colored
              border_color = "grey_fg", -- only applicable for "default" style, use color names from base30 variables
              selected_item_bg = "colored", -- colored / simple
            },

            telescope = { style = "borderless" }, -- borderless / bordered

            ------------------------------- nvchad_ui modules -----------------------------
            statusline = {
              theme = "default", -- default/vscode/vscode_colored/minimal
              -- default/round/block/arrow separators work only for default statusline theme
              -- round and block will work for minimal theme only
              separator_style = "default",
              overriden_modules = nil,
            },

            -- lazyload it when there are 1+ buffers
            tabufline = {
              show_numbers = false,
              enabled = true,
              lazyload = true,
              overriden_modules = nil,
            },

            -- nvdash (dashboard)
            nvdash = {
              load_on_startup = false,

              header = {
                "           ▄ ▄                   ",
                "       ▄   ▄▄▄     ▄ ▄▄▄ ▄ ▄     ",
                "       █ ▄ █▄█ ▄▄▄ █ █▄█ █ █     ",
                "    ▄▄ █▄█▄▄▄█ █▄█▄█▄▄█▄▄█ █     ",
                "  ▄ █▄▄█ ▄ ▄▄ ▄█ ▄▄▄▄▄▄▄▄▄▄▄▄▄▄  ",
                "  █▄▄▄▄ ▄▄▄ █ ▄ ▄▄▄ ▄ ▄▄▄ ▄ ▄ █ ▄",
                "▄ █ █▄█ █▄█ █ █ █▄█ █ █▄█ ▄▄▄ █ █",
                "█▄█ ▄ █▄▄█▄▄█ █ ▄▄█ █ ▄ █ █▄█▄█ █",
                "    █▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█ █▄█▄▄▄█    ",
              },

              buttons = {
                { "  Find File", "Spc f f", "Telescope find_files" },
                { "󰈚  Recent Files", "Spc f o", "Telescope oldfiles" },
                { "󰈭  Find Word", "Spc f w", "Telescope live_grep" },
                { "  Bookmarks", "Spc m a", "Telescope marks" },
                { "  Themes", "Spc t h", "Telescope themes" },
                { "  Mappings", "Spc c h", "NvCheatsheet" },
              },
            },

            cheatsheet = { theme = "grid" }, -- simple/grid

            lsp = {
              -- show function signatures i.e args as you type
              signature = {
                disabled = false,
                silent = true, -- silences 'no signature help available' message from appearing
              },
            },
          }

          M.plugins = "" -- path i.e "custom.plugins", so make custom/plugins.lua file

          M.lazy_nvim = require "plugins.configs.lazy_nvim" -- config for lazy.nvim startup options

          M.mappings = require "core.mappings"

          return M
        '';
        "init.lua".text = ''
          local opt = vim.opt
          local g = vim.g
          local config = require("core.utils").load_config()

          -------------------------------------- globals -----------------------------------------
          g.nvchad_theme = config.ui.theme
          g.base46_cache = vim.fn.stdpath "data" .. "/nvchad/base46/"
          g.toggle_theme_icon = "   "
          g.transparency = config.ui.transparency

          -------------------------------------- options ------------------------------------------
          opt.laststatus = 3 -- global statusline
          opt.showmode = false

          opt.clipboard = "unnamedplus"
          opt.cursorline = true

          -- Indenting
          opt.expandtab = true
          opt.shiftwidth = 2
          opt.smartindent = true
          opt.tabstop = 2
          opt.softtabstop = 2

          opt.fillchars = { eob = " " }
          opt.ignorecase = true
          opt.smartcase = true
          opt.mouse = "a"

          -- Numbers
          opt.number = true
          opt.numberwidth = 2
          opt.ruler = false

          -- disable nvim intro
          opt.shortmess:append "sI"

          opt.signcolumn = "yes"
          opt.splitbelow = true
          opt.splitright = true
          opt.termguicolors = true
          opt.timeoutlen = 400
          opt.undofile = true

          -- interval for writing swap file to disk, also used by gitsigns
          opt.updatetime = 250

          -- go to previous/next line with h,l,left arrow and right arrow
          -- when cursor reaches end/beginning of line
          opt.whichwrap:append "<>[]hl"

          g.mapleader = " "

          -- disable some default providers
          for _, provider in ipairs { "node", "perl", "python3", "ruby" } do
            vim.g["loaded_" .. provider .. "_provider"] = 0
          end

          -- add binaries installed by mason.nvim to path
          local is_windows = vim.loop.os_uname().sysname == "Windows_NT"
          vim.env.PATH = vim.fn.stdpath "data" .. "/mason/bin" .. (is_windows and ";" or ":") .. vim.env.PATH

          -------------------------------------- autocmds ------------------------------------------
          local autocmd = vim.api.nvim_create_autocmd

          -- dont list quickfix buffers
          autocmd("FileType", {
            pattern = "qf",
            callback = function()
              vim.opt_local.buflisted = false
            end,
          })

          -- reload some chadrc options on-save
          autocmd("BufWritePost", {
            pattern = vim.tbl_map(function(path)
              return vim.fs.normalize(vim.loop.fs_realpath(path))
            end, vim.fn.glob(vim.fn.stdpath "config" .. "/lua/custom/**/*.lua", true, true, true)),
            group = vim.api.nvim_create_augroup("ReloadNvChad", {}),

            callback = function(opts)
              local fp = vim.fn.fnamemodify(vim.fs.normalize(vim.api.nvim_buf_get_name(opts.buf)), ":r") --[[@as string]]
              local app_name = vim.env.NVIM_APPNAME and vim.env.NVIM_APPNAME or "nvim"
              local module = string.gsub(fp, "^.*/" .. app_name .. "/lua/", ""):gsub("/", ".")

              require("plenary.reload").reload_module "base46"
              require("plenary.reload").reload_module(module)
              require("plenary.reload").reload_module "custom.chadrc"

              config = require("core.utils").load_config()

              vim.g.nvchad_theme = config.ui.theme
              vim.g.transparency = config.ui.transparency

              -- statusline
              require("plenary.reload").reload_module("nvchad.statusline." .. config.ui.statusline.theme)
              vim.opt.statusline = "%!v:lua.require('nvchad.statusline." .. config.ui.statusline.theme .. "').run()"

              -- tabufline
              if config.ui.tabufline.enabled then
                require("plenary.reload").reload_module "nvchad.tabufline.modules"
                vim.opt.tabline = "%!v:lua.require('nvchad.tabufline.modules').run()"
              end

              require("base46").load_all_highlights()
              -- vim.cmd("redraw!")
            end,
          })

          -------------------------------------- commands ------------------------------------------
          local new_cmd = vim.api.nvim_create_user_command

          new_cmd("NvChadUpdate", function()
            require "nvchad.updater"()
          end, {})
        '';
        "mappings.lua".text = ''
          -- n, v, i, t = mode names

          local M = {}

          M.general = {
            i = {
              -- go to  beginning and end
              ["<C-b>"] = { "<ESC>^i", "Beginning of line" },
              ["<C-e>"] = { "<End>", "End of line" },

              -- navigate within insert mode
              ["<C-h>"] = { "<Left>", "Move left" },
              ["<C-l>"] = { "<Right>", "Move right" },
              ["<C-j>"] = { "<Down>", "Move down" },
              ["<C-k>"] = { "<Up>", "Move up" },
            },

            n = {
              ["<Esc>"] = { ":noh <CR>", "Clear highlights" },
              -- switch between windows
              ["<C-h>"] = { "<C-w>h", "Window left" },
              ["<C-l>"] = { "<C-w>l", "Window right" },
              ["<C-j>"] = { "<C-w>j", "Window down" },
              ["<C-k>"] = { "<C-w>k", "Window up" },

              -- save
              ["<C-s>"] = { "<cmd> w <CR>", "Save file" },

              -- Copy all
              ["<C-c>"] = { "<cmd> %y+ <CR>", "Copy whole file" },

              -- line numbers
              ["<leader>n"] = { "<cmd> set nu! <CR>", "Toggle line number" },
              ["<leader>rn"] = { "<cmd> set rnu! <CR>", "Toggle relative number" },

              -- Allow moving the cursor through wrapped lines with j, k, <Up> and <Down>
              -- http://www.reddit.com/r/vim/comments/2k4cbr/problem_with_gj_and_gk/
              -- empty mode is same as using <cmd> :map
              -- also don't use g[j|k] when in operator pending mode, so it doesn't alter d, y or c behaviour
              ["j"] = { 'v:count || mode(1)[0:1] == "no" ? "j" : "gj"', "Move down", opts = { expr = true } },
              ["k"] = { 'v:count || mode(1)[0:1] == "no" ? "k" : "gk"', "Move up", opts = { expr = true } },
              ["<Up>"] = { 'v:count || mode(1)[0:1] == "no" ? "k" : "gk"', "Move up", opts = { expr = true } },
              ["<Down>"] = { 'v:count || mode(1)[0:1] == "no" ? "j" : "gj"', "Move down", opts = { expr = true } },

              -- new buffer
              ["<leader>b"] = { "<cmd> enew <CR>", "New buffer" },
              ["<leader>ch"] = { "<cmd> NvCheatsheet <CR>", "Mapping cheatsheet" },

              ["<leader>fm"] = {
                function()
                  vim.lsp.buf.format { async = true }
                end,
                "LSP formatting",
              },
            },

            t = {
              ["<C-x>"] = { vim.api.nvim_replace_termcodes("<C-\\><C-N>", true, true, true), "Escape terminal mode" },
            },

            v = {
              ["<Up>"] = { 'v:count || mode(1)[0:1] == "no" ? "k" : "gk"', "Move up", opts = { expr = true } },
              ["<Down>"] = { 'v:count || mode(1)[0:1] == "no" ? "j" : "gj"', "Move down", opts = { expr = true } },
            },

            x = {
              ["j"] = { 'v:count || mode(1)[0:1] == "no" ? "j" : "gj"', "Move down", opts = { expr = true } },
              ["k"] = { 'v:count || mode(1)[0:1] == "no" ? "k" : "gk"', "Move up", opts = { expr = true } },
              -- Don't copy the replaced text after pasting in visual mode
              -- https://vim.fandom.com/wiki/Replace_a_word_with_yanked_text#Alternative_mapping_for_paste
              ["p"] = { 'p:let @+=@0<CR>:let @"=@0<CR>', "Dont copy replaced text", opts = { silent = true } },
            },
          }

          M.tabufline = {
            plugin = true,

            n = {
              -- cycle through buffers
              ["<tab>"] = {
                function()
                  require("nvchad.tabufline").tabuflineNext()
                end,
                "Goto next buffer",
              },

              ["<S-tab>"] = {
                function()
                  require("nvchad.tabufline").tabuflinePrev()
                end,
                "Goto prev buffer",
              },

              -- close buffer + hide terminal buffer
              ["<leader>x"] = {
                function()
                  require("nvchad.tabufline").close_buffer()
                end,
                "Close buffer",
              },
            },
          }

          M.comment = {
            plugin = true,

            -- toggle comment in both modes
            n = {
              ["<leader>/"] = {
                function()
                  require("Comment.api").toggle.linewise.current()
                end,
                "Toggle comment",
              },
            },

            v = {
              ["<leader>/"] = {
                "<ESC><cmd>lua require('Comment.api').toggle.linewise(vim.fn.visualmode())<CR>",
                "Toggle comment",
              },
            },
          }

          M.lspconfig = {
            plugin = true,

            -- See `<cmd> :help vim.lsp.*` for documentation on any of the below functions

            n = {
              ["gD"] = {
                function()
                  vim.lsp.buf.declaration()
                end,
                "LSP declaration",
              },

              ["gd"] = {
                function()
                  vim.lsp.buf.definition()
                end,
                "LSP definition",
              },

              ["K"] = {
                function()
                  vim.lsp.buf.hover()
                end,
                "LSP hover",
              },

              ["gi"] = {
                function()
                  vim.lsp.buf.implementation()
                end,
                "LSP implementation",
              },

              ["<leader>ls"] = {
                function()
                  vim.lsp.buf.signature_help()
                end,
                "LSP signature help",
              },

              ["<leader>D"] = {
                function()
                  vim.lsp.buf.type_definition()
                end,
                "LSP definition type",
              },

              ["<leader>ra"] = {
                function()
                  require("nvchad.renamer").open()
                end,
                "LSP rename",
              },

              ["<leader>ca"] = {
                function()
                  vim.lsp.buf.code_action()
                end,
                "LSP code action",
              },

              ["gr"] = {
                function()
                  vim.lsp.buf.references()
                end,
                "LSP references",
              },

              ["<leader>f"] = {
                function()
                  vim.diagnostic.open_float { border = "rounded" }
                end,
                "Floating diagnostic",
              },

              ["[d"] = {
                function()
                  vim.diagnostic.goto_prev { float = { border = "rounded" } }
                end,
                "Goto prev",
              },

              ["]d"] = {
                function()
                  vim.diagnostic.goto_next { float = { border = "rounded" } }
                end,
                "Goto next",
              },

              ["<leader>q"] = {
                function()
                  vim.diagnostic.setloclist()
                end,
                "Diagnostic setloclist",
              },

              ["<leader>wa"] = {
                function()
                  vim.lsp.buf.add_workspace_folder()
                end,
                "Add workspace folder",
              },

              ["<leader>wr"] = {
                function()
                  vim.lsp.buf.remove_workspace_folder()
                end,
                "Remove workspace folder",
              },

              ["<leader>wl"] = {
                function()
                  print(vim.inspect(vim.lsp.buf.list_workspace_folders()))
                end,
                "List workspace folders",
              },
            },
          }

          M.nvimtree = {
            plugin = true,

            n = {
              -- toggle
              ["<C-n>"] = { "<cmd> NvimTreeToggle <CR>", "Toggle nvimtree" },

              -- focus
              ["<leader>e"] = { "<cmd> NvimTreeFocus <CR>", "Focus nvimtree" },
            },
          }

          M.telescope = {
            plugin = true,

            n = {
              -- find
              ["<leader>ff"] = { "<cmd> Telescope find_files <CR>", "Find files" },
              ["<leader>fa"] = { "<cmd> Telescope find_files follow=true no_ignore=true hidden=true <CR>", "Find all" },
              ["<leader>fw"] = { "<cmd> Telescope live_grep <CR>", "Live grep" },
              ["<leader>fb"] = { "<cmd> Telescope buffers <CR>", "Find buffers" },
              ["<leader>fh"] = { "<cmd> Telescope help_tags <CR>", "Help page" },
              ["<leader>fo"] = { "<cmd> Telescope oldfiles <CR>", "Find oldfiles" },
              ["<leader>fz"] = { "<cmd> Telescope current_buffer_fuzzy_find <CR>", "Find in current buffer" },

              -- git
              ["<leader>cm"] = { "<cmd> Telescope git_commits <CR>", "Git commits" },
              ["<leader>gt"] = { "<cmd> Telescope git_status <CR>", "Git status" },

              -- pick a hidden term
              ["<leader>pt"] = { "<cmd> Telescope terms <CR>", "Pick hidden term" },

              -- theme switcher
              ["<leader>th"] = { "<cmd> Telescope themes <CR>", "Nvchad themes" },

              ["<leader>ma"] = { "<cmd> Telescope marks <CR>", "telescope bookmarks" },
            },
          }

          M.nvterm = {
            plugin = true,

            t = {
              -- toggle in terminal mode
              ["<A-i>"] = {
                function()
                  require("nvterm.terminal").toggle "float"
                end,
                "Toggle floating term",
              },

              ["<A-h>"] = {
                function()
                  require("nvterm.terminal").toggle "horizontal"
                end,
                "Toggle horizontal term",
              },

              ["<A-v>"] = {
                function()
                  require("nvterm.terminal").toggle "vertical"
                end,
                "Toggle vertical term",
              },
            },

            n = {
              -- toggle in normal mode
              ["<A-i>"] = {
                function()
                  require("nvterm.terminal").toggle "float"
                end,
                "Toggle floating term",
              },

              ["<A-h>"] = {
                function()
                  require("nvterm.terminal").toggle "horizontal"
                end,
                "Toggle horizontal term",
              },

              ["<A-v>"] = {
                function()
                  require("nvterm.terminal").toggle "vertical"
                end,
                "Toggle vertical term",
              },

              -- new
              ["<leader>h"] = {
                function()
                  require("nvterm.terminal").new "horizontal"
                end,
                "New horizontal term",
              },

              ["<leader>v"] = {
                function()
                  require("nvterm.terminal").new "vertical"
                end,
                "New vertical term",
              },
            },
          }

          M.whichkey = {
            plugin = true,

            n = {
              ["<leader>wK"] = {
                function()
                  vim.cmd "WhichKey"
                end,
                "Which-key all keymaps",
              },
              ["<leader>wk"] = {
                function()
                  local input = vim.fn.input "WhichKey: "
                  vim.cmd("WhichKey " .. input)
                end,
                "Which-key query lookup",
              },
            },
          }

          M.blankline = {
            plugin = true,

            n = {
              ["<leader>cc"] = {
                function()
                  local ok, start = require("indent_blankline.utils").get_current_context(
                    vim.g.indent_blankline_context_patterns,
                    vim.g.indent_blankline_use_treesitter_scope
                  )

                  if ok then
                    vim.api.nvim_win_set_cursor(vim.api.nvim_get_current_win(), { start, 0 })
                    vim.cmd [[normal! _]]
                  end
                end,

                "Jump to current context",
              },
            },
          }

          M.gitsigns = {
            plugin = true,

            n = {
              -- Navigation through hunks
              ["]c"] = {
                function()
                  if vim.wo.diff then
                    return "]c"
                  end
                  vim.schedule(function()
                    require("gitsigns").next_hunk()
                  end)
                  return "<Ignore>"
                end,
                "Jump to next hunk",
                opts = { expr = true },
              },

              ["[c"] = {
                function()
                  if vim.wo.diff then
                    return "[c"
                  end
                  vim.schedule(function()
                    require("gitsigns").prev_hunk()
                  end)
                  return "<Ignore>"
                end,
                "Jump to prev hunk",
                opts = { expr = true },
              },

              -- Actions
              ["<leader>rh"] = {
                function()
                  require("gitsigns").reset_hunk()
                end,
                "Reset hunk",
              },

              ["<leader>ph"] = {
                function()
                  require("gitsigns").preview_hunk()
                end,
                "Preview hunk",
              },

              ["<leader>gb"] = {
                function()
                  package.loaded.gitsigns.blame_line()
                end,
                "Blame line",
              },

              ["<leader>td"] = {
                function()
                  require("gitsigns").toggle_deleted()
                end,
                "Toggle deleted",
              },
            },
          }

          return M
        '';
        "utils.lua".text = ''
          local M = {}
          local merge_tb = vim.tbl_deep_extend

          M.load_config = function()
            local config = require "core.default_config"
            local chadrc_path = vim.api.nvim_get_runtime_file("lua/custom/chadrc.lua", false)[1]

            if chadrc_path then
              local chadrc = dofile(chadrc_path)

              config.mappings = M.remove_disabled_keys(chadrc.mappings, config.mappings)
              config = merge_tb("force", config, chadrc)
              config.mappings.disabled = nil
            end

            return config
          end

          M.remove_disabled_keys = function(chadrc_mappings, default_mappings)
            if not chadrc_mappings then
              return default_mappings
            end

            -- store keys in a array with true value to compare
            local keys_to_disable = {}
            for _, mappings in pairs(chadrc_mappings) do
              for mode, section_keys in pairs(mappings) do
                if not keys_to_disable[mode] then
                  keys_to_disable[mode] = {}
                end
                section_keys = (type(section_keys) == "table" and section_keys) or {}
                for k, _ in pairs(section_keys) do
                  keys_to_disable[mode][k] = true
                end
              end
            end

            -- make a copy as we need to modify default_mappings
            for section_name, section_mappings in pairs(default_mappings) do
              for mode, mode_mappings in pairs(section_mappings) do
                mode_mappings = (type(mode_mappings) == "table" and mode_mappings) or {}
                for k, _ in pairs(mode_mappings) do
                  -- if key if found then remove from default_mappings
                  if keys_to_disable[mode] and keys_to_disable[mode][k] then
                    default_mappings[section_name][mode][k] = nil
                  end
                end
              end
            end

            return default_mappings
          end

          M.load_mappings = function(section, mapping_opt)
            vim.schedule(function()
              local function set_section_map(section_values)
                if section_values.plugin then
                  return
                end

                section_values.plugin = nil

                for mode, mode_values in pairs(section_values) do
                  local default_opts = merge_tb("force", { mode = mode }, mapping_opt or {})
                  for keybind, mapping_info in pairs(mode_values) do
                    -- merge default + user opts
                    local opts = merge_tb("force", default_opts, mapping_info.opts or {})

                    mapping_info.opts, opts.mode = nil, nil
                    opts.desc = mapping_info[2]

                    vim.keymap.set(mode, keybind, mapping_info[1], opts)
                  end
                end
              end

              local mappings = require("core.utils").load_config().mappings

              if type(section) == "string" then
                mappings[section]["plugin"] = nil
                mappings = { mappings[section] }
              end

              for _, sect in pairs(mappings) do
                set_section_map(sect)
              end
            end)
          end

          M.lazy_load = function(plugin)
            vim.api.nvim_create_autocmd({ "BufRead", "BufWinEnter", "BufNewFile" }, {
              group = vim.api.nvim_create_augroup("BeLazyOnFileOpen" .. plugin, {}),
              callback = function()
                local file = vim.fn.expand "%"
                local condition = file ~= "NvimTree_1" and file ~= "[lazy]" and file ~= ""

                if condition then
                  vim.api.nvim_del_augroup_by_name("BeLazyOnFileOpen" .. plugin)

                  -- dont defer for treesitter as it will show slow highlighting
                  -- This deferring only happens only when we do "nvim filename"
                  if plugin ~= "nvim-treesitter" then
                    vim.schedule(function()
                      require("lazy").load { plugins = plugin }

                      if plugin == "nvim-lspconfig" then
                        vim.cmd "silent! do FileType"
                      end
                    end, 0)
                  else
                    require("lazy").load { plugins = plugin }
                  end
                end
              end,
            })
          end

          return M
        '';
      };
      "plugins/init.lua".text = ''
        -- All plugins have lazy=true by default,to load a plugin on startup just lazy=false
        -- List of all default plugins & their definitions
        local default_plugins = {

          "nvim-lua/plenary.nvim",

          {
            "NvChad/base46",
            branch = "v2.0",
            build = function()
              require("base46").load_all_highlights()
            end,
          },

          {
            "NvChad/ui",
            branch = "v2.0",
            lazy = false,
          },

          {
            "NvChad/nvterm",
            init = function()
              require("core.utils").load_mappings "nvterm"
            end,
            config = function(_, opts)
              require "base46.term"
              require("nvterm").setup(opts)
            end,
          },

          {
            "NvChad/nvim-colorizer.lua",
            init = function()
              require("core.utils").lazy_load "nvim-colorizer.lua"
            end,
            config = function(_, opts)
              require("colorizer").setup(opts)

              -- execute colorizer as soon as possible
              vim.defer_fn(function()
                require("colorizer").attach_to_buffer(0)
              end, 0)
            end,
          },

          {
            "nvim-tree/nvim-web-devicons",
            opts = function()
              return { override = require "nvchad.icons.devicons" }
            end,
            config = function(_, opts)
              dofile(vim.g.base46_cache .. "devicons")
              require("nvim-web-devicons").setup(opts)
            end,
          },

          {
            "lukas-reineke/indent-blankline.nvim",
            version = "2.20.7",
            init = function()
              require("core.utils").lazy_load "indent-blankline.nvim"
            end,
            opts = function()
              return require("plugins.configs.others").blankline
            end,
            config = function(_, opts)
              require("core.utils").load_mappings "blankline"
              dofile(vim.g.base46_cache .. "blankline")
              require("indent_blankline").setup(opts)
            end,
          },

          {
            "nvim-treesitter/nvim-treesitter",
            init = function()
              require("core.utils").lazy_load "nvim-treesitter"
            end,
            cmd = { "TSInstall", "TSBufEnable", "TSBufDisable", "TSModuleInfo" },
            build = ":TSUpdate",
            opts = function()
              return require "plugins.configs.treesitter"
            end,
            config = function(_, opts)
              dofile(vim.g.base46_cache .. "syntax")
              require("nvim-treesitter.configs").setup(opts)
            end,
          },

          -- git stuff
          {
            "lewis6991/gitsigns.nvim",
            ft = { "gitcommit", "diff" },
            init = function()
              -- load gitsigns only when a git file is opened
              vim.api.nvim_create_autocmd({ "BufRead" }, {
                group = vim.api.nvim_create_augroup("GitSignsLazyLoad", { clear = true }),
                callback = function()
                  vim.fn.system("git -C " .. '"' .. vim.fn.expand "%:p:h" .. '"' .. " rev-parse")
                  if vim.v.shell_error == 0 then
                    vim.api.nvim_del_augroup_by_name "GitSignsLazyLoad"
                    vim.schedule(function()
                      require("lazy").load { plugins = { "gitsigns.nvim" } }
                    end)
                  end
                end,
              })
            end,
            opts = function()
              return require("plugins.configs.others").gitsigns
            end,
            config = function(_, opts)
              dofile(vim.g.base46_cache .. "git")
              require("gitsigns").setup(opts)
            end,
          },

          -- lsp stuff
          {
            "williamboman/mason.nvim",
            cmd = { "Mason", "MasonInstall", "MasonInstallAll", "MasonUninstall", "MasonUninstallAll", "MasonLog" },
            opts = function()
              return require "plugins.configs.mason"
            end,
            config = function(_, opts)
              dofile(vim.g.base46_cache .. "mason")
              require("mason").setup(opts)

              -- custom nvchad cmd to install all mason binaries listed
              vim.api.nvim_create_user_command("MasonInstallAll", function()
                vim.cmd("MasonInstall " .. table.concat(opts.ensure_installed, " "))
              end, {})

              vim.g.mason_binaries_list = opts.ensure_installed
            end,
          },

          {
            "neovim/nvim-lspconfig",
            init = function()
              require("core.utils").lazy_load "nvim-lspconfig"
            end,
            config = function()
              require "plugins.configs.lspconfig"
            end,
          },

          -- load luasnips + cmp related in insert mode only
          {
            "hrsh7th/nvim-cmp",
            event = "InsertEnter",
            dependencies = {
              {
                -- snippet plugin
                "L3MON4D3/LuaSnip",
                dependencies = "rafamadriz/friendly-snippets",
                opts = { history = true, updateevents = "TextChanged,TextChangedI" },
                config = function(_, opts)
                  require("plugins.configs.others").luasnip(opts)
                end,
              },

              -- autopairing of (){}[] etc
              {
                "windwp/nvim-autopairs",
                opts = {
                  fast_wrap = {},
                  disable_filetype = { "TelescopePrompt", "vim" },
                },
                config = function(_, opts)
                  require("nvim-autopairs").setup(opts)

                  -- setup cmp for autopairs
                  local cmp_autopairs = require "nvim-autopairs.completion.cmp"
                  require("cmp").event:on("confirm_done", cmp_autopairs.on_confirm_done())
                end,
              },

              -- cmp sources plugins
              {
                "saadparwaiz1/cmp_luasnip",
                "hrsh7th/cmp-nvim-lua",
                "hrsh7th/cmp-nvim-lsp",
                "hrsh7th/cmp-buffer",
                "hrsh7th/cmp-path",
              },
            },
            opts = function()
              return require "plugins.configs.cmp"
            end,
            config = function(_, opts)
              require("cmp").setup(opts)
            end,
          },

          {
            "numToStr/Comment.nvim",
            keys = {
              { "gcc", mode = "n", desc = "Comment toggle current line" },
              { "gc", mode = { "n", "o" }, desc = "Comment toggle linewise" },
              { "gc", mode = "x", desc = "Comment toggle linewise (visual)" },
              { "gbc", mode = "n", desc = "Comment toggle current block" },
              { "gb", mode = { "n", "o" }, desc = "Comment toggle blockwise" },
              { "gb", mode = "x", desc = "Comment toggle blockwise (visual)" },
            },
            init = function()
              require("core.utils").load_mappings "comment"
            end,
            config = function(_, opts)
              require("Comment").setup(opts)
            end,
          },

          -- file managing , picker etc
          {
            "nvim-tree/nvim-tree.lua",
            cmd = { "NvimTreeToggle", "NvimTreeFocus" },
            init = function()
              require("core.utils").load_mappings "nvimtree"
            end,
            opts = function()
              return require "plugins.configs.nvimtree"
            end,
            config = function(_, opts)
              dofile(vim.g.base46_cache .. "nvimtree")
              require("nvim-tree").setup(opts)
            end,
          },

          {
            "nvim-telescope/telescope.nvim",
            dependencies = "nvim-treesitter/nvim-treesitter",
            cmd = "Telescope",
            init = function()
              require("core.utils").load_mappings "telescope"
            end,
            opts = function()
              return require "plugins.configs.telescope"
            end,
            config = function(_, opts)
              dofile(vim.g.base46_cache .. "telescope")
              local telescope = require "telescope"
              telescope.setup(opts)

              -- load extensions
              for _, ext in ipairs(opts.extensions_list) do
                telescope.load_extension(ext)
              end
            end,
          },

          -- Only load whichkey after all the gui
          {
            "folke/which-key.nvim",
            keys = { "<leader>", "<c-r>", '"', "'", "`", "c", "v", "g" },
            init = function()
              require("core.utils").load_mappings "whichkey"
            end,
            cmd = "WhichKey",
            config = function(_, opts)
              dofile(vim.g.base46_cache .. "whichkey")
              require("which-key").setup(opts)
            end,
          },
        }

        local config = require("core.utils").load_config()

        if #config.plugins > 0 then
          table.insert(default_plugins, { import = config.plugins })
        end

        require("lazy").setup(default_plugins, config.lazy_nvim)
      '';
      "plugins/configs/" = {
        "cmp.lua".text = ''
          local cmp = require "cmp"

          dofile(vim.g.base46_cache .. "cmp")

          local cmp_ui = require("core.utils").load_config().ui.cmp
          local cmp_style = cmp_ui.style

          local field_arrangement = {
            atom = { "kind", "abbr", "menu" },
            atom_colored = { "kind", "abbr", "menu" },
          }

          local formatting_style = {
            -- default fields order i.e completion word + item.kind + item.kind icons
            fields = field_arrangement[cmp_style] or { "abbr", "kind", "menu" },

            format = function(_, item)
              local icons = require "nvchad.icons.lspkind"
              local icon = (cmp_ui.icons and icons[item.kind]) or ""

              if cmp_style == "atom" or cmp_style == "atom_colored" then
                icon = " " .. icon .. " "
                item.menu = cmp_ui.lspkind_text and "   (" .. item.kind .. ")" or ""
                item.kind = icon
              else
                icon = cmp_ui.lspkind_text and (" " .. icon .. " ") or icon
                item.kind = string.format("%s %s", icon, cmp_ui.lspkind_text and item.kind or "")
              end

              return item
            end,
          }

          local function border(hl_name)
            return {
              { "╭", hl_name },
              { "─", hl_name },
              { "╮", hl_name },
              { "│", hl_name },
              { "╯", hl_name },
              { "─", hl_name },
              { "╰", hl_name },
              { "│", hl_name },
            }
          end

          local options = {
            completion = {
              completeopt = "menu,menuone",
            },

            window = {
              completion = {
                side_padding = (cmp_style ~= "atom" and cmp_style ~= "atom_colored") and 1 or 0,
                winhighlight = "Normal:CmpPmenu,CursorLine:CmpSel,Search:PmenuSel",
                scrollbar = false,
              },
              documentation = {
                border = border "CmpDocBorder",
                winhighlight = "Normal:CmpDoc",
              },
            },
            snippet = {
              expand = function(args)
                require("luasnip").lsp_expand(args.body)
              end,
            },

            formatting = formatting_style,

            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.Insert,
                select = true,
              },
              ["<Tab>"] = cmp.mapping(function(fallback)
                if cmp.visible() then
                  cmp.select_next_item()
                elseif require("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, {
                "i",
                "s",
              }),
              ["<S-Tab>"] = cmp.mapping(function(fallback)
                if cmp.visible() then
                  cmp.select_prev_item()
                elseif require("luasnip").jumpable(-1) then
                  vim.fn.feedkeys(vim.api.nvim_replace_termcodes("<Plug>luasnip-jump-prev", true, true, true), "")
                else
                  fallback()
                end
              end, {
                "i",
                "s",
              }),
            },
            sources = {
              { name = "nvim_lsp" },
              { name = "luasnip" },
              { name = "buffer" },
              { name = "nvim_lua" },
              { name = "path" },
            },
          }

          if cmp_style ~= "atom" and cmp_style ~= "atom_colored" then
            options.window.completion.border = border "CmpBorder"
          end

          return options
        '';
        "lazy_nvim.lua".text = ''
          return {
            defaults = { lazy = true },
            install = { colorscheme = { "nvchad" } },

            ui = {
              icons = {
                ft = "",
                lazy = "󰂠 ",
                loaded = "",
                not_loaded = "",
              },
            },

            performance = {
              rtp = {
                disabled_plugins = {
                  "2html_plugin",
                  "tohtml",
                  "getscript",
                  "getscriptPlugin",
                  "gzip",
                  "logipat",
                  "netrw",
                  "netrwPlugin",
                  "netrwSettings",
                  "netrwFileHandlers",
                  "matchit",
                  "tar",
                  "tarPlugin",
                  "rrhelper",
                  "spellfile_plugin",
                  "vimball",
                  "vimballPlugin",
                  "zip",
                  "zipPlugin",
                  "tutor",
                  "rplugin",
                  "syntax",
                  "synmenu",
                  "optwin",
                  "compiler",
                  "bugreport",
                  "ftplugin",
                },
              },
            },
          }
        '';
        "lspconfig.lua".text = ''
          dofile(vim.g.base46_cache .. "lsp")
          require "nvchad.lsp"

          local M = {}
          local utils = require "core.utils"

          -- export on_attach & capabilities for custom lspconfigs

          M.on_attach = function(client, bufnr)
            client.server_capabilities.documentFormattingProvider = false
            client.server_capabilities.documentRangeFormattingProvider = false

            utils.load_mappings("lspconfig", { buffer = bufnr })

            if client.server_capabilities.signatureHelpProvider then
              require("nvchad.signature").setup(client)
            end

            if not utils.load_config().ui.lsp_semantic_tokens and client.supports_method "textDocument/semanticTokens" then
              client.server_capabilities.semanticTokensProvider = nil
            end
          end

          M.capabilities = vim.lsp.protocol.make_client_capabilities()

          M.capabilities.textDocument.completion.completionItem = {
            documentationFormat = { "markdown", "plaintext" },
            snippetSupport = true,
            preselectSupport = true,
            insertReplaceSupport = true,
            labelDetailsSupport = true,
            deprecatedSupport = true,
            commitCharactersSupport = true,
            tagSupport = { valueSet = { 1 } },
            resolveSupport = {
              properties = {
                "documentation",
                "detail",
                "additionalTextEdits",
              },
            },
          }

          require("lspconfig").lua_ls.setup {
            on_attach = M.on_attach,
            capabilities = M.capabilities,

            settings = {
              Lua = {
                diagnostics = {
                  globals = { "vim" },
                },
                workspace = {
                  library = {
                    [vim.fn.expand "$VIMRUNTIME/lua"] = true,
                    [vim.fn.expand "$VIMRUNTIME/lua/vim/lsp"] = true,
                    [vim.fn.stdpath "data" .. "/lazy/ui/nvchad_types"] = true,
                    [vim.fn.stdpath "data" .. "/lazy/lazy.nvim/lua/lazy"] = true,
                  },
                  maxPreload = 100000,
                  preloadFileSize = 10000,
                },
              },
            },
          }

          return M
        '';
        "mason.lua".text = ''
          local options = {
            ensure_installed = { "lua-language-server" }, -- not an option from mason.nvim

            PATH = "skip",

            ui = {
              icons = {
                package_pending = " ",
                package_installed = "󰄳 ",
                package_uninstalled = " 󰚌",
              },

              keymaps = {
                toggle_server_expand = "<CR>",
                install_server = "i",
                update_server = "u",
                check_server_version = "c",
                update_all_servers = "U",
                check_outdated_servers = "C",
                uninstall_server = "X",
                cancel_installation = "<C-c>",
              },
            },

            max_concurrent_installers = 10,
          }

          return options
        '';
        "nvimtree.lua".text = ''
          local options = {
            filters = {
              dotfiles = false,
              exclude = { vim.fn.stdpath "config" .. "/lua/custom" },
            },
            disable_netrw = true,
            hijack_netrw = true,
            hijack_cursor = true,
            hijack_unnamed_buffer_when_opening = false,
            sync_root_with_cwd = true,
            update_focused_file = {
              enable = true,
              update_root = false,
            },
            view = {
              adaptive_size = false,
              side = "left",
              width = 30,
              preserve_window_proportions = true,
            },
            git = {
              enable = false,
              ignore = true,
            },
            filesystem_watchers = {
              enable = true,
            },
            actions = {
              open_file = {
                resize_window = true,
              },
            },
            renderer = {
              root_folder_label = false,
              highlight_git = false,
              highlight_opened_files = "none",

              indent_markers = {
                enable = false,
              },

              icons = {
                show = {
                  file = true,
                  folder = true,
                  folder_arrow = true,
                  git = false,
                },

                glyphs = {
                  default = "󰈚",
                  symlink = "",
                  folder = {
                    default = "",
                    empty = "",
                    empty_open = "",
                    open = "",
                    symlink = "",
                    symlink_open = "",
                    arrow_open = "",
                    arrow_closed = "",
                  },
                  git = {
                    unstaged = "✗",
                    staged = "✓",
                    unmerged = "",
                    renamed = "➜",
                    untracked = "★",
                    deleted = "",
                    ignored = "◌",
                  },
                },
              },
            },
          }

          return options
        '';
        "others.lua".text = ''
          local M = {}
          local utils = require "core.utils"

          M.blankline = {
            indentLine_enabled = 1,
            filetype_exclude = {
              "help",
              "terminal",
              "lazy",
              "lspinfo",
              "TelescopePrompt",
              "TelescopeResults",
              "mason",
              "nvdash",
              "nvcheatsheet",
              "",
            },
            buftype_exclude = { "terminal" },
            show_trailing_blankline_indent = false,
            show_first_indent_level = false,
            show_current_context = true,
            show_current_context_start = true,
          }

          M.luasnip = function(opts)
            require("luasnip").config.set_config(opts)

            -- vscode format
            require("luasnip.loaders.from_vscode").lazy_load()
            require("luasnip.loaders.from_vscode").lazy_load { paths = vim.g.vscode_snippets_path or "" }

            -- snipmate format
            require("luasnip.loaders.from_snipmate").load()
            require("luasnip.loaders.from_snipmate").lazy_load { paths = vim.g.snipmate_snippets_path or "" }

            -- lua format
            require("luasnip.loaders.from_lua").load()
            require("luasnip.loaders.from_lua").lazy_load { paths = vim.g.lua_snippets_path or "" }

            vim.api.nvim_create_autocmd("InsertLeave", {
              callback = function()
                if
                  require("luasnip").session.current_nodes[vim.api.nvim_get_current_buf()]
                  and not require("luasnip").session.jump_active
                then
                  require("luasnip").unlink_current()
                end
              end,
            })
          end

          M.gitsigns = {
            signs = {
              add = { text = "│" },
              change = { text = "│" },
              delete = { text = "󰍵" },
              topdelete = { text = "‾" },
              changedelete = { text = "~" },
              untracked = { text = "│" },
            },
            on_attach = function(bufnr)
              utils.load_mappings("gitsigns", { buffer = bufnr })
            end,
          }

          return M
        '';
        "telescope.lua".text = ''
          local options = {
            defaults = {
              vimgrep_arguments = {
                "rg",
                "-L",
                "--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 = { "node_modules" },
              generic_sorter = require("telescope.sorters").get_generic_fuzzy_sorter,
              path_display = { "truncate" },
              winblend = 0,
              border = {},
              borderchars = { "─", "│", "─", "│", "╭", "╮", "╯", "╰" },
              color_devicons = 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,
              mappings = {
                n = { ["q"] = require("telescope.actions").close },
              },
            },

            extensions_list = { "themes", "terms" },
          }

          return options
        '';
        "treesitter.lua".text = ''
          local options = {
          ensure_installed = { "lua" },

          highlight = {
            enable = true,
            use_languagetree = true,
          },

          indent = { enable = true },
        }

        return options
        '';
      };
    };
  };
}

#    plugins = with pkgs.vimPlugins; [
#      # vim-airline # Trying out lualine - below
#      YouCompleteMe
#      tabnine-vim
#      rainbow
#      zen-mode-nvim
#
#      # Themes
#      nord-vim
#      gruvbox
#      tokyonight-nvim
#
#      # https://github.com/figsoda/cfg/blob/main/src/programs/neovim/configure/packages.nix
#      bufferline-nvim                 # https://github.com/akinsho/bufferline.nvim/#configuration
#      cmp-buffer                      #
#      cmp-cmdline                     #
#      cmp-dap                         #
#      cmp-nvim-lsp                    #
#      cmp-nvim-lsp-document-symbol    #
#      cmp-path                        #
#      cmp_luasnip                     #
#      comment-nvim                    # https://github.com/numtostr/comment.nvim/
#      dressing-nvim                   #
#      gitsigns-nvim                   # https://github.com/lewis6991/gitsigns.nvim/
#      indent-blankline-nvim           # https://github.com/lukas-reineke/indent-blankline.nvim/
#      leap-nvim                       # https://github.com/ggandor/leap.nvim/
#      lspkind-nvim                    # https://github.com/onsails/lspkind.nvim/
#      lualine-nvim                    # https://github.com/nvim-lualine/lualine.nvim/
#      luasnip                         # https://github.com/l3mon4d3/luasnip/
#      neo-tree-nvim                   # https://github.com/nvim-neo-tree/neo-tree.nvim/
#      nix-develop-nvim                # https://github.com/figsoda/nix-develop.nvim/
#      noice-nvim                      # https://github.com/folke/noice.nvim/
#      numb-nvim                       # https://github.com/nacro90/numb.nvim/
#      nvim-cmp                        # https://github.com/hrsh7th/nvim-cmp
#      nvim-colorizer-lua              #
#      nvim-dap                        #
#      nvim-dap-ui                     #
#      nvim-lspconfig                  #
#      nvim-navic                      #
#      nvim-notify                     #
#      nvim-treesitter-textobjects     #
#      nvim-treesitter.withAllGrammars #
#      nvim-web-devicons               #
#      nvim_context_vt                 #
#      playground                      #
#      refactoring-nvim                #
#      ron-vim                         #
#      telescope-fzf-native-nvim       #
#      telescope-nvim                  #
#      trouble-nvim                    #
#      vim-fugitive                    # https://github.com/tpope/vim-fugitive
#      vim-lastplace                   #
#      vim-visual-multi                #
#    ];
#    extraConfig = ''
#      set mouse=a
#      set number
#      syntax on
#      set hlsearch
#      set ignorecase
#      set smartcase
#      set autoindent
#      set ruler
#      set shiftwidth=2
#      set expandtab
#      set softtabstop=2
#      set cursorline
#      let g:rainbow_active = 1
#
#      colorscheme gruvbox
#    '';
#  };
# }