mirror of https://github.com/folke/lazy.nvim.git
125 lines
3.0 KiB
Lua
125 lines
3.0 KiB
Lua
local Util = require("lazy.core.util")
|
|
local Loader = require("lazy.core.loader")
|
|
|
|
---@class LazyKeys
|
|
---@field [1] string lhs
|
|
---@field [2]? string|fun() rhs
|
|
---@field desc? string
|
|
---@field mode? string|string[]
|
|
---@field noremap? boolean
|
|
---@field remap? boolean
|
|
---@field expr? boolean
|
|
---@field id string
|
|
|
|
---@class LazyKeysHandler:LazyHandler
|
|
local M = {}
|
|
|
|
---@param feed string
|
|
function M.replace_special(feed)
|
|
for special, key in pairs({ leader = vim.g.mapleader or "\\", localleader = vim.g.maplocalleader or "\\" }) do
|
|
local pattern = "<"
|
|
for i = 1, #special do
|
|
pattern = pattern .. "[" .. special:sub(i, i) .. special:upper():sub(i, i) .. "]"
|
|
end
|
|
pattern = pattern .. ">"
|
|
feed = feed:gsub(pattern, key)
|
|
end
|
|
return feed
|
|
end
|
|
|
|
function M.retrigger(keys)
|
|
local pending = ""
|
|
while true do
|
|
---@type number|string
|
|
local c = vim.fn.getchar(0)
|
|
if c == 0 then
|
|
break
|
|
end
|
|
c = type(c) == "number" and vim.fn.nr2char(c) or c
|
|
pending = pending .. c
|
|
end
|
|
local op = vim.v.operator
|
|
if op and op ~= "" and vim.api.nvim_get_mode().mode:find("o") then
|
|
keys = "<esc>" .. op .. keys
|
|
end
|
|
local feed = keys .. pending
|
|
feed = M.replace_special(feed)
|
|
if vim.v.count ~= 0 then
|
|
feed = vim.v.count .. feed
|
|
end
|
|
vim.api.nvim_input(feed)
|
|
end
|
|
|
|
---@param value string|LazyKeys
|
|
function M.parse(value)
|
|
local ret = vim.deepcopy(value)
|
|
ret = type(ret) == "string" and { ret } or ret --[[@as LazyKeys]]
|
|
ret.mode = ret.mode or "n"
|
|
ret.id = (ret[1] or "")
|
|
if ret.mode then
|
|
local mode = ret.mode
|
|
if type(mode) == "table" then
|
|
---@cast mode string[]
|
|
table.sort(mode)
|
|
ret.id = ret.id .. " (" .. table.concat(mode, ", ") .. ")"
|
|
elseif mode ~= "n" then
|
|
ret.id = ret.id .. " (" .. mode .. ")"
|
|
end
|
|
end
|
|
return ret
|
|
end
|
|
|
|
---@param plugin LazyPlugin
|
|
function M:values(plugin)
|
|
---@type table<string,any>
|
|
local values = {}
|
|
---@diagnostic disable-next-line: no-unknown
|
|
for _, value in ipairs(plugin[self.type] or {}) do
|
|
local keys = M.parse(value)
|
|
if keys[2] == vim.NIL or keys[2] == false then
|
|
values[keys.id] = nil
|
|
else
|
|
values[keys.id] = keys
|
|
end
|
|
end
|
|
return values
|
|
end
|
|
|
|
function M.opts(keys)
|
|
local opts = {}
|
|
for k, v in pairs(keys) do
|
|
if type(k) ~= "number" and k ~= "mode" and k ~= "id" then
|
|
opts[k] = v
|
|
end
|
|
end
|
|
return opts
|
|
end
|
|
|
|
---@param keys LazyKeys
|
|
function M:_add(keys)
|
|
local lhs = keys[1]
|
|
local opts = M.opts(keys)
|
|
vim.keymap.set(keys.mode, lhs, function()
|
|
local plugins = self.active[keys.id]
|
|
|
|
-- always delete the mapping immediately to prevent recursive mappings
|
|
self:_del(keys)
|
|
self.active[keys.id] = nil
|
|
|
|
Util.track({ keys = lhs })
|
|
Loader.load(plugins, { keys = lhs })
|
|
M.retrigger(lhs)
|
|
Util.track()
|
|
end, opts)
|
|
end
|
|
|
|
---@param keys LazyKeys
|
|
function M:_del(keys)
|
|
pcall(vim.keymap.del, keys.mode, keys[1])
|
|
if keys[2] then
|
|
vim.keymap.set(keys.mode, keys[1], keys[2], M.opts(keys))
|
|
end
|
|
end
|
|
|
|
return M
|