terminal-pilot 0.0.30 → 0.0.31

package/node_modules/toolcraft-design/dist/components/template.js

@@ -0,0 +1,437 @@
+const MAX_PARTIAL_DEPTH = 100;
+const HTML_ESCAPE = {
+    "&": "&",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;",
+    "/": "&#x2F;",
+    "`": "&#x60;",
+    "=": "&#x3D;"
+};
+export function renderTemplate(template, view, options = {}) {
+    const prepared = options.yield === undefined
+        ? template
+        : resolveTemplatePartials(template, options.partials ?? {})
+            .split("{{yield}}")
+            .join(options.yield);
+    const tokens = parseTemplate(prepared);
+    validatePartialReferences(tokens, options.partials ?? {}, []);
+    if (options.validate === true) {
+        const expanded = resolveTemplatePartials(prepared, options.partials ?? {});
+        validateVariables(parseTemplate(expanded), { view });
+    }
+    const state = {
+        escape: options.escape === "none" ? String : escapeHtml,
+        partials: options.partials ?? {},
+        partialStack: [],
+        preserveMissing: options.yield !== undefined && options.escape === "none",
+        validate: options.validate === true
+    };
+    return renderTokens(tokens, { view }, prepared, state);
+}
+export function getTemplatePartialNames(template) {
+    const names = new Set();
+    collectPartialNames(parseTemplate(template), names);
+    return [...names];
+}
+export function resolveTemplatePartials(template, partials) {
+    return expandTemplatePartials(template, partials, []);
+}
+function renderTemplateInContext(template, context, state) {
+    return renderTokens(parseTemplate(template), context, template, state);
+}
+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 === "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 === "partial") {
+            tokens.push({
+                type: "partial",
+                name: parsed.name,
+                indent: standalone === undefined ? "" : template.slice(standalone.lineStart, open)
+            });
+            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, state) {
+    let output = "";
+    for (const token of tokens) {
+        switch (token.type) {
+            case "text":
+                output += token.value;
+                continue;
+            case "name":
+            case "unescaped": {
+                const result = lookup(context, token.name);
+                if (!result.hit || result.value == null) {
+                    if (state.validate) {
+                        throw new Error(`Template variable "${token.name}" not found.`);
+                    }
+                    if (state.preserveMissing) {
+                        output += token.raw;
+                    }
+                    continue;
+                }
+                const rendered = String(result.value);
+                output += token.type === "name" ? state.escape(rendered) : rendered;
+                continue;
+            }
+            case "partial": {
+                if (!Object.hasOwn(state.partials, token.name)) {
+                    throw new Error(`Partial "${token.name}" not found.`);
+                }
+                if (state.partialStack.includes(token.name)) {
+                    throw new Error(`Circular partial reference detected: ${[...state.partialStack, token.name].join(" -> ")}.`);
+                }
+                if (state.partialStack.length >= MAX_PARTIAL_DEPTH) {
+                    throw new Error(`Maximum partial depth exceeded (${MAX_PARTIAL_DEPTH}).`);
+                }
+                const partial = indentPartial(state.partials[token.name], token.indent);
+                output += renderTokens(parseTemplate(partial), context, partial, {
+                    ...state,
+                    partialStack: [...state.partialStack, token.name]
+                });
+                continue;
+            }
+            case "inverted": {
+                const result = lookup(context, token.name);
+                if (!result.hit && state.validate) {
+                    throw new Error(`Template variable "${token.name}" not found.`);
+                }
+                const value = result.value;
+                if (!value || (Array.isArray(value) && value.length === 0)) {
+                    output += renderTokens(token.children, context, template, state);
+                }
+                continue;
+            }
+            case "section": {
+                const result = lookup(context, token.name);
+                if (!result.hit && state.validate) {
+                    throw new Error(`Template variable "${token.name}" not found.`);
+                }
+                const value = result.value;
+                if (!value) {
+                    continue;
+                }
+                if (Array.isArray(value)) {
+                    for (const item of value) {
+                        output += renderTokens(token.children, pushContext(context, item), template, state);
+                    }
+                    continue;
+                }
+                if (typeof value === "function") {
+                    const raw = template.slice(token.rawStart, token.rawEnd);
+                    const rendered = value.call(context.view, raw, (nextTemplate) => renderTemplateInContext(nextTemplate, context, state));
+                    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, state);
+                    continue;
+                }
+                output += renderTokens(token.children, context, template, state);
+            }
+        }
+    }
+    return output;
+}
+function lookup(context, name) {
+    if (name === ".") {
+        return { hit: true, value: 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 { hit: true, value: callLambda(result.value, cursor.view) };
+        }
+        cursor = cursor.parent;
+    }
+    return { hit: false, value: undefined };
+}
+function collectPartialNames(tokens, names) {
+    for (const token of tokens) {
+        if (token.type === "partial") {
+            names.add(token.name);
+            continue;
+        }
+        if (token.type === "section" || token.type === "inverted") {
+            collectPartialNames(token.children, names);
+        }
+    }
+}
+function validateVariables(tokens, context) {
+    for (const token of tokens) {
+        if (token.type === "text" || token.type === "partial") {
+            continue;
+        }
+        if (token.type === "name" || token.type === "unescaped") {
+            if (!lookup(context, token.name).hit) {
+                throw new Error(`Template variable "${token.name}" not found.`);
+            }
+            continue;
+        }
+        if (token.type !== "section" && token.type !== "inverted") {
+            continue;
+        }
+        const result = lookup(context, token.name);
+        if (!result.hit) {
+            throw new Error(`Template variable "${token.name}" not found.`);
+        }
+        if (Array.isArray(result.value) && result.value.length > 0) {
+            for (const item of result.value) {
+                validateVariables(token.children, pushContext(context, item));
+            }
+            continue;
+        }
+        if (typeof result.value === "object" && result.value !== null ||
+            typeof result.value === "string" ||
+            typeof result.value === "number") {
+            validateVariables(token.children, pushContext(context, result.value));
+            continue;
+        }
+        validateVariables(token.children, context);
+    }
+}
+function validatePartialReferences(tokens, partials, partialStack) {
+    for (const token of tokens) {
+        if (token.type === "section" || token.type === "inverted") {
+            validatePartialReferences(token.children, partials, partialStack);
+            continue;
+        }
+        if (token.type !== "partial") {
+            continue;
+        }
+        if (!Object.hasOwn(partials, token.name)) {
+            throw new Error(`Partial "${token.name}" not found.`);
+        }
+        if (partialStack.includes(token.name)) {
+            throw new Error(`Circular partial reference detected: ${[...partialStack, token.name].join(" -> ")}.`);
+        }
+        if (partialStack.length >= MAX_PARTIAL_DEPTH) {
+            throw new Error(`Maximum partial depth exceeded (${MAX_PARTIAL_DEPTH}).`);
+        }
+        validatePartialReferences(parseTemplate(partials[token.name]), partials, [
+            ...partialStack,
+            token.name
+        ]);
+    }
+}
+function indentPartial(partial, indent) {
+    if (indent === "") {
+        return partial;
+    }
+    return partial
+        .split("\n")
+        .map((line) => (line === "" ? "" : `${indent}${line}`))
+        .join("\n");
+}
+function expandTemplatePartials(template, partials, partialStack) {
+    let output = "";
+    let index = 0;
+    while (index < template.length) {
+        const open = template.indexOf("{{", index);
+        if (open === -1) {
+            output += template.slice(index);
+            break;
+        }
+        const parsed = parseTag(template, open);
+        if (parsed.kind !== "partial") {
+            output += template.slice(index, parsed.end);
+            index = parsed.end;
+            continue;
+        }
+        if (!Object.hasOwn(partials, parsed.name)) {
+            throw new Error(`Partial "${parsed.name}" not found.`);
+        }
+        if (partialStack.includes(parsed.name)) {
+            throw new Error(`Circular partial reference detected: ${[...partialStack, parsed.name].join(" -> ")}.`);
+        }
+        if (partialStack.length >= MAX_PARTIAL_DEPTH) {
+            throw new Error(`Maximum partial depth exceeded (${MAX_PARTIAL_DEPTH}).`);
+        }
+        const standalone = getStandalone(template, open, parsed.end, parsed.kind);
+        const beforePartial = standalone === undefined
+            ? template.slice(index, open)
+            : template.slice(index, standalone.lineStart);
+        const indent = standalone === undefined ? "" : template.slice(standalone.lineStart, open);
+        const partial = indentPartial(partials[parsed.name], indent);
+        output +=
+            beforePartial + expandTemplatePartials(partial, partials, [...partialStack, parsed.name]);
+        index = standalone?.nextIndex ?? parsed.end;
+    }
+    return output;
+}
+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;
+    for (const part of parts) {
+        if (!isPropertyContainer(value) || !hasProperty(value, part)) {
+            return { hit: false, value: undefined };
+        }
+        value = Object(value)[part];
+    }
+    return { hit: true, 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 Object.prototype.hasOwnProperty.call(value, key);
+}

package/node_modules/toolcraft-design/dist/components/text.d.ts

@@ -0,0 +1,16 @@
+export declare const text: {
+    readonly intro: (content: string) => string;
+    readonly heading: (content: string) => string;
+    readonly section: (content: string) => string;
+    readonly sectionHeader: (content: string) => string;
+    readonly command: (content: string) => string;
+    readonly argument: (content: string) => string;
+    readonly option: (content: string) => string;
+    readonly example: (content: string) => string;
+    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/toolcraft-design/dist/components/text.js

@@ -0,0 +1,145 @@
+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";
+function renderMarkdownInline(content) {
+    return content.replaceAll("\r\n", " ").replaceAll("\n", " ").replaceAll("\r", " ");
+}
+function renderMarkdownCode(content) {
+    const value = renderMarkdownInline(content);
+    let longestRun = 0;
+    let currentRun = 0;
+    for (const char of value) {
+        if (char === "`") {
+            currentRun += 1;
+            longestRun = Math.max(longestRun, currentRun);
+            continue;
+        }
+        currentRun = 0;
+    }
+    const delimiter = "`".repeat(longestRun + 1);
+    const paddedValue = value.startsWith("`") || value.endsWith("`") ? ` ${value} ` : value;
+    return `${delimiter}${paddedValue}${delimiter}`;
+}
+function renderMarkdownLink(content) {
+    const value = renderMarkdownInline(content);
+    const label = value.replaceAll("\\", "\\\\").replaceAll("[", "\\[").replaceAll("]", "\\]");
+    const url = value.replaceAll("\\", "\\\\").replaceAll("(", "\\(").replaceAll(")", "\\)");
+    return `[${label}](${url})`;
+}
+export const text = {
+    intro(content) {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return content;
+        if (format === "markdown")
+            return `**${content}**`;
+        return getTheme().intro(content);
+    },
+    heading(content) {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return content;
+        if (format === "markdown")
+            return `## ${content}`;
+        return getTheme().header(content);
+    },
+    section(content) {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return content;
+        if (format === "markdown")
+            return `**${content}**`;
+        return typography.bold(content);
+    },
+    sectionHeader(content) {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return content;
+        if (format === "markdown")
+            return `## ${content}`;
+        return typography.bold(content.toUpperCase());
+    },
+    command(content) {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return content;
+        if (format === "markdown")
+            return renderMarkdownCode(content);
+        return getTheme().accent(content);
+    },
+    argument(content) {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return content;
+        if (format === "markdown")
+            return `<${content}>`;
+        return getTheme().muted(content);
+    },
+    option(content) {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return content;
+        if (format === "markdown")
+            return renderMarkdownCode(content);
+        return color.yellow(content);
+    },
+    example(content) {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return content;
+        if (format === "markdown")
+            return renderMarkdownCode(content);
+        return getTheme().muted(content);
+    },
+    usageCommand(content) {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return content;
+        if (format === "markdown")
+            return renderMarkdownCode(content);
+        return color.green(content);
+    },
+    link(content) {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return content;
+        if (format === "markdown")
+            return renderMarkdownLink(content);
+        return getTheme().accent(content);
+    },
+    muted(content) {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return content;
+        if (format === "markdown")
+            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")
+            return content;
+        if (format === "markdown")
+            return `[${content}]`;
+        return getTheme().badge(content);
+    },
+    selectLabel(label, detail) {
+        if (!detail) {
+            return label;
+        }
+        const format = resolveOutputFormat();
+        if (format !== "terminal") {
+            return `${label} — ${detail}`;
+        }
+        return `${label} ${typography.dim("—")} ${typography.dim(detail)}`;
+    }
+};

package/node_modules/toolcraft-design/dist/dashboard/ansi.d.ts

@@ -0,0 +1,18 @@
+import type { CellStyle } from "./types.js";
+export interface StyledSegment {
+    text: string;
+    style: CellStyle;
+}
+export interface StyledLine {
+    segments: StyledSegment[];
+}
+export declare function hasAnsi(text: string): boolean;
+/**
+ * Parse a block of text that may contain ANSI SGR escape codes into a sequence of
+ * logical lines split on "\n". Each line is a list of styled segments: contiguous
+ * printable runs of characters sharing the same style.
+ *
+ * Common cursor-affecting line controls are rendered into their visible result.
+ * `baseStyle` is used as the initial style and as the restore target for SGR reset / default color.
+ */
+export declare function parseAnsi(text: string, baseStyle?: CellStyle): StyledLine[];