open-agreements
Version:
Open-source legal template filling CLI and library
265 lines • 11.8 kB
JavaScript
/**
* 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 { getDirectContentElements, splitRunAtVisibleOffset, visibleLengthForEl } from '../../primitives/index.js';
import { warn } from './debug.js';
import { FIELD_CHAR_TAG_NAMES } from './inPlaceModifier-deletion.js';
export function atomContentVisibleLength(el) {
const tag = el.tagName;
if (tag === 'w:t')
return (el.textContent ?? '').length;
if (tag === 'w:tab' || tag === 'w:br')
return 1;
// w:cr is treated as zero-length (consistent with visibleLengthForEl which also returns 0).
return 0;
}
/**
* Pre-split revised-tree runs that contain atoms with mixed correlation statuses.
*
* Without this, `handleInserted` wraps the entire run with `<w:ins>`, destroying
* Equal content in the same run. After splitting, each fragment is a separate
* `<w:r>` and existing per-status handlers work without modification.
*
* Safety: wrapped in try/catch per run group. If any DOM operation fails, the
* run is skipped and the existing fallback-to-rebuild architecture handles it.
*/
export function preSplitMixedStatusRuns(mergedAtoms) {
// Group atoms by their sourceRunElement (revised-tree runs only).
const runGroups = new Map();
for (const atom of mergedAtoms) {
if (!atom.sourceRunElement)
continue;
// Skip original-tree atoms — Deleted/MovedSource runs are cloned, not wrapped.
if (atom.correlationStatus === CorrelationStatus.Deleted ||
atom.correlationStatus === CorrelationStatus.MovedSource)
continue;
// Skip collapsed field atoms (multi-run field sequences).
if (atom.collapsedFieldAtoms && atom.collapsedFieldAtoms.length > 0)
continue;
// Skip field character elements — semantically fragile.
if (FIELD_CHAR_TAG_NAMES.has(atom.contentElement.tagName))
continue;
const group = runGroups.get(atom.sourceRunElement);
if (group) {
group.push(atom);
}
else {
runGroups.set(atom.sourceRunElement, [atom]);
}
}
for (const [run, atoms] of runGroups) {
// Early check: skip single-status runs before any DOM work.
const statuses = new Set(atoms.map((a) => a.correlationStatus));
if (statuses.size <= 1)
continue;
// Guard: skip runs already detached from the tree.
if (!run.parentNode)
continue;
try {
// Compute the run's actual visible length via DOM traversal.
const contentEls = getDirectContentElements(run);
let runVisibleLength = 0;
for (const cel of contentEls) {
runVisibleLength += visibleLengthForEl(cel);
}
// Cross-run safety: if sum of atom lengths exceeds run visible length,
// this group contains a cross-run merged atom (passes 3/4). Skip it.
let sumAtomLengths = 0;
for (const atom of atoms) {
sumAtomLengths += atomContentVisibleLength(atom.contentElement);
}
if (sumAtomLengths > runVisibleLength)
continue;
const spans = [];
let offset = 0;
for (const atom of atoms) {
const len = atomContentVisibleLength(atom.contentElement);
const lastSpan = spans[spans.length - 1];
if (lastSpan && lastSpan.status === atom.correlationStatus) {
lastSpan.length += len;
lastSpan.atoms.push(atom);
}
else {
spans.push({
status: atom.correlationStatus,
startOffset: offset,
length: len,
atoms: [atom],
});
}
offset += len;
}
// If only one span after grouping, no split needed.
if (spans.length <= 1)
continue;
// Collect split points: startOffset of each span after the first.
const splitPoints = [];
for (let i = 1; i < spans.length; i++) {
const pt = spans[i].startOffset;
// Filter out degenerate split points at boundaries.
if (pt > 0 && pt < runVisibleLength) {
splitPoints.push(pt);
}
}
if (splitPoints.length === 0)
continue;
// Split DOM run right-to-left to keep earlier offsets valid.
const rightFragments = [];
for (let i = splitPoints.length - 1; i >= 0; i--) {
const { right } = splitRunAtVisibleOffset(run, splitPoints[i]);
rightFragments.push(right);
}
// Map fragments: [originalRun (leftmost), ...reverse(rightFragments)]
// After R-to-L splits, rightFragments are in reverse document order.
const fragments = [run, ...rightFragments.reverse()];
// Update atom sourceRunElement pointers to the correct fragment.
// Each span maps to one fragment in order.
for (let i = 0; i < spans.length; i++) {
const fragment = fragments[i];
if (!fragment)
continue;
for (const atom of spans[i].atoms) {
atom.sourceRunElement = fragment;
}
}
}
catch (_err) {
// DOM operation failed — skip this run. The existing fallback-to-rebuild
// architecture will handle it if the overall safety check fails.
warn('preSplitMixedStatusRuns', `Skipping run split due to error: ${_err}`);
}
}
}
/**
* Pre-split revised-tree runs where word-split Equal atoms from the same run
* are interleaved with Deleted/MovedSource atoms in the merged atom list.
*
* `preSplitMixedStatusRuns` handles the case where a single run contains atoms
* with DIFFERENT statuses (e.g., some Equal and some Inserted). But it cannot
* handle the case where ALL atoms from a run are Equal yet Deleted atoms (from
* the original tree) are interspersed between them in the merged list.
*
* Without this split, `handleEqual` sees all Equal atoms pointing to the same
* run and skips position advancement (the `lastRevisedRunAnchor` optimization).
* Subsequent `handleDeleted` calls then insert deleted content at the wrong
* position because the cursor never advanced past the shared run.
*
* This function detects interleaved sequences and splits the DOM run so each
* contiguous group of Equal atoms gets its own run fragment. The handlers then
* advance the cursor correctly across fragments.
*/
export function preSplitInterleavedWordRuns(mergedAtoms) {
const runToGroups = new Map();
// Track cumulative offset per run (sums visible lengths of atoms seen so far)
const runToOffset = new Map();
let lastRevisedRun = null;
for (const atom of mergedAtoms) {
// Skip atoms from the original tree (Deleted/MovedSource have runs in the
// original tree, not the revised tree).
if (atom.correlationStatus === CorrelationStatus.Deleted ||
atom.correlationStatus === CorrelationStatus.MovedSource) {
// A Deleted/MovedSource atom between Equal atoms from the same run
// creates an interleaving gap. Mark this by clearing lastRevisedRun
// so the next Equal atom from the same run starts a new group.
lastRevisedRun = null;
continue;
}
const run = atom.sourceRunElement;
if (!run)
continue;
// Skip collapsed field atoms — multi-run field sequences.
if (atom.collapsedFieldAtoms && atom.collapsedFieldAtoms.length > 0)
continue;
// Skip field character elements — semantically fragile.
if (FIELD_CHAR_TAG_NAMES.has(atom.contentElement.tagName))
continue;
const atomLen = atomContentVisibleLength(atom.contentElement);
const currentOffset = runToOffset.get(run) ?? 0;
runToOffset.set(run, currentOffset + atomLen);
const groups = runToGroups.get(run);
if (!groups) {
// First time seeing this run — create initial group.
runToGroups.set(run, [{
startOffset: currentOffset,
length: atomLen,
atoms: [atom],
}]);
lastRevisedRun = run;
continue;
}
if (lastRevisedRun === run) {
// Contiguous with the previous atom from the same run — extend group.
const lastGroup = groups[groups.length - 1];
lastGroup.length += atomLen;
lastGroup.atoms.push(atom);
}
else {
// Gap detected (a Deleted/MovedSource atom intervened). Start new group.
groups.push({
startOffset: currentOffset,
length: atomLen,
atoms: [atom],
});
}
lastRevisedRun = run;
}
// Now split runs that have more than one group.
for (const [run, groups] of runToGroups) {
if (groups.length <= 1)
continue;
// Guard: skip runs already detached from the tree.
if (!run.parentNode)
continue;
try {
// Compute actual visible length of the DOM run.
const contentEls = getDirectContentElements(run);
let runVisibleLength = 0;
for (const cel of contentEls) {
runVisibleLength += visibleLengthForEl(cel);
}
// Safety: if the sum of atom lengths exceeds run visible length,
// something is off (cross-run atoms, etc.). Skip.
let sumAtomLengths = 0;
for (const group of groups) {
sumAtomLengths += group.length;
}
if (sumAtomLengths > runVisibleLength)
continue;
// Collect split points: the startOffset of each group after the first.
const splitPoints = [];
for (let i = 1; i < groups.length; i++) {
const pt = groups[i].startOffset;
if (pt > 0 && pt < runVisibleLength) {
splitPoints.push(pt);
}
}
if (splitPoints.length === 0)
continue;
// Split DOM run right-to-left to keep earlier offsets valid.
const rightFragments = [];
for (let i = splitPoints.length - 1; i >= 0; i--) {
const { right } = splitRunAtVisibleOffset(run, splitPoints[i]);
rightFragments.push(right);
}
// Map fragments: [originalRun (leftmost), ...reverse(rightFragments)]
const fragments = [run, ...rightFragments.reverse()];
// Update atom sourceRunElement pointers to the correct fragment.
for (let i = 0; i < groups.length; i++) {
const fragment = fragments[i];
if (!fragment)
continue;
for (const atom of groups[i].atoms) {
atom.sourceRunElement = fragment;
}
}
}
catch (_err) {
warn('preSplitInterleavedWordRuns', `Skipping run split due to error: ${_err}`);
}
}
}
//# sourceMappingURL=inPlaceModifier-presplit.js.map