UNPKG

open-agreements

Version:

Open-source legal template filling CLI and library

402 lines • 17.4 kB
/** * In-Place AST Modifier * * Modifies the revised document's AST in-place to add track changes markup. * This replaces the reconstruction-based approach with direct tree manipulation. */ import { CorrelationStatus } from '../../core-types.js'; import { areRunPropertiesEqual } from '../../format-detection.js'; import { childElements, findChildByTagName, unwrapElement } from '../../primitives/index.js'; import { createEl } from './inPlaceModifier-shared.js'; import { TRACK_CHANGE_WRAPPERS } from './inPlaceModifier-wrappers.js'; export const DELETION_LIKE_STATUSES = new Set([ CorrelationStatus.Deleted, CorrelationStatus.MovedSource, ]); export const INSERTION_LIKE_STATUSES = new Set([ CorrelationStatus.Inserted, CorrelationStatus.MovedDestination, ]); /** * Reorder merged atoms so that within each contiguous block of non-equal atoms, * all deletion-like atoms come before all insertion-like atoms. * * This produces grouped tracked changes ("<del>old words</del><ins>new words</ins>") * instead of alternating word-by-word pairs ("<del>old1</del><ins>new1</ins><del>old2</del>..."). */ export function groupDeletionsBeforeInsertions(atoms) { const result = []; let i = 0; while (i < atoms.length) { const atom = atoms[i]; const status = atom.correlationStatus; // Pass through equal/format-changed/unknown atoms unchanged if (!DELETION_LIKE_STATUSES.has(status) && !INSERTION_LIKE_STATUSES.has(status)) { result.push(atom); i++; continue; } // Collect a contiguous block of change atoms (deletions + insertions) const deletions = []; const insertions = []; while (i < atoms.length) { const s = atoms[i].correlationStatus; if (DELETION_LIKE_STATUSES.has(s)) { deletions.push(atoms[i]); } else if (INSERTION_LIKE_STATUSES.has(s)) { insertions.push(atoms[i]); } else { break; } i++; } // Emit all deletions first, then all insertions result.push(...deletions, ...insertions); } return result; } export function mergeAdjacentTrackChangeSiblings(root) { function traverse(node) { const children = childElements(node); if (children.length < 2) { // Still recurse into children for (const child of childElements(node)) traverse(child); return; } for (let i = 0; i < children.length - 1;) { const a = children[i]; const b = children[i + 1]; if (a.tagName === b.tagName && TRACK_CHANGE_WRAPPERS.has(a.tagName) && a.getAttribute('w:author') === b.getAttribute('w:author') && a.getAttribute('w:date') === b.getAttribute('w:date')) { // Absorb b's children into a while (b.firstChild) a.appendChild(b.firstChild); node.removeChild(b); // Remove b from our local children snapshot and don't increment i — // recheck a with its new next sibling. children.splice(i + 1, 1); continue; } i++; } // Recurse into current children (re-query after mutations) for (const child of childElements(node)) { traverse(child); } } traverse(root); } // ============================================================================= // Bug 1: Suppress field-adjacent false no-op del/ins pairs (issue #42) // ============================================================================= /** * Build a normalized content signature for a run's non-rPr children. * On the del side, maps w:delText → w:t and w:delInstrText → w:instrText * so that content from del wrappers can be compared to ins wrappers. */ export function normalizeRunContentSignature(run, isDelSide) { const parts = []; for (let i = 0; i < run.childNodes.length; i++) { const child = run.childNodes[i]; if (child.nodeType !== 1) continue; const el = child; if (el.tagName === 'w:rPr') continue; let tag = el.tagName; if (isDelSide) { if (tag === 'w:delText') tag = 'w:t'; else if (tag === 'w:delInstrText') tag = 'w:instrText'; } const text = el.textContent ?? ''; parts.push(`<${tag}>${text}</${tag}>`); } return parts.join(''); } /** * Check if an adjacent w:del + w:ins pair is a no-op (identical text and formatting). * Both wrappers must contain the same number of runs with matching rPr and content. */ export function isNoOpPair(del, ins) { const delRuns = childElements(del).filter(c => c.tagName === 'w:r'); const insRuns = childElements(ins).filter(c => c.tagName === 'w:r'); if (delRuns.length !== insRuns.length) return false; if (delRuns.length === 0) return false; for (let i = 0; i < delRuns.length; i++) { const delRun = delRuns[i]; const insRun = insRuns[i]; // Compare formatting via canonical rPr comparison const delRPr = findChildByTagName(delRun, 'w:rPr'); const insRPr = findChildByTagName(insRun, 'w:rPr'); if (!areRunPropertiesEqual(delRPr ?? null, insRPr ?? null)) return false; // Compare content structure (text, tabs, breaks, field chars, etc.) const delSig = normalizeRunContentSignature(delRun, true); const insSig = normalizeRunContentSignature(insRun, false); if (delSig !== insSig) return false; } return true; } /** * Suppress no-op del/ins pairs — adjacent w:del + w:ins wrappers where the * content and formatting are identical. These arise from field-adjacent atoms * that are false-positive changes. * * When a no-op is detected, both wrappers are unwrapped, leaving the ins-side * runs as plain (non-tracked) children. The del-side runs are removed. */ export function suppressNoOpChangePairs(root) { function traverse(node) { const children = childElements(node); for (let i = 0; i < children.length - 1;) { const a = children[i]; const b = children[i + 1]; if (a.tagName === 'w:del' && b.tagName === 'w:ins' && isNoOpPair(a, b)) { // Remove the del wrapper and its content entirely node.removeChild(a); // Unwrap the ins wrapper — promote its children to the parent unwrapElement(b); // Re-snapshot children after mutation children.splice(i, 2, ...childElements(node).slice(i)); // Don't increment — recheck from same position continue; } i++; } // Recurse into current children (re-query after mutations) for (const child of childElements(node)) { traverse(child); } } traverse(root); } // ============================================================================= // Bug 2: Merge whitespace-bridged track change siblings (issue #42) // ============================================================================= /** * Narrow whitespace predicate for bridging: returns true only if a w:r element's * visible children are exclusively w:t elements with whitespace-only text content. * Excludes w:tab, w:br, w:cr which have layout significance. */ export function isInlineWhitespaceOnlyRun(run) { if (run.tagName !== 'w:r') return false; let hasVisibleChild = false; for (let i = 0; i < run.childNodes.length; i++) { const child = run.childNodes[i]; if (child.nodeType !== 1) continue; const el = child; if (el.tagName === 'w:rPr') continue; // Only w:t with whitespace-only text is allowed if (el.tagName === 'w:t') { const text = el.textContent ?? ''; if (text.length === 0 || !/^\s+$/.test(text)) return false; hasVisibleChild = true; continue; } // Any other visible element (w:tab, w:br, w:cr, w:fldChar, etc.) disqualifies return false; } return hasVisibleChild; } /** * Merge track-change wrappers (w:del or w:ins) that are separated by a * whitespace-only run. This groups "word-by-word" tracked changes into * contiguous blocks for cleaner presentation. * * For w:del: clones the whitespace run, converts w:t→w:delText, and absorbs * both the whitespace and the second wrapper's children into the first wrapper. * * For w:ins: moves the whitespace run into the first wrapper, then absorbs * the second wrapper's children. * * Both projections (Accept All, Reject All) remain correct because each * wrapper independently contains the whitespace it needs. */ export function mergeWhitespaceBridgedTrackChanges(root) { function traverse(node) { const children = childElements(node); for (let i = 0; i < children.length - 2;) { const a = children[i]; const mid = children[i + 1]; const b = children[i + 2]; // Check: same track-change tag, same author/date, with whitespace-only run between. // Only bridge w:ins and w:moveTo — bridging w:del is unsafe because the // intervening whitespace is Equal content needed by the accept projection. const bridgeableTags = new Set(['w:ins', 'w:moveTo']); if (a.tagName === b.tagName && bridgeableTags.has(a.tagName) && a.getAttribute('w:author') === b.getAttribute('w:author') && a.getAttribute('w:date') === b.getAttribute('w:date') && isInlineWhitespaceOnlyRun(mid)) { // Move the whitespace run into the first wrapper, then absorb second's children a.appendChild(mid); while (b.firstChild) a.appendChild(b.firstChild); node.removeChild(b); // mid was moved into a, b removed from parent — splice both from snapshot children.splice(i + 1, 2); // Don't increment — recheck a with new next sibling continue; } i++; } // Recurse into current children (re-query after mutations) for (const child of childElements(node)) { traverse(child); } } traverse(root); } // ============================================================================= // Bug 2b: Coalesce del/ins pair chains across whitespace (issue #42) // ============================================================================= /** * Convert w:t → w:delText and w:instrText → w:delInstrText within a run, * preserving xml:space attributes. Used for cloning whitespace runs into * w:del wrappers during pair-chain coalescing. */ export function convertRunTextToDelText(run) { for (let i = 0; i < run.childNodes.length; i++) { const child = run.childNodes[i]; if (child.nodeType !== 1) continue; const el = child; if (el.tagName === 'w:t' || el.tagName === 'w:instrText') { const newTag = el.tagName === 'w:t' ? 'w:delText' : 'w:delInstrText'; const newEl = createEl(newTag); // Copy text content while (el.firstChild) newEl.appendChild(el.firstChild); // Copy attributes (including xml:space="preserve") for (let j = 0; j < el.attributes.length; j++) { const attr = el.attributes[j]; newEl.setAttribute(attr.name, attr.value); } run.replaceChild(newEl, el); } } } /** * Coalesce alternating del/ins pair chains separated by whitespace-only runs * into single grouped del + ins wrappers. * * Pattern: [w:del, w:ins, ws-segment..., w:del, w:ins, ws-segment..., w:del, w:ins] * * For each whitespace segment between consecutive [del, ins] pairs: * 1. Clone each ws-run → convert to delText → append to first del * 2. Clone each ws-run → keep as w:t → append to first ins * 3. Move nextDel's children into first del * 4. Move nextIns's children into first ins * 5. Remove original ws-runs, empty nextDel, empty nextIns from parent * * Safety invariants: * - Only bridges when both del AND ins absorb the whitespace (both projections correct) * - Incomplete tail [del, ins, ws, del] (no trailing ins) → stop chain, don't bridge * - All wrappers in chain must share same w:author and w:date */ export function coalesceDelInsPairChains(root) { function traverse(node) { const children = childElements(node); for (let i = 0; i < children.length - 1;) { const firstDel = children[i]; const firstIns = children[i + 1]; // Must start with a [del, ins] pair if (firstDel.tagName !== 'w:del' || firstIns.tagName !== 'w:ins') { i++; continue; } const author = firstDel.getAttribute('w:author'); const date = firstDel.getAttribute('w:date'); // All four must match author/date if (firstIns.getAttribute('w:author') !== author || firstIns.getAttribute('w:date') !== date) { i++; continue; } // Try to extend the chain by absorbing subsequent [ws..., del, ins] triples let cursor = i + 2; // position after firstIns let chainExtended = false; while (cursor < children.length) { // Collect whitespace segment (1..N consecutive whitespace-only runs) const wsStart = cursor; while (cursor < children.length && isInlineWhitespaceOnlyRun(children[cursor])) { cursor++; } const wsEnd = cursor; const wsCount = wsEnd - wsStart; if (wsCount === 0) break; // No whitespace → end of chain // Must have a complete [del, ins] pair after the whitespace if (cursor + 1 >= children.length) break; // Not enough elements const nextDel = children[cursor]; const nextIns = children[cursor + 1]; if (nextDel.tagName !== 'w:del' || nextIns.tagName !== 'w:ins') break; // Author/date must match if (nextDel.getAttribute('w:author') !== author || nextDel.getAttribute('w:date') !== date || nextIns.getAttribute('w:author') !== author || nextIns.getAttribute('w:date') !== date) break; // All conditions met — absorb this [ws..., del, ins] into the first pair // 1. Clone whitespace runs into del (as delText) and ins (as w:t) for (let w = wsStart; w < wsEnd; w++) { const wsRun = children[w]; const delClone = wsRun.cloneNode(true); convertRunTextToDelText(delClone); firstDel.appendChild(delClone); const insClone = wsRun.cloneNode(true); firstIns.appendChild(insClone); } // 2. Move nextDel's children into firstDel while (nextDel.firstChild) firstDel.appendChild(nextDel.firstChild); // 3. Move nextIns's children into firstIns while (nextIns.firstChild) firstIns.appendChild(nextIns.firstChild); // 4. Remove ws-runs, nextDel, nextIns from parent for (let w = wsStart; w < wsEnd; w++) { node.removeChild(children[w]); } node.removeChild(nextDel); node.removeChild(nextIns); // 5. Splice removed elements from children snapshot // Remove wsCount + 2 elements starting at wsStart children.splice(wsStart, wsCount + 2); // Reset cursor to continue checking after firstIns cursor = wsStart; chainExtended = true; } // Advance past the (possibly extended) [del, ins] pair i += chainExtended ? 2 : 1; // If no chain was formed, we only skip the del (i++ already happened above // for the non-chain case), but if it was a chain we skip both del+ins. // Actually: if chain wasn't extended, we need to check if firstDel+firstIns // alone should advance by 2 or by 1. Since they ARE a del+ins pair but // no chain formed, skip both. if (!chainExtended) { i++; // skip the ins too (total i += 2 from the earlier i++) } } // Recurse into current children (re-query after mutations) for (const child of childElements(node)) { traverse(child); } } traverse(root); } //# sourceMappingURL=inPlaceModifier-postprocess.js.map