terminal-pilot 0.0.50 → 0.0.52

package/node_modules/toolcraft-design/dist/explorer/keymap.js

@@ -1,376 +1,117 @@
-const builtinBindings = {
-    quit: ["q", "Ctrl+c"],
-    filter: ["/"],
-    help: ["?"],
-    palette: ["Ctrl+p", "Ctrl+k"],
-    cursorUp: ["up", "k"],
-    cursorDown: ["down", "j"],
-    top: ["home", "gg"],
-    bottom: ["end", "G"],
-    pageUp: ["pageup", "Ctrl+u"],
-    pageDown: ["pagedown", "Ctrl+d"],
+const BUILTINS = {
+    quit: ["Ctrl+c"],
+    filter: [],
+    help: [],
+    palette: ["Ctrl+p"],
+    cursorUp: ["up"],
+    cursorDown: ["down"],
+    top: ["home"],
+    bottom: ["end"],
+    pageUp: ["pageup"],
+    pageDown: ["pagedown"],
+    halfPageUp: ["Ctrl+u"],
+    halfPageDown: ["Ctrl+d"],
     focusNext: ["tab"],
     escape: ["escape"],
     confirm: ["return", "enter"],
     toggleSelect: ["space"],
     selectAll: ["Ctrl+a"],
     clearSelection: ["Ctrl+/"],
-    detailScrollDown: ["Ctrl+f"],
-    detailScrollUp: ["Ctrl+b"],
+    detailScrollDown: [],
+    detailScrollUp: [],
     extendSelectionUp: ["Shift+up"],
     extendSelectionDown: ["Shift+down"],
-    reorderUp: ["Shift+up", "K"],
-    reorderDown: ["Shift+down", "J"]
+    reorderUp: ["Shift+up"],
+    reorderDown: ["Shift+down"]
 };
-const baseBuiltinCommands = [
-    "quit",
-    "filter",
-    "help",
-    "palette",
-    "cursorUp",
-    "cursorDown",
-    "top",
-    "bottom",
-    "pageUp",
-    "pageDown",
-    "focusNext",
-    "escape",
-    "confirm",
-    "toggleSelect",
-    "selectAll",
-    "clearSelection",
-    "detailScrollDown",
-    "detailScrollUp",
-    "extendSelectionUp",
-    "extendSelectionDown"
-];
-const reorderCommands = ["reorderUp", "reorderDown"];
-const selectionCommands = new Set([
-    "toggleSelect",
-    "selectAll",
-    "clearSelection",
-    "extendSelectionUp",
-    "extendSelectionDown"
-]);
-const reservedActionIds = new Set(["quit"]);
+const CORE_ACCELERATORS = new Set(["c", "u", "d", "p"]);
 export function resolveBindings(config, defaults = {}) {
-    const baseCommands = config.reorder === undefined
-        ? baseBuiltinCommands
-        : [
-            ...baseBuiltinCommands.filter((command) => command !== "extendSelectionUp" && command !== "extendSelectionDown"),
-            ...reorderCommands
-        ];
-    const commands = config.multiSelect === false
-        ? baseCommands.filter((command) => !selectionCommands.has(command))
-        : baseCommands;
-    const commandBindings = new Map();
-    const flatBindings = new Map();
-    const targetKeys = new Map();
-    const targetsByCommand = new Map();
-    const claimed = new Map();
-    const conflicts = new Map();
+    assertNoBareLetterBindings(config);
+    assertAcceleratorsFree(config);
+    const bindings = new Map();
+    const keysByTarget = new Map();
+    const commands = Object.keys(BUILTINS).filter(command => {
+        if (config.multiSelect === false && ["toggleSelect", "selectAll", "clearSelection", "extendSelectionUp", "extendSelectionDown"].includes(command))
+            return false;
+        if (config.reorder === undefined && (command === "reorderUp" || command === "reorderDown"))
+            return false;
+        if (config.reorder !== undefined && (command === "extendSelectionUp" || command === "extendSelectionDown"))
+            return false;
+        return true;
+    });
     for (const command of commands) {
-        const target = { type: "builtin", id: command };
-        const keys = command === "quit"
-            ? builtinBindings.quit
-            : defaults[command] ?? builtinBindings[command];
-        addBindings({
-            keys,
-            owner: command,
-            commandId: `builtin:${command}`,
-            target,
-            commandBindings,
-            flatBindings,
-            targetKeys,
-            targetsByCommand,
-            claimed,
-            conflicts,
-            warn: false
-        });
+        const keys = command === "quit" ? BUILTINS.quit : (defaults[command] ?? BUILTINS[command]);
+        add(keys, { type: "builtin", id: command }, bindings, keysByTarget);
     }
-    for (const action of [...config.actions, ...(config.detail.actions ?? [])]) {
-        if (reservedActionIds.has(action.id)) {
-            continue;
-        }
-        const keys = toBindingArray(config.keybindOverrides?.[action.id] ?? action.key);
-        addBindings({
-            keys,
-            owner: action.id,
-            commandId: `action:${action.id}`,
-            target: { type: "action", id: action.id },
-            commandBindings,
-            flatBindings,
-            targetKeys,
-            targetsByCommand,
-            claimed,
-            conflicts,
-            warn: true
-        });
-    }
-    if (process.env.NODE_ENV !== "production") {
-        for (const warning of conflicts.values()) {
-            process.stderr.write(`${warning}\n`);
-        }
+    for (const action of allActions(config)) {
+        if (action.accelerator !== undefined)
+            add([`Ctrl+${action.accelerator}`], { type: "action", id: action.id }, bindings, keysByTarget);
     }
-    const commandIds = Array.from(commandBindings.keys());
-    const defaultKeymapBindings = Object.fromEntries(Array.from(commandBindings.entries()));
-    const resolveCommand = createKeymap(commandIds, defaultKeymapBindings);
     return {
-        bindings: flatBindings,
-        keysByTarget: targetKeys,
-        resolve: (event) => {
-            const command = resolveCommand(event);
-            return command === undefined ? undefined : targetsByCommand.get(command);
-        }
+        bindings,
+        keysByTarget,
+        resolve: event => bindings.get(eventKey(event))
     };
 }
-function addBindings(opts) {
-    const accepted = [];
-    for (const key of opts.keys) {
-        const canonical = canonicalizeBinding(key);
-        if (canonical === undefined) {
-            continue;
-        }
-        const existing = opts.claimed.get(canonical);
-        if (existing !== undefined) {
-            if (existing !== opts.owner && opts.warn) {
-                opts.conflicts.set(`${opts.owner}:${canonical}`, `Explorer key binding conflict: ${key} for ${opts.owner} is already bound to ${existing}`);
-            }
-            continue;
-        }
-        opts.claimed.set(canonical, opts.owner);
-        opts.flatBindings.set(canonical, opts.target);
-        accepted.push(key);
+export function assertNoBareLetterBindings(config) {
+    for (const action of allActions(config)) {
+        const legacy = action.key === undefined ? [] : (Array.isArray(action.key) ? action.key : [action.key]);
+        if (legacy.length > 0)
+            throw new Error(`Explorer action ${action.id} uses a bare key; use accelerator instead`);
     }
-    if (accepted.length > 0) {
-        opts.commandBindings.set(opts.commandId, accepted);
-        opts.targetKeys.set(targetKey(opts.target), accepted);
-        opts.targetsByCommand.set(opts.commandId, opts.target);
+    if (config.keybindOverrides !== undefined && Object.keys(config.keybindOverrides).length > 0) {
+        throw new Error("Explorer keybind overrides are not supported because printable keys belong to filtering");
     }
-    return accepted;
 }
-function targetKey(target) {
-    return `${target.type}:${target.id}`;
-}
-function toBindingArray(value) {
-    if (value === undefined) {
-        return [];
-    }
-    return Array.isArray(value) ? value : [value];
-}
-function createKeymap(commands, defaultBindings) {
-    const bindings = new Map();
-    const sequences = new Set();
-    let pendingSequence = "";
-    for (const command of commands) {
-        const commandBindings = defaultBindings[command]
-            .map(parseBinding)
-            .filter((binding) => binding !== undefined);
-        for (const binding of commandBindings) {
-            if (binding.sequence !== undefined) {
-                sequences.add(binding.sequence);
-            }
-        }
-        bindings.set(command, commandBindings);
-    }
-    return (event) => {
-        for (const command of commands) {
-            const commandBindings = bindings.get(command);
-            if (commandBindings?.some((binding) => matchesSingleKey(binding, event))) {
-                pendingSequence = "";
-                return command;
-            }
-        }
-        const token = eventToSequenceToken(event);
-        if (token === undefined) {
-            pendingSequence = "";
-            return undefined;
-        }
-        pendingSequence = `${pendingSequence}${token}`;
-        for (const command of commands) {
-            const commandBindings = bindings.get(command);
-            if (commandBindings?.some((binding) => binding.sequence === pendingSequence)) {
-                pendingSequence = "";
-                return command;
-            }
-        }
-        if (hasSequencePrefix(sequences, pendingSequence)) {
-            return undefined;
-        }
-        pendingSequence = token;
-        if (hasSequencePrefix(sequences, pendingSequence)) {
-            return undefined;
-        }
-        pendingSequence = "";
-        return undefined;
-    };
-}
-function canonicalizeBinding(binding) {
-    const parsed = parseBinding(binding);
-    if (parsed === undefined) {
-        return undefined;
-    }
-    const modifiers = [
-        parsed.ctrl ? "ctrl" : undefined,
-        parsed.meta ? "meta" : undefined,
-        parsed.shift ? "shift" : undefined
-    ].filter((modifier) => modifier !== undefined);
-    const key = parsed.name ?? parsed.ch;
-    if (parsed.sequence !== undefined) {
-        return parsed.sequence.toLowerCase();
-    }
-    return key === undefined ? undefined : [...modifiers, key.toLowerCase()].join("+");
-}
-function parseBinding(binding) {
-    const value = binding.trim();
-    if (value.length === 0) {
-        return undefined;
-    }
-    const parts = value.split("+").map((part) => part.trim()).filter(Boolean);
-    if (parts.length === 0) {
-        return undefined;
-    }
-    let ctrl = false;
-    let meta = false;
-    let shift = false;
-    const key = parts.at(-1);
-    if (key === undefined) {
-        return undefined;
-    }
-    for (const modifier of parts.slice(0, -1)) {
-        const normalized = modifier.toLowerCase();
-        if (normalized === "ctrl" || normalized === "control") {
-            ctrl = true;
-            continue;
-        }
-        if (normalized === "meta" || normalized === "alt") {
-            meta = true;
+export function assertAcceleratorsFree(config) {
+    const claimed = new Map();
+    for (const action of allActions(config)) {
+        if (action.accelerator === undefined)
             continue;
-        }
-        if (normalized === "shift") {
-            shift = true;
-        }
-    }
-    const normalizedKey = normalizeKeyName(key);
-    if (parts.length === 1 && isShiftedCharacter(normalizedKey)) {
-        shift = true;
-    }
-    if (normalizedKey.length === 1) {
-        return {
-            ch: normalizeBindingCharacter(normalizedKey, shift),
-            ctrl,
-            meta,
-            shift
-        };
+        const accelerator = action.accelerator.toLowerCase();
+        if (accelerator.length !== 1 || accelerator < "a" || accelerator > "z")
+            throw new Error(`Explorer action ${action.id} accelerator must be one letter`);
+        if (CORE_ACCELERATORS.has(accelerator))
+            throw new Error(`Explorer action ${action.id} accelerator Ctrl+${accelerator.toUpperCase()} collides with a core key`);
+        const owner = claimed.get(accelerator);
+        if (owner !== undefined)
+            throw new Error(`Explorer actions ${owner} and ${action.id} share Ctrl+${accelerator.toUpperCase()}`);
+        claimed.set(accelerator, action.id);
     }
-    if (!ctrl &&
-        !meta &&
-        !shift &&
-        !isNamedKey(normalizedKey) &&
-        isPrintableSequence(normalizedKey)) {
-        return {
-            sequence: normalizedKey,
-            ctrl,
-            meta,
-            shift
-        };
-    }
-    return {
-        name: normalizedKey.toLowerCase(),
-        ctrl,
-        meta,
-        shift
-    };
 }
-function matchesSingleKey(binding, event) {
-    if (binding.sequence !== undefined) {
-        return false;
-    }
-    if (binding.ctrl !== event.ctrl ||
-        binding.meta !== event.meta ||
-        binding.shift !== event.shift) {
-        return false;
-    }
-    if (binding.ch !== undefined) {
-        if (binding.ch === " " && event.name === "space") {
-            return true;
-        }
-        return event.ch === binding.ch || event.name === binding.ch.toLowerCase();
-    }
-    if (binding.name !== undefined) {
-        return event.name === binding.name;
-    }
-    return false;
+export function keymapToHelp(config) {
+    return [
+        { title: "Navigation", entries: [
+                { key: "↑/↓", label: "move" }, { key: "PgUp/PgDn", label: "page" },
+                { key: "Home/End", label: "first/last" }, { key: "Tab", label: "focus" }
+            ] },
+        { title: "Actions", entries: [
+                { key: "Enter", label: "actions" }, { key: "Ctrl+P", label: "palette" },
+                ...allActions(config).filter(action => action.accelerator !== undefined).map(action => ({ key: `Ctrl+${action.accelerator.toUpperCase()}`, label: typeof action.label === "string" ? action.label : action.id }))
+            ] },
+        { title: "General", entries: [{ key: "Esc", label: "clear/quit" }, { key: "Ctrl+C", label: "quit" }] }
+    ];
 }
-function eventToSequenceToken(event) {
-    if (event.ctrl || event.meta || event.ch === undefined) {
-        return undefined;
-    }
-    return event.ch;
+function allActions(config) {
+    const actions = [...config.actions, ...(config.detail?.actions ?? [])];
+    return [...new Map(actions.map(action => [action.id, action])).values()];
 }
-function hasSequencePrefix(sequences, prefix) {
-    for (const sequence of sequences) {
-        if (sequence.startsWith(prefix)) {
-            return true;
+function add(keys, target, bindings, keysByTarget) {
+    const accepted = [];
+    for (const key of keys) {
+        const normalized = canonical(key);
+        if (!bindings.has(normalized)) {
+            bindings.set(normalized, target);
+            accepted.push(key);
         }
     }
-    return false;
-}
-function isShiftedCharacter(value) {
-    return value.length === 1 && value.toLowerCase() !== value && value.toUpperCase() === value;
-}
-function normalizeBindingCharacter(value, shift) {
-    if (!shift || value.toLowerCase() === value.toUpperCase()) {
-        return value;
-    }
-    return value.toUpperCase();
-}
-function normalizeKeyName(value) {
-    if (value.toLowerCase() === "space") {
-        return " ";
-    }
-    if (value === "↑") {
-        return "up";
-    }
-    if (value === "↓") {
-        return "down";
-    }
-    if (value === "←") {
-        return "left";
-    }
-    if (value === "→") {
-        return "right";
-    }
-    return value;
-}
-function isNamedKey(value) {
-    return namedKeys.has(value.toLowerCase());
+    if (accepted.length > 0)
+        keysByTarget.set(`${target.type}:${target.id}`, accepted);
 }
-function isPrintableSequence(value) {
-    if (Array.from(value).length <= 1) {
-        return false;
-    }
-    for (const char of value) {
-        const codePoint = char.codePointAt(0);
-        if (codePoint === undefined || codePoint < 0x20 || codePoint === 0x7f) {
-            return false;
-        }
-    }
-    return true;
+function canonical(value) { return value.trim().toLowerCase().replace("control+", "ctrl+"); }
+function eventKey(event) {
+    const name = event.name ?? event.ch ?? "";
+    const modifiers = [event.ctrl ? "ctrl" : "", event.meta ? "meta" : "", event.shift ? "shift" : ""].filter(Boolean);
+    const normalized = name === "return" ? "return" : name.toLowerCase();
+    return [...modifiers, normalized].join("+");
 }
-const namedKeys = new Set([
-    "backspace",
-    "delete",
-    "down",
-    "end",
-    "enter",
-    "escape",
-    "home",
-    "left",
-    "pagedown",
-    "pageup",
-    "return",
-    "right",
-    "tab",
-    "up"
-]);

package/node_modules/toolcraft-design/dist/explorer/layout.d.ts

@@ -9,6 +9,7 @@ export interface ExplorerLayoutOptions {
     cols: number;
     rows: number;
     detailHidden?: boolean;
+    focused?: "list" | "detail";
 }
 export interface ExplorerLayout {
     mode: ExplorerLayoutMode;

package/node_modules/toolcraft-design/dist/explorer/layout.js

@@ -3,7 +3,7 @@ const FOOTER_HEIGHT = 1;
 export function computeExplorerLayout(opts) {
     const cols = normalizeSize(opts.cols);
     const rows = normalizeSize(opts.rows);
-    const mode = resolveMode(cols);
+    const mode = resolveMode(cols, rows);
     const footerHeight = rows > 0 ? Math.min(FOOTER_HEIGHT, rows) : 0;
     const headerHeight = Math.min(HEADER_HEIGHT, Math.max(0, rows - footerHeight));
     const contentY = headerHeight;
@@ -11,7 +11,7 @@ export function computeExplorerLayout(opts) {
     const footerY = headerHeight + contentHeight;
     const header = { x: 0, y: 0, width: cols, height: headerHeight };
     const footer = { x: 0, y: footerY, width: cols, height: footerHeight };
-    if (mode === "too-narrow" || mode === "narrow-list-only") {
+    if (mode === "too-narrow") {
         return {
             mode,
             header,
@@ -20,6 +20,16 @@ export function computeExplorerLayout(opts) {
             footer
         };
     }
+    if (mode === "narrow-list-only") {
+        const detailFocused = opts.focused === "detail";
+        return {
+            mode,
+            header,
+            list: detailFocused ? { x: 0, y: contentY, width: 0, height: contentHeight } : { x: 0, y: contentY, width: cols, height: contentHeight },
+            detail: detailFocused ? { x: 0, y: contentY, width: cols, height: contentHeight } : { x: cols, y: contentY, width: 0, height: contentHeight },
+            footer
+        };
+    }
     if (opts.detailHidden === true) {
         return {
             mode,
@@ -52,8 +62,8 @@ export function computeExplorerLayout(opts) {
         footer
     };
 }
-function resolveMode(cols) {
-    if (cols < 40) {
+function resolveMode(cols, rows) {
+    if (cols < 60 || rows < 8) {
         return "too-narrow";
     }
     if (cols < 80) {