--- @since 26.9.1 local MODE_DIRECTORY = "directory" local MODE_FILE = "file" local MODE_EITHER = "either" local DIRECTION_FORWARD = "forward" local DIRECTION_BACKWARD = "backward" local CASE_SENSITIVE = "sensitive" local CASE_INSENSITIVE = "insensitive" local CASE_SMART = "smart" local FIND_ACTION = "find_do" local ACTION_ENTER = "enter" local ACTION_OPEN_HOVERED = "open-hovered" local ACTION_NONE = "none" local EVENT_TYPE = "type" local EVENT_SUBMIT = "submit" local EVENT_CANCEL = "cancel" local EVENT_CLOSED = "closed" local UPDATE_SUCCESS = "success" local UPDATE_FAILURE = "failure" local ERROR_STATUS_CLEAR = false local COMMON_PROMPT_DATA = { name = "find", history = "shared", value = "", obscure = false, realtime = true, debounce = 0.05, pos = { "top-center", x = 0, y = 2, w = 50, h = 3 }, } local ACCEPTED_OPTIONS = { previous = true, smart = true, insensitive = true, } local function parse_mode(value) if value == MODE_DIRECTORY or value == MODE_FILE or value == MODE_EITHER then return value end error("yazi-enter: mode must be directory, file, or either", 0) end local function normalize_boolean(name, value) if value == nil or value == false or value == "no" then return false end if value == true or value == "yes" then return true end error(("yazi-enter: option --%s must be true, false, 'yes', or 'no'"):format(name), 0) end local function normalize_options(args) return normalize_boolean("previous", args.previous), normalize_boolean("smart", args.smart), normalize_boolean("insensitive", args.insensitive) end local function validate_argument_keys(args) for key in pairs(args) do local key_type = type(key) if key_type == "number" and key ~= 1 then error(("yazi-enter: unexpected positional argument at index %s"):format(key), 0) elseif key_type == "string" and not ACCEPTED_OPTIONS[key] then error(("yazi-enter: unknown option --%s"):format(key), 0) elseif key_type ~= "number" and key_type ~= "string" then error("yazi-enter: argument keys must be positional indexes or option names", 0) end end end local function derive_direction(previous) if previous then return DIRECTION_BACKWARD end return DIRECTION_FORWARD end local function derive_effective_case(smart, insensitive) if smart then return CASE_SMART end if insensitive then return CASE_INSENSITIVE end return CASE_SENSITIVE end local function parse_invocation_intent(args) local mode = parse_mode(args[1]) local previous, smart, insensitive = normalize_options(args) validate_argument_keys(args) return { mode = mode, previous = previous, smart = smart, insensitive = insensitive, direction = derive_direction(previous), effective_case = derive_effective_case(smart, insensitive), } end local function decide_target(mode, is_dir) if mode == MODE_DIRECTORY then if is_dir then return ACTION_ENTER end return ACTION_NONE end if mode == MODE_FILE then if is_dir then return ACTION_NONE end return ACTION_OPEN_HOVERED end if mode == MODE_EITHER then if is_dir then return ACTION_ENTER end return ACTION_OPEN_HOVERED end return ACTION_NONE end local commit = ya.sync(function(_, mode, submitted_query) local tab = cx.active local finder = tab.finder local target = tab.current.hovered if finder == nil then return 0 end if target == nil then return 0 end if tostring(finder) ~= submitted_query then return 0 end if target:highlights() == nil then return 0 end local is_dir = target.cha.is_dir local decision = decide_target(mode, is_dir) if decision == ACTION_NONE then return 0 end if decision == ACTION_ENTER then ya.emit("enter", {}) elseif decision == ACTION_OPEN_HOVERED then ya.emit("open", { hovered = true }) end return 1 end) local function new_find_request(query, search_policy) return { query, previous = search_policy.previous, smart = search_policy.smart, insensitive = search_policy.insensitive, } end local function apply_find(query, search_policy) local ok, reply_or_error = pcall(ya.exec, FIND_ACTION, new_find_request(query, search_policy)) if ok then return UPDATE_SUCCESS, ERROR_STATUS_CLEAR end return UPDATE_FAILURE, reply_or_error end local function new_prompt_specification(direction) return { name = COMMON_PROMPT_DATA.name, history = COMMON_PROMPT_DATA.history, value = COMMON_PROMPT_DATA.value, obscure = COMMON_PROMPT_DATA.obscure, realtime = COMMON_PROMPT_DATA.realtime, debounce = COMMON_PROMPT_DATA.debounce, pos = { COMMON_PROMPT_DATA.pos[1], x = COMMON_PROMPT_DATA.pos.x, y = COMMON_PROMPT_DATA.pos.y, w = COMMON_PROMPT_DATA.pos.w, h = COMMON_PROMPT_DATA.pos.h, }, title = direction == DIRECTION_BACKWARD and "Find previous:" or "Find next:", } end local function require_plain_data(label, value, active_tables) local value_type = type(value) if value_type == "string" or value_type == "boolean" or value_type == "number" then return end if value_type ~= "table" or getmetatable(value) ~= nil then error(("yazi-enter: %s must use plain boundary data"):format(label), 0) end active_tables = active_tables or {} if active_tables[value] then error(("yazi-enter: %s must not contain a table cycle"):format(label), 0) end active_tables[value] = true for key, item in pairs(value) do local key_type = type(key) if key_type ~= "string" and key_type ~= "number" then error(("yazi-enter: %s must use string or number table keys"):format(label), 0) end require_plain_data(label, item, active_tables) end active_tables[value] = nil end local function require_string(label, value) if type(value) ~= "string" then error(("yazi-enter: %s must be a string"):format(label), 0) end end local function new_search_policy(intent) if type(intent.previous) ~= "boolean" or type(intent.smart) ~= "boolean" or type(intent.insensitive) ~= "boolean" then error("yazi-enter: search policy values must be Booleans", 0) end return { previous = intent.previous, smart = intent.smart, insensitive = intent.insensitive, } end local function new_application_boundaries( prompt_capability, find_update_capability, commit_capability, target_dispatch_capability ) return { prompt = function(prompt_data) if type(prompt_data) ~= "table" then error("yazi-enter: prompt data must be a table", 0) end require_plain_data("prompt data", prompt_data) return prompt_capability(prompt_data) end, find_update = function(query, search_policy) require_string("Find query", query) if type(search_policy) ~= "table" then error("yazi-enter: search policy must be a table", 0) end require_plain_data("search policy", search_policy) local result, error_status = find_update_capability(query, search_policy) if result ~= UPDATE_SUCCESS and result ~= UPDATE_FAILURE then error("yazi-enter: Find update capability returned an invalid result", 0) end return result, error_status end, commit = function(mode, submitted_query) require_string("commit mode", mode) require_string("submitted query", submitted_query) local dispatch_count = commit_capability(mode, submitted_query) if dispatch_count ~= 0 and dispatch_count ~= 1 then error("yazi-enter: commit capability returned an invalid dispatch count", 0) end return dispatch_count end, target_dispatch = function(decision) if decision ~= ACTION_ENTER and decision ~= ACTION_OPEN_HOVERED then error("yazi-enter: target dispatch capability received an invalid decision", 0) end target_dispatch_capability(decision) end, } end local function new_invocation_state(intent, receiver) require_plain_data("invocation intent", intent) return { intent = intent, receiver = receiver, current_query = "", error_status = ERROR_STATUS_CLEAR, } end local function run_selection_session(intent, boundaries) local receiver = boundaries.prompt(new_prompt_specification(intent.direction)) local state = new_invocation_state(intent, receiver) while true do local query, event = state.receiver:recv() if event == 3 then state.current_query = query local result, error_status = boundaries.find_update( state.current_query, new_search_policy(state.intent) ) if result == UPDATE_SUCCESS then state.error_status = ERROR_STATUS_CLEAR else state.error_status = error_status end elseif event == 1 then state.current_query = query local result, error_status = boundaries.find_update( state.current_query, new_search_policy(state.intent) ) state.error_status = error_status if result == UPDATE_SUCCESS then return boundaries.commit(state.intent.mode, state.current_query) end return 0 elseif event == 2 then return 0 else return 0 end end end local function run_entry(job) local intent = parse_invocation_intent(job.args) local boundaries = new_application_boundaries( ya.input, apply_find, commit, function() error("yazi-enter: target dispatch is owned by the commit transaction", 0) end ) return run_selection_session(intent, boundaries) end return { entry = function(_, job) return run_entry(job) end, }