smartrte-core 1.0.0-beta.5 → 1.0.0-beta.7

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 1.0.0-beta.7
+
+- Fix copy, cut, and native drag throwing an uncaught error ("Clipboard copy is clamped to one structural parent.") for any selection whose two endpoints weren't immediate siblings — e.g. starting in a plain paragraph and dragging into a nested list item, or spanning two list items at different nesting depths. This was not an exotic shape: any selection reaching into a list, table, or blockquote from outside it hit this, and the failure was a silent no-op (nothing copied) with a console error, not a graceful fallback. See `docs/bugs/clipboard-copy-cut-throws-across-differently-nested-endpoints.md`.
+
+## 1.0.0-beta.6
+
+- Fix pasting a long, list-free document (many short paragraphs, no images) being slow enough to look broken — the Office/Google Docs list normalizers recursed into every paragraph hunting for nested lists a `<p>` can never structurally contain. Pasting a few thousand blocks now completes in well under a second instead of multiple seconds to tens of seconds. See `docs/bugs/clipboard-paste-slow-on-large-list-free-documents.md` for the full investigation, including a known remaining limitation for very large (10,000+ block) pastes.
+
 ## 1.0.0-beta.5
 
 - Add a per-block `lineHeight` attribute (paragraph, heading, blockquote, code block) — a unitless multiplier matching CSS `line-height`'s own unitless mode (`1`, `1.5`, `2`, ...), consistent with how `align`/`indentLevel` are represented. Absence means no override (the browser/font's own natural line-height), not a forced `1`. Full HTML round-trip fidelity via a dedicated `data-smart-line-height` marker — deliberately does **not** fall back to reading a bare CSS `line-height` value on import (unlike `align`/`indentLevel`'s own CSS fallbacks): real captured clipboard fixtures show `line-height` is frequently an ambient, whole-document default baked onto every paragraph, not a deliberate per-paragraph choice, and recognizing it would have silently misattributed that default as an explicit override on every pasted document. Real Word line spacing (`w:spacing`/`w:line`/`w:lineRule="auto"`) on DOCX export; declared `lossy` there (confirmed empirically that DOCX reimport via mammoth drops it) and `unsupported` (content preserved) in Markdown. Inherits `full` PDF fidelity for free, since this package's "Save as PDF" prints the same HTML export.

package/dist/foundation/clipboard/normalizers.js

@@ -2,6 +2,20 @@ import { parseCanonicalListMarkdown, serializeCanonicalListHtml } from "../list/
 const listTags = new Set(["UL", "OL"]);
 const blockSelector = ":scope > p, :scope > h1, :scope > h2, :scope > h3, :scope > h4, :scope > h5, :scope > h6, :scope > ul, :scope > ol, :scope > blockquote, :scope > pre, :scope > table, :scope > div";
 const msoListPattern = /(?:^|;)\s*mso-list\s*:\s*([^\s;]+)\s+level(\d+)\s+([^\s;]+)/i;
+/**
+ * Elements whose HTML content model is inline-only - a real HTML parser
+ * never lets a <p>/<ul>/<ol>/<div> nest inside one of these (an outer <p>
+ * auto-closes first), so a nested Office mso-list paragraph or a
+ * declared-level <ul>/<ol> can never appear inside one. normalizeMsoLists/
+ * normalizeDeclaredLevelLists below recurse looking for exactly those two
+ * things - recursing into one of these tags is always wasted work. See
+ * docs/bugs/clipboard-paste-normalizer-quadratic-blowup-on-large-documents.md:
+ * on a real document with thousands of top-level paragraphs (the common
+ * case for a long pasted document with no lists at all), skipping this
+ * recursion is what turns an O(n) visit count with an accidentally
+ * document-size-scaled per-call cost back into genuinely linear work.
+ */
+const INLINE_LEAF_TAGS = new Set(["P", "SPAN", "B", "STRONG", "I", "EM", "U", "S", "A", "CODE", "BR", "IMG", "SUP", "SUB"]);
 const unwrap = (element) => element.replaceWith(...Array.from(element.childNodes));
 const normalizeTransparentContainers = (document) => {
     const docsWrapper = document.body.querySelector('[id^="docs-internal-guid-"]');
@@ -71,7 +85,8 @@ const normalizeMsoLists = (document) => {
         for (let index = 0; index < children.length;) {
             const first = msoListEntry(children[index]);
             if (!first) {
-                visit(children[index]);
+                if (!INLINE_LEAF_TAGS.has(children[index].tagName))
+                    visit(children[index]);
                 index += 1;
                 continue;
             }
@@ -167,7 +182,8 @@ const normalizeDeclaredLevelLists = (document) => {
             run[0].replaceWith(...roots);
             run.slice(1).forEach((list) => list.remove());
         }
-        Array.from(parent.children).forEach((child) => visit(child));
+        Array.from(parent.children).forEach((child) => { if (!INLINE_LEAF_TAGS.has(child.tagName))
+            visit(child); });
     };
     visit(document.body);
 };

package/dist/foundation/clipboard/transfer.js

@@ -1,6 +1,12 @@
 import { isTextNode } from "../identity.js";
 import { comparePos, nodeAtPath } from "../positions.js";
 const samePath = (left, right) => left.length === right.length && left.every((part, index) => part === right[index]);
+const commonPrefixLength = (left, right) => {
+    let index = 0;
+    while (index < left.length && index < right.length && left[index] === right[index])
+        index += 1;
+    return index;
+};
 const size = (node) => isTextNode(node) ? node.text.length : 1;
 const split = (children, offset) => {
     const before = [];
@@ -31,6 +37,42 @@ const element = (document, pos) => {
         throw new Error("Clipboard selection owner is invalid.");
     return node;
 };
+/**
+ * `node`'s content, keeping only what lies at-or-after (path, offset) within it -
+ * fully-included later siblings at every level, and a recursively-trimmed branch
+ * for the one that actually contains the position. Used for the tail (or "from")
+ * endpoint of a selection that crosses into a different structural ancestor than
+ * its other endpoint (e.g. from a plain paragraph into a nested list item) - a
+ * selection shape that isn't naturally isTextNode/same-parent, but is still a
+ * perfectly ordinary drag-selection a user can make.
+ */
+const afterSlice = (node, path, offset) => {
+    const children = node.children || [];
+    if (path.length === 0) {
+        const [, tail] = split(children, offset);
+        return { ...node, children: tail };
+    }
+    const index = path[0];
+    const child = children[index];
+    if (!child || isTextNode(child))
+        throw new Error("Clipboard selection path is malformed.");
+    const rest = children.slice(index + 1).map((sibling) => structuredClone(sibling));
+    return { ...node, children: [afterSlice(child, path.slice(1), offset), ...rest] };
+};
+/** Mirror of {@link afterSlice}: keeps only what lies strictly before (path, offset). */
+const beforeSlice = (node, path, offset) => {
+    const children = node.children || [];
+    if (path.length === 0) {
+        const [before] = split(children, offset);
+        return { ...node, children: before };
+    }
+    const index = path[0];
+    const child = children[index];
+    if (!child || isTextNode(child))
+        throw new Error("Clipboard selection path is malformed.");
+    const rest = children.slice(0, index).map((sibling) => structuredClone(sibling));
+    return { ...node, children: [...rest, beforeSlice(child, path.slice(1), offset)] };
+};
 export const sliceClipboardSelection = (document, selection) => {
     const selected = range(selection);
     if (selection.type === "node" || selection.type === "cell") {
@@ -45,24 +87,27 @@ export const sliceClipboardSelection = (document, selection) => {
         const [content] = split(tail, selected.to.offset - selected.from.offset);
         return { type: "doc", id: document.id, children: [{ ...fromOwner, children: content }] };
     }
-    const parentPath = selected.from.path.slice(0, -1);
-    if (!samePath(parentPath, selected.to.path.slice(0, -1)))
-        throw new Error("Clipboard copy is clamped to one structural parent.");
-    const parent = nodeAtPath(document, parentPath);
-    const toOwner = element(document, selected.to);
-    if (!parent || isTextNode(parent) || !parent.children)
-        throw new Error("Clipboard selection parent is invalid.");
-    const fromIndex = selected.from.path[selected.from.path.length - 1];
-    const toIndex = selected.to.path[selected.to.path.length - 1];
-    const [, first] = split(fromOwner.children || [], selected.from.offset);
-    const [last] = split(toOwner.children || [], selected.to.offset);
+    // The two endpoints don't share an immediate parent - they may still share a
+    // deeper common ancestor (e.g. one endpoint is a plain paragraph and the other
+    // is nested inside a list item or table cell several levels down, an entirely
+    // ordinary drag-selection). Slice each endpoint's own top-level branch under
+    // that ancestor recursively, rather than assuming a flat sibling relationship.
+    const commonLength = commonPrefixLength(selected.from.path, selected.to.path);
+    const ancestorPath = selected.from.path.slice(0, commonLength);
+    const ancestor = nodeAtPath(document, ancestorPath);
+    if (!ancestor || isTextNode(ancestor) || !ancestor.children)
+        throw new Error("Clipboard selection ancestor is invalid.");
+    const fromIndex = selected.from.path[commonLength];
+    const toIndex = selected.to.path[commonLength];
+    const fromBranch = ancestor.children[fromIndex];
+    const toBranch = ancestor.children[toIndex];
+    if (!fromBranch || !toBranch || isTextNode(fromBranch) || isTextNode(toBranch))
+        throw new Error("Clipboard selection endpoint is invalid.");
+    const first = afterSlice(fromBranch, selected.from.path.slice(commonLength + 1), selected.from.offset);
+    const last = beforeSlice(toBranch, selected.to.path.slice(commonLength + 1), selected.to.offset);
     return {
         type: "doc", id: document.id,
-        children: [
-            { ...fromOwner, children: first },
-            ...parent.children.slice(fromIndex + 1, toIndex).map((node) => structuredClone(node)),
-            { ...toOwner, children: last },
-        ],
+        children: [first, ...ancestor.children.slice(fromIndex + 1, toIndex).map((node) => structuredClone(node)), last],
     };
 };
 export const deleteClipboardSelection = (document, selection, positions) => {
@@ -91,18 +136,45 @@ export const deleteClipboardSelection = (document, selection, positions) => {
         };
     }
     const parentPath = selected.from.path.slice(0, -1);
-    const parent = nodeAtPath(document, parentPath);
     const toOwner = element(document, selected.to);
-    if (!samePath(parentPath, selected.to.path.slice(0, -1)) || !parent || isTextNode(parent) || !parent.children) {
-        throw new Error("Clipboard deletion is clamped to one structural parent.");
+    if (samePath(parentPath, selected.to.path.slice(0, -1))) {
+        const parent = nodeAtPath(document, parentPath);
+        if (!parent || isTextNode(parent) || !parent.children)
+            throw new Error("Clipboard deletion parent is invalid.");
+        const fromIndex = selected.from.path[selected.from.path.length - 1];
+        const toIndex = selected.to.path[selected.to.path.length - 1];
+        const [before] = split(owner.children || [], selected.from.offset);
+        const [, after] = split(toOwner.children || [], selected.to.offset);
+        const operations = [];
+        for (let index = toIndex; index > fromIndex; index -= 1)
+            operations.push({ type: "removeNode", pos: { path: [...parentPath], offset: index }, node: parent.children[index] });
+        operations.push({ type: "replaceNode", pos: ownerPosition.pos, before: owner, after: { ...owner, children: [...before, ...after] } });
+        return { operations, selectionTarget: { ownerId: owner.id, offset: selected.from.offset } };
+    }
+    // Endpoints live under different immediate parents (e.g. cutting from a plain
+    // paragraph into a nested list item) - too structurally different to merge
+    // into one owner the way same-parent siblings do above, but still coherent:
+    // trim each endpoint's own top-level branch down to what's unselected, remove
+    // any branch fully between them, and leave both trimmed branches in place.
+    const commonLength = commonPrefixLength(selected.from.path, selected.to.path);
+    const ancestorPath = selected.from.path.slice(0, commonLength);
+    const ancestor = nodeAtPath(document, ancestorPath);
+    if (!ancestor || isTextNode(ancestor) || !ancestor.children)
+        throw new Error("Clipboard deletion ancestor is invalid.");
+    const fromIndex = selected.from.path[commonLength];
+    const toIndex = selected.to.path[commonLength];
+    const fromBranch = ancestor.children[fromIndex];
+    const toBranch = ancestor.children[toIndex];
+    if (!fromBranch || !toBranch || isTextNode(fromBranch) || isTextNode(toBranch))
+        throw new Error("Clipboard deletion endpoint is invalid.");
+    const trimmedFrom = beforeSlice(fromBranch, selected.from.path.slice(commonLength + 1), selected.from.offset);
+    const trimmedTo = afterSlice(toBranch, selected.to.path.slice(commonLength + 1), selected.to.offset);
+    const operations = [
+        { type: "replaceNode", pos: { path: [...ancestorPath], offset: toIndex }, before: toBranch, after: trimmedTo },
+    ];
+    for (let index = toIndex - 1; index > fromIndex; index -= 1) {
+        operations.push({ type: "removeNode", pos: { path: [...ancestorPath], offset: index }, node: ancestor.children[index] });
     }
-    const fromIndex = selected.from.path[selected.from.path.length - 1];
-    const toIndex = selected.to.path[selected.to.path.length - 1];
-    const [before] = split(owner.children || [], selected.from.offset);
-    const [, after] = split(toOwner.children || [], selected.to.offset);
-    const operations = [];
-    for (let index = toIndex; index > fromIndex; index -= 1)
-        operations.push({ type: "removeNode", pos: { path: [...parentPath], offset: index }, node: parent.children[index] });
-    operations.push({ type: "replaceNode", pos: ownerPosition.pos, before: owner, after: { ...owner, children: [...before, ...after] } });
+    operations.push({ type: "replaceNode", pos: { path: [...ancestorPath], offset: fromIndex }, before: fromBranch, after: trimmedFrom });
     return { operations, selectionTarget: { ownerId: owner.id, offset: selected.from.offset } };
 };

package/dist/foundation/surface/input.js

@@ -601,15 +601,25 @@ export class FoundationInputPipeline {
         if (!event.clipboardData || collapsed(this.editor.selection))
             return;
         event.preventDefault();
-        this.writeTransfer(event.clipboardData, sliceClipboardSelection(this.editor.document, this.editor.selection));
+        try {
+            this.writeTransfer(event.clipboardData, sliceClipboardSelection(this.editor.document, this.editor.selection));
+        }
+        catch {
+            this.unhandled.push("copy-rejected");
+        }
     }
     handleCut(event) {
         if (!event.clipboardData || collapsed(this.editor.selection))
             return;
         event.preventDefault();
-        this.writeTransfer(event.clipboardData, sliceClipboardSelection(this.editor.document, this.editor.selection));
-        const deletion = deleteClipboardSelection(this.editor.document, this.editor.selection, this.editor.positions);
-        this.commitClipboard({ ...deletion, definingAncestorId: null }, "cut");
+        try {
+            this.writeTransfer(event.clipboardData, sliceClipboardSelection(this.editor.document, this.editor.selection));
+            const deletion = deleteClipboardSelection(this.editor.document, this.editor.selection, this.editor.positions);
+            this.commitClipboard({ ...deletion, definingAncestorId: null }, "cut");
+        }
+        catch {
+            this.unhandled.push("cut-rejected");
+        }
     }
     handlePaste(event) {
         event.preventDefault();
@@ -635,10 +645,15 @@ export class FoundationInputPipeline {
     handleDragStart(event) {
         if (!event.dataTransfer || collapsed(this.editor.selection))
             return;
-        const fragment = sliceClipboardSelection(this.editor.document, this.editor.selection);
-        this.internalDrag = { selection: this.editor.selection, fragment };
-        this.writeTransfer(event.dataTransfer, fragment);
-        event.dataTransfer.effectAllowed = "move";
+        try {
+            const fragment = sliceClipboardSelection(this.editor.document, this.editor.selection);
+            this.internalDrag = { selection: this.editor.selection, fragment };
+            this.writeTransfer(event.dataTransfer, fragment);
+            event.dataTransfer.effectAllowed = "move";
+        }
+        catch {
+            this.unhandled.push("dragstart-rejected");
+        }
     }
     handleDrop(event) {
         event.preventDefault();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smartrte-core",
-  "version": "1.0.0-beta.5",
+  "version": "1.0.0-beta.7",
   "description": "Framework-agnostic document model and editing primitives for Smart RTE",
   "repository": {
     "type": "git",