@syncfusion/ej2-office-common 35.1.37 → 35.1.43

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

@@ -0,0 +1,95 @@
+/**
+ * Structural traversal shared by clone and equality over the Math model.
+ */
+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 };
+        }
+    };
+};
+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;
+};
+import { MathFunctionType } from './enums';
+import { OfficeMath } from './office-math';
+/**
+ * Lists the child equations of a function in a fixed, schema-like order.
+ * Matrix cells are listed row by row.
+ *
+ * @param {OfficeMathFunctionBase} fn The function to inspect.
+ * @returns {OfficeMath[]} Child equations in order.
+ * @private
+ */
+export function childEquations(fn) {
+    var holder = fn;
+    if (fn.type === MathFunctionType.Matrix) {
+        var cells_1 = [];
+        fn.rowItems.forEach(function (row) {
+            var e_1, _a;
+            try {
+                for (var _b = __values(row.arguments), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var cell = _c.value;
+                    cells_1.push(cell);
+                }
+            }
+            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; }
+            }
+        });
+        return cells_1;
+    }
+    var result = [];
+    ['equation', 'degree', 'numerator', 'denominator', 'functionName', 'limit', 'script', 'subscript', 'superscript']
+        .forEach(function (name) {
+        var value = holder[name];
+        if (value instanceof OfficeMath) {
+            result.push(value);
+        }
+    });
+    var list = holder['equations'];
+    if (list !== undefined) {
+        result.push.apply(result, __spread(Array.from(list)));
+    }
+    return result;
+}
+/**
+ * Returns the manual break owned by a box or run element.
+ *
+ * @param {OfficeMathFunctionBase} fn The function to inspect.
+ * @returns {OfficeMathBreak | undefined} The break, when present.
+ * @private
+ */
+export function breakOf(fn) {
+    if (fn.type === MathFunctionType.Box) {
+        return fn.break;
+    }
+    if (fn.type === MathFunctionType.RunElement) {
+        return fn.mathFormat.break;
+    }
+    return undefined;
+}

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

@@ -0,0 +1,54 @@
+/**
+ * Matrix row and column collections that keep rows and columns synchronized.
+ */
+import { OwnedCollection } from './collection';
+import { OfficeMathMatrixRow } from './matrix-row';
+import { OfficeMathMatrixColumn } from './matrix-column';
+import { OfficeMathMatrix } from './matrix';
+/**
+ * Rows of a matrix. New rows receive one cell per existing column.
+ *
+ * @public
+ */
+export declare class OfficeMathMatrixRowCollection extends OwnedCollection<OfficeMathMatrixRow> {
+    private readonly matrix;
+    constructor(matrix: OfficeMathMatrix);
+    /**
+     * Creates a row and appends it, or inserts it at `index`.
+     *
+     * @param index
+     */
+    add(index?: number): OfficeMathMatrixRow;
+    protected afterChange(): void;
+}
+/**
+ * Columns of a matrix. Adding or removing a column adds or removes the cell in every row.
+ *
+ * @public
+ */
+export declare class OfficeMathMatrixColumnCollection extends OwnedCollection<OfficeMathMatrixColumn> {
+    private readonly matrix;
+    constructor(matrix: OfficeMathMatrix);
+    /**
+     * Creates a column and appends it, or inserts it at `index`.
+     *
+     * @param index
+     */
+    add(index?: number): OfficeMathMatrixColumn;
+    /**
+     * Removes the column and its cell in every row.
+     *
+     * @param index
+     */
+    removeAt(index: number): void;
+    /** Removes all columns and every cell. */
+    clear(): void;
+    protected afterChange(): void;
+    /**
+     * Adds the matching cell to every row once the column is inserted.
+     *
+     * @param index
+     * @param item
+     */
+    insertItem(index: number, item: OfficeMathMatrixColumn): void;
+}

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

@@ -0,0 +1,113 @@
+/**
+ * Matrix row and column collections that keep rows and columns synchronized.
+ */
+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 { OwnedCollection } from './collection';
+import { OfficeMath } from './office-math';
+import { OfficeMathMatrixRow } from './matrix-row';
+import { OfficeMathMatrixColumn } from './matrix-column';
+/**
+ * Rows of a matrix. New rows receive one cell per existing column.
+ *
+ * @public
+ */
+var OfficeMathMatrixRowCollection = /** @class */ (function (_super) {
+    __extends(OfficeMathMatrixRowCollection, _super);
+    function OfficeMathMatrixRowCollection(matrix) {
+        var _this = _super.call(this, matrix) || this;
+        _this.matrix = matrix;
+        return _this;
+    }
+    /**
+     * Creates a row and appends it, or inserts it at `index`.
+     *
+     * @param index
+     */
+    OfficeMathMatrixRowCollection.prototype.add = function (index) {
+        var row = new OfficeMathMatrixRow();
+        var columnCount = this.matrix.columns.count;
+        for (var i = 0; i < columnCount; i++) {
+            row.arguments.pushRaw(new OfficeMath(row));
+        }
+        this.insertItem(index === undefined ? this.count : index, row);
+        return row;
+    };
+    OfficeMathMatrixRowCollection.prototype.afterChange = function () {
+        this.matrix.relink();
+        _super.prototype.afterChange.call(this);
+    };
+    return OfficeMathMatrixRowCollection;
+}(OwnedCollection));
+export { OfficeMathMatrixRowCollection };
+/**
+ * Columns of a matrix. Adding or removing a column adds or removes the cell in every row.
+ *
+ * @public
+ */
+var OfficeMathMatrixColumnCollection = /** @class */ (function (_super) {
+    __extends(OfficeMathMatrixColumnCollection, _super);
+    function OfficeMathMatrixColumnCollection(matrix) {
+        var _this = _super.call(this, matrix) || this;
+        _this.matrix = matrix;
+        return _this;
+    }
+    /**
+     * Creates a column and appends it, or inserts it at `index`.
+     *
+     * @param index
+     */
+    OfficeMathMatrixColumnCollection.prototype.add = function (index) {
+        var position = index === undefined ? this.count : index;
+        var column = new OfficeMathMatrixColumn();
+        this.insertItem(position, column);
+        return column;
+    };
+    /**
+     * Removes the column and its cell in every row.
+     *
+     * @param index
+     */
+    OfficeMathMatrixColumnCollection.prototype.removeAt = function (index) {
+        _super.prototype.removeAt.call(this, index);
+        this.matrix.rowItems.forEach(function (row) { return row.arguments.removeRawAt(index); });
+        this.matrix.relink();
+    };
+    /** Removes all columns and every cell. */
+    OfficeMathMatrixColumnCollection.prototype.clear = function () {
+        _super.prototype.clear.call(this);
+        this.matrix.rowItems.forEach(function (row) {
+            while (row.arguments.count > 0) {
+                row.arguments.removeRawAt(row.arguments.count - 1);
+            }
+        });
+    };
+    OfficeMathMatrixColumnCollection.prototype.afterChange = function () {
+        this.matrix.relink();
+        _super.prototype.afterChange.call(this);
+    };
+    /**
+     * Adds the matching cell to every row once the column is inserted.
+     *
+     * @param index
+     * @param item
+     */
+    OfficeMathMatrixColumnCollection.prototype.insertItem = function (index, item) {
+        _super.prototype.insertItem.call(this, index, item);
+        this.matrix.rowItems.forEach(function (row) { return row.arguments.insertRaw(index, new OfficeMath(row)); });
+        this.matrix.relink();
+    };
+    return OfficeMathMatrixColumnCollection;
+}(OwnedCollection));
+export { OfficeMathMatrixColumnCollection };

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

@@ -0,0 +1,43 @@
+/**
+ * Matrix column.
+ */
+import { OwnerHolder } from './owner-holder';
+import { MathHorizontalAlignment } from './enums';
+import { OfficeMath } from './office-math';
+import { OfficeMathMatrix } from './matrix';
+/**
+ * Read-only view of the cells of one column.
+ *
+ * @public
+ */
+export declare class OfficeMathMatrixColumnArguments {
+    [index: number]: OfficeMath;
+    private readonly _items;
+    constructor(items: OfficeMath[]);
+    /** Number of cells. */
+    readonly count: number;
+    /**
+     * Returns the cell at `index`.
+     *
+     * @param index
+     */
+    getItem(index: number): OfficeMath;
+    /** Not supported: cells are created when rows are added. */
+    add(): never;
+    /** Iterates the cells top to bottom. */
+    [Symbol.iterator](): Iterator<OfficeMath>;
+}
+/**
+ * Column of a matrix.
+ *
+ * @public
+ */
+export declare class OfficeMathMatrixColumn extends OwnerHolder {
+    constructor(owner?: OfficeMathMatrix);
+    /** Horizontal alignment of the column. Default center. */
+    horizontalAlignment: MathHorizontalAlignment;
+    /** Index of the column in its matrix, or -1 when detached. */
+    readonly columnIndex: number;
+    /** Cells of this column, one per row. */
+    readonly arguments: OfficeMathMatrixColumnArguments;
+}

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

@@ -0,0 +1,96 @@
+/**
+ * Matrix column.
+ */
+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 { MathHorizontalAlignment } from './enums';
+import { K } from './keys';
+/**
+ * Read-only view of the cells of one column.
+ *
+ * @public
+ */
+var OfficeMathMatrixColumnArguments = /** @class */ (function () {
+    function OfficeMathMatrixColumnArguments(items) {
+        var _this = this;
+        this._items = items;
+        items.forEach(function (item, i) { _this[i] = item; });
+    }
+    Object.defineProperty(OfficeMathMatrixColumnArguments.prototype, "count", {
+        /** Number of cells. */
+        get: function () { return this._items.length; },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Returns the cell at `index`.
+     *
+     * @param index
+     */
+    OfficeMathMatrixColumnArguments.prototype.getItem = function (index) {
+        if (!(index >= 0 && index < this._items.length)) {
+            throw new RangeError('Index ' + index + ' is out of range.');
+        }
+        return this._items[index];
+    };
+    /** Not supported: cells are created when rows are added. */
+    OfficeMathMatrixColumnArguments.prototype.add = function () { throw new Error('Cells are managed by the matrix; add a row instead.'); };
+    /** Iterates the cells top to bottom. */
+    OfficeMathMatrixColumnArguments.prototype[Symbol.iterator] = function () { return this._items[Symbol.iterator](); };
+    return OfficeMathMatrixColumnArguments;
+}());
+export { OfficeMathMatrixColumnArguments };
+/**
+ * Column of a matrix.
+ *
+ * @public
+ */
+var OfficeMathMatrixColumn = /** @class */ (function (_super) {
+    __extends(OfficeMathMatrixColumn, _super);
+    function OfficeMathMatrixColumn(owner) {
+        return _super.call(this, owner) || this;
+    }
+    Object.defineProperty(OfficeMathMatrixColumn.prototype, "horizontalAlignment", {
+        /** Horizontal alignment of the column. Default center. */
+        get: function () {
+            return this.getProperty(K.MatrixAlign, function () { return MathHorizontalAlignment.Center; });
+        },
+        set: function (value) { this.setProperty(K.MatrixAlign, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathMatrixColumn.prototype, "columnIndex", {
+        /** Index of the column in its matrix, or -1 when detached. */
+        get: function () {
+            var matrix = this.ownerMathEntity;
+            return matrix === undefined ? -1 : matrix.columns.toArray().indexOf(this);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathMatrixColumn.prototype, "arguments", {
+        /** Cells of this column, one per row. */
+        get: function () {
+            var matrix = this.ownerMathEntity;
+            var index = this.columnIndex;
+            var cells = matrix === undefined ? [] : matrix.rowItems.map(function (row) { return row.arguments.getItem(index); });
+            return new OfficeMathMatrixColumnArguments(cells);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return OfficeMathMatrixColumn;
+}(OwnerHolder));
+export { OfficeMathMatrixColumn };

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

@@ -0,0 +1,38 @@
+/**
+ * Matrix row.
+ */
+import { OwnerHolder } from './owner-holder';
+import { OwnedCollection, CollectionOwner } from './collection';
+import { OfficeMath } from './office-math';
+import { OfficeMathMatrix } from './matrix';
+/**
+ * Cells of a row. Managed by matrix synchronization, so direct mutation is rejected.
+ *
+ * @public
+ */
+export declare class OfficeMathMatrixRowArguments extends OwnedCollection<OfficeMath> {
+    constructor(owner: CollectionOwner);
+    /** Not supported: cells are created when columns are added. */
+    add(): never;
+    /** Not supported: cells are managed by the matrix. */
+    insert(): never;
+    /** Not supported: cells are managed by the matrix. */
+    removeAt(): never;
+    /** Not supported: cells are managed by the matrix. */
+    remove(): never;
+    /** Not supported: cells are managed by the matrix. */
+    clear(): never;
+}
+/**
+ * Row of a matrix holding one cell per column.
+ *
+ * @public
+ */
+export declare class OfficeMathMatrixRow extends OwnerHolder {
+    private readonly _arguments;
+    constructor(owner?: OfficeMathMatrix);
+    /** Cells of the row. */
+    readonly arguments: OfficeMathMatrixRowArguments;
+    /** Index of the row in its matrix, or -1 when detached. */
+    readonly rowIndex: number;
+}

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

@@ -0,0 +1,71 @@
+/**
+ * Matrix row.
+ */
+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 { OwnedCollection } from './collection';
+/**
+ * Cells of a row. Managed by matrix synchronization, so direct mutation is rejected.
+ *
+ * @public
+ */
+var OfficeMathMatrixRowArguments = /** @class */ (function (_super) {
+    __extends(OfficeMathMatrixRowArguments, _super);
+    function OfficeMathMatrixRowArguments(owner) {
+        return _super.call(this, owner) || this;
+    }
+    /** Not supported: cells are created when columns are added. */
+    OfficeMathMatrixRowArguments.prototype.add = function () { throw new Error('Cells are managed by the matrix; add a column instead.'); };
+    /** Not supported: cells are managed by the matrix. */
+    OfficeMathMatrixRowArguments.prototype.insert = function () { throw new Error('Cells are managed by the matrix.'); };
+    /** Not supported: cells are managed by the matrix. */
+    OfficeMathMatrixRowArguments.prototype.removeAt = function () { throw new Error('Cells are managed by the matrix; remove a column instead.'); };
+    /** Not supported: cells are managed by the matrix. */
+    OfficeMathMatrixRowArguments.prototype.remove = function () { throw new Error('Cells are managed by the matrix; remove a column instead.'); };
+    /** Not supported: cells are managed by the matrix. */
+    OfficeMathMatrixRowArguments.prototype.clear = function () { throw new Error('Cells are managed by the matrix; remove columns instead.'); };
+    return OfficeMathMatrixRowArguments;
+}(OwnedCollection));
+export { OfficeMathMatrixRowArguments };
+/**
+ * Row of a matrix holding one cell per column.
+ *
+ * @public
+ */
+var OfficeMathMatrixRow = /** @class */ (function (_super) {
+    __extends(OfficeMathMatrixRow, _super);
+    function OfficeMathMatrixRow(owner) {
+        var _this = _super.call(this, owner) || this;
+        _this._arguments = new OfficeMathMatrixRowArguments(_this);
+        return _this;
+    }
+    Object.defineProperty(OfficeMathMatrixRow.prototype, "arguments", {
+        /** Cells of the row. */
+        get: function () { return this._arguments; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathMatrixRow.prototype, "rowIndex", {
+        /** Index of the row in its matrix, or -1 when detached. */
+        get: function () {
+            var matrix = this.ownerMathEntity;
+            return matrix === undefined ? -1 : matrix.rowItems.indexOf(this);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return OfficeMathMatrixRow;
+}(OwnerHolder));
+export { OfficeMathMatrixRow };

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

@@ -0,0 +1,62 @@
+/**
+ * Matrix (`m:m`) function.
+ */
+import { MathFunctionType, MathVerticalAlignment, MathHorizontalAlignment, SpacingRule } from './enums';
+import { OfficeMathFunctionBase } from './function-base';
+import { OfficeMathEntity } from './entity';
+import { OfficeMathMatrixRow } from './matrix-row';
+import { OfficeMathMatrixRowCollection, OfficeMathMatrixColumnCollection } from './matrix-collections';
+/** A run of consecutive columns that share the same horizontal alignment (`m:mcs`). @public */
+export interface MatrixColumnGroup {
+    /** Index of the first column in the group. */
+    startIndex: number;
+    /** Number of columns in the group. */
+    count: number;
+    /** Shared horizontal alignment. */
+    horizontalAlignment: MathHorizontalAlignment;
+}
+/**
+ * Matrix whose rows and columns are kept synchronized: every row always has one cell per column.
+ *
+ * @public
+ */
+export declare class OfficeMathMatrix extends OfficeMathFunctionBase {
+    readonly type = MathFunctionType.Matrix;
+    private readonly _rows;
+    private readonly _columns;
+    constructor(owner?: OfficeMathEntity);
+    /** Rows of the matrix. */
+    readonly rows: OfficeMathMatrixRowCollection;
+    /** Columns of the matrix. */
+    readonly columns: OfficeMathMatrixColumnCollection;
+    /** Vertical alignment. Default center. */
+    verticalAlignment: MathVerticalAlignment;
+    /** Hides placeholders for empty cells. Default false. */
+    hidePlaceholder: boolean;
+    /** Row spacing; unit depends on `rowSpacingRule`. Default 0. */
+    rowSpacing: number;
+    /** Row spacing rule (`m:rSpRule`). Default single. */
+    rowSpacingRule: SpacingRule;
+    /** Column gap (`m:cGp`). Default 0. */
+    columnGap: number;
+    /** Column gap rule (`m:cGpRule`). Default single. */
+    columnGapRule: SpacingRule;
+    /** DocIO-compatible alias of `hidePlaceholder` (`m:plcHide`). */
+    hidePlaceHolders: boolean;
+    /** DocIO-compatible alias of `columnGapRule` (`m:cGpRule`). */
+    columnSpacingRule: SpacingRule;
+    /** DocIO-compatible name for the column width (`m:cSp`); shares storage with `columnSpacing`. */
+    columnWidth: number;
+    /** Column spacing (`m:cSp`). Default 0. */
+    columnSpacing: number;
+    /** Column groups: consecutive columns with identical alignment, in order. */
+    readonly columnGroups: MatrixColumnGroup[];
+    /**
+     * Re-links every cell to its row and column after a structural change.
+     *
+     * @private
+     */
+    relink(): void;
+    /** @private */
+    readonly rowItems: OfficeMathMatrixRow[];
+}