@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/revisions/index.js

@@ -0,0 +1,695 @@
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+var __values = (this && this.__values) || function (o) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+    if (m) return m.call(o);
+    return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+};
+import { DetachedObjectError } from '../../core/errors/docx-error';
+import { registerAlwaysOnBodyFeatureBootstrap } from '../document/body-always-on';
+import { FeatureInlineParagraphItem, serializeRun, TextRange, } from '../document/text-range';
+import { elementChildren, isWml, wmlAttr, wmlElement } from '../document/wml';
+import { featureId, registerFeature, registerFeatureBlockHandler, registerFeatureInlineHandler, visitParagraphsInDocumentOrder, } from '../../core/registry/index';
+var REVISIONS = featureId('revisions');
+// TS 3.3: plain string-array literals widen to string[] even with a ReadonlyArray annotation.
+var TRACK_CHANGE_LOCAL_NAMES = [
+    'ins',
+    'del',
+    'moveFrom',
+    'moveTo',
+];
+function wmlAttribute(el, localName) {
+    var __ts33_0;
+    return ((__ts33_0 = el.attributes.find(function (a) { return a.localName === localName && (a.namespaceUri === '' || a.prefix === 'w'); })), __ts33_0 == null ? undefined : __ts33_0.value);
+}
+function parseDecimalId(raw) {
+    if (raw === undefined || !/^\d+$/.test(raw)) {
+        return undefined;
+    }
+    return Number.parseInt(raw, 10);
+}
+var TrackChangeRunOwner = /** @class */ (function () {
+    function TrackChangeRunOwner() {
+        this.runs = [];
+    }
+    TrackChangeRunOwner.prototype.assertAttachedItem = function (target) {
+        if (!(target instanceof TextRange) || this.runs.indexOf(target) < 0) {
+            throw new DetachedObjectError('This run is no longer in its track-change wrapper');
+        }
+    };
+    TrackChangeRunOwner.prototype.appendRun = function () {
+        var run = new TextRange(this);
+        this.runs = __spread(this.runs, [run]);
+        return run;
+    };
+    TrackChangeRunOwner.prototype.listRuns = function () {
+        return this.runs;
+    };
+    TrackChangeRunOwner.prototype.detachRuns = function () {
+        var e_1, _a;
+        try {
+            for (var _b = __values(this.runs), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var run = _c.value;
+                run.detach();
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        this.runs = [];
+    };
+    TrackChangeRunOwner.prototype.hydrateRuns = function (runs) {
+        var e_2, _a;
+        this.runs = runs;
+        try {
+            for (var runs_1 = __values(runs), runs_1_1 = runs_1.next(); !runs_1_1.done; runs_1_1 = runs_1.next()) {
+                var run = runs_1_1.value;
+                run.attach(this);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (runs_1_1 && !runs_1_1.done && (_a = runs_1.return)) _a.call(runs_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    };
+    return TrackChangeRunOwner;
+}());
+function parseTrackChangeChildren(element, runOwner) {
+    var e_3, _a;
+    var items = [];
+    var parsedRuns = [];
+    try {
+        for (var _b = __values(elementChildren(element)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isWml(child, 'r')) {
+                var run = TextRange.fromXml(child, runOwner);
+                parsedRuns.push(run);
+                items.push({ type: 'textRange', run: run });
+                continue;
+            }
+            items.push({ type: 'opaque', xml: child });
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    runOwner.hydrateRuns(parsedRuns);
+    return items;
+}
+function trackChangeAttributes(changeId, author, date) {
+    var attributes = [
+        wmlAttr('id', String(changeId)),
+        wmlAttr('author', author),
+    ];
+    if (date !== undefined && date.length > 0) {
+        attributes.push(wmlAttr('date', date));
+    }
+    return attributes;
+}
+/**
+ * Run- or block-level track change wrapper (`w:ins`, `w:del`, `w:moveFrom`, `w:moveTo`).
+ * @private
+ */
+var RunTrackChange = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function RunTrackChange(kind, changeId, author, date, runOwner, items, preservedXml) {
+        this.kind = kind;
+        this.changeId = changeId;
+        this.author = author;
+        this.date = date;
+        this.runOwner = runOwner;
+        this.items = items;
+        this.preservedXml = preservedXml;
+    }
+    Object.defineProperty(RunTrackChange.prototype, "runs", {
+        /** Nested runs inside the track-change wrapper. */
+        get: function () {
+            return this.runOwner.listRuns();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RunTrackChange.prototype, "type", {
+        /**
+         * Product revision type derived from {@link kind}
+         * (`ins` → insertion, `del` → deletion, move kinds unchanged).
+         */
+        get: function () {
+            return revisionTypeForKind(this.kind);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RunTrackChange.prototype, "text", {
+        /**
+         * Concatenated text of nested modeled runs. Opaque children contribute nothing.
+         */
+        get: function () {
+            return revisionText(this);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    RunTrackChange.prototype.releaseContent = function () {
+        this.runOwner.detachRuns();
+    };
+    RunTrackChange.prototype.toOpenXml = function () {
+        var e_4, _a;
+        if (this.preservedXml !== undefined) {
+            return this.preservedXml;
+        }
+        var children = [];
+        try {
+            for (var _b = __values(this.items), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var item = _c.value;
+                if (item.type === 'textRange') {
+                    children.push(serializeRun(item.run));
+                }
+                else {
+                    children.push(item.xml);
+                }
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        return wmlElement(this.kind, {
+            attributes: trackChangeAttributes(this.changeId, this.author, this.date),
+            children: children,
+        });
+    };
+    return RunTrackChange;
+}());
+export { RunTrackChange };
+/**
+ * Live view over a modeled {@link RunTrackChange} (inline or block).
+ *
+ * Exposes author/date/type/text and readonly nested runs without duplicating state.
+ * Accept/reject is intentionally not part of this MVP.
+ * @private
+ */
+var RevisionRange = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function RevisionRange(change) {
+        this.change = change;
+    }
+    Object.defineProperty(RevisionRange.prototype, "trackChange", {
+        /** Underlying track-change model (same object as body/paragraph feature value). */
+        get: function () {
+            return this.change;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RevisionRange.prototype, "changeId", {
+        /** `@w:id` on the track-change wrapper. */
+        get: function () {
+            return this.change.changeId;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RevisionRange.prototype, "author", {
+        /** `@w:author`. */
+        get: function () {
+            return this.change.author;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RevisionRange.prototype, "date", {
+        /** Optional `@w:date`. */
+        get: function () {
+            return this.change.date;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RevisionRange.prototype, "kind", {
+        /** OOXML local kind (`ins` / `del` / `moveFrom` / `moveTo`). */
+        get: function () {
+            return this.change.kind;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RevisionRange.prototype, "type", {
+        /** Product type mapped from {@link kind}. */
+        get: function () {
+            return this.change.type;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RevisionRange.prototype, "runs", {
+        /** Nested modeled runs (readonly). */
+        get: function () {
+            return this.change.runs;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RevisionRange.prototype, "text", {
+        /** Concatenated nested run text; opaque children omitted. */
+        get: function () {
+            return this.change.text;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return RevisionRange;
+}());
+export { RevisionRange };
+/**
+ * Map track-change kind to product {@link RevisionType}.
+ * @private
+ */
+export function revisionTypeForKind(kind) {
+    switch (kind) {
+        case 'ins':
+            return 'insertion';
+        case 'del':
+            return 'deletion';
+        case 'moveFrom':
+            return 'moveFrom';
+        case 'moveTo':
+            return 'moveTo';
+    }
+}
+/**
+ * Concatenated text of nested runs in a track-change wrapper.
+ * @private
+ */
+export function revisionText(change) {
+    var e_5, _a;
+    var out = '';
+    try {
+        for (var _b = __values(change.runs), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var run = _c.value;
+            out += run.text;
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    return out;
+}
+/**
+ * Thin {@link RevisionRange} over an existing track-change model.
+ * @private
+ */
+export function revisionRangeFor(change) {
+    return new RevisionRange(change);
+}
+/**
+ * Move range start marker (`w:moveFromRangeStart` or `w:moveToRangeStart`).
+ *
+ * @public
+ */
+var MoveRangeStart = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function MoveRangeStart(moveKind, markerId, name, author, date) {
+        this.moveKind = moveKind;
+        this.markerId = markerId;
+        this.name = name;
+        this.author = author;
+        this.date = date;
+    }
+    /**
+     * @private
+     */
+    MoveRangeStart.prototype.releaseContent = function () {
+        return;
+    };
+    MoveRangeStart.prototype.toOpenXml = function () {
+        var localName = this.moveKind === 'moveFrom' ? 'moveFromRangeStart' : 'moveToRangeStart';
+        return wmlElement(localName, {
+            attributes: [
+                wmlAttr('id', String(this.markerId)),
+                wmlAttr('name', this.name),
+                wmlAttr('author', this.author),
+                wmlAttr('date', this.date),
+            ],
+        });
+    };
+    return MoveRangeStart;
+}());
+export { MoveRangeStart };
+/**
+ * Move range end marker (`w:moveFromRangeEnd` or `w:moveToRangeEnd`).
+ *
+ * @private
+ */
+var MoveRangeEnd = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function MoveRangeEnd(moveKind, markerId) {
+        this.moveKind = moveKind;
+        this.markerId = markerId;
+    }
+    /**
+     * @private
+     */
+    MoveRangeEnd.prototype.releaseContent = function () {
+        return;
+    };
+    MoveRangeEnd.prototype.toOpenXml = function () {
+        var localName = this.moveKind === 'moveFrom' ? 'moveFromRangeEnd' : 'moveToRangeEnd';
+        return wmlElement(localName, { attributes: [wmlAttr('id', String(this.markerId))] });
+    };
+    return MoveRangeEnd;
+}());
+export { MoveRangeEnd };
+function parseRunTrackChange(element, kind) {
+    var changeId = parseDecimalId(wmlAttribute(element, 'id'));
+    var author = wmlAttribute(element, 'author');
+    if (changeId === undefined || author === undefined || author.length === 0) {
+        return new RunTrackChange(kind, -1, '', undefined, new TrackChangeRunOwner(), [], element);
+    }
+    var runOwner = new TrackChangeRunOwner();
+    var items = parseTrackChangeChildren(element, runOwner);
+    return new RunTrackChange(kind, changeId, author, wmlAttribute(element, 'date'), runOwner, items, undefined);
+}
+function parseMoveRangeStart(element, moveKind) {
+    var localName = moveKind === 'moveFrom' ? 'moveFromRangeStart' : 'moveToRangeStart';
+    if (!isWml(element, localName)) {
+        return undefined;
+    }
+    var markerId = parseDecimalId(wmlAttribute(element, 'id'));
+    var name = wmlAttribute(element, 'name');
+    var author = wmlAttribute(element, 'author');
+    var date = wmlAttribute(element, 'date');
+    if (markerId === undefined ||
+        name === undefined ||
+        name.length === 0 ||
+        author === undefined ||
+        author.length === 0 ||
+        date === undefined ||
+        date.length === 0) {
+        return undefined;
+    }
+    return new MoveRangeStart(moveKind, markerId, name, author, date);
+}
+function parseMoveRangeEnd(element, moveKind) {
+    var localName = moveKind === 'moveFrom' ? 'moveFromRangeEnd' : 'moveToRangeEnd';
+    if (!isWml(element, localName)) {
+        return undefined;
+    }
+    var markerId = parseDecimalId(wmlAttribute(element, 'id'));
+    if (markerId === undefined) {
+        return undefined;
+    }
+    return new MoveRangeEnd(moveKind, markerId);
+}
+function trackChangesInInlines(inlines) {
+    var e_6, _a;
+    var found = [];
+    try {
+        for (var inlines_1 = __values(inlines), inlines_1_1 = inlines_1.next(); !inlines_1_1.done; inlines_1_1 = inlines_1.next()) {
+            var inline = inlines_1_1.value;
+            if (inline instanceof FeatureInlineParagraphItem && inline.value instanceof RunTrackChange) {
+                found.push(inline.value);
+            }
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (inlines_1_1 && !inlines_1_1.done && (_a = inlines_1.return)) _a.call(inlines_1);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    return found;
+}
+function moveMarkersInInlines(inlines) {
+    var e_7, _a;
+    var found = [];
+    try {
+        for (var inlines_2 = __values(inlines), inlines_2_1 = inlines_2.next(); !inlines_2_1.done; inlines_2_1 = inlines_2.next()) {
+            var inline = inlines_2_1.value;
+            if (!(inline instanceof FeatureInlineParagraphItem)) {
+                continue;
+            }
+            if (inline.value instanceof MoveRangeStart || inline.value instanceof MoveRangeEnd) {
+                found.push(inline.value);
+            }
+        }
+    }
+    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    finally {
+        try {
+            if (inlines_2_1 && !inlines_2_1.done && (_a = inlines_2.return)) _a.call(inlines_2);
+        }
+        finally { if (e_7) throw e_7.error; }
+    }
+    return found;
+}
+var registered = false;
+/**
+ * @private
+ * Test hook */
+export function resetRevisionsFeatureForTests() {
+    registered = false;
+}
+function registerTrackChangeHandler(kind) {
+    registerFeatureInlineHandler({
+        featureId: REVISIONS,
+        wmlLocalName: kind,
+        tryParse: function (element) {
+            if (!isWml(element, kind)) {
+                return undefined;
+            }
+            return parseRunTrackChange(element, kind);
+        },
+    });
+    registerFeatureBlockHandler({
+        featureId: REVISIONS,
+        wmlLocalName: kind,
+        tryParse: function (element, ctx) {
+            void ctx;
+            if (!isWml(element, kind)) {
+                return undefined;
+            }
+            return parseRunTrackChange(element, kind);
+        },
+    });
+}
+/**
+ * @private
+ * Register track-change and move-range handlers. Idempotent. */
+export function registerRevisionsFeature() {
+    var e_8, _a;
+    if (registered) {
+        return;
+    }
+    registered = true;
+    registerFeature({ id: REVISIONS });
+    try {
+        for (var TRACK_CHANGE_LOCAL_NAMES_1 = __values(TRACK_CHANGE_LOCAL_NAMES), TRACK_CHANGE_LOCAL_NAMES_1_1 = TRACK_CHANGE_LOCAL_NAMES_1.next(); !TRACK_CHANGE_LOCAL_NAMES_1_1.done; TRACK_CHANGE_LOCAL_NAMES_1_1 = TRACK_CHANGE_LOCAL_NAMES_1.next()) {
+            var kind = TRACK_CHANGE_LOCAL_NAMES_1_1.value;
+            registerTrackChangeHandler(kind);
+        }
+    }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (TRACK_CHANGE_LOCAL_NAMES_1_1 && !TRACK_CHANGE_LOCAL_NAMES_1_1.done && (_a = TRACK_CHANGE_LOCAL_NAMES_1.return)) _a.call(TRACK_CHANGE_LOCAL_NAMES_1);
+        }
+        finally { if (e_8) throw e_8.error; }
+    }
+    registerFeatureInlineHandler({
+        featureId: REVISIONS,
+        wmlLocalName: 'moveFromRangeStart',
+        tryParse: function (element) {
+            return parseMoveRangeStart(element, 'moveFrom');
+        },
+    });
+    registerFeatureInlineHandler({
+        featureId: REVISIONS,
+        wmlLocalName: 'moveFromRangeEnd',
+        tryParse: function (element) {
+            return parseMoveRangeEnd(element, 'moveFrom');
+        },
+    });
+    registerFeatureInlineHandler({
+        featureId: REVISIONS,
+        wmlLocalName: 'moveToRangeStart',
+        tryParse: function (element) {
+            return parseMoveRangeStart(element, 'moveTo');
+        },
+    });
+    registerFeatureInlineHandler({
+        featureId: REVISIONS,
+        wmlLocalName: 'moveToRangeEnd',
+        tryParse: function (element) {
+            return parseMoveRangeEnd(element, 'moveTo');
+        },
+    });
+}
+/**
+ * Track-change wrappers in a paragraph, in document order.
+ * @private
+ */
+export function runTrackChangesInParagraph(paragraph) {
+    return trackChangesInInlines(paragraph.items.toArray());
+}
+/**
+ * All modeled run/block track-change wrappers in the document body, in document order.
+ *
+ * Walks top-level body blocks so block-level `w:ins`/`w:del` between paragraphs are
+ * included; also visits nested feature paragraphs registered with a block walker.
+ * Move range markers are separate ({@link moveRangeMarkersInParagraph}) — pairing UX deferred.
+ * @private
+ */
+export function runTrackChangesInDocument(document) {
+    var e_9, _a, e_10, _b;
+    var found = [];
+    var seen = new Set();
+    var push = function (change) {
+        if (seen.has(change)) {
+            return;
+        }
+        seen.add(change);
+        found.push(change);
+    };
+    try {
+        for (var _c = __values(document.listBlocks()), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var block = _d.value;
+            if (block.type === 'paragraph') {
+                try {
+                    for (var _e = __values(runTrackChangesInParagraph(block.paragraph)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                        var change = _f.value;
+                        push(change);
+                    }
+                }
+                catch (e_10_1) { e_10 = { error: e_10_1 }; }
+                finally {
+                    try {
+                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                    }
+                    finally { if (e_10) throw e_10.error; }
+                }
+                continue;
+            }
+            if (block.type === 'feature' && block.value instanceof RunTrackChange) {
+                push(block.value);
+            }
+        }
+    }
+    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_9) throw e_9.error; }
+    }
+    // Nested paragraphs inside other feature blocks (tables, SDT, …) when walkers exist.
+    visitParagraphsInDocumentOrder(document, function (paragraph) {
+        var e_11, _a;
+        try {
+            for (var _b = __values(runTrackChangesInParagraph(paragraph)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var change = _c.value;
+                push(change);
+            }
+        }
+        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_11) throw e_11.error; }
+        }
+    });
+    return found;
+}
+/**
+ * WordDocument-order {@link RevisionRange} views for every modeled track change.
+ * @private
+ */
+export function revisionsInDocument(document) {
+    return runTrackChangesInDocument(document).map(function (change) { return new RevisionRange(change); });
+}
+/**
+ * Move range markers in a paragraph, in document order.
+ * @private
+ */
+export function moveRangeMarkersInParagraph(paragraph) {
+    return moveMarkersInInlines(paragraph.items.toArray());
+}
+/**
+ * Whether inline content is a modeled run track change from this module.
+ * @private
+ */
+export function isRunTrackChangeInline(inline) {
+    return (inline instanceof FeatureInlineParagraphItem &&
+        inline.featureId === REVISIONS &&
+        inline.value instanceof RunTrackChange);
+}
+/**
+ * Whether inline content is a modeled move range marker from this module.
+ * @private
+ */
+export function isMoveRangeMarkerInline(inline) {
+    return (inline instanceof FeatureInlineParagraphItem &&
+        inline.featureId === REVISIONS &&
+        (inline.value instanceof MoveRangeStart || inline.value instanceof MoveRangeEnd));
+}
+// Always-on on the main `@syncfusion/ej2-docx` entry: track-change inline/block handlers and
+// move-range markers re-arm after test handler resets via WordDocument.create /
+// fromPackage.
+registerAlwaysOnBodyFeatureBootstrap(function () {
+    registerRevisionsFeature();
+});
+registerRevisionsFeature();