Como migrar o init.vim para a linguagem lua – Parte final

return {
  --[[
  -- Lualine
  --]]
  {
    "nvim-lualine/lualine.nvim",
    event = "VeryLazy",
    opts = {
      options = {
        theme = "tokyonight",
        icons_enabled = true,
        globalstatus = false,
        section_separators = { left = '', right = '' },
        component_separators = '|'
      },
      sections = {
        lualine_a = {
          { 'mode', separator = { right = '' }, right_padding = 2 },
        }
      },
      tabline = {}
    }
  },

  -- better vim.ui
  {
    "stevearc/dressing.nvim",
    lazy = true,
    init = function()
      ---@diagnostic disable-next-line: duplicate-set-field
      vim.ui.select = function(...)
        require("lazy").load({ plugins = { "dressing.nvim" } })
        return vim.ui.select(...)
      end
      ---@diagnostic disable-next-line: duplicate-set-field
      vim.ui.input = function(...)
        require("lazy").load({ plugins = { "dressing.nvim" } })
        return vim.ui.input(...)
      end
    end,
    opts = {
      input = {
        win_options = {
          winblend = 0
        }
      },
      select = {
        win_options = {
          winblend = 0
        }
      }
    }
  },

  -- icons
  { "nvim-tree/nvim-web-devicons", lazy = true },

  -- plenary
  { "nvim-lua/plenary.nvim", lazy = true },

  -- ui components
  { "MunifTanjim/nui.nvim", lazy = true },
}

return {
  {
    "nvim-treesitter/nvim-treesitter",
    version = false,
    build = ":TSUpdate",
    event = { "BufReadPost", "BufNewFile" },
    opts = {
      auto_install = true,
      highlight = {
        enable = true,
        additional_vim_regex_highlighting = false
      },
      indent = { enable = false },
      context_commentstring = {
        enable = true,
        enable_autocmd = false
      },
      ensure_installed = {
        "html",
        "javascript",
        "json",
        "lua",
        "luadoc",
        "markdown",
        "markdown_inline",
        "regex",
        "tsx",
        "typescript",
        "vim",
        "vimdoc",
        "yaml",
      },
      incremental_selection = {
        enable = true,
        keymaps = {
          init_selection = "<C-space>",
          node_incremental = "<C-space>",
          scope_incremental = false,
          node_decremental = "<bs>",
        },
      },
    },
    ---@param opts TSConfig
    config = function(_, opts)
      if type(opts.ensure_installed) == "table" then
        ---@type table<string, boolean>
        local added = {}
        opts.ensure_installed = vim.tbl_filter(function(lang)
          if added[lang] then
            return false
          end
          added[lang] = true
          return true
        end, opts.ensure_installed)
      end
      require("nvim-treesitter.configs").setup(opts)
    end,
  },
}

return {
  -- lspconfig
  {
    "neovim/nvim-lspconfig",
    event = { "BufReadPre", "BufNewFile" },
    dependencies = {
      { "folke/neoconf.nvim", cmd = "Neoconf", config = true },
      { "folke/neodev.nvim", opts = { experimental = { pathStrict = true } } },
      "mason.nvim",
      "williamboman/mason-lspconfig.nvim",
      "hrsh7th/cmp-nvim-lsp"
    },
    opts = {
      diagnostics = {
        underline = true,
        update_in_insert = false,
        virtual_text = {
          spacing = 4,
          source = "if_many",
          prefix = "●",
        },
        severity_sort = true,
      },
      capabilities = {},
      autoformat = true,
      format = {
        formatting_options = nil,
        timeout_ms = nil,
      },
      servers = {
        lua_ls = {
          settings = {
            Lua = {
              workspace = {
                checkThirdParty = false,
              },
              completion = {
                callSnippet = "Replace",
              },
            },
          },
        },
      },
      setup = { },
    },
    config = function(_, opts)
      local icons = {
        diagnostics = {
          Error = " ",
          Warn = " ",
          Hint = " ",
          Info = " ",
          Information = " ",
        }
      }

      -- diagnostics
      for name, icon in pairs(icons.diagnostics) do
        name = "DiagnosticSign" .. name
        vim.fn.sign_define(name, { text = icon, texthl = name, numhl = "" })
      end

      if type(opts.diagnostics.virtual_text) == "table" and opts.diagnostics.virtual_text.prefix == "icons" then
        opts.diagnostics.virtual_text.prefix = vim.fn.has("nvim-0.10.0") == 0 and "●"
          or function(diagnostic)
            for d, icon in pairs(icons.diagnostics) do
              if diagnostic.severity == vim.diagnostic.severity[d:upper()] then
                return icon
              end
            end
          end
      end

      vim.diagnostic.config(vim.deepcopy(opts.diagnostics))

      local servers = opts.servers
      local capabilities = vim.tbl_deep_extend(
        "force",
        {},
        vim.lsp.protocol.make_client_capabilities(),
        require("cmp_nvim_lsp").default_capabilities(),
        opts.capabilities or {}
      )

      local function setup(server)
        local server_opts = vim.tbl_deep_extend("force", {
          capabilities = vim.deepcopy(capabilities),
        }, servers[server] or {})

        if opts.setup[server] then
          if opts.setup[server](server, server_opts) then
            return
          end
        elseif opts.setup["*"] then
          if opts.setup["*"](server, server_opts) then
            return
          end
        end
        require("lspconfig")[server].setup(server_opts)
      end

      -- get all the servers that are available thourgh mason-lspconfig
      local have_mason, mlsp = pcall(require, "mason-lspconfig")
      local all_mslp_servers = {}
      if have_mason then
        all_mslp_servers = vim.tbl_keys(require("mason-lspconfig.mappings.server").lspconfig_to_package)
      end

      local ensure_installed = {} ---@type string[]
      for server, server_opts in pairs(servers) do
        if server_opts then
          server_opts = server_opts == true and {} or server_opts
          -- run manual setup if mason=false or if this is a server that cannot be installed with mason-lspconfig
          if server_opts.mason == false or not vim.tbl_contains(all_mslp_servers, server) then
            setup(server)
          else
            ensure_installed[#ensure_installed + 1] = server
          end
        end
      end

      if have_mason then
        mlsp.setup({ ensure_installed = ensure_installed })
        mlsp.setup_handlers({ setup })
      end
    end,
  },

  -- cmdline tools and lsp servers
  {

    "williamboman/mason.nvim",
    cmd = "Mason",
    keys = { { "<leader>cm", "<cmd>Mason<cr>", desc = "Mason" } },
    opts = {
      ensure_installed = {
        "typescript-language-server",
      },
    },
    config = function(_, opts)
      require("mason").setup(opts)
      local mr = require("mason-registry")
      local function ensure_installed()
        for _, tool in ipairs(opts.ensure_installed) do
          local p = mr.get_package(tool)
          if not p:is_installed() then
            p:install()
          end
        end
      end
      if mr.refresh then
        mr.refresh(ensure_installed)
      else
        ensure_installed()
      end
    end,
  },
}

return {
  "L3MON4D3/LuaSnip",
  build = "make install_jsregexp",
  lazy = true,
  dependencies = {
    "rafamadriz/friendly-snippets",
    config = function()
      require("luasnip.loaders.from_vscode").lazy_load()
    end,
  },
  opts = {
    history = true,
    delete_check_events = {"InsertEnter"},
    region_check_events = {"InsertLeave", "InsertEnter"}
  }
}

return {
  "hrsh7th/nvim-cmp",
  version = false,
  event = "InsertEnter",
  dependencies = {
    "hrsh7th/cmp-nvim-lsp",
    "hrsh7th/cmp-buffer",
    "hrsh7th/cmp-path",
    "saadparwaiz1/cmp_luasnip",
  },
  opts = function()
    local cmp = require("cmp")
    local luasnip = require("luasnip")

    local has_words_before = function()
      unpack = unpack or table.unpack
      local line, col = unpack(vim.api.nvim_win_get_cursor(0))
      return col ~= 0 and vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1]:sub(col, col):match("%s") == nil
    end

    return {
      completion = {
        completeopt = "menu,menuone",
        get_trigger_characters = function (trigger_characters)
          -- Don't open cmp suggestions on space or tab
          local filter_characters = function(char)
            return char ~= ' ' and char ~= '\t'
          end

          return vim.tbl_filter(filter_characters, trigger_characters)
        end
      },
      snippet = {
        expand = function(args)
          require("luasnip").lsp_expand(args.body)
        end,
      },
      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 = false,
        },  -- Tab, Shift + Tab to cycle through list
        ['<Tab>'] = cmp.mapping(function(fallback)
          if cmp.visible() then
            cmp.select_next_item()
          elseif luasnip.expand_or_locally_jumpable() then
            luasnip.expand_or_jump()
          elseif has_words_before() then
            cmp.complete()
          else
            fallback()
          end
        end, { 'i', 's' }),
        ['<S-Tab>'] = cmp.mapping(function(fallback)
          if cmp.visible() then
            cmp.select_prev_item()
          elseif luasnip.jumpable(-1) then
            luasnip.jump(-1)
          else
            fallback()
          end
        end, { 'i', 's' }),
      },
      sources = cmp.config.sources({
        {
          name = "nvim_lsp",
          max_item_count = 15,
          priority = 1000,
          entry_filter = function(entry)
            return cmp.lsp.CompletionItemKind.Snippet ~= entry:get_kind()
          end
        },
        { name = "luasnip", max_item_count = 5, priority = 750 },
        { name = "path", max_item_count = 5, priority = 500 },
        { name = "buffer", max_item_count = 5, priority = 250 },
      }),
      formatting = {
        format = function(_, item)
          local icons = {
            Text = "",
            Method = "",
            Function = "󰊕",
            Constructor = "",
            Field = "",
            Variable = "󰫧",
            Class = "",
            Interface = "",
            Module = "",
            Property = "",
            Unit = "",
            Value = "",
            Enum = "",
            Keyword = "",
            Snippet = "",
            Color = "",
            File = "",
            Reference = "",
            Folder = "",
            EnumMember = "",
            Constant = "",
            Struct = "",
            Event = "",
            Operator = "",
            TypeParameter = ""
          }
          if icons[item.kind] then
            item.kind = icons[item.kind] .. ' ' .. item.kind
          end
          return item
        end,
      },
      experimental = {
        ghost_text = {
          hl_group = "LspCodeLens",
        },
      },
    }
  end,
}

return {
  "nvim-telescope/telescope.nvim",
  lazy = true,
  cmd = "Telescope",
  version = false,
  dependencies = {
    { 'nvim-telescope/telescope-fzf-native.nvim', build = 'make' }
  },
  config = function()
    require('telescope').setup({
      defaults = {
        prompt_prefix = " ",
        selection_caret = " ",
        sorting_strategy = "ascending",
        scroll_strategy = "limit",
        layout_strategy = "vertical",
        layout_config = {
          vertical = {
            prompt_position = "top",
            mirror = true
          }
        }
      }
    })
    require('telescope').load_extension('fzf')
  end,
  keys = {
    -- find
    { "<leader>fb", "<cmd>Telescope buffers<cr>", desc = "Buffers" },
    { "<leader>ff", function() require('telescope.builtin').find_files({ hidden = true }) end, desc = "Find Files (root dir)" },
    { "<leader>fF", function() require('telescope.builtin').find_files({ hidden = true, cwd = false }) end, desc = "Find Files (cwd)" },
    { "<leader>fr", "<cmd>Telescope oldfiles<cr>", desc = "Recent" },
    -- search
    { "<leader>sb", "<cmd>Telescope current_buffer_fuzzy_find<cr>", desc = "Buffer" },
    { "<leader>sd", "<cmd>Telescope diagnostics bufnr=0<cr>", desc = "Document diagnostics" },
    { "<leader>sD", "<cmd>Telescope diagnostics<cr>", desc = "Workspace diagnostics" },
    { "<leader>sg", function() require('telescope.builtin').live_grep() end, desc = "Grep (root dir)" },
    { "<leader>sG", function() require('telescope.builtin').live_grep({ cwd = false }) end, desc = "Grep (cwd)" },
    { "<leader>sk", "<cmd>Telescope keymaps<cr>", desc = "Key Maps" },
    { "<leader>sm", "<cmd>Telescope marks<cr>", desc = "Jump to Mark" },
    { "<leader>sr", "<cmd>Telescope resume<cr>", desc = "Resume" },
    { "<leader>sw", function() require('telescope.builtin').grep_string() end, desc = "Word (root dir)" },
    { "<leader>sW", function() require('telescope.builtin').grep_string({ cwd = false }) end, desc = "Word (cwd)" },
    {
      "<leader>ss",
      function()
        require('telescope.builtin').lsp_document_symbols({
          symbols = {
            "Class",
            "Function",
            "Method",
            "Constructor",
            "Interface",
            "Module",
            "Struct",
            "Trait",
            "Field",
            "Property",
          },
        })
      end,
      desc = "Goto Symbol",
    },
    {
      "<leader>sS",
      function()
        require('telescope.builtin').lsp_dynamic_workspace_symbols({
          symbols = {
            "Class",
            "Function",
            "Method",
            "Constructor",
            "Interface",
            "Module",
            "Struct",
            "Trait",
            "Field",
            "Property",
          },
        })
      end,
      desc = "Goto Symbol (Workspace)",
    },
  },
}

return {
  'stevearc/oil.nvim',
  lazy = false,
  dependencies = { "nvim-tree/nvim-web-devicons" },
  opts = {
    default_file_explorer = true,
    columns = {
      "icon",
    },
    float = {
      padding = 4,
      max_width = 100
    }
  },
  config = function(_, opts)
    require('oil').setup(opts)
  end
}

--[[
-- All keymaps are grouped in this file for convenience
--]]
local function map(mode, lhs, rhs, options)
  local default_options = { noremap = true, silent = true }

  if options then
    default_options = vim.tbl_extend('force', default_options, options)
  end

  vim.api.nvim_set_keymap(mode, lhs, rhs, default_options)
end

-- Oil
map('n', '<leader>e', '<cmd>Oil<CR>')

-- Close current buffer
map('n', '<leader>fa', '<cmd>bd<CR>', { desc = "Close current buffer" })
-- Close all buffers
map('n', '<leader>ft', '<cmd>%bd<CR>', { desc = "Close all buffers" })

-- Paste replacing selected text, without losing data
map('x', '<leader>p', '"_dP', { desc = "Paste without losing clipboard content" })
-- Delete without yanking
map('x', '<leader>d', '"_d', { desc = "Delete without yanking" })


-- jk exits insert mode and abandon any snippets
vim.keymap.set('i', 'jk', function ()
  local luasnip = require("luasnip")
  local current_nodes = luasnip.session.current_nodes
  if current_nodes then
    if current_nodes[vim.api.nvim_get_current_buf()] then
      current_nodes[vim.api.nvim_get_current_buf()] = nil
    end
  end

  vim.cmd("stopinsert")
end)

-- Create/resize splits
map('n', '<leader>|', '<cmd>vs<CR>', { desc = "Create vertical split" })
map('n', '<leader>-', '<cmd>sp<CR>', { desc = "Create horizontal split" })
map('n', '<leader>q', '<cmd>q<CR>', { desc = "Quit" })
map('n', '<C-Up>', '<cmd>resize +2<CR>', { desc = "Increase horizontal split size" })
map('n', '<C-Down>', '<cmd>resize -2<CR>', { desc = "Decrease horizontal split size" })
map('n', '<C-Left>', '<cmd>vertical resize -2<CR>', { desc = "Decrease vertical split size" })
map('n', '<C-Right>', '<cmd>vertical resize +2<CR>', { desc = "Increase vertical split size" })

-- Use LspAttach autocommand to only map the following keys
-- after the language server attaches to the current buffer
vim.api.nvim_create_autocmd('LspAttach', {
  group = vim.api.nvim_create_augroup('UserLspConfig', {}),
  callback = function(ev)
    -- Enable completion triggered by <c-x><c-o>
    vim.bo[ev.buf].omnifunc = 'v:lua.vim.lsp.omnifunc'

    -- Buffer local mappings.
    -- See `:help vim.lsp.*` for documentation on any of the below functions
    local opts = { buffer = ev.buf, desc = "Go to previous diagnostic" }
    vim.keymap.set('n', '[d', vim.diagnostic.goto_prev, opts)

    opts = { buffer = ev.buf, desc = "Go to next diagnostic" }
    vim.keymap.set('n', ']d', vim.diagnostic.goto_next, opts)

    opts = { buffer = ev.buf, desc = "Go to declaration" }
    vim.keymap.set('n', 'gD', vim.lsp.buf.declaration, opts)

    opts = { buffer = ev.buf, desc = "Go to definition" }
    vim.keymap.set('n', 'gd', vim.lsp.buf.definition, opts)

    opts = { buffer = ev.buf, desc = "Show documentation" }
    vim.keymap.set('n', 'K', vim.lsp.buf.hover, opts)

    opts = { buffer = ev.buf, desc = "Go to implementation" }
    vim.keymap.set('n', 'gi', vim.lsp.buf.implementation, opts)

    opts = { buffer = ev.buf, desc = "Signature help" }
    vim.keymap.set('n', '<C-k>', vim.lsp.buf.signature_help, opts)

    opts = { buffer = ev.buf, desc = "Type definition" }
    vim.keymap.set('n', '<space>D', vim.lsp.buf.type_definition, opts)

    opts = { buffer = ev.buf, desc = "Rename" }
    vim.keymap.set('n', '<f2>', vim.lsp.buf.rename, opts)

    opts = { buffer = ev.buf, desc = "Code action" }
    vim.keymap.set({ 'n', 'v' }, '<space>ca', vim.lsp.buf.code_action, opts)

    opts = { buffer = ev.buf, desc = "Find references" }
    vim.keymap.set('n', 'gr', vim.lsp.buf.references, opts)

    opts = { buffer = ev.buf, desc = "Format buffer" }
    vim.keymap.set('n', '<space>fc', function()
      vim.lsp.buf.format { async = true }
    end, opts)
  end
})