@dogsbay/editor 0.0.0-stage → 0.2.0-beta.173

package/dist/bridge.js

@@ -0,0 +1,626 @@
+/** Attrs fragment carrying the node's full props/meta verbatim. */
+function carryAttrs(node) {
+    const carried = {};
+    if (node.props && Object.keys(node.props).length)
+        carried.props = node.props;
+    if (node.meta && Object.keys(node.meta).length)
+        carried.meta = node.meta;
+    return Object.keys(carried).length ? { dogsbayProps: carried } : {};
+}
+/** Restore carried props/meta; modeled fields are merged over these. */
+function carried(pm) {
+    const saved = pm.attrs?.dogsbayProps;
+    if (!saved || typeof saved !== "object")
+        return {};
+    const out = {};
+    if (saved.props)
+        out.props = { ...saved.props };
+    if (saved.meta)
+        out.meta = { ...saved.meta };
+    return out;
+}
+function flagMarks(n) {
+    const marks = [];
+    if (n.bold)
+        marks.push({ type: "bold" });
+    if (n.italic)
+        marks.push({ type: "italic" });
+    if (n.strikethrough)
+        marks.push({ type: "strike" });
+    return marks;
+}
+function marksToFlags(marks) {
+    const types = new Set((marks ?? []).map((m) => m.type));
+    const out = {};
+    if (types.has("bold"))
+        out.bold = true;
+    if (types.has("italic"))
+        out.italic = true;
+    if (types.has("strike"))
+        out.strikethrough = true;
+    return out;
+}
+/* ───────────────────────────────  inline ─────────────────────────────── */
+function inlineToPm(nodes) {
+    if (!nodes)
+        return [];
+    const out = [];
+    for (const n of nodes) {
+        if (n.type === "text") {
+            if (n.text === "")
+                continue; // ProseMirror forbids empty text nodes
+            const marks = [];
+            if (n.bold)
+                marks.push({ type: "bold" });
+            if (n.italic)
+                marks.push({ type: "italic" });
+            if (n.strikethrough)
+                marks.push({ type: "strike" });
+            // change-review view only (diff.ts): word-level ins/del runs of a changed prose node
+            const diffOp = n.diffOp;
+            if (diffOp === "ins")
+                marks.push({ type: "diffIns" });
+            if (diffOp === "del")
+                marks.push({ type: "diffDel" });
+            out.push(marks.length ? { type: "text", text: n.text, marks } : { type: "text", text: n.text });
+            continue;
+        }
+        if (n.type === "code") {
+            if (n.text === "")
+                continue;
+            out.push({ type: "text", text: n.text, marks: [{ type: "code" }] });
+            continue;
+        }
+        if (n.type === "break") {
+            out.push({ type: "hardBreak" });
+            continue;
+        }
+        if (n.type === "link") {
+            // Links with a trailing `{...}` attrs block aren't representable as a
+            // plain link mark — preserve the whole link verbatim instead.
+            if (n.attrs && Object.keys(n.attrs).length) {
+                out.push({ type: "dogsbayInline", attrs: { json: JSON.stringify(n) } });
+                continue;
+            }
+            // PM models links as a mark on text; flatten the children and stamp
+            // the mark on each text span.
+            const linkMark = {
+                type: "link",
+                attrs: { href: n.href, ...(n.title !== undefined ? { title: n.title } : {}) },
+            };
+            const inner = inlineToPm(n.children);
+            if (!inner.length) {
+                // empty link text — preserve verbatim rather than dropping the href
+                out.push({ type: "dogsbayInline", attrs: { json: JSON.stringify(n) } });
+                continue;
+            }
+            for (const child of inner) {
+                if (child.type === "text") {
+                    out.push({ ...child, marks: [...(child.marks ?? []), linkMark] });
+                }
+                else {
+                    out.push(child); // hardBreak / atoms inside a link keep their type
+                }
+            }
+            continue;
+        }
+        const t = n.type;
+        if (t === "variable") {
+            const v = n;
+            const marks = flagMarks(v);
+            out.push({
+                type: "variable",
+                attrs: { expr: v.expr },
+                ...(marks.length ? { marks } : {}),
+            });
+            continue;
+        }
+        if (t === "conditional-span") {
+            const c = n;
+            const marks = flagMarks(c);
+            out.push({
+                type: "conditionalSpan",
+                attrs: { test: c.test },
+                content: inlineToPm(c.children),
+                ...(marks.length ? { marks } : {}),
+            });
+            continue;
+        }
+        if (t === "directive-raw-inline") {
+            const r = n;
+            const marks = flagMarks(r);
+            out.push({
+                type: "directiveRawInline",
+                attrs: { source: r.source },
+                ...(marks.length ? { marks } : {}),
+            });
+            continue;
+        }
+        // Escape hatch: anything else (images, math, footnotes, …) verbatim.
+        out.push({ type: "dogsbayInline", attrs: { json: JSON.stringify(n) } });
+    }
+    return out;
+}
+function textSpanFromPm(n) {
+    const markTypes = new Set((n.marks ?? []).map((m) => m.type));
+    if (markTypes.has("code")) {
+        // Vocabulary limit: InlineCode has no formatting flags (parser parity).
+        return { type: "code", text: n.text ?? "" };
+    }
+    const out = { type: "text", text: n.text ?? "" };
+    if (markTypes.has("bold"))
+        out.bold = true;
+    if (markTypes.has("italic"))
+        out.italic = true;
+    if (markTypes.has("strike"))
+        out.strikethrough = true;
+    return out;
+}
+function pmInlineToTree(content) {
+    const out = [];
+    for (const n of content ?? []) {
+        if (n.type === "variable") {
+            out.push({
+                type: "variable",
+                expr: String(n.attrs?.expr ?? ""),
+                ...marksToFlags(n.marks),
+            });
+            continue;
+        }
+        if (n.type === "conditionalSpan") {
+            out.push({
+                type: "conditional-span",
+                test: String(n.attrs?.test ?? ""),
+                children: pmInlineToTree(n.content),
+                ...marksToFlags(n.marks),
+            });
+            continue;
+        }
+        if (n.type === "directiveRawInline") {
+            out.push({
+                type: "directive-raw-inline",
+                source: String(n.attrs?.source ?? ""),
+                ...marksToFlags(n.marks),
+            });
+            continue;
+        }
+        if (n.type === "dogsbayInline") {
+            out.push(JSON.parse(String(n.attrs?.json ?? "null")));
+            continue;
+        }
+        if (n.type === "hardBreak") {
+            out.push({ type: "break" });
+            continue;
+        }
+        // text node — a link mark wraps the span in an InlineLink; consecutive
+        // spans of the SAME link are grouped back into one link with children.
+        const linkMark = (n.marks ?? []).find((m) => m.type === "link");
+        const span = textSpanFromPm(n);
+        if (linkMark) {
+            const href = String(linkMark.attrs?.href ?? "");
+            const title = linkMark.attrs?.title == null ? undefined : String(linkMark.attrs.title);
+            const prev = out[out.length - 1];
+            if (prev && prev.type === "link" && prev.href === href && prev.title === title) {
+                prev.children.push(span);
+            }
+            else {
+                out.push({ type: "link", href, ...(title !== undefined ? { title } : {}), children: [span] });
+            }
+            continue;
+        }
+        out.push(span);
+    }
+    return out;
+}
+/* ───────────────────────────────  blocks ─────────────────────────────── */
+function listItemToPm(item) {
+    // Parser list items carry their own text in `inline` AND any nested list
+    // in `children` — both must survive. TipTap listItem holds block content,
+    // so the inline text becomes the leading paragraph.
+    const content = [];
+    if (item.inline && item.inline.length) {
+        content.push({ type: "paragraph", content: inlineToPm(item.inline) });
+    }
+    for (const child of item.children ?? [])
+        content.push(blockToPm(child));
+    if (!content.length)
+        content.push({ type: "paragraph", content: [] });
+    const attrs = carryAttrs(item);
+    return { type: "listItem", ...(Object.keys(attrs).length ? { attrs } : {}), content };
+}
+function blockToPm(node) {
+    switch (node.type) {
+        case "heading":
+            return {
+                type: "heading",
+                attrs: { level: Number(node.props?.level ?? 1), ...carryAttrs(node) },
+                content: inlineToPm(node.inline),
+            };
+        case "paragraph": {
+            const attrs = carryAttrs(node);
+            return {
+                type: "paragraph",
+                ...(Object.keys(attrs).length ? { attrs } : {}),
+                content: inlineToPm(node.inline),
+            };
+        }
+        case "blockquote": {
+            const attrs = carryAttrs(node);
+            return {
+                type: "blockquote",
+                ...(Object.keys(attrs).length ? { attrs } : {}),
+                content: (node.children ?? []).map(blockToPm),
+            };
+        }
+        case "hr":
+        case "thematic-break":
+        case "separator": {
+            const attrs = carryAttrs(node);
+            return { type: "horizontalRule", ...(Object.keys(attrs).length ? { attrs } : {}) };
+        }
+        case "unordered-list": {
+            const attrs = carryAttrs(node);
+            return {
+                type: "bulletList",
+                ...(Object.keys(attrs).length ? { attrs } : {}),
+                content: (node.children ?? []).map(listItemToPm),
+            };
+        }
+        case "ordered-list": {
+            const attrs = carryAttrs(node);
+            // The list's first number is the editor's own attribute (TipTap's `start`), so a change made in
+            // the editor comes back; the carried props keep everything else
+            const start = node.props?.start;
+            if (typeof start === "number")
+                attrs.start = start;
+            return {
+                type: "orderedList",
+                ...(Object.keys(attrs).length ? { attrs } : {}),
+                content: (node.children ?? []).map(listItemToPm),
+            };
+        }
+        case "callout":
+            return {
+                type: "callout",
+                attrs: { tone: String(node.props?.type ?? "note"), ...carryAttrs(node) },
+                content: (node.children ?? []).map(blockToPm),
+            };
+        case "table": {
+            const pm = tableToPm(node);
+            // a shape prosemirror-tables cannot hold (ragged rows, rowspan) keeps the verbatim
+            // atom — losing the table would be worse than not editing it in place
+            if (pm)
+                return pm;
+            // in a diff, the atom is ONE node: per-row marks cannot be shown, so a table whose
+            // rows changed is marked changed as a whole rather than rendering unhighlighted
+            const rowDiff = node.meta?.diff ? undefined : firstDescendantDiff(node);
+            const marked = rowDiff ? { ...node, meta: { ...node.meta, diff: rowDiff } } : node;
+            return { type: "dogsbayBlock", attrs: { json: JSON.stringify(marked) } };
+        }
+        case "code":
+            return {
+                type: "codeBlock",
+                attrs: { language: node.props?.language ?? null, ...carryAttrs(node) },
+                content: node.html ? [{ type: "text", text: node.html }] : [],
+            };
+        case "conditional":
+            return {
+                type: "conditional",
+                attrs: { test: String(node.props?.test ?? ""), ...carryAttrs(node) },
+                content: (node.children ?? []).map(blockToPm),
+            };
+        case "include":
+            return {
+                type: "include",
+                attrs: { src: String(node.props?.src ?? ""), ...carryAttrs(node) },
+            };
+        case "var-def":
+            return {
+                type: "varDef",
+                attrs: {
+                    name: String(node.props?.name ?? ""),
+                    value: String(node.props?.value ?? ""),
+                    ...carryAttrs(node),
+                },
+            };
+        case "directive-raw":
+            return {
+                type: "directiveRaw",
+                attrs: {
+                    source: String(node.props?.source ?? ""),
+                    kind: node.props?.kind ?? null,
+                    ...carryAttrs(node),
+                },
+            };
+        default:
+            // Escape hatch: tables and anything unmodeled, preserved verbatim.
+            return { type: "dogsbayBlock", attrs: { json: JSON.stringify(node) } };
+    }
+}
+/* ────────────────────────────── tables ──────────────────────────────── */
+/**
+ * thead/tbody/tfoot wrappers or bare `tr` children — every shape the parser
+ * and the importers produce. The SECTION each row came from is carried on
+ * the row so `pmTableToTree` can put it back: PM has no `tfoot`, and a table
+ * whose footer silently became a body row changes the file on save.
+ */
+/** The first `meta.diff` anywhere below this node (rows/cells of a table that cannot be modeled). */
+function firstDescendantDiff(node) {
+    for (const child of node.children ?? []) {
+        const own = child.meta?.diff;
+        if (own && own !== "unchanged")
+            return "changed";
+        const deeper = firstDescendantDiff(child);
+        if (deeper)
+            return deeper;
+    }
+    return undefined;
+}
+function tableRows(node) {
+    const out = [];
+    for (const child of node.children ?? []) {
+        if (child.type === "thead")
+            for (const r of child.children ?? [])
+                out.push({ row: r, header: true, section: "thead" });
+        else if (child.type === "tbody" || child.type === "tfoot")
+            for (const r of child.children ?? [])
+                out.push({ row: r, header: false, section: child.type });
+        else if (child.type === "tr")
+            out.push({ row: child, header: (child.children ?? []).every((c) => c.type === "th"), section: "" });
+    }
+    return out;
+}
+const cellAttrs = (cell) => {
+    const colspan = Number(cell.props?.colspan ?? 1) || 1;
+    const rowspan = Number(cell.props?.rowspan ?? 1) || 1;
+    const align = typeof cell.props?.align === "string" ? cell.props.align : null;
+    // align/colspan/rowspan are MODELED (the toolbar edits them); the rest rides verbatim
+    const rest = { ...cell.props };
+    delete rest.colspan;
+    delete rest.rowspan;
+    delete rest.align;
+    const carry = carryAttrs({ ...cell, props: rest });
+    return { colspan, rowspan, align, ...carry };
+};
+/**
+ * A TreeNode table → a prosemirror-tables table, or null when the shape is
+ * one PM cannot hold: every row must have the same column count (counting
+ * colspans; rowspans are not tracked, so a table using them stays verbatim).
+ */
+function tableToPm(node) {
+    const rows = tableRows(node);
+    if (rows.length === 0)
+        return null;
+    let width = -1;
+    for (const { row } of rows) {
+        const cells = row.children ?? [];
+        if (cells.length === 0)
+            return null;
+        if (cells.some((c) => Number(c.props?.rowspan ?? 1) > 1))
+            return null;
+        const w = cells.reduce((n, c) => n + (Number(c.props?.colspan ?? 1) || 1), 0);
+        if (width === -1)
+            width = w;
+        else if (w !== width)
+            return null;
+    }
+    return {
+        type: "table",
+        attrs: carryAttrs(node),
+        content: rows.map(({ row, header, section }) => ({
+            type: "tableRow",
+            attrs: carryAttrs(section ? { ...row, meta: { ...row.meta, tableSection: section } } : row),
+            content: (row.children ?? []).map((cell) => ({
+                type: cell.type === "th" || (header && cell.type !== "td") ? "tableHeader" : "tableCell",
+                attrs: cellAttrs(cell),
+                // a cell is inline in the pipe form and blocks in the HTML form; PM holds blocks,
+                // so an inline cell becomes one paragraph and comes back as `inline`
+                // a cell may carry BOTH forms (importer trees do): the inline part leads, then the blocks
+                content: cell.children?.length
+                    ? [
+                        ...(cell.inline?.length ? [{ type: "paragraph", content: inlineToPm(cell.inline) }] : []),
+                        ...cell.children.map(blockToPm),
+                    ]
+                    : [{ type: "paragraph", content: inlineToPm(cell.inline ?? []) }],
+            })),
+        })),
+    };
+}
+function pmTableToTree(pm) {
+    const saved = carried(pm);
+    const rowSection = (row) => {
+        const meta = (carried(row).meta ?? {});
+        if (meta.tableSection)
+            return meta.tableSection;
+        const cells = row.content ?? [];
+        return cells.length > 0 && cells.every((c) => c.type === "tableHeader") ? "thead" : "tbody";
+    };
+    const toRow = (row) => {
+        const c = carried(row);
+        // tableSection is bookkeeping for this bridge, not the document's own meta
+        if (c.meta) {
+            const { tableSection: _drop, ...rest } = c.meta;
+            if (Object.keys(rest).length)
+                c.meta = rest;
+            else
+                delete c.meta;
+        }
+        return { type: "tr", ...c, children: (row.content ?? []).map(pmCellToTree) };
+    };
+    // sections in document order: a header row that is no longer at the top stays where it is,
+    // and a tfoot comes back as a tfoot
+    const children = [];
+    let current = null;
+    let currentType = "";
+    for (const row of pm.content ?? []) {
+        const section = rowSection(row);
+        if (!current || currentType !== section) {
+            current = { type: section, children: [] };
+            currentType = section;
+            children.push(current);
+        }
+        current.children.push(toRow(row));
+    }
+    return { type: "table", ...saved, children };
+}
+function pmCellToTree(cell) {
+    const saved = carried(cell);
+    const props = { ...saved.props };
+    const colspan = Number(cell.attrs?.colspan ?? 1) || 1;
+    const rowspan = Number(cell.attrs?.rowspan ?? 1) || 1;
+    if (colspan > 1)
+        props.colspan = colspan;
+    else
+        delete props.colspan;
+    if (rowspan > 1)
+        props.rowspan = rowspan;
+    else
+        delete props.rowspan;
+    const align = cell.attrs?.align;
+    if (typeof align === "string" && align)
+        props.align = align;
+    else
+        delete props.align;
+    const type = cell.type === "tableHeader" ? "th" : "td";
+    const content = cell.content ?? [];
+    const out = { type, ...saved };
+    if (Object.keys(props).length)
+        out.props = props;
+    else
+        delete out.props;
+    // one plain paragraph → an inline cell (the pipe form); anything else — several blocks, or a
+    // paragraph carrying props the editor does not model — stays blocks (the HTML form)
+    if (content.length === 1 && content[0].type === "paragraph" && !content[0].attrs?.dogsbayProps) {
+        out.inline = pmInlineToTree(content[0].content);
+    }
+    else {
+        out.children = content.map(pmBlockToTree);
+    }
+    return out;
+}
+function pmListItemToTree(li) {
+    const saved = carried(li);
+    const content = li.content ?? [];
+    // Leading paragraph is the item's own text; the rest (nested lists, …)
+    // are children — mirrors the parser's list-item shape.
+    if (content.length === 1 && content[0].type === "paragraph") {
+        return { type: "list-item", inline: pmInlineToTree(content[0].content), ...saved };
+    }
+    if (content.length > 1 && content[0].type === "paragraph") {
+        return {
+            type: "list-item",
+            inline: pmInlineToTree(content[0].content),
+            children: content.slice(1).map(pmBlockToTree),
+            ...saved,
+        };
+    }
+    return { type: "list-item", children: content.map(pmBlockToTree), ...saved };
+}
+function pmBlockToTree(pm) {
+    const saved = carried(pm);
+    switch (pm.type) {
+        case "heading":
+            return {
+                type: "heading",
+                ...saved,
+                props: { ...saved.props, level: Number(pm.attrs?.level ?? 1) },
+                inline: pmInlineToTree(pm.content),
+            };
+        case "paragraph":
+            return { type: "paragraph", ...saved, inline: pmInlineToTree(pm.content) };
+        case "blockquote":
+            return { type: "blockquote", ...saved, children: (pm.content ?? []).map(pmBlockToTree) };
+        case "horizontalRule":
+            return { type: "hr", ...saved };
+        case "bulletList":
+            return { type: "unordered-list", ...saved, children: (pm.content ?? []).map(pmListItemToTree) };
+        case "orderedList": {
+            const start = pm.attrs?.start;
+            const props = { ...saved.props };
+            // the editor's start wins over the carried one; 1 is the default and not written
+            if (typeof start === "number" && start !== 1)
+                props.start = start;
+            else
+                delete props.start;
+            const out = { type: "ordered-list", ...saved, children: (pm.content ?? []).map(pmListItemToTree) };
+            if (Object.keys(props).length)
+                out.props = props;
+            else
+                delete out.props;
+            return out;
+        }
+        case "callout":
+            return {
+                type: "callout",
+                ...saved,
+                props: { ...saved.props, type: String(pm.attrs?.tone ?? "note") },
+                children: (pm.content ?? []).map(pmBlockToTree),
+            };
+        case "table":
+            return pmTableToTree(pm);
+        case "codeBlock": {
+            const props = { ...saved.props };
+            const language = pm.attrs?.language;
+            if (language)
+                props.language = language;
+            else
+                delete props.language;
+            return {
+                type: "code",
+                ...saved,
+                props,
+                html: pm.content?.[0]?.text ?? "",
+            };
+        }
+        case "conditional":
+            return {
+                type: "conditional",
+                ...saved,
+                props: { ...saved.props, test: String(pm.attrs?.test ?? "") },
+                children: (pm.content ?? []).map(pmBlockToTree),
+            };
+        case "include":
+            return {
+                type: "include",
+                ...saved,
+                props: { ...saved.props, src: String(pm.attrs?.src ?? "") },
+            };
+        case "varDef":
+            return {
+                type: "var-def",
+                ...saved,
+                props: {
+                    ...saved.props,
+                    name: String(pm.attrs?.name ?? ""),
+                    value: String(pm.attrs?.value ?? ""),
+                },
+            };
+        case "directiveRaw": {
+            const props = {
+                ...saved.props,
+                source: String(pm.attrs?.source ?? ""),
+            };
+            if (pm.attrs?.kind != null)
+                props.kind = pm.attrs.kind;
+            return { type: "directive-raw", ...saved, props };
+        }
+        case "dogsbayBlock":
+            return JSON.parse(String(pm.attrs?.json ?? "null"));
+        default:
+            // Unreachable for the schema in schema.ts — kept loud so a future
+            // schema addition fails visibly (the editor surfaces this error)
+            // instead of silently corrupting the document.
+            throw new Error(`pmBlockToTree: unhandled node type "${pm.type}"`);
+    }
+}
+/* ─────────────────────────────── document ────────────────────────────── */
+export function treeToPmDoc(tree) {
+    return { type: "doc", content: tree.map(blockToPm) };
+}
+/** Block-level mapping without the doc wrapper — for replacing ONE block with what a snippet parses to. */
+export function treeToPmBlocks(tree) {
+    return tree.map(blockToPm);
+}
+export function pmDocToTree(doc) {
+    return (doc.content ?? []).map(pmBlockToTree);
+}

package/dist/diff.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Change review — the DiffTree rendered as an editor view
+ * (plans/ide-change-review.md; plans/tree-diff-rendering.md names "the IDE's
+ * change review" as one of the views over ONE transform).
+ *
+ * `@dogsbay/tree-diff`'s `diffTrees(old, new)` yields a DiffTree: a TreeNode
+ * union tree carrying `diff` / `diffInline` / `diffPeer` / `diffMovedFrom`
+ * marks. Here it becomes a plain TreeNode tree the existing bridge already
+ * understands — block marks move to `meta.diff` (carried as `dogsbayProps`),
+ * changed prose becomes text runs flagged `diffOp: 'ins'|'del'` (two marks),
+ * a changed code/table-row pair renders peer (removed) then node — and the
+ * `DiffMarks` extension decorates the resulting ProseMirror nodes with
+ * `data-diff="…"`, exactly the vocabulary the comparison site's CSS uses. A
+ * tree with no marks renders identically to `treeToPmDoc`.
+ *
+ * Read-only by contract: the review pane never serializes back.
+ */
+import { Extension, Mark } from "@tiptap/core";
+import type { TreeNode } from "@dogsbay/types";
+import type { DiffNode } from "@dogsbay/tree-diff";
+import { type PMNode } from "./bridge.js";
+export type DiffKind = "added" | "removed" | "changed" | "moved";
+/** meta the review view reads (mirrors tree-diff's marks, in TreeNode.meta so the bridge carries them). */
+export interface DiffMeta {
+    diff?: DiffKind;
+    diffMovedFrom?: string[];
+    /** Set on a rendered peer (the OLD side of a changed code/table-row pair). */
+    diffPeerOf?: DiffKind;
+}
+/** DiffTree → plain TreeNode tree with diff meta (the bridge carries meta verbatim). */
+export declare function diffTreeToTree(nodes: DiffNode[]): TreeNode[];
+export declare function diffTreeToPmDoc(nodes: DiffNode[]): PMNode;
+export declare const DiffIns: Mark<any, any>;
+export declare const DiffDel: Mark<any, any>;
+/** Node decorations from `meta.diff` (data-diff="added|removed|changed|moved"). */
+export declare const DiffMarks: Extension<any, any>;
+/** The read-only review schema: the editing extensions + the two diff marks + the decorator. */
+export declare const diffExtensions: (import("@tiptap/core").Node<any, any> | Mark<any, any> | Extension<any, any> | Extension<import("@tiptap/starter-kit").StarterKitOptions, any>)[];