@a9s/cli 0.0.1 → 0.1.0

package/dist/src/hooks/useInputEventProcessor.js

@@ -0,0 +1,450 @@
+import { useCallback, useRef } from "react";
+import { KB } from "../constants/keys.js";
+import { KEYBINDINGS } from "../constants/keybindings.js";
+import { useKeyChord, matchesTrigger } from "./useKeyChord.js";
+import { resolveHelpScopeAction, resolveNavigateScopeAction, resolvePickerScopeAction, } from "./mainInputScopes.js";
+export function translateRawInputEvent(input, key, runtime, deps) {
+    if (runtime.helpOpen) {
+        const action = resolveHelpScopeAction(input, deps.resolve(input, key, "help"));
+        switch (action.type) {
+            case "close":
+                return { event: { scope: "help", type: "close" }, resetChord: true };
+            case "prevTab":
+                return { event: { scope: "help", type: "prevTab" }, resetChord: true };
+            case "nextTab":
+                return { event: { scope: "help", type: "nextTab" }, resetChord: true };
+            case "scrollUp":
+                return { event: { scope: "help", type: "scrollUp" }, resetChord: true };
+            case "scrollDown":
+                return { event: { scope: "help", type: "scrollDown" }, resetChord: true };
+            case "goToTab":
+                return {
+                    event: { scope: "help", type: "goToTab", input: action.input },
+                    resetChord: true,
+                };
+            case "none":
+                return { event: null, resetChord: false };
+        }
+    }
+    if (runtime.pickerMode) {
+        const action = resolvePickerScopeAction(key, runtime.pickerMode, deps.resolve(input, key, "picker"));
+        switch (action.type) {
+            case "consume":
+                return { event: null, resetChord: false };
+            case "close":
+                return {
+                    event: runtime.pickerMode === "search"
+                        ? { scope: "picker", type: "cancelSearch" }
+                        : { scope: "picker", type: "close" },
+                    resetChord: true,
+                };
+            case "search":
+                return { event: { scope: "picker", type: "startSearch" }, resetChord: true };
+            case "down":
+                return { event: { scope: "picker", type: "down" }, resetChord: true };
+            case "up":
+                return { event: { scope: "picker", type: "up" }, resetChord: true };
+            case "top":
+                return { event: { scope: "picker", type: "top" }, resetChord: true };
+            case "bottom":
+                return { event: { scope: "picker", type: "bottom" }, resetChord: true };
+            case "confirm":
+                return { event: { scope: "picker", type: "confirm" }, resetChord: true };
+            case "none":
+                return { event: null, resetChord: false };
+        }
+    }
+    if (input === "?" &&
+        runtime.mode === "navigate" &&
+        !runtime.uploadPending &&
+        !runtime.describeOpen &&
+        !runtime.yankMode &&
+        !runtime.pendingActionType) {
+        return { event: { scope: "modal", type: "openHelp" }, resetChord: true };
+    }
+    if (runtime.pendingActionType) {
+        if (runtime.pendingActionType === "prompt" && key.escape) {
+            return { event: { scope: "modal", type: "cancelPendingPrompt" }, resetChord: true };
+        }
+        if (runtime.pendingActionType === "confirm") {
+            if (input === "y" || input === "Y") {
+                return { event: { scope: "pending", type: "submit", confirmed: true }, resetChord: true };
+            }
+            if (input === "n" || input === "N" || key.escape) {
+                return {
+                    event: { scope: "pending", type: "submit", confirmed: false },
+                    resetChord: true,
+                };
+            }
+        }
+        return { event: null, resetChord: true };
+    }
+    if (runtime.uploadPending) {
+        const scrollAction = deps.resolve(input, key, "navigate");
+        if (scrollAction === KB.MOVE_DOWN) {
+            return { event: { scope: "scroll", type: "down" }, resetChord: true };
+        }
+        if (scrollAction === KB.MOVE_UP) {
+            return { event: { scope: "scroll", type: "up" }, resetChord: true };
+        }
+        if (input === "y" || input === "Y") {
+            return { event: { scope: "upload", type: "decision", confirmed: true }, resetChord: true };
+        }
+        if (input === "n" || input === "N" || key.escape) {
+            return {
+                event: { scope: "upload", type: "decision", confirmed: false },
+                resetChord: true,
+            };
+        }
+        return { event: null, resetChord: true };
+    }
+    if (runtime.describeOpen) {
+        const scrollAction = deps.resolve(input, key, "navigate");
+        if (scrollAction === KB.MOVE_DOWN) {
+            return { event: { scope: "scroll", type: "down" }, resetChord: true };
+        }
+        if (scrollAction === KB.MOVE_UP) {
+            return { event: { scope: "scroll", type: "up" }, resetChord: true };
+        }
+        if (key.escape) {
+            return { event: { scope: "modal", type: "closeDetails" }, resetChord: true };
+        }
+        return { event: null, resetChord: true };
+    }
+    if (runtime.yankMode) {
+        if (!runtime.selectedRow) {
+            return { event: null, resetChord: true };
+        }
+        if (input === "?") {
+            return { event: { scope: "modal", type: "openYankHelp" }, resetChord: true };
+        }
+        if (key.escape) {
+            return { event: { scope: "modal", type: "cancelYank" }, resetChord: true };
+        }
+        return { event: null, resetChord: true };
+    }
+    if (key.escape) {
+        if (runtime.mode === "search" || runtime.mode === "command") {
+            return { event: { scope: "mode", type: "cancelSearchOrCommand" }, resetChord: true };
+        }
+        return { event: { scope: "mode", type: "clearFilterOrNavigateBack" }, resetChord: true };
+    }
+    if (key.tab) {
+        const canAutocomplete = runtime.mode === "command" &&
+            runtime.commandText.length > 0 &&
+            deps.hasCommandAutocomplete(runtime.commandText);
+        return {
+            event: canAutocomplete ? { scope: "mode", type: "commandAutocomplete" } : null,
+            resetChord: true,
+        };
+    }
+    if (runtime.mode === "search" || runtime.mode === "command") {
+        return { event: null, resetChord: false };
+    }
+    const baseAction = deps.resolve(input, key, "navigate");
+    // Check for scroll actions (j/k) first before other navigate actions
+    if (baseAction === KB.MOVE_DOWN) {
+        return { event: { scope: "scroll", type: "down" }, resetChord: false };
+    }
+    if (baseAction === KB.MOVE_UP) {
+        return { event: { scope: "scroll", type: "up" }, resetChord: false };
+    }
+    const navAction = resolveNavigateScopeAction(baseAction);
+    switch (navAction.type) {
+        case "search":
+            return { event: { scope: "mode", type: "startSearch" }, resetChord: false };
+        case "command":
+            return { event: { scope: "mode", type: "startCommand" }, resetChord: false };
+        case "quit":
+            return { event: { scope: "navigation", type: "quit" }, resetChord: false };
+        case "refresh":
+            return { event: { scope: "navigation", type: "refresh" }, resetChord: false };
+        case "reveal":
+            return { event: { scope: "navigation", type: "reveal" }, resetChord: false };
+        case "yank":
+            return { event: { scope: "navigation", type: "enterYank" }, resetChord: false };
+        case "details":
+            return { event: { scope: "navigation", type: "showDetails" }, resetChord: false };
+        case "edit":
+            return { event: { scope: "navigation", type: "edit" }, resetChord: false };
+        case "bottom":
+            return { event: { scope: "navigation", type: "bottom" }, resetChord: false };
+        case "top":
+            return { event: { scope: "navigation", type: "top" }, resetChord: false };
+        case "enter":
+            return { event: { scope: "navigation", type: "enter" }, resetChord: false };
+        case "none":
+            return { event: null, resetChord: false };
+    }
+}
+export function resolveAdapterBindingEvent(input, key, bindings, pending, row) {
+    const scoped = bindings.filter((binding) => (binding.scope ?? "navigate") === "navigate");
+    const next = pending.length > 0 ? [...pending, input] : [input];
+    const chordHit = scoped.find((binding) => binding.trigger.type === "chord" &&
+        binding.trigger.keys.length === next.length &&
+        binding.trigger.keys.every((k, i) => k === next[i]));
+    if (chordHit) {
+        return {
+            event: { scope: "adapterAction", type: "run", actionId: chordHit.actionId, row },
+            nextPending: [],
+            consumed: true,
+        };
+    }
+    const isChordPrefix = scoped.some((binding) => binding.trigger.type === "chord" &&
+        binding.trigger.keys.length > next.length &&
+        binding.trigger.keys.slice(0, next.length).every((k, i) => k === next[i]));
+    if (isChordPrefix) {
+        return { event: null, nextPending: next, consumed: true };
+    }
+    const directHit = scoped.find((binding) => binding.trigger.type !== "chord" && matchesTrigger(input, key, binding.trigger));
+    if (directHit) {
+        return {
+            event: { scope: "adapterAction", type: "run", actionId: directHit.actionId, row },
+            nextPending: [],
+            consumed: true,
+        };
+    }
+    return { event: null, nextPending: [], consumed: false };
+}
+export function applyInputEvent(event, actions) {
+    switch (event.scope) {
+        case "system":
+            actions.app.exit();
+            return;
+        case "raw":
+            return;
+        case "help":
+            switch (event.type) {
+                case "close":
+                    actions.help.close();
+                    return;
+                case "prevTab":
+                    actions.help.prevTab();
+                    return;
+                case "nextTab":
+                    actions.help.nextTab();
+                    return;
+                case "scrollUp":
+                    actions.help.scrollUp();
+                    return;
+                case "scrollDown":
+                    actions.help.scrollDown();
+                    return;
+                case "goToTab":
+                    actions.help.goToTab(event.input);
+                    return;
+            }
+            return;
+        case "picker":
+            switch (event.type) {
+                case "close":
+                    actions.picker.close();
+                    return;
+                case "cancelSearch":
+                    actions.picker.cancelSearch();
+                    return;
+                case "startSearch":
+                    actions.picker.startSearch();
+                    return;
+                case "down":
+                    actions.picker.moveDown();
+                    return;
+                case "up":
+                    actions.picker.moveUp();
+                    return;
+                case "top":
+                    actions.picker.top();
+                    return;
+                case "bottom":
+                    actions.picker.bottom();
+                    return;
+                case "confirm":
+                    actions.picker.confirm();
+                    return;
+            }
+            return;
+        case "modal":
+            switch (event.type) {
+                case "openHelp":
+                    actions.help.open();
+                    return;
+                case "openYankHelp":
+                    actions.yank.openHelp();
+                    return;
+                case "closeYankHelp":
+                    actions.yank.closeHelp();
+                    return;
+                case "closeDetails":
+                    actions.details.close();
+                    return;
+                case "cancelYank":
+                    actions.yank.cancel();
+                    return;
+                case "cancelPendingPrompt":
+                    actions.pending.cancelPrompt();
+                    return;
+            }
+            return;
+        case "pending":
+            actions.pending.submit(event.confirmed);
+            return;
+        case "upload":
+            actions.upload.decide(event.confirmed);
+            return;
+        case "mode":
+            switch (event.type) {
+                case "cancelSearchOrCommand":
+                    actions.mode.cancelSearchOrCommand();
+                    return;
+                case "clearFilterOrNavigateBack":
+                    actions.mode.clearFilterOrNavigateBack();
+                    return;
+                case "startSearch":
+                    actions.mode.startSearch();
+                    return;
+                case "startCommand":
+                    actions.mode.startCommand();
+                    return;
+                case "commandAutocomplete":
+                    actions.mode.commandAutocomplete();
+                    return;
+            }
+            return;
+        case "navigation":
+            switch (event.type) {
+                case "quit":
+                    actions.app.exit();
+                    return;
+                case "refresh":
+                    actions.navigation.refresh();
+                    return;
+                case "reveal":
+                    actions.navigation.revealToggle();
+                    return;
+                case "enterYank":
+                    actions.yank.enter();
+                    return;
+                case "showDetails":
+                    actions.navigation.showDetails();
+                    return;
+                case "edit":
+                    actions.navigation.editSelection();
+                    return;
+                case "bottom":
+                    actions.navigation.bottom();
+                    return;
+                case "top":
+                    actions.navigation.top();
+                    return;
+                case "enter":
+                    actions.navigation.enter();
+                    return;
+            }
+            return;
+        case "scroll":
+            switch (event.type) {
+                case "up":
+                    actions.scroll.up();
+                    return;
+                case "down":
+                    actions.scroll.down();
+                    return;
+            }
+            return;
+        case "adapterAction":
+            actions.adapterAction.run(event.actionId, event.row);
+            return;
+    }
+}
+export function useInputEventProcessor({ runtime, actions, yankOptions, pushYankFeedback, writeClipboard, hasCommandAutocomplete, }) {
+    const { resolve, reset } = useKeyChord(KEYBINDINGS);
+    const adapterPendingRef = useRef([]);
+    const pendingYankHelpRef = useRef(false);
+    const resetAllChords = useCallback(() => {
+        reset();
+        adapterPendingRef.current = [];
+    }, [reset]);
+    return useCallback((event) => {
+        if (event.scope === "raw") {
+            // Support fast "y ?" combo even before yankMode state is committed.
+            if (pendingYankHelpRef.current) {
+                if (event.input === "?") {
+                    pendingYankHelpRef.current = false;
+                    resetAllChords();
+                    actions.yank.openHelp();
+                    return;
+                }
+                pendingYankHelpRef.current = false;
+            }
+            if (runtime.yankHelpOpen) {
+                if (event.input === "?" || event.key.escape) {
+                    resetAllChords();
+                    actions.yank.closeHelp();
+                }
+                return;
+            }
+            if (runtime.yankMode) {
+                if (!runtime.selectedRow) {
+                    resetAllChords();
+                    return;
+                }
+                if (event.input === "?") {
+                    resetAllChords();
+                    actions.yank.openHelp();
+                    return;
+                }
+                if (event.key.escape) {
+                    resetAllChords();
+                    actions.yank.cancel();
+                    return;
+                }
+                const option = yankOptions.find((o) => matchesTrigger(event.input, event.key, o.trigger));
+                resetAllChords();
+                if (!option)
+                    return;
+                actions.yank.cancel();
+                void option.resolve(runtime.selectedRow).then((value) => {
+                    if (!value)
+                        return;
+                    void writeClipboard(value).then(() => pushYankFeedback(option.feedback));
+                });
+                return;
+            }
+            const translated = translateRawInputEvent(event.input, event.key, runtime, {
+                resolve: (input, key, scope) => resolve(input, key, scope),
+                hasCommandAutocomplete,
+            });
+            if (translated.resetChord) {
+                resetAllChords();
+            }
+            if (translated.event) {
+                if (translated.event.scope === "navigation" && translated.event.type === "enterYank") {
+                    pendingYankHelpRef.current = true;
+                }
+                applyInputEvent(translated.event, actions);
+                return;
+            }
+            const adapterResolved = resolveAdapterBindingEvent(event.input, event.key, actions.adapterAction.bindings, adapterPendingRef.current, runtime.selectedRow);
+            adapterPendingRef.current = adapterResolved.nextPending;
+            if (adapterResolved.event) {
+                reset();
+                applyInputEvent(adapterResolved.event, actions);
+                return;
+            }
+            return;
+        }
+        if (event.scope === "system") {
+            applyInputEvent(event, actions);
+        }
+    }, [
+        actions,
+        hasCommandAutocomplete,
+        pushYankFeedback,
+        reset,
+        resetAllChords,
+        resolve,
+        runtime,
+        writeClipboard,
+        yankOptions,
+    ]);
+}

package/dist/src/hooks/useInputEventProcessor.test.js

@@ -0,0 +1,174 @@
+import { describe, expect, it, vi } from "vitest";
+import { KB } from "../constants/keys.js";
+import { applyInputEvent, resolveAdapterBindingEvent, translateRawInputEvent, } from "./useInputEventProcessor.js";
+import { textCell } from "../types.js";
+const key = (patch = {}) => ({
+    upArrow: false,
+    downArrow: false,
+    leftArrow: false,
+    rightArrow: false,
+    pageDown: false,
+    pageUp: false,
+    home: false,
+    end: false,
+    return: false,
+    escape: false,
+    ctrl: false,
+    shift: false,
+    tab: false,
+    backspace: false,
+    delete: false,
+    meta: false,
+    ...patch,
+});
+const baseRuntime = {
+    mode: "navigate",
+    filterText: "",
+    commandText: "",
+    searchEntryFilter: null,
+    yankMode: false,
+    yankHelpOpen: false,
+    selectedRow: null,
+    helpOpen: false,
+    pickerMode: null,
+    describeOpen: false,
+    uploadPending: false,
+    pendingActionType: null,
+};
+describe("translateRawInputEvent", () => {
+    it("maps help scope actions first", () => {
+        const result = translateRawInputEvent("", key(), { ...baseRuntime, helpOpen: true }, {
+            resolve: () => KB.HELP_CLOSE,
+            hasCommandAutocomplete: () => false,
+        });
+        expect(result).toEqual({
+            event: { scope: "help", type: "close" },
+            resetChord: true,
+        });
+    });
+    it("consumes picker search typing", () => {
+        const result = translateRawInputEvent("a", key(), { ...baseRuntime, pickerMode: "search" }, {
+            resolve: () => null,
+            hasCommandAutocomplete: () => false,
+        });
+        expect(result).toEqual({ event: null, resetChord: false });
+    });
+    it("maps pending confirm y/n", () => {
+        const yes = translateRawInputEvent("y", key(), { ...baseRuntime, pendingActionType: "confirm" }, {
+            resolve: () => null,
+            hasCommandAutocomplete: () => false,
+        });
+        expect(yes.event).toEqual({ scope: "pending", type: "submit", confirmed: true });
+    });
+    it("maps y ? to yank help when yank mode is active", () => {
+        const result = translateRawInputEvent("?", key(), { ...baseRuntime, yankMode: true, selectedRow: { id: "r1", cells: { name: textCell("x") } } }, {
+            resolve: () => null,
+            hasCommandAutocomplete: () => false,
+        });
+        expect(result).toEqual({
+            event: { scope: "modal", type: "openYankHelp" },
+            resetChord: true,
+        });
+    });
+});
+describe("resolveAdapterBindingEvent", () => {
+    it("resolves adapter chord keybindings like g p", () => {
+        const row = { id: "row-1", cells: { name: textCell("n") } };
+        const first = resolveAdapterBindingEvent("g", key(), [
+            {
+                trigger: { type: "chord", keys: ["g", "p"] },
+                actionId: "jump-to-path",
+                label: "jump",
+                adapterId: "s3",
+            },
+        ], [], row);
+        expect(first.event).toBeNull();
+        expect(first.nextPending).toEqual(["g"]);
+        const second = resolveAdapterBindingEvent("p", key(), [
+            {
+                trigger: { type: "chord", keys: ["g", "p"] },
+                actionId: "jump-to-path",
+                label: "jump",
+                adapterId: "s3",
+            },
+        ], first.nextPending, row);
+        expect(second.event).toEqual({
+            scope: "adapterAction",
+            type: "run",
+            actionId: "jump-to-path",
+            row,
+        });
+    });
+});
+describe("applyInputEvent", () => {
+    it("routes event to grouped action handlers", () => {
+        const actions = {
+            app: { exit: vi.fn() },
+            help: {
+                open: vi.fn(),
+                close: vi.fn(),
+                prevTab: vi.fn(),
+                nextTab: vi.fn(),
+                scrollUp: vi.fn(),
+                scrollDown: vi.fn(),
+                goToTab: vi.fn(),
+            },
+            picker: {
+                close: vi.fn(),
+                cancelSearch: vi.fn(),
+                startSearch: vi.fn(),
+                moveDown: vi.fn(),
+                moveUp: vi.fn(),
+                top: vi.fn(),
+                bottom: vi.fn(),
+                confirm: vi.fn(),
+            },
+            mode: {
+                cancelSearchOrCommand: vi.fn(),
+                clearFilterOrNavigateBack: vi.fn(),
+                startSearch: vi.fn(),
+                startCommand: vi.fn(),
+                commandAutocomplete: vi.fn(),
+            },
+            navigation: {
+                refresh: vi.fn(),
+                revealToggle: vi.fn(),
+                showDetails: vi.fn(),
+                editSelection: vi.fn(),
+                top: vi.fn(),
+                bottom: vi.fn(),
+                enter: vi.fn(),
+            },
+            scroll: {
+                up: vi.fn(),
+                down: vi.fn(),
+            },
+            yank: {
+                enter: vi.fn(),
+                cancel: vi.fn(),
+                openHelp: vi.fn(),
+                closeHelp: vi.fn(),
+            },
+            details: {
+                close: vi.fn(),
+            },
+            pending: {
+                cancelPrompt: vi.fn(),
+                submit: vi.fn(),
+            },
+            upload: {
+                decide: vi.fn(),
+            },
+            adapterAction: {
+                run: vi.fn(),
+                bindings: [],
+            },
+        };
+        applyInputEvent({ scope: "navigation", type: "refresh" }, actions);
+        expect(actions.navigation.refresh).toHaveBeenCalledTimes(1);
+        applyInputEvent({ scope: "modal", type: "openHelp" }, actions);
+        expect(actions.help.open).toHaveBeenCalledTimes(1);
+        applyInputEvent({ scope: "modal", type: "openYankHelp" }, actions);
+        expect(actions.yank.openHelp).toHaveBeenCalledTimes(1);
+    });
+});