@syncfusion/ej2-office-common 35.1.37

package/src/features/mathml/model/math-element.js

@@ -0,0 +1,315 @@
+/**
+ * MathElement base hierarchy for OMML typed DOM.
+ *
+ * Source: mathml-spec §7; ECMA-376-4 Annex A.8.1.
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 { MathmlReadOnlyError, MathmlValidationError } from '../errors';
+import { isInteger2 } from './enums';
+/**
+ * Abstract base for every OMML model node.
+ *
+ * @public
+ */
+var MathElement = /** @class */ (function () {
+    function MathElement() {
+        /** When true, mutation is blocked (preserve-only degradation). */
+        this._preserveOnly = false;
+    }
+    Object.defineProperty(MathElement.prototype, "preserveOnly", {
+        /**
+         * Whether this node is locked in preserve-only mode (mutations blocked; original OpenXML is re-emitted).
+         *
+         * @private
+         * Framework/parser state used for round-trip fidelity and host dirty tracking.
+         */
+        get: function () {
+            return this._preserveOnly;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(MathElement.prototype, "preservedXml", {
+        /**
+         * Captured original OpenXML tree when the node is preserve-only or cannot be fully represented.
+         *
+         * @private
+         * Used by the serializer and hosts to round-trip unmodified structure.
+         */
+        get: function () {
+            return this._preservedXml;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Registers an internal mutation callback for change tracking and document synchronization.
+     *
+     * @private
+     * Hosts (for example docx `MathInline`) inject dirty tracking; not part of the authoring API.
+     */
+    MathElement.prototype.setMutationListener = function (listener) {
+        this._onMutate = listener;
+    };
+    /**
+     * Marks this node preserve-only and stores the original OpenXML for round-trip preservation.
+     *
+     * @private
+     * Used by the OMML parser for structural degradation and by document hosts to bubble a
+     * child-level preserve-only lock up to the equation root.
+     */
+    MathElement.prototype.markPreserveOnly = function (xml) {
+        this._preserveOnly = true;
+        this._preservedXml = xml;
+    };
+    /**
+     * Attach preserved XML without locking mutation (UnknownMathElement).
+     *
+     * @private
+     */
+    MathElement.prototype.attachPreservedXml = function (xml) {
+        this._preservedXml = xml;
+    };
+    /** Guard + notify after a successful mutation. */
+    MathElement.prototype.notifyMutated = function () {
+        if (this._preserveOnly) {
+            throw new MathmlReadOnlyError();
+        }
+        this._onMutate == null ? void 0 : this._onMutate();
+    };
+    /** Throw if preserve-only before a mutation begins. */
+    MathElement.prototype.assertMutable = function () {
+        if (this._preserveOnly) {
+            throw new MathmlReadOnlyError();
+        }
+    };
+    return MathElement;
+}());
+export { MathElement };
+/**
+ * Math text leaf (`m:t`) — literal character content inside a math run.
+ *
+ * Source: ECMA-376-1 §22.1.2.116 `CT_Text` — UTF-8 passthrough, no substitution.
+ *
+ * @public
+ */
+var MathText = /** @class */ (function (_super) {
+    __extends(MathText, _super);
+    function MathText(value, xmlSpace) {
+        if (value === void 0) { value = ''; }
+        var _this = _super.call(this) || this;
+        /**
+         * Math element type for this text leaf (`t`).
+         */
+        _this.type = 't';
+        _this._value = value;
+        _this._xmlSpace = xmlSpace;
+        return _this;
+    }
+    Object.defineProperty(MathText.prototype, "value", {
+        /**
+         * Raw text content of this math text element (full UTF-8, no substitution).
+         */
+        get: function () {
+            return this._value;
+        },
+        set: function (next) {
+            this.assertMutable();
+            this._value = next;
+            this.notifyMutated();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(MathText.prototype, "xmlSpace", {
+        /**
+         * Optional `xml:space` on `m:t` (`default` | `preserve`), same policy as Word `w:t`.
+         *
+         * @private
+         * Serialization attribute for whitespace fidelity; prefer setting text via {@link value}.
+         */
+        get: function () {
+            return this._xmlSpace;
+        },
+        set: function (next) {
+            this.assertMutable();
+            this._xmlSpace = next;
+            this.notifyMutated();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return MathText;
+}(MathElement));
+export { MathText };
+/**
+ * Argument container that holds ordered math elements inside a larger structure.
+ *
+ * @public
+ */
+var MathArgument = /** @class */ (function (_super) {
+    __extends(MathArgument, _super);
+    function MathArgument(properties, item, ctrlPr) {
+        if (properties === void 0) { properties = {}; }
+        if (item === void 0) { item = []; }
+        var _this = _super.call(this) || this;
+        /**
+         * Discriminator for this math argument container.
+         *
+         * @public
+         */
+        _this.type = 'arg';
+        if (properties.argSz !== undefined && !isInteger2(properties.argSz)) {
+            throw new MathmlValidationError("argSz must be an integer in \u22122..2 (ST_Integer2), got " + String(properties.argSz), 'arg.argPr.argSz', 'value-range');
+        }
+        _this._properties = Object.freeze(__assign({}, properties));
+        _this._item = __spread(item);
+        _this._ctrlPr = ctrlPr;
+        return _this;
+    }
+    Object.defineProperty(MathArgument.prototype, "properties", {
+        /**
+         * Gets or sets argument properties such as script size.
+         *
+         * @throws MathmlValidationError when script size is outside the allowed integer range.
+         *
+         * @public
+         */
+        get: function () {
+            return this._properties;
+        },
+        set: function (next) {
+            this.assertMutable();
+            if (next.argSz !== undefined && !isInteger2(next.argSz)) {
+                throw new MathmlValidationError("argSz must be an integer in \u22122..2 (ST_Integer2), got " + String(next.argSz), 'arg.argPr.argSz', 'value-range');
+            }
+            this._properties = Object.freeze(__assign({}, next));
+            this.notifyMutated();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(MathArgument.prototype, "item", {
+        /**
+         * Gets or sets the ordered math elements inside this argument.
+         *
+         * @public
+         */
+        get: function () {
+            return this._item;
+        },
+        set: function (next) {
+            this.assertMutable();
+            this._item = __spread(next);
+            this.notifyMutated();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(MathArgument.prototype, "ctrlPr", {
+        /**
+         * Opaque control properties (`m:ctrlPr`) carried on the argument, when present.
+         *
+         * @private
+         * Wire-fidelity carrier for WML run properties; not part of the public authoring API.
+         */
+        get: function () {
+            return this._ctrlPr;
+        },
+        /**
+         * @private
+         */
+        set: function (next) {
+            this.assertMutable();
+            this._ctrlPr = next;
+            this.notifyMutated();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Appends one math element at the end of {@link MathArgument.item}.
+     */
+    MathArgument.prototype.appendItem = function (child) {
+        this.assertMutable();
+        this._item.push(child);
+        this.notifyMutated();
+        return child;
+    };
+    return MathArgument;
+}(MathElement));
+export { MathArgument };
+/**
+ * Escape hatch for unrecognized `m:*` elements.
+ *
+ * Source: mathml-spec §8.5 — re-serializes verbatim.
+ *
+ * @public
+ */
+var UnknownMathElement = /** @class */ (function (_super) {
+    __extends(UnknownMathElement, _super);
+    function UnknownMathElement(localName, xml) {
+        var _this = _super.call(this) || this;
+        _this.type = 'unknown';
+        _this.localName = localName;
+        _this.attachPreservedXml(xml);
+        return _this;
+    }
+    return UnknownMathElement;
+}(MathElement));
+export { UnknownMathElement };
+/**
+ * Convenience: build MathArgument from a list of elements.
+ *
+ * @private
+ */
+export function mathArg() {
+    var elements = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        elements[_i] = arguments[_i];
+    }
+    return new MathArgument({}, elements);
+}

package/src/features/mathml/model/roots.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Math root containers: `m:oMathPara`, `m:oMath`.
+ *
+ * Source: ECMA-376-4 Annex A.8.1 `CT_OMathPara`, `CT_OMath`.
+ */
+import { MathJc } from './enums';
+import { MathElement } from './math-element';
+/**
+ * Paragraph-level math properties (`m:oMathParaPr` → `m:jc`).
+ *
+ * @public
+ */
+export interface MathParaProperties {
+    readonly jc?: MathJc;
+}
+/**
+ * Display-math paragraph (`m:oMathPara`) — a block of one or more office-math equations.
+ *
+ * Child sequence: `oMathParaPr?`, `oMath` (1..∞).
+ *
+ * @public
+ */
+export declare class MathParagraph extends MathElement {
+    /**
+     * Math element type for this root (`oMathPara`).
+     */
+    readonly type = "oMathPara";
+    private _properties;
+    private _equations;
+    constructor(properties?: MathParaProperties, equations?: ReadonlyArray<MathOMath>);
+    /**
+     * Paragraph-level math configuration (`m:oMathParaPr`), such as justification (`m:jc`).
+     */
+    properties: Readonly<MathParaProperties>;
+    /**
+     * Ordered office-math equations in this paragraph (`m:oMath`), each a {@link MathOMath}.
+     * At least one equation is required on serialize.
+     */
+    readonly equations: ReadonlyArray<MathOMath>;
+    /**
+     * Replaces the ordered `m:oMath` equations in this paragraph.
+     */
+    setEquations(next: ReadonlyArray<MathOMath>): void;
+    /**
+     * Appends one office-math equation (`m:oMath`) at the end of this paragraph.
+     */
+    appendEquation(equation: MathOMath): void;
+    /**
+     * Validates that this paragraph has at least one `m:oMath` before serialization.
+     *
+     * @private
+     * Called by the OMML serializer; not part of the public authoring API.
+     */
+    assertSerializable(path?: string): void;
+}
+/**
+ * Inline office-math root (`m:oMath`) — one equation body of math elements.
+ *
+ * Child sequence: `EG_OMathElements` (0..∞).
+ *
+ * @public
+ */
+export declare class MathOMath extends MathElement {
+    /**
+     * Math element type for this root (`oMath`).
+     */
+    readonly type = "oMath";
+    private _children;
+    constructor(children?: ReadonlyArray<MathElement>);
+    /**
+     * Ordered math children of this equation (`EG_OMathElements`).
+     */
+    readonly children: ReadonlyArray<MathElement>;
+    /**
+     * Replaces the ordered math children of this equation.
+     */
+    setChildren(next: ReadonlyArray<MathElement>): void;
+    /**
+     * Appends one math element at the end of this equation.
+     */
+    appendChild(child: MathElement): void;
+}

package/src/features/mathml/model/roots.js

@@ -0,0 +1,177 @@
+/**
+ * Math root containers: `m:oMathPara`, `m:oMath`.
+ *
+ * Source: ECMA-376-4 Annex A.8.1 `CT_OMathPara`, `CT_OMath`.
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 { MathElement } from './math-element';
+import { MathmlValidationError } from '../errors';
+/**
+ * Display-math paragraph (`m:oMathPara`) — a block of one or more office-math equations.
+ *
+ * Child sequence: `oMathParaPr?`, `oMath` (1..∞).
+ *
+ * @public
+ */
+var MathParagraph = /** @class */ (function (_super) {
+    __extends(MathParagraph, _super);
+    function MathParagraph(properties, equations) {
+        if (properties === void 0) { properties = {}; }
+        if (equations === void 0) { equations = []; }
+        var _this = _super.call(this) || this;
+        /**
+         * Math element type for this root (`oMathPara`).
+         */
+        _this.type = 'oMathPara';
+        _this._properties = Object.freeze(__assign({}, properties));
+        _this._equations = __spread(equations);
+        return _this;
+    }
+    Object.defineProperty(MathParagraph.prototype, "properties", {
+        /**
+         * Paragraph-level math configuration (`m:oMathParaPr`), such as justification (`m:jc`).
+         */
+        get: function () {
+            return this._properties;
+        },
+        set: function (next) {
+            this.assertMutable();
+            this._properties = Object.freeze(__assign({}, next));
+            this.notifyMutated();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(MathParagraph.prototype, "equations", {
+        /**
+         * Ordered office-math equations in this paragraph (`m:oMath`), each a {@link MathOMath}.
+         * At least one equation is required on serialize.
+         */
+        get: function () {
+            return this._equations;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Replaces the ordered `m:oMath` equations in this paragraph.
+     */
+    MathParagraph.prototype.setEquations = function (next) {
+        this.assertMutable();
+        this._equations = __spread(next);
+        this.notifyMutated();
+    };
+    /**
+     * Appends one office-math equation (`m:oMath`) at the end of this paragraph.
+     */
+    MathParagraph.prototype.appendEquation = function (equation) {
+        this.assertMutable();
+        this._equations.push(equation);
+        this.notifyMutated();
+    };
+    /**
+     * Validates that this paragraph has at least one `m:oMath` before serialization.
+     *
+     * @private
+     * Called by the OMML serializer; not part of the public authoring API.
+     */
+    MathParagraph.prototype.assertSerializable = function (path) {
+        if (path === void 0) { path = 'oMathPara'; }
+        if (this._equations.length < 1) {
+            throw new MathmlValidationError('m:oMathPara requires at least one m:oMath (CT_OMathPara)', path, 'required-child');
+        }
+    };
+    return MathParagraph;
+}(MathElement));
+export { MathParagraph };
+/**
+ * Inline office-math root (`m:oMath`) — one equation body of math elements.
+ *
+ * Child sequence: `EG_OMathElements` (0..∞).
+ *
+ * @public
+ */
+var MathOMath = /** @class */ (function (_super) {
+    __extends(MathOMath, _super);
+    function MathOMath(children) {
+        if (children === void 0) { children = []; }
+        var _this = _super.call(this) || this;
+        /**
+         * Math element type for this root (`oMath`).
+         */
+        _this.type = 'oMath';
+        _this._children = __spread(children);
+        return _this;
+    }
+    Object.defineProperty(MathOMath.prototype, "children", {
+        /**
+         * Ordered math children of this equation (`EG_OMathElements`).
+         */
+        get: function () {
+            return this._children;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Replaces the ordered math children of this equation.
+     */
+    MathOMath.prototype.setChildren = function (next) {
+        this.assertMutable();
+        this._children = __spread(next);
+        this.notifyMutated();
+    };
+    /**
+     * Appends one math element at the end of this equation.
+     */
+    MathOMath.prototype.appendChild = function (child) {
+        this.assertMutable();
+        this._children.push(child);
+        this.notifyMutated();
+    };
+    return MathOMath;
+}(MathElement));
+export { MathOMath };

package/src/features/mathml/openxml.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Local structural OpenXml element-tree contract for mathml parse/serialize.
+ *
+ * office-common has no shared `src/core/xml` yet (TASK-9002/9003). This
+ * mirrors ej2-docx `src/core/xml/model.ts` so TASK-9011 can pass the same
+ * tree shape across the boundary. Unify when core XML lands.
+ *
+ * These types are part of the public `@syncfusion/ej2-office-common/mathml` surface
+ * (parse/serialize boundary). Keep them public under stripInternal builds —
+ * never tag this module as internal.
+ */
+/** Attribute on an OpenXml element. */
+export interface OpenXmlAttribute {
+    readonly namespaceUri: string;
+    readonly localName: string;
+    readonly prefix: string;
+    readonly value: string;
+}
+/** Namespace declaration (`xmlns` / `xmlns:prefix`). */
+export interface NamespaceDeclaration {
+    readonly prefix: string;
+    readonly namespaceUri: string;
+}
+/** Element node. */
+export interface OpenXmlElement {
+    readonly kind: 'element';
+    readonly namespaceUri: string;
+    readonly localName: string;
+    readonly prefix: string;
+    readonly attributes: ReadonlyArray<OpenXmlAttribute>;
+    readonly namespaceDeclarations: ReadonlyArray<NamespaceDeclaration>;
+    readonly children: ReadonlyArray<OpenXmlChild>;
+}
+/** Text node. */
+export interface OpenXmlText {
+    readonly kind: 'text';
+    readonly value: string;
+}
+/** Child of an element. */
+export declare type OpenXmlChild = OpenXmlElement | OpenXmlText;
+/** Create an immutable element node. */
+export declare function createElement(namespaceUri: string, localName: string, prefix: string, options?: {
+    readonly attributes?: ReadonlyArray<OpenXmlAttribute>;
+    readonly namespaceDeclarations?: ReadonlyArray<NamespaceDeclaration>;
+    readonly children?: ReadonlyArray<OpenXmlChild>;
+}): OpenXmlElement;
+/** Create a text node. */
+export declare function createText(value: string): OpenXmlText;
+/** Filter element children only. */
+export declare function childElements(element: OpenXmlElement): ReadonlyArray<OpenXmlElement>;
+/** Read the first matching attribute value by local name (any namespace). */
+export declare function attrValue(element: OpenXmlElement, localName: string): string | undefined;
+/** Read attribute value restricted to a namespace URI. */
+export declare function attrValueNs(element: OpenXmlElement, namespaceUri: string, localName: string): string | undefined;
+/** Concatenate direct text-node children. */
+export declare function textContent(element: OpenXmlElement): string;