open-agreements
Version:
Open-source legal template filling CLI and library
326 lines • 14 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 { childElements, findChildByTagName, insertAfterElement } from '../../primitives/index.js';
import { allocateRevisionId, convertToDelText, createEl, findAncestorByTag, getMoveRangeIds, } from './inPlaceModifier-shared.js';
import { cloneUnemittedSourceBookmarkMarkers, insertMarkersBeforeWrapper, } from './inPlaceModifier-bookmarks.js';
import { getAtomRuns, isCollapsedFieldAtom, wrapAsDeleted } from './inPlaceModifier-wrappers.js';
export function getInsertableAtomContentElements(atom, filterRun) {
if (atom.collapsedFieldAtoms && atom.collapsedFieldAtoms.length > 0) {
if (filterRun) {
return atom.collapsedFieldAtoms
.filter((fieldAtom) => {
const run = fieldAtom.sourceRunElement ?? findAncestorByTag(fieldAtom, 'w:r');
return run === filterRun;
})
.map((fieldAtom) => fieldAtom.contentElement);
}
return atom.collapsedFieldAtoms.map((fieldAtom) => fieldAtom.contentElement);
}
return [atom.contentElement];
}
/**
* Clone a source run and replace its non-rPr children with atom content.
*
* This keeps run-level formatting while allowing atom-level fragment insertion.
*
* @param filterRun - When provided, only include content elements belonging
* to this source run (for multi-run collapsed field replay).
*/
export function cloneRunWithAtomContent(sourceRun, atom, filterRun) {
const clonedRun = sourceRun.cloneNode(true);
const retainedChildren = [];
for (const child of childElements(clonedRun)) {
if (child.tagName === 'w:rPr') {
retainedChildren.push(child);
}
}
// Remove all current children from clonedRun
while (clonedRun.firstChild)
clonedRun.removeChild(clonedRun.firstChild);
// Re-append retained rPr children
for (const child of retainedChildren) {
clonedRun.appendChild(child);
}
for (const contentElement of getInsertableAtomContentElements(atom, filterRun)) {
const fragment = contentElement.cloneNode(true);
clonedRun.appendChild(fragment);
}
return clonedRun;
}
/**
* Clone a deleted run from the original document and insert it into the revised document.
*
* For a single-content atom this wraps one cloned run in `<w:del>` and returns
* the `<w:del>` element. For a collapsed-field atom (issue #217), control
* routes to `insertFragmentedDeletedField` which emits multiple sibling
* elements — `w:fldChar` runs at sibling level (unwrapped) and individual
* `<w:del>` wrappers around each payload run — and returns the LAST inserted
* sibling (which may be a `<w:r>` carrying the end fldChar, not a `<w:del>`).
* Callers use the return value purely as the next insertion anchor.
*
* @param deletedAtom - Atom with the deleted content
* @param insertAfterRun - The run to insert after (null to insert at beginning of paragraph)
* @param targetParagraph - The paragraph to insert into
* @param author - Author name
* @param dateStr - Formatted date
* @param state - Revision ID state
* @returns The last inserted sibling element (a `<w:del>` for non-collapsed-field
* atoms; possibly a `<w:r>` for fragmented collapsed-field atoms), or null
* if insertion failed.
*/
export function insertDeletedRun(deletedAtom, insertAfterRun, targetParagraph, author, dateStr, state, context) {
// Get the source run element from the deleted atom
const sourceRun = deletedAtom.sourceRunElement;
if (!sourceRun) {
return null;
}
const runs = getAtomRuns(deletedAtom);
// ECMA-376 Part 4 fragmentation (issue #217): for a collapsed-field atom,
// emit w:fldChar runs at sibling level (unwrapped) and wrap only the
// payload runs (w:instrText, w:t, etc.) in <w:del>. w:fldChar inside
// <w:del> is non-conformant and Word treats it as fatal. Iterates the
// constituent collapsedFieldAtoms (not the deduped source runs) so a
// mixed-run field — where multiple field elements share one source `<w:r>` —
// is correctly split into one cloned run per field element.
if (isCollapsedFieldAtom(deletedAtom)) {
return insertFragmentedDeletedField(deletedAtom, sourceRun, insertAfterRun, targetParagraph, author, dateStr, state, context);
}
// Avoid an unused variable when the collapsed-field branch above is not taken.
void runs;
// Single-run path: wrap the cloned run in one <w:del>.
const id = allocateRevisionId(state);
const del = createEl('w:del', {
'w:id': String(id),
'w:author': author,
'w:date': dateStr,
});
const clonedRun = cloneRunWithAtomContent(sourceRun, deletedAtom);
convertToDelText(clonedRun);
del.appendChild(clonedRun);
// Insert at correct position
if (insertAfterRun) {
insertAfterElement(insertAfterRun, del);
}
else {
// Insert at the beginning of the paragraph (after pPr if present)
const pPr = findChildByTagName(targetParagraph, 'w:pPr');
if (pPr) {
insertAfterElement(pPr, del);
}
else {
targetParagraph.insertBefore(del, targetParagraph.firstChild);
}
}
const sourceMarkers = cloneUnemittedSourceBookmarkMarkers(sourceRun, targetParagraph, state, context);
if (sourceMarkers.length > 0)
insertMarkersBeforeWrapper(del, sourceMarkers);
return del;
}
/**
* Emit a fragmented deletion of a collapsed-field atom: walks the constituent
* source runs in document order, cloning each into the target paragraph as
* either a sibling-level unwrapped run (for `w:fldChar`) or a `<w:del>`-wrapped
* run (for payload runs whose text is renamed to `w:delText` / `w:delInstrText`).
*
* Returns the last sibling element inserted, which the caller uses as the
* next insertion anchor (preserving the contract of `insertDeletedRun`).
*
* @conformance ECMA-376 edition 5, Part 4 § 17.16.5
*
* Rule: `w:delInstrText` MUST appear inside `<w:del>`;
* by extension and by issue #217's deep-research conclusion, `w:fldChar` runs
* stay at sibling level.
*/
export function insertFragmentedDeletedField(deletedAtom, sourceRun, insertAfterRun, targetParagraph, author, dateStr, state, context) {
const fieldAtoms = deletedAtom.collapsedFieldAtoms;
if (!fieldAtoms || fieldAtoms.length === 0)
return null;
let anchor = insertAfterRun;
let firstInserted = null;
let lastInserted = null;
const pPr = findChildByTagName(targetParagraph, 'w:pPr');
const place = (el) => {
if (anchor) {
insertAfterElement(anchor, el);
}
else if (pPr) {
insertAfterElement(pPr, el);
}
else {
targetParagraph.insertBefore(el, targetParagraph.firstChild);
}
if (firstInserted === null)
firstInserted = el;
lastInserted = el;
anchor = el;
};
for (const fieldAtom of fieldAtoms) {
// Each constituent field atom produces its own cloned run carrying exactly
// one content element (fldChar / instrText / t). This is critical for
// mixed-run fields where multiple field elements share a single `<w:r>` in
// the source — we MUST emit them as separate runs so we can fragment
// fldChars out of the `<w:del>` wrapper.
const baseRun = fieldAtom.sourceRunElement ?? findAncestorByTag(fieldAtom, 'w:r') ?? sourceRun;
if (!baseRun)
continue;
const clonedRun = cloneRunWithAtomContent(baseRun, fieldAtom);
const contentTag = fieldAtom.contentElement.tagName;
if (contentTag === 'w:fldChar') {
// Sibling level — unwrapped.
place(clonedRun);
continue;
}
// Payload — wrap in <w:del> and rename w:t→w:delText / w:instrText→w:delInstrText.
convertToDelText(clonedRun);
const id = allocateRevisionId(state);
const del = createEl('w:del', {
'w:id': String(id),
'w:author': author,
'w:date': dateStr,
});
del.appendChild(clonedRun);
place(del);
}
if (firstInserted) {
const sourceMarkers = cloneUnemittedSourceBookmarkMarkers(sourceRun, targetParagraph, state, context);
if (sourceMarkers.length > 0)
insertMarkersBeforeWrapper(firstInserted, sourceMarkers);
}
return lastInserted;
}
/**
* Clone a moved-from run from the original document and insert it into the revised document.
*
* MovedSource atoms have their sourceRunElement in the ORIGINAL tree, but we need to
* insert the content into the REVISED tree. This function clones the run, wraps it with
* <w:moveFrom> and range markers, and inserts at the correct position.
*
* @param atom - Atom with the moved-from content
* @param moveName - Name for linking source and destination
* @param insertAfterRun - The run to insert after (null to insert at beginning of paragraph)
* @param targetParagraph - The paragraph to insert into
* @param author - Author name
* @param dateStr - Formatted date
* @param state - Revision ID state
* @returns The inserted moveFrom element, or null if insertion failed
*/
export function insertMoveFromRun(atom, moveName, insertAfterRun, targetParagraph, author, dateStr, state, context) {
// Get the source run element from the atom (in original tree)
const sourceRun = atom.sourceRunElement;
if (!sourceRun) {
return null;
}
// For collapsed field atoms, replay one cloned run per original source run.
const runs = getAtomRuns(atom);
const clonedRuns = [];
if (runs.length > 1) {
for (const run of runs) {
const clonedRun = cloneRunWithAtomContent(run, atom, run);
convertToDelText(clonedRun);
clonedRuns.push(clonedRun);
}
}
else {
const clonedRun = cloneRunWithAtomContent(sourceRun, atom);
convertToDelText(clonedRun);
clonedRuns.push(clonedRun);
}
// Get or allocate move range IDs
const ids = getMoveRangeIds(state, moveName);
const moveId = allocateRevisionId(state);
// Create range start marker
const rangeStart = createEl('w:moveFromRangeStart', {
'w:id': String(ids.sourceRangeId),
'w:name': moveName,
'w:author': author,
'w:date': dateStr,
});
// Create moveFrom wrapper
const moveFrom = createEl('w:moveFrom', {
'w:id': String(moveId),
'w:author': author,
'w:date': dateStr,
});
// Create range end marker
const rangeEnd = createEl('w:moveFromRangeEnd', {
'w:id': String(ids.sourceRangeId),
});
// Add cloned run(s) as children of moveFrom
for (const clonedRun of clonedRuns) {
moveFrom.appendChild(clonedRun);
}
// Insert at correct position: rangeStart -> moveFrom(run) -> rangeEnd
if (insertAfterRun) {
insertAfterElement(insertAfterRun, rangeStart);
insertAfterElement(rangeStart, moveFrom);
insertAfterElement(moveFrom, rangeEnd);
}
else {
// Insert at the beginning of the paragraph (after pPr if present)
const pPr = findChildByTagName(targetParagraph, 'w:pPr');
if (pPr) {
insertAfterElement(pPr, rangeStart);
insertAfterElement(rangeStart, moveFrom);
insertAfterElement(moveFrom, rangeEnd);
}
else {
targetParagraph.insertBefore(rangeEnd, targetParagraph.firstChild);
targetParagraph.insertBefore(moveFrom, rangeEnd);
targetParagraph.insertBefore(rangeStart, moveFrom);
}
}
const sourceMarkers = cloneUnemittedSourceBookmarkMarkers(sourceRun, targetParagraph, state, context);
if (sourceMarkers.length > 0)
insertMarkersBeforeWrapper(moveFrom, sourceMarkers);
return moveFrom;
}
/**
* Clone a deleted paragraph from the original document and insert it.
*
* @param deletedAtom - Atom representing the deleted paragraph
* @param insertAfterParagraph - Paragraph to insert after (null to insert at body start)
* @param targetBody - The body element to insert into
* @param author - Author name
* @param dateStr - Formatted date
* @param state - Revision ID state
* @returns The inserted paragraph, or null if insertion failed
*/
export function insertDeletedParagraph(deletedAtom, insertAfterParagraph, targetContainer, author, dateStr, state) {
// Get the source paragraph from the deleted atom
const sourceParagraph = deletedAtom.sourceParagraphElement;
if (!sourceParagraph) {
return null;
}
// Clone the paragraph
const clonedParagraph = sourceParagraph.cloneNode(true);
// Wrap runs with w:del (wrapAsDeleted handles w:t -> w:delText conversion internally)
const runs = Array.from(clonedParagraph.getElementsByTagName('w:r'));
for (const run of runs) {
wrapAsDeleted(run, author, dateStr, state);
}
// Insert at correct position, preserving w:tcPr as first child when target is a table cell
if (insertAfterParagraph) {
insertAfterElement(insertAfterParagraph, clonedParagraph);
}
else {
const tcPr = targetContainer.tagName === 'w:tc'
? findChildByTagName(targetContainer, 'w:tcPr')
: null;
if (tcPr) {
insertAfterElement(tcPr, clonedParagraph);
}
else {
targetContainer.insertBefore(clonedParagraph, targetContainer.firstChild);
}
}
return clonedParagraph;
}
// Field-character tag names that should not be split.
export const FIELD_CHAR_TAG_NAMES = new Set([
'w:fldChar', 'w:instrText', 'w:delInstrText',
]);
//# sourceMappingURL=inPlaceModifier-deletion.js.map