@syncfusion/ej2-docx 0.0.0-stage → 35.1.39

package/src/features/document/body-item-collection.js

@@ -0,0 +1,440 @@
+import { DetachedObjectError } from '../../core/errors/docx-error';
+import { bindAltChunkDocument } from './alt-chunk';
+import { bodyItemToBlock, isSupportedBodyItem, projectBlockToBodyItem, } from './body-item-adapters';
+import { Paragraph } from './paragraph';
+function bindDocumentToFeatureBlock(value, document) {
+    if (typeof value !== 'object' || value === null || !('bindDocument' in value)) {
+        return;
+    }
+    var bindDocument = value.bindDocument;
+    if (typeof bindDocument === 'function') {
+        bindDocument.call(value, document);
+    }
+}
+function releaseFeatureBlock(value) {
+    if (typeof value !== 'object' || value === null || !('releaseContent' in value)) {
+        return;
+    }
+    var release = value.releaseContent;
+    if (typeof release === 'function') {
+        release.call(value);
+    }
+}
+function blocksEqual(a, b) {
+    if (a.type !== b.type) {
+        return false;
+    }
+    if (a.type === 'paragraph' && b.type === 'paragraph') {
+        return a.paragraph === b.paragraph;
+    }
+    if (a.type === 'feature' && b.type === 'feature') {
+        return a.featureId === b.featureId && a.value === b.value;
+    }
+    if (a.type === 'opaque' && b.type === 'opaque') {
+        return a.xml === b.xml;
+    }
+    return false;
+}
+function findBlockIndexForBodyItem(blocks, item) {
+    for (var i = 0; i < blocks.length; i += 1) {
+        var projected = projectBlockToBodyItem(blocks[i]);
+        if (projected === item) {
+            return i;
+        }
+    }
+    return -1;
+}
+/**
+ * Managed mutable collection of public {@link BodyItem} instances for a body.
+ *
+ * Projects from the body's internal ordered store. Unsupported markup remains
+ * in the package but is not listed here. Index access uses own numeric
+ * properties (no `Proxy`); identity at a given index is stable across reads.
+ *
+ * @public
+ */
+var BodyItemCollection = /** @class */ (function () {
+    /** @private */
+    function BodyItemCollection(host) {
+        this.cachedLength = 0;
+        this.host = host;
+        this.rebuildIndexProperties();
+    }
+    Object.defineProperty(BodyItemCollection.prototype, "count", {
+        /**
+         * Number of public body items (paragraphs, tables, block content controls).
+         */
+        get: function () {
+            return this.project().length;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(BodyItemCollection.prototype, "length", {
+        /**
+         * Alias of {@link count} for array-like consumers (`toHaveLength`, `items.length`).
+         */
+        get: function () {
+            return this.count;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Append a body item after existing public children.
+     *
+     * @param item - Paragraph, table, or block content control instance.
+     * @returns The same `item` reference.
+     * @throws TypeError when `item` is not a supported body item.
+     * @throws DetachedObjectError when `item` is already owned.
+     */
+    BodyItemCollection.prototype.add = function (item) {
+        return this.insert(this.count, item);
+    };
+    /**
+     * Insert a body item at a public-items index (`0…count` inclusive).
+     *
+     * @param index - Insert-before index; `count` appends.
+     * @param item - Paragraph, table, or block content control instance.
+     * @returns The same `item` reference.
+     * @throws RangeError when `index` is outside `0…count`.
+     * @throws TypeError when `item` is not a supported body item.
+     * @throws DetachedObjectError when `item` is already owned.
+     */
+    BodyItemCollection.prototype.insert = function (index, item) {
+        if (!isSupportedBodyItem(item)) {
+            throw new TypeError('BodyItemCollection accepts only Paragraph, Table, or block content control instances');
+        }
+        var projected = this.project();
+        if (index < 0 || index > projected.length) {
+            throw new RangeError("Body item index " + String(index) + " is out of range");
+        }
+        this.assertNotOwned(item);
+        var block = bodyItemToBlock(item);
+        var raw = this.host.rawBlocks();
+        var at = this.rawIndexForPublicInsert(index, projected, raw);
+        this.insertRawBlockAt(at, block);
+        return item;
+    };
+    /**
+     * Remove a body item by instance identity.
+     *
+     * @param item - Item currently in this collection.
+     * @throws DetachedObjectError when `item` is not in this collection.
+     */
+    BodyItemCollection.prototype.remove = function (item) {
+        var at = findBlockIndexForBodyItem(this.host.rawBlocks(), item);
+        if (at === -1) {
+            throw new DetachedObjectError('Body item is not in this body');
+        }
+        this.removeRawBlockAt(at);
+    };
+    /**
+     * Remove the public body item at `index` (`0…count-1`).
+     *
+     * @throws RangeError when `index` is out of range.
+     */
+    BodyItemCollection.prototype.removeAt = function (index) {
+        var projected = this.project();
+        if (index < 0 || index >= projected.length) {
+            throw new RangeError("Body item index " + String(index) + " is out of range");
+        }
+        var item = projected[index];
+        var at = findBlockIndexForBodyItem(this.host.rawBlocks(), item);
+        if (at === -1) {
+            throw new DetachedObjectError('Body item is not in this body');
+        }
+        this.removeRawBlockAt(at);
+    };
+    /**
+     * Remove all body items (paragraphs, tables, block content controls) and
+     * detach/release owned content. Opaque unmodeled blocks are also cleared.
+     */
+    BodyItemCollection.prototype.clear = function () {
+        var raw = this.host.rawBlocks();
+        if (raw.length === 0) {
+            this.rebuildIndexProperties();
+            this.notifyHostBodyItemsChanged();
+            return;
+        }
+        var snapshot = raw.slice();
+        this.host.replaceRawBlocks([]);
+        for (var i = 0; i < snapshot.length; i += 1) {
+            var block = snapshot[i];
+            if (block.type === 'paragraph') {
+                block.paragraph.detach();
+            }
+            else if (block.type === 'feature') {
+                releaseFeatureBlock(block.value);
+            }
+        }
+        this.rebuildIndexProperties();
+        this.notifyHostBodyItemsChanged();
+    };
+    /**
+     * Index of `item` in this collection, or `-1` when absent.
+     */
+    BodyItemCollection.prototype.indexOf = function (item) {
+        var projected = this.project();
+        for (var i = 0; i < projected.length; i += 1) {
+            if (projected[i] === item) {
+                return i;
+            }
+        }
+        return -1;
+    };
+    /**
+     * Snapshot of public body items in order.
+     */
+    BodyItemCollection.prototype.toArray = function () {
+        return this.project();
+    };
+    /**
+     * Invoke `fn` for each public body item.
+     */
+    BodyItemCollection.prototype.forEach = function (fn) {
+        var items = this.project();
+        for (var i = 0; i < items.length; i += 1) {
+            fn(items[i], i);
+        }
+    };
+    /**
+     * True when at least one public body item satisfies `predicate`.
+     */
+    BodyItemCollection.prototype.some = function (predicate) {
+        var items = this.project();
+        for (var i = 0; i < items.length; i += 1) {
+            if (predicate(items[i], i)) {
+                return true;
+            }
+        }
+        return false;
+    };
+    /**
+     * Public body items that satisfy `predicate`.
+     */
+    BodyItemCollection.prototype.filter = function (predicate) {
+        var items = this.project();
+        var out = [];
+        for (var i = 0; i < items.length; i += 1) {
+            var item = items[i];
+            if (predicate(item, i)) {
+                out.push(item);
+            }
+        }
+        return out;
+    };
+    /**
+     * First public body item that satisfies `predicate`, or `undefined`.
+     */
+    BodyItemCollection.prototype.find = function (predicate) {
+        var items = this.project();
+        for (var i = 0; i < items.length; i += 1) {
+            var item = items[i];
+            if (predicate(item, i)) {
+                return item;
+            }
+        }
+        return undefined;
+    };
+    /**
+     * Map public body items with `fn`.
+     */
+    BodyItemCollection.prototype.map = function (fn) {
+        var items = this.project();
+        var out = [];
+        for (var i = 0; i < items.length; i += 1) {
+            out.push(fn(items[i], i));
+        }
+        return out;
+    };
+    /**
+     * Iterate public body items in document order.
+     */
+    BodyItemCollection.prototype[Symbol.iterator] = function () {
+        var items = this.project();
+        var i = 0;
+        return {
+            next: function () {
+                if (i >= items.length) {
+                    return { done: true, value: undefined };
+                }
+                var value = items[i];
+                i += 1;
+                return { done: false, value: value };
+            },
+        };
+    };
+    /**
+     * @private
+     * Refresh numeric index properties after any raw-store mutation outside
+     * this collection (load, feature internal hooks).
+     */
+    BodyItemCollection.prototype.syncFromHost = function () {
+        this.rebuildIndexProperties();
+    };
+    /**
+     * @private
+     * Insert an internal block at a raw store index (features / load bridge).
+     */
+    BodyItemCollection.prototype.insertRawBlockAt = function (index, block) {
+        var raw = this.host.rawBlocks();
+        if (index < 0 || index > raw.length) {
+            throw new RangeError("Body item index " + String(index) + " is out of range");
+        }
+        var document = this.host.owningDocument();
+        if (block.type === 'paragraph') {
+            block.paragraph.attach(this.host);
+        }
+        else if (block.type === 'feature') {
+            bindDocumentToFeatureBlock(block.value, document);
+        }
+        var next = raw.slice();
+        next.splice(index, 0, block);
+        this.host.replaceRawBlocks(next);
+        bindAltChunkDocument([block], document);
+        this.rebuildIndexProperties();
+        this.notifyHostBodyItemsChanged();
+    };
+    /**
+     * @private
+     */
+    BodyItemCollection.prototype.removeRawBlockAt = function (index) {
+        var raw = this.host.rawBlocks();
+        if (index < 0 || index >= raw.length) {
+            throw new RangeError("Body item index " + String(index) + " is out of range");
+        }
+        var block = raw[index];
+        var next = raw.slice();
+        next.splice(index, 1);
+        this.host.replaceRawBlocks(next);
+        if (block.type === 'paragraph') {
+            block.paragraph.detach();
+        }
+        else if (block.type === 'feature') {
+            releaseFeatureBlock(block.value);
+        }
+        this.rebuildIndexProperties();
+        this.notifyHostBodyItemsChanged();
+    };
+    /**
+     * @private
+     */
+    BodyItemCollection.prototype.appendRawBlock = function (block) {
+        this.insertRawBlockAt(this.host.rawBlocks().length, block);
+    };
+    /**
+     * @private
+     */
+    BodyItemCollection.prototype.indexOfRawBlock = function (block) {
+        var raw = this.host.rawBlocks();
+        var direct = raw.indexOf(block);
+        if (direct !== -1) {
+            return direct;
+        }
+        for (var i = 0; i < raw.length; i += 1) {
+            if (blocksEqual(raw[i], block)) {
+                return i;
+            }
+        }
+        return -1;
+    };
+    BodyItemCollection.prototype.project = function () {
+        var raw = this.host.rawBlocks();
+        var out = [];
+        for (var i = 0; i < raw.length; i += 1) {
+            var item = projectBlockToBodyItem(raw[i]);
+            if (item !== undefined) {
+                out.push(item);
+            }
+        }
+        return out;
+    };
+    BodyItemCollection.prototype.rawIndexForPublicInsert = function (publicIndex, projected, raw) {
+        if (publicIndex === projected.length) {
+            return raw.length;
+        }
+        var target = projected[publicIndex];
+        var at = findBlockIndexForBodyItem(raw, target);
+        if (at === -1) {
+            throw new DetachedObjectError('Body item index is inconsistent');
+        }
+        return at;
+    };
+    BodyItemCollection.prototype.assertNotOwned = function (item) {
+        var raw = this.host.rawBlocks();
+        if (findBlockIndexForBodyItem(raw, item) !== -1) {
+            throw new DetachedObjectError('Body item is already in this body');
+        }
+        if (item instanceof Paragraph) {
+            try {
+                // Attached paragraphs throw when mutate path runs; owningDocument is public-ish.
+                var doc = item.owningDocument();
+                if (doc !== this.host.owningDocument()) {
+                    throw new DetachedObjectError('Body item belongs to another document');
+                }
+                // Same document but not in this body (e.g. nested cell / other section).
+                throw new DetachedObjectError('Body item is already attached');
+            }
+            catch (err) {
+                if (err instanceof DetachedObjectError && err.message === 'This paragraph is no longer in a document') {
+                    return;
+                }
+                if (err instanceof DetachedObjectError) {
+                    throw err;
+                }
+                throw err;
+            }
+        }
+        // Feature instances: detect via bindDocument presence + optional owner probe.
+        if (typeof item === 'object' && item !== null && 'owningDocument' in item) {
+            var owning = item.owningDocument;
+            if (typeof owning === 'function') {
+                var owner = void 0;
+                try {
+                    owner = owning.call(item);
+                }
+                catch (_a) {
+                    owner = undefined;
+                }
+                if (owner !== undefined) {
+                    if (owner !== this.host.owningDocument()) {
+                        throw new DetachedObjectError('Body item belongs to another document');
+                    }
+                    throw new DetachedObjectError('Body item is already attached');
+                }
+            }
+        }
+    };
+    BodyItemCollection.prototype.rebuildIndexProperties = function () {
+        var items = this.project();
+        var nextLen = items.length;
+        var prevLen = this.cachedLength;
+        var limit = prevLen > nextLen ? prevLen : nextLen;
+        for (var i = 0; i < limit; i += 1) {
+            var key = String(i);
+            if (i < nextLen) {
+                var value = items[i];
+                Object.defineProperty(this, key, {
+                    value: value,
+                    writable: false,
+                    enumerable: true,
+                    configurable: true,
+                });
+            }
+            else {
+                // Remove stale index
+                delete this[key];
+            }
+        }
+        this.cachedLength = nextLen;
+    };
+    BodyItemCollection.prototype.notifyHostBodyItemsChanged = function () {
+        var notify = this.host.notifyBodyItemsChanged;
+        if (typeof notify === 'function') {
+            notify.call(this.host);
+        }
+    };
+    return BodyItemCollection;
+}());
+export { BodyItemCollection };

package/src/features/document/body-item.d.ts

@@ -0,0 +1,35 @@
+import { Paragraph } from './paragraph';
+/**
+ * Structural contract for a modeled table body item (`w:tbl`).
+ * Runtime class lives in the tables feature; core never value-imports it.
+ *
+ * @public
+ */
+export interface TableBodyItem {
+    readonly rows: {
+        readonly length: number;
+    };
+}
+/**
+ * Structural contract for a modeled block content control (`w:sdt`).
+ * Runtime class lives in the content-controls feature; core never value-imports it.
+ *
+ * @public
+ */
+export interface BlockContentControlBodyItem {
+    readonly isBlockLevel?: boolean;
+}
+/**
+ * Closed public body item — direct instances, not wrapper objects.
+ *
+ * Supported main-story children only: {@link Paragraph}, table, and block
+ * content control. Unsupported markup is preserved off this public list.
+ *
+ * @public
+ */
+export declare type BodyItem = Paragraph | TableBodyItem | BlockContentControlBodyItem;
+/**
+ * @private
+ * True when `value` is a {@link Paragraph} instance.
+ */
+export declare function isParagraphBodyItem(value: unknown): value is Paragraph;

package/src/features/document/body-item.js

@@ -0,0 +1,8 @@
+import { Paragraph } from './paragraph';
+/**
+ * @private
+ * True when `value` is a {@link Paragraph} instance.
+ */
+export function isParagraphBodyItem(value) {
+    return value instanceof Paragraph;
+}

package/src/features/document/body.d.ts

@@ -0,0 +1,150 @@
+import { BodyItemCollection, BodyItemCollectionHost } from './body-item-collection';
+import { BlockContent, Paragraph, ParagraphOwner } from './paragraph';
+import { ParagraphCollection } from './typed-body-collections';
+import { WordDocument } from './document';
+import { Section } from './section';
+/**
+ * Section body (`w:body` story content for one section).
+ *
+ * Collection owner only: mutate through {@link Body.items}
+ * ({@link BodyItemCollection}). The internal ordered store holds
+ * {@link BlockContent} wrappers for parse/serialize; the public collection
+ * projects {@link import('./body-item').BodyItem} instances.
+ *
+ * Temporary bridges until TASK-8076: {@link Body.paragraphs},
+ * {@link Body.appendParagraph}. Prefer {@link Body.items} for insert/remove.
+ *
+ * @public
+ */
+export declare class Body implements BodyItemCollectionHost, ParagraphOwner {
+    private itemList;
+    private readonly itemsInstance;
+    private readonly paragraphsInstance;
+    private section;
+    private document;
+    /**
+     * @private
+     */
+    constructor(document: WordDocument | undefined, items?: ReadonlyArray<BlockContent>, section?: Section);
+    /**
+     * Managed mutable collection of public body items (paragraphs, tables,
+     * block content controls). Same instance on every access.
+     */
+    readonly items: BodyItemCollection;
+    /**
+     * Paragraphs in this body (filtered view over {@link Body.items}).
+     *
+     * Temporary bridge until TASK-8076 — prefer {@link Section.paragraphs}
+     * when using the sections spine.
+     */
+    readonly paragraphs: ParagraphCollection;
+    /**
+     * @private
+     * Owning section when this body is attached under a {@link Section}.
+     */
+    owningSection(): Section | undefined;
+    /**
+     * @private
+     */
+    setOwningSection(section: Section | undefined): void;
+    /**
+     * @private
+     */
+    setOwningDocument(document: WordDocument | undefined): void;
+    /**
+     * @private
+     * Document that owns this body (via section or direct bind during load).
+     */
+    owningDocument(): WordDocument;
+    /**
+     * @private
+     */
+    rawBlocks(): BlockContent[];
+    /**
+     * @private
+     */
+    replaceRawBlocks(blocks: ReadonlyArray<BlockContent>): void;
+    /**
+     * @private
+     */
+    assertAttachedParagraph(target: Paragraph): void;
+    /**
+     * @private
+     * Full internal store (paragraphs, features, opaque) for serialize/load.
+     */
+    listBlocks(): ReadonlyArray<BlockContent>;
+    /**
+     * @private
+     * Replace the entire internal store (load / section partition helpers).
+     */
+    replaceItems(items: ReadonlyArray<BlockContent>): void;
+    /**
+     * @private
+     * Append an internal block (feature/load bridge — not a public Body mutator).
+     * Typed views refresh via {@link notifyBodyItemsChanged} from the item collection.
+     */
+    appendRawBlock(block: BlockContent): void;
+    /**
+     * @private
+     */
+    insertRawBlockAt(index: number, block: BlockContent): void;
+    /**
+     * @private
+     */
+    removeRawBlockAt(index: number): void;
+    /**
+     * @private
+     * Paragraph instances in store order (internal bridge).
+     */
+    listParagraphs(): ReadonlyArray<Paragraph>;
+    /**
+     * Appends an empty `w:p` after existing body children (before preserved `sectPr`).
+     *
+     * Temporary bridge until TASK-8076.
+     *
+     * @param options - Optional paragraph style id and/or initial text.
+     * @returns The appended {@link Paragraph}.
+     */
+    appendParagraph(options?: {
+        readonly style?: string;
+        readonly text?: string;
+    }): Paragraph;
+    /**
+     * Inserts an empty paragraph among existing paragraphs.
+     *
+     * @private
+     * Not part of the customer Body surface (API-RULES). Prefer
+     * {@link Body.items} or {@link Body.paragraphs} collection verbs.
+     *
+     * @param index - Index in {@link Body.paragraphs}, `0…count` inclusive.
+     * @throws RangeError if `index` is out of range.
+     */
+    insertParagraph(index: number): Paragraph;
+    /**
+     * Removes a paragraph. Further mutation of it throws {@link DetachedObjectError}.
+     *
+     * @private
+     * Not part of the customer Body surface (API-RULES). Prefer
+     * {@link Body.items} or {@link Body.paragraphs} collection verbs.
+     */
+    removeParagraph(paragraph: Paragraph): void;
+    /**
+     * @private
+     * Refresh typed views after raw mutations that bypass Body helpers.
+     */
+    syncParagraphs(): void;
+    /**
+     * @private
+     * Invoked by {@link BodyItemCollection} after public/raw item mutations so
+     * body paragraphs and section typed views stay aligned with `items`.
+     */
+    notifyBodyItemsChanged(): void;
+    /**
+     * @private
+     * Rebuild body paragraph indexes and, when this body is a section main
+     * story, section typed views (`paragraphs` / `tables` / block CCs).
+     * Cell bodies (`TableCell extends Body`) have no owning section — only
+     * local paragraphs refresh.
+     */
+    private syncTypedViews;
+}