@syncfusion/ej2-office-common 35.1.37 → 35.1.42

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

@@ -0,0 +1,407 @@
+/**
+ * Multi-equation Math functions: delimiter, equation array, fraction, function, limit, n-ary, scripts.
+ */
+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, MathDelimiterShapeType, MathFractionType, MathLimitType, MathScriptType, MathVerticalAlignment, SpacingRule } from './enums';
+import { K } from './keys';
+import { OfficeMathFunctionBase } from './function-base';
+import { OfficeMath } from './office-math';
+import { OfficeMathCollection } from './math-collection';
+/** Delimiter (`m:d`). @public */
+var OfficeMathDelimiter = /** @class */ (function (_super) {
+    __extends(OfficeMathDelimiter, _super);
+    function OfficeMathDelimiter(owner) {
+        var _this = _super.call(this, owner) || this;
+        _this.type = MathFunctionType.Delimiter;
+        _this._equations = new OfficeMathCollection(_this);
+        return _this;
+    }
+    Object.defineProperty(OfficeMathDelimiter.prototype, "beginCharacter", {
+        /** Opening character. Default `(`. */
+        get: function () { return this.getProperty(K.BegChar, function () { return '('; }); },
+        set: function (value) { this.setProperty(K.BegChar, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathDelimiter.prototype, "endCharacter", {
+        /** Closing character. Default `)`. */
+        get: function () { return this.getProperty(K.EndChar, function () { return ')'; }); },
+        set: function (value) { this.setProperty(K.EndChar, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathDelimiter.prototype, "separator", {
+        /** Separator character. Default `|`. */
+        get: function () { return this.getProperty(K.SeparatorChar, function () { return '|'; }); },
+        set: function (value) { this.setProperty(K.SeparatorChar, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathDelimiter.prototype, "isGrow", {
+        /** Whether delimiters grow with content. Default true. */
+        get: function () { return this.getProperty(K.Grow, function () { return true; }); },
+        set: function (value) { this.setProperty(K.Grow, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathDelimiter.prototype, "delimiterShape", {
+        /** Delimiter shape. Default centered. */
+        get: function () { return this.getProperty(K.Shape, function () { return MathDelimiterShapeType.Centered; }); },
+        set: function (value) { this.setProperty(K.Shape, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathDelimiter.prototype, "equations", {
+        /** Argument equations. */
+        get: function () { return this._equations; },
+        enumerable: true,
+        configurable: true
+    });
+    return OfficeMathDelimiter;
+}(OfficeMathFunctionBase));
+export { OfficeMathDelimiter };
+/**
+ * Validates a row spacing value against its rule.
+ *
+ * @param value
+ * @param rule
+ * @private
+ */
+export function checkRowSpacing(value, rule) {
+    if (rule === SpacingRule.Exactly && (value < 0 || value > 1584)) {
+        throw new RangeError('RowSpacing must be between 0 pt and 1584 pt for Exactly spacing rule.');
+    }
+    if (rule === SpacingRule.Multiple && (value < 0 || value > 132)) {
+        throw new RangeError('RowSpacing must be between 0 li and 132 li for Multiple spacing rule.');
+    }
+}
+/** Equation array (`m:eqArr`). @public */
+var OfficeMathEquationArray = /** @class */ (function (_super) {
+    __extends(OfficeMathEquationArray, _super);
+    function OfficeMathEquationArray(owner) {
+        var _this = _super.call(this, owner) || this;
+        _this.type = MathFunctionType.EquationArray;
+        _this._equations = new OfficeMathCollection(_this);
+        return _this;
+    }
+    Object.defineProperty(OfficeMathEquationArray.prototype, "verticalAlignment", {
+        /** Vertical alignment. Default center. */
+        get: function () { return this.getProperty(K.EqArrAlign, function () { return MathVerticalAlignment.Center; }); },
+        set: function (value) { this.setProperty(K.EqArrAlign, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathEquationArray.prototype, "expandEquationContainer", {
+        /** Expand container. Default false. */
+        get: function () { return this.getProperty(K.MaxDist, function () { return false; }); },
+        set: function (value) { this.setProperty(K.MaxDist, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathEquationArray.prototype, "expandEquationContent", {
+        /** Expand content. Default false. */
+        get: function () { return this.getProperty(K.ObjDist, function () { return false; }); },
+        set: function (value) { this.setProperty(K.ObjDist, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathEquationArray.prototype, "rowSpacing", {
+        /** Row spacing; unit depends on `rowSpacingRule` (points for Exactly, lines for Multiple). 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(OfficeMathEquationArray.prototype, "rowSpacingRule", {
+        /** Row spacing rule. 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(OfficeMathEquationArray.prototype, "equations", {
+        /** Row equations. */
+        get: function () { return this._equations; },
+        enumerable: true,
+        configurable: true
+    });
+    return OfficeMathEquationArray;
+}(OfficeMathFunctionBase));
+export { OfficeMathEquationArray };
+/** Fraction (`m:f`). @public */
+var OfficeMathFraction = /** @class */ (function (_super) {
+    __extends(OfficeMathFraction, _super);
+    function OfficeMathFraction(owner) {
+        var _this = _super.call(this, owner) || this;
+        _this.type = MathFunctionType.Fraction;
+        _this._denominator = new OfficeMath(_this);
+        _this._numerator = new OfficeMath(_this);
+        return _this;
+    }
+    Object.defineProperty(OfficeMathFraction.prototype, "fractionType", {
+        /** Fraction type. Default normal bar. */
+        get: function () { return this.getProperty(K.FractionType, function () { return MathFractionType.NormalFractionBar; }); },
+        set: function (value) { this.setProperty(K.FractionType, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathFraction.prototype, "numerator", {
+        /** Numerator. */
+        get: function () { return this._numerator; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathFraction.prototype, "denominator", {
+        /** Denominator. */
+        get: function () { return this._denominator; },
+        enumerable: true,
+        configurable: true
+    });
+    return OfficeMathFraction;
+}(OfficeMathFunctionBase));
+export { OfficeMathFraction };
+/** Function application (`m:func`). @public */
+var OfficeMathFunction = /** @class */ (function (_super) {
+    __extends(OfficeMathFunction, _super);
+    function OfficeMathFunction(owner) {
+        var _this = _super.call(this, owner) || this;
+        _this.type = MathFunctionType.Function;
+        _this._equation = new OfficeMath(_this);
+        _this._functionName = new OfficeMath(_this);
+        return _this;
+    }
+    Object.defineProperty(OfficeMathFunction.prototype, "equation", {
+        /** Argument equation. */
+        get: function () { return this._equation; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathFunction.prototype, "functionName", {
+        /** Function name equation. */
+        get: function () { return this._functionName; },
+        enumerable: true,
+        configurable: true
+    });
+    return OfficeMathFunction;
+}(OfficeMathFunctionBase));
+export { OfficeMathFunction };
+/** Lower or upper limit (`m:limLow` / `m:limUpp`). @public */
+var OfficeMathLimit = /** @class */ (function (_super) {
+    __extends(OfficeMathLimit, _super);
+    function OfficeMathLimit(owner) {
+        var _this = _super.call(this, owner) || this;
+        _this.type = MathFunctionType.Limit;
+        _this._equation = new OfficeMath(_this);
+        _this._limit = new OfficeMath(_this);
+        return _this;
+    }
+    Object.defineProperty(OfficeMathLimit.prototype, "limitType", {
+        /** Lower or upper limit. Default lower. */
+        get: function () { return this.getProperty(K.LimitType, function () { return MathLimitType.LowerLimit; }); },
+        set: function (value) { this.setProperty(K.LimitType, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathLimit.prototype, "equation", {
+        /** Base equation. */
+        get: function () { return this._equation; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathLimit.prototype, "limit", {
+        /** Limit equation. */
+        get: function () { return this._limit; },
+        enumerable: true,
+        configurable: true
+    });
+    return OfficeMathLimit;
+}(OfficeMathFunctionBase));
+export { OfficeMathLimit };
+/** N-ary operator (`m:nary`). @public */
+var OfficeMathNArray = /** @class */ (function (_super) {
+    __extends(OfficeMathNArray, _super);
+    function OfficeMathNArray(owner) {
+        var _this = _super.call(this, owner) || this;
+        _this.type = MathFunctionType.NArray;
+        _this._equation = new OfficeMath(_this);
+        _this._subscript = new OfficeMath(_this);
+        _this._superscript = new OfficeMath(_this);
+        return _this;
+    }
+    Object.defineProperty(OfficeMathNArray.prototype, "nArrayCharacter", {
+        /** Operator character. Default U+222B. */
+        get: function () { return this.getProperty(K.NAryChar, function () { return String.fromCharCode(8747); }); },
+        set: function (value) { this.setProperty(K.NAryChar, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathNArray.prototype, "hasGrow", {
+        /** Whether the operator grows. Default false. */
+        get: function () { return this.getProperty(K.HasGrow, function () { return false; }); },
+        set: function (value) { this.setProperty(K.HasGrow, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathNArray.prototype, "hideLowerLimit", {
+        /** Hides the lower limit. Default false. */
+        get: function () { return this.getProperty(K.HideSubscript, function () { return false; }); },
+        set: function (value) { this.setProperty(K.HideSubscript, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathNArray.prototype, "hideUpperLimit", {
+        /** Hides the upper limit. Default false. */
+        get: function () { return this.getProperty(K.HideSuperscript, function () { return false; }); },
+        set: function (value) { this.setProperty(K.HideSuperscript, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathNArray.prototype, "subSuperscriptLimit", {
+        /** Limits as sub/superscript. Default true for the integral character, false otherwise. */
+        get: function () {
+            var _this = this;
+            return this.getProperty(K.SubSupLimit, function () { return _this.nArrayCharacter === String.fromCharCode(8747); });
+        },
+        set: function (value) { this.setProperty(K.SubSupLimit, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathNArray.prototype, "equation", {
+        /** Operand equation. */
+        get: function () { return this._equation; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathNArray.prototype, "subscript", {
+        /** Lower limit equation. */
+        get: function () { return this._subscript; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathNArray.prototype, "superscript", {
+        /** Upper limit equation. */
+        get: function () { return this._superscript; },
+        enumerable: true,
+        configurable: true
+    });
+    return OfficeMathNArray;
+}(OfficeMathFunctionBase));
+export { OfficeMathNArray };
+/** Single subscript or superscript (`m:sSub` / `m:sSup`). @public */
+var OfficeMathScript = /** @class */ (function (_super) {
+    __extends(OfficeMathScript, _super);
+    function OfficeMathScript(owner) {
+        var _this = _super.call(this, owner) || this;
+        _this.type = MathFunctionType.SubSuperscript;
+        _this._equation = new OfficeMath(_this);
+        _this._script = new OfficeMath(_this);
+        return _this;
+    }
+    Object.defineProperty(OfficeMathScript.prototype, "scriptType", {
+        /** Subscript or superscript. Default superscript. */
+        get: function () { return this.getProperty(K.ScriptType, function () { return MathScriptType.Superscript; }); },
+        set: function (value) { this.setProperty(K.ScriptType, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathScript.prototype, "equation", {
+        /** Base equation. */
+        get: function () { return this._equation; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathScript.prototype, "script", {
+        /** Script equation. */
+        get: function () { return this._script; },
+        enumerable: true,
+        configurable: true
+    });
+    return OfficeMathScript;
+}(OfficeMathFunctionBase));
+export { OfficeMathScript };
+/** Combined right sub/superscript (`m:sSubSup`). @public */
+var OfficeMathRightScript = /** @class */ (function (_super) {
+    __extends(OfficeMathRightScript, _super);
+    function OfficeMathRightScript(owner) {
+        var _this = _super.call(this, owner) || this;
+        _this.type = MathFunctionType.RightSubSuperscript;
+        _this._equation = new OfficeMath(_this);
+        _this._subscript = new OfficeMath(_this);
+        _this._superscript = new OfficeMath(_this);
+        return _this;
+    }
+    Object.defineProperty(OfficeMathRightScript.prototype, "isSkipAlign", {
+        /** Align scripts. Default true. */
+        get: function () { return this.getProperty(K.SkipAlign, function () { return true; }); },
+        set: function (value) { this.setProperty(K.SkipAlign, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathRightScript.prototype, "equation", {
+        /** Base equation. */
+        get: function () { return this._equation; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathRightScript.prototype, "subscript", {
+        /** Subscript equation. */
+        get: function () { return this._subscript; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathRightScript.prototype, "superscript", {
+        /** Superscript equation. */
+        get: function () { return this._superscript; },
+        enumerable: true,
+        configurable: true
+    });
+    return OfficeMathRightScript;
+}(OfficeMathFunctionBase));
+export { OfficeMathRightScript };
+/** Left sub/superscript (`m:sPre`). @public */
+var OfficeMathLeftScript = /** @class */ (function (_super) {
+    __extends(OfficeMathLeftScript, _super);
+    function OfficeMathLeftScript(owner) {
+        var _this = _super.call(this, owner) || this;
+        _this.type = MathFunctionType.LeftSubSuperscript;
+        _this._equation = new OfficeMath(_this);
+        _this._subscript = new OfficeMath(_this);
+        _this._superscript = new OfficeMath(_this);
+        return _this;
+    }
+    Object.defineProperty(OfficeMathLeftScript.prototype, "equation", {
+        /** Base equation. */
+        get: function () { return this._equation; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathLeftScript.prototype, "subscript", {
+        /** Subscript equation. */
+        get: function () { return this._subscript; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathLeftScript.prototype, "superscript", {
+        /** Superscript equation. */
+        get: function () { return this._superscript; },
+        enumerable: true,
+        configurable: true
+    });
+    return OfficeMathLeftScript;
+}(OfficeMathFunctionBase));
+export { OfficeMathLeftScript };

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

@@ -0,0 +1,27 @@
+/**
+ * Office Math authoring model.
+ */
+export * from './enums';
+export * from './entity';
+export * from './property-store';
+export * from './owner-holder';
+export * from './adapter';
+export * from './basic';
+export * from './collection';
+export * from './break';
+export * from './format';
+export * from './function-base';
+export * from './run-element';
+export * from './functions-basic';
+export * from './functions-multi';
+export * from './matrix';
+export * from './matrix-row';
+export * from './matrix-column';
+export * from './matrix-collections';
+export * from './office-math';
+export * from './math-collection';
+export * from './function-collection';
+export * from './math-paragraph';
+export * from './unknown-element';
+export * from './math-clone';
+export * from './math-equality';

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

@@ -0,0 +1,25 @@
+/**
+ * Office Math authoring model.
+ */
+export * from './enums';
+export * from './property-store';
+export * from './owner-holder';
+export * from './basic';
+export * from './collection';
+export * from './break';
+export * from './format';
+export * from './function-base';
+export * from './run-element';
+export * from './functions-basic';
+export * from './functions-multi';
+export * from './matrix';
+export * from './matrix-row';
+export * from './matrix-column';
+export * from './matrix-collections';
+export * from './office-math';
+export * from './math-collection';
+export * from './function-collection';
+export * from './math-paragraph';
+export * from './unknown-element';
+export * from './math-clone';
+export * from './math-equality';

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

@@ -0,0 +1,6 @@
+/**
+ * Property keys of the Office Math authoring model (same numbering as Compression).
+ */
+export declare const K: {
+    [name: string]: number;
+};

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

@@ -0,0 +1,20 @@
+/**
+ * Property keys of the Office Math authoring model (same numbering as Compression).
+ */
+export var K = {
+    AccentChar: 1, BarTop: 2,
+    HideTop: 3, HideBottom: 4, HideRight: 5, HideLeft: 6,
+    StrikeBLTR: 7, StrikeTLBR: 8, StrikeVertical: 9, StrikeHorizontal: 10,
+    BoxAlign: 11, NoBreak: 12, EnableDifferential: 14, OperatorEmulator: 15,
+    AlignAt: 16, BegChar: 17, EndChar: 18, NoRightChar: 19, NoLeftChar: 20,
+    SeparatorChar: 21, Grow: 22, Shape: 23,
+    EqArrAlign: 24, MaxDist: 25, ObjDist: 26, RowSpacing: 27, RowSpacingRule: 28,
+    FractionType: 29, HasAlignTop: 30, GroupChar: 31, HasCharTop: 32,
+    MatrixAlign: 33, ColumnWidth: 34, ColumnSpacingRule: 35, ColumnSpacing: 36, ColumnGap: 38, ColumnGapRule: 39, PlaceHoldHidden: 37,
+    NAryChar: 41, HasGrow: 42, HideSubscript: 43, HideSuperscript: 44, SubSupLimit: 45,
+    Show: 46, Smash: 47, Transparent: 48, ZeroAscent: 49, ZeroDescent: 50, ZeroWidth: 51,
+    HideDegree: 51, SkipAlign: 52,
+    HasAlignment: 53, HasLiteral: 54, HasNormalText: 55, Script: 56, Style: 57,
+    ArgumentSize: 74, AlignPoint: 76, Justification: 77,
+    LimitType: 80, ScriptType: 81
+};

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

@@ -0,0 +1,20 @@
+/**
+ * Deep clone of the Math model.
+ */
+import { OfficeMath } from './office-math';
+import { OfficeMathParagraph } from './math-paragraph';
+/**
+ * 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 declare function cloneOfficeMath(source: OfficeMath, root: OfficeMathParagraph): OfficeMath;
+/**
+ * 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 declare function cloneOfficeMathParagraph(source: OfficeMathParagraph): OfficeMathParagraph;