@turri-dev/cli 0.0.0-stage → 0.1.2-next.48dacfc

package/dist/plain/liquid.js

@@ -0,0 +1,129 @@
+import { Liquid, Tag } from "liquidjs";
+import { InvalidLiquidVariableName } from "./errors.js";
+/** The innermost include namespace, which is what liquid2 calls `context.scope`. */
+const scopeStack = [];
+function currentScope() {
+    return scopeStack[scopeStack.length - 1];
+}
+/**
+ * Leading indentation of the line the tag sits on, and whether that line is a
+ * comment. Ported from Plain2CodeIncludeNode.render_to_output, which walks
+ * backwards from the tag to the start of its line.
+ */
+function scanLine(source, start) {
+    let whitespaces = 0;
+    let i = start;
+    while (i >= 0 && source[i] !== "\n") {
+        if (source[i] === " ") {
+            whitespaces += 1;
+        }
+        else if (source[i] === ">") {
+            return { whitespaces, isComment: true };
+        }
+        else {
+            whitespaces = 0;
+        }
+        i -= 1;
+    }
+    return { whitespaces, isComment: false };
+}
+/** `"tpl.plain", key: "value", other: "value"` */
+function parseIncludeArgs(args) {
+    const nameMatch = /^\s*(["'])(.*?)\1/.exec(args);
+    if (!nameMatch)
+        throw new Error(`Invalid include tag arguments: ${args}`);
+    const namespace = [];
+    const rest = args.slice(nameMatch[0].length);
+    const argPattern = /([A-Za-z_][A-Za-z0-9_]*)\s*:\s*(["'])(.*?)\2/g;
+    let match;
+    while ((match = argPattern.exec(rest)) !== null) {
+        namespace.push([match[1], match[3]]);
+    }
+    return { name: nameMatch[2], namespace };
+}
+export function createEnvironment(options) {
+    const engine = new Liquid({ strictVariables: options.strictVariables ?? false });
+    engine.registerTag("include", class extends Tag {
+        rawArgs;
+        begin;
+        source;
+        constructor(token, remain, liquid) {
+            super(token, remain, liquid);
+            this.rawArgs = token.args;
+            this.begin = token.begin;
+            this.source = token.input;
+        }
+        *render(_ctx, emitter) {
+            const { whitespaces, isComment } = scanLine(this.source, this.begin);
+            const { name, namespace } = parseIncludeArgs(this.rawArgs);
+            if (isComment) {
+                // liquid2 writes the node back through str(node), which normalises quoting.
+                emitter.write(`{% include '${name}' %}`);
+                return;
+            }
+            const templateSource = options.loadTemplateSource(name);
+            if (templateSource === null) {
+                throw new Error(`Template not found: ${name}\n` +
+                    "The required template could not be found. Templates are searched in the following order " +
+                    "(highest to lowest precedence):\n\n" +
+                    "    1. The directory containing your .plain file\n" +
+                    "    2. The directory specified by --template-dir (if provided)\n" +
+                    "    3. The built-in 'standard_template_library' directory\n");
+            }
+            // Plain2CodeLoaderMixin.load: rstrip, then re-indent every line to match the
+            // include site. The rstrip is what stops a block-level include from ending
+            // the surrounding list.
+            const indented = templateSource.replace(/\s+$/, "").split("\n").join("\n" + " ".repeat(whitespaces));
+            const scope = Object.fromEntries(namespace);
+            scopeStack.push(scope);
+            try {
+                emitter.write(engine.parseAndRenderSync(indented, scope));
+            }
+            finally {
+                scopeStack.pop();
+            }
+        }
+    });
+    engine.registerFilter("code_variable", (value) => {
+        const scope = currentScope();
+        if (scope === undefined || Object.keys(scope).length === 0) {
+            throw new Error("Invalid use of code_variable filter!");
+        }
+        if (options.codeVariables === undefined)
+            return value;
+        // liquid2 takes the first item of the current scope, so every code_variable in a
+        // template is attributed to the include's first argument, whatever it renders.
+        const variableName = Object.keys(scope)[0];
+        const uniqueStr = randomHex();
+        options.codeVariables[uniqueStr] = { [variableName]: String(value) };
+        return uniqueStr;
+    });
+    engine.registerFilter("prohibited_chars", (value, prohibitedChars) => {
+        const text = typeof value === "string" ? value : String(value);
+        const scope = currentScope();
+        if (scope === undefined || Object.keys(scope).length === 0) {
+            throw new Error("Invalid use of prohibited_chars filter!");
+        }
+        const variableName = Object.keys(scope)[0];
+        for (const char of prohibitedChars) {
+            if (text.includes(char)) {
+                throw new InvalidLiquidVariableName(`'${char}' is not a valid character for variable '${variableName}' (value: '${text}').`);
+            }
+        }
+        return text;
+    });
+    return engine;
+}
+function randomHex() {
+    return [...crypto.getRandomValues(new Uint8Array(16))]
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("");
+}
+/** Port of plain_file.render_plain_source. */
+export function renderPlainSource(plainSource, loadedTemplates, codeVariables) {
+    const engine = createEnvironment({
+        loadTemplateSource: (name) => loadedTemplates[name] ?? null,
+        codeVariables,
+    });
+    return engine.parseAndRenderSync(plainSource, {});
+}

package/dist/plain/markdown.js

@@ -0,0 +1,208 @@
+import { fromMarkdown } from "mdast-util-from-markdown";
+/**
+ * The markdown layer.
+ *
+ * The Python parser leans on mistletoe for two things: an AST with line numbers,
+ * and a MarkdownRenderer that round-trips a token back to markdown. mdast gives
+ * us the first. The second is `renderToMarkdown` below - a serializer for the
+ * subset of markdown the plain language uses, matching mistletoe's output
+ * (source indentation preserved, links rewritten as `[resource]` spans).
+ */
+export const RESOURCE_MARKER = "[resource]";
+/**
+ * Parse markdown, then pin every inline node back to its original source text.
+ *
+ * mdast decodes inline syntax: `\"` becomes `"`, and an emphasis written with `_`
+ * loses the fact that it was not `*`. mistletoe's MarkdownRenderer round-trips the
+ * source instead, so re-serialising a decoded tree drifts from the Python output.
+ * Recording the raw slice for leaf nodes and the real delimiters for emphasis and
+ * strong keeps the two renderers in agreement.
+ */
+export function parseMarkdown(text) {
+    const root = fromMarkdown(text);
+    pinToSource(root, text);
+    return root;
+}
+const RAW_LEAF_TYPES = new Set(["text", "inlineCode", "html"]);
+function pinToSource(node, source, origin = 1) {
+    const start = node.position?.start.offset;
+    const end = node.position?.end.offset;
+    if (start !== undefined && end !== undefined) {
+        if (RAW_LEAF_TYPES.has(node.type)) {
+            const raw = source.slice(start, end);
+            // A paragraph's continuation lines carry leading whitespace that is not part of
+            // the text. mistletoe drops it when rendering; keeping it here would indent the
+            // line twice, once from the source and once from the enclosing list item.
+            node.value = node.type === "text" ? raw.replace(/\n[ \t]*/g, "\n") : raw;
+            node.raw = true;
+        }
+        else if (node.type === "emphasis" || node.type === "strong") {
+            const width = node.type === "strong" ? 2 : 1;
+            node.openDelimiter = source.slice(start, start + width);
+            node.closeDelimiter = source.slice(end - width, end);
+        }
+    }
+    let childOrigin = origin;
+    if (node.type === "listItem") {
+        // mistletoe strips the enclosing item's indentation before parsing nested blocks,
+        // so `indentation` and `prepend` are measured against that stripped origin - not
+        // against the item's own column. Continuation lines are later indented by
+        // `prepend`, which is why a nested list keeps more indentation than the gap
+        // between the two columns in the source.
+        const itemColumn = column(node);
+        const first = childrenOf(node)[0];
+        const contentColumn = first ? column(first) : itemColumn + 2;
+        node.indentation = itemColumn - origin;
+        node.prepend = contentColumn - origin;
+        node.leader =
+            start !== undefined && first
+                ? source.slice(start, start + (contentColumn - itemColumn)).trimEnd()
+                : "-";
+        childOrigin = contentColumn;
+    }
+    for (const child of childrenOf(node))
+        pinToSource(child, source, childOrigin);
+}
+export function lineNumber(node) {
+    return node.position?.start.line ?? 0;
+}
+function column(node) {
+    return node.position?.start.column ?? 1;
+}
+function isParent(node) {
+    return Array.isArray(node.children);
+}
+function childrenOf(node) {
+    return node.children ?? [];
+}
+/** Port of plain_file.remove_quotes: block quotes are comments and are dropped. */
+export function removeQuotes(node) {
+    if (!isParent(node))
+        return;
+    const kept = [];
+    for (const child of node.children) {
+        if (child.type === "blockquote")
+            continue;
+        removeQuotes(child);
+        kept.push(child);
+    }
+    node.children = kept;
+}
+/** Port of plain_file.get_raw_text. */
+export function getRawText(node) {
+    if (node.type === "text")
+        return node.value;
+    if (isParent(node)) {
+        return childrenOf(node).map(getRawText).join("");
+    }
+    const value = node.value;
+    if (value !== undefined)
+        return value;
+    throw new Error(`Unknown token type: ${node.type}`);
+}
+/** Port of mistletoe.utils.traverse restricted to a node type. */
+export function traverse(node, type) {
+    const found = [];
+    const walk = (n) => {
+        if (n.type === type)
+            found.push(n);
+        if (isParent(n))
+            for (const child of n.children)
+                walk(child);
+    };
+    walk(node);
+    return found;
+}
+function renderInline(node) {
+    switch (node.type) {
+        case "text":
+            return node.value;
+        case "inlineCode":
+            // The raw slice already carries its own backticks.
+            return node.raw ? node.value : `\`${node.value}\``;
+        case "emphasis":
+            return `${node.openDelimiter ?? "*"}${renderInlineChildren(node)}${node.closeDelimiter ?? "*"}`;
+        case "strong":
+            return `${node.openDelimiter ?? "**"}${renderInlineChildren(node)}${node.closeDelimiter ?? "**"}`;
+        // PlainRenderer.render_link: a link becomes a literal `[resource]<text>` span.
+        case "link":
+            return `\`${RESOURCE_MARKER}${renderInlineChildren(node)}\``;
+        case "image":
+            return `![${renderInlineChildren(node)}](${node.url})`;
+        case "break":
+            return "\n";
+        case "html":
+            return node.value;
+        default:
+            return isParent(node) ? renderInlineChildren(node) : (node.value ?? "");
+    }
+}
+function renderInlineChildren(node) {
+    return childrenOf(node).map(renderInline).join("");
+}
+/** Blank lines between two sibling blocks, as they appeared in the source. */
+function blankLinesBetween(previous, next) {
+    const previousEnd = previous.position?.end.line;
+    const nextStart = next.position?.start.line;
+    if (previousEnd === undefined || nextStart === undefined)
+        return 0;
+    return Math.max(0, nextStart - previousEnd - 1);
+}
+/** Port of MarkdownRenderer.prefix_lines. */
+function prefixLines(lines, firstPrefix, followingPrefix) {
+    return lines.map((line, index) => {
+        const prefixed = (index === 0 ? firstPrefix : followingPrefix) + line;
+        return prefixed.trim() === "" ? "" : prefixed;
+    });
+}
+/**
+ * Port of MarkdownRenderer.blocks_to_lines. Blocks are concatenated with no separator;
+ * blank lines are their own tokens in mistletoe, and are recovered here from the gaps
+ * between sibling positions.
+ */
+function blocksToLines(nodes) {
+    const lines = [];
+    nodes.forEach((node, index) => {
+        if (index > 0 && blankLinesBetween(nodes[index - 1], node) > 0)
+            lines.push("");
+        lines.push(...renderBlockLines(node));
+    });
+    return lines;
+}
+/** Port of MarkdownRenderer.render_list_item. */
+function renderListItemLines(item) {
+    const prepend = item.prepend ?? 2;
+    const indentation = item.indentation ?? 0;
+    const leader = item.leader ?? "-";
+    const lines = blocksToLines(childrenOf(item));
+    const firstPrefix = " ".repeat(Math.max(0, indentation)) +
+        leader +
+        " ".repeat(Math.max(0, prepend - leader.length - indentation));
+    return prefixLines(lines.length > 0 ? lines : [""], firstPrefix, " ".repeat(Math.max(0, prepend)));
+}
+function renderBlockLines(node) {
+    switch (node.type) {
+        case "paragraph":
+            return renderInlineChildren(node).split("\n");
+        case "heading":
+            return [`${"#".repeat(node.depth)} ${renderInlineChildren(node)}`];
+        case "code":
+            return [`\`\`\`${node.lang ?? ""}`, ...(node.value ?? "").split("\n"), "\`\`\`"];
+        case "thematicBreak":
+            return ["---"];
+        case "blockquote":
+            return blocksToLines(childrenOf(node)).map((line) => (line ? `> ${line}` : ">"));
+        case "list":
+            return blocksToLines(childrenOf(node));
+        case "listItem":
+            return renderListItemLines(node);
+        default:
+            return node.children !== undefined
+                ? blocksToLines(childrenOf(node))
+                : (node.value ?? "").split("\n");
+    }
+}
+/** Port of PlainRenderer.render. */
+export function renderToMarkdown(node) {
+    return renderBlockLines(node).join("\n");
+}