docxmlater 10.4.1 → 11.0.4

package/dist/esm/processors/MoveOperationHelper.js

@@ -0,0 +1,57 @@
+import { Revision } from '../elements/Revision.js';
+import { RangeMarker } from '../elements/RangeMarker.js';
+import { Run } from '../elements/Run.js';
+let globalMoveIdCounter = 0;
+let globalAnnotationIdCounter = 1000;
+export class MoveOperationHelper {
+    static createMoveOperation(options) {
+        const { author, content, date = new Date() } = options;
+        const moveId = options.moveId || `move-${++globalMoveIdCounter}`;
+        const getNextId = options.idProvider || (() => ++globalAnnotationIdCounter);
+        const moveFromRangeId = getNextId();
+        const moveFromId = getNextId();
+        const moveToRangeId = getNextId();
+        const moveToId = getNextId();
+        const moveFromRangeStart = RangeMarker.createMoveFromStart(moveFromRangeId, moveId, author, date);
+        const moveFrom = Revision.createMoveFrom(author, content, moveId, date);
+        moveFrom.setId(moveFromId);
+        const moveFromRangeEnd = RangeMarker.createMoveFromEnd(moveFromRangeId);
+        const contentArray = Array.isArray(content) ? content : [content];
+        const clonedContent = contentArray.map((run) => {
+            const cloned = new Run(run.getText(), { ...run.getFormatting() });
+            return cloned;
+        });
+        const moveToRangeStart = RangeMarker.createMoveToStart(moveToRangeId, moveId, author, date);
+        const moveTo = Revision.createMoveTo(author, clonedContent, moveId, date);
+        moveTo.setId(moveToId);
+        const moveToRangeEnd = RangeMarker.createMoveToEnd(moveToRangeId);
+        return {
+            source: {
+                rangeStart: moveFromRangeStart,
+                moveFrom,
+                rangeEnd: moveFromRangeEnd,
+            },
+            destination: {
+                rangeStart: moveToRangeStart,
+                moveTo,
+                rangeEnd: moveToRangeEnd,
+            },
+            moveId,
+        };
+    }
+    static addMoveOperation(sourceParagraph, destParagraph, options) {
+        const moveOp = this.createMoveOperation(options);
+        sourceParagraph.addRangeMarker(moveOp.source.rangeStart);
+        sourceParagraph.addRevision(moveOp.source.moveFrom);
+        sourceParagraph.addRangeMarker(moveOp.source.rangeEnd);
+        destParagraph.addRangeMarker(moveOp.destination.rangeStart);
+        destParagraph.addRevision(moveOp.destination.moveTo);
+        destParagraph.addRangeMarker(moveOp.destination.rangeEnd);
+        return moveOp;
+    }
+    static resetIdCounters() {
+        globalMoveIdCounter = 0;
+        globalAnnotationIdCounter = 1000;
+    }
+}
+//# sourceMappingURL=MoveOperationHelper.js.map

package/dist/esm/processors/MoveOperationHelper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MoveOperationHelper.js","sourceRoot":"","sources":["../../../src/processors/MoveOperationHelper.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * MoveOperationHelper - Creates complete move operations with range markers\n *\n * Per ECMA-376, move operations in tracked changes require:\n * 1. w:moveFromRangeStart (marks start of source region)\n * 2. w:moveFrom (contains the moved content)\n * 3. w:moveFromRangeEnd (marks end of source region)\n * 4. w:moveToRangeStart (marks start of destination region)\n * 5. w:moveTo (contains the moved content copy)\n * 6. w:moveToRangeEnd (marks end of destination region)\n *\n * The range markers and move elements share a common 'name' (for range markers)\n * and 'moveId' (for move elements) that links them together.\n *\n * @example\n * ```typescript\n * // Create a complete move operation\n * const moveOp = MoveOperationHelper.createMoveOperation({\n *   author: 'John Doe',\n *   content: [new Run('moved text')],\n *   idProvider: () => document.getIdManager().getNextId(),\n * });\n *\n * // Add to source paragraph\n * sourceParagraph.addRangeMarker(moveOp.source.rangeStart);\n * sourceParagraph.addRevision(moveOp.source.moveFrom);\n * sourceParagraph.addRangeMarker(moveOp.source.rangeEnd);\n *\n * // Add to destination paragraph\n * destParagraph.addRangeMarker(moveOp.destination.rangeStart);\n * destParagraph.addRevision(moveOp.destination.moveTo);\n * destParagraph.addRangeMarker(moveOp.destination.rangeEnd);\n * ```\n */\n\nimport { Revision } from '../elements/Revision.js';\nimport { RangeMarker } from '../elements/RangeMarker.js';\nimport { Run } from '../elements/Run.js';\n\n/**\n * Options for creating a move operation\n */\nexport interface MoveOperationOptions {\n  /** Author who made the move */\n  author: string;\n  /** Content being moved (Run or array of Runs) */\n  content: Run | Run[];\n  /** Date of the move (defaults to now) */\n  date?: Date;\n  /** ID provider function - returns the next available annotation ID */\n  idProvider?: () => number;\n  /** Optional move ID (auto-generated if not provided) */\n  moveId?: string;\n}\n\n/**\n * Result of creating a move operation\n */\nexport interface MoveOperationResult {\n  /** Elements to add to the source paragraph (where content was moved FROM) */\n  source: {\n    /** Range start marker (w:moveFromRangeStart) */\n    rangeStart: RangeMarker;\n    /** Move revision (w:moveFrom) */\n    moveFrom: Revision;\n    /** Range end marker (w:moveFromRangeEnd) */\n    rangeEnd: RangeMarker;\n  };\n  /** Elements to add to the destination paragraph (where content was moved TO) */\n  destination: {\n    /** Range start marker (w:moveToRangeStart) */\n    rangeStart: RangeMarker;\n    /** Move revision (w:moveTo) */\n    moveTo: Revision;\n    /** Range end marker (w:moveToRangeEnd) */\n    rangeEnd: RangeMarker;\n  };\n  /** The move ID linking all elements together */\n  moveId: string;\n}\n\n/**\n * Simple ID counter for when no provider is specified\n */\nlet globalMoveIdCounter = 0;\nlet globalAnnotationIdCounter = 1000; // Start high to avoid conflicts\n\n/**\n * Helper class for creating complete move operations\n */\nexport class MoveOperationHelper {\n  /**\n   * Creates a complete move operation with all required elements.\n   *\n   * This generates:\n   * - Source: w:moveFromRangeStart, w:moveFrom, w:moveFromRangeEnd\n   * - Destination: w:moveToRangeStart, w:moveTo, w:moveToRangeEnd\n   *\n   * All elements are linked by the moveId (for revisions) and name (for range markers).\n   *\n   * @param options - Move operation options\n   * @returns Complete move operation with all elements\n   *\n   * @example\n   * ```typescript\n   * const moveOp = MoveOperationHelper.createMoveOperation({\n   *   author: 'John Doe',\n   *   content: new Run('text to move'),\n   * });\n   *\n   * // Add to source paragraph (where text was)\n   * sourcePara.addRangeMarker(moveOp.source.rangeStart);\n   * sourcePara.addRevision(moveOp.source.moveFrom);\n   * sourcePara.addRangeMarker(moveOp.source.rangeEnd);\n   *\n   * // Add to destination paragraph (where text moved to)\n   * destPara.addRangeMarker(moveOp.destination.rangeStart);\n   * destPara.addRevision(moveOp.destination.moveTo);\n   * destPara.addRangeMarker(moveOp.destination.rangeEnd);\n   * ```\n   */\n  static createMoveOperation(options: MoveOperationOptions): MoveOperationResult {\n    const { author, content, date = new Date() } = options;\n\n    // Generate move ID if not provided\n    const moveId = options.moveId || `move-${++globalMoveIdCounter}`;\n\n    // Get IDs from provider or use simple counter\n    const getNextId = options.idProvider || (() => ++globalAnnotationIdCounter);\n\n    // Allocate IDs for all elements\n    // Range markers use same ID for start/end pairs\n    const moveFromRangeId = getNextId();\n    const moveFromId = getNextId();\n    const moveToRangeId = getNextId();\n    const moveToId = getNextId();\n\n    // Create source elements\n    const moveFromRangeStart = RangeMarker.createMoveFromStart(\n      moveFromRangeId,\n      moveId,\n      author,\n      date\n    );\n\n    const moveFrom = Revision.createMoveFrom(author, content, moveId, date);\n    moveFrom.setId(moveFromId);\n\n    const moveFromRangeEnd = RangeMarker.createMoveFromEnd(moveFromRangeId);\n\n    // Create destination elements (clone content for moveTo)\n    const contentArray = Array.isArray(content) ? content : [content];\n    const clonedContent = contentArray.map((run) => {\n      // Clone the run to have independent content at destination\n      const cloned = new Run(run.getText(), { ...run.getFormatting() });\n      return cloned;\n    });\n\n    const moveToRangeStart = RangeMarker.createMoveToStart(moveToRangeId, moveId, author, date);\n\n    const moveTo = Revision.createMoveTo(author, clonedContent, moveId, date);\n    moveTo.setId(moveToId);\n\n    const moveToRangeEnd = RangeMarker.createMoveToEnd(moveToRangeId);\n\n    return {\n      source: {\n        rangeStart: moveFromRangeStart,\n        moveFrom,\n        rangeEnd: moveFromRangeEnd,\n      },\n      destination: {\n        rangeStart: moveToRangeStart,\n        moveTo,\n        rangeEnd: moveToRangeEnd,\n      },\n      moveId,\n    };\n  }\n\n  /**\n   * Adds a complete move operation to source and destination paragraphs.\n   *\n   * This is a convenience method that creates the move operation and adds\n   * all elements to the appropriate paragraphs in the correct order.\n   *\n   * @param sourceParagraph - Paragraph where content was moved FROM\n   * @param destParagraph - Paragraph where content was moved TO\n   * @param options - Move operation options\n   * @returns The move operation result for reference\n   *\n   * @example\n   * ```typescript\n   * import { Paragraph } from 'docxmlater';\n   *\n   * const sourcePara = document.getParagraphs()[0];\n   * const destPara = document.getParagraphs()[5];\n   *\n   * MoveOperationHelper.addMoveOperation(sourcePara, destPara, {\n   *   author: 'John Doe',\n   *   content: new Run('moved text'),\n   * });\n   * ```\n   */\n  static addMoveOperation(\n    sourceParagraph: import('../elements/Paragraph.js').Paragraph,\n    destParagraph: import('../elements/Paragraph.js').Paragraph,\n    options: MoveOperationOptions\n  ): MoveOperationResult {\n    const moveOp = this.createMoveOperation(options);\n\n    // Add to source paragraph in order\n    sourceParagraph.addRangeMarker(moveOp.source.rangeStart);\n    sourceParagraph.addRevision(moveOp.source.moveFrom);\n    sourceParagraph.addRangeMarker(moveOp.source.rangeEnd);\n\n    // Add to destination paragraph in order\n    destParagraph.addRangeMarker(moveOp.destination.rangeStart);\n    destParagraph.addRevision(moveOp.destination.moveTo);\n    destParagraph.addRangeMarker(moveOp.destination.rangeEnd);\n\n    return moveOp;\n  }\n\n  /**\n   * Resets the global ID counters (for testing purposes).\n   * @internal\n   */\n  static resetIdCounters(): void {\n    globalMoveIdCounter = 0;\n    globalAnnotationIdCounter = 1000;\n  }\n}\n"]}

package/dist/esm/processors/RevisionAwareProcessor.js

@@ -0,0 +1,232 @@
+import { Revision } from '../elements/Revision.js';
+export class RevisionAwareProcessor {
+    static async prepare(doc, options) {
+        const log = [];
+        const acceptedRevisions = [];
+        const preservedRevisions = [];
+        const newRevisions = [];
+        const conflicts = [];
+        const addLog = (action, details, revisionId) => {
+            log.push({
+                timestamp: new Date(),
+                action,
+                details,
+                revisionId,
+            });
+        };
+        addLog('start', `Starting revision processing with mode: ${options.mode}`);
+        try {
+            const revisionManager = doc.getRevisionManager();
+            const hasInMemoryRevisions = revisionManager?.hasRevisions() ?? false;
+            const hasRawXmlRevisions = doc.hasRawXmlRevisions();
+            if (!hasInMemoryRevisions && !hasRawXmlRevisions) {
+                addLog('complete', 'No revisions found in document');
+                return {
+                    success: true,
+                    acceptedRevisions,
+                    preservedRevisions,
+                    newRevisions,
+                    conflicts,
+                    log,
+                };
+            }
+            const allRevisions = revisionManager?.getAllRevisions() ?? [];
+            const inMemoryCount = allRevisions.length;
+            const rawXmlNote = hasRawXmlRevisions ? ' (raw XML contains revision markup)' : '';
+            addLog('info', `Found ${inMemoryCount} parsed revisions in document${rawXmlNote}`);
+            switch (options.mode) {
+                case 'accept_all':
+                    await this.acceptAllRevisions(doc, allRevisions, acceptedRevisions, addLog);
+                    break;
+                case 'preserve':
+                    for (const rev of allRevisions) {
+                        preservedRevisions.push(rev.getId().toString());
+                    }
+                    doc.preserveRawXml();
+                    addLog('complete', `Preserved ${preservedRevisions.length} revisions (raw XML preservation enabled)`);
+                    break;
+                case 'preserve_and_wrap':
+                    for (const rev of allRevisions) {
+                        preservedRevisions.push(rev.getId().toString());
+                    }
+                    doc.preserveRawXml();
+                    addLog('info', `Will preserve and wrap conflicts for ${preservedRevisions.length} revisions`);
+                    addLog('info', `New revisions will be authored by: ${options.author || 'Unknown'}`);
+                    break;
+                default:
+                    addLog('error', `Unknown processing mode: ${options.mode}`);
+                    return {
+                        success: false,
+                        acceptedRevisions,
+                        preservedRevisions,
+                        newRevisions,
+                        conflicts,
+                        log,
+                    };
+            }
+            addLog('complete', 'Revision processing completed successfully');
+            return {
+                success: true,
+                acceptedRevisions,
+                preservedRevisions,
+                newRevisions,
+                conflicts,
+                log,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            addLog('error', `Processing failed: ${errorMessage}`);
+            return {
+                success: false,
+                acceptedRevisions,
+                preservedRevisions,
+                newRevisions,
+                conflicts,
+                log,
+            };
+        }
+    }
+    static async acceptAllRevisions(doc, revisions, acceptedIds, addLog) {
+        addLog('info', 'Accepting all revisions using in-memory DOM transformation');
+        for (const rev of revisions) {
+            acceptedIds.push(rev.getId().toString());
+        }
+        await doc.acceptAllRevisions();
+        for (const id of acceptedIds) {
+            addLog('accept', `Accepted revision ${id}`, id);
+        }
+        addLog('complete', `Accepted ${acceptedIds.length} revisions (in-memory transformation)`);
+    }
+    static acceptSelective(doc, criteria) {
+        const revisionManager = doc.getRevisionManager();
+        if (!revisionManager) {
+            return [];
+        }
+        const allRevisions = revisionManager.getAllRevisions();
+        const matchingRevisions = this.filterRevisions(allRevisions, criteria);
+        const acceptedIds = [];
+        for (const rev of matchingRevisions) {
+            acceptedIds.push(rev.getId().toString());
+        }
+        return acceptedIds;
+    }
+    static filterRevisions(revisions, criteria) {
+        return revisions.filter((rev) => {
+            if (criteria.ids && !criteria.ids.includes(rev.getId())) {
+                return false;
+            }
+            if (criteria.types && !criteria.types.includes(rev.getType())) {
+                return false;
+            }
+            if (criteria.authors && !criteria.authors.includes(rev.getAuthor())) {
+                return false;
+            }
+            if (criteria.dateRange) {
+                const date = rev.getDate();
+                if (date < criteria.dateRange.start || date > criteria.dateRange.end) {
+                    return false;
+                }
+            }
+            if (criteria.categories) {
+                const category = this.getRevisionCategory(rev);
+                if (!criteria.categories.includes(category)) {
+                    return false;
+                }
+            }
+            if (criteria.custom && !criteria.custom(rev)) {
+                return false;
+            }
+            return true;
+        });
+    }
+    static getRevisionCategory(revision) {
+        const type = revision.getType();
+        if (type === 'insert' || type === 'delete') {
+            return 'content';
+        }
+        if (type === 'runPropertiesChange' ||
+            type === 'paragraphPropertiesChange' ||
+            type === 'numberingChange') {
+            return 'formatting';
+        }
+        if (type === 'moveFrom' || type === 'moveTo' || type === 'sectionPropertiesChange') {
+            return 'structural';
+        }
+        if (type === 'tablePropertiesChange' ||
+            type === 'tableExceptionPropertiesChange' ||
+            type === 'tableRowPropertiesChange' ||
+            type === 'tableCellPropertiesChange' ||
+            type === 'tableCellInsert' ||
+            type === 'tableCellDelete' ||
+            type === 'tableCellMerge') {
+            return 'table';
+        }
+        return 'content';
+    }
+    static checkConflict(doc, paragraphIndex, _runIndex) {
+        const revisionManager = doc.getRevisionManager();
+        if (!revisionManager) {
+            return null;
+        }
+        const revisions = revisionManager.getRevisionsForParagraph(paragraphIndex);
+        return revisions.length > 0 ? revisions[0] : null;
+    }
+    static getAffectedRevisions(doc, paragraphIndex, _runIndex) {
+        const revisionManager = doc.getRevisionManager();
+        if (!revisionManager) {
+            return [];
+        }
+        return revisionManager.getRevisionsForParagraph(paragraphIndex);
+    }
+    static wrapInRevision(doc, paragraphIndex, runIndex, author, type) {
+        const revisionManager = doc.getRevisionManager();
+        if (!revisionManager) {
+            throw new Error('Document does not have a revision manager');
+        }
+        const paragraphs = doc.getParagraphs();
+        if (paragraphIndex < 0 || paragraphIndex >= paragraphs.length) {
+            throw new Error(`Invalid paragraph index: ${paragraphIndex}`);
+        }
+        const paragraph = paragraphs[paragraphIndex];
+        if (!paragraph) {
+            throw new Error(`Paragraph at index ${paragraphIndex} not found`);
+        }
+        const runs = paragraph.getRuns();
+        if (runIndex < 0 || runIndex >= runs.length) {
+            throw new Error(`Invalid run index: ${runIndex}`);
+        }
+        const run = runs[runIndex];
+        if (!run) {
+            throw new Error(`Run at index ${runIndex} not found`);
+        }
+        const revision = new Revision({
+            author,
+            type,
+            content: run,
+            date: new Date(),
+        });
+        revisionManager.register(revision);
+        return revision.getId().toString();
+    }
+    static hasTrackedChanges(doc) {
+        const revisionManager = doc.getRevisionManager();
+        return revisionManager ? revisionManager.hasRevisions() : false;
+    }
+    static getTrackedChangesSummary(doc) {
+        const revisionManager = doc.getRevisionManager();
+        if (!revisionManager) {
+            return null;
+        }
+        const summary = revisionManager.getSummary();
+        return {
+            total: summary.total,
+            insertions: summary.byType.insertions,
+            deletions: summary.byType.deletions,
+            formatting: summary.byType.propertyChanges,
+            moves: summary.byType.moves,
+            authors: summary.authors,
+        };
+    }
+}
+//# sourceMappingURL=RevisionAwareProcessor.js.map

package/dist/esm/processors/RevisionAwareProcessor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RevisionAwareProcessor.js","sourceRoot":"","sources":["../../../src/processors/RevisionAwareProcessor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * RevisionAwareProcessor - Handles document revisions before and during processing\n *\n * Provides three modes for handling existing Word tracked changes:\n * - accept_all: Accept all revisions before processing (default)\n * - preserve: Preserve revisions, skip conflicting operations\n * - preserve_and_wrap: Preserve revisions, wrap conflicts in new revisions\n *\n * Implements ECMA-376 compliant revision handling.\n *\n * @module RevisionAwareProcessor\n */\n\nimport type { Document } from '../core/Document.js';\nimport { Revision, RevisionType } from '../elements/Revision.js';\nimport { ChangeCategory, ChangeLocation } from './ChangelogGenerator.js';\n\n/**\n * Revision handling modes for document processing.\n */\nexport type RevisionHandlingMode =\n  | 'accept_all' // Accept all revisions before processing\n  | 'preserve' // Preserve revisions, skip conflicting operations\n  | 'preserve_and_wrap'; // Preserve revisions, wrap conflicts in new revisions\n\n/**\n * Options for revision-aware processing.\n */\nexport interface RevisionProcessingOptions {\n  /** How to handle existing revisions */\n  mode: RevisionHandlingMode;\n  /** Author name for new revisions (required for 'preserve_and_wrap' mode) */\n  author?: string;\n  /** Selective acceptance criteria (optional, for partial acceptance) */\n  acceptCriteria?: SelectionCriteria;\n}\n\n/**\n * Criteria for selecting specific revisions.\n */\nexport interface SelectionCriteria {\n  /** Specific revision IDs */\n  ids?: number[];\n  /** Filter by revision types */\n  types?: RevisionType[];\n  /** Filter by authors */\n  authors?: string[];\n  /** Filter by date range */\n  dateRange?: { start: Date; end: Date };\n  /** Filter by category */\n  categories?: ChangeCategory[];\n  /** Custom filter function */\n  custom?: (revision: Revision) => boolean;\n}\n\n/**\n * Result of revision-aware processing.\n */\nexport interface RevisionProcessingResult {\n  /** Whether processing completed successfully */\n  success: boolean;\n  /** IDs of revisions that were accepted */\n  acceptedRevisions: string[];\n  /** IDs of revisions that were preserved */\n  preservedRevisions: string[];\n  /** IDs of new revisions created (preserve_and_wrap mode) */\n  newRevisions: string[];\n  /** Conflicts encountered during processing */\n  conflicts: ConflictInfo[];\n  /** Processing log entries */\n  log: ProcessingLogEntry[];\n}\n\n/**\n * Information about a conflict between an operation and a revision.\n */\nexport interface ConflictInfo {\n  /** Description of the operation that conflicted */\n  operation: string;\n  /** ID of the conflicting revision */\n  revisionId: string;\n  /** How the conflict was resolved */\n  resolution: 'accepted' | 'skipped' | 'wrapped';\n  /** Location of the conflict */\n  location: ChangeLocation;\n}\n\n/**\n * Log entry for processing actions.\n */\nexport interface ProcessingLogEntry {\n  timestamp: Date;\n  action: string;\n  details: string;\n  revisionId?: string;\n}\n\n/**\n * Handles document revisions before and during processing.\n * Implements ECMA-376 compliant revision handling.\n */\nexport class RevisionAwareProcessor {\n  /**\n   * Prepare document for processing by handling revisions.\n   * Call this before applying any document modifications.\n   *\n   * @param doc - Document to prepare\n   * @param options - Processing options\n   * @returns Processing result with details of actions taken\n   */\n  static async prepare(\n    doc: Document,\n    options: RevisionProcessingOptions\n  ): Promise<RevisionProcessingResult> {\n    const log: ProcessingLogEntry[] = [];\n    const acceptedRevisions: string[] = [];\n    const preservedRevisions: string[] = [];\n    const newRevisions: string[] = [];\n    const conflicts: ConflictInfo[] = [];\n\n    const addLog = (action: string, details: string, revisionId?: string) => {\n      log.push({\n        timestamp: new Date(),\n        action,\n        details,\n        revisionId,\n      });\n    };\n\n    addLog('start', `Starting revision processing with mode: ${options.mode}`);\n\n    try {\n      const revisionManager = doc.getRevisionManager();\n      const hasInMemoryRevisions = revisionManager?.hasRevisions() ?? false;\n      const hasRawXmlRevisions = doc.hasRawXmlRevisions();\n\n      // Check both in-memory model AND raw XML for revisions\n      // Raw XML may contain revisions that weren't fully parsed into memory\n      if (!hasInMemoryRevisions && !hasRawXmlRevisions) {\n        addLog('complete', 'No revisions found in document');\n        return {\n          success: true,\n          acceptedRevisions,\n          preservedRevisions,\n          newRevisions,\n          conflicts,\n          log,\n        };\n      }\n\n      const allRevisions = revisionManager?.getAllRevisions() ?? [];\n      const inMemoryCount = allRevisions.length;\n      const rawXmlNote = hasRawXmlRevisions ? ' (raw XML contains revision markup)' : '';\n      addLog('info', `Found ${inMemoryCount} parsed revisions in document${rawXmlNote}`);\n\n      switch (options.mode) {\n        case 'accept_all':\n          // Accept all revisions\n          await this.acceptAllRevisions(doc, allRevisions, acceptedRevisions, addLog);\n          break;\n\n        case 'preserve':\n          // Preserve all revisions by preventing document.xml regeneration\n          // This keeps the original XML with w:ins/w:del elements intact\n          for (const rev of allRevisions) {\n            preservedRevisions.push(rev.getId().toString());\n          }\n          doc.preserveRawXml();\n          addLog(\n            'complete',\n            `Preserved ${preservedRevisions.length} revisions (raw XML preservation enabled)`\n          );\n          break;\n\n        case 'preserve_and_wrap':\n          // Preserve all revisions, track for later wrapping\n          // Also enable raw XML preservation to keep existing revisions\n          for (const rev of allRevisions) {\n            preservedRevisions.push(rev.getId().toString());\n          }\n          doc.preserveRawXml();\n          addLog(\n            'info',\n            `Will preserve and wrap conflicts for ${preservedRevisions.length} revisions`\n          );\n          addLog('info', `New revisions will be authored by: ${options.author || 'Unknown'}`);\n          break;\n\n        default:\n          addLog('error', `Unknown processing mode: ${options.mode}`);\n          return {\n            success: false,\n            acceptedRevisions,\n            preservedRevisions,\n            newRevisions,\n            conflicts,\n            log,\n          };\n      }\n\n      addLog('complete', 'Revision processing completed successfully');\n\n      return {\n        success: true,\n        acceptedRevisions,\n        preservedRevisions,\n        newRevisions,\n        conflicts,\n        log,\n      };\n    } catch (error: unknown) {\n      const errorMessage = error instanceof Error ? error.message : 'Unknown error';\n      addLog('error', `Processing failed: ${errorMessage}`);\n\n      return {\n        success: false,\n        acceptedRevisions,\n        preservedRevisions,\n        newRevisions,\n        conflicts,\n        log,\n      };\n    }\n  }\n\n  /**\n   * Accept all revisions in the document using Document.acceptAllRevisions().\n   *\n   * This delegates to Document.acceptAllRevisions() which uses in-memory DOM transformation\n   * (the industry-standard approach used by OpenXML PowerTools, Aspose.Words, etc.):\n   *\n   * 1. Transforms Revision objects in paragraph.content arrays\n   * 2. Insertions (w:ins): Unwraps content - keeps Runs/Hyperlinks, removes Revision wrapper\n   * 3. Deletions (w:del): Removes content entirely from the model\n   * 4. Move operations: moveFrom removed, moveTo unwrapped\n   * 5. Property changes: Removes change metadata, keeps current formatting\n   *\n   * This approach allows subsequent modifications to be saved correctly because the\n   * in-memory model is transformed (not raw XML), so save() regenerates document.xml\n   * with both the accepted changes AND any subsequent modifications.\n   *\n   * @see https://github.com/OfficeDev/Open-Xml-PowerTools - RevisionAccepter.cs\n   * @see https://learn.microsoft.com/en-us/previous-versions/office/developer/office-2007/ee836138\n   */\n  private static async acceptAllRevisions(\n    doc: Document,\n    revisions: Revision[],\n    acceptedIds: string[],\n    addLog: (action: string, details: string, revisionId?: string) => void\n  ): Promise<void> {\n    addLog('info', 'Accepting all revisions using in-memory DOM transformation');\n\n    // Track accepted revision IDs before acceptance (for logging)\n    for (const rev of revisions) {\n      acceptedIds.push(rev.getId().toString());\n    }\n\n    // Use Document.acceptAllRevisions() which uses in-memory transformation\n    // This allows subsequent modifications to be saved correctly\n    await doc.acceptAllRevisions();\n\n    // Log each accepted revision\n    for (const id of acceptedIds) {\n      addLog('accept', `Accepted revision ${id}`, id);\n    }\n\n    addLog('complete', `Accepted ${acceptedIds.length} revisions (in-memory transformation)`);\n  }\n\n  /**\n   * Accept revisions matching the given criteria.\n   * Uses existing RevisionAcceptor under the hood.\n   *\n   * @param doc - Document to process\n   * @param criteria - Selection criteria\n   * @returns Array of accepted revision IDs\n   */\n  static acceptSelective(doc: Document, criteria: SelectionCriteria): string[] {\n    const revisionManager = doc.getRevisionManager();\n    if (!revisionManager) {\n      return [];\n    }\n\n    const allRevisions = revisionManager.getAllRevisions();\n    const matchingRevisions = this.filterRevisions(allRevisions, criteria);\n\n    const acceptedIds: string[] = [];\n    for (const rev of matchingRevisions) {\n      acceptedIds.push(rev.getId().toString());\n      // Note: Actual acceptance would require XML manipulation\n      // For now, this returns which revisions WOULD be accepted\n    }\n\n    return acceptedIds;\n  }\n\n  /**\n   * Filter revisions based on criteria.\n   */\n  private static filterRevisions(revisions: Revision[], criteria: SelectionCriteria): Revision[] {\n    return revisions.filter((rev) => {\n      // Filter by IDs\n      if (criteria.ids && !criteria.ids.includes(rev.getId())) {\n        return false;\n      }\n\n      // Filter by types\n      if (criteria.types && !criteria.types.includes(rev.getType())) {\n        return false;\n      }\n\n      // Filter by authors\n      if (criteria.authors && !criteria.authors.includes(rev.getAuthor())) {\n        return false;\n      }\n\n      // Filter by date range\n      if (criteria.dateRange) {\n        const date = rev.getDate();\n        if (date < criteria.dateRange.start || date > criteria.dateRange.end) {\n          return false;\n        }\n      }\n\n      // Filter by categories\n      if (criteria.categories) {\n        const category = this.getRevisionCategory(rev);\n        if (!criteria.categories.includes(category)) {\n          return false;\n        }\n      }\n\n      // Custom filter\n      if (criteria.custom && !criteria.custom(rev)) {\n        return false;\n      }\n\n      return true;\n    });\n  }\n\n  /**\n   * Get the semantic category of a revision.\n   */\n  private static getRevisionCategory(revision: Revision): ChangeCategory {\n    const type = revision.getType();\n\n    if (type === 'insert' || type === 'delete') {\n      return 'content';\n    }\n    if (\n      type === 'runPropertiesChange' ||\n      type === 'paragraphPropertiesChange' ||\n      type === 'numberingChange'\n    ) {\n      return 'formatting';\n    }\n    if (type === 'moveFrom' || type === 'moveTo' || type === 'sectionPropertiesChange') {\n      return 'structural';\n    }\n    if (\n      type === 'tablePropertiesChange' ||\n      type === 'tableExceptionPropertiesChange' ||\n      type === 'tableRowPropertiesChange' ||\n      type === 'tableCellPropertiesChange' ||\n      type === 'tableCellInsert' ||\n      type === 'tableCellDelete' ||\n      type === 'tableCellMerge'\n    ) {\n      return 'table';\n    }\n\n    return 'content';\n  }\n\n  /**\n   * Check if an operation at the given location would conflict with any revision.\n   *\n   * @param doc - Document to check\n   * @param paragraphIndex - Paragraph index\n   * @param runIndex - Optional run index\n   * @returns Conflicting revision or null\n   */\n  static checkConflict(doc: Document, paragraphIndex: number, _runIndex?: number): Revision | null {\n    const revisionManager = doc.getRevisionManager();\n    if (!revisionManager) {\n      return null;\n    }\n\n    // Get revisions that might affect this paragraph\n    const revisions = revisionManager.getRevisionsForParagraph(paragraphIndex);\n\n    // For now, return the first revision at this location\n    // In a more complete implementation, we would check run-level conflicts\n    return revisions.length > 0 ? revisions[0]! : null;\n  }\n\n  /**\n   * Get all revisions that would be affected by an operation.\n   *\n   * @param doc - Document to check\n   * @param paragraphIndex - Paragraph index\n   * @param runIndex - Optional run index\n   * @returns Array of affected revisions\n   */\n  static getAffectedRevisions(\n    doc: Document,\n    paragraphIndex: number,\n    _runIndex?: number\n  ): Revision[] {\n    const revisionManager = doc.getRevisionManager();\n    if (!revisionManager) {\n      return [];\n    }\n\n    return revisionManager.getRevisionsForParagraph(paragraphIndex);\n  }\n\n  /**\n   * Wrap content in a new revision (for preserve_and_wrap mode).\n   * Creates a new revision tracking the change.\n   *\n   * @param doc - Document to modify\n   * @param paragraphIndex - Paragraph index\n   * @param runIndex - Run index\n   * @param author - Author for the new revision\n   * @param type - Type of revision to create\n   * @returns ID of the new revision\n   */\n  static wrapInRevision(\n    doc: Document,\n    paragraphIndex: number,\n    runIndex: number,\n    author: string,\n    type: 'insert' | 'delete'\n  ): string {\n    const revisionManager = doc.getRevisionManager();\n    if (!revisionManager) {\n      throw new Error('Document does not have a revision manager');\n    }\n\n    // Get the paragraphs from the document\n    const paragraphs = doc.getParagraphs();\n    if (paragraphIndex < 0 || paragraphIndex >= paragraphs.length) {\n      throw new Error(`Invalid paragraph index: ${paragraphIndex}`);\n    }\n\n    const paragraph = paragraphs[paragraphIndex];\n    if (!paragraph) {\n      throw new Error(`Paragraph at index ${paragraphIndex} not found`);\n    }\n\n    const runs = paragraph.getRuns();\n    if (runIndex < 0 || runIndex >= runs.length) {\n      throw new Error(`Invalid run index: ${runIndex}`);\n    }\n\n    const run = runs[runIndex];\n    if (!run) {\n      throw new Error(`Run at index ${runIndex} not found`);\n    }\n\n    // Create new revision\n    const revision = new Revision({\n      author,\n      type,\n      content: run,\n      date: new Date(),\n    });\n\n    // Register with manager\n    revisionManager.register(revision);\n\n    return revision.getId().toString();\n  }\n\n  /**\n   * Check if document has any tracked changes.\n   *\n   * @param doc - Document to check\n   * @returns True if document has tracked changes\n   */\n  static hasTrackedChanges(doc: Document): boolean {\n    const revisionManager = doc.getRevisionManager();\n    return revisionManager ? revisionManager.hasRevisions() : false;\n  }\n\n  /**\n   * Get summary of tracked changes in document.\n   *\n   * @param doc - Document to summarize\n   * @returns Summary object or null if no revision manager\n   */\n  static getTrackedChangesSummary(doc: Document): {\n    total: number;\n    insertions: number;\n    deletions: number;\n    formatting: number;\n    moves: number;\n    authors: string[];\n  } | null {\n    const revisionManager = doc.getRevisionManager();\n    if (!revisionManager) {\n      return null;\n    }\n\n    const summary = revisionManager.getSummary();\n    return {\n      total: summary.total,\n      insertions: summary.byType.insertions,\n      deletions: summary.byType.deletions,\n      formatting: summary.byType.propertyChanges,\n      moves: summary.byType.moves,\n      authors: summary.authors,\n    };\n  }\n}\n"]}

package/dist/esm/processors/RevisionWalker.js

@@ -0,0 +1,278 @@
+const REVISION_ELEMENTS = {
+    UNWRAP: ['w:ins', 'w:moveTo'],
+    REMOVE: ['w:del', 'w:moveFrom'],
+    PROPERTY_CHANGES: [
+        'w:rPrChange',
+        'w:pPrChange',
+        'w:tblPrChange',
+        'w:tcPrChange',
+        'w:trPrChange',
+        'w:sectPrChange',
+        'w:tblGridChange',
+        'w:numberingChange',
+        'w:tblPrExChange',
+    ],
+    RANGE_MARKERS: [
+        'w:moveFromRangeStart',
+        'w:moveFromRangeEnd',
+        'w:moveToRangeStart',
+        'w:moveToRangeEnd',
+        'w:customXmlInsRangeStart',
+        'w:customXmlInsRangeEnd',
+        'w:customXmlDelRangeStart',
+        'w:customXmlDelRangeEnd',
+        'w:customXmlMoveFromRangeStart',
+        'w:customXmlMoveFromRangeEnd',
+        'w:customXmlMoveToRangeStart',
+        'w:customXmlMoveToRangeEnd',
+    ],
+};
+export class RevisionWalker {
+    static processTree(obj, options) {
+        const opts = {
+            acceptInsertions: options?.acceptInsertions ?? true,
+            acceptDeletions: options?.acceptDeletions ?? true,
+            acceptMoves: options?.acceptMoves ?? true,
+            acceptPropertyChanges: options?.acceptPropertyChanges ?? true,
+        };
+        const clone = RevisionWalker.deepClone(obj);
+        RevisionWalker.walkAndTransform(clone, opts);
+        return clone;
+    }
+    static deepClone(obj) {
+        if (obj === null || typeof obj !== 'object') {
+            return obj;
+        }
+        if (Array.isArray(obj)) {
+            return obj.map((item) => RevisionWalker.deepClone(item));
+        }
+        const clone = {};
+        for (const key of Object.keys(obj)) {
+            clone[key] = RevisionWalker.deepClone(obj[key]);
+        }
+        return clone;
+    }
+    static walkAndTransform(obj, options) {
+        if (obj === null || typeof obj !== 'object') {
+            return;
+        }
+        if (options.acceptDeletions && obj['w:tr']) {
+            RevisionWalker.filterDeletedRows(obj);
+        }
+        const keys = Object.keys(obj).filter((k) => !k.startsWith('@_') && k !== '#text' && k !== '_orderedChildren');
+        for (const key of keys) {
+            const value = obj[key];
+            if (Array.isArray(value)) {
+                for (const item of value) {
+                    RevisionWalker.walkAndTransform(item, options);
+                }
+            }
+            else if (typeof value === 'object' && value !== null) {
+                RevisionWalker.walkAndTransform(value, options);
+            }
+        }
+        RevisionWalker.processRevisions(obj, options);
+    }
+    static filterDeletedRows(tbl) {
+        const rows = tbl['w:tr'];
+        const isRowDeleted = (row) => {
+            if (!row || typeof row !== 'object')
+                return false;
+            const trPr = row['w:trPr'];
+            if (!trPr || typeof trPr !== 'object')
+                return false;
+            return !!trPr['w:del'];
+        };
+        if (Array.isArray(rows)) {
+            const kept = rows.filter((r) => !isRowDeleted(r));
+            if (kept.length !== rows.length) {
+                if (kept.length === 0) {
+                    delete tbl['w:tr'];
+                }
+                else {
+                    tbl['w:tr'] = kept;
+                }
+            }
+        }
+        else if (isRowDeleted(rows)) {
+            delete tbl['w:tr'];
+        }
+    }
+    static processRevisions(parent, options) {
+        if (!parent || typeof parent !== 'object') {
+            return;
+        }
+        const keysToProcess = Object.keys(parent).filter((k) => !k.startsWith('@_') && k !== '#text' && k !== '_orderedChildren');
+        for (const key of keysToProcess) {
+            if (RevisionWalker.shouldUnwrap(key, options)) {
+                RevisionWalker.unwrapAllElements(parent, key);
+            }
+            else if (RevisionWalker.shouldRemove(key, options)) {
+                RevisionWalker.removeAllElements(parent, key);
+            }
+        }
+    }
+    static shouldUnwrap(key, options) {
+        if (REVISION_ELEMENTS.UNWRAP.includes(key)) {
+            if (key === 'w:ins' && !options.acceptInsertions)
+                return false;
+            if (key === 'w:moveTo' && !options.acceptMoves)
+                return false;
+            return true;
+        }
+        return false;
+    }
+    static shouldRemove(key, options) {
+        if (REVISION_ELEMENTS.REMOVE.includes(key)) {
+            if (key === 'w:del' && !options.acceptDeletions)
+                return false;
+            if (key === 'w:moveFrom' && !options.acceptMoves)
+                return false;
+            return true;
+        }
+        if (REVISION_ELEMENTS.PROPERTY_CHANGES.includes(key)) {
+            return options.acceptPropertyChanges;
+        }
+        if (REVISION_ELEMENTS.RANGE_MARKERS.includes(key)) {
+            return true;
+        }
+        return false;
+    }
+    static unwrapAllElements(parent, key) {
+        const elements = parent[key];
+        if (!elements)
+            return;
+        const elementArray = Array.isArray(elements) ? elements : [elements];
+        const orderedElements = [];
+        if (parent._orderedChildren) {
+            const typeCounters = new Map();
+            let unwrappedIndex = 0;
+            for (const entry of parent._orderedChildren) {
+                const { type } = entry;
+                if (type === key) {
+                    const revElement = elementArray[unwrappedIndex];
+                    unwrappedIndex++;
+                    if (revElement && typeof revElement === 'object') {
+                        if (revElement._orderedChildren) {
+                            const childCounters = new Map();
+                            for (const childEntry of revElement._orderedChildren) {
+                                const childType = childEntry.type;
+                                const childIdx = childCounters.get(childType) || 0;
+                                childCounters.set(childType, childIdx + 1);
+                                const childElements = revElement[childType];
+                                if (childElements) {
+                                    const childArray = Array.isArray(childElements) ? childElements : [childElements];
+                                    if (childIdx < childArray.length) {
+                                        orderedElements.push({
+                                            type: childType,
+                                            element: childArray[childIdx],
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                        else {
+                            const childKeys = Object.keys(revElement).filter((k) => !k.startsWith('@_') && k !== '#text' && k !== '_orderedChildren');
+                            for (const childKey of childKeys) {
+                                const childValue = revElement[childKey];
+                                const childArray = Array.isArray(childValue) ? childValue : [childValue];
+                                for (const child of childArray) {
+                                    orderedElements.push({ type: childKey, element: child });
+                                }
+                            }
+                        }
+                    }
+                }
+                else {
+                    const idx = typeCounters.get(type) || 0;
+                    typeCounters.set(type, idx + 1);
+                    const parentElements = parent[type];
+                    if (parentElements) {
+                        const parentArray = Array.isArray(parentElements) ? parentElements : [parentElements];
+                        if (idx < parentArray.length) {
+                            orderedElements.push({ type, element: parentArray[idx] });
+                        }
+                    }
+                }
+            }
+        }
+        delete parent[key];
+        if (orderedElements.length > 0) {
+            const rebuiltArrays = new Map();
+            for (const { type, element } of orderedElements) {
+                if (!rebuiltArrays.has(type)) {
+                    rebuiltArrays.set(type, []);
+                }
+                rebuiltArrays.get(type).push(element);
+            }
+            for (const [type, elements] of rebuiltArrays) {
+                if (elements.length === 1) {
+                    parent[type] = elements[0];
+                }
+                else {
+                    parent[type] = elements;
+                }
+            }
+            const newOrderedChildren = [];
+            const typeCounters = new Map();
+            for (const { type } of orderedElements) {
+                const idx = typeCounters.get(type) || 0;
+                typeCounters.set(type, idx + 1);
+                newOrderedChildren.push({ type, index: idx });
+            }
+            parent._orderedChildren = newOrderedChildren;
+        }
+        else {
+            for (const element of elementArray) {
+                if (!element || typeof element !== 'object')
+                    continue;
+                const elementKeys = Object.keys(element).filter((k) => !k.startsWith('@_') && k !== '#text' && k !== '_orderedChildren');
+                for (const childKey of elementKeys) {
+                    RevisionWalker.mergeIntoParent(parent, childKey, element[childKey]);
+                }
+            }
+        }
+    }
+    static removeAllElements(parent, key) {
+        if (!parent[key])
+            return;
+        if (parent._orderedChildren) {
+            parent._orderedChildren = parent._orderedChildren.filter((c) => c.type !== key);
+            RevisionWalker.reindexOrderedChildren(parent._orderedChildren);
+        }
+        delete parent[key];
+    }
+    static mergeIntoParent(parent, childKey, childValue) {
+        if (parent[childKey] === undefined) {
+            parent[childKey] = childValue;
+        }
+        else {
+            const existing = parent[childKey];
+            const incoming = Array.isArray(childValue) ? childValue : [childValue];
+            if (Array.isArray(existing)) {
+                parent[childKey] = [...existing, ...incoming];
+            }
+            else {
+                parent[childKey] = [existing, ...incoming];
+            }
+        }
+    }
+    static reindexOrderedChildren(orderedChildren) {
+        const typeCounters = new Map();
+        for (const entry of orderedChildren) {
+            const currentIndex = typeCounters.get(entry.type) || 0;
+            entry.index = currentIndex;
+            typeCounters.set(entry.type, currentIndex + 1);
+        }
+    }
+    static isRevisionElement(key) {
+        return (REVISION_ELEMENTS.UNWRAP.includes(key) ||
+            REVISION_ELEMENTS.REMOVE.includes(key) ||
+            REVISION_ELEMENTS.PROPERTY_CHANGES.includes(key) ||
+            REVISION_ELEMENTS.RANGE_MARKERS.includes(key));
+    }
+    static getRevisionElementCategories() {
+        return { ...REVISION_ELEMENTS };
+    }
+}
+//# sourceMappingURL=RevisionWalker.js.map