@syncfusion/ej2-office-common 35.1.37 → 35.1.43

package/src/office-common/features/mathml/office-math/matrix.js

@@ -0,0 +1,158 @@
+/**
+ * Matrix (`m:m`) function.
+ */
+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 __());
+    };
+})();
+import { MathFunctionType, MathVerticalAlignment, SpacingRule } from './enums';
+import { K } from './keys';
+import { checkRowSpacing } from './functions-multi';
+import { OfficeMathFunctionBase } from './function-base';
+import { OfficeMathMatrixRowCollection, OfficeMathMatrixColumnCollection } from './matrix-collections';
+/**
+ * Matrix whose rows and columns are kept synchronized: every row always has one cell per column.
+ *
+ * @public
+ */
+var OfficeMathMatrix = /** @class */ (function (_super) {
+    __extends(OfficeMathMatrix, _super);
+    function OfficeMathMatrix(owner) {
+        var _this = _super.call(this, owner) || this;
+        _this.type = MathFunctionType.Matrix;
+        _this._rows = new OfficeMathMatrixRowCollection(_this);
+        _this._columns = new OfficeMathMatrixColumnCollection(_this);
+        return _this;
+    }
+    Object.defineProperty(OfficeMathMatrix.prototype, "rows", {
+        /** Rows of the matrix. */
+        get: function () { return this._rows; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathMatrix.prototype, "columns", {
+        /** Columns of the matrix. */
+        get: function () { return this._columns; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathMatrix.prototype, "verticalAlignment", {
+        /** Vertical alignment. Default center. */
+        get: function () { return this.getProperty(K.MatrixAlign, function () { return MathVerticalAlignment.Center; }); },
+        set: function (value) { this.setProperty(K.MatrixAlign, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathMatrix.prototype, "hidePlaceholder", {
+        /** Hides placeholders for empty cells. Default false. */
+        get: function () { return this.getProperty(K.PlaceHoldHidden, function () { return false; }); },
+        set: function (value) { this.setProperty(K.PlaceHoldHidden, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathMatrix.prototype, "rowSpacing", {
+        /** Row spacing; unit depends on `rowSpacingRule`. Default 0. */
+        get: function () { return this.getProperty(K.RowSpacing, function () { return 0; }); },
+        set: function (value) {
+            checkRowSpacing(value, this.rowSpacingRule);
+            this.setProperty(K.RowSpacing, value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathMatrix.prototype, "rowSpacingRule", {
+        /** Row spacing rule (`m:rSpRule`). Default single. */
+        get: function () { return this.getProperty(K.RowSpacingRule, function () { return SpacingRule.Single; }); },
+        set: function (value) { this.setProperty(K.RowSpacingRule, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathMatrix.prototype, "columnGap", {
+        /** Column gap (`m:cGp`). Default 0. */
+        get: function () { return this.getProperty(K.ColumnGap, function () { return 0; }); },
+        set: function (value) { this.setProperty(K.ColumnGap, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathMatrix.prototype, "columnGapRule", {
+        /** Column gap rule (`m:cGpRule`). Default single. */
+        get: function () { return this.getProperty(K.ColumnGapRule, function () { return SpacingRule.Single; }); },
+        set: function (value) { this.setProperty(K.ColumnGapRule, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathMatrix.prototype, "hidePlaceHolders", {
+        /** DocIO-compatible alias of `hidePlaceholder` (`m:plcHide`). */
+        get: function () { return this.hidePlaceholder; },
+        set: function (value) { this.hidePlaceholder = value; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathMatrix.prototype, "columnSpacingRule", {
+        /** DocIO-compatible alias of `columnGapRule` (`m:cGpRule`). */
+        get: function () { return this.columnGapRule; },
+        set: function (value) { this.columnGapRule = value; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathMatrix.prototype, "columnWidth", {
+        /** DocIO-compatible name for the column width (`m:cSp`); shares storage with `columnSpacing`. */
+        get: function () { return this.columnSpacing; },
+        set: function (value) { this.columnSpacing = value; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathMatrix.prototype, "columnSpacing", {
+        /** Column spacing (`m:cSp`). Default 0. */
+        get: function () { return this.getProperty(K.ColumnSpacing, function () { return 0; }); },
+        set: function (value) { this.setProperty(K.ColumnSpacing, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathMatrix.prototype, "columnGroups", {
+        /** Column groups: consecutive columns with identical alignment, in order. */
+        get: function () {
+            var groups = [];
+            this._columns.toArray().forEach(function (column, index) {
+                var last = groups[groups.length - 1];
+                if (last !== undefined && last.horizontalAlignment === column.horizontalAlignment) {
+                    last.count++;
+                }
+                else {
+                    groups.push({ startIndex: index, count: 1, horizontalAlignment: column.horizontalAlignment });
+                }
+            });
+            return groups;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Re-links every cell to its row and column after a structural change.
+     *
+     * @private
+     */
+    OfficeMathMatrix.prototype.relink = function () {
+        var columns = this._columns.toArray();
+        this._rows.toArray().forEach(function (row) {
+            row.arguments.toArray().forEach(function (cell, i) { return cell.setOwnerColumn(columns[i]); });
+        });
+    };
+    Object.defineProperty(OfficeMathMatrix.prototype, "rowItems", {
+        /** @private */
+        get: function () { return this._rows.toArray(); },
+        enumerable: true,
+        configurable: true
+    });
+    return OfficeMathMatrix;
+}(OfficeMathFunctionBase));
+export { OfficeMathMatrix };

package/src/office-common/features/mathml/office-math/office-math.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Office Math equation (`m:oMath`): a container of Math functions.
+ */
+import { OwnerHolder } from './owner-holder';
+import { OfficeMathEntity } from './entity';
+import { OfficeMathFunctionCollection } from './function-collection';
+import { OfficeMathBreakCollection } from './break';
+import { OpenXmlElement } from '../openxml';
+/** Column back-reference used by matrix synchronization. */
+interface ColumnLink {
+    readonly columnIndex: number;
+}
+/**
+ * Equation that holds an ordered list of Math functions.
+ *
+ * @public
+ */
+export declare class OfficeMath extends OwnerHolder {
+    private readonly _functions;
+    private readonly _breaks;
+    private _column;
+    private _preservedControl;
+    constructor(owner?: OfficeMathEntity);
+    /** Manual breaks owned by this equation; a box references one of them. */
+    readonly breaks: OfficeMathBreakCollection;
+    /** Functions of this equation. */
+    readonly functions: OfficeMathFunctionCollection;
+    /**
+     * Argument size (`m:argPr/m:argSz`), from -2 to 2. Default 0.
+     *
+     * @returns {number} The argument size.
+     */
+    argumentSize: number;
+    /**
+     * The original `m:ctrlPr` of an argument, kept verbatim for round trips.
+     *
+     * @returns {OpenXmlElement | undefined} The preserved element, when present.
+     * @private
+     */
+    preservedControlProperties: OpenXmlElement | undefined;
+    /** The nearest enclosing equation, or `undefined` for a top-level equation. */
+    readonly ownerMath: OfficeMath | undefined;
+    /** The matrix row that owns this cell, or `undefined` when it is not a matrix cell. */
+    readonly ownerRow: OfficeMathEntity | undefined;
+    /** The matrix column that contains this cell, or `undefined` when it is not a matrix cell. */
+    readonly ownerColumn: ColumnLink | undefined;
+    /**
+     * @private
+     *
+     * @param {ColumnLink | undefined} column The column the equation belongs to.
+     * @returns {void}
+     */
+    setOwnerColumn(column: ColumnLink | undefined): void;
+}
+export {};

package/src/office-common/features/mathml/office-math/office-math.js

@@ -0,0 +1,116 @@
+/**
+ * Office Math equation (`m:oMath`): a container of Math functions.
+ */
+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 __());
+    };
+})();
+import { OwnerHolder } from './owner-holder';
+import { OfficeMathFunctionCollection } from './function-collection';
+import { OfficeMathBreakCollection } from './break';
+import { K } from './keys';
+/**
+ * Equation that holds an ordered list of Math functions.
+ *
+ * @public
+ */
+var OfficeMath = /** @class */ (function (_super) {
+    __extends(OfficeMath, _super);
+    function OfficeMath(owner) {
+        var _this = _super.call(this, owner) || this;
+        _this._functions = new OfficeMathFunctionCollection(_this);
+        _this._breaks = new OfficeMathBreakCollection(_this);
+        return _this;
+    }
+    Object.defineProperty(OfficeMath.prototype, "breaks", {
+        /** Manual breaks owned by this equation; a box references one of them. */
+        get: function () { return this._breaks; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMath.prototype, "functions", {
+        /** Functions of this equation. */
+        get: function () { return this._functions; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMath.prototype, "argumentSize", {
+        /**
+         * Argument size (`m:argPr/m:argSz`), from -2 to 2. Default 0.
+         *
+         * @returns {number} The argument size.
+         */
+        get: function () { return this.getProperty(K.ArgumentSize, function () { return 0; }); },
+        set: function (value) {
+            if (value < -2 || value > 2 || Math.floor(value) !== value) {
+                throw new RangeError('ArgumentSize must be an integer between -2 and 2.');
+            }
+            this.setProperty(K.ArgumentSize, value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMath.prototype, "preservedControlProperties", {
+        /**
+         * The original `m:ctrlPr` of an argument, kept verbatim for round trips.
+         *
+         * @returns {OpenXmlElement | undefined} The preserved element, when present.
+         * @private
+         */
+        get: function () { return this._preservedControl; },
+        set: function (value) {
+            this._preservedControl = value;
+            this.notifyMutated();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMath.prototype, "ownerMath", {
+        /** The nearest enclosing equation, or `undefined` for a top-level equation. */
+        get: function () {
+            var entity = this.ownerMathEntity;
+            while (entity !== undefined) {
+                if (entity instanceof OfficeMath) {
+                    return entity;
+                }
+                entity = entity.ownerMathEntity;
+            }
+            return undefined;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMath.prototype, "ownerRow", {
+        /** The matrix row that owns this cell, or `undefined` when it is not a matrix cell. */
+        get: function () {
+            var owner = this.ownerMathEntity;
+            return owner !== undefined && 'arguments' in owner ? owner : undefined;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMath.prototype, "ownerColumn", {
+        /** The matrix column that contains this cell, or `undefined` when it is not a matrix cell. */
+        get: function () { return this._column; },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     *
+     * @param {ColumnLink | undefined} column The column the equation belongs to.
+     * @returns {void}
+     */
+    OfficeMath.prototype.setOwnerColumn = function (column) { this._column = column; };
+    return OfficeMath;
+}(OwnerHolder));
+export { OfficeMath };

package/src/office-common/features/mathml/office-math/owner-holder.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Base class of every owner-aware Math object.
+ */
+import { OfficeMathEntity } from './entity';
+import { ExplicitPropertyStore } from './property-store';
+/**
+ * Holds the owner reference, bubbles mutations to the root and tracks explicit properties.
+ *
+ * @public
+ */
+export declare abstract class OwnerHolder extends ExplicitPropertyStore implements OfficeMathEntity {
+    private _owner;
+    constructor(owner?: OfficeMathEntity);
+    /** The containing entity, or `undefined` for a root or detached object. */
+    readonly ownerMathEntity: OfficeMathEntity | undefined;
+    /**
+     * Re-parents this object.
+     *
+     * @param owner
+     * @private
+     */
+    setOwner(owner: OfficeMathEntity | undefined): void;
+    /**
+     * True when this object is a matrix row or column, whose arguments are managed by synchronization.
+     *
+     * @private
+     */
+    readonly isMatrixArgumentOwner: boolean;
+    /**
+     * Root-level mutation sink. The Math paragraph overrides it to notify the host.
+     *
+     * @private
+     */
+    protected rootMutated(): void;
+    /**
+     * Notifies the root that something below it changed.
+     *
+     * @private
+     */
+    notifyMutated(): void;
+    protected propertyChanged(): void;
+}

package/src/office-common/features/mathml/office-math/owner-holder.js

@@ -0,0 +1,87 @@
+/**
+ * Base class of every owner-aware Math object.
+ */
+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 __());
+    };
+})();
+import { ExplicitPropertyStore } from './property-store';
+/**
+ * Holds the owner reference, bubbles mutations to the root and tracks explicit properties.
+ *
+ * @public
+ */
+var OwnerHolder = /** @class */ (function (_super) {
+    __extends(OwnerHolder, _super);
+    function OwnerHolder(owner) {
+        var _this = _super.call(this) || this;
+        _this._owner = owner;
+        return _this;
+    }
+    Object.defineProperty(OwnerHolder.prototype, "ownerMathEntity", {
+        /** The containing entity, or `undefined` for a root or detached object. */
+        get: function () {
+            return this._owner;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Re-parents this object.
+     *
+     * @param owner
+     * @private
+     */
+    OwnerHolder.prototype.setOwner = function (owner) {
+        this._owner = owner;
+    };
+    Object.defineProperty(OwnerHolder.prototype, "isMatrixArgumentOwner", {
+        /**
+         * True when this object is a matrix row or column, whose arguments are managed by synchronization.
+         *
+         * @private
+         */
+        get: function () {
+            return false;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Root-level mutation sink. The Math paragraph overrides it to notify the host.
+     *
+     * @private
+     */
+    OwnerHolder.prototype.rootMutated = function () {
+        // no-op unless this object is the root
+    };
+    /**
+     * Notifies the root that something below it changed.
+     *
+     * @private
+     */
+    OwnerHolder.prototype.notifyMutated = function () {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        var current = this;
+        var next = current._owner;
+        while (next instanceof OwnerHolder) {
+            current = next;
+            next = current._owner;
+        }
+        current.rootMutated();
+    };
+    OwnerHolder.prototype.propertyChanged = function () {
+        this.notifyMutated();
+    };
+    return OwnerHolder;
+}(ExplicitPropertyStore));
+export { OwnerHolder };

package/src/office-common/features/mathml/office-math/property-store.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Explicit-value tracking for Math properties.
+ *
+ * Public getters return effective (Compression-compatible) defaults while the
+ * store separately remembers which keys were assigned or parsed, so the
+ * serializer emits only explicit values.
+ */
+/**
+ * Reusable keyed property store.
+ *
+ * @public
+ */
+export declare class ExplicitPropertyStore {
+    private readonly _values;
+    /**
+     * Whether the key was explicitly assigned or parsed.
+     *
+     * @param key
+     */
+    protected hasProperty(key: number): boolean;
+    /**
+     * Returns the explicit value, or the lazily computed effective default.
+     *
+     * @param key
+     * @param defaultValue
+     */
+    protected getProperty<T>(key: number, defaultValue: () => T): T;
+    /**
+     * Assigns a value and marks it explicit, even when equal to the default.
+     *
+     * @param key
+     * @param value
+     */
+    protected setProperty<T>(key: number, value: T): void;
+    /**
+     * Removes the explicit value so the effective default applies again.
+     *
+     * @param key
+     */
+    protected clearProperty(key: number): void;
+    /**
+     * Whether a property was explicitly set or parsed from source.
+     * Serializers use this to emit only explicit values.
+     *
+     * @param key
+     */
+    isExplicit(key: number): boolean;
+    /**
+     * Copies every explicit property of `source` into this store, keeping explicitness.
+     *
+     * @param {ExplicitPropertyStore} source Store to copy from.
+     * @returns {void}
+     * @private
+     */
+    copyExplicitFrom(source: ExplicitPropertyStore): void;
+    /**
+     * Whether both stores hold the same explicit keys with equal values.
+     *
+     * @param {ExplicitPropertyStore} other Store to compare with.
+     * @returns {boolean} True when the explicit properties are identical.
+     * @private
+     */
+    explicitEquals(other: ExplicitPropertyStore): boolean;
+    /** Hook invoked after any mutation of the store. */
+    protected propertyChanged(): void;
+}

package/src/office-common/features/mathml/office-math/property-store.js

@@ -0,0 +1,99 @@
+/**
+ * Explicit-value tracking for Math properties.
+ *
+ * Public getters return effective (Compression-compatible) defaults while the
+ * store separately remembers which keys were assigned or parsed, so the
+ * serializer emits only explicit values.
+ */
+/**
+ * Reusable keyed property store.
+ *
+ * @public
+ */
+var ExplicitPropertyStore = /** @class */ (function () {
+    function ExplicitPropertyStore() {
+        this._values = new Map();
+    }
+    /**
+     * Whether the key was explicitly assigned or parsed.
+     *
+     * @param key
+     */
+    ExplicitPropertyStore.prototype.hasProperty = function (key) {
+        return this._values.has(key);
+    };
+    /**
+     * Returns the explicit value, or the lazily computed effective default.
+     *
+     * @param key
+     * @param defaultValue
+     */
+    ExplicitPropertyStore.prototype.getProperty = function (key, defaultValue) {
+        return this._values.has(key) ? this._values.get(key) : defaultValue();
+    };
+    /**
+     * Assigns a value and marks it explicit, even when equal to the default.
+     *
+     * @param key
+     * @param value
+     */
+    ExplicitPropertyStore.prototype.setProperty = function (key, value) {
+        this._values.set(key, value);
+        this.propertyChanged();
+    };
+    /**
+     * Removes the explicit value so the effective default applies again.
+     *
+     * @param key
+     */
+    ExplicitPropertyStore.prototype.clearProperty = function (key) {
+        if (this._values.delete(key)) {
+            this.propertyChanged();
+        }
+    };
+    /**
+     * Whether a property was explicitly set or parsed from source.
+     * Serializers use this to emit only explicit values.
+     *
+     * @param key
+     */
+    ExplicitPropertyStore.prototype.isExplicit = function (key) {
+        return this.hasProperty(key);
+    };
+    /**
+     * Copies every explicit property of `source` into this store, keeping explicitness.
+     *
+     * @param {ExplicitPropertyStore} source Store to copy from.
+     * @returns {void}
+     * @private
+     */
+    ExplicitPropertyStore.prototype.copyExplicitFrom = function (source) {
+        var _this = this;
+        source._values.forEach(function (value, key) { return _this._values.set(key, value); });
+    };
+    /**
+     * Whether both stores hold the same explicit keys with equal values.
+     *
+     * @param {ExplicitPropertyStore} other Store to compare with.
+     * @returns {boolean} True when the explicit properties are identical.
+     * @private
+     */
+    ExplicitPropertyStore.prototype.explicitEquals = function (other) {
+        if (this._values.size !== other._values.size) {
+            return false;
+        }
+        var equal = true;
+        this._values.forEach(function (value, key) {
+            if (!other._values.has(key) || other._values.get(key) !== value) {
+                equal = false;
+            }
+        });
+        return equal;
+    };
+    /** Hook invoked after any mutation of the store. */
+    ExplicitPropertyStore.prototype.propertyChanged = function () {
+        // overridden by owner-aware subclasses
+    };
+    return ExplicitPropertyStore;
+}());
+export { ExplicitPropertyStore };

package/src/office-common/features/mathml/office-math/run-element.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Run element (`m:r`) holding a document-native run.
+ */
+import { MathFunctionType } from './enums';
+import { OfficeMathFunctionBase } from './function-base';
+import { OfficeMathFormat } from './format';
+import { OfficeRun } from './adapter';
+import { OfficeMathEntity } from './entity';
+/**
+ * Math run: native document run plus Math format (`m:rPr`).
+ *
+ * @public
+ */
+export declare class OfficeMathRunElement extends OfficeMathFunctionBase {
+    readonly type = MathFunctionType.RunElement;
+    private _item;
+    private readonly _mathFormat;
+    constructor(owner?: OfficeMathEntity);
+    /** The native document run. */
+    item: OfficeRun | undefined;
+    /**
+     * Text of the run (`m:t`). Uses the host adapter when the run is attached to a paragraph
+     * that has one, otherwise a standalone run. Empty when no run exists yet.
+     *
+     * @returns {string} The run text.
+     */
+    text: string;
+    private findAdapter;
+    /** Math run format (`m:rPr`). */
+    readonly mathFormat: OfficeMathFormat;
+}