toolcraft-openapi 0.0.74 → 0.0.76

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

@@ -0,0 +1 @@
+export { symbols } from "./components/symbols.js";

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

@@ -0,0 +1 @@
+export { symbols } from "./components/symbols.js";

package/node_modules/toolcraft-design/dist/terminal-markdown/html-renderer.d.ts

@@ -0,0 +1,6 @@
+import type { MdNode } from "./ast.js";
+export interface HtmlRenderOptions {
+    showFrontmatter?: boolean;
+    allowRawHtml?: boolean;
+}
+export declare function renderHtml(ast: MdNode, options?: HtmlRenderOptions): string;

package/node_modules/toolcraft-design/dist/terminal-markdown/html-renderer.js

@@ -0,0 +1,356 @@
+export function renderHtml(ast, options = {}) {
+    const context = {
+        showFrontmatter: options.showFrontmatter ?? false,
+        allowRawHtml: options.allowRawHtml ?? false,
+        footnotes: ast.type === "root" ? createFootnoteState(ast.children) : undefined
+    };
+    return renderNode(ast, context);
+}
+function renderNode(node, context) {
+    switch (node.type) {
+        case "root":
+            return renderRoot(node, context);
+        case "heading":
+            return renderHeading(node, context);
+        case "paragraph":
+            return renderParagraph(node, context);
+        case "blockquote":
+            return renderBlockquote(node, context);
+        case "alert":
+            return renderAlert(node, context);
+        case "code":
+            return renderCodeBlock(node);
+        case "list":
+            return renderList(node, context);
+        case "table":
+            return renderTable(node, context);
+        case "html":
+            return context.allowRawHtml ? node.value : escapeHtml(node.value);
+        case "thematicBreak":
+            return "<hr>";
+        case "frontmatter":
+            return context.showFrontmatter ? renderFrontmatter(node.data) : "";
+        case "footnoteDefinition":
+            return "";
+        case "text":
+        case "strong":
+        case "emphasis":
+        case "strikethrough":
+        case "inlineCode":
+        case "link":
+        case "image":
+        case "break":
+        case "footnoteReference":
+            return renderInline(node, context);
+        default:
+            return "children" in node ? renderChildren(node.children, context) : "";
+    }
+}
+function renderRoot(node, context) {
+    const blocks = node.children
+        .filter((child) => child.type !== "footnoteDefinition")
+        .map((child) => renderNode(child, context))
+        .filter((value) => value.length > 0);
+    const footnotes = renderReferencedFootnotes(context);
+    if (footnotes.length > 0) {
+        blocks.push(footnotes);
+    }
+    return blocks.join("\n");
+}
+function renderChildren(children, context) {
+    return children
+        .map((child) => renderNode(child, context))
+        .filter((value) => value.length > 0)
+        .join("\n");
+}
+function renderHeading(node, context) {
+    const content = renderInlineChildren(node.children, context);
+    return content.length === 0 ? "" : `<h${node.depth}>${content}</h${node.depth}>`;
+}
+function renderParagraph(node, context) {
+    const content = renderInlineChildren(node.children, context);
+    return content.length === 0 ? "" : `<p>${content}</p>`;
+}
+function renderBlockquote(node, context) {
+    const content = renderChildren(node.children, context);
+    return `<blockquote>${content}</blockquote>`;
+}
+function renderAlert(node, context) {
+    const content = renderChildren(node.children, context);
+    return `<blockquote data-alert="${escapeAttribute(node.kind)}">${content}</blockquote>`;
+}
+function renderCodeBlock(node) {
+    const classAttribute = node.lang === undefined || node.lang.length === 0
+        ? ""
+        : ` class="language-${escapeAttribute(node.lang)}"`;
+    return `<pre><code${classAttribute}>${escapeHtml(node.value)}</code></pre>`;
+}
+function renderList(node, context) {
+    const tag = node.ordered ? "ol" : "ul";
+    const startAttribute = node.ordered && node.start !== undefined && node.start !== 1
+        ? ` start="${escapeAttribute(String(node.start))}"`
+        : "";
+    const items = node.children
+        .map((child) => (child.type === "listItem" ? renderListItem(child, context) : renderNode(child, context)))
+        .filter((value) => value.length > 0)
+        .join("");
+    return items.length === 0 ? "" : `<${tag}${startAttribute}>${items}</${tag}>`;
+}
+function renderListItem(node, context) {
+    const renderedChildren = node.children
+        .map((child, index) => {
+        if (index === 0 && child.type === "paragraph") {
+            return renderInlineChildren(child.children, context);
+        }
+        return renderNode(child, context);
+    })
+        .filter((value) => value.length > 0);
+    const checkbox = renderTaskCheckbox(node);
+    return `<li>${checkbox}${renderedChildren.join("")}</li>`;
+}
+function renderTaskCheckbox(node) {
+    if (node.checked === true) {
+        return '<input type="checkbox" disabled checked> ';
+    }
+    if (node.checked === false) {
+        return '<input type="checkbox" disabled> ';
+    }
+    return "";
+}
+function renderTable(node, context) {
+    const rows = node.children.filter((child) => child.type === "tableRow");
+    const headerRow = rows[0];
+    if (headerRow === undefined) {
+        return "";
+    }
+    const header = `<thead>${renderTableRow(headerRow, node.align, "th", context)}</thead>`;
+    const bodyRows = rows
+        .slice(1)
+        .map((row) => renderTableRow(row, node.align, "td", context))
+        .join("");
+    const body = `<tbody>${bodyRows}</tbody>`;
+    return ["<table>", header, body, "</table>"].join("\n");
+}
+function renderTableRow(node, alignments, cellTag, context) {
+    const cells = node.children
+        .map((cell, index) => {
+        if (cell.type !== "tableCell") {
+            return "";
+        }
+        const style = renderTableAlignment(alignments[index] ?? null);
+        return `<${cellTag}${style}>${renderInlineChildren(cell.children, context)}</${cellTag}>`;
+    })
+        .join("");
+    return `<tr>${cells}</tr>`;
+}
+function renderTableAlignment(alignment) {
+    if (alignment === null) {
+        return "";
+    }
+    return ` style="text-align: ${alignment}"`;
+}
+function renderFrontmatter(data) {
+    const lines = Object.entries(data).map(([key, value]) => `${key}: ${formatFrontmatterValue(value)}`);
+    if (lines.length === 0) {
+        return "";
+    }
+    return `<pre><code class="language-yaml">${escapeHtml(lines.join("\n"))}</code></pre>`;
+}
+function formatFrontmatterValue(value) {
+    if (value === null) {
+        return "null";
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    const ancestors = [];
+    return JSON.stringify(value, function (_key, nestedValue) {
+        if (typeof nestedValue !== "object" || nestedValue === null) {
+            return nestedValue;
+        }
+        while (ancestors.length > 0 && ancestors[ancestors.length - 1] !== this) {
+            ancestors.pop();
+        }
+        if (ancestors.includes(nestedValue)) {
+            return "[Circular]";
+        }
+        ancestors.push(nestedValue);
+        return nestedValue;
+    });
+}
+function renderInlineChildren(children, context) {
+    return children.map((child) => renderInline(child, context)).join("");
+}
+function renderInline(node, context) {
+    switch (node.type) {
+        case "text":
+            return escapeHtml(node.value);
+        case "strong":
+            return `<strong>${renderInlineChildren(node.children, context)}</strong>`;
+        case "emphasis":
+            return `<em>${renderInlineChildren(node.children, context)}</em>`;
+        case "strikethrough":
+            return `<del>${renderInlineChildren(node.children, context)}</del>`;
+        case "inlineCode":
+            return `<code>${escapeHtml(node.value)}</code>`;
+        case "link":
+            return renderLink(node, context);
+        case "image":
+            return renderImage(node);
+        case "break":
+            return "<br>";
+        case "footnoteReference":
+            return renderFootnoteReference(node, context);
+        case "html":
+            return context.allowRawHtml ? node.value : escapeHtml(node.value);
+        default:
+            return "children" in node ? renderInlineChildren(node.children, context) : renderNode(node, context);
+    }
+}
+function renderLink(node, context) {
+    const href = sanitizeUrl(node.url);
+    const attributes = [
+        href === null ? "" : ` href="${escapeAttribute(href)}"`,
+        node.title === undefined ? "" : ` title="${escapeAttribute(node.title)}"`
+    ].join("");
+    return `<a${attributes}>${renderInlineChildren(node.children, context)}</a>`;
+}
+function renderImage(node) {
+    const src = sanitizeUrl(node.url);
+    const attributes = [
+        src === null ? "" : ` src="${escapeAttribute(src)}"`,
+        ` alt="${escapeAttribute(node.alt)}"`,
+        node.title === undefined ? "" : ` title="${escapeAttribute(node.title)}"`
+    ].join("");
+    return `<img${attributes}>`;
+}
+function renderFootnoteReference(node, context) {
+    const footnotes = context.footnotes;
+    if (footnotes === undefined || !footnotes.definitions.has(node.label)) {
+        return "";
+    }
+    let number = footnotes.numbers.get(node.label);
+    if (number === undefined) {
+        footnotes.labelsInOrder.push(node.label);
+        number = footnotes.labelsInOrder.length;
+        footnotes.numbers.set(node.label, number);
+    }
+    const id = escapeAttribute(createFootnoteId(node.label));
+    return `<sup id="fnref-${id}"><a href="#fn-${id}">${number}</a></sup>`;
+}
+function renderReferencedFootnotes(context) {
+    const footnotes = context.footnotes;
+    if (footnotes === undefined || footnotes.labelsInOrder.length === 0) {
+        return "";
+    }
+    const items = footnotes.labelsInOrder
+        .map((label) => {
+        const definition = footnotes.definitions.get(label);
+        if (definition === undefined) {
+            return "";
+        }
+        const id = escapeAttribute(createFootnoteId(label));
+        const content = renderChildren(definition.children, context);
+        return `<li id="fn-${id}">${content} <a href="#fnref-${id}" aria-label="Back to content">Back</a></li>`;
+    })
+        .filter((value) => value.length > 0)
+        .join("");
+    return items.length === 0 ? "" : `<section class="footnotes"><ol>${items}</ol></section>`;
+}
+function createFootnoteState(children) {
+    const definitions = new Map();
+    for (const child of children) {
+        collectFootnoteDefinitions(child, definitions);
+    }
+    return {
+        definitions,
+        labelsInOrder: [],
+        numbers: new Map()
+    };
+}
+function collectFootnoteDefinitions(node, definitions) {
+    if (node.type === "footnoteDefinition") {
+        definitions.set(node.label, node);
+        return;
+    }
+    if ("children" in node) {
+        for (const child of node.children) {
+            collectFootnoteDefinitions(child, definitions);
+        }
+    }
+}
+function createFootnoteId(label) {
+    return encodeURIComponent(label);
+}
+function sanitizeUrl(url) {
+    const trimmed = url.trim();
+    if (trimmed.startsWith("//")) {
+        return null;
+    }
+    const scheme = readScheme(trimmed);
+    if (scheme === null) {
+        return trimmed;
+    }
+    switch (scheme.toLowerCase()) {
+        case "http":
+        case "https":
+        case "mailto":
+        case "tel":
+            return trimmed;
+        default:
+            return null;
+    }
+}
+function readScheme(url) {
+    let value = "";
+    for (let index = 0; index < url.length; index += 1) {
+        const char = url[index];
+        if (char === "/" || char === "?" || char === "#") {
+            return null;
+        }
+        if (char === ":") {
+            return value.length === 0 ? null : value;
+        }
+        if (!isSchemeChar(char, index)) {
+            return null;
+        }
+        value += char;
+    }
+    return null;
+}
+function isSchemeChar(char, index) {
+    const code = char.charCodeAt(0);
+    const isAlpha = (code >= 65 && code <= 90) || (code >= 97 && code <= 122);
+    if (index === 0) {
+        return isAlpha;
+    }
+    return isAlpha || (code >= 48 && code <= 57) || char === "+" || char === "-" || char === ".";
+}
+function escapeHtml(value) {
+    let output = "";
+    for (const char of value) {
+        switch (char) {
+            case "&":
+                output += "&amp;";
+                break;
+            case "<":
+                output += "&lt;";
+                break;
+            case ">":
+                output += "&gt;";
+                break;
+            case '"':
+                output += "&quot;";
+                break;
+            default:
+                output += char;
+        }
+    }
+    return output;
+}
+function escapeAttribute(value) {
+    return escapeHtml(value);
+}

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

@@ -1,6 +1,10 @@
+import { type HtmlRenderOptions } from "./html-renderer.js";
 import { type RenderOptions } from "./renderer.js";
 export type { MdNode } from "./ast.js";
+export { renderHtml } from "./html-renderer.js";
+export type { HtmlRenderOptions } from "./html-renderer.js";
 export { parse } from "./parser.js";
 export { render } from "./renderer.js";
 export type { RenderOptions } from "./renderer.js";
 export declare function renderMarkdown(markdown: string, options?: RenderOptions): string;
+export declare function renderMarkdownHtml(markdown: string, options?: HtmlRenderOptions): string;

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

@@ -1,8 +1,14 @@
 import { parse } from "./parser.js";
+import { renderHtml } from "./html-renderer.js";
 import { render } from "./renderer.js";
+export { renderHtml } from "./html-renderer.js";
 export { parse } from "./parser.js";
 export { render } from "./renderer.js";
 export function renderMarkdown(markdown, options) {
     const { ast } = parse(markdown);
     return render(ast, options);
 }
+export function renderMarkdownHtml(markdown, options) {
+    const { ast } = parse(markdown);
+    return renderHtml(ast, options);
+}

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

@@ -0,0 +1 @@
+export { text } from "./components/text.js";

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

@@ -0,0 +1 @@
+export { text } from "./components/text.js";

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

@@ -0,0 +1 @@
+export { typography } from "./tokens/typography.js";

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

@@ -0,0 +1 @@
+export { typography } from "./tokens/typography.js";

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

@@ -0,0 +1 @@
+export { widths } from "./tokens/widths.js";

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

@@ -0,0 +1 @@
+export { widths } from "./tokens/widths.js";

package/node_modules/toolcraft-design/dist/with-output-format.d.ts

@@ -0,0 +1,2 @@
+export { withOutputFormat } from "./internal/output-format.js";
+export type { OutputFormat } from "./internal/output-format.js";

package/node_modules/toolcraft-design/dist/with-output-format.js

@@ -0,0 +1 @@
+export { withOutputFormat } from "./internal/output-format.js";

package/node_modules/toolcraft-design/dist/with-spinner.d.ts

@@ -0,0 +1,2 @@
+export { withSpinner } from "./prompts/index.js";
+export type { WithSpinnerOptions } from "./prompts/index.js";

package/node_modules/toolcraft-design/dist/with-spinner.js

@@ -0,0 +1 @@
+export { withSpinner } from "./prompts/index.js";

package/node_modules/toolcraft-design/package.json

@@ -28,6 +28,10 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "import": "./dist/*.js"
     }
   },
   "engines": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft-openapi",
-  "version": "0.0.74",
+  "version": "0.0.76",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -28,7 +28,7 @@
     "toolcraft-openapi-generate": "dist/bin/generate.js"
   },
   "dependencies": {
-    "toolcraft": "0.0.74",
+    "toolcraft": "0.0.76",
     "auth-store": "^0.0.1",
     "fast-string-width": "^3.0.2",
     "fast-wrap-ansi": "^0.2.0",