@syncfusion/ej2-office-common 35.1.37 → 35.1.43

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

@@ -0,0 +1,203 @@
+/**
+ * Deep clone of 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 };
+        }
+    };
+};
+import { MathFunctionType } from './enums';
+import { OfficeMath } from './office-math';
+import { OfficeMathParagraph } from './math-paragraph';
+import { OfficeMathUnknownElement } from './unknown-element';
+import { OfficeMathBreak } from './break';
+import { BasicRun } from './basic';
+import { childEquations } from './math-traversal';
+/**
+ * Implementation helper. @private
+ *
+ * @param {OfficeMathBreak} source The source object.
+ * @returns {OfficeMathBreak} The result.
+ */
+function cloneBreak(source) {
+    var copy = new OfficeMathBreak();
+    copy.copyExplicitFrom(source);
+    return copy;
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {OfficeMathRunElement} source The source object.
+ * @param {OfficeMathRunElement} target The target to populate.
+ * @param {OfficeMathParagraph} root The owning Math paragraph.
+ * @returns {void}
+ */
+function cloneRunContent(source, target, root) {
+    target.mathFormat.copyExplicitFrom(source.mathFormat);
+    if (source.mathFormat.break !== undefined) {
+        target.mathFormat.break = cloneBreak(source.mathFormat.break);
+    }
+    if (source.item === undefined) {
+        return;
+    }
+    if (root.adapter !== undefined) {
+        target.item = root.adapter.cloneRun(source.item);
+    }
+    else {
+        if (source.item instanceof BasicRun) {
+            target.item = source.item.clone();
+        }
+        else {
+            var run = new BasicRun();
+            run.text = source.text;
+            target.item = run;
+        }
+    }
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {OfficeMathFunctionBase} source The source object.
+ * @param {OfficeMathFunctionBase} target The target to populate.
+ * @returns {void}
+ */
+function prepareStructure(source, target) {
+    if (source.type === MathFunctionType.Matrix) {
+        var from = source;
+        var to_1 = target;
+        from.columns.toArray().forEach(function (column) { return to_1.columns.add().copyExplicitFrom(column); });
+        from.rowItems.forEach(function (row) { return to_1.rows.add().copyExplicitFrom(row); });
+    }
+    else if (source.type === MathFunctionType.Delimiter || source.type === MathFunctionType.EquationArray) {
+        var from = source;
+        var to = target;
+        for (var i = 0; i < from.equations.count; i++) {
+            to.equations.add();
+        }
+    }
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {OfficeMathFunctionBase} source The source object.
+ * @param {OfficeMathFunctionBase} target The target to populate.
+ * @returns {void}
+ */
+function copyFunctionState(source, target) {
+    target.copyExplicitFrom(source);
+    if (source.hasControlProperties) {
+        target.controlProperties = source.controlProperties.clone();
+    }
+    if (source.type === MathFunctionType.Box && source.break !== undefined) {
+        var sourceBreak = source.break;
+        var from = source.ownerMathEntity instanceof OfficeMath ? source.ownerMathEntity : undefined;
+        var to = target.ownerMathEntity instanceof OfficeMath ? target.ownerMathEntity : undefined;
+        var index = from !== undefined ? from.breaks.toArray().indexOf(sourceBreak) : -1;
+        target.break = index >= 0 && to !== undefined ? to.breaks.getItem(index) : cloneBreak(sourceBreak);
+    }
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {OfficeMathFunctionBase} source The source object.
+ * @param {OfficeMath} destination The destination equation.
+ * @param {OfficeMathParagraph} root The owning Math paragraph.
+ * @returns {void}
+ */
+function cloneFunctionInto(source, destination, root) {
+    if (source instanceof OfficeMathUnknownElement) {
+        destination.functions.insert(destination.functions.count, new OfficeMathUnknownElement(source.localName, source.preservedXml));
+        return;
+    }
+    var target = destination.functions.add(source.type);
+    copyFunctionState(source, target);
+    if (source.type === MathFunctionType.RunElement) {
+        cloneRunContent(source, target, root);
+        return;
+    }
+    prepareStructure(source, target);
+    var from = childEquations(source);
+    var to = childEquations(target);
+    from.forEach(function (child, i) { return cloneEquationInto(child, to[i], root); });
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {OfficeMath} source The source object.
+ * @param {OfficeMath} target The target to populate.
+ * @param {OfficeMathParagraph} root The owning Math paragraph.
+ * @returns {void}
+ */
+function cloneEquationInto(source, target, root) {
+    var e_1, _a, e_2, _b;
+    target.copyExplicitFrom(source);
+    target.preservedControlProperties = source.preservedControlProperties;
+    try {
+        for (var _c = __values(source.breaks), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var brk = _d.value;
+            target.breaks.add().copyExplicitFrom(brk);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    try {
+        for (var _e = __values(source.functions), _f = _e.next(); !_f.done; _f = _e.next()) {
+            var fn = _f.value;
+            cloneFunctionInto(fn, target, root);
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+}
+/**
+ * Deep-clones an equation as a new, detached equation.
+ *
+ * @param {OfficeMath} source The equation to clone.
+ * @param {OfficeMathParagraph} root Paragraph that supplies the host adapter for the copy.
+ * @returns {OfficeMath} An attached copy living under `root`.
+ */
+export function cloneOfficeMath(source, root) {
+    var copy = root.maths.add();
+    cloneEquationInto(source, copy, root);
+    return copy;
+}
+/**
+ * Deep-clones a Math paragraph including explicit properties, owners and unknown elements.
+ *
+ * @param {OfficeMathParagraph} source The paragraph to clone.
+ * @returns {OfficeMathParagraph} An independent copy.
+ */
+export function cloneOfficeMathParagraph(source) {
+    var e_3, _a;
+    var copy = new OfficeMathParagraph(source.adapter);
+    copy.copyExplicitFrom(source);
+    try {
+        for (var _b = __values(source.maths), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var math = _c.value;
+            cloneOfficeMath(math, copy);
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return copy;
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Collection of equations (`OfficeMath`).
+ */
+import { OwnedCollection, CollectionOwner } from './collection';
+import { OfficeMath } from './office-math';
+/**
+ * Ordered collection of {@link OfficeMath} equations.
+ *
+ * @public
+ */
+export declare class OfficeMathCollection extends OwnedCollection<OfficeMath> {
+    constructor(owner: CollectionOwner);
+    /**
+     * Creates an equation and appends it, or inserts it at `index`.
+     *
+     * @param index
+     */
+    add(index?: number): OfficeMath;
+}

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

@@ -0,0 +1,41 @@
+/**
+ * Collection of equations (`OfficeMath`).
+ */
+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';
+/**
+ * Ordered collection of {@link OfficeMath} equations.
+ *
+ * @public
+ */
+var OfficeMathCollection = /** @class */ (function (_super) {
+    __extends(OfficeMathCollection, _super);
+    function OfficeMathCollection(owner) {
+        return _super.call(this, owner) || this;
+    }
+    /**
+     * Creates an equation and appends it, or inserts it at `index`.
+     *
+     * @param index
+     */
+    OfficeMathCollection.prototype.add = function (index) {
+        var item = new OfficeMath();
+        this.insertItem(index === undefined ? this.count : index, item);
+        return item;
+    };
+    return OfficeMathCollection;
+}(OwnedCollection));
+export { OfficeMathCollection };

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

@@ -0,0 +1,21 @@
+/**
+ * Semantic equality of two Math trees.
+ */
+import { OfficeMath } from './office-math';
+import { OfficeMathParagraph } from './math-paragraph';
+/**
+ * Semantic equality of two equations (shape, text, explicit properties).
+ *
+ * @param {OfficeMath} a First equation.
+ * @param {OfficeMath} b Second equation.
+ * @returns {boolean} True when both trees are equal.
+ */
+export declare function officeMathEquals(a: OfficeMath, b: OfficeMath): boolean;
+/**
+ * Semantic equality of two Math paragraphs.
+ *
+ * @param {OfficeMathParagraph} a First paragraph.
+ * @param {OfficeMathParagraph} b Second paragraph.
+ * @returns {boolean} True when both trees are equal.
+ */
+export declare function officeMathParagraphEquals(a: OfficeMathParagraph, b: OfficeMathParagraph): boolean;

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

@@ -0,0 +1,115 @@
+/**
+ * Semantic equality of two Math trees.
+ */
+import { MathFunctionType } from './enums';
+import { OfficeMathUnknownElement } from './unknown-element';
+import { childEquations, breakOf } from './math-traversal';
+import { xmlEqual } from './xml-equal';
+/**
+ * Implementation helper. @private
+ *
+ * @param {OfficeMathBreak | undefined} a First object.
+ * @param {OfficeMathBreak | undefined} b Second object.
+ * @returns {boolean} The result.
+ */
+function breakEqual(a, b) {
+    if (a === undefined || b === undefined) {
+        return a === b;
+    }
+    return a.explicitEquals(b);
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {OfficeMathFunctionBase} a First object.
+ * @param {OfficeMathFunctionBase} b Second object.
+ * @returns {boolean} The result.
+ */
+function controlEqual(a, b) {
+    if (a.hasControlProperties !== b.hasControlProperties) {
+        return false;
+    }
+    if (!a.hasControlProperties) {
+        return true;
+    }
+    var fa = a.controlProperties;
+    return fa.equals === undefined || fa.equals(b.controlProperties);
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {OfficeMathMatrix} a First object.
+ * @param {OfficeMathMatrix} b Second object.
+ * @returns {boolean} The result.
+ */
+function matrixShapeEqual(a, b) {
+    var ca = a.columns.toArray();
+    var cb = b.columns.toArray();
+    var ra = a.rowItems;
+    var rb = b.rowItems;
+    return ca.length === cb.length && ra.length === rb.length
+        && ca.every(function (c, i) { return c.explicitEquals(cb[i]); })
+        && ra.every(function (r, i) { return r.explicitEquals(rb[i]); });
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {OfficeMathFunctionBase} a First object.
+ * @param {OfficeMathFunctionBase} b Second object.
+ * @returns {boolean} The result.
+ */
+function functionEqual(a, b) {
+    if (a.type !== b.type || !a.explicitEquals(b) || !controlEqual(a, b)) {
+        return false;
+    }
+    if (a instanceof OfficeMathUnknownElement) {
+        var other = b;
+        return a.localName === other.localName && xmlEqual(a.preservedXml, other.preservedXml);
+    }
+    if (!breakEqual(breakOf(a), breakOf(b))) {
+        return false;
+    }
+    if (a.type === MathFunctionType.RunElement) {
+        var ra = a;
+        var rb = b;
+        return ra.text === rb.text && ra.mathFormat.explicitEquals(rb.mathFormat);
+    }
+    if (a.type === MathFunctionType.Matrix && !matrixShapeEqual(a, b)) {
+        return false;
+    }
+    var ca = childEquations(a);
+    var cb = childEquations(b);
+    return ca.length === cb.length && ca.every(function (c, i) { return officeMathEquals(c, cb[i]); });
+}
+/**
+ * Semantic equality of two equations (shape, text, explicit properties).
+ *
+ * @param {OfficeMath} a First equation.
+ * @param {OfficeMath} b Second equation.
+ * @returns {boolean} True when both trees are equal.
+ */
+export function officeMathEquals(a, b) {
+    if (!a.explicitEquals(b) || a.functions.count !== b.functions.count || a.breaks.count !== b.breaks.count) {
+        return false;
+    }
+    var bb = b.breaks.toArray();
+    if (!a.breaks.toArray().every(function (x, i) { return breakEqual(x, bb[i]); })) {
+        return false;
+    }
+    var fb = b.functions.toArray();
+    return a.functions.toArray().every(function (f, i) { return functionEqual(f, fb[i]); });
+}
+/**
+ * Semantic equality of two Math paragraphs.
+ *
+ * @param {OfficeMathParagraph} a First paragraph.
+ * @param {OfficeMathParagraph} b Second paragraph.
+ * @returns {boolean} True when both trees are equal.
+ */
+export function officeMathParagraphEquals(a, b) {
+    if (!a.explicitEquals(b) || a.maths.count !== b.maths.count) {
+        return false;
+    }
+    var mb = b.maths.toArray();
+    return a.maths.toArray().every(function (m, i) { return officeMathEquals(m, mb[i]); });
+}

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

@@ -0,0 +1,58 @@
+/**
+ * Office Math paragraph (`m:oMathPara`): the root of the Math model.
+ */
+import { OwnerHolder } from './owner-holder';
+import { OfficeMathCollection } from './math-collection';
+import { MathJustification } from './enums';
+import { MathDocumentAdapter, OfficeRunFormat } from './adapter';
+/**
+ * Root container of equations. Notifies a host listener on any change below it.
+ *
+ * @public
+ */
+export declare class OfficeMathParagraph extends OwnerHolder {
+    private readonly _maths;
+    private _listener;
+    private _suspended;
+    readonly adapter: MathDocumentAdapter | undefined;
+    constructor(adapter?: MathDocumentAdapter);
+    /** Equations of the paragraph. */
+    readonly maths: OfficeMathCollection;
+    /** Paragraph justification. Default center-group. */
+    justification: MathJustification;
+    /** Whether the justification was set or parsed explicitly. */
+    readonly hasExplicitJustification: boolean;
+    /** Default Math character format used to seed function control properties. */
+    readonly defaultMathCharacterFormat: OfficeRunFormat;
+    /**
+     * LaTeX of the current equations, generated from the live Math tree.
+     * Assigning replaces all equations on this same paragraph.
+     */
+    latex: string;
+    /**
+     * Replaces all equations with those parsed from `latex`. The paragraph keeps its identity, owner,
+     * adapter and mutation listener; one mutation notification is raised after the replacement.
+     * An empty string leaves the paragraph without equations.
+     *
+     * @param {string} latex The LaTeX source.
+     * @returns {void}
+     */
+    convertLatexToMath(latex: string): void;
+    /**
+     * Registers a callback invoked after any change in the Math tree.
+     *
+     * @param {Function} listener The mutation callback, or undefined to clear it.
+     * @returns {void}
+     */
+    setMutationListener(listener: (() => void) | undefined): void;
+    /**
+     * Runs `action` without raising mutation notifications, then restores notifications.
+     * Used while hydrating the model from XML.
+     *
+     * @param {Function} action The work to perform silently.
+     * @returns {void}
+     * @private
+     */
+    suspendMutations(action: () => void): void;
+    protected rootMutated(): void;
+}

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

@@ -0,0 +1,126 @@
+/**
+ * Office Math paragraph (`m:oMathPara`): the root of the Math model.
+ */
+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 { OfficeMathCollection } from './math-collection';
+import { MathJustification } from './enums';
+import { K } from './keys';
+import { BasicRunFormat } from './basic';
+import { parseLatexIntoMathParagraph } from '../latex/latex-parser';
+import { mathToLatex } from '../latex/latex-generator';
+/**
+ * Root container of equations. Notifies a host listener on any change below it.
+ *
+ * @public
+ */
+var OfficeMathParagraph = /** @class */ (function (_super) {
+    __extends(OfficeMathParagraph, _super);
+    function OfficeMathParagraph(adapter) {
+        var _this = _super.call(this) || this;
+        _this._suspended = 0;
+        _this.adapter = adapter;
+        _this._maths = new OfficeMathCollection(_this);
+        return _this;
+    }
+    Object.defineProperty(OfficeMathParagraph.prototype, "maths", {
+        /** Equations of the paragraph. */
+        get: function () { return this._maths; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathParagraph.prototype, "justification", {
+        /** Paragraph justification. Default center-group. */
+        get: function () {
+            return this.getProperty(K.Justification, function () { return MathJustification.CenterGroup; });
+        },
+        set: function (value) { this.setProperty(K.Justification, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathParagraph.prototype, "hasExplicitJustification", {
+        /** Whether the justification was set or parsed explicitly. */
+        get: function () { return this.isExplicit(K.Justification); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathParagraph.prototype, "defaultMathCharacterFormat", {
+        /** Default Math character format used to seed function control properties. */
+        get: function () {
+            return this.adapter !== undefined
+                ? this.adapter.createDefaultMathCharacterFormat(this)
+                : new BasicRunFormat();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathParagraph.prototype, "latex", {
+        /**
+         * LaTeX of the current equations, generated from the live Math tree.
+         * Assigning replaces all equations on this same paragraph.
+         */
+        get: function () { return mathToLatex(this); },
+        set: function (value) { this.convertLatexToMath(value); },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Replaces all equations with those parsed from `latex`. The paragraph keeps its identity, owner,
+     * adapter and mutation listener; one mutation notification is raised after the replacement.
+     * An empty string leaves the paragraph without equations.
+     *
+     * @param {string} latex The LaTeX source.
+     * @returns {void}
+     */
+    OfficeMathParagraph.prototype.convertLatexToMath = function (latex) {
+        var _this = this;
+        this.suspendMutations(function () {
+            _this._maths.clear();
+            parseLatexIntoMathParagraph(latex, _this);
+        });
+        this.notifyMutated();
+    };
+    /**
+     * Registers a callback invoked after any change in the Math tree.
+     *
+     * @param {Function} listener The mutation callback, or undefined to clear it.
+     * @returns {void}
+     */
+    OfficeMathParagraph.prototype.setMutationListener = function (listener) { this._listener = listener; };
+    /**
+     * Runs `action` without raising mutation notifications, then restores notifications.
+     * Used while hydrating the model from XML.
+     *
+     * @param {Function} action The work to perform silently.
+     * @returns {void}
+     * @private
+     */
+    OfficeMathParagraph.prototype.suspendMutations = function (action) {
+        this._suspended++;
+        try {
+            action();
+        }
+        finally {
+            this._suspended--;
+        }
+    };
+    OfficeMathParagraph.prototype.rootMutated = function () {
+        if (this._suspended === 0 && this._listener !== undefined) {
+            this._listener();
+        }
+    };
+    return OfficeMathParagraph;
+}(OwnerHolder));
+export { OfficeMathParagraph };

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

@@ -0,0 +1,23 @@
+/**
+ * Structural traversal shared by clone and equality over the Math model.
+ */
+import { OfficeMathFunctionBase } from './function-base';
+import { OfficeMath } from './office-math';
+import { OfficeMathBreak } from './break';
+/**
+ * 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 declare function childEquations(fn: OfficeMathFunctionBase): OfficeMath[];
+/**
+ * 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 declare function breakOf(fn: OfficeMathFunctionBase): OfficeMathBreak | undefined;