smartrte-core 0.2.1 → 1.0.0-beta.2

package/dist/foundation/modelDom.d.ts

@@ -0,0 +1,38 @@
+import type { ModelDomMapping, SmartDocument, SmartElementNode, SmartNode, SmartPos } from "./types.js";
+export declare const SMART_UI_ATTRIBUTE = "data-smart-ui";
+export declare const SMART_PROJECTION_ATTRIBUTE = "data-smart-projection";
+export declare const SMART_NODE_ID_ATTRIBUTE = "data-smart-id";
+export declare const SMART_EMPTY_LINE_ATTRIBUTE = "data-smart-empty-line";
+/**
+ * Correctness renderer for the mapping contract. The production strategy is
+ * contentEditable plus subtree diffing. Benchmark content-visibility before
+ * considering windowing; destructive editable-region virtualization is out of
+ * scope unless measurements prove it unavoidable.
+ */
+export declare const renderDocumentNaively: (root: HTMLElement, document: SmartDocument) => FoundationModelDomMapping;
+export declare class FoundationModelDomMapping implements ModelDomMapping {
+    private root;
+    private document;
+    private readonly byId;
+    private readonly byDom;
+    private readonly pathById;
+    rebuild(root: HTMLElement, document: SmartDocument): void;
+    /** Incremental renderer hook. Paths passed here are already current. */
+    beginUpdate(document: SmartDocument): void;
+    track(node: SmartElementNode, path: readonly number[], element: HTMLElement): void;
+    forget(nodeId: string): void;
+    nodeToDom(nodeId: string): HTMLElement | null;
+    domToNode(input: Node): {
+        nodeId: string;
+        node: SmartNode;
+    } | null;
+    private modelDomChildren;
+    private isInlineOwner;
+    private textDescendant;
+    posToDom(pos: SmartPos): {
+        node: Node;
+        offset: number;
+    } | null;
+    domToPos(node: Node, offset: number): SmartPos | null;
+    isEditorUiNode(node: Node): boolean;
+}

package/dist/foundation/modelDom.js

@@ -0,0 +1,327 @@
+import { isTextNode } from "./identity.js";
+import { nodeAtPath } from "./positions.js";
+import { renderMarkedText } from "./marks/dom.js";
+import { sanitizeAtomSource } from "./atom/security.js";
+const atomTypes = new Set(["image", "block_image", "formula", "block_formula", "video", "audio", "divider"]);
+export const SMART_UI_ATTRIBUTE = "data-smart-ui";
+export const SMART_PROJECTION_ATTRIBUTE = "data-smart-projection";
+export const SMART_NODE_ID_ATTRIBUTE = "data-smart-id";
+export const SMART_EMPTY_LINE_ATTRIBUTE = "data-smart-empty-line";
+const tagForNode = (node) => {
+    if (node.type === "paragraph")
+        return "p";
+    if (node.type === "heading")
+        return `h${String(node.attrs?.level || 1)}`;
+    if (node.type === "blockquote")
+        return "blockquote";
+    if (node.type === "code_block")
+        return "pre";
+    if (node.type === "list") {
+        const marker = String(node.attrs?.style || node.attrs?.preset || "");
+        return /^(?:decimal|lower-|upper-|ordered)/.test(marker) || node.attrs?.start !== undefined ? "ol" : "ul";
+    }
+    if (node.type === "list_item")
+        return "li";
+    if (node.type === "hard_break")
+        return "br";
+    if (node.type === "table")
+        return "table";
+    if (node.type === "table_row")
+        return "tr";
+    if (node.type === "table_cell")
+        return node.attrs?.header === true ? "th" : "td";
+    if (node.type === "image" || node.type === "block_image")
+        return "img";
+    if (node.type === "formula")
+        return "span";
+    if (node.type === "block_formula")
+        return "div";
+    if (node.type === "video" || node.type === "audio")
+        return node.type;
+    return "div";
+};
+const renderNode = (node, ownerDocument) => {
+    if (isTextNode(node))
+        return renderMarkedText(node, ownerDocument);
+    const element = ownerDocument.createElement(tagForNode(node));
+    element.setAttribute(SMART_NODE_ID_ATTRIBUTE, node.id);
+    element.setAttribute("data-smart-type", node.type);
+    if (node.attrs?.align)
+        element.style.textAlign = String(node.attrs.align);
+    if (node.attrs?.indentLevel)
+        element.style.marginInlineStart = `${Number(node.attrs.indentLevel) * 2}em`;
+    if (node.type === "code_block") {
+        const language = typeof node.attrs?.language === "string" && node.attrs.language.trim()
+            ? node.attrs.language.trim()
+            : null;
+        if (language)
+            element.setAttribute("data-smart-language", language);
+        element.setAttribute("aria-label", language ? `Code block, ${language}` : "Code block");
+    }
+    if (node.type === "list") {
+        if (typeof node.attrs?.preset === "string")
+            element.setAttribute("data-smart-list-preset", node.attrs.preset);
+        if (typeof node.attrs?.style === "string") {
+            element.setAttribute("data-smart-list-style", node.attrs.style);
+            element.style.listStyleType = node.attrs.style;
+        }
+        if (node.attrs?.start !== undefined)
+            element.setAttribute("start", String(node.attrs.start));
+        element.setAttribute("data-smart-checkable", node.attrs?.checkable === true ? "true" : "false");
+    }
+    if (node.type === "table_cell") {
+        const rowspan = Math.max(1, Number(node.attrs?.rowspan) || 1);
+        const colspan = Math.max(1, Number(node.attrs?.colspan) || 1);
+        if (rowspan > 1)
+            element.setAttribute("rowspan", String(rowspan));
+        if (colspan > 1)
+            element.setAttribute("colspan", String(colspan));
+        if (node.attrs?.background)
+            element.style.background = String(node.attrs.background);
+        if (node.attrs?.borders)
+            element.style.border = String(node.attrs.borders);
+        ["Top", "Right", "Bottom", "Left"].forEach((side) => {
+            const value = node.attrs?.[`border${side}`];
+            if (value)
+                element.style.setProperty(`border-${side.toLowerCase()}`, String(value));
+        });
+        if (node.attrs?.verticalAlign)
+            element.style.verticalAlign = String(node.attrs.verticalAlign);
+    }
+    if (node.type === "image" || node.type === "block_image") {
+        const source = sanitizeAtomSource(String(node.attrs?.src || ""), { kind: "image", allowBlobPreview: node.attrs?.status === "pending" });
+        if (source)
+            element.setAttribute("src", source);
+        element.setAttribute("alt", typeof node.attrs?.alt === "string" ? node.attrs.alt : "");
+    }
+    if (node.type === "formula" || node.type === "block_formula") {
+        const source = String(node.attrs?.source || "");
+        element.setAttribute("role", "math");
+        element.setAttribute("aria-label", `Mathematical formula: ${source}`);
+        element.setAttribute("data-smart-formula", source);
+        element.textContent = source;
+    }
+    if (node.type === "video" || node.type === "audio") {
+        const source = sanitizeAtomSource(String(node.attrs?.src || ""), { kind: node.type });
+        if (source)
+            element.setAttribute("src", source);
+        element.setAttribute("controls", "");
+        element.setAttribute("aria-label", node.type === "video" ? "Video player" : "Audio player");
+    }
+    if (node.type === "hard_break") {
+        element.setAttribute("data-smart-atomic", "true");
+        return element;
+    }
+    if (node.type === "unknown") {
+        element.contentEditable = "false";
+        element.setAttribute("data-smart-atomic", "true");
+        element.textContent = `[Unsupported: ${String(node.attrs?.originalType || "unknown")}]`;
+        return element;
+    }
+    if (atomTypes.has(node.type)) {
+        element.contentEditable = "false";
+        element.setAttribute("data-smart-atomic", "true");
+        return element;
+    }
+    node.children?.forEach((child) => element.appendChild(renderNode(child, ownerDocument)));
+    return element;
+};
+/**
+ * Correctness renderer for the mapping contract. The production strategy is
+ * contentEditable plus subtree diffing. Benchmark content-visibility before
+ * considering windowing; destructive editable-region virtualization is out of
+ * scope unless measurements prove it unavoidable.
+ */
+export const renderDocumentNaively = (root, document) => {
+    while (root.firstChild)
+        root.removeChild(root.firstChild);
+    document.children.forEach((node) => root.appendChild(renderNode(node, root.ownerDocument)));
+    const mapping = new FoundationModelDomMapping();
+    mapping.rebuild(root, document);
+    return mapping;
+};
+export class FoundationModelDomMapping {
+    constructor() {
+        this.root = null;
+        this.document = null;
+        this.byId = new Map();
+        this.byDom = new WeakMap();
+        this.pathById = new Map();
+    }
+    rebuild(root, document) {
+        this.root = root;
+        this.document = document;
+        this.byId.clear();
+        this.pathById.clear();
+        this.byId.set(document.id, root);
+        this.byDom.set(root, document);
+        this.pathById.set(document.id, []);
+        const elements = new Map();
+        root.querySelectorAll(`[${SMART_NODE_ID_ATTRIBUTE}]`).forEach((element) => {
+            const id = element.getAttribute(SMART_NODE_ID_ATTRIBUTE);
+            if (id)
+                elements.set(id, element);
+        });
+        const visit = (node, path) => {
+            if (isTextNode(node))
+                return;
+            const element = path.length ? elements.get(node.id) || null : root;
+            if (element) {
+                this.byId.set(node.id, element);
+                this.byDom.set(element, node);
+                this.pathById.set(node.id, path);
+            }
+            node.children?.forEach((child, index) => visit(child, [...path, index]));
+        };
+        visit(document, []);
+    }
+    /** Incremental renderer hook. Paths passed here are already current. */
+    beginUpdate(document) {
+        this.document = document;
+        if (this.root)
+            this.byDom.set(this.root, document);
+    }
+    track(node, path, element) {
+        this.byId.set(node.id, element);
+        this.byDom.set(element, node);
+        this.pathById.set(node.id, [...path]);
+    }
+    forget(nodeId) {
+        this.byId.delete(nodeId);
+        this.pathById.delete(nodeId);
+    }
+    nodeToDom(nodeId) { return this.byId.get(nodeId) || null; }
+    domToNode(input) {
+        let node = input;
+        while (node && node !== this.root) {
+            if (this.isEditorUiNode(node))
+                return null;
+            const model = this.byDom.get(node);
+            if (model && !isTextNode(model))
+                return { nodeId: model.id, node: model };
+            node = node.parentNode;
+        }
+        const rootModel = this.root ? this.byDom.get(this.root) : undefined;
+        return rootModel && !isTextNode(rootModel) ? { nodeId: rootModel.id, node: rootModel } : null;
+    }
+    modelDomChildren(element) {
+        return [...element.childNodes].filter((child) => !this.isEditorUiNode(child)
+            && !(child instanceof Element && child.hasAttribute(SMART_PROJECTION_ATTRIBUTE)));
+    }
+    isInlineOwner(node) {
+        if (node.type === "paragraph" || node.type === "heading")
+            return true;
+        return Boolean(node.children?.length) && node.children.every((child) => isTextNode(child) || child.type === "hard_break" || child.type === "image" || child.type === "formula" || child.attrs?.originalGroup === "inline");
+    }
+    textDescendant(node) {
+        if (node.nodeType === node.TEXT_NODE)
+            return node;
+        const walker = node.ownerDocument?.createTreeWalker(node, NodeFilter.SHOW_TEXT);
+        return walker?.nextNode();
+    }
+    posToDom(pos) {
+        if (!this.document)
+            return null;
+        const model = nodeAtPath(this.document, pos.path);
+        if (!model || isTextNode(model))
+            return null;
+        const element = this.byId.get(model.id);
+        if (!element)
+            return null;
+        if (!this.isInlineOwner(model)) {
+            const children = this.modelDomChildren(element);
+            return pos.offset <= children.length ? { node: element, offset: pos.offset } : null;
+        }
+        let remaining = pos.offset;
+        const domChildren = this.modelDomChildren(element);
+        for (let index = 0; index < (model.children || []).length; index += 1) {
+            const modelChild = model.children?.[index];
+            const child = domChildren[index];
+            if (!modelChild || !child)
+                return null;
+            if (isTextNode(modelChild)) {
+                const length = modelChild.text.length;
+                const text = this.textDescendant(child);
+                if (remaining <= length && text)
+                    return { node: text, offset: remaining };
+                remaining -= length;
+            }
+            else {
+                const directIndex = [...element.childNodes].indexOf(child);
+                if (remaining === 0)
+                    return { node: element, offset: directIndex };
+                if (remaining === 1)
+                    return { node: element, offset: directIndex + 1 };
+                remaining -= 1;
+            }
+        }
+        if (remaining !== 0)
+            return null;
+        const lastModelChild = domChildren[domChildren.length - 1];
+        return {
+            node: element,
+            // Renderer-owned UI projections do not consume model offsets. An empty
+            // inline owner therefore maps to offset zero even when it has a visual
+            // caret-line projection.
+            offset: lastModelChild ? [...element.childNodes].indexOf(lastModelChild) + 1 : 0,
+        };
+    }
+    domToPos(node, offset) {
+        if (!this.root || !this.document || this.isEditorUiNode(node))
+            return null;
+        const owner = this.domToNode(node);
+        if (!owner)
+            return null;
+        if (isTextNode(owner.node))
+            return null;
+        const ownerNode = owner.node;
+        const path = this.pathById.get(owner.nodeId);
+        const element = this.byId.get(owner.nodeId);
+        if (!path || !element)
+            return null;
+        if (!this.isInlineOwner(ownerNode)) {
+            if (node !== element) {
+                const direct = node.nodeType === node.ELEMENT_NODE ? node : node.parentElement;
+                const child = direct?.closest(`[${SMART_NODE_ID_ATTRIBUTE}]`);
+                const children = [...element.children].filter((candidate) => !this.isEditorUiNode(candidate));
+                const index = child ? children.indexOf(child) : -1;
+                return index >= 0 ? { path: [...path], offset: index + (offset > 0 ? 1 : 0) } : null;
+            }
+            return { path: [...path], offset };
+        }
+        if (node === element) {
+            const direct = this.modelDomChildren(element);
+            const domChildren = [...element.childNodes];
+            const count = direct.filter((child) => domChildren.indexOf(child) < offset).length;
+            const total = (ownerNode.children || []).slice(0, count)
+                .reduce((sum, child) => sum + (isTextNode(child) ? child.text.length : 1), 0);
+            return { path: [...path], offset: total };
+        }
+        let direct = node;
+        while (direct?.parentNode && direct.parentNode !== element)
+            direct = direct.parentNode;
+        if (!direct || direct.parentNode !== element)
+            return null;
+        const directIndex = this.modelDomChildren(element).indexOf(direct);
+        const modelChild = ownerNode.children?.[directIndex];
+        if (!modelChild)
+            return null;
+        const base = (ownerNode.children || []).slice(0, directIndex)
+            .reduce((sum, child) => sum + (isTextNode(child) ? child.text.length : 1), 0);
+        if (!isTextNode(modelChild))
+            return { path: [...path], offset: base + (offset > 0 ? 1 : 0) };
+        try {
+            const range = element.ownerDocument.createRange();
+            range.selectNodeContents(direct);
+            range.setEnd(node, offset);
+            return { path: [...path], offset: base + Math.min(modelChild.text.length, range.toString().length) };
+        }
+        catch {
+            return null;
+        }
+    }
+    isEditorUiNode(node) {
+        const element = node.nodeType === node.ELEMENT_NODE ? node : node.parentElement;
+        return Boolean(element?.closest(`[${SMART_UI_ATTRIBUTE}]`));
+    }
+}

package/dist/foundation/normalization.d.ts

@@ -0,0 +1,22 @@
+import type { NormalizerRegistration, SmartDocument, SmartOperation, SmartSchema } from "./types.js";
+/**
+ * Normalization is deterministic, idempotent, terminating, and scoped to the
+ * smallest affected ancestor unless a document-wide invariant requires otherwise.
+ */
+export declare const NORMALIZATION_PASS_CAP = 3;
+export declare const smallestAffectedAncestor: (operations: readonly SmartOperation[]) => number[];
+export interface NormalizationRun {
+    document: SmartDocument;
+    operations: SmartOperation[];
+    affectedPath: number[];
+    passes: number;
+    fullDocumentTraversals: number;
+    ranNormalizers: string[];
+}
+export declare const runNormalization: (options: {
+    document: SmartDocument;
+    originatingOperations: readonly SmartOperation[];
+    schema: SmartSchema;
+    normalizers?: readonly NormalizerRegistration[];
+    onDocumentWideRun?: (normalizerId: string) => void;
+}) => NormalizationRun;

package/dist/foundation/normalization.js

@@ -0,0 +1,132 @@
+import { applyOperation } from "./operations.js";
+import { nodeAtPath } from "./positions.js";
+import { repair, validate } from "./schema.js";
+/**
+ * Normalization is deterministic, idempotent, terminating, and scoped to the
+ * smallest affected ancestor unless a document-wide invariant requires otherwise.
+ */
+export const NORMALIZATION_PASS_CAP = 3;
+const commonPrefix = (paths) => {
+    if (!paths.length)
+        return [];
+    const result = [];
+    for (let index = 0; index < Math.min(...paths.map((path) => path.length)); index += 1) {
+        if (!paths.every((path) => path[index] === paths[0][index]))
+            break;
+        result.push(paths[0][index]);
+    }
+    return result;
+};
+const operationPaths = (operation) => {
+    if (operation.type === "moveNode")
+        return [operation.from.path, operation.to.path];
+    if (operation.type === "addMark" || operation.type === "removeMark")
+        return [operation.range.from.path, operation.range.to.path];
+    return [operation.pos.path];
+};
+/** Paths whose existing content an emitted repair changes. Node operations
+ * address their parent plus a child offset, unlike text operations whose path
+ * already addresses the inline owner. */
+const repairedContentPaths = (operation) => {
+    if (operation.type === "replaceNode" || operation.type === "removeNode") {
+        return [[...operation.pos.path, operation.pos.offset]];
+    }
+    return operationPaths(operation);
+};
+export const smallestAffectedAncestor = (operations) => commonPrefix(operations.flatMap(operationPaths));
+const structuralRepairOperations = (before, after, affectedPath) => {
+    if (affectedPath.length) {
+        const beforeNode = nodeAtPath(before, affectedPath);
+        const afterNode = nodeAtPath(after, affectedPath);
+        if (beforeNode && afterNode && JSON.stringify(beforeNode) !== JSON.stringify(afterNode)) {
+            return [{
+                    type: "replaceNode",
+                    pos: { path: affectedPath.slice(0, -1), offset: affectedPath[affectedPath.length - 1] },
+                    before: beforeNode,
+                    after: afterNode,
+                }];
+        }
+    }
+    const operations = [];
+    const shared = Math.min(before.children.length, after.children.length);
+    for (let index = 0; index < shared; index += 1) {
+        if (JSON.stringify(before.children[index]) !== JSON.stringify(after.children[index])) {
+            operations.push({ type: "replaceNode", pos: { path: [], offset: index }, before: before.children[index], after: after.children[index] });
+        }
+    }
+    for (let index = before.children.length - 1; index >= after.children.length; index -= 1) {
+        operations.push({ type: "removeNode", pos: { path: [], offset: index }, node: before.children[index] });
+    }
+    for (let index = shared; index < after.children.length; index += 1) {
+        operations.push({ type: "insertNode", pos: { path: [], offset: index }, node: after.children[index] });
+    }
+    return operations;
+};
+export const runNormalization = (options) => {
+    const affectedPath = smallestAffectedAncestor(options.originatingOperations);
+    let document = options.document;
+    const appended = [];
+    let fullDocumentTraversals = 0;
+    const ranNormalizers = [];
+    const registrations = (options.normalizers || [])
+        .map((normalizer, registrationOrder) => ({ normalizer, registrationOrder }))
+        .sort((left, right) => left.normalizer.priority - right.normalizer.priority || left.registrationOrder - right.registrationOrder);
+    for (let pass = 0; pass < NORMALIZATION_PASS_CAP; pass += 1) {
+        const changedBy = [];
+        // Structural schema repair always precedes registered normalizers. For a
+        // valid operation sequence this is a no-op; invalid output fails loudly
+        // rather than allowing an unrecorded whole-document mutation.
+        const textOnly = options.originatingOperations.every((operation) => operation.type === "insertText" || operation.type === "deleteText" || operation.type === "addMark" || operation.type === "removeMark");
+        if (!textOnly) {
+            const structural = repair(document, options.schema);
+            if (structural.repairs.length) {
+                const repairs = structuralRepairOperations(document, structural.doc, affectedPath);
+                if (!repairs.length)
+                    throw new Error(`Schema repair could not be represented as operations: ${structural.repairs[0].message}`);
+                repairs.forEach((operation) => {
+                    document = applyOperation(document, operation);
+                    appended.push(operation);
+                });
+                changedBy.push("schema");
+            }
+        }
+        for (const { normalizer } of registrations) {
+            const documentWide = normalizer.documentWide === true;
+            if (documentWide) {
+                fullDocumentTraversals += 1;
+                options.onDocumentWideRun?.(normalizer.id);
+            }
+            else if (affectedPath.length && !nodeAtPath(document, affectedPath)) {
+                throw new Error(`Affected normalization path for "${normalizer.id}" no longer exists.`);
+            }
+            ranNormalizers.push(normalizer.id);
+            const result = normalizer.normalize(document, {
+                schema: options.schema,
+                affectedPath,
+                pass,
+                documentWide,
+            });
+            for (const operation of result.operations) {
+                const paths = repairedContentPaths(operation);
+                if (!documentWide && affectedPath.length && paths.some((path) => !affectedPath.every((part, index) => path[index] === part))) {
+                    throw new Error(`Normalizer "${normalizer.id}" emitted an operation outside the affected subtree.`);
+                }
+                document = applyOperation(document, operation);
+                appended.push(operation);
+                changedBy.push(normalizer.id);
+            }
+        }
+        if (!changedBy.length) {
+            if (!textOnly) {
+                const errors = validate(document, options.schema);
+                if (errors.length)
+                    throw new Error(`Normalization produced invalid content: ${errors[0].message}`);
+            }
+            return { document, operations: appended, affectedPath, passes: pass + 1, fullDocumentTraversals, ranNormalizers };
+        }
+        if (pass === NORMALIZATION_PASS_CAP - 1) {
+            throw new Error(`Normalization exceeded ${NORMALIZATION_PASS_CAP} passes; oscillating normalizers: ${[...new Set(changedBy)].join(", ")}.`);
+        }
+    }
+    throw new Error("Unreachable normalization state.");
+};

package/dist/foundation/operations.d.ts

@@ -0,0 +1,28 @@
+import type { SmartDocument, SmartOperation, SmartPos } from "./types.js";
+export declare const applyOperation: (input: SmartDocument, operation: SmartOperation) => SmartDocument;
+export declare const invertOperation: (operation: SmartOperation) => SmartOperation;
+export declare const applyOperations: (document: SmartDocument, operations: readonly SmartOperation[]) => SmartDocument;
+export declare const invertOperations: (operations: readonly SmartOperation[]) => SmartOperation[];
+export declare const mapPosThroughOperation: (pos: SmartPos, operation: SmartOperation, bias?: -1 | 1) => {
+    pos: SmartPos;
+    deleted: boolean;
+};
+/**
+ * `tieBreakBias` only affects the exact-tie case (operation's own structural
+ * position coincides exactly with `through`'s insertion point - e.g. two
+ * concurrent insertNode ops at the identical offset) - every other case's
+ * bias is unaffected. Defaults to 1 (through's content sorts first),
+ * preserving this function's existing, already-tested behavior exactly for
+ * every caller that doesn't pass it. A concurrent-rebase caller should
+ * derive this from a total order over the two operations' authors (e.g.
+ * lexicographic authorId comparison) so both transform directions agree:
+ * mapOperation(A, B, {tieBreakBias: A-sorts-first ? -1 : 1}) and
+ * mapOperation(B, A, {tieBreakBias: B-sorts-first ? -1 : 1}) must reach the
+ * same final order regardless of which one is "operation" and which is
+ * "through". This does not affect the addMark/removeMark range-endpoint
+ * biases below (-1/+1), which serve an unrelated purpose (range-growth
+ * semantics at an insertion boundary) and are deliberately left hardcoded.
+ */
+export declare const mapOperation: (operation: SmartOperation, through: SmartOperation, options?: {
+    tieBreakBias?: -1 | 1;
+}) => SmartOperation | null;