@docx4j/core-ts 0.3.0 → 0.3.1

package/dist/model/content/tracking.mjs

@@ -1,8 +1,9 @@
 import { deepCopy, deepCopyAsSync } from '@docx4j/generated-objects-ts';
-import { createCTTrackChange, createCTRPrChange, createCTRPrChangeRPr, createCTPPrChange, createDelText, createPPr, createParaRPr, createTrPr, } from '@docx4j/generated-objects-ts/factory/org_docx4j_wml';
+import * as el from '@docx4j/generated-objects-ts/el/org_docx4j_wml';
+import { createCTTrackChange, createCTRPrChange, createCTRPrChangeRPr, createCTPPrChange, createCTMarkup, createDelText, createPPr, createParaRPr, createTrPr, } from '@docx4j/generated-objects-ts/factory/org_docx4j_wml';
 import { rPrToElements, rPrFromElements } from '@docx4j/generated-objects-ts/builders/wml';
 import { Docx4JException } from '../../opc/exceptions.mjs';
-import { W_NS, linkParents, walk, typeNameOf, revisionKindOf } from './tree.mjs';
+import { W_NS, linkParents, walk, typeNameOf, revisionKindOf, childrenOf, rowsOf, cellsOf } from './tree.mjs';
 /**
  * `w:id` on these is the one annotation id space (ECMA-376 17.13.5.4): revisions, bookmarks,
  * comment range marks and permissions share it. `w:comment/@w:id` (docx4j `Comments.Comment`,
@@ -294,49 +295,166 @@ export class ChangeTracker {
     }
 }
 /**
- * A whole paragraph inserted: the mark is marked inserted and every run of it goes into a
- * `w:ins`. Word, splitting a paragraph, marks the *first* paragraph's mark instead and leaves
- * the new one the original mark; marking the new paragraph's own mark is the same document once
+ * A whole paragraph inserted: the mark is marked inserted (unless it already is) and every run of it
+ * goes into a `w:ins` - the runs in its hyperlinks, inline content controls, fields and smart tags as
+ * well (`wrapNewRuns`). Word, splitting a paragraph, marks the *first* paragraph's mark instead and
+ * leaves the new one the original mark; marking the new paragraph's own mark is the same document once
  * accepted or rejected and keeps the edit to the element that was added (CR-002 section 13).
  */
 export function trackInsertedParagraph(tracker, p) {
-    tracker.markParagraphInserted(p);
+    var _a, _b;
+    if (!((_b = (_a = p.pPr) === null || _a === void 0 ? void 0 : _a.rPr) === null || _b === void 0 ? void 0 : _b.ins))
+        tracker.markParagraphInserted(p);
     wrapNewRuns(tracker, p);
 }
-/** Every top-level run of the paragraph that is not already in a revision, wrapped in one `w:ins` per group. */
+/**
+ * Every run of the paragraph not already in a revision, wrapped in one `w:ins` per group of touching
+ * runs - at the top level and inside the run-level holders, where Word's form decides (`test/README.md`
+ * check 30, CR-002 section 37 item 7): in a hyperlink or a simple field the `w:ins` goes inside, since
+ * neither can be in one (`CT_RunTrackChange` holds `EG_ContentRunContent` only); a smart tag goes
+ * *into* the `w:ins` with the runs beside it, its own runs plain; an inline content control or custom
+ * XML element keeps the `w:ins` inside and is itself marked inserted (`markHolderInserted`). Before,
+ * only the top level was wrapped, so that rejecting an inserted paragraph left a link's text behind
+ * (the editor's finding on 0.3.0, CR-002 section 37 item 4).
+ */
 export function wrapNewRuns(tracker, p) {
-    const content = p.content;
-    if (!content)
+    wrapInsertedRuns(tracker, p.content, p);
+}
+/** True for what goes into a `w:ins` beside the runs: a run, or a smart tag (Word's form, check 30). */
+function wrapsAsRun(item) {
+    const tn = typeNameOf(item);
+    return (tn === 'org_docx4j_wml.R' || tn === 'org_docx4j_wml.CTSmartTagRun') && revisionKindOf(item) === undefined;
+}
+/**
+ * `wrapNewRuns` over run-level items that are about to go into a paragraph (`Paragraph.insertItemsAt`):
+ * the runs among them, and those in their holders, wrapped in `w:ins`; a content control or custom
+ * XML element among them marked inserted. `parent` is what the items' array belongs to.
+ */
+export function wrapInsertedRuns(tracker, items, parent) {
+    var _a, _b;
+    if (!items)
         return;
-    for (let i = 0; i < content.length; i++) {
-        if (typeNameOf(content[i]) !== 'org_docx4j_wml.R' || revisionKindOf(content[i]) !== undefined)
+    for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        if (revisionKindOf(item) !== undefined)
+            continue; // already a revision
+        if (wrapsAsRun(item)) {
+            let j = i;
+            while (j < items.length && wrapsAsRun(items[j]))
+                j++;
+            const runs = items.splice(i, j - i);
+            const ins = tracker.ins(runs);
+            items.splice(i, 0, ins);
+            linkParents(ins, parent);
+            continue;
+        }
+        const value = item.value;
+        if (typeof value !== 'object' || value === null)
             continue;
-        let j = i;
-        while (j < content.length && typeNameOf(content[j]) === 'org_docx4j_wml.R' && revisionKindOf(content[j]) === undefined)
-            j++;
-        const runs = content.splice(i, j - i);
-        const ins = tracker.ins(runs);
-        content.splice(i, 0, ins);
-        linkParents(ins, p);
+        const holder = (_a = value.sdtContent) !== null && _a !== void 0 ? _a : value;
+        if (HOLDER_TYPES.has((_b = typeNameOf(item)) !== null && _b !== void 0 ? _b : '')) {
+            const before = items.length;
+            markHolderInserted(tracker, item, items, () => wrapInsertedRuns(tracker, childrenOf(value), holder));
+            i += items.length - before;
+            continue;
+        }
+        wrapInsertedRuns(tracker, childrenOf(value), holder);
     }
 }
-/** A whole table inserted: every row is marked inserted and every paragraph in it is an insertion. */
+/** A whole table inserted: every row is marked inserted and everything in its cells is an insertion (`trackInsertedBlocks`). */
 export function trackInsertedTable(tracker, tbl) {
-    var _a, _b, _c;
-    for (const row of ((_a = tbl.content) !== null && _a !== void 0 ? _a : [])) {
-        if (typeNameOf(row) !== 'org_docx4j_wml.Tr')
-            continue;
-        const tr = row.value;
-        tracker.markRowInserted(tr);
-        for (const cell of ((_b = tr.content) !== null && _b !== void 0 ? _b : [])) {
-            if (typeNameOf(cell) !== 'org_docx4j_wml.Tc')
-                continue;
-            for (const block of ((_c = cell.value.content) !== null && _c !== void 0 ? _c : [])) {
-                if (typeNameOf(block) === 'org_docx4j_wml.P')
-                    trackInsertedParagraph(tracker, block.value);
-            }
-        }
+    var _a;
+    for (const row of rowsOf(tbl)) {
+        const tr = row.element.value;
+        if (!((_a = tr.trPr) === null || _a === void 0 ? void 0 : _a.ins))
+            tracker.markRowInserted(tr);
+        for (const cell of cellsOf(tr))
+            trackInsertedBlocks(tracker, childrenOf(cell.element.value));
+    }
+}
+/**
+ * Block content inserted, whatever it holds: a paragraph (`trackInsertedParagraph`), a table
+ * (`trackInsertedTable`: rows inside row-level content controls, nested tables in its cells), and a
+ * block-level content control's or custom XML element's content, recursively, the element itself
+ * marked inserted (`markHolderInserted`; `owner` is the array holding `block`, which takes the
+ * markers). What `Body.insertElement` and `Table.addRows` track new content by (CR-002 section 37).
+ */
+export function trackInsertedBlock(tracker, block, owner) {
+    const tn = typeNameOf(block);
+    if (tn === 'org_docx4j_wml.P')
+        trackInsertedParagraph(tracker, block.value);
+    else if (tn === 'org_docx4j_wml.Tbl')
+        trackInsertedTable(tracker, block.value);
+    else if (typeof block.value !== 'object' || block.value === null)
+        return;
+    else if (HOLDER_TYPES.has(tn !== null && tn !== void 0 ? tn : ''))
+        markHolderInserted(tracker, block, owner, () => trackInsertedBlocks(tracker, childrenOf(block.value)));
+    else
+        trackInsertedBlocks(tracker, childrenOf(block.value));
+}
+/** `trackInsertedBlock` over every item of a list, which is their owner. */
+export function trackInsertedBlocks(tracker, items) {
+    if (!items)
+        return;
+    for (let i = 0; i < items.length; i++) {
+        const before = items.length;
+        trackInsertedBlock(tracker, items[i], items);
+        i += items.length - before; // past the markers just put in
+    }
+}
+/**
+ * The elements Word marks inserted as a whole with `w:customXmlInsRangeStart` / `End`: a content
+ * control or a custom XML element (check 30 measured the control at run and block level; a smart tag
+ * goes into the `w:ins` instead, and a hyperlink or field has no form of its own). Row- and cell-level
+ * ones are listed for the reader: `trackInsertedTable` walks through them to the rows and cells, and
+ * does not mark them.
+ */
+export const HOLDER_TYPES = new Set([
+    'org_docx4j_wml.SdtRun', 'org_docx4j_wml.SdtBlock', 'org_docx4j_wml.CTSdtRow', 'org_docx4j_wml.CTSdtCell',
+    'org_docx4j_wml.CTCustomXmlRun', 'org_docx4j_wml.CTCustomXmlBlock', 'org_docx4j_wml.CTCustomXmlRow', 'org_docx4j_wml.CTCustomXmlCell',
+]);
+/** The list a holder's content is in (`w:sdtContent`'s for a control, its own for custom XML), created when absent. */
+export function holderItemsOf(value) {
+    var _a, _b;
+    var _c;
+    const v = value;
+    if (v.sdtContent)
+        return ((_a = (_c = v.sdtContent).content) !== null && _a !== void 0 ? _a : (_c.content = []));
+    if ('element' in v)
+        return ((_b = v.content) !== null && _b !== void 0 ? _b : (v.content = [])); // w:customXml carries w:element
+    return undefined;
+}
+/**
+ * A content control or custom XML element inserted under tracking, as Word writes it (check 30): a
+ * `w:customXmlInsRangeStart` before the element with its `w:customXmlInsRangeEnd` first inside its
+ * content, and a second start last inside with its end after the element. Rejecting takes the element
+ * away and leaves its content where it stood (`TrackedChange`'s `holder` target); without the markers
+ * an element holding only an insertion reads as one that was there before and was typed into, which
+ * rejecting keeps (check 30, existing-control-typed). `inside` tracks the content between the two
+ * pairs, so that the ids run in document order as Word's do.
+ */
+export function markHolderInserted(tracker, holder, owner, inside) {
+    var _a;
+    const at = owner.indexOf(holder);
+    const items = holderItemsOf(holder.value);
+    if (at < 0 || !items) {
+        inside();
+        return;
     }
+    const value = holder.value;
+    const first = tracker.markup();
+    const outerStart = el.customXmlInsRangeStart(createCTTrackChange(first));
+    const innerEnd = el.customXmlInsRangeEnd(createCTMarkup({ id: first.id }));
+    owner.splice(at, 0, outerStart);
+    items.unshift(innerEnd);
+    inside();
+    const second = tracker.markup();
+    const innerStart = el.customXmlInsRangeStart(createCTTrackChange(second));
+    const outerEnd = el.customXmlInsRangeEnd(createCTMarkup({ id: second.id }));
+    items.push(innerStart);
+    owner.splice(owner.indexOf(holder) + 1, 0, outerEnd);
+    linkParents([outerStart, outerEnd], value.PARENT);
+    linkParents([innerEnd, innerStart], (_a = value.sdtContent) !== null && _a !== void 0 ? _a : value);
 }
 /** The paragraph mark's run properties (`w:pPr/w:rPr`), created when absent. */
 export function paraRPrOf(p) {

package/dist/packages/WordprocessingMLPackage.d.mts

@@ -81,6 +81,12 @@ export declare class WordprocessingMLPackage extends OpcPackage implements Track
      * `styles.ensure` (CR-002 section 25). `saveTo` ensures them; nothing is read before then.
      */
     private requiredStyles;
+    /**
+     * Comments whose anchored text went with a rejected insertion or an accepted deletion: their
+     * markers are gone, their entries go from the comment parts when the comments are next read or
+     * the package is saved (check 32; `TrackedChange`). An extension.
+     */
+    readonly pendingCommentRemovals: Set<number>;
     /**
      * The parts `seedAnnotationIds()` has read, with what it read: `true` for a part still holding its
      * source, whose bytes cannot change, and otherwise the bytes that were set, which stay the same

package/dist/packages/WordprocessingMLPackage.mjs

@@ -15,6 +15,7 @@ import { DefaultXPathEngine } from '../model/customxml/xpath.mjs';
 import { ChangeTracker, highestAnnotationId } from '../model/content/tracking.mjs';
 import { NumberingFacade } from '../model/content/List.mjs';
 import { StylesFacade } from '../model/content/stylesFacade.mjs';
+import { flushPendingCommentRemovals } from '../model/content/Comment.mjs';
 import { PropertyResolver } from '../model/properties/PropertyResolver.mjs';
 import { PropertyResolverNotCreatedException } from '../opc/exceptions.mjs';
 import { XmlPart } from '../parts/XmlPart.mjs';
@@ -81,6 +82,12 @@ export class WordprocessingMLPackage extends OpcPackage {
          * `styles.ensure` (CR-002 section 25). `saveTo` ensures them; nothing is read before then.
          */
         this.requiredStyles = new Set();
+        /**
+         * Comments whose anchored text went with a rejected insertion or an accepted deletion: their
+         * markers are gone, their entries go from the comment parts when the comments are next read or
+         * the package is saved (check 32; `TrackedChange`). An extension.
+         */
+        this.pendingCommentRemovals = new Set();
         /**
          * The parts `seedAnnotationIds()` has read, with what it read: `true` for a part still holding its
          * source, whose bytes cannot change, and otherwise the bytes that were set, which stay the same
@@ -497,6 +504,8 @@ export class WordprocessingMLPackage extends OpcPackage {
             return;
         target.requireStyles(this.requiredStyles);
         target.author = { ...this.author };
+        for (const id of this.pendingCommentRemovals)
+            target.pendingCommentRemovals.add(id);
         target.trackedChangeDate = this.trackedChangeDate;
         target.fonts.defaultTheme = this.fonts.defaultTheme;
         target.xpathEngine = this.xpathEngine;
@@ -505,6 +514,8 @@ export class WordprocessingMLPackage extends OpcPackage {
         var _a;
         if (this.trackingPending)
             await this.setChangeTrackingMode((_a = this.trackingMode) !== null && _a !== void 0 ? _a : 'Off');
+        if (this.pendingCommentRemovals.size > 0)
+            await flushPendingCommentRemovals(await this.getBody());
         if (this.requiredStyles.size > 0) {
             await this.styles.ensure([...this.requiredStyles]);
             this.requiredStyles.clear();

package/dist/parts/wml/commentStyles.d.mts

@@ -0,0 +1,3 @@
+import type * as wml from '@docx4j/generated-objects-ts/modules/org_docx4j_wml';
+/** Fresh copies of the two definitions, each call. */
+export declare function commentStyles(): wml.Style[];

package/dist/parts/wml/commentStyles.mjs

@@ -0,0 +1,25 @@
+import * as wmlFactory from '@docx4j/generated-objects-ts/factory/org_docx4j_wml';
+import { COMMENT_REFERENCE_STYLE, COMMENT_TEXT_STYLE } from '../../model/content/comments.mjs';
+/** Fresh copies of the two definitions, each call. */
+export function commentStyles() {
+    return [
+        wmlFactory.createStyle({
+            type: 'paragraph', styleId: COMMENT_TEXT_STYLE,
+            name: wmlFactory.createStyleName({ val: 'annotation text' }),
+            basedOn: wmlFactory.createStyleBasedOn({ val: 'Normal' }),
+            uiPriority: wmlFactory.createStyleUiPriority({ val: 99 }),
+            semiHidden: wmlFactory.createBooleanDefaultTrue(),
+            unhideWhenUsed: wmlFactory.createBooleanDefaultTrue(),
+            rPr: wmlFactory.createRPr({ sz: wmlFactory.createHpsMeasure({ val: 20 }), szCs: wmlFactory.createHpsMeasure({ val: 20 }) }),
+        }),
+        wmlFactory.createStyle({
+            type: 'character', styleId: COMMENT_REFERENCE_STYLE,
+            name: wmlFactory.createStyleName({ val: 'annotation reference' }),
+            basedOn: wmlFactory.createStyleBasedOn({ val: 'DefaultParagraphFont' }),
+            uiPriority: wmlFactory.createStyleUiPriority({ val: 99 }),
+            semiHidden: wmlFactory.createBooleanDefaultTrue(),
+            unhideWhenUsed: wmlFactory.createBooleanDefaultTrue(),
+            rPr: wmlFactory.createRPr({ sz: wmlFactory.createHpsMeasure({ val: 16 }), szCs: wmlFactory.createHpsMeasure({ val: 16 }) }),
+        }),
+    ];
+}

package/dist/parts/wml/comments.mjs

@@ -9,6 +9,7 @@ import { COMMENT_REFERENCE_STYLE, COMMENT_TEXT_STYLE, setCommentPartsAccess, dat
 import { dateOf } from '../../model/content/tracking.mjs';
 // Loaded for its side effect: the Comment views register themselves with the content API.
 import '../../model/content/Comment.mjs';
+import { commentStyles } from './commentStyles.mjs';
 /** The comment parts of one document. */
 class DocumentCommentParts {
     constructor(main, commentsPart, comments, author) {
@@ -180,28 +181,9 @@ async function ensureCommentStyles(main) {
         linkParents(style, styles);
         (_a = pkg === null || pkg === void 0 ? void 0 : pkg.refreshPropertyResolver) === null || _a === void 0 ? void 0 : _a.call(pkg);
     };
-    if (!list.some((s) => s.styleId === COMMENT_TEXT_STYLE)) {
-        add(wmlFactory.createStyle({
-            type: 'paragraph', styleId: COMMENT_TEXT_STYLE,
-            name: wmlFactory.createStyleName({ val: 'annotation text' }),
-            basedOn: wmlFactory.createStyleBasedOn({ val: 'Normal' }),
-            uiPriority: wmlFactory.createStyleUiPriority({ val: 99 }),
-            semiHidden: wmlFactory.createBooleanDefaultTrue(),
-            unhideWhenUsed: wmlFactory.createBooleanDefaultTrue(),
-            rPr: wmlFactory.createRPr({ sz: wmlFactory.createHpsMeasure({ val: 20 }), szCs: wmlFactory.createHpsMeasure({ val: 20 }) }),
-        }));
-    }
-    if (!list.some((s) => s.styleId === COMMENT_REFERENCE_STYLE)) {
-        add(wmlFactory.createStyle({
-            type: 'character', styleId: COMMENT_REFERENCE_STYLE,
-            name: wmlFactory.createStyleName({ val: 'annotation reference' }),
-            basedOn: wmlFactory.createStyleBasedOn({ val: 'DefaultParagraphFont' }),
-            uiPriority: wmlFactory.createStyleUiPriority({ val: 99 }),
-            semiHidden: wmlFactory.createBooleanDefaultTrue(),
-            unhideWhenUsed: wmlFactory.createBooleanDefaultTrue(),
-            rPr: wmlFactory.createRPr({ sz: wmlFactory.createHpsMeasure({ val: 16 }), szCs: wmlFactory.createHpsMeasure({ val: 16 }) }),
-        }));
-    }
+    for (const style of commentStyles())
+        if (!list.some((s) => s.styleId === style.styleId))
+            add(style);
 }
 setCommentPartsAccess({
     async load(body) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@docx4j/core-ts",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "docx4j-core for TypeScript: Open Packaging (docx/pptx/xlsx zip and flat OPC), typed parts and relationships, style, numbering and font resolution over @docx4j/generated-objects-ts. Node, browsers, Word add-ins.",
   "type": "module",
   "main": "./dist/index.mjs",