vestrycms 0.0.0-stage → 0.1.0

package/dist/mdx/expressions.js

@@ -0,0 +1,141 @@
+import { isRawExpression } from "./types.js";
+/**
+ * Convert a parsed JSX attribute expression to a plain JSON value when it is
+ * made only of literals; otherwise return a RawExpression holding the source.
+ */
+export function estreeToValue(node, source) {
+    if (!node)
+        return { $raw: source };
+    try {
+        return literal(node);
+    }
+    catch {
+        return { $raw: source };
+    }
+}
+class NotLiteral extends Error {
+}
+function literal(node) {
+    switch (node.type) {
+        case "Program": {
+            const body = node.body;
+            if (body.length !== 1 || body[0].type !== "ExpressionStatement")
+                throw new NotLiteral();
+            return literal(body[0].expression);
+        }
+        case "ExpressionStatement":
+            return literal(node.expression);
+        case "Literal": {
+            const v = node.value;
+            if (v instanceof RegExp)
+                throw new NotLiteral();
+            return v ?? null;
+        }
+        case "TemplateLiteral": {
+            const t = node;
+            if (t.expressions.length)
+                throw new NotLiteral();
+            return t.quasis.map((q) => q.value.cooked ?? q.value.raw).join("");
+        }
+        case "UnaryExpression": {
+            const u = node;
+            const arg = literal(u.argument);
+            if (u.operator === "-" && typeof arg === "number")
+                return -arg;
+            if (u.operator === "+" && typeof arg === "number")
+                return arg;
+            if (u.operator === "!")
+                return !arg;
+            throw new NotLiteral();
+        }
+        case "Identifier": {
+            const name = node.name;
+            if (name === "undefined")
+                return undefined;
+            throw new NotLiteral();
+        }
+        case "ArrayExpression":
+            return node.elements.map((el) => {
+                if (!el || el.type === "SpreadElement")
+                    throw new NotLiteral();
+                return literal(el);
+            });
+        case "ObjectExpression": {
+            const out = {};
+            for (const p of node.properties) {
+                if (p.type !== "Property" ||
+                    p.kind !== "init" ||
+                    p.method ||
+                    p.computed)
+                    throw new NotLiteral();
+                let key;
+                if (p.key.type === "Identifier")
+                    key = p.key.name;
+                else if (p.key.type === "Literal")
+                    key = String(p.key.value);
+                else
+                    throw new NotLiteral();
+                out[key] = literal(p.value);
+            }
+            return out;
+        }
+        default:
+            throw new NotLiteral();
+    }
+}
+const IDENT = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+const PRINT_WIDTH = 80;
+/**
+ * Serialize a JSON value (or RawExpression) to JS source for a JSX attribute,
+ * in the shape Prettier produces: multi-line objects and arrays with trailing
+ * commas, bare identifier keys, double-quoted strings.
+ */
+export function valueToSource(value, indent = "") {
+    const inner = `${indent}  `;
+    if (isRawExpression(value))
+        return value.$raw.trim();
+    if (value === undefined)
+        return "undefined";
+    if (value === null)
+        return "null";
+    if (typeof value === "string")
+        return JSON.stringify(value);
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    if (value instanceof Date)
+        return JSON.stringify(value.toISOString());
+    if (Array.isArray(value)) {
+        if (!value.length)
+            return "[]";
+        const simple = value.every((v) => isScalar(v));
+        const items = value.map((v) => valueToSource(v, inner));
+        if (simple) {
+            const oneLine = `[${items.join(", ")}]`;
+            if (oneLine.length + indent.length <= PRINT_WIDTH - 8)
+                return oneLine;
+        }
+        return `[\n${items.map((i) => `${inner}${i},`).join("\n")}\n${indent}]`;
+    }
+    if (typeof value === "object") {
+        const entries = Object.entries(value).filter(([, v]) => v !== undefined);
+        if (!entries.length)
+            return "{}";
+        const keyOf = (k) => (IDENT.test(k) ? k : JSON.stringify(k));
+        // Like Prettier: a flat object that fits on one line stays on one line.
+        if (entries.every(([, v]) => isScalar(v))) {
+            const oneLine = `{ ${entries.map(([k, v]) => `${keyOf(k)}: ${valueToSource(v)}`).join(", ")} }`;
+            if (oneLine.length + indent.length <= PRINT_WIDTH - 2)
+                return oneLine;
+        }
+        const lines = entries.map(([k, v]) => `${inner}${keyOf(k)}: ${valueToSource(v, inner)},`);
+        return `{\n${lines.join("\n")}\n${indent}}`;
+    }
+    return JSON.stringify(value) ?? "null";
+}
+function isScalar(v) {
+    return v === null || ["string", "number", "boolean"].includes(typeof v);
+}
+/** Whether a value can be written as a plain string attribute (`a="b"`) rather than an expression. */
+export function isPlainString(value) {
+    return typeof value === "string" && !value.includes("\n");
+}

package/dist/mdx/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export { parseMdx } from "./parse.js";
+export { serializeMdx } from "./serialize.js";
+export { estreeToValue, valueToSource } from "./expressions.js";

package/dist/mdx/index.js

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export { parseMdx } from "./parse.js";
+export { serializeMdx } from "./serialize.js";
+export { estreeToValue, valueToSource } from "./expressions.js";

package/dist/mdx/parse.d.ts

@@ -0,0 +1,6 @@
+import type { ParsedDocument } from "./types.js";
+export interface ParseOptions {
+    /** `md` disables JSX/ESM parsing (raw HTML is preserved as html nodes). */
+    format?: "md" | "mdx";
+}
+export declare function parseMdx(source: string, options?: ParseOptions): ParsedDocument;

package/dist/mdx/parse.js

@@ -0,0 +1,378 @@
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { gfmFromMarkdown } from "mdast-util-gfm";
+import { mdxFromMarkdown } from "mdast-util-mdx";
+import { gfm } from "micromark-extension-gfm";
+import { mdxjs } from "micromark-extension-mdxjs";
+import { estreeToValue } from "./expressions.js";
+const SUPERSCRIPT_TAGS = new Set(["sup"]);
+const SUBSCRIPT_TAGS = new Set(["sub"]);
+export function parseMdx(source, options = {}) {
+    const isMdx = options.format !== "md";
+    const tree = fromMarkdown(source, {
+        extensions: isMdx ? [mdxjs(), gfm()] : [gfm()],
+        mdastExtensions: isMdx
+            ? [mdxFromMarkdown(), gfmFromMarkdown()]
+            : [gfmFromMarkdown()],
+    });
+    const ctx = { imports: {}, definitions: new Map() };
+    collectDefinitions(tree, ctx);
+    const content = blocks(tree.children, ctx);
+    return {
+        doc: {
+            type: "doc",
+            content: content.length ? content : [{ type: "paragraph" }],
+        },
+        imports: ctx.imports,
+    };
+}
+function collectDefinitions(tree, ctx) {
+    const visit = (node) => {
+        if (node.type === "definition") {
+            const d = node;
+            ctx.definitions.set(d.identifier.toLowerCase(), d);
+        }
+        const children = node.children;
+        if (children)
+            children.forEach(visit);
+    };
+    visit(tree);
+}
+function blocks(nodes, ctx) {
+    const out = [];
+    for (const node of nodes) {
+        const converted = block(node, ctx);
+        if (converted)
+            out.push(...(Array.isArray(converted) ? converted : [converted]));
+    }
+    return out;
+}
+function block(node, ctx) {
+    switch (node.type) {
+        case "paragraph":
+            return {
+                type: "paragraph",
+                content: inlines(node.children, ctx),
+            };
+        case "heading":
+            return {
+                type: "heading",
+                attrs: { level: node.depth },
+                content: inlines(node.children, ctx),
+            };
+        case "thematicBreak":
+            return { type: "horizontalRule" };
+        case "blockquote":
+            return {
+                type: "blockquote",
+                content: ensureBlocks(blocks(node.children, ctx)),
+            };
+        case "list": {
+            const items = node.children.map((item) => listItem(item, ctx));
+            return node.ordered
+                ? {
+                    type: "orderedList",
+                    attrs: { start: node.start ?? 1 },
+                    content: items,
+                }
+                : { type: "bulletList", content: items };
+        }
+        case "code":
+            return {
+                type: "codeBlock",
+                attrs: { language: node.lang ?? null, meta: node.meta ?? null },
+                content: node.value ? [{ type: "text", text: node.value }] : [],
+            };
+        case "html":
+            return { type: "rawHtml", attrs: { value: node.value } };
+        case "table":
+            return table(node, ctx);
+        case "definition":
+        case "footnoteDefinition":
+            return null;
+        case "mdxJsxFlowElement":
+            return jsxElement(node, ctx, false);
+        case "mdxFlowExpression":
+            return { type: "mdxExpression", attrs: { value: node.value } };
+        case "mdxjsEsm":
+            return esm(node, ctx);
+        case "yaml":
+            return null;
+        default: {
+            // Inline content at block level (shouldn't happen) – wrap in a paragraph.
+            const inline = inlineNode(node, ctx, []);
+            return inline.length ? { type: "paragraph", content: inline } : null;
+        }
+    }
+}
+function ensureBlocks(content) {
+    return content.length ? content : [{ type: "paragraph" }];
+}
+function listItem(item, ctx) {
+    const content = ensureBlocks(blocks(item.children, ctx));
+    return {
+        type: "listItem",
+        attrs: item.checked === null || item.checked === undefined
+            ? {}
+            : { checked: item.checked },
+        content,
+    };
+}
+function table(node, ctx) {
+    const rows = node.children.map((row, rowIdx) => ({
+        type: "tableRow",
+        content: row.children.map((cell, colIdx) => ({
+            type: rowIdx === 0 ? "tableHeader" : "tableCell",
+            attrs: { align: node.align?.[colIdx] ?? null },
+            content: [
+                {
+                    type: "paragraph",
+                    content: inlines(cell.children, ctx),
+                },
+            ],
+        })),
+    }));
+    return { type: "table", content: rows };
+}
+function esm(node, ctx) {
+    const program = node.data?.estree;
+    const leftovers = [];
+    if (program) {
+        for (const stmt of program.body) {
+            if (stmt.type === "ImportDeclaration" &&
+                typeof stmt.source.value === "string") {
+                let recognized = true;
+                for (const spec of stmt.specifiers) {
+                    if (spec.type === "ImportDefaultSpecifier") {
+                        ctx.imports[spec.local.name] = {
+                            name: spec.local.name,
+                            from: stmt.source.value,
+                        };
+                    }
+                    else if (spec.type === "ImportSpecifier") {
+                        const imported = spec.imported.type === "Identifier"
+                            ? spec.imported.name
+                            : String(spec.imported.value);
+                        ctx.imports[spec.local.name] = {
+                            name: spec.local.name,
+                            from: stmt.source.value,
+                            named: imported === spec.local.name ? true : undefined,
+                        };
+                        if (imported !== spec.local.name)
+                            recognized = false;
+                    }
+                    else {
+                        recognized = false;
+                    }
+                }
+                if (recognized && stmt.specifiers.length)
+                    continue;
+            }
+            const start = stmt.start;
+            const end = stmt.end;
+            leftovers.push(typeof start === "number" && typeof end === "number"
+                ? node.value.slice(start, end)
+                : node.value);
+        }
+    }
+    else {
+        leftovers.push(node.value);
+    }
+    if (!leftovers.length)
+        return null;
+    return { type: "mdxEsm", attrs: { value: leftovers.join("\n") } };
+}
+function attrsToProps(attributes) {
+    const props = {};
+    const spreads = [];
+    for (const attr of attributes) {
+        if (attr.type === "mdxJsxExpressionAttribute") {
+            spreads.push(attr.value);
+            continue;
+        }
+        if (attr.value === null || attr.value === undefined) {
+            props[attr.name] = true;
+        }
+        else if (typeof attr.value === "string") {
+            props[attr.name] = attr.value;
+        }
+        else {
+            const estree = attr.value.data?.estree;
+            props[attr.name] = estreeToValue(estree, attr.value.value);
+        }
+    }
+    return { props, spreads };
+}
+function jsxElement(node, ctx, inline) {
+    const name = node.name ?? "";
+    const { props, spreads } = attrsToProps(node.attributes);
+    const children = node.children;
+    if (inline) {
+        if (SUPERSCRIPT_TAGS.has(name) || SUBSCRIPT_TAGS.has(name)) {
+            const mark = {
+                type: SUPERSCRIPT_TAGS.has(name) ? "superscript" : "subscript",
+            };
+            return inlines(children, ctx, [mark]);
+        }
+        return {
+            type: "mdxInlineComponent",
+            attrs: { name, props, spreads, hasChildren: children.length > 0 },
+            content: inlines(children, ctx),
+        };
+    }
+    // Block element. Children may be flow content or phrasing content (MDX
+    // allows `<Foo>text</Foo>`); normalise to blocks.
+    const hasFlowChildren = children.some((c) => !isPhrasing(c));
+    const content = hasFlowChildren
+        ? blocks(children, ctx)
+        : children.length
+            ? [{ type: "paragraph", content: inlines(children, ctx) }]
+            : [];
+    return {
+        type: "mdxComponent",
+        attrs: { name, props, spreads, hasChildren: content.length > 0 },
+        content,
+    };
+}
+const PHRASING = new Set([
+    "text",
+    "emphasis",
+    "strong",
+    "delete",
+    "inlineCode",
+    "link",
+    "linkReference",
+    "image",
+    "imageReference",
+    "break",
+    "html",
+    "footnoteReference",
+    "mdxJsxTextElement",
+    "mdxTextExpression",
+]);
+function isPhrasing(node) {
+    return PHRASING.has(node.type);
+}
+function inlines(nodes, ctx, marks = []) {
+    const out = [];
+    for (const node of nodes)
+        out.push(...inlineNode(node, ctx, marks));
+    return mergeText(out);
+}
+function withMarks(node, marks) {
+    return marks.length
+        ? { ...node, marks: [...(node.marks ?? []), ...marks] }
+        : node;
+}
+function inlineNode(node, ctx, marks) {
+    switch (node.type) {
+        case "text":
+            return node.value
+                ? [withMarks({ type: "text", text: node.value }, marks)]
+                : [];
+        case "emphasis":
+            return inlines(node.children, ctx, [
+                ...marks,
+                { type: "italic" },
+            ]);
+        case "strong":
+            return inlines(node.children, ctx, [
+                ...marks,
+                { type: "bold" },
+            ]);
+        case "delete":
+            return inlines(node.children, ctx, [
+                ...marks,
+                { type: "strike" },
+            ]);
+        case "inlineCode":
+            return [
+                withMarks({ type: "text", text: node.value }, [
+                    ...marks,
+                    { type: "code" },
+                ]),
+            ];
+        case "link":
+            return inlines(node.children, ctx, [
+                ...marks,
+                { type: "link", attrs: { href: node.url, title: node.title ?? null } },
+            ]);
+        case "linkReference": {
+            const def = ctx.definitions.get(node.identifier.toLowerCase());
+            if (!def)
+                return inlines(node.children, ctx, marks);
+            return inlines(node.children, ctx, [
+                ...marks,
+                { type: "link", attrs: { href: def.url, title: def.title ?? null } },
+            ]);
+        }
+        case "image":
+            return [
+                withMarks({
+                    type: "image",
+                    attrs: {
+                        src: node.url,
+                        alt: node.alt ?? null,
+                        title: node.title ?? null,
+                    },
+                }, marks),
+            ];
+        case "imageReference": {
+            const def = ctx.definitions.get(node.identifier.toLowerCase());
+            return def
+                ? [
+                    withMarks({
+                        type: "image",
+                        attrs: {
+                            src: def.url,
+                            alt: node.alt ?? null,
+                            title: def.title ?? null,
+                        },
+                    }, marks),
+                ]
+                : [];
+        }
+        case "break":
+            return [{ type: "hardBreak" }];
+        case "html":
+            return [{ type: "rawInlineHtml", attrs: { value: node.value } }];
+        case "footnoteReference":
+            return [
+                withMarks({ type: "text", text: `[^${node.identifier}]` }, marks),
+            ];
+        case "mdxJsxTextElement": {
+            const converted = jsxElement(node, ctx, true);
+            const arr = Array.isArray(converted) ? converted : [converted];
+            return arr.map((n) => (n.type === "text" ? withMarks(n, marks) : n));
+        }
+        case "mdxTextExpression":
+            return [{ type: "mdxInlineExpression", attrs: { value: node.value } }];
+        case "mdxJsxFlowElement": {
+            const converted = jsxElement(node, ctx, true);
+            return Array.isArray(converted) ? converted : [converted];
+        }
+        default: {
+            // Block content inside inline context: flatten to text.
+            const children = node.children;
+            return children ? inlines(children, ctx, marks) : [];
+        }
+    }
+}
+function mergeText(nodes) {
+    const out = [];
+    for (const n of nodes) {
+        const prev = out[out.length - 1];
+        if (prev &&
+            prev.type === "text" &&
+            n.type === "text" &&
+            sameMarks(prev.marks, n.marks)) {
+            prev.text = (prev.text ?? "") + (n.text ?? "");
+        }
+        else {
+            out.push({ ...n });
+        }
+    }
+    return out;
+}
+function sameMarks(a, b) {
+    return JSON.stringify(a ?? []) === JSON.stringify(b ?? []);
+}

package/dist/mdx/serialize.d.ts

@@ -0,0 +1,9 @@
+import type { ComponentRegistry, ImportSpec, PMNode } from "./types.js";
+export interface SerializeOptions {
+    format?: "md" | "mdx";
+    /** Known components; used to emit imports for the ones the document uses. */
+    components?: ComponentRegistry;
+    /** Imports that were present in the source (used for components not in the registry). */
+    existingImports?: Record<string, ImportSpec>;
+}
+export declare function serializeMdx(doc: PMNode, options?: SerializeOptions): string;