toolcraft-openapi 0.0.151 → 0.0.153

package/node_modules/toolcraft-design/dist/terminal/input.js

@@ -0,0 +1,181 @@
+const ESC = 0x1b;
+const PASTE_START = Buffer.from("\u001b[200~");
+const PASTE_END = Buffer.from("\u001b[201~");
+export function createInputParser(options = {}) {
+    const escTimeoutMs = options.escTimeoutMs ?? 50;
+    let pending = Buffer.alloc(0);
+    let paste = false;
+    let timer;
+    let escapeReady = false;
+    const clearEscapeTimer = () => {
+        if (timer !== undefined)
+            clearTimeout(timer);
+        timer = undefined;
+        escapeReady = false;
+    };
+    const armEscapeTimer = () => {
+        if (timer !== undefined)
+            return;
+        timer = setTimeout(() => {
+            timer = undefined;
+            if (options.onEvent !== undefined && pending.length === 1 && pending[0] === ESC) {
+                pending = pending.subarray(1);
+                options.onEvent(key("escape"));
+            }
+            else {
+                escapeReady = true;
+            }
+        }, escTimeoutMs);
+    };
+    const parse = () => {
+        const events = [];
+        while (pending.length > 0) {
+            if (paste) {
+                const end = pending.indexOf(PASTE_END);
+                if (end < 0)
+                    break;
+                events.push({ type: "paste", text: pending.subarray(0, end).toString("utf8") });
+                pending = pending.subarray(end + PASTE_END.length);
+                paste = false;
+                continue;
+            }
+            if (pending[0] === ESC) {
+                if (pending.length === 1) {
+                    if (escapeReady) {
+                        pending = pending.subarray(1);
+                        escapeReady = false;
+                        events.push(key("escape"));
+                    }
+                    else {
+                        armEscapeTimer();
+                    }
+                    break;
+                }
+                clearEscapeTimer();
+                if (pending.subarray(0, PASTE_START.length).equals(PASTE_START)) {
+                    pending = pending.subarray(PASTE_START.length);
+                    paste = true;
+                    continue;
+                }
+                if (pending[1] === 0x5b) {
+                    const final = findCsiFinal(pending);
+                    if (final < 0)
+                        break;
+                    const sequence = pending.subarray(0, final + 1).toString("ascii");
+                    pending = pending.subarray(final + 1);
+                    const event = parseCsi(sequence);
+                    if (event !== undefined)
+                        events.push(event);
+                    continue;
+                }
+                if (pending[1] === 0x4f) {
+                    if (pending.length < 3)
+                        break;
+                    const name = navigationName(String.fromCharCode(pending[2]));
+                    pending = pending.subarray(3);
+                    if (name !== undefined)
+                        events.push(key(name));
+                    continue;
+                }
+                if (pending[1] === 0x03) {
+                    pending = pending.subarray(1);
+                    events.push(key("escape"));
+                    continue;
+                }
+                const decoded = decodeFirstCharacter(pending.subarray(1));
+                if (decoded === undefined)
+                    break;
+                pending = pending.subarray(1 + decoded.bytes);
+                events.push(character(decoded.ch, true));
+                continue;
+            }
+            const byte = pending[0];
+            if (byte < 0x20 || byte === 0x7f) {
+                pending = pending.subarray(1);
+                events.push(control(byte));
+                continue;
+            }
+            const decoded = decodeFirstCharacter(pending);
+            if (decoded === undefined)
+                break;
+            pending = pending.subarray(decoded.bytes);
+            events.push(character(decoded.ch, false));
+        }
+        return events;
+    };
+    return {
+        feed(chunk) {
+            if (chunk.length > 0) {
+                if (pending.length === 1 && pending[0] === ESC)
+                    clearEscapeTimer();
+                pending = pending.length === 0 ? Buffer.from(chunk) : Buffer.concat([pending, chunk]);
+            }
+            return parse();
+        },
+        flush() {
+            return parse();
+        },
+        destroy() {
+            clearEscapeTimer();
+            pending = Buffer.alloc(0);
+        }
+    };
+}
+function findCsiFinal(input) {
+    for (let index = 2; index < input.length; index += 1) {
+        const byte = input[index];
+        if (byte >= 0x40 && byte <= 0x7e)
+            return index;
+    }
+    return -1;
+}
+function parseCsi(sequence) {
+    if (sequence.startsWith("\u001b[<") && (sequence.endsWith("M") || sequence.endsWith("m"))) {
+        const fields = sequence.slice(3, -1).split(";");
+        if ((fields[0] === "64" || fields[0] === "65") && fields.length === 3) {
+            return {
+                type: "wheel",
+                direction: fields[0] === "64" ? "up" : "down",
+                x: Number(fields[1]) - 1,
+                y: Number(fields[2]) - 1
+            };
+        }
+    }
+    const final = sequence.at(-1);
+    const name = navigationName(final) ?? ({ "5": "pageup", "6": "pagedown" }[sequence.slice(2, -1)]);
+    if (name === undefined)
+        return undefined;
+    const modifier = sequence.includes(";5") ? { ctrl: true } : {};
+    return key(name, modifier);
+}
+function navigationName(final) {
+    return { A: "up", B: "down", C: "right", D: "left", H: "home", F: "end" }[final];
+}
+function control(byte) {
+    if (byte === 0x0d || byte === 0x0a)
+        return key("enter");
+    if (byte === 0x09)
+        return key("tab");
+    if (byte === 0x7f || byte === 0x08)
+        return key("backspace");
+    if (byte === 0x20)
+        return character(" ", false);
+    if (byte >= 1 && byte <= 26)
+        return key(String.fromCharCode(96 + byte), { ctrl: true });
+    return key(`control-${byte}`);
+}
+function character(ch, alt) {
+    return { type: "key", name: ch, ch, ctrl: false, alt, shift: ch.toLocaleUpperCase() === ch && ch.toLocaleLowerCase() !== ch };
+}
+function key(name, flags = {}) {
+    return { type: "key", name, ctrl: flags.ctrl ?? false, alt: flags.alt ?? false, shift: flags.shift ?? false };
+}
+function decodeFirstCharacter(input) {
+    if (input.length === 0)
+        return undefined;
+    const first = input[0];
+    const bytes = first < 0x80 ? 1 : first < 0xe0 ? 2 : first < 0xf0 ? 3 : 4;
+    if (input.length < bytes)
+        return undefined;
+    return { ch: input.subarray(0, bytes).toString("utf8"), bytes };
+}

package/node_modules/toolcraft-design/dist/terminal/output.d.ts

@@ -0,0 +1,8 @@
+export interface FrameWriter {
+    open(): void;
+    close(): void;
+    writeFrame(ansi: string): void;
+}
+export declare function createFrameWriter(stream: {
+    write(value: string): boolean;
+}): FrameWriter;

package/node_modules/toolcraft-design/dist/terminal/output.js

@@ -0,0 +1,42 @@
+const OPEN = "\u001b[?1049h\u001b[?25l\u001b[?2004h\u001b[?1000h\u001b[?1006h\u001b[?7l";
+const CLOSE = "\u001b[0m\u001b[?7h\u001b[?1006l\u001b[?1000l\u001b[?2004l\u001b[?25h\u001b[?1049l";
+export function createFrameWriter(stream) {
+    let opened = false;
+    const interrupt = () => terminateWith("SIGINT");
+    const terminate = () => terminateWith("SIGTERM");
+    const fatal = (error) => {
+        close();
+        throw error;
+    };
+    function terminateWith(signal) {
+        close();
+        process.kill(process.pid, signal);
+    }
+    function open() {
+        if (opened)
+            return;
+        opened = true;
+        stream.write(OPEN);
+        process.once("SIGINT", interrupt);
+        process.once("SIGTERM", terminate);
+        process.once("uncaughtException", fatal);
+    }
+    function close() {
+        if (!opened)
+            return;
+        opened = false;
+        process.removeListener("SIGINT", interrupt);
+        process.removeListener("SIGTERM", terminate);
+        process.removeListener("uncaughtException", fatal);
+        stream.write(CLOSE);
+    }
+    return {
+        open,
+        close,
+        writeFrame(ansi) {
+            if (!opened || ansi.length === 0)
+                return;
+            stream.write(`\u001b[?2026h${ansi}\u001b[?2026l`);
+        }
+    };
+}

package/node_modules/toolcraft-schema/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft-schema",
-  "version": "0.0.151",
+  "version": "0.0.153",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft-openapi",
-  "version": "0.0.151",
+  "version": "0.0.153",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
@@ -30,7 +30,7 @@
     "toolcraft-openapi-generate": "dist/bin/generate.js"
   },
   "dependencies": {
-    "toolcraft": "0.0.151",
+    "toolcraft": "0.0.153",
     "auth-store": "^0.0.1",
     "fast-string-width": "^3.0.2",
     "fast-wrap-ansi": "^0.2.0",
@@ -46,7 +46,7 @@
     "directory": "packages/toolcraft-openapi"
   },
   "optionalDependencies": {
-    "toolcraft-schema": "0.0.151",
+    "toolcraft-schema": "0.0.153",
     "toolcraft-design": "*",
     "@poe-code/frontmatter": "*"
   },

package/node_modules/toolcraft-design/dist/explorer/two-pane.d.ts

@@ -1,102 +0,0 @@
-import { ScreenBuffer } from "../dashboard/buffer.js";
-import { type TerminalDriver } from "../dashboard/terminal.js";
-import type { Tone } from "./state.js";
-export interface TwoPaneRow {
-    id: string;
-    title: string;
-    subtitle?: string;
-    badge?: {
-        text: string;
-        tone?: Tone;
-    };
-}
-export interface TwoPaneDefinition {
-    id: string;
-    title: string;
-    rows: () => Promise<TwoPaneRow[]>;
-    emptyHint?: string;
-}
-export interface TwoPaneActionContext<R> {
-    activePane: TwoPanePaneState;
-    inactivePane: TwoPanePaneState;
-    row: TwoPaneRow;
-    rows: TwoPaneRow[];
-    refresh: () => Promise<void>;
-    suspendAnd: <T>(fn: () => Promise<T>) => Promise<T>;
-    toast: (message: string, tone?: Tone) => void;
-    exit: (result?: R | null) => void;
-}
-export interface TwoPaneAction<R> {
-    id: string;
-    label: string;
-    key: string | string[];
-    handler: (ctx: TwoPaneActionContext<R>) => void | Promise<void>;
-}
-export interface TwoPaneExplorerConfig<R> {
-    title: string;
-    panes: [TwoPaneDefinition, TwoPaneDefinition];
-    actions: TwoPaneAction<R>[];
-    refresh?: () => void | Promise<void>;
-    trace?: (record: TwoPaneTraceRecord) => void | Promise<void>;
-}
-export interface TwoPaneTraceRecord {
-    event: string;
-    [key: string]: unknown;
-}
-export interface TwoPanePaneState {
-    id: string;
-    title: string;
-    rows: TwoPaneRow[];
-    cursor: number;
-    selected: Set<string>;
-    filter: string;
-    emptyHint: string;
-}
-export interface TwoPaneExplorerState {
-    title: string;
-    panes: [TwoPanePaneState, TwoPanePaneState];
-    activePaneIndex: 0 | 1;
-    filterFocused: boolean;
-    toast: {
-        message: string;
-        tone: Tone;
-    } | null;
-    size: {
-        cols: number;
-        rows: number;
-    };
-}
-export declare function runTwoPaneExplorer<R = void>(config: TwoPaneExplorerConfig<R>): Promise<R | null>;
-export declare class TwoPaneExplorerRuntime<R> {
-    private readonly config;
-    private readonly driver;
-    private state;
-    private unsubscribeKeypress;
-    private unsubscribeResize;
-    private toastTimer;
-    private stopped;
-    private rowsRequestToken;
-    private settle;
-    constructor(config: TwoPaneExplorerConfig<R>, driver: TerminalDriver);
-    run(): Promise<R | null>;
-    private startTerminal;
-    private subscribeKeypress;
-    private pauseKeypress;
-    private loadRows;
-    private refresh;
-    private dispatchKey;
-    private dispatchFilterKey;
-    private moveCursor;
-    private setCursor;
-    private toggleSelection;
-    private runAction;
-    private suspendAnd;
-    private showToast;
-    private activePane;
-    private inactivePane;
-    private render;
-    private exit;
-    private fail;
-    private trace;
-}
-export declare function renderTwoPaneExplorer<R>(state: TwoPaneExplorerState, actions: TwoPaneAction<R>[], screen: ScreenBuffer): void;