docx-diff-editor 1.0.57 → 1.0.59

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.d.mts

@@ -189,6 +189,13 @@ interface ComparisonResult {
     mergedJson: ProseMirrorJSON;
     /** Metadata for structural changes (for the pane) */
     structuralChangeInfos: StructuralChangeInfo[];
+    /**
+     * True if comparison fell back to direct content update (without track bubbles).
+     * This happens when SuperDoc's internal plugins crash on certain content structures
+     * (e.g., ordered lists with missing numbering definitions).
+     * The content is still applied correctly, but track change visualization is unavailable.
+     */
+    usedFallback?: boolean;
 }
 /**
  * Location context for a change

package/dist/index.d.ts

@@ -189,6 +189,13 @@ interface ComparisonResult {
     mergedJson: ProseMirrorJSON;
     /** Metadata for structural changes (for the pane) */
     structuralChangeInfos: StructuralChangeInfo[];
+    /**
+     * True if comparison fell back to direct content update (without track bubbles).
+     * This happens when SuperDoc's internal plugins crash on certain content structures
+     * (e.g., ordered lists with missing numbering definitions).
+     * The content is still applied correctly, but track change visualization is unavailable.
+     */
+    usedFallback?: boolean;
 }
 /**
  * Location context for a change

package/dist/index.js

@@ -970,6 +970,67 @@ async function parseHtmlToJson(html, SuperDoc) {
     }, 50);
   });
 }
+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;
+            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;";
@@ -3313,36 +3374,59 @@ var DocxDiffEditor = react.forwardRef(
             setMergedJson(normalizedMerged);
             const diff = diffDocuments(cleanBaseline, cleanNewJson);
             setDiffResult(diff);
+            let usedFallback = false;
             if (superdocRef.current?.activeEditor) {
-              setEditorContent(superdocRef.current.activeEditor, normalizedMerged);
-              enableReviewMode(superdocRef.current);
-              const sd = superdocRef.current;
-              if (sd.commentsStore?.processLoadedDocxComments) {
-                setTimeout(() => {
-                  try {
-                    sd.commentsStore.processLoadedDocxComments({
-                      superdoc: sd,
-                      editor: sd.activeEditor,
-                      comments: [],
-                      // Empty array - we just want to trigger createCommentForTrackChanges
-                      documentId: sd.activeEditor?.options?.documentId || "primary"
-                    });
-                  } catch (err) {
-                    console.warn("[DocxDiffEditor] Failed to process track changes for bubbles:", err);
-                  }
-                }, 50);
+              try {
+                setEditorContent(superdocRef.current.activeEditor, normalizedMerged);
+                enableReviewMode(superdocRef.current);
+                const sd = superdocRef.current;
+                if (sd.commentsStore?.processLoadedDocxComments) {
+                  setTimeout(() => {
+                    try {
+                      sd.commentsStore.processLoadedDocxComments({
+                        superdoc: sd,
+                        editor: sd.activeEditor,
+                        comments: [],
+                        // Empty array - we just want to trigger createCommentForTrackChanges
+                        documentId: sd.activeEditor?.options?.documentId || "primary"
+                      });
+                    } catch (err) {
+                      console.warn("[DocxDiffEditor] Failed to process track changes for bubbles:", err);
+                    }
+                  }, 50);
+                }
+              } catch (contentErr) {
+                console.warn(
+                  "[DocxDiffEditor] Failed to apply merged content with track changes. Falling back to direct content update without track bubbles.",
+                  contentErr
+                );
+                usedFallback = true;
+                try {
+                  setEditorContent(superdocRef.current.activeEditor, normalizedNewJson);
+                  setEditingMode(superdocRef.current);
+                } catch (fallbackErr) {
+                  console.error("[DocxDiffEditor] Fallback content update also failed:", fallbackErr);
+                  throw contentErr;
+                }
               }
             }
-            setStructuralChanges(structInfos);
-            setIsPaneDismissed(false);
+            if (!usedFallback) {
+              setStructuralChanges(structInfos);
+              setIsPaneDismissed(false);
+            } else {
+              setStructuralChanges([]);
+            }
             const insertions = diff.segments.filter((s) => s.type === "insert").length;
             const deletions = diff.segments.filter((s) => s.type === "delete").length;
             const formatChanges = diff.formatChanges?.length || 0;
-            const structuralChangeCount = structInfos.length;
+            const structuralChangeCount = usedFallback ? 0 : structInfos.length;
             const combinedSummary = [...structuralResult.summary];
             if (diff.summary.length > 0 && structuralResult.summary.length === 0) {
               combinedSummary.push(...diff.summary);
             }
+            if (usedFallback) {
+              combinedSummary.push("Note: Track change visualization unavailable for this content");
+            }
             const result = {
               totalChanges: insertions + deletions + formatChanges + structuralChangeCount,
               insertions,
@@ -3350,8 +3434,9 @@ var DocxDiffEditor = react.forwardRef(
               formatChanges,
               structuralChanges: structuralChangeCount,
               summary: combinedSummary,
-              mergedJson: merged,
-              structuralChangeInfos: structInfos
+              mergedJson: usedFallback ? normalizedNewJson : merged,
+              structuralChangeInfos: usedFallback ? [] : structInfos,
+              usedFallback
             };
             onComparisonComplete?.(result);
             return result;
@@ -3648,13 +3733,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);
         }
       }),