docxmlater 10.2.0 → 10.2.2

package/src/core/DocumentParser.ts

@@ -1238,8 +1238,14 @@ export class DocumentParser {
         if (nextClose === -1) break;
         if (nextOpen !== -1 && nextOpen < nextClose) {
           const charAfter = paraContent[nextOpen + openTag.length];
-          if (charAfter === '>' || charAfter === ' ' || charAfter === '/' ||
-              charAfter === '\t' || charAfter === '\n' || charAfter === '\r') {
+          if (
+            charAfter === '>' ||
+            charAfter === ' ' ||
+            charAfter === '/' ||
+            charAfter === '\t' ||
+            charAfter === '\n' ||
+            charAfter === '\r'
+          ) {
             depth++;
           }
           searchFrom = nextOpen + openTag.length;
@@ -1323,19 +1329,32 @@ export class DocumentParser {
             ? [hyperlinks]
             : [];
         if (child.index < hyperlinkArray.length) {
-          const result = this.parseHyperlinkFromObject(
-            hyperlinkArray[child.index],
-            relationshipManager
-          );
-          if (result.hyperlink) {
-            paragraph.addHyperlink(result.hyperlink);
-          }
-          // Add any bookmarks found inside the hyperlink
-          for (const bookmark of result.bookmarkStarts) {
-            paragraph.addBookmarkStart(bookmark);
-          }
-          for (const bookmark of result.bookmarkEnds) {
-            paragraph.addBookmarkEnd(bookmark);
+          const hyperlinkObj = hyperlinkArray[child.index];
+
+          // Hyperlinks containing tracked changes (w:del/w:ins inside w:hyperlink)
+          // cannot survive parseHyperlinkFromObject round-trip — preserve as raw XML
+          const hasRevisionChildren =
+            hyperlinkObj['w:del'] ||
+            hyperlinkObj['w:ins'] ||
+            hyperlinkObj['w:moveFrom'] ||
+            hyperlinkObj['w:moveTo'];
+          if (hasRevisionChildren) {
+            const rawXml = extractElementXmlAtPosition(child.pos, 'w:hyperlink');
+            if (rawXml) {
+              paragraph.addContent(new PreservedElement(rawXml, 'w:hyperlink', 'inline'));
+            }
+          } else {
+            const result = this.parseHyperlinkFromObject(hyperlinkObj, relationshipManager);
+            if (result.hyperlink) {
+              paragraph.addHyperlink(result.hyperlink);
+            }
+            // Add any bookmarks found inside the hyperlink
+            for (const bookmark of result.bookmarkStarts) {
+              paragraph.addBookmarkStart(bookmark);
+            }
+            for (const bookmark of result.bookmarkEnds) {
+              paragraph.addBookmarkEnd(bookmark);
+            }
           }
         }
       } else if (child.type === 'w:fldSimple') {
@@ -1347,8 +1366,12 @@ export class DocumentParser {
             paragraph.addField(field);
           }
         }
-      } else if (child.type === 'w:ins' || child.type === 'w:del' ||
-                 child.type === 'w:moveFrom' || child.type === 'w:moveTo') {
+      } else if (
+        child.type === 'w:ins' ||
+        child.type === 'w:del' ||
+        child.type === 'w:moveFrom' ||
+        child.type === 'w:moveTo'
+      ) {
         const revisionXml = extractElementXmlAtPosition(child.pos, child.type);
         if (revisionXml) {
           // Detect nested revision elements (e.g., w:del inside w:ins)
@@ -2811,6 +2834,35 @@ export class DocumentParser {
                   if (isHyperlinkInstruction(instruction)) {
                     const parsed = parseHyperlinkInstruction(instruction);
                     if (parsed && resultText) {
+                      // HYPERLINK fields with tracked changes in the result region cannot be
+                      // converted to Hyperlink objects — the revisions would become orphaned
+                      // standalone paragraph content. Keep as ComplexField instead.
+                      if (fieldRevisions.length > 0) {
+                        const complexField = this.createComplexFieldFromRuns(fieldRuns);
+                        if (complexField) {
+                          for (const rev of fieldRevisions) {
+                            rev.setFieldContext({
+                              field: complexField,
+                              instruction: complexField.getInstruction(),
+                              position: 'result',
+                            });
+                          }
+                          complexField.setResultRevisions(fieldRevisions);
+                          groupedContent.push(complexField);
+                        } else {
+                          fieldRuns.forEach((run) => groupedContent.push(run));
+                          for (const revision of fieldRevisions) {
+                            groupedContent.push(revision);
+                          }
+                        }
+                        fieldRuns = [];
+                        instructionRevisions = [];
+                        fieldRevisions = [];
+                        fieldState = null;
+                        break;
+                      }
+
+                      // Normal path (no revisions) — convert to Hyperlink object
                       let hyperlink: Hyperlink;
                       if (parsed.url && parsed.url.trim() !== '') {
                         // External hyperlink (or combined external + anchor)

package/src/elements/Field.ts

@@ -685,6 +685,8 @@ export class ComplexField {
    */
   setResult(result: string): this {
     this.result = result;
+    this.resultRevisions = []; // Clear orphaned revisions from old text
+    this.resultContent = []; // Clear raw XML content since we have new text
     return this;
   }
 

package/src/utils/InMemoryRevisionAcceptor.ts

@@ -22,6 +22,7 @@ import type { Run } from '../elements/Run';
 import type { Hyperlink } from '../elements/Hyperlink';
 import { isRunContent, isHyperlinkContent, isImageRunContent } from '../elements/RevisionContent';
 import type { ImageRun } from '../elements/ImageRun';
+import { ComplexField } from '../elements/Field';
 import { Table } from '../elements/Table';
 import { Section } from '../elements/Section';
 import { getGlobalLogger, createScopedLogger, ILogger } from './logger';
@@ -544,6 +545,18 @@ function acceptRevisionsInParagraph(
       // If we reach here, this revision type is not being accepted
       // Keep it in the content
       newContent.push(item);
+    } else if (item instanceof ComplexField && item.hasResultRevisions()) {
+      // Accept revisions nested inside ComplexField result sections
+      const fieldRevisions = item.getResultRevisions();
+      for (const rev of fieldRevisions) {
+        const revType = rev.getType();
+        if (revType === 'insert' && options.acceptInsertions) result.insertionsAccepted++;
+        else if (revType === 'delete' && options.acceptDeletions) result.deletionsAccepted++;
+        else if ((revType === 'moveFrom' || revType === 'moveTo') && options.acceptMoves)
+          result.movesAccepted++;
+      }
+      item.setResultRevisions([]); // Clear after acceptance
+      newContent.push(item);
     } else {
       // Non-revision content - keep as-is
       newContent.push(item);