docx-diff-editor 1.0.58 → 1.0.60

package/README.md

@@ -269,6 +269,11 @@ Convert HTML strings to ProseMirror JSON without visible rendering. **Inline sty
 const json = await editorRef.current?.parseHtml('<h1>Title</h1><p>Content here</p>');
 console.log(json); // { type: 'doc', content: [...] }
 
+// Lists work correctly - numbering definitions are synced to the main document
+const listJson = await editorRef.current?.parseHtml(
+  '<ul><li>Item 1</li><li>Item 2</li></ul>'
+);
+
 // Inline styles are converted to marks
 const styledJson = await editorRef.current?.parseHtml(
   '<p><span style="color: red; font-weight: bold;">styled text</span></p>'
@@ -283,6 +288,14 @@ import { parseHtmlToJson } from 'docx-diff-editor';
 const json = await parseHtmlToJson(htmlString, SuperDocClass);
 ```
 
+### Linked Parsing for Lists
+
+When the main editor is ready, `parseHtml()` automatically uses a **linked child editor** approach. This ensures that list numbering definitions (for `<ol>` and `<ul>` elements) are synced to the main document's numbering store.
+
+This prevents crashes when parsed content with lists is later spliced into the main document and rendered via `compareWith()`.
+
+If the main editor isn't ready yet, the method falls back to an isolated SuperDoc instance.
+
 ### Supported Inline Styles
 
 | CSS Property | ProseMirror Mark |

package/dist/index.js

@@ -970,6 +970,92 @@ async function parseHtmlToJson(html, SuperDoc) {
     }, 50);
   });
 }
+function syncNumberingToParent(childEditor, parentEditor) {
+  try {
+    const childNumbering = childEditor?.converter?.numbering;
+    const parentNumbering = parentEditor?.converter?.numbering;
+    if (!childNumbering || !parentNumbering) {
+      return;
+    }
+    if (childNumbering.definitions) {
+      parentNumbering.definitions = {
+        ...parentNumbering.definitions,
+        ...childNumbering.definitions
+      };
+    }
+    if (childNumbering.abstracts) {
+      parentNumbering.abstracts = {
+        ...parentNumbering.abstracts,
+        ...childNumbering.abstracts
+      };
+    }
+    parentEditor.converter.numbering = parentNumbering;
+  } catch (err) {
+    console.warn("[syncNumberingToParent] Failed to sync numbering definitions:", err);
+  }
+}
+async function parseHtmlWithLinkedEditor(html, mainEditor) {
+  const container = document.createElement("div");
+  container.style.cssText = "position:absolute;top:-9999px;left:-9999px;width:800px;height:600px;visibility:hidden;";
+  document.body.appendChild(container);
+  return new Promise((resolve, reject) => {
+    let resolved = false;
+    let childEditor = null;
+    const cleanup = () => {
+      setTimeout(() => {
+        if (childEditor) {
+          try {
+            childEditor.destroy?.();
+          } catch {
+          }
+          childEditor = null;
+        }
+        if (container.parentNode) {
+          container.parentNode.removeChild(container);
+        }
+      }, TIMEOUTS.CLEANUP_DELAY);
+    };
+    try {
+      mainEditor.createChildEditor({
+        element: container,
+        html,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        onCreate: ({ editor: localEditor }) => {
+          if (resolved) return;
+          try {
+            childEditor = localEditor;
+            syncNumberingToParent(localEditor, mainEditor);
+            const json = localEditor.getJSON();
+            const normalizedJson = normalizeRunProperties(json);
+            resolved = true;
+            cleanup();
+            resolve(normalizedJson);
+          } catch (err) {
+            resolved = true;
+            cleanup();
+            reject(err);
+          }
+        },
+        onError: (error) => {
+          if (resolved) return;
+          resolved = true;
+          cleanup();
+          reject(error);
+        }
+      });
+      setTimeout(() => {
+        if (!resolved) {
+          resolved = true;
+          cleanup();
+          reject(new Error("Linked HTML parsing timed out"));
+        }
+      }, TIMEOUTS.PARSE_TIMEOUT);
+    } catch (err) {
+      cleanup();
+      reject(err);
+    }
+  });
+}
 async function parseDocxFile(file, SuperDoc) {
   const container = document.createElement("div");
   container.style.cssText = "position:absolute;top:-9999px;left:-9999px;width:800px;height:600px;visibility:hidden;";
@@ -3672,13 +3758,30 @@ var DocxDiffEditor = react.forwardRef(
           }
         },
         /**
-         * Parse HTML string to ProseMirror JSON using a hidden SuperDoc instance.
-         * Useful for converting HTML content before using with other methods.
+         * Parse HTML string to ProseMirror JSON.
+         * 
+         * When the main editor is ready, this uses a linked child editor approach
+         * which ensures list numbering definitions are synced to the main document.
+         * This prevents crashes when parsed content with lists is spliced into
+         * the main document via compareWith().
+         * 
+         * Falls back to an isolated SuperDoc instance if the main editor isn't ready.
          */
         async parseHtml(html) {
           if (!SuperDocRef.current) {
             throw new Error("Editor not initialized");
           }
+          const mainEditor = superdocRef.current?.activeEditor;
+          if (mainEditor?.createChildEditor) {
+            try {
+              return await parseHtmlWithLinkedEditor(html, mainEditor);
+            } catch (err) {
+              console.warn(
+                "[DocxDiffEditor] Linked HTML parsing failed, falling back to isolated approach:",
+                err
+              );
+            }
+          }
           return parseHtmlToJson(html, SuperDocRef.current);
         }
       }),