mirror/pojokcodeid.nvim-lazy
1
0
Fork 0
mirror of https://github.com/pojokcodeid/nvim-lazy.git synced 2025-06-24 17:58:46 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

enc: upgrade v2 to v2.5

Browse source
This commit is contained in:
Pojok Code 2024-11-04 21:29:25 +07:00
parent 68ea712b98
commit 609234c086
443 changed files with 5224 additions and 90746 deletions
Download patch file Download diff file Expand all files Collapse all files

55
lua/pcode/plugins/_default.lua Normal file
View file

@ -0,0 +1,55 @@
_G.idxOf = function(array, value)
for i, v in ipairs(array) do
if v == value then
return i
end
end
return nil
end
_G.LAZYGIT_TOGGLE = function()
local ok = pcall(require, "toggleterm")
if not ok then
require("notify")("toggleterm not found!", "error")
return
end
local Terminal = require("toggleterm.terminal").Terminal
local lazygit = Terminal:new({ cmd = "lazygit", hidden = true })
lazygit:toggle()
end
_G.substring = function(text, key)
local index, _ = string.find(text, key)
if index then
return true
else
return false
end
end
_G.all_trim = function(s)
return s:match("^%s*(.-)%s*$")
end
_G.current_theme = function()
if pcode.themes then
local theme = ""
for _, value in pairs(pcode.themes or {}) do
theme = value
end
return all_trim(theme)
end
return ""
end
local function safeRequire(module)
local ok, result = pcall(require, module)
if ok then
return result
end
end
safeRequire("pcode.user.options")
safeRequire("pcode.user.autocmd")
safeRequire("pcode.user.keymaps")
return {}

111
lua/pcode/plugins/_lsp.lua Normal file
View file

@ -0,0 +1,111 @@
return {
{
"williamboman/mason-lspconfig.nvim",
event = { "VeryLazy", "BufReadPre", "BufNewFile", "BufRead" },
dependencies = {
{ "pojokcodeid/auto-lsp.nvim", lazy = true },
{
"neovim/nvim-lspconfig",
lazy = true,
cmd = {
"LspInfo",
"LspInstall",
"LspUninstall",
},
config = function()
require("lspconfig.ui.windows").default_options.border = "rounded"
end,
},
{
"williamboman/mason.nvim",
lazy = true,
build = ":MasonUpdate",
opts_extend = { "ensure_installed" },
cmd = {
"Mason",
"MasonInstall",
"MasonUninstall",
"MasonUninstallAll",
"MasonLog",
},
opts = function(_, opts)
local icons = require("pcode.user.icons").ui
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { "stylua" })
opts.ui = {
-- border = "none",
border = icons.Border,
icons = {
package_pending = icons.Pending,
package_installed = icons.CheckCircle,
package_uninstalled = icons.BlankCircle,
},
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",
},
}
opts.log_level = vim.log.levels.INFO
opts.max_concurrent_installers = 4
return opts
end,
config = function(_, opts)
require("mason").setup(opts)
local mr = require("mason-registry")
mr:on("package:install:success", function()
vim.defer_fn(function()
-- trigger FileType event to possibly load this newly installed LSP server
require("lazy.core.handler.event").trigger({
event = "FileType",
buf = vim.api.nvim_get_current_buf(),
})
end, 100)
end)
mr.refresh(function()
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)
end,
},
},
opts = function(_, opts)
opts.skip_config = opts.skip_config or {}
opts.ensure_installed = opts.ensure_installed or {}
opts.automatic_installation = true
vim.list_extend(opts.ensure_installed, { "lua_ls" })
opts.format_on_save = true -- if use none-ls set true
opts.virtual_text = true
opts.timeout_ms = 5000
return opts
end,
config = function(_, opts)
require("auto-lsp").setup(opts)
end,
-- stylua: ignore
keys = {
{ "<leader>l", "", desc = "  LSP", mode = "n" },
{ "<leader>la", "<cmd>lua vim.lsp.buf.code_action()<cr>", desc = "Code Action", mode = "n" },
{ "<leader>ld", "<cmd>Telescope diagnostics bufnr=0<cr>", desc = "Document Diagnostics", mode = "n" },
{ "<leader>lw", "<cmd>Telescope diagnostics<cr>", desc = "Workspace Diagnostics", mode = "n" },
{ "<leader>li", "<cmd>LspInfo<cr>", desc = "Info", mode = "n" },
{ "<leader>lI", "<cmd>Mason<cr>", desc = "Mason", mode = "n" },
{ "<leader>lj", "<cmd>lua vim.lsp.diagnostic.goto_next()<CR>", desc = "Next Diagnostic", mode = "n" },
{ "<leader>lk", "<cmd>lua vim.lsp.diagnostic.goto_prev()<cr>", desc = "Prev Diagnostic", mode = "n" },
{ "<leader>ll", "<cmd>lua vim.lsp.codelens.run()<cr>", desc = "Code Lens Action", mode = "n" },
{ "<leader>lq", "<cmd>lua vim.diagnostic.setloclist()<cr>", desc = "Quickfix", mode = "n" },
{ "<leader>lr", "<cmd>lua vim.lsp.buf.rename()<cr>", desc = "Rename", mode = "n" },
{ "<leader>ls", "<cmd>Telescope lsp_document_symbols<cr>", desc = "Document Symbols", mode = "n" },
{ "<leader>lS", "<cmd>Telescope lsp_dynamic_workspace_symbols<cr>", desc = "Workspace Symbols", mode = "n"},
},
},
}

47
lua/pcode/plugins/_treesitter.lua Normal file
View file

@ -0,0 +1,47 @@
return {
{ "nvim-lua/plenary.nvim", event = "VeryLazy" },
{
"nvim-treesitter/nvim-treesitter",
event = { "BufRead", "VeryLazy" },
version = false,
build = ":TSUpdate",
lazy = true,
cmd = {
"TSInstall",
"TSInstallInfo",
"TSInstallSync",
"TSUpdate",
"TSUpdateSync",
"TSUninstall",
"TSUninstallInfo",
"TSInstallFromGrammar",
},
opts = function()
return {
highlight = { enable = true },
indent = { enable = true },
ensure_installed = { "lua", "luadoc", "printf", "vim", "vimdoc" },
incremental_selection = {
enable = true,
},
autopairs = {
enable = true,
},
}
end,
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,
},
}

35
lua/pcode/plugins/_treesitterautopairs.lua Normal file
View file

@ -0,0 +1,35 @@
return {
"windwp/nvim-autopairs",
lazy = true,
dependencies = "hrsh7th/nvim-cmp",
event = "InsertEnter",
opts = {
check_ts = true,
ts_config = {
lua = { "string", "source" },
javascript = { "string", "template_string" },
java = false,
},
disable_filetype = { "TelescopePrompt", "spectre_panel" },
fast_wrap = {
map = "<M-e>",
chars = { "{", "[", "(", '"', "'", "`" },
pattern = string.gsub([[ [%'%"%)%>%]%)%}%,] ]], "%s+", ""),
offset = 0, -- Offset from pattern match
end_key = "$",
keys = "qwertyuiopzxcvbnmasdfghjkl",
check_comma = true,
highlight = "PmenuSel",
highlight_grey = "LineNr",
},
},
config = function(_, opts)
require("nvim-autopairs").setup(opts)
local cmp_autopairs = require("nvim-autopairs.completion.cmp")
local cmp_status_ok, cmp = pcall(require, "cmp")
if not cmp_status_ok then
return
end
cmp.event:on("confirm_done", cmp_autopairs.on_confirm_done({ map_char = { tex = "" } }))
end,
}

6
lua/pcode/plugins/_treesitterautotag.lua Normal file
View file

@ -0,0 +1,6 @@
return {
"windwp/nvim-ts-autotag",
lazy = true,
event = { "BufRead", "VeryLazy" },
opts = {},
}

82
lua/pcode/plugins/alpha.lua Normal file
View file

@ -0,0 +1,82 @@
local M = {
"goolord/alpha-nvim",
event = "VimEnter",
}
M.opts = {
dash_model = {
[[ _ __ __ ]],
[[ ___ ___ (____ / /__ _______ ___/ ___ ]],
[[ / _ / _ \ / / _ \/ '_/ / __/ _ / _ / -_) ]],
[[ / .__\_____/ /\___/_/\_\ \__/\___\_,_/\__/ ]],
[[ /_/ |___/ ]],
},
}
function M.config(_, opts)
local alpha = require("alpha")
local startify = require("alpha.themes.startify")
startify.section.header.val = pcode.dashboard or opts.dash_model
startify.section.top_buttons.val = {
startify.button("F", "󰈞 Find file", ":Telescope find_files <CR>"),
startify.button("e", " New file", ":ene <BAR> startinsert <CR>"),
startify.button("p", "󰉋 Find project", ":Telescope projects <CR>"),
startify.button("r", "󰦛 Recently used files", ":Telescope oldfiles <CR>"),
startify.button("t", "󰊄 Find text", ":Telescope live_grep <CR>"),
startify.button("c", " Configuration", ":e $MYVIMRC <CR>"),
startify.button("L", "󰒲 Lazy", ":Lazy<CR>"),
startify.button("q", "󰅚 Quit", ":qa<CR>"),
}
-- disable MRU
startify.section.mru.val = { { type = "padding", val = 4 } }
-- disable MRU cwd
startify.section.mru_cwd.val = { { type = "padding", val = 0 } }
-- disable nvim_web_devicons
startify.nvim_web_devicons.enabled = false
startify.section.bottom_buttons.val = {}
vim.api.nvim_create_autocmd("User", {
pattern = "LazyVimStarted",
desc = "Add Alpha dashboard footer",
once = true,
callback = function()
local stats = require("lazy").stats()
local ms = math.floor(stats.startuptime * 100 + 0.5) / 100
-- stylua: ignore
startify.section.footer.val = {
-- {
-- type = "text",
-- val = {"───────────────────────────────────────────"},
-- },
{
type = "text",
val = {
"⚡ Neovim loaded " .. stats.loaded .. "/" .. stats.count .. " plugins  in " .. ms .. "ms",
},
},
-- {
-- type = "text",
-- val = {"───────────────────────────────────────────"},
-- },
}
pcall(vim.cmd.AlphaRedraw)
end,
})
vim.api.nvim_create_autocmd({ "User" }, {
pattern = { "AlphaReady" },
callback = function()
vim.cmd([[
set laststatus=0 | autocmd BufUnload <buffer> set laststatus=3
]])
end,
})
-- ignore filetypes in MRU
local default_mru_ignore = {}
startify.mru_opts.ignore = function(path, ext)
return (string.find(path, "COMMIT_EDITMSG")) or (vim.tbl_contains(default_mru_ignore, ext))
end
alpha.setup(startify.config)
end
return M

34
lua/pcode/plugins/bufferline.lua Normal file
View file

@ -0,0 +1,34 @@
return {
"akinsho/bufferline.nvim",
branch = "main",
event = { "BufRead", "InsertEnter", "BufNewFile" },
dependencies = "pojokcodeid/auto-bufferline.nvim",
config = function()
vim.opt.termguicolors = true
local config = require("auto-bufferline").config()
require("bufferline").setup(config)
end,
keys = {
{ "<leader>b", "", desc = "  Buffers", mode = "n" },
{
"<leader>bb",
function()
require("telescope.builtin").buffers(require("telescope.themes").get_dropdown({ previewer = false }))
end,
desc = "All Buffer",
mode = "n",
},
{
"<leader>bc",
function()
require("auto-bufferline.configs.utils").bufremove()
end,
desc = "Close current buffer",
mode = "n",
},
{ "<leader>bd", "<cmd>BufferLineCloseLeft<cr>", desc = "Close Buffer Left", mode = "n" },
{ "<leader>bD", "<cmd>BufferLineCloseRight<cr>", desc = "Close Buffer Right", mode = "n" },
{ "<leader>ba", "<cmd>BufferLineCloseOthers<cr>", desc = "Close Buffer Other", mode = "n" },
{ "<leader>bA", "<cmd>BufferLineCloseOthers<cr><cmd>bd!<cr>", desc = "Close Buffer All", mode = "n" },
},
}

121
lua/pcode/plugins/cmp.lua Normal file
View file

@ -0,0 +1,121 @@
return {
{
"L3MON4D3/LuaSnip",
event = "InsertEnter",
opts = {
history = true,
delete_check_events = "TextChanged",
},
-- stylua: ignore
keys = {
{ "<tab>", function() require("luasnip").jump(1) end, mode = "s" },
{ "<s-tab>", function() require("luasnip").jump(-1) end, mode = { "i", "s" } },
},
},
{
"hrsh7th/nvim-cmp",
version = false, -- last release is way too old
event = "InsertEnter",
dependencies = {
"hrsh7th/cmp-nvim-lsp",
"hrsh7th/cmp-buffer",
"hrsh7th/cmp-path",
"saadparwaiz1/cmp_luasnip",
"hrsh7th/cmp-nvim-lua",
},
opts = function()
local cmp = require("cmp")
local luasnip = require("luasnip")
local check_backspace = function()
local col = vim.fn.col(".") - 1
return col == 0 or vim.fn.getline("."):sub(col, col):match("%s")
end
return {
completion = {
completeopt = "menu,menuone,noinsert",
},
snippet = {
expand = function(args)
require("luasnip").lsp_expand(args.body)
end,
},
mapping = cmp.mapping.preset.insert({
["<C-b>"] = cmp.mapping.scroll_docs(-4),
["<C-f>"] = cmp.mapping.scroll_docs(4),
["<C-Space>"] = cmp.mapping.complete(),
["<C-e>"] = cmp.mapping.abort(),
["<CR>"] = cmp.mapping.confirm({ select = true }), -- Accept currently selected item. Set `select` to `false` to only confirm explicitly selected items.
["<Tab>"] = cmp.mapping(function(fallback)
if cmp.visible() then
cmp.select_next_item()
elseif luasnip.expandable() then
luasnip.expand()
elseif luasnip.expand_or_jumpable() then
luasnip.expand_or_jump()
elseif check_backspace() then
fallback()
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" },
{ name = "luasnip" },
{ name = "buffer" },
{ name = "path" },
{ name = "nvim_lua" },
}),
formatting = {
fields = { "kind", "abbr", "menu" },
format = function(entry, vim_item)
vim_item.menu = vim.api.nvim_get_mode().mode == "c" and "" or vim_item.kind
vim_item.kind = string.format("%s", require("pcode.user.icons")["kind"][vim_item.kind])
-- vim_item.menu = ({
-- nvim_lsp = "(LSP)",
-- luasnip = "(Snippet)",
-- buffer = "(Buffer)",
-- path = "(Path)",
-- codeium = "(Codeium)",
-- })[entry.source.name]
return vim_item
end,
},
window = {
completion = cmp.config.window.bordered(),
documentation = cmp.config.window.bordered(),
},
experimental = {
ghost_text = false,
native_menu = false,
},
}
end,
},
{
"rafamadriz/friendly-snippets",
event = "InsertEnter",
lazy = true,
config = function()
require("luasnip.loaders.from_vscode").lazy_load()
require("pcode.user.snippets")
end,
},
}

133
lua/pcode/plugins/cmpcmdline.lua Normal file
View file

@ -0,0 +1,133 @@
return {
{
"folke/noice.nvim",
lazy = true,
enabled = true,
dependencies = {
{ "MunifTanjim/nui.nvim" },
},
event = "CmdlineEnter",
opts = {
messages = {
enabled = false,
},
notify = {
enabled = false,
},
lsp = {
progress = {
enabled = false,
},
hover = {
enabled = false,
},
signature = {
enabled = false,
},
},
},
keys = {
{
"<S-Enter>",
function()
require("noice").redirect(vim.fn.getcmdline())
end,
mode = "c",
desc = "Redirect Cmdline",
},
{
"<leader>snl",
function()
require("noice").cmd("last")
end,
desc = "Noice Last Message",
},
{
"<leader>snh",
function()
require("noice").cmd("history")
end,
desc = "Noice History",
},
{
"<leader>sna",
function()
require("noice").cmd("all")
end,
desc = "Noice All",
},
{
"<c-f>",
function()
if not require("noice.lsp").scroll(4) then
return "<c-f>"
end
end,
silent = true,
expr = true,
desc = "Scroll forward",
mode = { "i", "n", "s" },
},
{
"<c-b>",
function()
if not require("noice.lsp").scroll(-4) then
return "<c-b>"
end
end,
silent = true,
expr = true,
desc = "Scroll backward",
mode = { "i", "n", "s" },
},
},
},
{
"hrsh7th/cmp-cmdline",
event = "VeryLazy",
config = function()
local cmp = require("cmp")
local mapping = {
["<CR>"] = cmp.mapping.confirm({ select = true }),
["<Up>"] = cmp.mapping(cmp.mapping.select_prev_item(), { "i", "c" }),
["<S-Tab>"] = cmp.mapping(cmp.mapping.select_prev_item(), { "i", "c" }),
["<Down>"] = cmp.mapping(cmp.mapping.select_next_item(), { "i", "c" }),
["<Tab>"] = cmp.mapping(cmp.mapping.select_next_item(), { "i", "c" }),
}
-- Use buffer source for `/`.
cmp.setup.cmdline("/", {
preselect = "none",
completion = {
completeopt = "menu,preview,menuone,noselect",
},
mapping = mapping,
sources = {
{ name = "buffer" },
},
experimental = {
ghost_text = true,
native_menu = false,
},
})
-- Use cmdline & path source for ':'.
cmp.setup.cmdline(":", {
preselect = "none",
completion = {
completeopt = "menu,preview,menuone,noselect",
},
mapping = mapping,
sources = cmp.config.sources({
{ name = "path" },
}, {
{ name = "cmdline" },
}),
experimental = {
ghost_text = true,
native_menu = false,
},
})
end,
},
}

52
lua/pcode/plugins/coderunner.lua Normal file
View file

@ -0,0 +1,52 @@
--typescript = "deno run",
-- cpp="gcc $fileName -lstdc++ -o $fileNameWithoutExt && $fileNameWithoutExt"
local pyrun = "python -u"
if vim.fn.has("win32") == 0 then
pyrun = "python3 -u"
end
local rfile = {
java = "cd $dir && javac $fileName && java $fileNameWithoutExt",
python = pyrun,
typescript = "ts-node $dir/$fileName",
rust = "cd $dir && rustc $fileName && $dir/$fileNameWithoutExt",
cpp = "cd $dir && g++ $fileName -o $fileNameWithoutExt && $dir/$fileNameWithoutExt",
scss = "sass $dir/$fileName $dir/$fileNameWithoutExt.css",
javascript = 'node "$dir/$fileName"',
go = "go run .",
}
return {
"CRAG666/code_runner.nvim",
lazy = true,
cmd = { "RunCode", "RunFile", "RunProject", "RunClose" },
opts = {
filetype = rfile,
mode = "float",
focus = true,
startinsert = true,
term = {
position = "bot",
size = 50,
},
float = {
close_key = "<ESC>",
border = "rounded",
height = 0.8,
width = 0.8,
x = 0.5,
y = 0.5,
border_hl = "FloatBorder",
float_hl = "Normal",
blend = 0,
},
},
config = function(_, opts)
require("code_runner").setup(opts)
end,
keys = {
{ "<leader>r", "", desc = "  Run", mode = "n" },
{ "<leader>rr", "<cmd>RunCode<CR>", desc = "Run Code", mode = "n" },
{ "<leader>rf", "<cmd>RunFile<CR>", desc = "Run File", mode = "n" },
{ "<leader>rp", "<cmd>RunProject<CR>", desc = "Run Project", mode = "n" },
},
}

29
lua/pcode/plugins/comment.lua Normal file
View file

@ -0,0 +1,29 @@
return {
"numToStr/Comment.nvim",
event = "VeryLazy",
dependencies = {
"JoosepAlviste/nvim-ts-context-commentstring",
},
opts = function()
return {
pre_hook = require("ts_context_commentstring.integrations.comment_nvim").create_pre_hook(),
}
end,
keys = {
{
"<leader>/",
"<Plug>(comment_toggle_linewise_current)",
desc = "󰆈 Coment line",
mode = "n",
},
{
"<leader>/",
"<Plug>(comment_toggle_linewise_visual)",
desc = "󰆈 Coment line",
mode = "v",
},
},
config = function(_, opts)
require("Comment").setup(opts)
end,
}

40
lua/pcode/plugins/conform.lua Normal file
View file

@ -0,0 +1,40 @@
return {
"pojokcodeid/auto-conform.nvim",
dependencies = {
"williamboman/mason.nvim",
"stevearc/conform.nvim",
},
event = "VeryLazy",
opts = function(_, opts)
opts.formatters = opts.formatters or {}
opts.formatters_by_ft = opts.formatters_by_ft or {}
opts.ensure_installed = opts.ensure_installed or {}
-- vim.list_extend(opts.ensure_installed, { "stylua" })
opts.lang_maps = opts.lang_maps or {}
opts.name_maps = opts.name_maps or {}
opts.add_new = opts.add_new or {}
opts.ignore = opts.ignore or {}
opts.format_on_save = opts.format_on_save or true
opts.format_timeout_ms = opts.format_timeout_ms or 5000
end,
config = function(_, opts)
require("auto-conform").setup(opts)
-- other conform config
local conform = require("conform")
if opts.format_on_save then
conform.setup({
format_on_save = {
lsp_fallback = true,
timeout_ms = opts.format_timeout_ms or 5000,
},
})
end
vim.keymap.set({ "n", "v" }, "<leader>lF", function()
conform.format({
lsp_fallback = true,
async = false,
timeout_ms = opts.format_timeout_ms or 5000,
})
end, { desc = "Format file or range (in visual mode)" })
end,
}

34
lua/pcode/plugins/dressing.lua Normal file
View file

@ -0,0 +1,34 @@
return {
"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 = {
title_pos = "center",
relative = "editor",
default_prompt = "➤ ",
win_options = { winhighlight = "Normal:Normal,NormalNC:Normal" },
prefer_width = 30,
max_width = { 140, 0.9 },
min_width = { 50, 0.2 },
},
select = {
backend = { "telescope", "builtin" },
builtin = { win_options = { winhighlight = "Normal:Normal,NormalNC:Normal" } },
},
},
config = function(_, opts)
require("dressing").setup(opts)
end,
}

53
lua/pcode/plugins/extras/autosave.lua Normal file
View file

@ -0,0 +1,53 @@
return {
"okuuva/auto-save.nvim",
version = "^1.0.0", -- see https://devhints.io/semver, alternatively use '*' to use the latest tagged release
cmd = "ASToggle", -- optional for lazy loading on command
event = { "InsertLeave", "TextChanged" }, -- optional for lazy loading on trigger events
opts = {
enabled = true, -- start auto-save when the plugin is loaded (i.e. when your package manager loads it)
trigger_events = { -- See :h events
immediate_save = { "BufLeave", "FocusLost" }, -- vim events that trigger an immediate save
defer_save = { "InsertLeave", "TextChanged" }, -- vim events that trigger a deferred save (saves after `debounce_delay`)
cancel_deferred_save = { "InsertEnter" }, -- vim events that cancel a pending deferred save
},
-- function that takes the buffer handle and determines whether to save the current buffer or not
-- return true: if buffer is ok to be saved
-- return false: if it's not ok to be saved
-- if set to `nil` then no specific condition is applied
condition = nil,
write_all_buffers = false, -- write all buffers when the current one meets `condition`
noautocmd = false, -- do not execute autocmds when saving
lockmarks = false, -- lock marks when saving, see `:h lockmarks` for more details
debounce_delay = 1500, -- delay after which a pending save is executed
-- log debug messages to 'auto-save.log' file in neovim cache directory, set to `true` to enable
debug = false,
},
config = function(_, opts)
require("auto-save").setup(opts)
local group = vim.api.nvim_create_augroup("autosave", {})
vim.api.nvim_create_autocmd("User", {
pattern = "AutoSaveWritePost",
group = group,
callback = function(opts)
local ftype = vim.bo.filetype
if
opts.data.saved_buffer ~= nil
and ftype ~= "TelescopePrompt"
and not substring(tostring(ftype), "dap")
then
local filename = vim.api.nvim_buf_get_name(opts.data.saved_buffer)
local is_ok = pcall(require, "notify")
if is_ok then
require("notify")("AutoSave: saved at " .. vim.fn.strftime("%H:%M:%S"))
else
print("AutoSave: saved " .. filename .. " at " .. vim.fn.strftime("%H:%M:%S"))
end
end
end,
})
end,
keys = {
{ "<leader>n", ":ASToggle<CR>", desc = "󰨚 Toggle auto-save" },
},
}

8
lua/pcode/plugins/extras/bigfiles.lua Normal file
View file

@ -0,0 +1,8 @@
return {
"LunarVim/bigfile.nvim",
lazy = true,
event = "BufReadPre",
opts = {
file_size = 2,
},
}

33
lua/pcode/plugins/extras/codeium.lua Normal file
View file

@ -0,0 +1,33 @@
return {
"exafunction/codeium.vim",
enabled = true,
-- for fix notwork new version
-- https://github.com/exafunction/codeium.vim/issues/376#issuecomment-2159643405
-- version = "1.8.37",
-- event = "bufwinenter",
-- event = "bufenter",
-- event = "insertenter",
event = { "VeryLazy", "bufreadpre", "bufnewfile", "bufread" },
build = ":Codeium Auth",
cmd = { "CodeiumChat" },
config = function()
vim.g.codeium_disable_bindings = 1
-- Change '<C-g>' here to any keycode you like.
vim.keymap.set("i", "<C-g>", function()
return vim.fn["codeium#Accept"]()
end, { expr = true, silent = true })
vim.keymap.set("i", "<c-;>", function()
return vim.fn["codeium#CycleCompletions"](1)
end, { expr = true, silent = true })
vim.keymap.set("i", "<c-,>", function()
return vim.fn["codeium#CycleCompletions"](-1)
end, { expr = true, silent = true })
vim.keymap.set("i", "<c-x>", function()
return vim.fn["codeium#Clear"]()
end, { expr = true, silent = true })
end,
keys = {
{ "<leader>c", ":CodeiumChat<cr>", desc = "󰭹 codeium chat", mode = "n" },
},
}

26
lua/pcode/plugins/extras/codeiumnvim.lua Normal file
View file

@ -0,0 +1,26 @@
return {
-- codeium cmp source
{
"nvim-cmp",
dependencies = {
-- codeium
{
"Exafunction/codeium.nvim",
cmd = "Codeium",
enabled = false,
build = ":Codeium Auth",
opts = {
enable_chat = true,
},
},
},
--@param opts cmp.ConfigSchema
opts = function(_, opts)
table.insert(opts.sources, 1, {
name = "codeium",
group_index = 1,
priority = 100,
})
end,
},
}

25
lua/pcode/plugins/extras/colorizer.lua Normal file
View file

@ -0,0 +1,25 @@
return {
"NvChad/nvim-colorizer.lua",
lazy = true,
event = { "BufRead", "InsertEnter", "BufNewFile" },
opts = {
user_default_options = {
RGB = true, -- #RGB hex codes
RRGGBB = true, -- #RRGGBB hex codes
names = true, -- "Name" codes like Blue
RRGGBBAA = true, -- #RRGGBBAA hex codes
rgb_fn = true, -- CSS rgb() and rgba() functions
hsl_fn = true, -- CSS hsl() and hsla() functions
css = true, -- Enable all CSS features: rgb_fn, hsl_fn, names, RGB, RRGGBB
css_fn = true, -- Enable all CSS *functions*: rgb_fn, hsl_fn
-- Available modes: foreground, background
mode = "background", -- Set the display mode.
tailwind = true,
},
filetypes = {
"*", -- Highlight all files, but customize some others.
css = { rgb_fn = true }, -- Enable parsing rgb(...) functions in css.
html = { names = false }, -- Disable parsing "names" like Blue or Gray
},
},
}

62
lua/pcode/plugins/extras/dap.lua Normal file
View file

@ -0,0 +1,62 @@
return {
{
"rcarriga/nvim-dap-ui",
lazy = true,
event = "BufRead",
dependencies = {
{ "mfussenegger/nvim-dap", lazy = true },
{ "nvim-neotest/nvim-nio", lazy = true },
{
"theHamsta/nvim-dap-virtual-text",
opts = {
virt_text_win_col = 80,
},
},
},
config = function()
require("pcode.user.dapui")
end,
keys = {
{ "<leader>d", "", desc = "  Debug" },
{ "<leader>dt", "<cmd>lua require'dap'.toggle_breakpoint()<cr>", desc = "Toggle Breakpoint" },
{ "<leader>db", "<cmd>lua require'dap'.step_back()<cr>", desc = "Step Back" },
{ "<leader>dc", "<cmd>lua require'dap'.continue()<cr>", desc = "Continue" },
{ "<leader>dC", "<cmd>lua require'dap'.run_to_cursor()<cr>", desc = "Run To Cursor" },
{ "<leader>dd", "<cmd>lua require'dap'.disconnect()<cr>", desc = "Disconnect" },
{ "<leader>dg", "<cmd>lua require'dap'.session()<cr>", desc = "Get Session" },
{ "<leader>di", "<cmd>lua require'dap'.step_into()<cr>", desc = "Step Into" },
{ "<leader>do", "<cmd>lua require'dap'.step_over()<cr>", desc = "Step Over" },
{ "<leader>du", "<cmd>lua require'dap'.step_out()<cr>", desc = "Step Out" },
{ "<leader>dp", "<cmd>lua require'dap'.pause()<cr>", desc = "Pause" },
{ "<leader>dr", "<cmd>lua require'dap'.repl.toggle()<cr>", desc = "Toggle Repl" },
{ "<leader>ds", "<cmd>lua require'dap'.continue()<cr>", desc = "Start" },
{ "<leader>dq", "<cmd>lua require'dap'.close()<cr>", desc = "Quit" },
{ "<leader>dU", "<cmd>lua require'dapui'.toggle({reset = true})<cr>", desc = "Toggle UI" },
},
},
{
"jay-babu/mason-nvim-dap.nvim",
lazy = true,
event = "BufRead",
dependencies = { "williamboman/mason.nvim", "mfussenegger/nvim-dap" },
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, {})
opts.automatic_setup = true
opts.handlers = {
function(config)
-- all sources with no handler get passed here
-- Keep original functionality
require("mason-nvim-dap").default_setup(config)
end,
}
return opts
end,
-- enabled = vim.fn.has("win32") == 0,
config = function(_, opts)
require("mason").setup()
require("mason-nvim-dap").setup(opts)
end,
},
}

7
lua/pcode/plugins/extras/deviconcolor.lua Normal file
View file

@ -0,0 +1,7 @@
return {
"rachartier/tiny-devicons-auto-colors.nvim",
event = "VeryLazy",
config = function()
require("tiny-devicons-auto-colors").setup()
end,
}

36
lua/pcode/plugins/extras/illuminate.lua Normal file
View file

@ -0,0 +1,36 @@
local M = {
"RRethy/vim-illuminate",
event = "VeryLazy",
}
function M.config()
require("illuminate").configure({
filetypes_denylist = {
"mason",
"harpoon",
"DressingInput",
"NeogitCommitMessage",
"qf",
"dirvish",
"oil",
"minifiles",
"fugitive",
"alpha",
"NvimTree",
"lazy",
"NeogitStatus",
"Trouble",
"netrw",
"lir",
"DiffviewFiles",
"Outline",
"Jaq",
"spectre_panel",
"toggleterm",
"DressingSelect",
"TelescopePrompt",
},
})
end
return M

32
lua/pcode/plugins/extras/indentscupe.lua Normal file
View file

@ -0,0 +1,32 @@
local icons = require("pcode.user.icons")
return {
"echasnovski/mini.indentscope",
version = false, -- wait till new 0.7.0 release to put it back on semver
event = "BufReadPre",
opts = {
symbol = icons.ui.LineMiddle,
options = { try_as_border = true },
},
init = function()
vim.api.nvim_create_autocmd("FileType", {
pattern = {
"alpha",
"dashboard",
"fzf",
"help",
"lazy",
"lazyterm",
"mason",
"neo-tree",
"NvimTree",
"notify",
"toggleterm",
"Trouble",
"trouble",
},
callback = function()
vim.b.miniindentscope_disable = true
end,
})
end,
}

10
lua/pcode/plugins/extras/liveserver.lua Normal file
View file

@ -0,0 +1,10 @@
return {
"barrett-ruth/live-server.nvim",
build = "npm i -g live-server",
cmd = { "LiveServerStart", "LiveServerStop", "LiveServerToggle" },
config = true,
keys = {
-- open http://localhost:5555/ jika menggunakan wsl
{ "<leader>rl", "<cmd>LiveServerToggle<cr>", desc = "LiveServer" },
},
}

40
lua/pcode/plugins/extras/minianimate.lua Normal file
View file

@ -0,0 +1,40 @@
return {
-- animations
{
"echasnovski/mini.animate",
event = "BufRead",
opts = function()
-- don't use animate when scrolling with the mouse
local mouse_scrolled = false
for _, scroll in ipairs({ "Up", "Down" }) do
local key = "<ScrollWheel" .. scroll .. ">"
vim.keymap.set({ "", "i" }, key, function()
mouse_scrolled = true
return key
end, { expr = true })
end
local animate = require("mini.animate")
return {
resize = {
timing = animate.gen_timing.linear({ duration = 100, unit = "total" }),
},
scroll = {
timing = animate.gen_timing.linear({ duration = 150, unit = "total" }),
subscroll = animate.gen_subscroll.equal({
predicate = function(total_scroll)
if mouse_scrolled then
mouse_scrolled = false
return false
end
return total_scroll > 1
end,
}),
},
}
end,
config = function(_, opts)
require("mini.animate").setup(opts)
end,
},
}

35
lua/pcode/plugins/extras/navic.lua Normal file
View file

@ -0,0 +1,35 @@
local M = {
"SmiteshP/nvim-navic",
event = "VeryLazy",
dependencies = {
"LunarVim/breadcrumbs.nvim",
opts = {},
config = true,
},
}
function M.config()
local icons = require("pcode.user.icons").kind
for key, value in pairs(icons) do
icons[key] = value .. " "
end
require("nvim-navic").setup({
icons = icons,
lsp = {
auto_attach = false,
preference = nil,
},
highlight = false,
separator = " > ",
depth_limit = 0,
depth_limit_indicator = "..",
safe_output = true,
lazy_update_context = false,
click = false,
format_text = function(text)
return text
end,
})
end
return M

8
lua/pcode/plugins/extras/neoscroll.lua Normal file
View file

@ -0,0 +1,8 @@
return {
"karb94/neoscroll.nvim",
event = "VeryLazy",
lazy = true,
config = function()
require("neoscroll").setup({})
end,
}

33
lua/pcode/plugins/extras/nvimmenu.lua Normal file
View file

@ -0,0 +1,33 @@
return {
{
"nvchad/menu",
lazy = true,
event = { "VeryLazy" },
dependencies = {
{ "nvchad/volt", lazy = true },
{
"nvchad/minty",
cmd = { "Shades", "Huefy" },
lazy = true,
},
},
opts = {
mouse = true,
border = true,
},
config = function(_, opts)
-- Keyboard users
vim.keymap.set("n", "<C-t>", function()
require("menu").open("default")
end, {})
-- mouse users + nvimtree users!
vim.keymap.set("n", "<RightMouse>", function()
vim.cmd.exec('"normal! \\<RightMouse>"')
local options = vim.bo.ft == "NvimTree" and "nvimtree" or "default"
require("menu").open(options, opts)
end, {})
end,
},
}

107
lua/pcode/plugins/extras/nvimufo.lua Normal file
View file

@ -0,0 +1,107 @@
local M = { "kevinhwang91/nvim-ufo" }
M.event = "VeryLazy"
M.dependencies = {
"kevinhwang91/promise-async",
"luukvbaal/statuscol.nvim",
}
M.config = function()
local builtin = require("statuscol.builtin")
local cfg = {
setopt = true,
relculright = true,
segments = {
{ text = { builtin.foldfunc, " " }, click = "v:lua.ScFa", hl = "Comment" },
{ text = { "%s" }, click = "v:lua.ScSa" },
{ text = { builtin.lnumfunc, " " }, click = "v:lua.ScLa" },
},
}
require("statuscol").setup(cfg)
vim.o.foldcolumn = "1" -- '0' is not bad
vim.o.foldlevel = 99 -- Using ufo provider need a large value, feel free to decrease the value
vim.o.foldlevelstart = 99
vim.o.foldenable = true
vim.o.fillchars = [[eob: ,fold: ,foldopen:▾,foldsep: ,foldclose:▸]]
-- Using ufo provider need remap `zR` and `zM`. If Neovim is 0.6.1, remap yourself
vim.keymap.set("n", "zR", require("ufo").openAllFolds)
vim.keymap.set("n", "zM", require("ufo").closeAllFolds)
local handler = function(virtText, lnum, endLnum, width, truncate)
local newVirtText = {}
local suffix = (" 󰡏 %d "):format(endLnum - lnum)
local sufWidth = vim.fn.strdisplaywidth(suffix)
local targetWidth = width - sufWidth
local curWidth = 0
for _, chunk in ipairs(virtText) do
local chunkText = chunk[1]
local chunkWidth = vim.fn.strdisplaywidth(chunkText)
if targetWidth > curWidth + chunkWidth then
table.insert(newVirtText, chunk)
else
chunkText = truncate(chunkText, targetWidth - curWidth)
local hlGroup = chunk[2]
table.insert(newVirtText, { chunkText, hlGroup })
chunkWidth = vim.fn.strdisplaywidth(chunkText)
-- str width returned from truncate() may less than 2nd argument, need padding
if curWidth + chunkWidth < targetWidth then
suffix = suffix .. (" "):rep(targetWidth - curWidth - chunkWidth)
end
break
end
curWidth = curWidth + chunkWidth
end
table.insert(newVirtText, { suffix, "MoreMsg" })
return newVirtText
end
local ftMap = {
-- typescriptreact = { "lsp", "treesitter" },
-- python = { "indent" },
-- git = "",
}
require("ufo").setup({
fold_virt_text_handler = handler,
close_fold_kinds = {},
-- close_fold_kinds = { "imports", "comment" },
provider_selector = function(bufnr, filetype, buftype)
-- if you prefer treesitter provider rather than lsp,
-- return ftMap[filetype] or {'treesitter', 'indent'}
return ftMap[filetype]
-- return { "treesitter", "indent" }
-- refer to ./doc/example.lua for detail
end,
preview = {
win_config = {
border = { "", "─", "", "", "", "─", "", "" },
winhighlight = "Normal:Folded",
winblend = 0,
},
mappings = {
scrollU = "<C-k>",
scrollD = "<C-j>",
jumpTop = "[",
jumpBot = "]",
},
},
})
vim.keymap.set("n", "zR", require("ufo").openAllFolds)
vim.keymap.set("n", "zM", require("ufo").closeAllFolds)
vim.keymap.set("n", "zr", require("ufo").openFoldsExceptKinds)
vim.keymap.set("n", "zm", require("ufo").closeFoldsWith) -- closeAllFolds == closeFoldsWith(0)
vim.keymap.set("n", "K", function()
local winid = require("ufo").peekFoldedLinesUnderCursor()
if not winid then
vim.lsp.buf.hover()
end
end)
end
return M

36
lua/pcode/plugins/extras/rainbowdelimiters.lua Normal file
View file

@ -0,0 +1,36 @@
return {
"hiphish/rainbow-delimiters.nvim",
lazy = true,
event = "BufRead",
config = function()
-- Modul ini berisi beberapa definisi default
local rainbow_delimiters = require("rainbow-delimiters")
vim.g.rainbow_delimiters = {
strategy = {
[""] = rainbow_delimiters.strategy["global"],
vim = rainbow_delimiters.strategy["local"],
},
query = {
[""] = "rainbow-delimiters",
-- lua = "rainbow-blocks",
},
priority = {
[""] = 110,
lua = 210,
},
highlight = {
"RainbowDelimiterRed",
"RainbowDelimiterYellow",
"RainbowDelimiterBlue",
"RainbowDelimiterOrange",
"RainbowDelimiterGreen",
"RainbowDelimiterViolet",
"RainbowDelimiterCyan",
},
blacklist = {
"html",
"tsx",
},
}
end,
}

43
lua/pcode/plugins/extras/refactoring.lua Normal file
View file

@ -0,0 +1,43 @@
return {
-- Incremental rename
{
"smjonas/inc-rename.nvim",
cmd = "IncRename",
-- stylua: ignore
keys = {
{"<leader>u","",desc="  Edit"},
{
"<leader>un",
function()
return ":IncRename " .. vim.fn.expand("<cword>")
end,
desc = "Incremental rename",
mode = "n",
noremap = true,
expr = true,
},
},
config = true,
},
-- Refactoring tool
{
"ThePrimeagen/refactoring.nvim",
keys = {
{
"<leader>r",
function()
require("refactoring").select_refactor({
show_success_message = true,
})
end,
mode = "v",
noremap = true,
silent = true,
expr = false,
desc = "  Refactoring",
},
},
opts = {},
},
}

27
lua/pcode/plugins/extras/rest.lua Normal file
View file

@ -0,0 +1,27 @@
vim.filetype.add({
extension = {
["http"] = "http",
},
})
return {
{
"mistweaverco/kulala.nvim",
ft = "http",
keys = {
{ "<leader>R", "", desc = " 󰖟 Rest" },
{ "<leader>Rs", "<cmd>lua require('kulala').run()<cr>", desc = "Send the request" },
{ "<leader>Rt", "<cmd>lua require('kulala').toggle_view()<cr>", desc = "Toggle headers/body" },
{ "<leader>Rp", "<cmd>lua require('kulala').jump_prev()<cr>", desc = "Jump to previous request" },
{ "<leader>Rn", "<cmd>lua require('kulala').jump_next()<cr>", desc = "Jump to next request" },
},
opts = {},
},
{
"nvim-treesitter/nvim-treesitter",
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { "http", "graphql" })
return opts
end,
},
}

46
lua/pcode/plugins/extras/restnvim.lua Normal file
View file

@ -0,0 +1,46 @@
-- install luarock
-- sudo apt-get install luarocks lua5.4 (untuk linux)
-- https://github.com/luarocks/luarocks/wiki/Installation-instructions-for-Windows
-- manual penggunaan
-- https://www.jetbrains.com/help/idea/exploring-http-syntax.html
return {
"rest-nvim/rest.nvim",
-- NOTE: Follow https://github.com/rest-nvim/rest.nvim/issues/306
-- commit = "91badd46c60df6bd9800c809056af2d80d33da4c",
event = "VeryLazy",
enabled = vim.fn.executable("luarocks") == 1,
dependencies = {
{
"nvim-treesitter/nvim-treesitter",
opts = function(_, opts)
vim.list_extend(opts.ensure_installed, { "http" })
end,
},
},
config = function()
require("rest-nvim").setup()
vim.api.nvim_create_autocmd("FileType", {
pattern = { "http", "httpResult" },
callback = function()
local opt = vim.opt
opt.number = false -- Print line number
opt.preserveindent = false -- Preserve indent structure as much as possible
opt.relativenumber = false
end,
})
end,
ft = "http",
keys = {
{
"<Leader>rh",
"<cmd>Rest run<cr>",
desc = "Run http request under cursor",
},
{
"<Leader>rH",
"<cmd>Rest last<cr>",
desc = "Run last http request",
},
},
}

13
lua/pcode/plugins/extras/scrollview.lua Normal file
View file

@ -0,0 +1,13 @@
return {
"dstein64/nvim-scrollview",
lazy = true,
event = { "BufRead", "InsertEnter", "BufNewFile" },
opts = {
bg = "LightCyan",
ctermbg = 160,
},
config = function(_, opts)
require("scrollview").setup(opts)
vim.g.scrollview_excluded_filetypes = { "NvimTree", "vista_kind", "Outline", "neo-tree" }
end,
}

21
lua/pcode/plugins/extras/smart-split.lua Normal file
View file

@ -0,0 +1,21 @@
return {
"mrjones2014/smart-splits.nvim",
lazy = true,
event = { "BufRead", "InsertEnter", "BufNewFile" },
opts = {
ignored_filetypes = {
"nofile",
"quickfix",
"qf",
"prompt",
},
ignored_buftypes = { "nofile" },
},
config = function(_, opts)
require("smart-splits").setup(opts)
vim.keymap.set("n", "<C-Left>", require("smart-splits").resize_left)
vim.keymap.set("n", "<C-Down>", require("smart-splits").resize_down)
vim.keymap.set("n", "<C-Up", require("smart-splits").resize_up)
vim.keymap.set("n", "<C-Right>", require("smart-splits").resize_right)
end,
}

64
lua/pcode/plugins/extras/transparent.lua Normal file
View file

@ -0,0 +1,64 @@
return {
-- transparant config
{
"xiyaowong/transparent.nvim",
lazy = true,
event = "BufWinEnter",
cmd = { "TransparentToggle", "TransparentEnable", "TransparentDisable" },
config = function()
require("transparent").setup({
extra_groups = {
"Normal",
"NormalNC",
"NormalFloat",
"FloatBorder",
"Comment",
"Folded",
"GitSignsAdd",
"GitSignsDelete",
"GitSignsChange",
"FoldColumn",
"WinBar",
"WinBarNC",
"NotifyBackground",
},
exclude_groups = {
-- disable active selection backgroun
"CursorLine",
"CursorLineNR",
"CursorLineSign",
"CursorLineFold",
-- disable nvimtree CursorLine
"NvimTreeCursorLine",
-- disable Neotree CursorLine
"NeoTreeCursorLine",
-- disable Telescope active selection background
"TelescopeSelection",
-- disable lualine background color
"LualineNormal",
},
})
require("transparent").clear_prefix("BufferLine")
-- clear prefix for which-key
require("transparent").clear_prefix("WhichKey")
-- clear prefix for lazy.nvim
require("transparent").clear_prefix("Lazy")
-- clear prefix for NvimTree
require("transparent").clear_prefix("NvimTree")
-- clear prefix for NeoTree
require("transparent").clear_prefix("NeoTree")
-- clear prefix for Telescope
require("transparent").clear_prefix("Telescope")
require("transparent").clear_prefix("mason")
-- create auto command to set transparent
vim.cmd("TransparentDisable")
vim.cmd("TransparentEnable")
end,
},
{
"rcarriga/nvim-notify",
opts = function(_, opts)
opts.background_colour = "#00000000"
end,
},
}

10
lua/pcode/plugins/extras/treesittercontex.lua Normal file
View file

@ -0,0 +1,10 @@
return {
"nvim-treesitter/nvim-treesitter-context",
lazy = true,
event = { "BufRead", "VeryLazy" },
opts = {},
keys = {
{ "<leader>T", "", desc = "  TS Context" },
{ "<leader>Tt", "<cmd>TSContextToggle<cr>", desc = "Toggle Context" },
},
}

27
lua/pcode/plugins/extras/verticalcolumn.lua Normal file
View file

@ -0,0 +1,27 @@
return {
{
"lukas-reineke/virt-column.nvim",
event = "BufRead",
opts = {},
config = function()
local icons = require("pcode.user.icons")
require("virt-column").overwrite({
exclude = {
filetypes = { "help", "text", "markdown" },
},
char = icons.ui.LineMiddle,
})
-- Mengatur colum color max 80 caracter
vim.api.nvim_create_autocmd("BufWinEnter", {
pattern = "*",
callback = function()
vim.opt.formatoptions = "croql"
vim.opt.textwidth = 80
vim.opt.colorcolumn = "+1"
vim.opt.lazyredraw = false
-- vim.cmd "hi ColorColumn guibg=#1B2430 ctermbg=246"
end,
})
end,
},
}

17
lua/pcode/plugins/extras/visualmulti.lua Normal file
View file

@ -0,0 +1,17 @@
return {
"mg979/vim-visual-multi",
event = { "BufRead", "InsertEnter", "BufNewFile" },
branch = "master",
lazy = true,
init = function()
vim.g.VM_mouse_mappings = 1 -- equal CTRL + Left Click on VSCODE
vim.g.VM_maps = {
["Find Under"] = "<C-d>", -- equal CTRL+D on VSCODE
["Find Subword Under"] = "<C-d>", -- equal CTRL+D on VSCODE
["Select Cursor Down"] = "<M-C-Down>", -- equal CTRL+ALT+DOWN on VSCODE
["Select Cursor Up"] = "<M-C-Up>", -- equal CTRL+ALT+UP on VSCODE
["Undo"] = "u", -- undo
["Redo"] = "<C-r>", -- redo
}
end,
}

19
lua/pcode/plugins/extras/yanky.lua Normal file
View file

@ -0,0 +1,19 @@
return {
"gbprod/yanky.nvim",
event = "BufReadPre",
opts = {
ring = {
history_length = 50,
storage = "memory",
},
preserve_cursor_position = {
enabled = false,
},
},
config = function(_, opts)
require("yanky").setup(opts)
-- cycle through the yank history, only work after paste
vim.keymap.set("n", "[y", "<Plug>(YankyCycleForward)")
vim.keymap.set("n", "]y", "<Plug>(YankyCycleBackward)")
end,
}

22
lua/pcode/plugins/extras/zenmode.lua Normal file
View file

@ -0,0 +1,22 @@
return {
"folke/zen-mode.nvim",
event = "VeryLazy",
opts = {
plugins = {
options = {
-- hide statusline
laststatus = 0,
},
},
on_open = function(win)
require("notify")("Zen Mode ON")
end,
on_close = function()
require("notify")("Zen Mode OFF")
end,
},
keys = {
{ "<leader>z", "<cmd>ZenMode<cr>", desc = "󰤼 Toggle Zen Mode" },
},
}

66
lua/pcode/plugins/gitsign.lua Normal file
View file

@ -0,0 +1,66 @@
return {
"lewis6991/gitsigns.nvim",
lazy = true,
enabled = vim.fn.executable("git") == 1,
ft = "gitcommit",
event = "BufRead",
opts = {
signs = {
add = { text = "▎" },
change = { text = "▎" },
delete = { text = "" },
topdelete = { text = "" },
changedelete = { text = "▎" },
untracked = { text = "▎" },
},
signcolumn = true,
numhl = false,
linehl = false,
word_diff = false,
watch_gitdir = {
interval = 1000,
follow_files = true,
},
attach_to_untracked = true,
current_line_blame = false, -- Toggle with `:Gitsigns toggle_current_line_blame`
current_line_blame_opts = {
virt_text = true,
virt_text_pos = "eol", -- 'eol' | 'overlay' | 'right_align'
delay = 1000,
ignore_whitespace = false,
},
current_line_blame_formatter = "<author>, <author_time:%Y-%m-%d> - <summary>",
sign_priority = 6,
status_formatter = nil, -- Use default
update_debounce = 200,
max_file_length = 40000,
preview_config = {
-- Options passed to nvim_open_win
border = "rounded",
style = "minimal",
relative = "cursor",
row = 0,
col = 1,
},
},
config = function(_, opts)
require("gitsigns").setup(opts)
end,
-- stylua: ignore
keys = {
{ "<leader>g", "", desc = "  Git" },
{ "<leader>gg",function()LAZYGIT_TOGGLE()end,desc = "Lazygit"},
{ "<leader>gj",function()require("gitsigns").next_hunk()end,desc = "Next Hunk"},
{ "<leader>gk",function()require("gitsigns").prev_hunk()end,desc = "Prev Hunk"},
{ "<leader>gl",function()require("gitsigns").blame_line()end,desc = "Blame"},
{ "<leader>gp",function()require("gitsigns").preview_hunk()end,desc = "Preview Hunk"},
{ "<leader>gr",function()require("gitsigns").reset_hunk()end,desc = "Reset Hunk"},
{ "<leader>gR",function()require("gitsigns").reset_buffer()end,desc = "Reset Buffer"},
{ "<leader>gs",function()require("gitsigns").stage_hunk()end,desc = "Stage Hunge"},
{ "<leader>gu",function()require("gitsigns").undo_stage_hunk()end,desc = "Undo Stage Hunge"},
{ "<leader>go","<cmd>Telescope git_status<cr>",desc = "Opened Changed File"},
{ "<leader>gb","<cmd>Telescope git_branches<cr>",desc = "Checkout Branch"},
{ "<leader>gc","<cmd>Telescope git_commits<cr>",desc = "Checkout Commit"},
{ "<leader>gd","<cmd>Gitsigns diffthis HEAD<cr>",desc = "Diff"},
},
}

39
lua/pcode/plugins/indentblakline.lua Normal file
View file

@ -0,0 +1,39 @@
return {
"lukas-reineke/indent-blankline.nvim",
-- version = "3.5.4",
event = { "BufRead", "InsertEnter", "BufNewFile" },
lazy = true,
opts = {
indent = {
char = "│",
tab_char = "│",
},
scope = { enabled = false },
exclude = {
buftypes = {
"nofile",
"prompt",
"quickfix",
"terminal",
},
filetypes = {
"help",
"alpha",
"dashboard",
"neo-tree",
"Trouble",
"trouble",
"lazy",
"mason",
"notify",
"toggleterm",
"lazyterm",
"NvimTree",
"aerial",
"neogitstatus",
"startify",
},
},
},
main = "ibl",
}

29
lua/pcode/plugins/lang/angular.lua Normal file
View file

@ -0,0 +1,29 @@
return {
{
"nvim-treesitter",
opts = function(_, opts)
if type(opts.ensure_installed) == "table" then
vim.list_extend(opts.ensure_installed, { "angular", "scss", "typescript" })
end
vim.api.nvim_create_autocmd({ "BufReadPost", "BufNewFile" }, {
pattern = { "*.component.html", "*.container.html" },
callback = function()
vim.treesitter.start(nil, "angular")
end,
})
end,
},
{
"williamboman/mason-lspconfig.nvim",
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { "angularls", "ts_ls" })
end,
},
{
"williamboman/mason.nvim",
opts = {
ensure_installed = { "prettier" },
},
},
}

66
lua/pcode/plugins/lang/cpp.lua Normal file
View file

@ -0,0 +1,66 @@
return {
{
"nvim-treesitter/nvim-treesitter",
event = "VeryLazy",
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { "cpp", "c" })
end,
},
{
"williamboman/mason-lspconfig.nvim",
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { "clangd" })
end,
},
{
"jay-babu/mason-nvim-dap.nvim",
event = "VeryLazy",
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { "codelldb" })
end,
},
{
"pojokcodeid/auto-conform.nvim",
event = "VeryLazy",
opts = function(_, opts)
local package = "clang-format"
vim.list_extend(opts.ensure_installed, { package })
opts.formatters_by_ft.cpp = { package }
opts.formatters_by_ft.c = { package }
end,
},
{
"nvim-neotest/neotest",
ft = { "cpp" },
dependencies = {
"nvim-treesitter/nvim-treesitter",
"nvim-neotest/nvim-nio",
"antoinemadec/FixCursorHold.nvim",
"nvim-lua/plenary.nvim",
"alfaix/neotest-gtest",
},
config = function()
require("neotest").setup({
adapters = {
require("neotest-gtest").setup({}),
},
})
end,
-- stylua: ignore
keys = {
{ "<leader>T","",desc="  Test"},
{ "<leader>Tt", function() require("neotest").run.run(vim.fn.expand("%")) end, desc = "Run File" },
{ "<leader>Tr", function() require("neotest").run.run() end, desc = "Run Nearest" },
{ "<leader>TT", function() require("neotest").run.run(vim.loop.cwd()) end, desc = "Run All Test Files" },
{ "<leader>Tl", function() require("neotest").run.run_last() end, desc = "Run Last" },
{ "<Leader>Ts", function() require("neotest").summary.toggle() end, desc = "Toggle Summary" },
{ "<leader>To", function() require("neotest").output.open({ enter = true, auto_close = true }) end, desc = "Show Output" },
{ "<Leader>TO", function() require("neotest").output_panel.toggle() end, desc = "Toggle Output Panel" },
{ "<Leader>TS", function() require("neotest").run.stop() end, desc = "Stop" },
{ "<leader>rc", "<cmd>terminal<cr>g++ --debug main.cpp -o main<cr>", desc = "Compile Debug main.cpp" },
},
},
}

149
lua/pcode/plugins/lang/deno.lua Normal file
View file

@ -0,0 +1,149 @@
return {
{
"nvim-treesitter/nvim-treesitter",
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(
opts.ensure_installed,
{ "html", "javascript", "typescript", "tsx", "css", "json", "jsonc" }
)
end,
},
{
"williamboman/mason-lspconfig.nvim",
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { "html", "eslint", "cssls", "emmet_ls", "jsonls", "denols" })
end,
},
{
"pojokcodeid/auto-conform.nvim",
event = "VeryLazy",
opts = function(_, opts)
opts.formatters_by_ft = opts.formatters_by_ft or {}
local package = "prettier"
vim.list_extend(opts.ensure_installed, { package })
opts.formatters_by_ft.javascript = { package }
end,
},
{
"pojokcodeid/auto-lint.nvim",
opts = function(_, opts)
opts.linters_by_ft = opts.linters_by_ft or {}
vim.list_extend(opts.ensure_installed, { "eslint_d" })
opts.linters_by_ft.javascript = { "eslint_d" }
end,
},
{
"rcarriga/nvim-dap-ui",
lazy = true,
event = "BufRead",
dependencies = {
{ "mfussenegger/nvim-dap", lazy = true },
{ "nvim-neotest/nvim-nio", lazy = true },
{
"mxsdev/nvim-dap-vscode-js",
dependencies = {
"microsoft/vscode-js-debug",
version = "1.x",
build = "npm i && npm run compile vsDebugServerBundle && mv dist out",
},
config = function()
require("dap-vscode-js").setup({
-- node_path = "node", -- Path of node executable. Defaults to $NODE_PATH, and then "node"
debugger_path = vim.fn.stdpath("data") .. "/lazy/vscode-js-debug",
-- debugger_cmd = { "extension" }, -- Command to use to launch the debug server. Takes precedence over `node_path` and `debugger_path`.
adapters = {
"chrome",
"pwa-node",
"pwa-chrome",
"pwa-msedge",
"node-terminal",
"pwa-extensionHost",
"node",
"chrome",
}, -- which adapters to register in nvim-dap
-- log_file_path = "(stdpath cache)/dap_vscode_js.log" -- Path for file logging
-- log_file_level = false -- Logging level for output to file. Set to false to disable file logging.
-- log_console_level = vim.log.levels.ERROR -- Logging level for output to console. Set to false to disable console output.
})
end,
},
},
config = function()
require("pcode.user.dapui")
local js_based_languages = { "typescript" }
for _, language in ipairs(js_based_languages) do
require("dap").configurations[language] = {
{
type = "pwa-node",
request = "launch",
name = "Launch file",
runtimeExecutable = "deno",
runtimeArgs = {
"run",
"--inspect-wait",
"--allow-all",
},
program = "${file}",
cwd = "${workspaceFolder}",
attachSimplePort = 9229,
},
}
end
end,
-- stylua: ignor
keys = {
{ "<leader>d", "", desc = "  Debug" },
{ "<leader>dt", "<cmd>lua require'dap'.toggle_breakpoint()<cr>", desc = "Toggle Breakpoint" },
{ "<leader>db", "<cmd>lua require'dap'.step_back()<cr>", desc = "Step Back" },
{ "<leader>dc", "<cmd>lua require'dap'.continue()<cr>", desc = "Continue" },
{ "<leader>dC", "<cmd>lua require'dap'.run_to_cursor()<cr>", desc = "Run To Cursor" },
{ "<leader>dd", "<cmd>lua require'dap'.disconnect()<cr>", desc = "Disconnect" },
{ "<leader>dg", "<cmd>lua require'dap'.session()<cr>", desc = "Get Session" },
{ "<leader>di", "<cmd>lua require'dap'.step_into()<cr>", desc = "Step Into" },
{ "<leader>do", "<cmd>lua require'dap'.step_over()<cr>", desc = "Step Over" },
{ "<leader>du", "<cmd>lua require'dap'.step_out()<cr>", desc = "Step Out" },
{ "<leader>dp", "<cmd>lua require'dap'.pause()<cr>", desc = "Pause" },
{ "<leader>dr", "<cmd>lua require'dap'.repl.toggle()<cr>", desc = "Toggle Repl" },
{ "<leader>ds", "<cmd>lua require'dap'.continue()<cr>", desc = "Start" },
{ "<leader>dq", "<cmd>lua require'dap'.close()<cr>", desc = "Quit" },
{ "<leader>dU", "<cmd>lua require'dapui'.toggle({reset = true})<cr>", desc = "Toggle UI" },
{ "<leader>T", "", desc = "  Test" },
{ "<leader>Tr", "<cmd>terminal deno test<cr>", desc = "Run Test" },
{ "<leader>Tp", "<cmd>terminal deno test --parallel<cr>", desc = "Run Parallel" },
{
"<leader>Ts",
function()
vim.cmd("terminal deno test " .. vim.fn.expand("%"))
end,
desc = "Run Current File",
},
{
"<leader>Tu",
function()
-- local current_word = vim.fn.expand("<cword>")
local extracted_text = ""
local input = vim.fn.getline(".")
local contains_double_quotes = input:match('"')
local contains_single_quotes = input:match("'")
if contains_double_quotes then
-- process jika ada double quote
input = input:gsub('"', "'")
local start_index, end_index = input:find("'([^']*)'") -- Mencari teks di dalam tanda petik satu
extracted_text = input:sub(start_index, end_index)
elseif contains_single_quotes then
input = input:gsub('"', "'")
local start_index, end_index = input:find("'([^']*)'") -- Mencari teks di dalam tanda petik satu
extracted_text = input:sub(start_index, end_index)
else
extracted_text = (input:gsub("Deno.test%(function", "")):gsub("%(%) %{", "")
end
vim.cmd("terminal deno test --filter " .. extracted_text)
end,
desc = "Run Under Cursor",
},
},
},
}

164
lua/pcode/plugins/lang/golang.lua Normal file
View file

@ -0,0 +1,164 @@
return {
{
"nvim-treesitter/nvim-treesitter",
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { "go", "gomod", "gosum", "gotmpl", "gowork" })
end,
},
{
"williamboman/mason-lspconfig.nvim",
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { "gopls" })
end,
},
{
"pojokcodeid/auto-conform.nvim",
event = "VeryLazy",
opts = function(_, opts)
local package = "gofumpt"
vim.list_extend(opts.ensure_installed, { package })
opts.formatters_by_ft.gofumpt = { package }
end,
},
{
"pojokcodeid/auto-lint.nvim",
opts = function(_, opts)
opts.linters_by_ft = opts.linters_by_ft or {}
vim.list_extend(opts.ensure_installed, { "ast-grep" })
opts.linters_by_ft.php = { "ast-grep" }
end,
},
{
"nvim-neotest/neotest",
event = "VeryLazy",
dependencies = {
"nvim-lua/plenary.nvim",
"antoinemadec/FixCursorHold.nvim",
"nvim-treesitter/nvim-treesitter",
"nvim-neotest/neotest-plenary",
"nvim-neotest/neotest-vim-test",
"nvim-neotest/nvim-nio",
{
"fredrikaverpil/neotest-golang",
dependencies = {
{
"leoluz/nvim-dap-go",
opts = {},
},
},
branch = "main",
},
},
opts = function(_, opts)
opts.adapters = opts.adapters or {}
opts.adapters["neotest-golang"] = {
go_test_args = {
"-v",
"-race",
"-count=1",
"-timeout=60s",
"-coverprofile=" .. vim.fn.getcwd() .. "/coverage.out",
},
dap_go_enabled = true,
}
end,
config = function(_, opts)
if opts.adapters then
local adapters = {}
for name, config in pairs(opts.adapters or {}) do
if type(name) == "number" then
if type(config) == "string" then
config = require(config)
end
adapters[#adapters + 1] = config
elseif config ~= false then
local adapter = require(name)
if type(config) == "table" and not vim.tbl_isempty(config) then
local meta = getmetatable(adapter)
if adapter.setup then
adapter.setup(config)
elseif meta and meta.__call then
adapter(config)
else
error("Adapter " .. name .. " does not support setup")
end
end
adapters[#adapters + 1] = adapter
end
end
opts.adapters = adapters
end
require("neotest").setup(opts)
end,
-- stylua: ignore
keys = {
{ "<leader>T","",desc="  Test"},
{ "<leader>Ta", function() require("neotest").run.attach() end, desc = "[t]est [a]ttach" },
{ "<leader>Tf", function() require("neotest").run.run(vim.fn.expand("%")) end, desc = "[t]est run [f]ile" },
{ "<leader>TA", function() require("neotest").run.run(vim.uv.cwd()) end, desc = "[t]est [A]ll files" },
{ "<leader>TS", function() require("neotest").run.run({ suite = true }) end, desc = "[t]est [S]uite" },
{ "<leader>Tn", function() require("neotest").run.run() end, desc = "[t]est [n]earest" },
{ "<leader>Tl", function() require("neotest").run.run_last() end, desc = "[t]est [l]ast" },
{ "<leader>Ts", function() require("neotest").summary.toggle() end, desc = "[t]est [s]ummary" },
{ "<leader>To", function() require("neotest").output.open({ enter = true, auto_close = true }) end, desc = "[t]est [o]utput" },
{ "<leader>TO", function() require("neotest").output_panel.toggle() end, desc = "[t]est [O]utput panel" },
{ "<leader>Tt", function() require("neotest").run.stop() end, desc = "[t]est [t]erminate" },
{ "<leader>Td", function() require("neotest").run.run({ suite = false, strategy = "dap" }) end, desc = "Debug nearest test" },
},
},
{
"rcarriga/nvim-dap-ui",
lazy = true,
event = "BufRead",
dependencies = {
{ "mfussenegger/nvim-dap", lazy = true },
{ "nvim-neotest/nvim-nio", lazy = true },
{
"theHamsta/nvim-dap-virtual-text",
opts = {
virt_text_win_col = 80,
},
},
},
config = function()
require("pcode.user.dapui")
end,
keys = {
{ "<leader>d", "", desc = "  Debug" },
{ "<leader>dt", "<cmd>lua require'dap'.toggle_breakpoint()<cr>", desc = "Toggle Breakpoint" },
{ "<leader>db", "<cmd>lua require'dap'.step_back()<cr>", desc = "Step Back" },
{ "<leader>dc", "<cmd>lua require'dap'.continue()<cr>", desc = "Continue" },
{ "<leader>dC", "<cmd>lua require'dap'.run_to_cursor()<cr>", desc = "Run To Cursor" },
{ "<leader>dd", "<cmd>lua require'dap'.disconnect()<cr>", desc = "Disconnect" },
{ "<leader>dg", "<cmd>lua require'dap'.session()<cr>", desc = "Get Session" },
{ "<leader>di", "<cmd>lua require'dap'.step_into()<cr>", desc = "Step Into" },
{ "<leader>do", "<cmd>lua require'dap'.step_over()<cr>", desc = "Step Over" },
{ "<leader>du", "<cmd>lua require'dap'.step_out()<cr>", desc = "Step Out" },
{ "<leader>dp", "<cmd>lua require'dap'.pause()<cr>", desc = "Pause" },
{ "<leader>dr", "<cmd>lua require'dap'.repl.toggle()<cr>", desc = "Toggle Repl" },
{ "<leader>ds", "<cmd>lua require'dap'.continue()<cr>", desc = "Start" },
{ "<leader>dq", "<cmd>lua require'dap'.close()<cr>", desc = "Quit" },
{ "<leader>dU", "<cmd>lua require'dapui'.toggle({reset = true})<cr>", desc = "Toggle UI" },
},
},
{
"jay-babu/mason-nvim-dap.nvim",
lazy = true,
event = "BufRead",
dependencies = { "williamboman/mason.nvim", "mfussenegger/nvim-dap" },
config = function()
require("mason-nvim-dap").setup({
automatic_installation = true,
automatic_setup = true,
handlers = {},
ensure_installed = { "delve" },
})
end,
},
}

309
lua/pcode/plugins/lang/java.lua Normal file
View file

@ -0,0 +1,309 @@
local M = {}
local java_filetypes = { "java" }
local root_markers = { ".git", "mvnw", "gradlew", "pom.xml", "build.gradle" }
-- Utility function to extend or override a config table, similar to the way
-- that Plugin.opts works.
---@param config table
---@param custom function | table | nil
local function extend_or_override(config, custom, ...)
if type(custom) == "function" then
config = custom(config, ...) or config
elseif custom then
config = vim.tbl_deep_extend("force", config, custom) --[[@as table]]
end
return config
end
M = {
{
"williamboman/mason-lspconfig.nvim",
opts = function(_, opts)
opts.skip_config = opts.skip_config or {}
vim.list_extend(opts.skip_config, { "jdtls" })
end,
},
{
"mfussenegger/nvim-jdtls",
ft = java_filetypes,
enabled = true,
opts = function()
return {
root_dir = require("jdtls.setup").find_root(root_markers),
project_name = function()
return vim.fn.fnamemodify(vim.fn.getcwd(), ":p:h:t")
end,
-- Where are the config and workspace dirs for a project?
jdtls_config_dir = function(project_name)
return vim.fn.stdpath("cache") .. "/jdtls/" .. project_name .. "/config"
end,
jdtls_workspace_dir = function(project_name)
return vim.fn.stdpath("cache") .. "/jdtls/" .. project_name .. "/workspace"
end,
cmd = { vim.fn.exepath("jdtls") },
full_cmd = function(opts)
local project_name = vim.fn.fnamemodify(vim.fn.getcwd(), ":p:h:t")
local cmd = vim.deepcopy(opts.cmd)
if project_name then
vim.list_extend(cmd, {
"-configuration",
opts.jdtls_config_dir(project_name),
"-data",
opts.jdtls_workspace_dir(project_name),
})
end
return cmd
end,
-- These depend on nvim-dap, but can additionally be disabled by setting false here.
dap = { hotcodereplace = "auto", config_overrides = {} },
dap_main = {},
test = true,
settings = {
java = {
inlayHints = {
parameterNames = {
enabled = "all",
},
},
},
},
}
end,
config = function(_, opts)
local opt = vim.opt
opt.shiftwidth = 4
opt.tabstop = 4
opt.softtabstop = 4
opt.ts = 4
opt.expandtab = true
local mason_registry = require("mason-registry")
local bundles = {} ---@type string[]
if opts.dap and mason_registry.is_installed("java-debug-adapter") then
local java_dbg_pkg = mason_registry.get_package("java-debug-adapter")
local java_dbg_path = java_dbg_pkg:get_install_path()
local jar_patterns = {
java_dbg_path .. "/extension/server/com.microsoft.java.debug.plugin-*.jar",
}
-- java-test also depends on java-debug-adapter.
if opts.test and mason_registry.is_installed("java-test") then
local java_test_pkg = mason_registry.get_package("java-test")
local java_test_path = java_test_pkg:get_install_path()
vim.list_extend(jar_patterns, {
java_test_path .. "/extension/server/*.jar",
})
end
for _, jar_pattern in ipairs(jar_patterns) do
for _, bundle in ipairs(vim.split(vim.fn.glob(jar_pattern), "\n")) do
table.insert(bundles, bundle)
end
end
end
local function attach_jdtls()
local fname = vim.api.nvim_buf_get_name(0)
-- Configuration can be augmented and overridden by opts.jdtls
local config = extend_or_override({
cmd = opts.full_cmd(opts),
root_dir = require("jdtls.setup").find_root(root_markers),
init_options = {
bundles = bundles,
},
settings = opts.settings,
-- enable CMP capabilities
-- capabilities = require("user.lsp.handlers").capabilities or nil,
capabilities = require("auto-lsp.lsp.handlers").capabilities or nil,
}, opts.jdtls)
-- Existing server will be reused if the root_dir matches.
require("jdtls").start_or_attach(config)
-- not need to require("jdtls.setup").add_commands(), start automatically adds commands
end
vim.api.nvim_create_autocmd("FileType", {
pattern = java_filetypes,
callback = attach_jdtls,
})
-- Setup keymap and dap after the lsp is fully attached.
-- https://github.com/mfussenegger/nvim-jdtls#nvim-dap-configuration
-- https://neovim.io/doc/user/lsp.html#LspAttach
vim.api.nvim_create_autocmd("LspAttach", {
callback = function(args)
local client = vim.lsp.get_client_by_id(args.data.client_id)
if client and client.name == "jdtls" then
local wk = require("which-key")
wk.add({
{
mode = "n",
buffer = args.buf,
{ "<leader>cx", group = "extract" },
{ "<leader>cxv", require("jdtls").extract_variable_all, desc = "Extract Variable" },
{ "<leader>cxc", require("jdtls").extract_constant, desc = "Extract Constant" },
{ "gs", require("jdtls").super_implementation, desc = "Goto Super" },
{ "<leader>co", require("jdtls").organize_imports, desc = "Organize Imports" },
},
})
wk.add({
{
mode = "v",
buffer = args.buf,
{ "<leader>cx", group = "extract" },
{
"<leader>cxm",
[[<ESC><CMD>lua require('jdtls').extract_method(true)<CR>]],
desc = "Extract Method",
},
{
"<leader>cxv",
[[<ESC><CMD>lua require('jdtls').extract_variable_all(true)<CR>]],
desc = "Extract Variable",
},
{
"<leader>cxc",
[[<ESC><CMD>lua require('jdtls').extract_constant(true)<CR>]],
desc = "Extract Constant",
},
},
})
if opts.dap and mason_registry.is_installed("java-debug-adapter") then
-- custom init for Java debugger
require("jdtls").setup_dap(opts.dap)
require("jdtls.dap").setup_dap_main_class_configs(opts.dap_main)
-- Java Test require Java debugger to work
-- if opts.test and mason_registry.is_installed("java-test") then
-- -- custom keymaps for Java test runner (not yet compatible with neotest)
-- wk.register({
-- ["<leader>t"] = { name = "+test" },
-- ["<leader>tt"] = { require("jdtls.dap").test_class, "Run All Test" },
-- ["<leader>tr"] = { require("jdtls.dap").test_nearest_method, "Run Nearest Test" },
-- ["<leader>tT"] = { require("jdtls.dap").pick_test, "Run Test" },
-- }, { mode = "n", buffer = args.buf })
-- end
end
-- User can set additional keymaps in opts.on_attach
if opts.on_attach then
opts.on_attach(args)
end
end
end,
})
-- Avoid race condition by calling attach the first time, since the autocmd won't fire.
attach_jdtls()
end,
},
{
"nvim-treesitter/nvim-treesitter",
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { "java" })
end,
},
{
"williamboman/mason-lspconfig.nvim",
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { "jdtls" })
end,
},
{
"pojokcodeid/auto-conform.nvim",
event = "VeryLazy",
opts = function(_, opts)
vim.list_extend(opts.ensure_installed, { "java-debug-adapter", "java-test" })
opts.formatters_by_ft.java = { "lsp_fmt" }
end,
},
{
"nvim-neotest/neotest",
dependencies = {
"nvim-neotest/nvim-nio",
"nvim-lua/plenary.nvim",
"antoinemadec/FixCursorHold.nvim",
"nvim-treesitter/nvim-treesitter",
"andy-bell101/neotest-java",
},
config = function()
require("neotest").setup({
adapters = {
require("neotest-java")({
-- function to determine which runner to use based on project path
determine_runner = function(project_root_path)
-- return should be "maven" or "gradle"
return "gradle"
end,
-- override the builtin runner discovery behaviour to always use given
-- tool. Default is "nil", so no override
force_runner = nil,
-- if the automatic runner discovery can't uniquely determine whether
-- to use Gradle or Maven, fallback to using this runner. Default is
-- "gradle or maven"
fallback_runner = "gradle",
}),
},
})
end,
-- stylua: ignore
keys = {
{ "<leader>T","",desc="  Test"},
{ "<leader>Tt", function() require("neotest").run.run(vim.fn.expand("%")) end, desc = "Run File" },
{ "<leader>Tr", function() require("neotest").run.run() end, desc = "Run Nearest" },
{ "<leader>TT", function() require("neotest").run.run(vim.loop.cwd()) end, desc = "Run All Test Files" },
{ "<leader>Tl", function() require("neotest").run.run_last() end, desc = "Run Last" },
{ "<Leader>Ts", function() require("neotest").summary.toggle() end, desc = "Toggle Summary" },
{ "<leader>To", function() require("neotest").output.open({ enter = true, auto_close = true }) end, desc = "Show Output" },
{ "<Leader>TO", function() require("neotest").output_panel.toggle() end, desc = "Toggle Output Panel" },
{ "<Leader>TS", function() require("neotest").run.stop() end, desc = "Stop" },
{ "<leader>rg", "<cmd>terminal<cr>gradle run<cr>", desc = "Run Gradle", mode = "n" },
},
},
{
"rockerBOO/symbols-outline.nvim",
cmd = "SymbolsOutline",
config = function()
require("symbols-outline").setup({
symbols = {
File = { icon = "󰈔", hl = "@text.uri" },
Module = { icon = "", hl = "@namespace" },
Namespace = { icon = "󰅪", hl = "@namespace" },
Package = { icon = "", hl = "@namespace" },
Class = { icon = "𝓒", hl = "@type" },
Method = { icon = "ƒ", hl = "@method" },
Property = { icon = "", hl = "@method" },
Field = { icon = "", hl = "@field" },
Constructor = { icon = "", hl = "@constructor" },
Enum = { icon = "ℰ", hl = "@type" },
Interface = { icon = "", hl = "@type" },
Function = { icon = "", hl = "@function" },
Variable = { icon = "", hl = "@constant" },
Constant = { icon = "", hl = "@constant" },
String = { icon = "𝓐", hl = "@string" },
Number = { icon = "#", hl = "@number" },
Boolean = { icon = "󰨙 ", hl = "@boolean" },
Array = { icon = "", hl = "@constant" },
Object = { icon = "⦿", hl = "@type" },
Key = { icon = "🔐", hl = "@type" },
Null = { icon = "NULL", hl = "@type" },
EnumMember = { icon = "", hl = "@field" },
Struct = { icon = "𝓢", hl = "@type" },
Event = { icon = "🗲", hl = "@type" },
Operator = { icon = "+", hl = "@operator" },
TypeParameter = { icon = "𝙏", hl = "@parameter" },
Component = { icon = "󰅴", hl = "@function" },
Fragment = { icon = "󰅴", hl = "@constant" },
},
})
end,
keys = {
{ "<leader>S", "<cmd>SymbolsOutline<cr>", desc = "Toggle Outline" },
},
},
}
return M

202
lua/pcode/plugins/lang/javascript.lua Normal file
View file

@ -0,0 +1,202 @@
local config_file = "jest.config.ts"
local M = {
{
"nvim-treesitter/nvim-treesitter",
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(
opts.ensure_installed,
{ "html", "javascript", "typescript", "tsx", "css", "json", "jsonc" }
)
end,
},
{
"williamboman/mason-lspconfig.nvim",
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { "html", "eslint", "cssls", "emmet_ls", "jsonls", "ts_ls" })
end,
},
{
"pojokcodeid/auto-conform.nvim",
event = "VeryLazy",
opts = function(_, opts)
opts.formatters_by_ft = opts.formatters_by_ft or {}
local package = "prettier"
vim.list_extend(opts.ensure_installed, { package })
opts.formatters_by_ft.javascript = { package }
end,
},
{
"nvim-neotest/neotest",
dependencies = {
"antoinemadec/FixCursorHold.nvim",
"nvim-neotest/neotest-jest",
"nvim-neotest/nvim-nio",
},
opts = {
adapters = {
["neotest-jest"] = {
jestCommand = "npm test -- ",
jestConfigFile = function()
local file = vim.fn.expand("%:p")
if string.find(file, "/packages/") then
return string.match(file, "(.-/[^/]+/)src") .. config_file
end
return vim.fn.getcwd() .. "/" .. config_file
end,
cwd = function()
local file = vim.fn.expand("%:p")
if string.find(file, "/packages/") then
return string.match(file, "(.-/[^/]+/)src")
end
return vim.fn.getcwd()
end,
},
},
status = { virtual_text = true },
output = { open_on_run = true },
},
config = function(_, opts)
local neotest_ns = vim.api.nvim_create_namespace("neotest")
vim.diagnostic.config({
virtual_text = {
format = function(diagnostic)
-- Replace newline and tab characters with space for more compact diagnostics
local message =
diagnostic.message:gsub("\n", " "):gsub("\t", " "):gsub("%s+", " "):gsub("^%s+", "")
return message
end,
},
}, neotest_ns)
opts.consumers = opts.consumers or {}
if opts.adapters then
local adapters = {}
for name, config in pairs(opts.adapters or {}) do
if type(name) == "number" then
if type(config) == "string" then
config = require(config)
end
adapters[#adapters + 1] = config
elseif config ~= false then
local adapter = require(name)
if type(config) == "table" and not vim.tbl_isempty(config) then
local meta = getmetatable(adapter)
if adapter.setup then
adapter.setup(config)
elseif meta and meta.__call then
adapter(config)
else
error("Adapter " .. name .. " does not support setup")
end
end
adapters[#adapters + 1] = adapter
end
end
opts.adapters = adapters
end
require("neotest").setup(opts)
end,
-- stylua: ignore
keys = {
{ "<leader>T","",desc="  Test"},
{ "<leader>Tt", function() require("neotest").run.run(vim.fn.expand("%")) end, desc = "Run File" },
{ "<leader>Tr", function() require("neotest").run.run() end, desc = "Run Nearest" },
{ "<leader>TT", function() require("neotest").run.run(vim.loop.cwd()) end, desc = "Run All Test Files" },
{ "<leader>Tl", function() require("neotest").run.run_last() end, desc = "Run Last" },
{ "<Leader>Ts", function() require("neotest").summary.toggle() end, desc = "Toggle Summary" },
{ "<leader>To", function() require("neotest").output.open({ enter = true, auto_close = true }) end, desc = "Show Output" },
{ "<Leader>TO", function() require("neotest").output_panel.toggle() end, desc = "Toggle Output Panel" },
{ "<Leader>TS", function() require("neotest").run.stop() end, desc = "Stop" },
},
},
{
"rcarriga/nvim-dap-ui",
lazy = true,
event = "BufRead",
dependencies = {
{ "mfussenegger/nvim-dap", lazy = true },
{ "nvim-neotest/nvim-nio", lazy = true },
{
"mxsdev/nvim-dap-vscode-js",
dependencies = {
"microsoft/vscode-js-debug",
version = "1.x",
build = "npm i && npm run compile vsDebugServerBundle && mv dist out",
},
config = function()
require("dap-vscode-js").setup({
-- node_path = "node", -- Path of node executable. Defaults to $NODE_PATH, and then "node"
debugger_path = vim.fn.stdpath("data") .. "/lazy/vscode-js-debug",
-- debugger_cmd = { "extension" }, -- Command to use to launch the debug server. Takes precedence over `node_path` and `debugger_path`.
adapters = {
"chrome",
"pwa-node",
"pwa-chrome",
"pwa-msedge",
"node-terminal",
"pwa-extensionHost",
"node",
"chrome",
}, -- which adapters to register in nvim-dap
-- log_file_path = "(stdpath cache)/dap_vscode_js.log" -- Path for file logging
-- log_file_level = false -- Logging level for output to file. Set to false to disable file logging.
-- log_console_level = vim.log.levels.ERROR -- Logging level for output to console. Set to false to disable console output.
})
end,
},
},
config = function()
require("pcode.user.dapui")
local js_based_languages = { "typescript", "javascript", "typescriptreact" }
for _, language in ipairs(js_based_languages) do
require("dap").configurations[language] = {
{
type = "pwa-node",
request = "launch",
name = "Launch file",
program = "${file}",
cwd = "${workspaceFolder}",
},
{
type = "pwa-node",
request = "attach",
name = "Attach",
processId = require("dap.utils").pick_process,
cwd = "${workspaceFolder}",
},
{
type = "pwa-chrome",
request = "launch",
name = 'Start Chrome with "localhost"',
url = "http://localhost:3000",
webRoot = "${workspaceFolder}",
userDataDir = "${workspaceFolder}/.vscode/vscode-chrome-debug-userdatadir",
},
}
end
end,
keys = {
{ "<leader>d", "", desc = "  Debug" },
{ "<leader>dt", "<cmd>lua require'dap'.toggle_breakpoint()<cr>", desc = "Toggle Breakpoint" },
{ "<leader>db", "<cmd>lua require'dap'.step_back()<cr>", desc = "Step Back" },
{ "<leader>dc", "<cmd>lua require'dap'.continue()<cr>", desc = "Continue" },
{ "<leader>dC", "<cmd>lua require'dap'.run_to_cursor()<cr>", desc = "Run To Cursor" },
{ "<leader>dd", "<cmd>lua require'dap'.disconnect()<cr>", desc = "Disconnect" },
{ "<leader>dg", "<cmd>lua require'dap'.session()<cr>", desc = "Get Session" },
{ "<leader>di", "<cmd>lua require'dap'.step_into()<cr>", desc = "Step Into" },
{ "<leader>do", "<cmd>lua require'dap'.step_over()<cr>", desc = "Step Over" },
{ "<leader>du", "<cmd>lua require'dap'.step_out()<cr>", desc = "Step Out" },
{ "<leader>dp", "<cmd>lua require'dap'.pause()<cr>", desc = "Pause" },
{ "<leader>dr", "<cmd>lua require'dap'.repl.toggle()<cr>", desc = "Toggle Repl" },
{ "<leader>ds", "<cmd>lua require'dap'.continue()<cr>", desc = "Start" },
{ "<leader>dq", "<cmd>lua require'dap'.close()<cr>", desc = "Quit" },
{ "<leader>dU", "<cmd>lua require'dapui'.toggle({reset = true})<cr>", desc = "Toggle UI" },
},
},
}
return M

136
lua/pcode/plugins/lang/kotlin.lua Normal file
View file

@ -0,0 +1,136 @@
return {
-- install treesitter
{
"nvim-treesitter/nvim-treesitter",
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { "kotlin" })
end,
},
{
"williamboman/mason-lspconfig.nvim",
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { "kotlin_language_server" })
end,
},
{
"pojokcodeid/auto-conform.nvim",
event = "VeryLazy",
opts = function(_, opts)
opts.formatters_by_ft = opts.formatters_by_ft or {}
local package = "ktfmt"
vim.list_extend(opts.ensure_installed, { package })
opts.formatters_by_ft.kotlin = { package }
end,
},
{
"pojokcodeid/auto-lint.nvim",
optional = true,
opts = function(_, opts)
opts.linters_by_ft = opts.linters_by_ft or {}
vim.list_extend(opts.ensure_installed, { "ktlint" })
opts.linters_by_ft.kotlin = { "ktlint" }
end,
},
{
"mason.nvim",
opts = {
ensure_installed = { "kotlin-debug-adapter" },
},
},
{
"rcarriga/nvim-dap-ui",
lazy = true,
event = "BufRead",
dependencies = {
{ "mfussenegger/nvim-dap", lazy = true },
{ "nvim-neotest/nvim-nio", lazy = true },
},
opts = function()
require("pcode.user.dapui")
local dap = require("dap")
if not dap.adapters.kotlin then
dap.adapters.kotlin = {
type = "executable",
command = "kotlin-debug-adapter",
options = { auto_continue_if_many_stopped = false },
}
end
dap.configurations.kotlin = {
{
type = "kotlin",
request = "launch",
name = "This file",
-- may differ, when in doubt, whatever your project structure may be,
-- it has to correspond to the class file located at `build/classes/`
-- and of course you have to build before you debug
mainClass = function()
local root = vim.uv.cwd()
local fname = vim.api.nvim_buf_get_name(0)
fname = fname:gsub(root, "")
fname = fname:gsub("/app/src/main/kotlin/", "")
fname = fname:gsub(".kt", "Kt"):gsub("/", ".")
-- src/main/kotlin/websearch/Main.kt -> websearch.MainKt
return fname
end,
projectRoot = "${workspaceFolder}",
jsonLogFile = "",
enableJsonLogging = false,
},
{
-- Use this for unit tests
-- First, run
-- ./gradlew --info cleanTest test --debug-jvm
-- then attach the debugger to it
type = "kotlin",
request = "attach",
name = "Attach to debugging session",
port = 5005,
args = {},
projectRoot = vim.fn.getcwd,
hostName = "localhost",
timeout = 2000,
},
}
end,
keys = {
{ "<leader>d", "", desc = "  Debug" },
{ "<leader>dt", "<cmd>lua require'dap'.toggle_breakpoint()<cr>", desc = "Toggle Breakpoint" },
{ "<leader>db", "<cmd>lua require'dap'.step_back()<cr>", desc = "Step Back" },
{ "<leader>dc", "<cmd>lua require'dap'.continue()<cr>", desc = "Continue" },
{ "<leader>dC", "<cmd>lua require'dap'.run_to_cursor()<cr>", desc = "Run To Cursor" },
{ "<leader>dd", "<cmd>lua require'dap'.disconnect()<cr>", desc = "Disconnect" },
{ "<leader>dg", "<cmd>lua require'dap'.session()<cr>", desc = "Get Session" },
{ "<leader>di", "<cmd>lua require'dap'.step_into()<cr>", desc = "Step Into" },
{ "<leader>do", "<cmd>lua require'dap'.step_over()<cr>", desc = "Step Over" },
{ "<leader>du", "<cmd>lua require'dap'.step_out()<cr>", desc = "Step Out" },
{ "<leader>dp", "<cmd>lua require'dap'.pause()<cr>", desc = "Pause" },
{ "<leader>dr", "<cmd>lua require'dap'.repl.toggle()<cr>", desc = "Toggle Repl" },
{ "<leader>ds", "<cmd>lua require'dap'.continue()<cr>", desc = "Start" },
{ "<leader>dq", "<cmd>lua require'dap'.close()<cr>", desc = "Quit" },
{ "<leader>dU", "<cmd>lua require'dapui'.toggle({reset = true})<cr>", desc = "Toggle UI" },
-- setting cek
-- https://stackoverflow.com/questions/9356543/logging-while-testing-through-gradle
{ "<leader>T", "", desc = " Test" },
{ "<leader>Ta", "<cmd>terminal gradle test<cr>", desc = "Run All" },
{
"<leader>Tu",
function()
-- local current_word = vim.fn.expand("<cword>")
local current_word = ""
local input = vim.fn.getline(".")
current_word = all_trim((input:gsub("class", "")):gsub("{", "")) -- hilangkan bagian class
current_word = current_word:gsub("fun", "")
current_word = current_word:gsub("%(%)", "")
current_word = current_word:gsub("{", "")
current_word = current_word:gsub("@Test", "")
vim.cmd("terminal gradle test --tests *." .. all_trim(current_word))
end,
desc = "Run Under Cursor",
},
{ "<leader>rg", "<cmd>terminal<cr>gradle run<cr>", desc = "Run Gradle", mode = "n" },
},
},
}

102
lua/pcode/plugins/lang/markdown.lua Normal file
View file

@ -0,0 +1,102 @@
return {
{
"pojokcodeid/auto-conform.nvim",
event = "VeryLazy",
optional = true,
opts = function(_, opts)
vim.list_extend(opts.formatters, {
["markdown-toc"] = {
condition = function(_, ctx)
for _, line in ipairs(vim.api.nvim_buf_get_lines(ctx.buf, 0, -1, false)) do
if line:find("<!%-%- toc %-%->") then
return true
end
end
end,
},
["markdownlint-cli2"] = {
condition = function(_, ctx)
local diag = vim.tbl_filter(function(d)
return d.source == "markdownlint"
end, vim.diagnostic.get(ctx.buf))
return #diag > 0
end,
},
})
vim.list_extend(opts.formatters_by_ft, {
["markdown"] = { "prettier", "markdownlint-cli2", "markdown-toc" },
["markdown.mdx"] = { "prettier", "markdownlint-cli2", "markdown-toc" },
})
end,
},
{
"williamboman/mason.nvim",
opts = function(_, opts)
vim.list_extend(opts.ensure_installed, { "markdownlint-cli2", "markdown-toc" })
end,
},
{
"pojokcodeid/auto-lint.nvim",
event = "VeryLazy",
opts = function(_, opts)
vim.list_extend(opts.ensure_installed, { "markdownlint-cli2" })
end,
config = function(_, opts)
require("auto-lint").setup(opts)
end,
},
{
"williamboman/mason-lspconfig.nvim",
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { "marksman" })
end,
},
-- Markdown preview
{
"iamcco/markdown-preview.nvim",
cmd = { "MarkdownPreviewToggle", "MarkdownPreview", "MarkdownPreviewStop" },
build = function()
require("lazy").load({ plugins = { "markdown-preview.nvim" } })
vim.fn["mkdp#util#install"]()
end,
keys = {
{
"<leader>Cp",
ft = "markdown",
"<cmd>MarkdownPreviewToggle<cr>",
desc = "Markdown Preview",
},
},
config = function()
vim.cmd([[do FileType]])
end,
},
{
"MeanderingProgrammer/render-markdown.nvim",
opts = {
code = {
sign = false,
width = "block",
right_pad = 1,
},
heading = {
sign = false,
icons = {},
},
},
ft = { "markdown", "norg", "rmd", "org" },
config = function(_, opts)
require("render-markdown").setup(opts)
end,
keys = {
{ "<leader>C", "", desc = "  Markdown" },
{
"<leader>Cr",
"<cmd>RenderMarkdown<cr>",
desc = "Render Markdown",
},
},
},
}

220
lua/pcode/plugins/lang/php.lua Normal file
View file

@ -0,0 +1,220 @@
local function is_laravel_project()
return vim.fn.isdirectory("app") == 1
and vim.fn.isdirectory("bootstrap") == 1
and vim.fn.isdirectory("config") == 1
and vim.fn.isdirectory("database") == 1
and vim.fn.isdirectory("routes") == 1
end
-- check parser php
-- local is_config = true
-- local parsers = require("nvim-treesitter.parsers").get_parser_configs()
-- if parsers.php ~= nil then
-- is_config = false
-- end
return {
{
"nvim-treesitter/nvim-treesitter",
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, {
"c",
"lua",
"vim",
"vimdoc",
"query",
"markdown",
"markdown_inline",
"html",
"php_only",
"php",
"bash",
"blade",
"json",
})
end,
config = function(_, opts)
local parser_config = require("nvim-treesitter.parsers").get_parser_configs()
parser_config.blade = {
install_info = {
url = "https://github.com/EmranMR/tree-sitter-blade",
files = { "src/parser.c" },
branch = "main",
},
filetype = "blade",
}
vim.filetype.add({
pattern = {
[".*%.blade%.php"] = "blade",
},
})
require("nvim-treesitter.configs").setup(opts)
end,
},
{
"williamboman/mason-lspconfig.nvim",
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { "intelephense", "stimulus_ls" })
end,
},
{
"pojokcodeid/auto-conform.nvim",
event = "VeryLazy",
opts = function(_, opts)
vim.list_extend(opts.ensure_installed, { "php-cs-fixer", "blade-formatter" })
opts.formatters_by_ft.php = { "easy-coding-standard" }
opts.formatters_by_ft.blade = { "blade-formatter" }
end,
},
{
"pojokcodeid/auto-lint.nvim",
event = "VeryLazy",
opts = function(_, opts)
vim.list_extend(opts.ensure_installed, { "phpcs" })
end,
config = function(_, opts)
require("auto-lint").setup(opts)
end,
},
{
"rcarriga/nvim-dap-ui",
lazy = true,
event = "BufRead",
dependencies = {
{ "mfussenegger/nvim-dap", lazy = true },
{ "nvim-neotest/nvim-nio", lazy = true },
{
"xdebug/vscode-php-debug",
version = "1.x",
build = "npm install && npm run build",
config = function()
require("dap.ext.vscode").load_launchjs()
end,
},
},
config = function()
require("pcode.user.dapui")
local dap = require("dap")
dap.adapters.php = {
type = "executable",
command = "node",
-- change this to where you build vscode-php-debug
args = { vim.fn.stdpath("data") .. "/lazy/vscode-php-debug/out/phpDebug.js" },
}
dap.configurations.php = {
-- to run php right from the editor
{
name = "run current script",
type = "php",
request = "launch",
port = 9003,
cwd = "${fileDirname}",
program = "${file}",
runtimeExecutable = "php",
},
-- to listen to any php call
{
name = "listen for Xdebug local",
type = "php",
request = "launch",
port = 9003,
},
-- to listen to php call in docker container
{
name = "listen for Xdebug docker",
type = "php",
request = "launch",
port = 9003,
-- this is where your file is in the container
pathMappings = {
["/opt/project"] = "${workspaceFolder}",
},
},
}
end,
keys = {
{ "<leader>d", "", desc = "  Debug" },
{ "<leader>dt", "<cmd>lua require'dap'.toggle_breakpoint()<cr>", desc = "Toggle Breakpoint" },
{ "<leader>db", "<cmd>lua require'dap'.step_back()<cr>", desc = "Step Back" },
{ "<leader>dc", "<cmd>lua require'dap'.continue()<cr>", desc = "Continue" },
{ "<leader>dC", "<cmd>lua require'dap'.run_to_cursor()<cr>", desc = "Run To Cursor" },
{ "<leader>dd", "<cmd>lua require'dap'.disconnect()<cr>", desc = "Disconnect" },
{ "<leader>dg", "<cmd>lua require'dap'.session()<cr>", desc = "Get Session" },
{ "<leader>di", "<cmd>lua require'dap'.step_into()<cr>", desc = "Step Into" },
{ "<leader>do", "<cmd>lua require'dap'.step_over()<cr>", desc = "Step Over" },
{ "<leader>du", "<cmd>lua require'dap'.step_out()<cr>", desc = "Step Out" },
{ "<leader>dp", "<cmd>lua require'dap'.pause()<cr>", desc = "Pause" },
{ "<leader>dr", "<cmd>lua require'dap'.repl.toggle()<cr>", desc = "Toggle Repl" },
{ "<leader>ds", "<cmd>lua require'dap'.continue()<cr>", desc = "Start" },
{ "<leader>dq", "<cmd>lua require'dap'.close()<cr>", desc = "Quit" },
{ "<leader>dU", "<cmd>lua require'dapui'.toggle({reset = true})<cr>", desc = "Toggle UI" },
},
},
{
"nvim-neotest/neotest",
dependencies = {
"antoinemadec/FixCursorHold.nvim",
"olimorris/neotest-phpunit",
"nvim-neotest/nvim-nio",
},
config = function()
require("neotest-phpunit")({
filter_dirs = { "vendor" },
})
require("neotest").setup({
adapters = {
require("neotest-phpunit"),
},
})
end,
-- stylua: ignore
keys = {
{ "<leader>T","",desc="  Test"},
{ "<leader>Tt", function() require("neotest").run.run(vim.fn.expand("%")) end, desc = "Run File" },
{ "<leader>Tr", function() require("neotest").run.run() end, desc = "Run Nearest" },
{ "<leader>TT", function() require("neotest").run.run(vim.loop.cwd()) end, desc = "Run All Test Files" },
{ "<leader>Tl", function() require("neotest").run.run_last() end, desc = "Run Last" },
{ "<Leader>Ts", function() require("neotest").summary.toggle() end, desc = "Toggle Summary" },
{ "<leader>To", function() require("neotest").output.open({ enter = true, auto_close = true }) end, desc = "Show Output" },
{ "<Leader>TO", function() require("neotest").output_panel.toggle() end, desc = "Toggle Output Panel" },
{ "<Leader>TS", function() require("neotest").run.stop() end, desc = "Stop" },
},
},
{
"mfussenegger/nvim-lint",
opts = function(_, opts)
opts.linters_by_ft = opts.linters_by_ft or {}
opts.linters_by_ft.php = { "phpcs" }
opts.linters_by_ft.blade = { "tlint" }
end,
config = function(_, opts)
require("lint").linters_by_ft = opts.linters_by_ft
end,
},
-- untuk case tertentu install ini
-- npm install -g tree-sitter-cli
{
"adalessa/laravel.nvim",
enabled = is_laravel_project(), -- pastikan membuka laravel project
dependencies = {
"tpope/vim-dotenv",
"nvim-telescope/telescope.nvim",
"MunifTanjim/nui.nvim",
"kevinhwang91/promise-async",
},
cmd = { "Laravel" },
keys = {
{ "<leader>L", "", desc = " 󰫐 Laravel" },
{ "<leader>La", ":Laravel artisan<cr>" },
{ "<leader>Lr", ":Laravel routes<cr>" },
{ "<leader>Lm", ":Laravel related<cr>" },
},
event = { "VeryLazy" },
opts = {},
config = true,
},
}

57
lua/pcode/plugins/lang/prisma.lua Normal file
View file

@ -0,0 +1,57 @@
return {
{
"nvim-treesitter/nvim-treesitter",
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { "prisma" })
end,
},
{
"williamboman/mason-lspconfig.nvim",
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { "prismals" })
vim.cmd([[
autocmd BufWritePost *.prisma silent! execute "!npx prisma format"
]])
end,
keys = {
{ "<leader>p", "", desc = "  Prisma" },
{
"<leader>pf",
function()
vim.cmd("execute '!npx prisma format'")
end,
desc = "Prisma Format",
},
{
"<leader>pm",
function()
vim.cmd("execute '!npx prisma init --datasource-provider mysql'")
end,
desc = "init MySQL",
},
{
"<leader>pp",
function()
vim.cmd("execute '!npx prisma init --datasource-provider postgresql'")
end,
desc = "init postgresql",
},
{
"<leader>pe",
function()
vim.cmd("execute '!npx prisma migrate dev --name init'")
end,
desc = "Migrate",
},
{
"<leader>ps",
function()
vim.cmd("terminal npx prisma studio")
end,
desc = "npx prisma Studio",
},
},
},
}

134
lua/pcode/plugins/lang/python.lua Normal file
View file

@ -0,0 +1,134 @@
-- https://github.com/nvim-neotest/neotest-python
-- https://docs.pytest.org/en/7.1.x/getting-started.html
-- (ini untuk windows)*********************************************
-- https://stackoverflow.com/questions/17737203/python-and-virtualenv-on-windows
-- pip install virtualenv
-- python -m virtualenv demoEnv
-- demoEnv\Scripts\activate
-- deactivate
-- (di bawah ini untuk
-- linux)***********************************************************
-- python3 -m venv my-virtual-env
-- sudo python3 -m venv my-virtual-env
-- . ./my-virtual-env/bin/activate
-- sudo apt-get install python3-pytest
-- DAP untuik linux tidak perlu tambahan pakai defaultnya saja
-- ini config khusus windows
local nvim_dap = {
"mfussenegger/nvim-dap",
event = "BufReadPre",
dependencies = {
"rcarriga/nvim-dap-ui",
"theHamsta/nvim-dap-virtual-text",
"nvim-neotest/nvim-nio",
"williamboman/mason.nvim",
"jay-babu/mason-nvim-dap.nvim",
"mfussenegger/nvim-dap-python",
},
config = function()
require("nvim-dap-virtual-text").setup({
virt_text_pos = "eol",
commented = true,
})
local dap_python = require("dap-python")
require("mason-nvim-dap").setup({
automatic_installation = true,
automatic_setup = true,
handlers = {},
ensure_installed = { "python" },
})
local mason_path = vim.fn.glob(vim.fn.stdpath("data") .. "/mason/")
local debugpy_path = mason_path .. "packages/debugpy/venv/Scripts/python"
dap_python.setup(debugpy_path)
dap_python.default_port = 38000
require("pcode.user.dapui")
end,
keys = {
{ "<leader>d", "", desc = "  Debug" },
{ "<leader>dt", "<cmd>lua require'dap'.toggle_breakpoint()<cr>", desc = "Toggle Breakpoint" },
{ "<leader>db", "<cmd>lua require'dap'.step_back()<cr>", desc = "Step Back" },
{ "<leader>dc", "<cmd>lua require'dap'.continue()<cr>", desc = "Continue" },
{ "<leader>dC", "<cmd>lua require'dap'.run_to_cursor()<cr>", desc = "Run To Cursor" },
{ "<leader>dd", "<cmd>lua require'dap'.disconnect()<cr>", desc = "Disconnect" },
{ "<leader>dg", "<cmd>lua require'dap'.session()<cr>", desc = "Get Session" },
{ "<leader>di", "<cmd>lua require'dap'.step_into()<cr>", desc = "Step Into" },
{ "<leader>do", "<cmd>lua require'dap'.step_over()<cr>", desc = "Step Over" },
{ "<leader>du", "<cmd>lua require'dap'.step_out()<cr>", desc = "Step Out" },
{ "<leader>dp", "<cmd>lua require'dap'.pause()<cr>", desc = "Pause" },
{ "<leader>dr", "<cmd>lua require'dap'.repl.toggle()<cr>", desc = "Toggle Repl" },
{ "<leader>ds", "<cmd>lua require'dap'.continue()<cr>", desc = "Start" },
{ "<leader>dq", "<cmd>lua require'dap'.close()<cr>", desc = "Quit" },
{ "<leader>dU", "<cmd>lua require'dapui'.toggle({reset = true})<cr>", desc = "Toggle UI" },
},
}
local M = {
{
"nvim-neotest/neotest",
dependencies = {
"mfussenegger/nvim-dap-python",
"antoinemadec/FixCursorHold.nvim",
"nvim-neotest/nvim-nio",
"nvim-neotest/neotest-python",
},
config = function()
local mason_path = vim.fn.glob(vim.fn.stdpath("data") .. "/mason/")
pcall(function()
require("dap-python").setup(mason_path .. "packages/debugpy/venv/bin/python")
end)
require("neotest").setup({
adapters = {
require("neotest-python")({
dap = { justMyCode = false },
args = { "--log-level", "DEBUG" },
runner = "pytest",
python = vim.fn.has("win32") == 0 and "python3" or "python",
}),
},
})
end,
-- stylua: ignore
keys = {
{ "<leader>T","",desc="  Test"},
{ "<leader>Tt", function() require("neotest").run.run(vim.fn.expand("%")) end, desc = "Run File" },
{ "<leader>Tr", function() require("neotest").run.run() end, desc = "Run Nearest" },
{ "<leader>TT", function() require("neotest").run.run(vim.loop.cwd()) end, desc = "Run All Test Files" },
{ "<leader>Tl", function() require("neotest").run.run_last() end, desc = "Run Last" },
{ "<Leader>Ts", function() require("neotest").summary.toggle() end, desc = "Toggle Summary" },
{ "<leader>To", function() require("neotest").output.open({ enter = true, auto_close = true }) end, desc = "Show Output" },
{ "<Leader>TO", function() require("neotest").output_panel.toggle() end, desc = "Toggle Output Panel" },
{ "<Leader>TS", function() require("neotest").run.stop() end, desc = "Stop" },
},
},
{
"nvim-treesitter/nvim-treesitter",
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { "python" })
end,
},
{
"williamboman/mason-lspconfig.nvim",
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { "pyright" })
end,
},
{
"pojokcodeid/auto-conform.nvim",
event = "VeryLazy",
opts = function(_, opts)
vim.list_extend(opts.ensure_installed, { "flake8", "black", "debugpy" })
opts.formatters_by_ft.python = { "black" }
end,
},
}
if vim.fn.has("win32") ~= 0 then
table.insert(M, nvim_dap)
end
return M

152
lua/pcode/plugins/lang/rust.lua Normal file
View file

@ -0,0 +1,152 @@
return {
{
"nvim-treesitter/nvim-treesitter",
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { "rust" })
end,
},
{
"williamboman/mason-lspconfig.nvim",
opts = function(_, opts)
opts.skip_config = opts.skip_config or {}
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { "rust_analyzer" })
vim.list_extend(opts.skip_config, { "rust_analyzer" })
end,
},
{
"pojokcodeid/auto-conform.nvim",
event = "VeryLazy",
opts = function(_, opts)
opts.formatters_by_ft.rust = { "lsp_fmt" }
end,
},
-- disable none-ls
{
"nvimtools/none-ls.nvim",
enabled = false,
},
{
"rust-lang/rust.vim",
ft = "rust",
init = function()
vim.g.rustfmt_autosave = 1
end,
},
{
"saecki/crates.nvim",
tag = "stable",
ft = { "toml" },
config = function()
require("crates").setup()
end,
},
{
"mrcjkb/rustaceanvim",
version = "^4",
ft = { "rust" },
dependencies = "neovim/nvim-lspconfig",
config = function()
-- local on_attach = require("user.lsp.handlers").on_attach
-- local capabilities = require("user.lsp.handlers").capabilities
local on_attach = require("auto-lsp.lsp.handlers").on_attach
local capabilities = require("auto-lsp.lsp.handlers").capabilities
vim.g.rustaceanvim = {
server = {
on_attach = on_attach,
capabilities = capabilities,
},
}
end,
keys = {
{ "<leader>rt", "<cmd>lua vim.cmd.RustLsp('run')<cr>", desc = "Run Rust" },
},
},
{
"nvim-neotest/neotest",
dependencies = {
"nvim-neotest/nvim-nio",
"nvim-lua/plenary.nvim",
"antoinemadec/FixCursorHold.nvim",
"nvim-treesitter/nvim-treesitter",
},
config = function()
require("neotest").setup({
adapters = {
require("rustaceanvim.neotest"),
},
})
end,
-- stylua: ignore
keys = {
{ "<leader>T","",desc="  Test"},
{ "<leader>Tt", function() require("neotest").run.run(vim.fn.expand("%")) end, desc = "Run File" },
{ "<leader>Tr", function() require("neotest").run.run() end, desc = "Run Nearest" },
{ "<leader>TT", function() require("neotest").run.run(vim.loop.cwd()) end, desc = "Run All Test Files" },
{ "<leader>Tl", function() require("neotest").run.run_last() end, desc = "Run Last" },
{ "<Leader>Ts", function() require("neotest").summary.toggle() end, desc = "Toggle Summary" },
{ "<leader>To", function() require("neotest").output.open({ enter = true, auto_close = true }) end, desc = "Show Output" },
{ "<Leader>TO", function() require("neotest").output_panel.toggle() end, desc = "Toggle Output Panel" },
{ "<Leader>TS", function() require("neotest").run.stop() end, desc = "Stop" },
},
},
{
"mfussenegger/nvim-dap",
event = "BufReadPre",
dependencies = {
"rcarriga/nvim-dap-ui",
"theHamsta/nvim-dap-virtual-text",
"nvim-neotest/nvim-nio",
"williamboman/mason.nvim",
"jay-babu/mason-nvim-dap.nvim",
},
config = function()
require("nvim-dap-virtual-text").setup({
virt_text_pos = "eol",
commented = true,
})
require("mason-nvim-dap").setup({
automatic_installation = true,
automatic_setup = true,
handlers = {},
ensure_installed = { "codelldb" },
})
local mason_path = vim.fn.glob(vim.fn.stdpath("data") .. "/mason/")
local debugrs_path = mason_path .. "packages/codelldb/extension/adapter/codelldb"
require("pcode.user.dapui")
local dap = require("dap")
dap.adapters.codelldb = {
type = "server",
port = "${port}",
executable = {
-- CHANGE THIS to your path!
command = debugrs_path,
args = { "--port", "${port}" },
-- On windows you may have to uncomment this:
detached = vim.fn.has("win32") and false or true,
},
}
end,
keys = {
{ "<leader>d", "", desc = "  Debug" },
{ "<leader>dt", "<cmd>lua require'dap'.toggle_breakpoint()<cr>", desc = "Toggle Breakpoint" },
{ "<leader>db", "<cmd>lua require'dap'.step_back()<cr>", desc = "Step Back" },
{ "<leader>dc", "<cmd>lua require'dap'.continue()<cr>", desc = "Continue" },
{ "<leader>dC", "<cmd>lua require'dap'.run_to_cursor()<cr>", desc = "Run To Cursor" },
{ "<leader>dd", "<cmd>lua require'dap'.disconnect()<cr>", desc = "Disconnect" },
{ "<leader>dg", "<cmd>lua require'dap'.session()<cr>", desc = "Get Session" },
{ "<leader>di", "<cmd>lua require'dap'.step_into()<cr>", desc = "Step Into" },
{ "<leader>do", "<cmd>lua require'dap'.step_over()<cr>", desc = "Step Over" },
{ "<leader>du", "<cmd>lua require'dap'.step_out()<cr>", desc = "Step Out" },
{ "<leader>dp", "<cmd>lua require'dap'.pause()<cr>", desc = "Pause" },
{ "<leader>dr", "<cmd>lua require'dap'.repl.toggle()<cr>", desc = "Toggle Repl" },
{ "<leader>ds", "<cmd>lua require'dap'.continue()<cr>", desc = "Start" },
{ "<leader>dq", "<cmd>lua require'dap'.close()<cr>", desc = "Quit" },
{ "<leader>dU", "<cmd>lua require'dapui'.toggle({reset = true})<cr>", desc = "Toggle UI" },
},
},
}

56
lua/pcode/plugins/lang/sql.lua Normal file
View file

@ -0,0 +1,56 @@
return {
"kristijanhusak/vim-dadbod-ui",
dependencies = {
{ "tpope/vim-dadbod", lazy = true },
{ "kristijanhusak/vim-dadbod-completion", ft = { "sql", "mysql", "plsql" }, lazy = true },
},
init = function()
-- Your DBUI configuration
vim.g.db_ui_show_database_icon = 1
vim.g.db_ui_use_nerd_fonts = 1
vim.g.db_ui_show_help = 0
end,
config = function()
local function db_completion()
require("cmp").setup.buffer({
sources = { { name = "vim-dadbod-completion" } },
})
end
vim.g.db_ui_save_location = vim.fn.stdpath("config") .. require("plenary.path").path.sep .. "db_ui"
vim.api.nvim_create_autocmd("FileType", {
pattern = {
"sql",
},
command = [[setlocal omnifunc=vim_dadbod_completion#omni]],
})
vim.api.nvim_create_autocmd("FileType", {
pattern = {
"sql",
"mysql",
"plsql",
},
callback = function()
vim.schedule(db_completion)
end,
})
end,
cmd = {
"DBUIToggle",
"DBUI",
"DBUIAddConnection",
"DBUIFindBuffer",
"DBUIRenameBuffer",
"DBUILastQueryInfo",
},
-- stylua: ignore
keys = {
{ "<leader>D", "", desc = " 󰆼 DBUI" },
{ "<leader>Dd", "<cmd>Alpha<cr><cmd>NvimTreeClose<cr><cmd>DBUI<cr>", desc = "󰆼 DBUI Open" },
{ "<leader>Dq",
"<cmd>DBUIClose<cr><cmd>BufferLineCloseOthers<cr><cmd>bd!<cr><cmd>lua require('auto-bufferline.configs.utils').bufremove()<cr><cmd>Alpha<cr>",
desc = "󰅙 DBUI Close",
},
},
}

35
lua/pcode/plugins/lang/tailwind.lua Normal file
View file

@ -0,0 +1,35 @@
return {
{
"williamboman/mason-lspconfig.nvim",
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { "tailwindcss" })
end,
},
{
"NvChad/nvim-colorizer.lua",
opts = {
user_default_options = {
tailwind = true,
},
},
},
{
"hrsh7th/nvim-cmp",
dependencies = {
{ "roobert/tailwindcss-colorizer-cmp.nvim", config = true },
},
opts = function(_, opts)
-- original kind icon formatter
local format_kinds = opts.formatting.format
opts.formatting.format = function(entry, item)
format_kinds(entry, item) -- add icons
local lspkind = require("tailwindcss-colorizer-cmp").formatter(entry, item)
if lspkind.kind == "XX" then
lspkind.kind = ""
end
return lspkind
end
end,
},
}

15
lua/pcode/plugins/lualine.lua Normal file
View file

@ -0,0 +1,15 @@
return {
{
"pojokcodeid/auto-lualine.nvim",
event = { "InsertEnter", "BufRead", "BufNewFile" },
dependencies = { "nvim-lualine/lualine.nvim" },
opts = {
setColor = "auto",
setOption = "roundedall",
setMode = 5,
},
config = function(_, opts)
require("auto-lualine").setup(opts)
end,
},
}

30
lua/pcode/plugins/notify.lua Normal file
View file

@ -0,0 +1,30 @@
return {
"rcarriga/nvim-notify",
lazy = true,
event = "VeryLazy",
keys = {
{
"<leader>un",
function()
require("notify").dismiss({ silent = true, pending = true })
end,
desc = "Delete all Notifications",
},
},
opts = {
timeout = 3000,
max_height = function()
return math.floor(vim.o.lines * 0.75)
end,
max_width = function()
return math.floor(vim.o.columns * 0.75)
end,
render = "wrapped-compact",
-- background_colour = "#00000000",
},
config = function(_, opts)
local notify = require("notify")
notify.setup(opts)
vim.notify = notify.notify
end,
}

18
lua/pcode/plugins/nvimlint.lua Normal file
View file

@ -0,0 +1,18 @@
return {
"pojokcodeid/auto-lint.nvim",
dependencies = {
"mfussenegger/nvim-lint",
event = "VeryLazy",
},
event = "VeryLazy",
opts = function(_, opts)
opts.map_lang = opts.map_lang or {}
opts.map_name = opts.map_name or {}
opts.add_new = opts.add_new or {}
opts.ignore = opts.ignore or {}
opts.ensure_installed = opts.ensure_installed or {}
end,
config = function(_, opts)
require("auto-lint").setup(opts)
end,
}

121
lua/pcode/plugins/nvimtree.lua Normal file
View file

@ -0,0 +1,121 @@
return {
"nvim-tree/nvim-tree.lua",
cmd = { "NvimTreeFindFileToggle", "NvimTree", "NvimTreeOpen", "NvimTreeToggle", "NvimTreeFocus", "NvimTreeClose" },
keys = {
{ "<leader>e", "<cmd>NvimTreeToggle<cr>", desc = "󰙅 Explorer" },
},
opts = function(_, opts)
local icons = require("pcode.user.icons")
opts.disable_netrw = true
opts.hijack_cursor = true
opts.sync_root_with_cwd = true
opts.update_focused_file = {
enable = true,
update_root = false,
}
opts.view = {
adaptive_size = false,
centralize_selection = true,
width = 30,
side = "left",
preserve_window_proportions = false,
number = false,
relativenumber = false,
signcolumn = "yes",
float = {
enable = false,
quit_on_focus_loss = true,
open_win_config = {
relative = "editor",
border = "rounded",
width = 30,
height = 30,
row = 1,
col = 1,
},
},
}
opts.renderer = {
root_folder_label = false,
highlight_git = true,
indent_markers = { enable = true },
--[[ indent_markers = {
enable = true,
inline_arrows = true,
icons = {
corner = "└",
edge = "│",
item = "│",
none = " ",
},
}, ]]
icons = {
webdev_colors = true,
git_placement = "before",
padding = " ",
symlink_arrow = " ➛ ",
show = {
file = true,
folder = true,
folder_arrow = true,
git = true,
},
glyphs = {
default = icons.ui.Text,
symlink = icons.ui.FileSymlink,
bookmark = icons.ui.BookMark,
folder = {
arrow_closed = icons.ui.ChevronShortRight,
arrow_open = icons.ui.ChevronShortDown,
default = icons.ui.Folder,
open = icons.ui.FolderOpen,
empty = icons.ui.EmptyFolder,
empty_open = icons.ui.EmptyFolderOpen,
symlink = icons.ui.FolderSymlink,
symlink_open = icons.ui.FolderOpen,
},
git = {
unstaged = icons.git.FileUnstaged,
staged = icons.git.FileStaged,
unmerged = icons.git.FileUnmerged,
renamed = icons.git.FileRenamed,
untracked = icons.git.FileUntracked,
deleted = icons.git.FileDeleted,
ignored = icons.git.FileIgnored,
},
},
},
special_files = { "Cargo.toml", "Makefile", "README.md", "readme.md" },
symlink_destination = true,
}
opts.filters = {
dotfiles = false,
git_clean = false,
no_buffer = false,
custom = { "node_modules", "\\.cache", "\\.git" },
exclude = {
".gitignore",
".prettierignore",
},
}
opts.notify = {
threshold = vim.log.levels.INFO,
}
opts.git = {
enable = true,
ignore = false,
show_on_dirs = true,
show_on_open_dirs = true,
disable_for_dirs = {},
timeout = 400,
}
return opts
end,
config = function(_, opts)
require("nvim-tree").setup(opts)
local api = require("nvim-tree.api")
api.events.subscribe(api.events.Event.FileCreated, function(file)
vim.cmd("edit " .. file.fname)
end)
end,
}

189
lua/pcode/plugins/telecope.lua Normal file
View file

@ -0,0 +1,189 @@
return {
"nvim-telescope/telescope.nvim",
lazy = true,
cmd = "Telescope",
version = false,
opts = function()
local find_files = {
hidden = true,
}
local live_grep = {
only_sort_text = true,
additional_args = function()
return { "--multiline" }
end,
}
local actions = require("telescope.actions")
vim.g.theme_switcher_loaded = true
return {
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 = { "smart" },
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" },
pickers = {
find_files = find_files,
live_grep = live_grep,
grep_string = {
only_sort_text = true,
},
buffers = {
initial_mode = "normal",
mappings = {
i = {
["<C-d>"] = actions.delete_buffer,
},
n = {
["dd"] = actions.delete_buffer,
},
},
},
planets = {
show_pluto = true,
show_moon = true,
},
git_files = {
hidden = true,
show_untracked = true,
},
colorscheme = {
enable_preview = true,
},
},
mappings = {
i = {
["<C-n>"] = actions.cycle_history_next,
["<C-p>"] = actions.cycle_history_prev,
["<C-j>"] = actions.move_selection_next,
["<C-k>"] = actions.move_selection_previous,
["<C-c>"] = actions.close,
["<Down>"] = actions.move_selection_next,
["<Up>"] = actions.move_selection_previous,
["<CR>"] = actions.select_default,
["<C-x>"] = actions.select_horizontal,
["<C-v>"] = actions.select_vertical,
["<C-t>"] = actions.select_tab,
["<C-u>"] = actions.preview_scrolling_up,
["<C-d>"] = actions.preview_scrolling_down,
["<PageUp>"] = actions.results_scrolling_up,
["<PageDown>"] = actions.results_scrolling_down,
["<Tab>"] = actions.toggle_selection + actions.move_selection_worse,
["<S-Tab>"] = actions.toggle_selection + actions.move_selection_better,
["<C-q>"] = actions.send_to_qflist + actions.open_qflist,
["<M-q>"] = actions.send_selected_to_qflist + actions.open_qflist,
["<C-l>"] = actions.complete_tag,
["<C-_>"] = actions.which_key, -- keys from pressing <C-/>
},
n = {
["<esc>"] = actions.close,
["<CR>"] = actions.select_default,
["<C-x>"] = actions.select_horizontal,
["<C-v>"] = actions.select_vertical,
["<C-t>"] = actions.select_tab,
["<Tab>"] = actions.toggle_selection + actions.move_selection_worse,
["<S-Tab>"] = actions.toggle_selection + actions.move_selection_better,
["<C-q>"] = actions.send_to_qflist + actions.open_qflist,
["<M-q>"] = actions.send_selected_to_qflist + actions.open_qflist,
["j"] = actions.move_selection_next,
["k"] = actions.move_selection_previous,
["H"] = actions.move_to_top,
["M"] = actions.move_to_middle,
["L"] = actions.move_to_bottom,
["<Down>"] = actions.move_selection_next,
["<Up>"] = actions.move_selection_previous,
["gg"] = actions.move_to_top,
["G"] = actions.move_to_bottom,
["<C-u>"] = actions.preview_scrolling_up,
["<C-d>"] = actions.preview_scrolling_down,
["<PageUp>"] = actions.results_scrolling_up,
["<PageDown>"] = actions.results_scrolling_down,
["?"] = actions.which_key,
},
},
}
end,
config = function(_, opts)
require("telescope").setup(opts)
-- load extensions
pcall(function()
for _, ext in ipairs(opts.extensions_list) do
require("telescope").load_extension(ext)
end
end)
end,
keys = {
{ "<leader>s", "", desc = "  Search", mode = "n" },
{ "<leader>f", "<cmd>Telescope find_files<CR>", desc = " Find files", mode = "n" },
{ "<leader>F", "<cmd>Telescope live_grep<cr>", desc = " Find Text", mode = "n" },
{ "<leader>sb", "<cmd>Telescope git_branches<cr>", desc = "Checkout branch", mode = "n" },
{ "<leader>sc", "<cmd>Telescope colorscheme<cr>", desc = "Colorscheme", mode = "n" },
{ "<leader>sh", "<cmd>Telescope help_tags<cr>", desc = "Find Help", mode = "n" },
{ "<leader>sM", "<cmd>Telescope man_pages<cr>", desc = "Man Pages", mode = "n" },
{ "<leader>sr", "<cmd>Telescope oldfiles<cr>", desc = "Open Recent File", mode = "n" },
{ "<leader>sR", "<cmd>Telescope registers<cr>", desc = "Registers", mode = "n" },
{ "<leader>sk", "<cmd>Telescope keymaps<cr>", desc = "Keymaps", mode = "n" },
{ "<leader>sC", "<cmd>Telescope commands<cr>", desc = "Commands", mode = "n" },
},
}

62
lua/pcode/plugins/theme/dracula.lua Normal file
View file

@ -0,0 +1,62 @@
return {
"Mofiqul/dracula.nvim",
priority = 1000,
opts=function()
local colors = require("dracula").colors()
return{
colors = {
-- purple = "#FCC76A",
menu = colors.bg,
selection = "#363848",
},
italic_comment = true,
lualine_bg_color = colors.bg,
overrides = {
Keywords = { fg = colors.cyan, italic = true },
["@keyword"] = { fg = colors.pink, italic = true },
["@keyword.function"] = { fg = colors.cyan, italic = true },
["@function"] = { fg = colors.green, italic = true },
["@tag.attribute"] = { fg = colors.green, italic = true },
["@tag.builtin.javascript"] = { fg = colors.pink },
["@tag.delimiter.javascript"] = { fg = colors.fg },
["@type.javascript"] = { fg = colors.fg },
["@property.css"] = { fg = colors.cyan },
["@type.css"] = { fg = colors.green },
["@tag.css"] = { fg = colors.pink },
["@keyword.css"] = { fg = colors.fg },
["@string.css"] = { fg = colors.pink },
NvimTreeFolderIcon = { fg = "#6776a7" },
CmpItemAbbr = { fg = "#ABB2BF" },
CmpItemKind = { fg = "#ABB2BF" },
CmpItemAbbrDeprecated = { fg = "#ABB2BF" },
CmpItemAbbrMatch = { fg = "#8BE9FD" },
htmlLink = { fg = "#BD93F9", underline = false },
Underlined = { fg = "#8BE9FD" },
NvimTreeSpecialFile = { fg = "#FF79C6" },
SpellBad = { fg = "#FF6E6E" },
illuminatedWord = { bg = "#3b4261" },
illuminatedCurWord = { bg = "#3b4261" },
IlluminatedWordText = { bg = "#3b4261" },
IlluminatedWordRead = { bg = "#3b4261" },
IlluminatedWordWrite = { bg = "#3b4261" },
DiffChange = { fg = colors.fg },
StatusLine = { fg = colors.fg, bg = colors.bg },
StatusLineTerm = { fg = colors.fg, bg = colors.bg },
BufferLineFill = { bg = colors.bg },
Pmenu = { fg = colors.fg, bg = colors.bg },
LspInfoBorder = { fg = colors.fg },
LspReferenceText = { bg = "#3b4261" },
LspReferenceRead = { bg = "#3b4261" },
LspReferenceWrite = { bg = "#3b4261" },
WinBar = { bg = colors.bg },
WinBarNC = { fg = colors.fg, bg = colors.bg },
},
transparent_bg = false,
}
end,
config = function(_,opts)
require("dracula").setup(opts)
local colorscheme = pcode.themes.dracula or "dracula"
vim.cmd("colorscheme " .. colorscheme)
end,
}

49
lua/pcode/plugins/theme/evatheme.lua Normal file
View file

@ -0,0 +1,49 @@
return {
"sharpchen/Eva-Theme.nvim",
lazy = false,
priority = 1000,
config = function()
require("Eva-Theme").setup({})
local color = {}
if pcode.localcode then
color = require("Eva-Theme.palette").dark_base.punctuation
else
color = require("Eva-Theme.palette").dark
end
vim.api.nvim_create_autocmd("ColorScheme", {
pattern = "*",
callback = function()
local hi = vim.api.nvim_set_hl
-- hi(0, "LspInfoBorder", { fg = "#2F3F5C" })
-- hi(0, "LspInfoBorder", { fg = "#598DEF" })
hi(0, "LspInfoBorder", { fg = "#8A97C3" })
-- hi(0, "FloatBorder", { fg = "#2F3F5C" })
-- hi(0, "FloatBorder", { fg = "#598DEF" })
hi(0, "FloatBorder", { fg = "#8A97C3" })
hi(0, "StatusLine", { bg = color.background })
hi(0, "StatusLineNC", { bg = color.background })
hi(0, "WinBar", { bg = color.background })
hi(0, "WinBarNC", { bg = color.background })
hi(0, "NormalFloat", { bg = color.background })
hi(0, "NormalNC", { bg = color.background })
hi(0, "@tag.delimiter.javascript", { fg = "#838FA7" })
hi(0, "@tag.delimiter.tsx", { fg = "#838FA7" })
-- git
hi(0, "NvimTreeGitNewIcon", { bg = color.dark, fg = color.git.added })
hi(0, "NvimTreeGitRenamedIcon", { bg = color.dark, fg = color.git.added })
hi(0, "NvimTreeGitDeletedIcon", { bg = color.dark, fg = color.git.stagedDeleted })
hi(0, "NvimTreeGitDirtyIcon", { bg = color.dark, fg = color.git.diffModified })
hi(0, "NvimTreeGitIgnoredIcon", { bg = color.dark, fg = color.git.ignored })
hi(0, "NvimTreeGitMergeIcon", { bg = color.dark, fg = color.git.diffModified })
hi(0, "NvimTreeGitStagedIcon", { bg = color.dark, fg = color.git.stagedModified })
hi(0, "NvimTreeWinSeparator", { bg = color.dark, fg = color.comment })
hi(0, "MiniIndentscopeSymbol", { bg = color.dark, fg = color.parameter })
-- cursor
-- hi(0, "Cursor", { bg = "#838FA7", fg = "#838FA7" })
hi(0, "CursorColumn", { bg = color.dark, fg = "#838FA7" })
hi(0, "TermCursor", { bg = "#FF9070", fg = color.dark })
hi(0, "TermCursorNC", { bg = "#FF9070", fg = color.dark })
end,
})
end,
}

41
lua/pcode/plugins/theme/jetbrains.lua Normal file
View file

@ -0,0 +1,41 @@
return {
"pojokcodeid/darcula-dark.nvim",
priority = 1000,
lazy = false,
config = function()
require("darcula").setup({
colors = {
lavender = "#9876AA",
statusline = "NONE",
},
})
vim.api.nvim_create_autocmd("ColorScheme", {
pattern = "*",
callback = function()
local colors = require("darcula").colors()
local hi = vim.api.nvim_set_hl
hi(0, "@property.json", { fg = colors.lavender })
hi(0, "@property.jsonc", { fg = colors.lavender })
hi(0, "LineNr", { ctermfg = 11, fg = colors._39 })
-- hi(0, "@variable.member.sql", { fg = colors.olive_green })
-- telescope
hi(0, "TelescopePromptBorder", { fg = colors.medium_gray })
hi(0, "TelescopeResultsBorder", { fg = colors.medium_gray })
hi(0, "TelescopePreviewBorder", { fg = colors.medium_gray })
hi(0, "TelescopeSelection", { bg = colors.dark_charcoal_gray })
hi(0, "TelescopeMultiSelection", { bg = colors.dark_charcoal_gray })
hi(0, "TelescopeNormal", { bg = colors.dark })
hi(0, "TelescopeMatching", { fg = colors.olive_green })
hi(0, "TelescopePromptPrefix", { fg = colors.red })
hi(0, "TelescopeResultsDiffDelete", { fg = colors.red })
hi(0, "TelescopeResultsDiffChange", { fg = colors.bright_cyan })
hi(0, "TelescopeResultsDiffAdd", { fg = colors.olive_green })
hi(0, "TelescopePromptNormal", { bg = colors.dark, fg = colors.grey })
hi(0, "TelescopePromptPrefix", { bg = colors.dark, fg = colors.red })
hi(0, "TelescopeResultsTitle", { bg = colors.olive_green, fg = colors.very_dark_gray })
end,
})
local colorscheme = pcode.themes.jetbrains or "darcula-dark"
vim.cmd("colorscheme " .. colorscheme)
end,
}

124
lua/pcode/plugins/theme/onedarkpro.lua Normal file
View file

@ -0,0 +1,124 @@
return {
"olimorris/onedarkpro.nvim",
priority = 1000,
config = function()
local is_transparent = false
require("onedarkpro").setup({
styles = {
types = "NONE",
methods = "NONE",
numbers = "NONE",
strings = "NONE",
comments = "italic",
keywords = "bold,italic",
constants = "NONE",
functions = "italic",
operators = "NONE",
variables = "NONE",
parameters = "NONE",
conditionals = "italic",
virtual_text = "NONE",
tags = "italic",
},
colors = {
bg_statusline = "#282c34",
onedark = {
green = "#99c379",
gray = "#8094b4",
red = "#e06c75",
purple = "#c678dd",
yellow = "#e5c07a",
blue = "#61afef",
cyan = "#56b6c2",
indentline = "#3b4261",
float_bg = "#282c34",
},
onedark_dark = {
bg_statusline = "#000",
},
},
options = {
cursorline = true,
transparency = is_transparent,
terminal_colors = true,
},
highlights = {
-- overide cursor line fill colors
LineNr = { fg = "#49505E" }, -- Line number for ":number" and ":#" commands, and when 'number' or 'relativenumber' option is set.
CursorLineNr = { fg = "${blue}" }, -- Like LineNr when 'cursorline' or 'relativenumber' is set for the cursor line.
CursorLine = { bg = "#333842" },
Cursor = { fg = "${bg}", bg = "${fg}" }, -- character under the cursor
lCursor = { fg = "${bg}", bg = "${fg}" }, -- the character under the cursor when |language-mapping| is used (see 'guicursor')
CursorIM = { fg = "${bg}", bg = "${fg}" }, -- like Cursor, but used when in IME mode |CursorIM|
CursorColumn = { bg = "#333842" }, -- Screen-column at the cursor, when 'cursorcolumn' is set.
-- overide nvimtree folder icon fill color
NvimTreeFolderIcon = { fg = "${gray}" },
-- overide nvimtree text fill color folder opened
NvimTreeOpenedFolderName = { fg = "${blue}" },
-- overide nvimtree text fill color root folder
NvimTreeRootFolder = { fg = "${yellow}" },
NvimTreeSpecialFile = { fg = "${orange}" },
NvimTreeWinSeparator = { fg = "#202329" },
NvimTreeIndentMarker = { fg = "#3E4450" },
-- overide nvimtree cursorline
NvimTreeCursorLine = { bg = "#333842" },
-- overide indenline fill color
IblIndent = { fg = "#3E4450" },
-- overide cmp cursorline fill color with #333842
PmenuSel = { bg = "#333842" },
illuminatedWord = { bg = "#3b4261" },
illuminatedCurWord = { bg = "#3b4261" },
IlluminatedWordText = { bg = "#3b4261" },
IlluminatedWordRead = { bg = "#3b4261" },
IlluminatedWordWrite = { bg = "#3b4261" },
StatusLine = { fg = "#f8f8f2", bg = is_transparent and "NONE" or "${bg}" },
StatusLineTerm = { fg = "#f8f8f2", bg = "${bg}" },
BufferLineFill = { bg = is_transparent and "NONE" or "${bg}" },
["@string.special.url.html"] = { fg = "${green}" },
["@lsp.type.parameter"] = { fg = "${gray}" },
-- ["@text.uri.html"] = { fg = "${green}" },
-- ["@tag.javascript"] = { fg = "${red}" },
-- ["@tag.attribute"] = { fg = "${orange}", style = "italic" },
-- ["@constructor.javascript"] = { fg = "${red}" },
-- ["@variable"] = { fg = "${fg}", style = "NONE" }, -- various variable names
-- ["@variable.builtin"] = { fg = "${red}", style = "NONE" },
-- ["@variable.member"] = "${cyan}",
-- ["@variable.parameter"] = "${red}",
-- ["@property"] = { fg = "${cyan}" }, -- similar to `@field`
["@property.lua"] = { fg = "${red}", bg = "NONE" },
["@lsp.type.property.lua"] = { fg = "${cyan}", bg = "NONE" },
["@lsp.type.variable.lua"] = { fg = "${red}", bg = "NONE" },
NvimTreeGitDirty = { fg = "${yellow}" },
Pmenu = { fg = "${fg}", bg = "${bg}" },
PmenuThumb = { bg = "${gray}" }, -- Popup menu: Thumb of the scrollbar.
-- overide lualine fill color with bg color
LualineNormal = { bg = "${bg}" },
-- overide lualine_c fill color with bg color
LualineC = { bg = "${bg}" },
-- overide lualine_x fill color with bg color
LualineX = { bg = "${bg}" },
-- overide which-key fill color with bg color
-- WhichKey = { bg = "${bg}" },
-- -- overide which-key fill color with bg color
-- WhichKeySeperator = { bg = "${bg}" },
-- -- overide which-key fill color with bg color
-- WhichKeyDesc = { fg = "${red}" },
-- -- overide which-key fill color with bg color
-- WhichKeyFloat = { bg = "${bg}" },
WhichKeyFloat = { bg = is_transparent and "NONE" or "${bg}" },
-- -- overide which-key fill color with bg color
-- WhichKeyValue = { bg = "${bg}" },
-- -- overide which-key fill color with bg color
-- WhichKeyBorder = { bg = "${bg}" },
LspInfoBorder = { fg = "${fg}" },
NormalFloat = { fg = "${fg}", bg = is_transparent and "NONE" or "${bg}" },
Normal = { fg = "${fg}", bg = is_transparent and "NONE" or "${bg}" },
NormalNC = { fg = "${fg}", bg = is_transparent and "NONE" or "${bg}" },
FloatBorder = { fg = "${fg}", bg = is_transparent and "NONE" or "${bg}" },
NonText = { bg = "NONE", fg = "#3E4450" },
},
})
local colorscheme = pcode.themes.onedarkpro or "onedark"
vim.cmd("colorscheme " .. colorscheme)
end,
}

57
lua/pcode/plugins/toggleterm.lua Normal file
View file

@ -0,0 +1,57 @@
return {
"akinsho/toggleterm.nvim",
lazy = true,
cmd = {
"ToggleTerm",
"TermExec",
"ToggleTermToggleAll",
"ToggleTermSendCurrentLine",
"ToggleTermSendVisualLines",
"ToggleTermSendVisualSelection",
},
branch = "main",
enabled = true,
opts = {
size = 20,
open_mapping = [[<c-\>]],
hide_numbers = true,
shade_filetypes = {},
shade_terminals = true,
shading_factor = 2,
start_in_insert = true,
insert_mappings = true,
persist_size = true,
direction = "float",
close_on_exit = true,
shell = vim.o.shell,
float_opts = {
border = "curved",
winblend = 0,
highlights = {
border = "Normal",
background = "Normal",
},
},
},
config = function(_, opts)
require("toggleterm").setup(opts)
function _G.set_terminal_keymaps()
local optsn = { noremap = true }
vim.api.nvim_buf_set_keymap(0, "t", "<esc>", [[<C-\><C-n>]], optsn)
vim.api.nvim_buf_set_keymap(0, "t", "jk", [[<C-\><C-n>]], optsn)
vim.api.nvim_buf_set_keymap(0, "t", "<C-h>", [[<C-\><C-n><C-W>h]], optsn)
vim.api.nvim_buf_set_keymap(0, "t", "<C-j>", [[<C-\><C-n><C-W>j]], optsn)
vim.api.nvim_buf_set_keymap(0, "t", "<C-k>", [[<C-\><C-n><C-W>k]], optsn)
vim.api.nvim_buf_set_keymap(0, "t", "<C-l>", [[<C-\><C-n><C-W>l]], optsn)
end
vim.cmd("autocmd! TermOpen term://* lua set_terminal_keymaps()")
end,
keys = {
{ "<leader>t", "", desc = "  Terminal", mode = "n" },
{ "<leader>tx", "<cmd>ToggleTermToggleAll!<cr>", desc = "Close Tab", mode = "n" },
{ "<leader>tf", "<cmd>ToggleTerm direction=float<cr>", desc = "Float", mode = "n" },
{ "<leader>th", "<cmd>ToggleTerm size=10 direction=horizontal<cr>", desc = "Horizontal", mode = "n" },
{ "<leader>tv", "<cmd>ToggleTerm size=80 direction=vertical<cr>", desc = "Vertical", mode = "n" },
{ "<leader>ts", "<cmd>ToggleTerm direction=tab<cr>", desc = "New Tab", mode = "n" },
},
}

21
lua/pcode/plugins/webdevicon.lua Normal file
View file

@ -0,0 +1,21 @@
return {
"kyazdani42/nvim-web-devicons",
lazy = true,
dependencies = "pojokcodeid/nvim-material-icon",
opts = function()
local material_icon_ok, material_icon = pcall(require, "nvim-material-icon")
if not material_icon_ok then
return
end
material_icon.setup({
override = {},
})
return {
override = material_icon.get_icons(),
override_by_filename = {},
}
end,
config = function(_, opts)
require("nvim-web-devicons").setup(opts)
end,
}

74
lua/pcode/plugins/whichkey.lua Normal file
View file

@ -0,0 +1,74 @@
return {
"folke/which-key.nvim",
lazy = true,
keys = { "<leader>", '"', "'", "`", "c", "v" },
event = "VeryLazy",
opts = function()
return {
plugins = {
marks = true,
registers = true,
spelling = {
enabled = true,
suggestions = 20,
},
presets = {
operators = false,
motions = false,
text_objects = false,
windows = false,
nav = false,
z = false,
g = false,
},
},
icons = {
mappings = false,
},
win = {
row = -1,
border = "rounded", -- none, single, double, shadow
padding = { 1, 2 }, -- extra window padding [top/bottom, right/left]
title = true,
title_pos = "center",
zindex = 1000,
bo = {},
wo = {},
},
layout = {
height = { min = 4, max = 25 }, -- min and max height of the columns
width = { min = 20, max = 50 }, -- min and max width of the columns
spacing = 3, -- spacing between columns
align = "left", -- align columns left, center or right
},
show_help = true, -- show help message on the command line when the popup is visible
show_keys = true, -- show the currently pressed key and its label as a message in the command line
-- Disabled by default for Telescope
disable = {
buftypes = {},
filetypes = { "TelescopePrompt" },
},
---@type false | "classic" | "modern" | "helix"
preset = "classic",
mappings = {
{ "<leader>S", "", desc = " 󱑠 Plugins(Lazy)", mode = "n" },
{ "<leader>Si", "<cmd>Lazy install<cr>", desc = "Install", mode = "n" },
{ "<leader>Ss", "<cmd>Lazy sync<cr>", desc = "Sync", mode = "n" },
{ "<leader>SS", "<cmd>Lazy clear<cr>", desc = "Status", mode = "n" },
{ "<leader>Sc", "<cmd>Lazy clean<cr>", desc = "Clean", mode = "n" },
{ "<leader>Su", "<cmd>Lazy update<cr>", desc = "Update", mode = "n" },
{ "<leader>Sp", "<cmd>Lazy profile<cr>", desc = "Profile", mode = "n" },
{ "<leader>Sl", "<cmd>Lazy log<cr>", desc = "Log", mode = "n" },
{ "<leader>Sd", "<cmd>Lazy debug<cr>", desc = "Debug", mode = "n" },
{ "<leader>w", "<cmd>w!<CR>", desc = "󰆓 Save", mode = "n" },
{ "<leader>q", "<cmd>q!<CR>", desc = "󰿅 Quit", mode = "n" },
{ "<leader>h", "<cmd>nohlsearch<CR>", desc = "󱪿 No Highlight", mode = "n" },
},
}
end,
config = function(_, opts)
local which_key = require("which-key")
which_key.setup(opts)
which_key.add(opts.mappings)
end,
}