@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/document/typed-body-collections.d.ts

@@ -0,0 +1,162 @@
+import { BodyItem } from './body-item';
+import { BodyItemCollection } from './body-item-collection';
+import { Paragraph } from './paragraph';
+/**
+ * @private
+ * Factory that creates a detached instance for typed `add()` / `insert()` with
+ * no customer-supplied item (paragraph / table / block CC shells).
+ */
+export declare type TypedItemFactory<T extends BodyItem> = () => T;
+/**
+ * @private
+ */
+export declare type TypedCollectionFilter<T extends BodyItem> = (item: BodyItem) => item is T;
+/**
+ * Filtered view over {@link BodyItemCollection} for one body-item kind.
+ *
+ * Insert index is among items of this type only; the item is placed at the
+ * corresponding position in the full body order.
+ *
+ * @public
+ */
+export declare class TypedBodyItemCollection<T extends BodyItem> implements Iterable<T> {
+    private readonly items;
+    private readonly typeFilter;
+    private readonly factory;
+    private cachedLength;
+    /** @private */
+    constructor(items: BodyItemCollection, typeFilter: TypedCollectionFilter<T>, factory?: TypedItemFactory<T>);
+    /** Number of items of this type in the body. */
+    readonly count: number;
+    /**
+     * Alias of {@link count} for array-like consumers (`toHaveLength`, `.length`).
+     */
+    readonly length: number;
+    /**
+     * Append a new item of this type (uses the registered factory when no
+     * `item` is passed), or append the given instance.
+     */
+    add(item?: T): T;
+    /**
+     * Insert at a typed index (`0…count` inclusive).
+     *
+     * @throws RangeError when `index` is outside `0…count`.
+     * @throws TypeError when no factory is registered and `item` is omitted.
+     */
+    insert(index: number, item?: T): T;
+    /**
+     * Remove by instance identity.
+     */
+    remove(item: T): void;
+    /**
+     * Remove at a typed index.
+     */
+    removeAt(index: number): void;
+    /**
+     * Typed index of `item`, or `-1`.
+     */
+    indexOf(item: T): number;
+    /**
+     * Snapshot of items of this type in document order.
+     */
+    toArray(): T[];
+    /**
+     * Invoke `fn` for each item of this type.
+     */
+    forEach(fn: (item: T, index: number) => void): void;
+    /**
+     * True when at least one item of this type satisfies `predicate`.
+     */
+    some(predicate: (item: T, index: number) => boolean): boolean;
+    /**
+     * Items of this type that satisfy `predicate`.
+     */
+    filter(predicate: (item: T, index: number) => boolean): T[];
+    /**
+     * First item of this type that satisfies `predicate`, or `undefined`.
+     */
+    find(predicate: (item: T, index: number) => boolean): T | undefined;
+    /**
+     * Map items of this type with `fn`.
+     */
+    map<U>(fn: (item: T, index: number) => U): U[];
+    [Symbol.iterator](): Iterator<T>;
+    /**
+     * @private
+     */
+    syncFromHost(): void;
+    /**
+     * @private
+     * Replace the factory used by parameterless add/insert.
+     */
+    setFactory(factory: TypedItemFactory<T> | undefined): void;
+    private list;
+    private bodyIndexForTypedInsert;
+    private rebuildIndexProperties;
+}
+export interface TypedBodyItemCollection<T extends BodyItem> {
+    readonly [index: number]: T;
+}
+/**
+ * Paragraphs in a section body (filtered view).
+ *
+ * @public
+ */
+export declare class ParagraphCollection extends TypedBodyItemCollection<Paragraph> {
+    /** @private */
+    constructor(items: BodyItemCollection, factory?: TypedItemFactory<Paragraph>);
+}
+/**
+ * Tables in a section body (filtered view).
+ *
+ * @public
+ */
+export declare class TableCollection extends TypedBodyItemCollection<BodyItem> {
+    /** @private */
+    constructor(items: BodyItemCollection, isTable: TypedCollectionFilter<BodyItem>, factory?: TypedItemFactory<BodyItem>);
+}
+/**
+ * Block content controls in a section body (filtered view).
+ *
+ * @public
+ */
+export declare class BlockContentControlCollection extends TypedBodyItemCollection<BodyItem> {
+    /** @private */
+    constructor(items: BodyItemCollection, isBlockCc: TypedCollectionFilter<BodyItem>, factory?: TypedItemFactory<BodyItem>);
+}
+/**
+ * @private
+ * Registration hooks so features can supply table / CC factories and filters
+ * without core value-importing feature modules.
+ */
+export declare type TypedCollectionHooks = {
+    isTable?(item: BodyItem): boolean;
+    createTable?(): BodyItem;
+    isBlockContentControl?(item: BodyItem): boolean;
+    createBlockContentControl?(): BodyItem;
+};
+/**
+ * @private
+ */
+export declare function registerTypedCollectionHooks(hooks: TypedCollectionHooks): void;
+/**
+ * @private
+ */
+export declare function resetTypedCollectionHooksForTests(): void;
+/**
+ * @private
+ */
+export declare function currentTypedCollectionHooks(): TypedCollectionHooks;
+/**
+ * @private
+ * Live filter/factory over {@link currentTypedCollectionHooks} so long-lived
+ * section collections do not permanently capture a pre-registration snapshot
+ * (hooks object is replaced on each {@link registerTypedCollectionHooks} call).
+ */
+export declare function createTableCollection(items: BodyItemCollection): TableCollection;
+/**
+ * @private
+ * Live filter/factory over {@link currentTypedCollectionHooks} (see
+ * {@link createTableCollection}).
+ */
+export declare function createBlockContentControlCollection(items: BodyItemCollection): BlockContentControlCollection;

package/src/features/document/typed-body-collections.js

@@ -0,0 +1,371 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { DetachedObjectError } from '../../core/errors/docx-error';
+import { Paragraph } from './paragraph';
+/**
+ * Filtered view over {@link BodyItemCollection} for one body-item kind.
+ *
+ * Insert index is among items of this type only; the item is placed at the
+ * corresponding position in the full body order.
+ *
+ * @public
+ */
+var TypedBodyItemCollection = /** @class */ (function () {
+    /** @private */
+    function TypedBodyItemCollection(items, typeFilter, factory) {
+        this.cachedLength = 0;
+        this.items = items;
+        this.typeFilter = typeFilter;
+        this.factory = factory;
+        this.rebuildIndexProperties();
+    }
+    Object.defineProperty(TypedBodyItemCollection.prototype, "count", {
+        /** Number of items of this type in the body. */
+        get: function () {
+            return this.list().length;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TypedBodyItemCollection.prototype, "length", {
+        /**
+         * Alias of {@link count} for array-like consumers (`toHaveLength`, `.length`).
+         */
+        get: function () {
+            return this.count;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Append a new item of this type (uses the registered factory when no
+     * `item` is passed), or append the given instance.
+     */
+    TypedBodyItemCollection.prototype.add = function (item) {
+        return this.insert(this.count, item);
+    };
+    /**
+     * Insert at a typed index (`0…count` inclusive).
+     *
+     * @throws RangeError when `index` is outside `0…count`.
+     * @throws TypeError when no factory is registered and `item` is omitted.
+     */
+    TypedBodyItemCollection.prototype.insert = function (index, item) {
+        var typed = this.list();
+        if (index < 0 || index > typed.length) {
+            throw new RangeError("Index " + String(index) + " is out of range");
+        }
+        var value;
+        if (item !== undefined) {
+            value = item;
+        }
+        else if (this.factory !== undefined) {
+            value = this.factory();
+        }
+        else {
+            throw new TypeError('No item provided and no factory is registered for this collection');
+        }
+        if (!this.typeFilter(value)) {
+            throw new TypeError('Item type does not match this collection');
+        }
+        var bodyIndex = this.bodyIndexForTypedInsert(index, typed);
+        this.items.insert(bodyIndex, value);
+        this.rebuildIndexProperties();
+        return value;
+    };
+    /**
+     * Remove by instance identity.
+     */
+    TypedBodyItemCollection.prototype.remove = function (item) {
+        if (this.items.indexOf(item) === -1 || !this.typeFilter(item)) {
+            throw new DetachedObjectError('Item is not in this collection');
+        }
+        this.items.remove(item);
+        this.rebuildIndexProperties();
+    };
+    /**
+     * Remove at a typed index.
+     */
+    TypedBodyItemCollection.prototype.removeAt = function (index) {
+        var typed = this.list();
+        if (index < 0 || index >= typed.length) {
+            throw new RangeError("Index " + String(index) + " is out of range");
+        }
+        this.items.remove(typed[index]);
+        this.rebuildIndexProperties();
+    };
+    /**
+     * Typed index of `item`, or `-1`.
+     */
+    TypedBodyItemCollection.prototype.indexOf = function (item) {
+        var typed = this.list();
+        for (var i = 0; i < typed.length; i += 1) {
+            if (typed[i] === item) {
+                return i;
+            }
+        }
+        return -1;
+    };
+    /**
+     * Snapshot of items of this type in document order.
+     */
+    TypedBodyItemCollection.prototype.toArray = function () {
+        return this.list();
+    };
+    /**
+     * Invoke `fn` for each item of this type.
+     */
+    TypedBodyItemCollection.prototype.forEach = function (fn) {
+        var items = this.list();
+        for (var i = 0; i < items.length; i += 1) {
+            fn(items[i], i);
+        }
+    };
+    /**
+     * True when at least one item of this type satisfies `predicate`.
+     */
+    TypedBodyItemCollection.prototype.some = function (predicate) {
+        var items = this.list();
+        for (var i = 0; i < items.length; i += 1) {
+            if (predicate(items[i], i)) {
+                return true;
+            }
+        }
+        return false;
+    };
+    /**
+     * Items of this type that satisfy `predicate`.
+     */
+    TypedBodyItemCollection.prototype.filter = function (predicate) {
+        var items = this.list();
+        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 item of this type that satisfies `predicate`, or `undefined`.
+     */
+    TypedBodyItemCollection.prototype.find = function (predicate) {
+        var items = this.list();
+        for (var i = 0; i < items.length; i += 1) {
+            var item = items[i];
+            if (predicate(item, i)) {
+                return item;
+            }
+        }
+        return undefined;
+    };
+    /**
+     * Map items of this type with `fn`.
+     */
+    TypedBodyItemCollection.prototype.map = function (fn) {
+        var items = this.list();
+        var out = [];
+        for (var i = 0; i < items.length; i += 1) {
+            out.push(fn(items[i], i));
+        }
+        return out;
+    };
+    TypedBodyItemCollection.prototype[Symbol.iterator] = function () {
+        var items = this.list();
+        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
+     */
+    TypedBodyItemCollection.prototype.syncFromHost = function () {
+        this.rebuildIndexProperties();
+    };
+    /**
+     * @private
+     * Replace the factory used by parameterless add/insert.
+     */
+    TypedBodyItemCollection.prototype.setFactory = function (factory) {
+        this.factory = factory;
+    };
+    TypedBodyItemCollection.prototype.list = function () {
+        var out = [];
+        var length = this.items.count;
+        for (var i = 0; i < length; i += 1) {
+            var item = this.items[i];
+            if (item !== undefined && this.typeFilter(item)) {
+                out.push(item);
+            }
+        }
+        return out;
+    };
+    TypedBodyItemCollection.prototype.bodyIndexForTypedInsert = function (typedIndex, typed) {
+        if (typedIndex === typed.length) {
+            // Typed append is document-order: place at the end of the body,
+            // not after the last item of this type (which would skip later
+            // tables / SDTs and break mixed-body authoring order).
+            return this.items.count;
+        }
+        var target = typed[typedIndex];
+        var at = this.items.indexOf(target);
+        if (at === -1) {
+            throw new DetachedObjectError('Typed collection index is inconsistent');
+        }
+        return at;
+    };
+    TypedBodyItemCollection.prototype.rebuildIndexProperties = function () {
+        var items = this.list();
+        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) {
+                Object.defineProperty(this, key, {
+                    value: items[i],
+                    writable: false,
+                    enumerable: true,
+                    configurable: true,
+                });
+            }
+            else {
+                delete this[key];
+            }
+        }
+        this.cachedLength = nextLen;
+    };
+    return TypedBodyItemCollection;
+}());
+export { TypedBodyItemCollection };
+/**
+ * Paragraphs in a section body (filtered view).
+ *
+ * @public
+ */
+var ParagraphCollection = /** @class */ (function (_super) {
+    __extends(ParagraphCollection, _super);
+    /** @private */
+    function ParagraphCollection(items, factory) {
+        return _super.call(this, items, function (item) { return item instanceof Paragraph; }, factory) || this;
+    }
+    return ParagraphCollection;
+}(TypedBodyItemCollection));
+export { ParagraphCollection };
+/**
+ * Tables in a section body (filtered view).
+ *
+ * @public
+ */
+var TableCollection = /** @class */ (function (_super) {
+    __extends(TableCollection, _super);
+    /** @private */
+    function TableCollection(items, isTable, factory) {
+        return _super.call(this, items, isTable, factory) || this;
+    }
+    return TableCollection;
+}(TypedBodyItemCollection));
+export { TableCollection };
+/**
+ * Block content controls in a section body (filtered view).
+ *
+ * @public
+ */
+var BlockContentControlCollection = /** @class */ (function (_super) {
+    __extends(BlockContentControlCollection, _super);
+    /** @private */
+    function BlockContentControlCollection(items, isBlockCc, factory) {
+        return _super.call(this, items, isBlockCc, factory) || this;
+    }
+    return BlockContentControlCollection;
+}(TypedBodyItemCollection));
+export { BlockContentControlCollection };
+var typedHooks = {};
+/**
+ * @private
+ */
+export function registerTypedCollectionHooks(hooks) {
+    typedHooks = __assign({}, typedHooks, hooks);
+}
+/**
+ * @private
+ */
+export function resetTypedCollectionHooksForTests() {
+    typedHooks = {};
+}
+/**
+ * @private
+ */
+export function currentTypedCollectionHooks() {
+    return typedHooks;
+}
+/**
+ * @private
+ * Live filter/factory over {@link currentTypedCollectionHooks} so long-lived
+ * section collections do not permanently capture a pre-registration snapshot
+ * (hooks object is replaced on each {@link registerTypedCollectionHooks} call).
+ */
+export function createTableCollection(items) {
+    var filter = function (item) {
+        var isTable = currentTypedCollectionHooks().isTable;
+        return isTable !== undefined ? isTable(item) : false;
+    };
+    var factory = function () {
+        var create = currentTypedCollectionHooks().createTable;
+        if (create === undefined) {
+            throw new TypeError('No item provided and no factory is registered for this collection');
+        }
+        return create();
+    };
+    return new TableCollection(items, filter, factory);
+}
+/**
+ * @private
+ * Live filter/factory over {@link currentTypedCollectionHooks} (see
+ * {@link createTableCollection}).
+ */
+export function createBlockContentControlCollection(items) {
+    var filter = function (item) {
+        var isBlockCc = currentTypedCollectionHooks().isBlockContentControl;
+        return isBlockCc !== undefined ? isBlockCc(item) : false;
+    };
+    var factory = function () {
+        var create = currentTypedCollectionHooks().createBlockContentControl;
+        if (create === undefined) {
+            throw new TypeError('No item provided and no factory is registered for this collection');
+        }
+        return create();
+    };
+    return new BlockContentControlCollection(items, filter, factory);
+}

package/src/features/document/underline-style.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Underline styles for character format (`w:u` / ST_Underline).
+ *
+ * Numeric values match the DocIO / requirement surface. Value 8 is reserved
+ * and intentionally unused.
+ *
+ * @public
+ */
+export declare enum UnderlineStyle {
+    None = 0,
+    Single = 1,
+    Words = 2,
+    Double = 3,
+    Dotted = 4,
+    Thick = 6,
+    Dash = 7,
+    DotDash = 9,
+    DotDotDash = 10,
+    Wavy = 11,
+    DottedHeavy = 20,
+    DashHeavy = 23,
+    DotDashHeavy = 25,
+    DotDotDashHeavy = 26,
+    WavyHeavy = 27,
+    DashLong = 39,
+    DashLongHeavy = 55,
+    WavyDouble = 43
+}
+/**
+ * Map ST_Underline wire string to {@link UnderlineStyle}.
+ * @private
+ */
+export declare function underlineStyleFromWire(raw: string | undefined): UnderlineStyle;
+/**
+ * Map {@link UnderlineStyle} to the preferred ST_Underline wire string.
+ * @private
+ */
+export declare function underlineStyleToWire(style: UnderlineStyle): string;

package/src/features/document/underline-style.js

@@ -0,0 +1,126 @@
+/**
+ * Underline styles for character format (`w:u` / ST_Underline).
+ *
+ * Numeric values match the DocIO / requirement surface. Value 8 is reserved
+ * and intentionally unused.
+ *
+ * @public
+ */
+export var UnderlineStyle;
+(function (UnderlineStyle) {
+    UnderlineStyle[UnderlineStyle["None"] = 0] = "None";
+    UnderlineStyle[UnderlineStyle["Single"] = 1] = "Single";
+    UnderlineStyle[UnderlineStyle["Words"] = 2] = "Words";
+    UnderlineStyle[UnderlineStyle["Double"] = 3] = "Double";
+    UnderlineStyle[UnderlineStyle["Dotted"] = 4] = "Dotted";
+    UnderlineStyle[UnderlineStyle["Thick"] = 6] = "Thick";
+    UnderlineStyle[UnderlineStyle["Dash"] = 7] = "Dash";
+    UnderlineStyle[UnderlineStyle["DotDash"] = 9] = "DotDash";
+    UnderlineStyle[UnderlineStyle["DotDotDash"] = 10] = "DotDotDash";
+    UnderlineStyle[UnderlineStyle["Wavy"] = 11] = "Wavy";
+    UnderlineStyle[UnderlineStyle["DottedHeavy"] = 20] = "DottedHeavy";
+    UnderlineStyle[UnderlineStyle["DashHeavy"] = 23] = "DashHeavy";
+    UnderlineStyle[UnderlineStyle["DotDashHeavy"] = 25] = "DotDashHeavy";
+    UnderlineStyle[UnderlineStyle["DotDotDashHeavy"] = 26] = "DotDotDashHeavy";
+    UnderlineStyle[UnderlineStyle["WavyHeavy"] = 27] = "WavyHeavy";
+    UnderlineStyle[UnderlineStyle["DashLong"] = 39] = "DashLong";
+    UnderlineStyle[UnderlineStyle["DashLongHeavy"] = 55] = "DashLongHeavy";
+    UnderlineStyle[UnderlineStyle["WavyDouble"] = 43] = "WavyDouble";
+})(UnderlineStyle || (UnderlineStyle = {}));
+/**
+ * Map ST_Underline wire string to {@link UnderlineStyle}.
+ * @private
+ */
+export function underlineStyleFromWire(raw) {
+    if (raw === undefined || raw === '' || raw === 'none') {
+        return UnderlineStyle.None;
+    }
+    switch (raw) {
+        case 'single':
+            return UnderlineStyle.Single;
+        case 'words':
+            return UnderlineStyle.Words;
+        case 'double':
+            return UnderlineStyle.Double;
+        case 'thick':
+            return UnderlineStyle.Thick;
+        case 'dotted':
+            return UnderlineStyle.Dotted;
+        case 'dottedHeavy':
+            return UnderlineStyle.DottedHeavy;
+        case 'dash':
+            return UnderlineStyle.Dash;
+        case 'dashed':
+        case 'dashedHeavy':
+            return UnderlineStyle.DashHeavy;
+        case 'dashLong':
+            return UnderlineStyle.DashLong;
+        case 'dashLongHeavy':
+            return UnderlineStyle.DashLongHeavy;
+        case 'dotDash':
+            return UnderlineStyle.DotDash;
+        case 'dashDotHeavy':
+        case 'dotDashHeavy':
+            return UnderlineStyle.DotDashHeavy;
+        case 'dotDotDash':
+            return UnderlineStyle.DotDotDash;
+        case 'dashDotDotHeavy':
+        case 'dotDotDashHeavy':
+            return UnderlineStyle.DotDotDashHeavy;
+        case 'wave':
+        case 'wavy':
+            return UnderlineStyle.Wavy;
+        case 'wavyHeavy':
+            return UnderlineStyle.WavyHeavy;
+        case 'wavyDouble':
+            return UnderlineStyle.WavyDouble;
+        default:
+            return UnderlineStyle.Single;
+    }
+}
+/**
+ * Map {@link UnderlineStyle} to the preferred ST_Underline wire string.
+ * @private
+ */
+export function underlineStyleToWire(style) {
+    switch (style) {
+        case UnderlineStyle.None:
+            return 'none';
+        case UnderlineStyle.Single:
+            return 'single';
+        case UnderlineStyle.Words:
+            return 'words';
+        case UnderlineStyle.Double:
+            return 'double';
+        case UnderlineStyle.Dotted:
+            return 'dotted';
+        case UnderlineStyle.Thick:
+            return 'thick';
+        case UnderlineStyle.Dash:
+            return 'dash';
+        case UnderlineStyle.DotDash:
+            return 'dotDash';
+        case UnderlineStyle.DotDotDash:
+            return 'dotDotDash';
+        case UnderlineStyle.Wavy:
+            return 'wave';
+        case UnderlineStyle.DottedHeavy:
+            return 'dottedHeavy';
+        case UnderlineStyle.DashHeavy:
+            return 'dashedHeavy';
+        case UnderlineStyle.DotDashHeavy:
+            return 'dotDashHeavy';
+        case UnderlineStyle.DotDotDashHeavy:
+            return 'dashDotDotHeavy';
+        case UnderlineStyle.WavyHeavy:
+            return 'wavyHeavy';
+        case UnderlineStyle.DashLong:
+            return 'dashLong';
+        case UnderlineStyle.DashLongHeavy:
+            return 'dashLongHeavy';
+        case UnderlineStyle.WavyDouble:
+            return 'wavyDouble';
+        default:
+            return 'single';
+    }
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Legacy units barrel (package-private). Public APIs use plain point numbers.
+ * or `./length`. Multi-unit constructors are package-private.
+ *
+ * @packageDocumentation
+ */
+export { Emus, HalfPoints, pointToEmus, pointToHalfPoints, pointToTwips, twipsToPoint, emuToPoint, halfPointsToPoint, addPoints, scalePoint, lengthToEmus, lengthToHalfPoints, halfPoints, emus, LengthUnits, // package-private aliases
+Length, Pt, Inches, Cm, Mm, Px, Twips, Emu, add, scale, inchesToPoint, cmToPoint, mmToPoint, pxToPoint } from './length';