toolcraft-openapi 0.0.17 → 0.0.19

package/node_modules/@poe-code/design-system/dist/components/template.js

@@ -0,0 +1,271 @@
+const HTML_ESCAPE = {
+    "&": "&",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;",
+    "/": "&#x2F;",
+    "`": "&#x60;",
+    "=": "&#x3D;"
+};
+export function renderTemplate(template, view, options = {}) {
+    const prepared = options.yield === undefined
+        ? template
+        : template.split("{{yield}}").join(options.yield);
+    const tokens = parseTemplate(prepared);
+    const escape = options.escape === "none" ? String : escapeHtml;
+    const preserveMissing = options.yield !== undefined && options.escape === "none";
+    return renderTokens(tokens, { view }, prepared, escape, preserveMissing);
+}
+function renderTemplateInContext(template, context, escape, preserveMissing) {
+    return renderTokens(parseTemplate(template), context, template, escape, preserveMissing);
+}
+function parseTemplate(template) {
+    const root = [];
+    const stack = [];
+    let tokens = root;
+    let index = 0;
+    while (index < template.length) {
+        const open = template.indexOf("{{", index);
+        if (open === -1) {
+            appendText(tokens, template.slice(index), index);
+            break;
+        }
+        appendText(tokens, template.slice(index, open), index);
+        const parsed = parseTag(template, open);
+        const standalone = getStandalone(template, open, parsed.end, parsed.kind);
+        if (standalone !== undefined) {
+            trimTextAfter(tokens, standalone.lineStart);
+        }
+        if (parsed.kind === "comment") {
+            index = standalone?.nextIndex ?? parsed.end;
+            continue;
+        }
+        if (parsed.kind === "partial") {
+            throw new Error(`Partials are not supported: "${parsed.name}"`);
+        }
+        if (parsed.kind === "delimiter") {
+            throw new Error("Custom delimiters are not supported");
+        }
+        if (parsed.kind === "section" || parsed.kind === "inverted") {
+            const token = {
+                type: parsed.kind,
+                name: parsed.name,
+                children: [],
+                rawStart: parsed.end,
+                rawEnd: standalone?.lineStart ?? open
+            };
+            tokens.push(token);
+            stack.push({ token, parent: tokens });
+            tokens = token.children;
+            index = standalone?.nextIndex ?? parsed.end;
+            continue;
+        }
+        if (parsed.kind === "close") {
+            const frame = stack.pop();
+            if (frame === undefined) {
+                throw new Error(`Closing unopened section "${parsed.name}"`);
+            }
+            if (frame.token.name !== parsed.name) {
+                throw new Error(`Unclosed section "${frame.token.name}" before closing "${parsed.name}"`);
+            }
+            frame.token.rawEnd = open;
+            tokens = frame.parent;
+            index = standalone?.nextIndex ?? parsed.end;
+            continue;
+        }
+        tokens.push({ type: parsed.kind, name: parsed.name, raw: template.slice(open, parsed.end) });
+        index = parsed.end;
+    }
+    const frame = stack.pop();
+    if (frame !== undefined) {
+        throw new Error(`Unclosed section "${frame.token.name}"`);
+    }
+    return root;
+}
+function parseTag(template, open) {
+    if (template.startsWith("{{{", open)) {
+        const close = template.indexOf("}}}", open + 3);
+        if (close === -1) {
+            throw new Error("Unclosed unescaped tag");
+        }
+        return { kind: "unescaped", name: template.slice(open + 3, close).trim(), end: close + 3 };
+    }
+    const close = template.indexOf("}}", open + 2);
+    if (close === -1) {
+        throw new Error("Unclosed tag");
+    }
+    const raw = template.slice(open + 2, close).trim();
+    const sigil = raw[0];
+    const name = sigil === undefined ? "" : raw.slice(1).trim();
+    const end = close + 2;
+    if (sigil === "#")
+        return { kind: "section", name, end };
+    if (sigil === "^")
+        return { kind: "inverted", name, end };
+    if (sigil === "/")
+        return { kind: "close", name, end };
+    if (sigil === "!")
+        return { kind: "comment", name, end };
+    if (sigil === "&")
+        return { kind: "unescaped", name, end };
+    if (sigil === ">")
+        return { kind: "partial", name, end };
+    if (sigil === "=" && raw.endsWith("="))
+        return { kind: "delimiter", name, end };
+    return { kind: "name", name: raw, end };
+}
+function getStandalone(template, tagStart, tagEnd, kind) {
+    if (!["section", "inverted", "close", "comment", "partial", "delimiter"].includes(kind)) {
+        return undefined;
+    }
+    const lineStart = template.lastIndexOf("\n", tagStart - 1) + 1;
+    if (!isWhitespace(template.slice(lineStart, tagStart))) {
+        return undefined;
+    }
+    let cursor = tagEnd;
+    while (cursor < template.length && (template[cursor] === " " || template[cursor] === "\t")) {
+        cursor += 1;
+    }
+    if (template.startsWith("\r\n", cursor)) {
+        return { lineStart, nextIndex: cursor + 2 };
+    }
+    if (template[cursor] === "\n") {
+        return { lineStart, nextIndex: cursor + 1 };
+    }
+    if (cursor === template.length) {
+        return { lineStart, nextIndex: cursor };
+    }
+    return undefined;
+}
+function renderTokens(tokens, context, template, escape, preserveMissing) {
+    let output = "";
+    for (const token of tokens) {
+        switch (token.type) {
+            case "text":
+                output += token.value;
+                continue;
+            case "name":
+            case "unescaped": {
+                const value = lookup(context, token.name);
+                if (value == null) {
+                    if (preserveMissing) {
+                        output += token.raw;
+                    }
+                    continue;
+                }
+                const rendered = String(value);
+                output += token.type === "name" ? escape(rendered) : rendered;
+                continue;
+            }
+            case "inverted": {
+                const value = lookup(context, token.name);
+                if (!value || (Array.isArray(value) && value.length === 0)) {
+                    output += renderTokens(token.children, context, template, escape, preserveMissing);
+                }
+                continue;
+            }
+            case "section": {
+                const value = lookup(context, token.name);
+                if (!value) {
+                    continue;
+                }
+                if (Array.isArray(value)) {
+                    for (const item of value) {
+                        output += renderTokens(token.children, pushContext(context, item), template, escape, preserveMissing);
+                    }
+                    continue;
+                }
+                if (typeof value === "function") {
+                    const raw = template.slice(token.rawStart, token.rawEnd);
+                    const rendered = value.call(context.view, raw, (nextTemplate) => renderTemplateInContext(nextTemplate, context, escape, preserveMissing));
+                    if (rendered != null) {
+                        output += String(rendered);
+                    }
+                    continue;
+                }
+                if (typeof value === "object" || typeof value === "string" || typeof value === "number") {
+                    output += renderTokens(token.children, pushContext(context, value), template, escape, preserveMissing);
+                    continue;
+                }
+                output += renderTokens(token.children, context, template, escape, preserveMissing);
+            }
+        }
+    }
+    return output;
+}
+function lookup(context, name) {
+    if (name === ".") {
+        return callLambda(context.view, context.view);
+    }
+    let cursor = context;
+    while (cursor !== undefined) {
+        const result = name.includes(".")
+            ? lookupDotted(cursor.view, name)
+            : lookupName(cursor.view, name);
+        if (result.hit) {
+            return callLambda(result.value, cursor.view);
+        }
+        cursor = cursor.parent;
+    }
+    return undefined;
+}
+function lookupName(view, name) {
+    if (!isPropertyContainer(view) || !hasProperty(view, name)) {
+        return { hit: false, value: undefined };
+    }
+    return { hit: true, value: view[name] };
+}
+function lookupDotted(view, name) {
+    const parts = name.split(".");
+    let value = view;
+    let hit = false;
+    for (let index = 0; value != null && index < parts.length; index += 1) {
+        const part = parts[index] ?? "";
+        if (index === parts.length - 1) {
+            hit = hasProperty(Object(value), part);
+        }
+        value = Object(value)[part];
+    }
+    return { hit, value };
+}
+function callLambda(value, view) {
+    return typeof value === "function" ? value.call(view) : value;
+}
+function pushContext(parent, view) {
+    return { view, parent };
+}
+function appendText(tokens, value, start) {
+    if (value === "") {
+        return;
+    }
+    const previous = tokens[tokens.length - 1];
+    if (previous?.type === "text") {
+        previous.value += value;
+        return;
+    }
+    tokens.push({ type: "text", value, start });
+}
+function trimTextAfter(tokens, lineStart) {
+    const previous = tokens[tokens.length - 1];
+    if (previous?.type !== "text") {
+        return;
+    }
+    const keep = Math.max(0, lineStart - previous.start);
+    previous.value = previous.value.slice(0, keep);
+    if (previous.value === "") {
+        tokens.pop();
+    }
+}
+function escapeHtml(value) {
+    return value.replace(/[&<>"'`=/]/g, (char) => HTML_ESCAPE[char] ?? char);
+}
+function isWhitespace(value) {
+    return value.trim() === "";
+}
+function isPropertyContainer(value) {
+    return (typeof value === "object" && value !== null) || typeof value === "function";
+}
+function hasProperty(value, key) {
+    return key in value;
+}

package/node_modules/@poe-code/design-system/dist/components/text.d.ts

@@ -10,6 +10,7 @@ export declare const text: {
     readonly usageCommand: (content: string) => string;
     readonly link: (content: string) => string;
     readonly muted: (content: string) => string;
+    readonly error: (content: string) => string;
     readonly badge: (content: string) => string;
     readonly selectLabel: (label: string, detail?: string) => string;
 };

package/node_modules/@poe-code/design-system/dist/components/text.js

@@ -1,4 +1,4 @@
-import chalk from "chalk";
+import { color } from "./color.js";
 import { resolveOutputFormat } from "../internal/output-format.js";
 import { getTheme } from "../internal/theme-detect.js";
 import { typography } from "../tokens/typography.js";
@@ -57,7 +57,7 @@ export const text = {
             return content;
         if (format === "markdown")
             return `\`${content}\``;
-        return chalk.yellow(content);
+        return color.yellow(content);
     },
     example(content) {
         const format = resolveOutputFormat();
@@ -73,7 +73,7 @@ export const text = {
             return content;
         if (format === "markdown")
             return `\`${content}\``;
-        return chalk.green(content);
+        return color.green(content);
     },
     link(content) {
         const format = resolveOutputFormat();
@@ -91,6 +91,14 @@ export const text = {
             return `*${content}*`;
         return getTheme().muted(content);
     },
+    error(content) {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return content;
+        if (format === "markdown")
+            return `**${content}**`;
+        return getTheme().error(content);
+    },
     badge(content) {
         const format = resolveOutputFormat();
         if (format === "json")

package/node_modules/@poe-code/design-system/dist/dashboard/buffer.js

@@ -1,4 +1,4 @@
-import chalk from "chalk";
+import { color } from "../components/color.js";
 const EMPTY_CELL = { ch: " ", style: {} };
 export class ScreenBuffer {
     _width;
@@ -119,13 +119,16 @@ export function diff(prev, next) {
 }
 export function cellToAnsi(cell) {
     const style = cell.style ?? {};
-    let painter = chalk;
+    let painter = color;
     if (style.bold) {
         painter = painter.bold;
     }
     if (style.dim) {
         painter = painter.dim;
     }
+    if (style.underline) {
+        painter = painter.underline;
+    }
     if (style.fg) {
         painter = applyForegroundColor(painter, style.fg);
     }
@@ -158,6 +161,9 @@ function normalizeStyle(style) {
     if (style?.dim !== undefined) {
         next.dim = style.dim;
     }
+    if (style?.underline !== undefined) {
+        next.underline = style.underline;
+    }
     return next;
 }
 function normalizeSize(value) {
@@ -168,22 +174,23 @@ function cellsEqual(left, right) {
         && left.style.fg === right.style.fg
         && left.style.bg === right.style.bg
         && left.style.bold === right.style.bold
-        && left.style.dim === right.style.dim;
+        && left.style.dim === right.style.dim
+        && left.style.underline === right.style.underline;
 }
-function applyForegroundColor(instance, color) {
-    if (color.startsWith("#")) {
-        return instance.hex(color);
+function applyForegroundColor(instance, ansiColor) {
+    if (ansiColor.startsWith("#")) {
+        return instance.hex(ansiColor);
     }
-    const painter = instance[color];
+    const painter = instance[ansiColor];
     return typeof painter === "function" ? painter : instance;
 }
-function applyBackgroundColor(instance, color) {
-    if (color.startsWith("#")) {
-        return instance.bgHex(color);
+function applyBackgroundColor(instance, ansiColor) {
+    if (ansiColor.startsWith("#")) {
+        return instance.bgHex(ansiColor);
     }
-    const methodName = color.startsWith("bg")
-        ? color
-        : `bg${color.charAt(0).toUpperCase()}${color.slice(1)}`;
+    const methodName = ansiColor.startsWith("bg")
+        ? ansiColor
+        : `bg${ansiColor.charAt(0).toUpperCase()}${ansiColor.slice(1)}`;
     const painter = instance[methodName];
     return typeof painter === "function" ? painter : instance;
 }

package/node_modules/@poe-code/design-system/dist/dashboard/keymap.d.ts

@@ -1,3 +1,8 @@
 import type { KeypressEvent } from "./terminal.js";
 import type { Command } from "./types.js";
 export declare function createKeymap(overrides?: Partial<Record<Command, string[]>>): (event: KeypressEvent) => Command | undefined;
+export declare function createKeymap<TCommand extends string>(overrides: Partial<Record<TCommand, string[]>> | undefined, options: {
+    commands: readonly TCommand[];
+    defaultBindings: Record<TCommand, readonly string[]>;
+}): (event: KeypressEvent) => TCommand | undefined;
+export declare function canonicalizeBinding(binding: string): string | undefined;

package/node_modules/@poe-code/design-system/dist/dashboard/keymap.js

@@ -7,23 +7,78 @@ const defaultBindings = {
     retry: ["r"],
     "view-log": ["l"]
 };
-export function createKeymap(overrides) {
+export function createKeymap(overrides, options) {
+    const resolvedCommands = options?.commands ?? commands;
+    const resolvedDefaults = options?.defaultBindings ?? defaultBindings;
     const bindings = new Map();
-    for (const command of commands) {
-        const keys = overrides?.[command] ?? defaultBindings[command];
-        bindings.set(command, keys
+    const sequences = new Set();
+    let pendingSequence = "";
+    for (const command of resolvedCommands) {
+        const keys = overrides?.[command] ?? resolvedDefaults[command];
+        const commandBindings = keys
             .map(parseBinding)
-            .filter((binding) => binding !== undefined));
+            .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) {
+        for (const command of resolvedCommands) {
             const commandBindings = bindings.get(command);
-            if (commandBindings?.some((binding) => matches(binding, event))) {
+            if (commandBindings?.some((binding) => matchesSingleKey(binding, event))) {
+                pendingSequence = "";
                 return command;
             }
         }
+        const sequenceCommand = resolveSequence(event);
+        if (sequenceCommand !== undefined) {
+            return sequenceCommand;
+        }
         return undefined;
     };
+    function resolveSequence(event) {
+        const token = eventToSequenceToken(event);
+        if (token === undefined) {
+            pendingSequence = "";
+            return undefined;
+        }
+        pendingSequence = `${pendingSequence}${token}`;
+        for (const command of resolvedCommands) {
+            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;
+    }
+}
+export 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();
@@ -56,25 +111,41 @@ function parseBinding(binding) {
             continue;
         }
     }
-    if (parts.length === 1 && isShiftedCharacter(key)) {
+    const normalizedKey = normalizeKeyName(key);
+    if (parts.length === 1 && isShiftedCharacter(normalizedKey)) {
         shift = true;
     }
-    if (key.length === 1) {
+    if (normalizedKey.length === 1) {
+        return {
+            ch: normalizeBindingCharacter(normalizedKey, shift),
+            ctrl,
+            meta,
+            shift
+        };
+    }
+    if (!ctrl &&
+        !meta &&
+        !shift &&
+        !isNamedKey(normalizedKey) &&
+        isPrintableSequence(normalizedKey)) {
         return {
-            ch: normalizeBindingCharacter(key, shift),
+            sequence: normalizedKey,
             ctrl,
             meta,
             shift
         };
     }
     return {
-        name: key.toLowerCase(),
+        name: normalizedKey.toLowerCase(),
         ctrl,
         meta,
         shift
     };
 }
-function matches(binding, event) {
+function matchesSingleKey(binding, event) {
+    if (binding.sequence !== undefined) {
+        return false;
+    }
     if (binding.ctrl !== event.ctrl ||
         binding.meta !== event.meta ||
         binding.shift !== event.shift) {
@@ -88,6 +159,20 @@ function matches(binding, event) {
     }
     return false;
 }
+function eventToSequenceToken(event) {
+    if (event.ctrl || event.meta || event.ch === undefined) {
+        return undefined;
+    }
+    return event.ch;
+}
+function hasSequencePrefix(sequences, prefix) {
+    for (const sequence of sequences) {
+        if (sequence.startsWith(prefix)) {
+            return true;
+        }
+    }
+    return false;
+}
 function isShiftedCharacter(value) {
     return value.length === 1 && value.toLowerCase() !== value && value.toUpperCase() === value;
 }
@@ -97,3 +182,52 @@ function normalizeBindingCharacter(value, shift) {
     }
     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());
+}
+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;
+}
+const namedKeys = new Set([
+    "backspace",
+    "delete",
+    "down",
+    "end",
+    "enter",
+    "escape",
+    "home",
+    "left",
+    "pagedown",
+    "pageup",
+    "return",
+    "right",
+    "tab",
+    "up"
+]);

package/node_modules/@poe-code/design-system/dist/dashboard/terminal.js

@@ -185,6 +185,10 @@ export function parseKeypress(data) {
     return event;
 }
 function toKeypressEvent(str, key) {
+    const controlCharacter = controlCharacterToKeypress(key?.sequence);
+    if (controlCharacter !== undefined) {
+        return controlCharacter;
+    }
     const ctrl = key?.ctrl ?? false;
     const meta = key?.meta ?? false;
     const shift = key?.shift ?? false;
@@ -206,12 +210,22 @@ function extractPrintableCharacter(str, sequence) {
     if (isPrintableCharacter(str)) {
         return str;
     }
+    if (isSinglePrintableSequence(sequence)) {
+        return sequence;
+    }
     if (sequence === undefined || sequence.length <= 1 || sequence[0] !== "\u001b") {
         return undefined;
     }
     const candidate = sequence.slice(1);
     return isPrintableCharacter(candidate) ? candidate : undefined;
 }
+function isSinglePrintableSequence(value) {
+    if (value === undefined || Array.from(value).length !== 1) {
+        return false;
+    }
+    const codePoint = value.codePointAt(0);
+    return codePoint !== undefined && codePoint >= 0x20 && codePoint !== 0x7f;
+}
 function isPrintableCharacter(value) {
     if (value === undefined || Array.from(value).length !== 1) {
         return false;
@@ -219,6 +233,23 @@ function isPrintableCharacter(value) {
     const codePoint = value.codePointAt(0);
     return codePoint !== undefined && codePoint >= 0x20 && codePoint !== 0x7f;
 }
+function controlCharacterToKeypress(sequence) {
+    if (sequence === "\u001f") {
+        return { ch: "/", ctrl: true, meta: false, shift: false };
+    }
+    if (sequence !== undefined && sequence.length === 1) {
+        const code = sequence.charCodeAt(0);
+        if (code >= 1 && code <= 26 && code !== 9 && code !== 10 && code !== 13) {
+            return {
+                name: String.fromCharCode(code + 96),
+                ctrl: true,
+                meta: false,
+                shift: false
+            };
+        }
+    }
+    return undefined;
+}
 function cursorPositionAnsi(x, y) {
     return `\u001b[${normalizeCoordinate(y) + 1};${normalizeCoordinate(x) + 1}H`;
 }

package/node_modules/@poe-code/design-system/dist/dashboard/types.d.ts

@@ -23,6 +23,7 @@ export type CellStyle = {
     bg?: string;
     bold?: boolean;
     dim?: boolean;
+    underline?: boolean;
 };
 export type Cell = {
     ch: string;

package/node_modules/@poe-code/design-system/dist/explorer/actions.d.ts

@@ -0,0 +1,16 @@
+import type { ExplorerEvent } from "./events.js";
+import type { Action, ActionContext, ExplorerState, Row, Tone } from "./state.js";
+export type ActionSource = "row" | "detail";
+type ExplorerKeypressEvent = Extract<ExplorerEvent, {
+    type: "key";
+}>["key"];
+export type ActionRuntimeHandles = {
+    refresh: () => Promise<void>;
+    suspendAnd: <T>(fn: () => Promise<T>) => Promise<T>;
+    toast: (msg: string, tone?: Tone) => void;
+    confirm: (prompt: string) => Promise<boolean>;
+    exit: (after?: () => void | Promise<void>) => void;
+};
+export declare function resolveAction<R>(state: ExplorerState, keyEvent: ExplorerKeypressEvent): Action<R> | null;
+export declare function buildActionContext<R>(state: ExplorerState, _action: Action<R>, source: ActionSource, runtimeHandles: ActionRuntimeHandles, rowsOverride?: Row[]): ActionContext<R>;
+export {};