toolcraft 0.0.23 → 0.0.24

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

@@ -1,3 +1,4 @@
+const MAX_PARTIAL_DEPTH = 100;
 const HTML_ESCAPE = {
     "&": "&",
     "<": "&lt;",
@@ -11,14 +12,34 @@ const HTML_ESCAPE = {
 export function renderTemplate(template, view, options = {}) {
     const prepared = options.yield === undefined
         ? template
-        : template.split("{{yield}}").join(options.yield);
+        : resolveTemplatePartials(template, options.partials ?? {})
+            .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);
+    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, escape, preserveMissing) {
-    return renderTokens(parseTemplate(template), context, template, escape, preserveMissing);
+function renderTemplateInContext(template, context, state) {
+    return renderTokens(parseTemplate(template), context, template, state);
 }
 function parseTemplate(template) {
     const root = [];
@@ -41,9 +62,6 @@ function parseTemplate(template) {
             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");
         }
@@ -61,6 +79,15 @@ function parseTemplate(template) {
             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) {
@@ -138,7 +165,7 @@ function getStandalone(template, tagStart, tagEnd, kind) {
     }
     return undefined;
 }
-function renderTokens(tokens, context, template, escape, preserveMissing) {
+function renderTokens(tokens, context, template, state) {
     let output = "";
     for (const token of tokens) {
         switch (token.type) {
@@ -147,48 +174,76 @@ function renderTokens(tokens, context, template, escape, preserveMissing) {
                 continue;
             case "name":
             case "unescaped": {
-                const value = lookup(context, token.name);
-                if (value == null) {
-                    if (preserveMissing) {
+                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(value);
-                output += token.type === "name" ? escape(rendered) : rendered;
+                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 value = lookup(context, token.name);
+                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, escape, preserveMissing);
+                    output += renderTokens(token.children, context, template, state);
                 }
                 continue;
             }
             case "section": {
-                const value = lookup(context, token.name);
+                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, escape, preserveMissing);
+                        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, escape, preserveMissing));
+                    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, escape, preserveMissing);
+                    output += renderTokens(token.children, pushContext(context, value), template, state);
                     continue;
                 }
-                output += renderTokens(token.children, context, template, escape, preserveMissing);
+                output += renderTokens(token.children, context, template, state);
             }
         }
     }
@@ -196,7 +251,7 @@ function renderTokens(tokens, context, template, escape, preserveMissing) {
 }
 function lookup(context, name) {
     if (name === ".") {
-        return callLambda(context.view, context.view);
+        return { hit: true, value: callLambda(context.view, context.view) };
     }
     let cursor = context;
     while (cursor !== undefined) {
@@ -204,11 +259,124 @@ function lookup(context, name) {
             ? lookupDotted(cursor.view, name)
             : lookupName(cursor.view, name);
         if (result.hit) {
-            return callLambda(result.value, cursor.view);
+            return { hit: true, value: callLambda(result.value, cursor.view) };
         }
         cursor = cursor.parent;
     }
-    return undefined;
+    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)) {
@@ -219,15 +387,13 @@ function lookupName(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);
+    for (const part of parts) {
+        if (!isPropertyContainer(value) || !hasProperty(value, part)) {
+            return { hit: false, value: undefined };
         }
         value = Object(value)[part];
     }
-    return { hit, value };
+    return { hit: true, value };
 }
 function callLambda(value, view) {
     return typeof value === "function" ? value.call(view) : value;
@@ -267,5 +433,5 @@ function isPropertyContainer(value) {
     return (typeof value === "object" && value !== null) || typeof value === "function";
 }
 function hasProperty(value, key) {
-    return key in value;
+    return Object.prototype.hasOwnProperty.call(value, key);
 }

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

@@ -2,6 +2,30 @@ 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);
+    return `${delimiter}${value}${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();
@@ -40,7 +64,7 @@ export const text = {
         if (format === "json")
             return content;
         if (format === "markdown")
-            return `\`${content}\``;
+            return renderMarkdownCode(content);
         return getTheme().accent(content);
     },
     argument(content) {
@@ -56,7 +80,7 @@ export const text = {
         if (format === "json")
             return content;
         if (format === "markdown")
-            return `\`${content}\``;
+            return renderMarkdownCode(content);
         return color.yellow(content);
     },
     example(content) {
@@ -64,7 +88,7 @@ export const text = {
         if (format === "json")
             return content;
         if (format === "markdown")
-            return `\`${content}\``;
+            return renderMarkdownCode(content);
         return getTheme().muted(content);
     },
     usageCommand(content) {
@@ -72,7 +96,7 @@ export const text = {
         if (format === "json")
             return content;
         if (format === "markdown")
-            return `\`${content}\``;
+            return renderMarkdownCode(content);
         return color.green(content);
     },
     link(content) {
@@ -80,7 +104,7 @@ export const text = {
         if (format === "json")
             return content;
         if (format === "markdown")
-            return `[${content}](${content})`;
+            return renderMarkdownLink(content);
         return getTheme().accent(content);
     },
     muted(content) {

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

@@ -12,7 +12,7 @@ export declare function hasAnsi(text: string): boolean;
  * logical lines split on "\n". Each line is a list of styled segments: contiguous
  * printable runs of characters sharing the same style.
  *
- * Non-SGR CSI sequences and other control characters are discarded. `baseStyle` is
- * used as the initial style and as the restore target for SGR reset / default color.
+ * 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[];

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

@@ -7,38 +7,25 @@ export function hasAnsi(text) {
  * logical lines split on "\n". Each line is a list of styled segments: contiguous
  * printable runs of characters sharing the same style.
  *
- * Non-SGR CSI sequences and other control characters are discarded. `baseStyle` is
- * used as the initial style and as the restore target for SGR reset / default color.
+ * 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 function parseAnsi(text, baseStyle) {
     const base = normalizeStyle(baseStyle);
     let style = { ...base };
+    let concealed = false;
     const lines = [];
-    let segments = [];
-    let pending = "";
-    const flushSegment = () => {
-        if (pending.length === 0) {
-            return;
-        }
-        const last = segments[segments.length - 1];
-        if (last && stylesEqual(last.style, style)) {
-            last.text += pending;
-        }
-        else {
-            segments.push({ text: pending, style: { ...style } });
-        }
-        pending = "";
-    };
+    let cells = [];
+    let column = 0;
     const finishLine = () => {
-        flushSegment();
-        lines.push({ segments });
-        segments = [];
+        lines.push({ segments: cellsToSegments(cells) });
+        cells = [];
+        column = 0;
     };
     let index = 0;
     while (index < text.length) {
         const ch = text[index];
         if (ch === ESC && text[index + 1] === "[") {
-            flushSegment();
             const paramsStart = index + 2;
             let cursor = paramsStart;
             while (cursor < text.length && !isCsiFinalByte(text[cursor])) {
@@ -51,13 +38,17 @@ export function parseAnsi(text, baseStyle) {
             const params = text.slice(paramsStart, cursor);
             const finalByte = text[cursor];
             if (finalByte === "m") {
-                style = applySgr(style, parseParams(params), base);
+                const sgr = applySgr(style, concealed, parseParams(params), base);
+                style = sgr.style;
+                concealed = sgr.concealed;
+            }
+            else if (finalByte === "K" && parseParams(params)[0] === 2) {
+                cells = [];
             }
             index = cursor + 1;
             continue;
         }
         if (ch === ESC) {
-            flushSegment();
             const next = text[index + 1];
             if (next === "]" || next === "P" || next === "X" || next === "^" || next === "_") {
                 index = skipStringTerminated(text, index + 2);
@@ -67,6 +58,7 @@ export function parseAnsi(text, baseStyle) {
             continue;
         }
         if (ch === "\r") {
+            column = 0;
             index += 1;
             continue;
         }
@@ -75,17 +67,37 @@ export function parseAnsi(text, baseStyle) {
             index += 1;
             continue;
         }
+        if (ch === "\b") {
+            column = Math.max(0, column - 1);
+            index += 1;
+            continue;
+        }
         const code = ch.charCodeAt(0);
         if (code < 0x20 && ch !== "\t") {
             index += 1;
             continue;
         }
-        pending += ch;
+        cells[column] = { ch: concealed ? " " : ch, style: { ...style } };
+        column += 1;
         index += 1;
     }
     finishLine();
     return lines;
 }
+function cellsToSegments(cells) {
+    const segments = [];
+    for (const cell of cells) {
+        const nextCell = cell ?? { ch: " ", style: {} };
+        const last = segments[segments.length - 1];
+        if (last && stylesEqual(last.style, nextCell.style)) {
+            last.text += nextCell.ch;
+        }
+        else {
+            segments.push({ text: nextCell.ch, style: { ...nextCell.style } });
+        }
+    }
+    return segments;
+}
 function isCsiFinalByte(ch) {
     const code = ch.charCodeAt(0);
     return code >= 0x40 && code <= 0x7e;
@@ -108,14 +120,21 @@ function parseParams(params) {
     if (params.length === 0) {
         return [0];
     }
-    return params.split(";").map((part) => {
-        if (part.length === 0) {
-            return 0;
+    return params.split(";").flatMap((part) => {
+        const colonParams = part.split(":");
+        if (colonParams.length > 2 && colonParams[1] === "2") {
+            colonParams.splice(2, 1);
         }
-        const parsed = Number.parseInt(part, 10);
-        return Number.isFinite(parsed) ? parsed : 0;
+        return colonParams.map(parseParam);
     });
 }
+function parseParam(part) {
+    if (part.length === 0) {
+        return 0;
+    }
+    const parsed = Number.parseInt(part, 10);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
 const BASIC_COLORS = [
     "black",
     "red",
@@ -136,13 +155,15 @@ const BRIGHT_COLORS = [
     "cyanBright",
     "whiteBright"
 ];
-function applySgr(style, params, base) {
+function applySgr(style, concealed, params, base) {
     let next = { ...style };
+    let nextConcealed = concealed;
     let index = 0;
     while (index < params.length) {
         const code = params[index];
         if (code === 0) {
             next = { ...base };
+            nextConcealed = false;
             index += 1;
             continue;
         }
@@ -156,12 +177,32 @@ function applySgr(style, params, base) {
             index += 1;
             continue;
         }
+        if (code === 7) {
+            next.inverse = true;
+            index += 1;
+            continue;
+        }
         if (code === 22) {
             delete next.bold;
             delete next.dim;
             index += 1;
             continue;
         }
+        if (code === 8) {
+            nextConcealed = true;
+            index += 1;
+            continue;
+        }
+        if (code === 28) {
+            nextConcealed = false;
+            index += 1;
+            continue;
+        }
+        if (code === 27) {
+            delete next.inverse;
+            index += 1;
+            continue;
+        }
         if (code >= 30 && code <= 37) {
             next.fg = BASIC_COLORS[code - 30];
             index += 1;
@@ -242,7 +283,7 @@ function applySgr(style, params, base) {
         }
         index += 1;
     }
-    return next;
+    return { style: next, concealed: nextConcealed };
 }
 function convert256(palette) {
     if (palette < 0 || palette > 255) {
@@ -278,7 +319,8 @@ function stylesEqual(left, right) {
     return left.fg === right.fg
         && left.bg === right.bg
         && left.bold === right.bold
-        && left.dim === right.dim;
+        && left.dim === right.dim
+        && left.inverse === right.inverse;
 }
 function normalizeStyle(style) {
     const next = {};
@@ -294,5 +336,8 @@ function normalizeStyle(style) {
     if (style?.dim !== undefined) {
         next.dim = style.dim;
     }
+    if (style?.inverse !== undefined) {
+        next.inverse = style.inverse;
+    }
     return next;
 }