toolcraft-openapi 0.0.152 → 0.0.154

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

@@ -1,4 +1,34 @@
 import { resolveBindings } from "./keymap.js";
+export function normalizeExplorerConfig(config) {
+    if (config.panes === undefined) {
+        if (config.rows === undefined || config.detail === undefined)
+            throw new Error("Explorer requires panes");
+        return config;
+    }
+    if (config.panes.length < 1 || config.panes.length > 3)
+        throw new Error("Explorer requires 1 to 3 panes");
+    const list = config.panes.find((pane) => pane.kind === "list");
+    if (list === undefined)
+        throw new Error("Explorer requires a list pane");
+    const companion = config.panes.find(pane => pane !== list);
+    const detail = companion?.kind === "detail"
+        ? { items: async (row, ctx) => {
+                const content = await companion.render(row, ctx);
+                if (ctx.signal.aborted)
+                    return [];
+                return [{ id: row.id, render: () => content, renderedContent: content }];
+            } }
+        : companion?.kind === "list"
+            ? { items: async () => (await companion.rows()).map(row => ({ ...row, render: () => "" })), actions: config.actions }
+            : { items: async () => [] };
+    return {
+        ...config,
+        rows: list.rows,
+        detail,
+        multiSelect: list.multiSelect ?? config.multiSelect,
+        emptyHint: list.emptyHint ?? config.emptyHint
+    };
+}
 export const REGION_HEADER = 1 << 0;
 export const REGION_LIST = 1 << 1;
 export const REGION_DETAIL = 1 << 2;
@@ -12,18 +42,20 @@ export const REGION_ALL = REGION_HEADER |
     REGION_MODAL |
     REGION_TOAST;
 export function createInitialState(config, size) {
+    const normalizedConfig = normalizeExplorerConfig(config);
     const normalizedSize = {
         cols: normalizeSize(size.cols),
         rows: normalizeSize(size.rows)
     };
-    const multiSelect = config.multiSelect ?? true;
-    const initialRows = config.initialRows ?? [];
-    const initialFilter = config.initialFilter ?? "";
+    const multiSelect = normalizedConfig.multiSelect ?? true;
+    const initialRows = normalizedConfig.initialRows ?? [];
+    const initialFilter = normalizedConfig.initialFilter ?? "";
     // Defer filtering to first rowsLoaded when empty; seed list immediately when provided.
     return {
-        title: config.title,
-        emptyHint: config.emptyHint ?? "No detail",
+        title: normalizedConfig.title,
+        emptyHint: normalizedConfig.emptyHint ?? "No detail",
         rows: initialRows,
+        rowsLoading: true,
         filtered: initialRows.map((_, index) => index),
         matchPositions: new Map(),
         cursor: 0,
@@ -33,6 +65,8 @@ export function createInitialState(config, size) {
         detail: {
             rowId: initialRows[0]?.id ?? null,
             items: null,
+            allItems: null,
+            filter: "",
             cursor: 0,
             scroll: 0,
             token: initialRows.length > 0 ? 1 : 0,
@@ -44,17 +78,27 @@ export function createInitialState(config, size) {
         toast: null,
         dirty: REGION_ALL,
         size: normalizedSize,
-        layout: resolveExplorerLayoutMode(normalizedSize.cols),
-        bindings: resolveBindings(config),
-        actionState: createInitialActionState(config)
+        layout: resolveExplorerLayoutMode(normalizedSize.cols, normalizedSize.rows),
+        bindings: resolveBindings(normalizedConfig),
+        actionState: createInitialActionState(normalizedConfig),
+        suspended: false,
+        paneDefinitions: normalizedConfig.panes?.map(({ id, title, kind }) => ({ id, title, kind })) ?? [
+            { id: "list", title: normalizedConfig.title, kind: "list" },
+            { id: "detail", title: "Preview", kind: "detail" }
+        ]
     };
 }
 function createInitialActionState(config) {
     const state = new Map();
-    for (const [source, actions] of [["row", config.actions], ["detail", config.detail.actions ?? []]]) {
+    for (const [source, actions] of [["row", config.actions], ["detail", config.detail?.actions ?? []]]) {
         for (const action of actions) {
             if (state.has(action.id)) {
-                throw new Error(`Duplicate explorer action id: ${action.id}`);
+                const isSharedListAction = config.panes?.some(pane => pane.kind === "list" && pane !== config.panes?.[0]) === true;
+                if (!isSharedListAction)
+                    throw new Error(`Duplicate explorer action id: ${action.id}`);
+                const existing = state.get(action.id);
+                state.set(action.id, { ...existing, source: "both" });
+                continue;
             }
             state.set(action.id, {
                 available: true,
@@ -66,8 +110,8 @@ function createInitialActionState(config) {
     }
     return state;
 }
-export function resolveExplorerLayoutMode(cols) {
-    if (cols < 40) {
+export function resolveExplorerLayoutMode(cols, rows = 24) {
+    if (cols < 60 || rows < 8) {
         return "too-narrow";
     }
     if (cols < 80) {

package/node_modules/toolcraft-design/dist/index.d.ts

@@ -37,8 +37,8 @@ export * as dashboard from "./dashboard/index.js";
 export { createDashboard, shouldUseInteractiveDashboard } from "./dashboard/index.js";
 export type { Dashboard, DashboardOptions } from "./dashboard/index.js";
 export * as explorer from "./explorer/index.js";
-export { runExplorer, runTwoPaneExplorer, singleDetail } from "./explorer/index.js";
-export type { Row, DetailItem, Detail, DetailCtx, Action, ActionContext, TwoPaneAction, TwoPaneActionContext, TwoPaneDefinition, TwoPaneExplorerConfig, TwoPanePaneState, TwoPaneRow, ExplorerConfig, ReorderContext, Tone } from "./explorer/index.js";
+export { runExplorer, singleDetail, normalizeExplorerConfig } from "./explorer/index.js";
+export type { Row, DetailItem, Detail, DetailCtx, Action, ActionContext, ExplorerConfig, PaneConfig, ListPaneConfig, DetailPaneConfig, PaneRuntimeState, ReorderContext, Tone } from "./explorer/index.js";
 export * as prompts from "./prompts/index.js";
 export { intro, introPlain, outro, note, select, multiselect, text as promptText, confirm, confirmOrCancel, password, spinner, withSpinner, isCancel, cancel, log, PromptCancelledError } from "./prompts/index.js";
 export type { SelectOptions, MultiselectOptions, TextOptions, ConfirmOptions, PasswordOptions, SpinnerOptions, WithSpinnerOptions } from "./prompts/index.js";
@@ -54,3 +54,9 @@ export { configureTheme, getThemeConfig, resetTheme } from "./internal/theme-sta
 export { stripAnsi } from "./internal/strip-ansi.js";
 export { resolveOutputFormat, resetOutputFormatCache, withOutputFormat } from "./internal/output-format.js";
 export type { OutputFormat } from "./internal/output-format.js";
+export { createTerminalDriver } from "./terminal/driver.js";
+export type { TerminalDriver, TerminalInputEvent, Size as TerminalSize } from "./terminal/driver.js";
+export { Screen } from "./screen/screen.js";
+export type { Cell as ScreenCell, ScreenSize, ScreenSurface } from "./screen/screen.js";
+export { packStyle, styleToSgrDelta } from "./screen/style.js";
+export type { PackedStyle } from "./screen/style.js";

package/node_modules/toolcraft-design/dist/index.js

@@ -29,7 +29,7 @@ export * as dashboard from "./dashboard/index.js";
 export { createDashboard, shouldUseInteractiveDashboard } from "./dashboard/index.js";
 // Explorer
 export * as explorer from "./explorer/index.js";
-export { runExplorer, runTwoPaneExplorer, singleDetail } from "./explorer/index.js";
+export { runExplorer, singleDetail, normalizeExplorerConfig } from "./explorer/index.js";
 // Prompts
 export * as prompts from "./prompts/index.js";
 export { intro, introPlain, outro, note, select, multiselect, text as promptText, confirm, confirmOrCancel, password, spinner, withSpinner, isCancel, cancel, log, PromptCancelledError } from "./prompts/index.js";
@@ -44,3 +44,7 @@ export { getTheme, resolveThemeName, resetThemeCache } from "./internal/theme-de
 export { configureTheme, getThemeConfig, resetTheme } from "./internal/theme-state.js";
 export { stripAnsi } from "./internal/strip-ansi.js";
 export { resolveOutputFormat, resetOutputFormatCache, withOutputFormat } from "./internal/output-format.js";
+// Terminal and screen primitives
+export { createTerminalDriver } from "./terminal/driver.js";
+export { Screen } from "./screen/screen.js";
+export { packStyle, styleToSgrDelta } from "./screen/style.js";

package/node_modules/toolcraft-design/dist/screen/ansi-text.d.ts

@@ -0,0 +1,2 @@
+import type { Cell } from "./screen.js";
+export declare function ansiToCells(text: string): Cell[];

package/node_modules/toolcraft-design/dist/screen/ansi-text.js

@@ -0,0 +1,35 @@
+import { parseAnsi } from "../dashboard/ansi.js";
+import { graphemes, graphemeWidth } from "../dashboard/terminal-width.js";
+import { packStyle } from "./style.js";
+const COLORS = new Map([
+    ["black", 1], ["red", 1], ["green", 2], ["yellow", 3], ["blue", 4],
+    ["magenta", 5], ["cyan", 6], ["white", 7], ["gray", 8]
+]);
+export function ansiToCells(text) {
+    const output = [];
+    const lines = parseAnsi(text);
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+        if (lineIndex > 0)
+            output.push(cell("\n", 1, 0));
+        for (const segment of lines[lineIndex].segments) {
+            const style = packed(segment.style);
+            for (const grapheme of graphemes(segment.text))
+                output.push(cell(grapheme, graphemeWidth(grapheme) > 1 ? 2 : 1, style));
+        }
+    }
+    return output;
+}
+function packed(style) {
+    return packStyle({
+        bold: style.bold,
+        dim: style.dim,
+        underline: style.underline,
+        inverse: style.inverse,
+        fg: colorNumber(style.fg),
+        bg: colorNumber(style.bg)
+    });
+}
+function colorNumber(value) { return value === undefined ? 0 : (COLORS.get(value) ?? 0); }
+function cell(ch, width, style) {
+    return { ch, width, style, fg: (style >> 8) & 0xff, bg: (style >> 16) & 0xff };
+}

package/node_modules/toolcraft-design/dist/screen/screen.d.ts

@@ -0,0 +1,40 @@
+import type { CellStyle, Rect } from "../dashboard/types.js";
+import { type PackedStyle } from "./style.js";
+export interface Cell {
+    ch: string;
+    width: 1 | 2;
+    style: PackedStyle;
+    fg: number;
+    bg: number;
+}
+export interface ScreenSize {
+    cols: number;
+    rows: number;
+}
+export interface ScreenSurface {
+    readonly width: number;
+    readonly height: number;
+    put(x: number, y: number, text: string, style?: CellStyle | PackedStyle): void;
+    clearRect(rect: Rect, style?: CellStyle | PackedStyle): void;
+}
+export declare class Screen {
+    private cols;
+    private rows;
+    private front;
+    private back;
+    private outputStyle;
+    private readonly colors;
+    constructor(size?: ScreenSize, options?: {
+        colors?: boolean;
+    });
+    get width(): number;
+    get height(): number;
+    resize(size: ScreenSize): void;
+    cell(x: number, y: number, ch: string, style?: PackedStyle): void;
+    text(x: number, y: number, text: string, style?: PackedStyle): void;
+    put(x: number, y: number, text: string, style?: CellStyle | PackedStyle): void;
+    clearRect(rect: Rect, style?: CellStyle | PackedStyle): void;
+    flush(): string;
+    private index;
+    private inBounds;
+}

package/node_modules/toolcraft-design/dist/screen/screen.js

@@ -0,0 +1,122 @@
+import { graphemes, graphemeWidth } from "../dashboard/terminal-width.js";
+import { background, foreground, styleToSgrDelta } from "./style.js";
+const EMPTY = { ch: " ", width: 1, style: 0, fg: 0, bg: 0 };
+export class Screen {
+    cols = 0;
+    rows = 0;
+    front = [];
+    back = [];
+    outputStyle = 0;
+    colors;
+    constructor(size = { cols: 0, rows: 0 }, options = {}) {
+        this.colors = options.colors ?? (process.env.NO_COLOR === undefined && process.env.TERM !== "dumb");
+        this.resize(size);
+    }
+    get width() { return this.cols; }
+    get height() { return this.rows; }
+    resize(size) {
+        this.cols = normalize(size.cols);
+        this.rows = normalize(size.rows);
+        this.front = cells(this.cols * this.rows);
+        this.back = cells(this.cols * this.rows);
+    }
+    cell(x, y, ch, style = 0) {
+        if (!this.inBounds(x, y) || ch.length === 0)
+            return;
+        const segment = graphemes(ch)[0];
+        if (segment === undefined)
+            return;
+        const measured = graphemeWidth(segment);
+        const width = measured > 1 ? 2 : 1;
+        this.back[this.index(x, y)] = makeCell(segment, width, style);
+        if (width === 2 && this.inBounds(x + 1, y))
+            this.back[this.index(x + 1, y)] = makeCell("", 1, style);
+    }
+    text(x, y, text, style = 0) {
+        let offset = 0;
+        for (const segment of graphemes(text)) {
+            const width = Math.max(0, graphemeWidth(segment));
+            if (width > 0)
+                this.cell(x + offset, y, segment, style);
+            offset += width;
+        }
+    }
+    put(x, y, text, style = 0) {
+        this.text(x, y, text, typeof style === "number" ? style : packLegacyStyle(style));
+    }
+    clearRect(rect, style = 0) {
+        const packed = typeof style === "number" ? style : packLegacyStyle(style);
+        const startX = Math.max(0, rect.x);
+        const startY = Math.max(0, rect.y);
+        const endX = Math.min(this.cols, rect.x + Math.max(0, rect.width));
+        const endY = Math.min(this.rows, rect.y + Math.max(0, rect.height));
+        for (let y = startY; y < endY; y += 1)
+            for (let x = startX; x < endX; x += 1)
+                this.cell(x, y, " ", packed);
+    }
+    flush() {
+        const changed = new Set();
+        for (let index = 0; index < this.back.length; index += 1) {
+            if (!equal(this.front[index], this.back[index])) {
+                changed.add(index);
+                const old = this.front[index];
+                const next = this.back[index];
+                if ((old.width === 2 || next.width === 2) && (index % this.cols) + 1 < this.cols)
+                    changed.add(index + 1);
+                if (old.ch === "" && index % this.cols > 0)
+                    changed.add(index - 1);
+            }
+        }
+        let output = "";
+        let currentStyle = this.outputStyle;
+        const ordered = [...changed].sort((left, right) => left - right);
+        let cursor = 0;
+        while (cursor < ordered.length) {
+            const start = ordered[cursor];
+            const y = Math.floor(start / this.cols);
+            let end = start;
+            while (cursor + 1 < ordered.length && ordered[cursor + 1] === end + 1 && Math.floor(ordered[cursor + 1] / this.cols) === y) {
+                cursor += 1;
+                end += 1;
+            }
+            output += `\u001b[${y + 1};${(start % this.cols) + 1}H`;
+            for (let index = start; index <= end; index += 1) {
+                const cell = this.back[index];
+                const delta = styleToSgrDelta(currentStyle, cell.style, this.colors);
+                output += delta;
+                currentStyle = cell.style;
+                output += cell.ch.length === 0 ? "" : cell.ch;
+            }
+            cursor += 1;
+        }
+        this.front = this.back;
+        this.back = cells(this.cols * this.rows);
+        this.outputStyle = currentStyle;
+        return output;
+    }
+    index(x, y) { return y * this.cols + x; }
+    inBounds(x, y) { return x >= 0 && y >= 0 && x < this.cols && y < this.rows; }
+}
+function makeCell(ch, width, style) {
+    return { ch, width, style, fg: foreground(style), bg: background(style) };
+}
+function cells(length) { return Array.from({ length }, () => ({ ...EMPTY })); }
+function equal(left, right) { return left.ch === right.ch && left.width === right.width && left.style === right.style; }
+function normalize(value) { return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0; }
+function packLegacyStyle(style) {
+    return (style.bold ? 1 : 0)
+        | (style.dim ? 2 : 0)
+        | (style.underline ? 4 : 0)
+        | (style.inverse ? 8 : 0)
+        | (legacyColor(style.fg) << 8)
+        | (legacyColor(style.bg) << 16);
+}
+function legacyColor(value) {
+    if (value === undefined)
+        return 0;
+    const names = ["", "red", "green", "yellow", "blue", "magenta", "cyan", "white", "gray"];
+    const exact = names.indexOf(value);
+    if (exact >= 0)
+        return exact;
+    return value.startsWith("#") ? 7 : 0;
+}

package/node_modules/toolcraft-design/dist/screen/style.d.ts

@@ -0,0 +1,16 @@
+export declare const STYLE_BOLD: number;
+export declare const STYLE_DIM: number;
+export declare const STYLE_UNDERLINE: number;
+export declare const STYLE_INVERSE: number;
+export type PackedStyle = number;
+export declare function packStyle(style: {
+    bold?: boolean;
+    dim?: boolean;
+    underline?: boolean;
+    inverse?: boolean;
+    fg?: number;
+    bg?: number;
+}): PackedStyle;
+export declare function foreground(style: PackedStyle): number;
+export declare function background(style: PackedStyle): number;
+export declare function styleToSgrDelta(previous: PackedStyle, next: PackedStyle, colors?: boolean): string;

package/node_modules/toolcraft-design/dist/screen/style.js

@@ -0,0 +1,55 @@
+export const STYLE_BOLD = 1 << 0;
+export const STYLE_DIM = 1 << 1;
+export const STYLE_UNDERLINE = 1 << 2;
+export const STYLE_INVERSE = 1 << 3;
+const FG_SHIFT = 8;
+const BG_SHIFT = 16;
+const COLOR_MASK = 0xff;
+export function packStyle(style) {
+    let packed = 0;
+    if (style.bold)
+        packed |= STYLE_BOLD;
+    if (style.dim)
+        packed |= STYLE_DIM;
+    if (style.underline)
+        packed |= STYLE_UNDERLINE;
+    if (style.inverse)
+        packed |= STYLE_INVERSE;
+    packed |= ((style.fg ?? 0) & COLOR_MASK) << FG_SHIFT;
+    packed |= ((style.bg ?? 0) & COLOR_MASK) << BG_SHIFT;
+    return packed;
+}
+export function foreground(style) { return (style >> FG_SHIFT) & COLOR_MASK; }
+export function background(style) { return (style >> BG_SHIFT) & COLOR_MASK; }
+export function styleToSgrDelta(previous, next, colors = process.env.NO_COLOR === undefined && process.env.TERM !== "dumb") {
+    if (!colors)
+        return "";
+    if (previous === next)
+        return "";
+    const codes = [];
+    const previousIntensity = previous & (STYLE_BOLD | STYLE_DIM);
+    const nextIntensity = next & (STYLE_BOLD | STYLE_DIM);
+    if (previousIntensity !== nextIntensity) {
+        if ((previousIntensity & ~nextIntensity) !== 0)
+            codes.push(22);
+        if ((nextIntensity & STYLE_BOLD) !== 0 && ((previousIntensity & ~nextIntensity) !== 0 || (previousIntensity & STYLE_BOLD) === 0))
+            codes.push(1);
+        if ((nextIntensity & STYLE_DIM) !== 0 && ((previousIntensity & ~nextIntensity) !== 0 || (previousIntensity & STYLE_DIM) === 0))
+            codes.push(2);
+    }
+    flagDelta(codes, previous, next, STYLE_UNDERLINE, 4, 24);
+    flagDelta(codes, previous, next, STYLE_INVERSE, 7, 27);
+    const previousFg = foreground(previous);
+    const nextFg = foreground(next);
+    if (previousFg !== nextFg)
+        codes.push(nextFg === 0 ? 39 : 30 + nextFg);
+    const previousBg = background(previous);
+    const nextBg = background(next);
+    if (previousBg !== nextBg)
+        codes.push(nextBg === 0 ? 49 : 40 + nextBg);
+    return codes.length === 0 ? "" : `\u001b[${[...new Set(codes)].join(";")}m`;
+}
+function flagDelta(codes, previous, next, flag, on, off) {
+    if ((previous & flag) !== (next & flag))
+        codes.push((next & flag) === 0 ? off : on);
+}

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

@@ -0,0 +1,33 @@
+import { type TerminalInputEvent } from "./input.js";
+export interface Size {
+    cols: number;
+    rows: number;
+}
+export interface TerminalDriver {
+    start(): void;
+    stop(): void;
+    onEvent(fn: (event: TerminalInputEvent) => void): () => void;
+    onResize(fn: (size: Size) => void): () => void;
+    getSize(): Size;
+    writeFrame(ansi: string): void;
+}
+interface InputStream {
+    setRawMode?: (enabled: boolean) => void;
+    resume(): void;
+    pause(): void;
+    on(event: "data", listener: (chunk: Buffer | string) => void): unknown;
+    off(event: "data", listener: (chunk: Buffer | string) => void): unknown;
+}
+interface OutputStream {
+    columns?: number;
+    rows?: number;
+    write(value: string): boolean;
+    on(event: "resize", listener: () => void): unknown;
+    off(event: "resize", listener: () => void): unknown;
+}
+export declare function createTerminalDriver(options?: {
+    input?: InputStream;
+    output?: OutputStream;
+    escTimeoutMs?: number;
+}): TerminalDriver;
+export type { TerminalInputEvent } from "./input.js";

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

@@ -0,0 +1,61 @@
+import { createInputParser } from "./input.js";
+import { createFrameWriter } from "./output.js";
+export function createTerminalDriver(options = {}) {
+    const input = options.input ?? process.stdin;
+    const output = options.output ?? process.stdout;
+    const eventListeners = new Set();
+    const resizeListeners = new Set();
+    const emit = (event) => {
+        for (const listener of eventListeners)
+            listener(event);
+    };
+    const parser = createInputParser({ escTimeoutMs: options.escTimeoutMs, onEvent: emit });
+    const writer = createFrameWriter(output);
+    let started = false;
+    const onData = (chunk) => {
+        for (const event of parser.feed(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)))
+            emit(event);
+    };
+    const getSize = () => ({ cols: dimension(output.columns), rows: dimension(output.rows) });
+    const onTerminalResize = () => {
+        const size = getSize();
+        for (const listener of resizeListeners)
+            listener(size);
+    };
+    return {
+        start() {
+            if (started)
+                return;
+            started = true;
+            input.setRawMode?.(true);
+            input.resume();
+            input.on("data", onData);
+            output.on("resize", onTerminalResize);
+            writer.open();
+        },
+        stop() {
+            if (!started)
+                return;
+            started = false;
+            input.off("data", onData);
+            output.off("resize", onTerminalResize);
+            parser.destroy();
+            writer.close();
+            input.setRawMode?.(false);
+            input.pause();
+        },
+        onEvent(fn) {
+            eventListeners.add(fn);
+            return () => { eventListeners.delete(fn); };
+        },
+        onResize(fn) {
+            resizeListeners.add(fn);
+            return () => { resizeListeners.delete(fn); };
+        },
+        getSize,
+        writeFrame: writer.writeFrame
+    };
+}
+function dimension(value) {
+    return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
+}

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

@@ -0,0 +1,25 @@
+export type TerminalInputEvent = {
+    type: "key";
+    name: string;
+    ch?: string;
+    ctrl: boolean;
+    alt: boolean;
+    shift: boolean;
+} | {
+    type: "paste";
+    text: string;
+} | {
+    type: "wheel";
+    direction: "up" | "down";
+    x: number;
+    y: number;
+};
+export interface InputParser {
+    feed(chunk: Buffer): TerminalInputEvent[];
+    flush(): TerminalInputEvent[];
+    destroy(): void;
+}
+export declare function createInputParser(options?: {
+    escTimeoutMs?: number;
+    onEvent?: (event: TerminalInputEvent) => void;
+}): InputParser;