UNPKG

open-agreements

Version:

Open-source legal template filling CLI and library

171 lines • 6.81 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 { EMPTY_PARAGRAPH_TAG } from '../../atomizer.js'; import { childElements, getLeafText } from '../../primitives/index.js'; import { findAncestorByTag } from './inPlaceModifier-shared.js'; // @lean-segment: container-topology // Lean traceability anchor — cited by verification/lean/LeanSpike/Spec.lean for // the container-topology-mismatch failure mode that makes the inplace candidate // partial. Grep this anchor instead of relying on line numbers (refactor-stable). export class ContainerResolutionError extends Error { constructor(message) { super(message); this.name = 'ContainerResolutionError'; } } /** * Compute the structural path from a paragraph to the document body. * Walks `parentNode` from the paragraph, recording {tag, index} for each * structural container (w:tc, w:tr, w:tbl). Stops at w:body. * Returns innermost-first order. * * Uses original-tree nodes — safe because only the revised tree is mutated. */ export function getContainerPath(paragraph) { const path = []; let current = paragraph.parentNode; while (current && current.tagName) { const el = current; if (el.tagName === 'w:body') break; if (el.tagName === 'w:tc' || el.tagName === 'w:tr' || el.tagName === 'w:tbl') { const parent = el.parentNode; if (parent) { let index = 0; let sibling = el.previousSibling; while (sibling) { if (sibling.nodeType === 1 && sibling.tagName === el.tagName) { index++; } sibling = sibling.previousSibling; } path.push({ tag: el.tagName, index }); } } current = el.parentNode; } return path; } /** * Resolve a container path in the revised tree. * Walks the path in reverse (outermost → innermost) from `body`. * Returns the deepest container (typically w:tc), or null on mismatch. */ export function resolveContainerInRevised(path, body) { if (path.length === 0) return null; let current = body; // Walk outermost to innermost (path is innermost-first, so reverse) for (let i = path.length - 1; i >= 0; i--) { const step = path[i]; const children = childElements(current).filter(c => c.tagName === step.tag); const child = children[step.index]; if (!child) return null; // Structural mismatch current = child; } return current; } /** * Validate that the revised tree has compatible topology at the given path. * Checks row count and cell count match at the target position. * Returns false if there's a structural mismatch (row/cell additions, gridSpan divergence). */ export function validateContainerTopology(path, body) { if (path.length === 0) return true; // Body-level, always valid let current = body; for (let i = path.length - 1; i >= 0; i--) { const step = path[i]; const children = childElements(current).filter(c => c.tagName === step.tag); if (step.index >= children.length) return false; current = children[step.index]; } return true; } /** * Find the correct container and insertion anchor for a deleted/moved-source atom. * * For body-level atoms, returns ctx.body with the global lastProcessedParagraph anchor. * For table-cell atoms, maps from the original tree container to the revised tree container * by structural position, and uses the per-container anchor from lastParaByContainer. * * Returns null if container resolution fails (topology mismatch) — caller must throw * ContainerResolutionError to trigger rebuild fallback. */ export function findTargetContainerForAtom(atom, ctx) { // 1. Check if atom was in a table cell (original tree ancestors) const sourceTc = findAncestorByTag(atom, 'w:tc'); if (!sourceTc) { // Body-level paragraph — use global anchor (current behavior, correct) return { container: ctx.body, insertAfter: ctx.lastProcessedParagraph }; } // 2. Compute structural path from original tree const sourcePara = atom.sourceParagraphElement; if (!sourcePara) { return null; // Can't resolve → force rebuild } const path = getContainerPath(sourcePara); if (path.length === 0) { // Paragraph has a w:tc ancestor but path is empty — shouldn't happen return null; } // 3. Validate topology match before resolving if (!validateContainerTopology(path, ctx.body)) { return null; // Structural mismatch → force rebuild } // 4. Resolve container in revised tree const revisedContainer = resolveContainerInRevised(path, ctx.body); if (!revisedContainer) { return null; // Resolution failed → force rebuild } // 5. Find container-local insertion anchor const anchor = ctx.lastParaByContainer.get(revisedContainer) ?? null; return { container: revisedContainer, insertAfter: anchor }; } /** * Determine whether an atom is "whitespace-only" for paragraph-level classification. * * We treat pure whitespace runs/tabs/breaks as ignorable noise, because LCS alignment * can mark them Equal even when a whole paragraph was inserted/deleted. If we don't * ignore them, Word can end up with a stub paragraph after Accept/Reject All. */ export function isWhitespaceAtom(atom) { const el = atom.contentElement; if (el.tagName === EMPTY_PARAGRAPH_TAG) return true; if (el.tagName === 'w:t') return ((getLeafText(el) ?? '').trim() === ''); return el.tagName === 'w:tab' || el.tagName === 'w:br' || el.tagName === 'w:cr'; } /** * Returns true if every non-empty atom in this paragraph is of the specified status, * ignoring whitespace-only atoms. * * Mirrors the rebuild reconstructor's whole-paragraph classification so that inplace * output behaves the same under Word's Accept/Reject All. */ export function isEntireParagraphAtomsWithStatus(atoms, status) { let sawAnyContent = false; let sawTargetStatus = false; for (const atom of atoms) { const el = atom.contentElement; if (el.tagName === EMPTY_PARAGRAPH_TAG) continue; sawAnyContent = true; if (atom.correlationStatus === status) { sawTargetStatus = true; continue; } if (isWhitespaceAtom(atom)) continue; return false; } return sawAnyContent && sawTargetStatus; } //# sourceMappingURL=inPlaceModifier-containers.js.map