smartrte-core 0.2.1 → 1.0.0-beta.2

package/dist/foundation/formats/pdf/format.js

@@ -0,0 +1,190 @@
+import { parseCanonicalListHtml, serializeCanonicalListHtml } from "../../list/formats.js";
+export const PDF_MEDIA_TYPE = "application/pdf";
+const escapeHtml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+const spanFor = (item) => {
+    const family = item.fontFamily?.toLowerCase() || "";
+    const styles = [
+        `font-size:${Math.max(8, Math.round(item.height))}px`,
+        family.includes("bold") ? "font-weight:700" : "",
+        family.includes("italic") || family.includes("oblique") ? "font-style:italic" : "",
+    ].filter(Boolean).join(";");
+    return `<span style="${styles}">${escapeHtml(item.text)}</span>`;
+};
+const lineContent = (items) => {
+    let previousRight;
+    let text = "";
+    let html = "";
+    const starts = [];
+    const gaps = [];
+    items.forEach((item, index) => {
+        const gap = previousRight === undefined ? 0 : item.x - previousRight;
+        if (index === 0 || gap > 20)
+            starts.push(item.x);
+        if (gap > 2) {
+            text += " ";
+            html += " ";
+            if (gap > 20)
+                gaps.push(gap);
+        }
+        text += item.text;
+        html += spanFor(item);
+        previousRight = item.x + item.width;
+    });
+    return { text, html, starts, gaps };
+};
+const alignmentForLine = (items, pageWidth) => {
+    const first = items[0]?.x || 0;
+    const last = items[items.length - 1];
+    const right = last ? last.x + last.width : first;
+    const center = (first + right) / 2;
+    if (Math.abs(center - pageWidth / 2) < pageWidth * 0.12)
+        return "center";
+    if (first > pageWidth * 0.55)
+        return "right";
+    return "";
+};
+/**
+ * Fidelity: `lossy` for everything - PDF has no structural document model to
+ * recover, only positioned text runs. This is a best-effort layout
+ * reconstruction (lines -> paragraphs/headings/lists/tables via position
+ * heuristics), not a round-trip format. Matches the standing scope decision
+ * since Phase 1.
+ */
+export const reconstructPdfPages = (pages) => {
+    let layoutHtml = "";
+    pages.forEach((page) => {
+        const heights = page.items.map((item) => item.height).filter((height) => height > 0).sort((a, b) => a - b);
+        const medianHeight = heights[Math.floor(heights.length / 2)] || 12;
+        const lines = [];
+        page.items.filter((item) => item.text.trim()).forEach((item) => {
+            const line = lines.find((candidate) => Math.abs(candidate.y - item.y) < medianHeight * 0.5);
+            if (line)
+                line.items.push(item);
+            else
+                lines.push({ y: item.y, items: [item] });
+        });
+        lines.sort((left, right) => right.y - left.y);
+        lines.forEach((line) => line.items.sort((left, right) => left.x - right.x));
+        let pageHtml = "";
+        let activeList;
+        let tableColumns = [];
+        let tableRows = [];
+        const closeList = () => {
+            if (activeList)
+                pageHtml += `</${activeList}>`;
+            activeList = undefined;
+        };
+        const closeTable = () => {
+            if (tableRows.length) {
+                pageHtml += `<table style="border-collapse:collapse;width:100%"><tbody>${tableRows.join("")}</tbody></table>`;
+            }
+            tableRows = [];
+            tableColumns = [];
+        };
+        lines.forEach((line) => {
+            const content = lineContent(line.items);
+            const alignsWithTable = tableColumns.length > 0
+                && content.starts.some((x) => tableColumns.some((column) => Math.abs(column - x) < 20));
+            const beginsTable = content.starts.length >= 2 && content.gaps.some((gap) => gap > 30);
+            if (beginsTable || alignsWithTable) {
+                closeList();
+                if (!tableColumns.length)
+                    tableColumns = [...content.starts];
+                const cells = new Array(tableColumns.length).fill("");
+                line.items.forEach((item) => {
+                    let column = 0;
+                    tableColumns.forEach((start, index) => {
+                        if (item.x >= start - 10)
+                            column = index;
+                    });
+                    cells[column] += `${cells[column] ? " " : ""}${spanFor(item)}`;
+                });
+                tableRows.push(`<tr>${cells.map((cell) => `<td style="border:1px solid #d1d5db;padding:8px;vertical-align:top">${cell || "&nbsp;"}</td>`).join("")}</tr>`);
+                return;
+            }
+            closeTable();
+            const bullet = /^[•\-*]\s/.test(content.text);
+            const numbered = /^\d+[.)]\s/.test(content.text);
+            if (bullet || numbered) {
+                const type = bullet ? "ul" : "ol";
+                if (activeList !== type) {
+                    closeList();
+                    activeList = type;
+                    pageHtml += `<${type}>`;
+                }
+                const listItems = line.items.map((item, index) => index === 0
+                    ? { ...item, text: item.text.replace(bullet ? /^[•\-*]\s*/ : /^\d+[.)]\s*/, "") }
+                    : item);
+                pageHtml += `<li>${lineContent(listItems).html.trim()}</li>`;
+                return;
+            }
+            closeList();
+            const largest = Math.max(...line.items.map((item) => item.height));
+            const heading = largest > medianHeight * 1.2;
+            const tag = heading ? (largest > medianHeight * 1.5 ? "h2" : "h3") : "p";
+            const alignment = alignmentForLine(line.items, page.width);
+            const indent = !alignment && line.items[0]?.x > 40 ? `margin-left:${Math.round(line.items[0].x)}px` : "";
+            const style = [alignment ? `text-align:${alignment}` : "", indent].filter(Boolean).join(";");
+            pageHtml += `<${tag}${style ? ` style="${style}"` : ""}>${content.html}</${tag}>`;
+        });
+        closeList();
+        closeTable();
+        layoutHtml += pageHtml;
+    });
+    return { document: parseCanonicalListHtml(layoutHtml), layoutHtml, pages: pages.length };
+};
+export const importPdfDocument = async (arrayBuffer) => {
+    const pdfjsLib = await import("pdfjs-dist");
+    if (typeof window !== "undefined") {
+        pdfjsLib.GlobalWorkerOptions.workerSrc = new URL("pdfjs-dist/build/pdf.worker.min.mjs", import.meta.url).toString();
+    }
+    const pdf = await pdfjsLib.getDocument({ data: arrayBuffer }).promise;
+    const pages = [];
+    for (let index = 1; index <= pdf.numPages; index += 1) {
+        const page = await pdf.getPage(index);
+        const viewport = page.getViewport({ scale: 1 });
+        const content = await page.getTextContent();
+        const styles = content.styles;
+        pages.push({
+            width: viewport.width,
+            items: content.items.map((item) => ({
+                text: item.str || "",
+                x: item.transform[4],
+                y: item.transform[5],
+                width: item.width || 0,
+                height: Math.abs(item.transform[3]) || 0,
+                fontFamily: styles[item.fontName]?.fontFamily,
+            })),
+        });
+    }
+    return reconstructPdfPages(pages);
+};
+export const buildPdfPrintDocument = (document) => {
+    const html = serializeCanonicalListHtml(document, { clean: true });
+    return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>Smart RTE PDF Export</title>
+  <style>
+    @page { margin: 18mm; }
+    html, body { background: #fff; }
+    body {
+      color: #111;
+      font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+      line-height: 1.6;
+      padding: 32px;
+    }
+    table { border-collapse: collapse; width: 100%; margin: 12px 0; break-inside: auto; }
+    tr, img, blockquote, pre { break-inside: avoid; }
+    td, th { border: 1px solid #d1d5db; padding: 8px; vertical-align: top; }
+    img { max-width: 100%; height: auto; }
+    blockquote { border-left: 4px solid #d1d5db; padding-left: 12px; color: #374151; }
+    pre, code { background: #f3f4f6; }
+    pre { padding: 12px; white-space: pre-wrap; }
+    @media print { body { padding: 0; } }
+  </style>
+</head>
+<body>${html || "<p></p>"}</body>
+</html>`;
+};

package/dist/foundation/history.d.ts

@@ -0,0 +1,20 @@
+import type { Attrs, HistoryEntry, SmartHistory, SmartTransaction } from "./types.js";
+export declare const DEFAULT_HISTORY_LIMIT = 200;
+export declare const DEFAULT_HISTORY_BYTE_LIMIT: number;
+export declare const DEFAULT_COALESCENCE_WINDOW_MS = 400;
+export declare const createHistory: (options?: {
+    limit?: number;
+    byteLimit?: number;
+    coalescenceWindowMs?: number;
+}) => SmartHistory;
+export declare const recordHistory: (history: SmartHistory, transaction: SmartTransaction) => SmartHistory;
+export declare const popUndo: (history: SmartHistory) => {
+    entry: HistoryEntry;
+    history: SmartHistory;
+} | null;
+export declare const popRedo: (history: SmartHistory) => {
+    entry: HistoryEntry;
+    history: SmartHistory;
+} | null;
+/** Keeps stored undo/redo payloads applicable through non-history async state updates. */
+export declare const rebaseHistoryNodeAttributes: (history: SmartHistory, nodeId: string, before: Attrs, after: Attrs) => SmartHistory;

package/dist/foundation/history.js

@@ -0,0 +1,121 @@
+import { invertTransaction } from "./transactions.js";
+import { isTextNode } from "./identity.js";
+export const DEFAULT_HISTORY_LIMIT = 200;
+export const DEFAULT_HISTORY_BYTE_LIMIT = 32 * 1024 * 1024;
+export const DEFAULT_COALESCENCE_WINDOW_MS = 400;
+export const createHistory = (options = {}) => ({
+    undo: [],
+    redo: [],
+    limit: Math.max(1, Math.floor(options.limit ?? DEFAULT_HISTORY_LIMIT)),
+    byteLimit: Math.max(1, Math.floor(options.byteLimit ?? DEFAULT_HISTORY_BYTE_LIMIT)),
+    coalescenceWindowMs: Math.max(0, options.coalescenceWindowMs ?? DEFAULT_COALESCENCE_WINDOW_MS),
+});
+const typingTail = (transaction) => {
+    if (!transaction.operations.length || transaction.operations.some((operation) => operation.type !== "insertText"))
+        return null;
+    return transaction.operations[transaction.operations.length - 1];
+};
+const equalPos = (left, right) => left.offset === right.offset && left.path.length === right.path.length && left.path.every((part, index) => part === right.path[index]);
+const canCoalesce = (previous, next, windowMs) => {
+    if (previous.metadata.historyGroup || next.metadata.historyGroup) {
+        return Boolean(previous.metadata.historyGroup && previous.metadata.historyGroup === next.metadata.historyGroup);
+    }
+    if (previous.metadata.compositionId || next.metadata.compositionId) {
+        return Boolean(previous.metadata.compositionId && previous.metadata.compositionId === next.metadata.compositionId);
+    }
+    const left = typingTail(previous);
+    const right = next.operations.length === 1 ? typingTail(next) : null;
+    return Boolean(left && right &&
+        previous.metadata.source === next.metadata.source &&
+        previous.metadata.source === "input" &&
+        next.metadata.timestamp - previous.metadata.timestamp >= 0 &&
+        next.metadata.timestamp - previous.metadata.timestamp <= windowMs &&
+        equalPos(previous.selectionAfter.anchor, next.selectionBefore.anchor) &&
+        equalPos(previous.selectionAfter.head, next.selectionBefore.head) &&
+        equalPos({ path: left.pos.path, offset: left.pos.offset + left.text.length }, right.pos));
+};
+const entryFor = (transaction) => {
+    const forward = structuredClone(transaction);
+    const inverse = invertTransaction(transaction);
+    return { forward, inverse, estimatedBytes: JSON.stringify(forward).length + JSON.stringify(inverse).length };
+};
+const evictToBudget = (entries, limit, byteLimit) => {
+    if (entries.length > limit)
+        entries.splice(0, entries.length - limit);
+    let bytes = entries.reduce((total, entry) => total + entry.estimatedBytes, 0);
+    // Keep the newest intent even when it alone exceeds the budget so undo never
+    // becomes unavailable immediately after a large paste or table operation.
+    while (entries.length > 1 && bytes > byteLimit)
+        bytes -= entries.shift().estimatedBytes;
+    return entries;
+};
+export const recordHistory = (history, transaction) => {
+    if (!transaction.metadata.addToHistory)
+        return history;
+    const undo = [...history.undo];
+    const previous = undo[undo.length - 1];
+    if (previous && canCoalesce(previous.forward, transaction, history.coalescenceWindowMs)) {
+        const combined = {
+            ...previous.forward,
+            operations: [...previous.forward.operations, ...structuredClone(transaction.operations)],
+            selectionAfter: structuredClone(transaction.selectionAfter),
+            storedMarksAfter: structuredClone(transaction.storedMarksAfter),
+            metadata: { ...previous.forward.metadata, timestamp: transaction.metadata.timestamp },
+        };
+        undo[undo.length - 1] = entryFor(combined);
+    }
+    else
+        undo.push(entryFor(transaction));
+    evictToBudget(undo, history.limit, history.byteLimit);
+    return { ...history, undo, redo: [] };
+};
+export const popUndo = (history) => {
+    const entry = history.undo[history.undo.length - 1];
+    if (!entry)
+        return null;
+    return { entry, history: { ...history, undo: history.undo.slice(0, -1), redo: [...history.redo, entry] } };
+};
+export const popRedo = (history) => {
+    const entry = history.redo[history.redo.length - 1];
+    if (!entry)
+        return null;
+    return { entry, history: { ...history, redo: history.redo.slice(0, -1), undo: [...history.undo, entry] } };
+};
+const rewriteNodeAttrs = (node, nodeId, before, after) => {
+    if (isTextNode(node))
+        return node;
+    const children = node.children?.map((child) => rewriteNodeAttrs(child, nodeId, before, after));
+    if (node.id !== nodeId)
+        return children ? { ...node, children } : node;
+    if (JSON.stringify(node.attrs || {}) !== JSON.stringify(before))
+        return children ? { ...node, children } : node;
+    const { attrs: _attrs, ...rest } = node;
+    return Object.keys(after).length ? { ...rest, attrs: structuredClone(after), ...(children ? { children } : {}) } : { ...rest, ...(children ? { children } : {}) };
+};
+/** Keeps stored undo/redo payloads applicable through non-history async state updates. */
+export const rebaseHistoryNodeAttributes = (history, nodeId, before, after) => {
+    const transaction = (value) => ({
+        ...value,
+        operations: value.operations.map((operation) => {
+            if (operation.type === "insertNode" || operation.type === "removeNode")
+                return { ...operation, node: rewriteNodeAttrs(operation.node, nodeId, before, after) };
+            if (operation.type === "replaceNode")
+                return {
+                    ...operation,
+                    before: rewriteNodeAttrs(operation.before, nodeId, before, after),
+                    after: rewriteNodeAttrs(operation.after, nodeId, before, after),
+                };
+            return operation;
+        }),
+    });
+    const entry = (value) => {
+        const forward = transaction(value.forward);
+        const inverse = transaction(value.inverse);
+        return { forward, inverse, estimatedBytes: JSON.stringify(forward).length + JSON.stringify(inverse).length };
+    };
+    return {
+        ...history,
+        undo: evictToBudget(history.undo.map(entry), history.limit, history.byteLimit),
+        redo: evictToBudget(history.redo.map(entry), history.limit, history.byteLimit),
+    };
+};

package/dist/foundation/identity.d.ts

@@ -0,0 +1,8 @@
+import type { SmartDocument, SmartNode } from "./types.js";
+export declare const createNodeId: () => string;
+export declare const isTextNode: (node: SmartNode) => node is Extract<SmartNode, {
+    type: "text";
+}>;
+export declare const cloneNode: <T extends SmartNode>(node: T) => T;
+export declare const collectNodeIds: (document: SmartDocument) => string[];
+export declare const assertUniqueNodeIds: (document: SmartDocument) => void;

package/dist/foundation/identity.js

@@ -0,0 +1,30 @@
+export const createNodeId = () => {
+    const cryptoApi = globalThis.crypto;
+    if (cryptoApi?.randomUUID)
+        return cryptoApi.randomUUID();
+    if (!cryptoApi?.getRandomValues)
+        throw new Error("A cryptographically secure random source is required for node IDs.");
+    const bytes = cryptoApi.getRandomValues(new Uint8Array(16));
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = [...bytes].map((value) => value.toString(16).padStart(2, "0"));
+    return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(6, 8).join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10).join("")}`;
+};
+export const isTextNode = (node) => node.type === "text";
+export const cloneNode = (node) => structuredClone(node);
+export const collectNodeIds = (document) => {
+    const result = [];
+    const visit = (node) => {
+        if (isTextNode(node))
+            return;
+        result.push(node.id);
+        node.children?.forEach(visit);
+    };
+    visit(document);
+    return result;
+};
+export const assertUniqueNodeIds = (document) => {
+    const ids = collectNodeIds(document);
+    if (new Set(ids).size !== ids.length)
+        throw new Error("Duplicate live node id in document.");
+};

package/dist/foundation/index.d.ts

@@ -0,0 +1,30 @@
+export * from "./types.js";
+export * from "./identity.js";
+export * from "./schema.js";
+export { resolvePos, selectionRange, graphemeBoundaries, inlineGraphemeBoundaries, previousGraphemeBoundary, nextGraphemeBoundary, moveGrapheme, graphemeBackspaceRange, } from "./positions.js";
+export * from "./operations.js";
+export * from "./mapping.js";
+export * from "./transactions.js";
+export * from "./normalization.js";
+export * from "./boundaries.js";
+export * from "./history.js";
+export * from "./editor.js";
+export * from "./modelDom.js";
+export * from "./scope/index.js";
+export * from "./surface/index.js";
+export * from "./list/index.js";
+export * from "./marks/index.js";
+export * from "./security/urlPolicy.js";
+export * from "./structural/index.js";
+export * from "./block/index.js";
+export * from "./table/index.js";
+export * from "./atom/index.js";
+export * from "./clipboard/index.js";
+export * from "./formats/index.js";
+export * from "./annotations/index.js";
+export * from "./diff/index.js";
+export * from "./versioning/index.js";
+export * from "./comments/index.js";
+export * from "./suggestions/index.js";
+export * from "./plugin/index.js";
+export * from "./collab/index.js";

package/dist/foundation/index.js

@@ -0,0 +1,30 @@
+export * from "./types.js";
+export * from "./identity.js";
+export * from "./schema.js";
+export { resolvePos, selectionRange, graphemeBoundaries, inlineGraphemeBoundaries, previousGraphemeBoundary, nextGraphemeBoundary, moveGrapheme, graphemeBackspaceRange, } from "./positions.js";
+export * from "./operations.js";
+export * from "./mapping.js";
+export * from "./transactions.js";
+export * from "./normalization.js";
+export * from "./boundaries.js";
+export * from "./history.js";
+export * from "./editor.js";
+export * from "./modelDom.js";
+export * from "./scope/index.js";
+export * from "./surface/index.js";
+export * from "./list/index.js";
+export * from "./marks/index.js";
+export * from "./security/urlPolicy.js";
+export * from "./structural/index.js";
+export * from "./block/index.js";
+export * from "./table/index.js";
+export * from "./atom/index.js";
+export * from "./clipboard/index.js";
+export * from "./formats/index.js";
+export * from "./annotations/index.js";
+export * from "./diff/index.js";
+export * from "./versioning/index.js";
+export * from "./comments/index.js";
+export * from "./suggestions/index.js";
+export * from "./plugin/index.js";
+export * from "./collab/index.js";

package/dist/foundation/list/commands.d.ts

@@ -0,0 +1,28 @@
+import type { SmartElementNode } from "../types.js";
+import type { ContinueListNumberingParams, CreateListParams, IndentListParams, InsertListFragmentParams, ListCommand, MoveListItemsParams, OutdentListParams, RestartListNumberingParams, SetListCheckedParams, SetListPresetParams, SetListStyleParams, UnwrapListParams } from "./types.js";
+/** Explicit style is the current-level override; preset supplies other levels. */
+export declare const effectiveListStyle: (list: SmartElementNode) => string | undefined;
+export declare const createList: ListCommand<CreateListParams>;
+export declare const unwrapList: ListCommand<UnwrapListParams>;
+export declare const indentList: ListCommand<IndentListParams>;
+export declare const outdentList: ListCommand<OutdentListParams>;
+export declare const setListPreset: ListCommand<SetListPresetParams>;
+export declare const setListStyle: ListCommand<SetListStyleParams>;
+export declare const setListChecked: ListCommand<SetListCheckedParams>;
+/** Moves one contiguous item run by one sibling while preserving every item subtree and ID. */
+export declare const moveListItems: ListCommand<MoveListItemsParams>;
+export declare const restartListNumbering: ListCommand<RestartListNumberingParams>;
+export declare const continueListNumbering: ListCommand<ContinueListNumberingParams>;
+export declare const insertListFragment: ListCommand<InsertListFragmentParams>;
+export declare const listCommands: {
+    readonly "list.create": ListCommand<CreateListParams>;
+    readonly "list.unwrap": ListCommand<UnwrapListParams>;
+    readonly "list.indent": ListCommand<IndentListParams>;
+    readonly "list.outdent": ListCommand<OutdentListParams>;
+    readonly "list.setPreset": ListCommand<SetListPresetParams>;
+    readonly "list.setStyle": ListCommand<SetListStyleParams>;
+    readonly "list.setChecked": ListCommand<SetListCheckedParams>;
+    readonly "list.move": ListCommand<MoveListItemsParams>;
+    readonly "list.restartNumbering": ListCommand<RestartListNumberingParams>;
+    readonly "list.continueNumbering": ListCommand<ContinueListNumberingParams>;
+};