@syncfusion/ej2-office-common 35.1.37

package/src/features/diagrams/diagram-data-model.js

@@ -0,0 +1,446 @@
+/**
+ * DiagramDataModel — CT_DataModel view/API.
+ *
+ * Citations:
+ * - dml-diagram.xsd CT_DataModel, CT_Pt, CT_Cxn, ST_PtType, ST_CxnType, ST_ModelId
+ * - Requirement docs/requirements/smart-art-diagrams.md §12 (maintenance API)
+ * - ECMA-376 DrawingML diagram data part
+ */
+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;
+};
+var _a;
+import { MAX_DIAGRAM_CONNECTIONS, MAX_DIAGRAM_POINTS } from './constants';
+import { cloneElement } from './element-tree';
+import { DiagramModelError } from './errors';
+var DIAGRAM_DATA_MODEL_BRAND = Symbol.for('@syncfusion/ej2-office-common.DiagramDataModel');
+function cloneBody(body) {
+    if (body == null)
+        return null;
+    return cloneElement(body);
+}
+function normalizePoint(p) {
+    return {
+        modelId: p.modelId,
+        type: p.type != null ? p.type : 'node',
+        cxnId: p.cxnId != null ? p.cxnId : '0',
+        body: cloneBody(p.body)
+    };
+}
+function normalizeConnection(c) {
+    return {
+        modelId: c.modelId,
+        type: c.type != null ? c.type : 'parOf',
+        srcId: c.srcId,
+        destId: c.destId,
+        srcOrd: c.srcOrd,
+        destOrd: c.destOrd,
+        parTransId: c.parTransId != null ? c.parTransId : '0',
+        sibTransId: c.sibTransId != null ? c.sibTransId : '0',
+        presId: c.presId != null ? c.presId : '',
+        body: cloneBody(c.body)
+    };
+}
+/**
+ * Mutable CT_DataModel graph.
+ * Identity: `instanceof DiagramDataModel` and brand symbol.
+ */
+var DiagramDataModel = /** @class */ (function () {
+    function DiagramDataModel(init) {
+        var e_1, _a, e_2, _b;
+        if (init === void 0) { init = {}; }
+        this[_a] = true;
+        this._points = [];
+        this._connections = [];
+        this._dirty = false;
+        /** Optional original part bytes when loaded clean (D14). */
+        this._originalBytes = null;
+        var points = init.points != null ? init.points : [];
+        var connections = init.connections != null ? init.connections : [];
+        if (points.length > MAX_DIAGRAM_POINTS) {
+            throw new DiagramModelError('limit_exceeded', "Point count " + String(points.length) + " exceeds MAX_DIAGRAM_POINTS (" + String(MAX_DIAGRAM_POINTS) + ").");
+        }
+        if (connections.length > MAX_DIAGRAM_CONNECTIONS) {
+            throw new DiagramModelError('limit_exceeded', "Connection count " + String(connections.length) + " exceeds MAX_DIAGRAM_CONNECTIONS (" + String(MAX_DIAGRAM_CONNECTIONS) + ").");
+        }
+        try {
+            for (var points_1 = __values(points), points_1_1 = points_1.next(); !points_1_1.done; points_1_1 = points_1.next()) {
+                var p = points_1_1.value;
+                this._points.push(normalizePoint(p));
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (points_1_1 && !points_1_1.done && (_a = points_1.return)) _a.call(points_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        try {
+            for (var connections_1 = __values(connections), connections_1_1 = connections_1.next(); !connections_1_1.done; connections_1_1 = connections_1.next()) {
+                var c = connections_1_1.value;
+                this._connections.push(normalizeConnection(c));
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (connections_1_1 && !connections_1_1.done && (_b = connections_1.return)) _b.call(connections_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        this._background = cloneBody(init.background);
+        this._whole = cloneBody(init.whole);
+        this._extLst = cloneBody(init.extLst);
+    }
+    Object.defineProperty(DiagramDataModel.prototype, "dirty", {
+        get: function () {
+            return this._dirty;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /** Mark dirty and drop original bytes (must reserialize). */
+    DiagramDataModel.prototype.markDirty = function () {
+        this._dirty = true;
+        this._originalBytes = null;
+    };
+    /** Clear dirty after successful apply; optionally stash bytes. */
+    DiagramDataModel.prototype.clearDirty = function (originalBytes) {
+        this._dirty = false;
+        this._originalBytes = originalBytes != null ? originalBytes : null;
+    };
+    Object.defineProperty(DiagramDataModel.prototype, "originalBytes", {
+        get: function () {
+            return this._originalBytes;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    DiagramDataModel.prototype.setOriginalBytes = function (bytes) {
+        this._originalBytes = bytes;
+    };
+    Object.defineProperty(DiagramDataModel.prototype, "points", {
+        get: function () {
+            return this._points;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DiagramDataModel.prototype, "connections", {
+        get: function () {
+            return this._connections;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DiagramDataModel.prototype, "background", {
+        get: function () {
+            return this._background;
+        },
+        set: function (value) {
+            this._background = cloneBody(value);
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DiagramDataModel.prototype, "whole", {
+        get: function () {
+            return this._whole;
+        },
+        set: function (value) {
+            this._whole = cloneBody(value);
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DiagramDataModel.prototype, "extLst", {
+        get: function () {
+            return this._extLst;
+        },
+        set: function (value) {
+            this._extLst = cloneBody(value);
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    DiagramDataModel.prototype.pointCount = function () {
+        return this._points.length;
+    };
+    DiagramDataModel.prototype.connectionCount = function () {
+        return this._connections.length;
+    };
+    DiagramDataModel.prototype.getPoint = function (modelId) {
+        return this._points.find(function (p) { return p.modelId === modelId; });
+    };
+    DiagramDataModel.prototype.getConnection = function (modelId) {
+        return this._connections.find(function (c) { return c.modelId === modelId; });
+    };
+    /**
+     * Document point (`type=doc`) if present — typically the root of the logical tree.
+     */
+    DiagramDataModel.prototype.documentPoint = function () {
+        return this._points.find(function (p) { return p.type === 'doc'; });
+    };
+    /**
+     * Child node points under `parentId` via parOf connections, ordered by srcOrd.
+     * Requirement §12 hierarchy helpers.
+     */
+    DiagramDataModel.prototype.childrenOf = function (parentId) {
+        var e_3, _a;
+        var links = this._connections.filter(function (c) { return c.type === 'parOf' && c.srcId === parentId; }).slice().sort(function (a, b) { return a.srcOrd - b.srcOrd; });
+        var out = [];
+        try {
+            for (var links_1 = __values(links), links_1_1 = links_1.next(); !links_1_1.done; links_1_1 = links_1.next()) {
+                var link = links_1_1.value;
+                var pt = this.getPoint(link.destId);
+                if (pt)
+                    out.push(pt);
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (links_1_1 && !links_1_1.done && (_a = links_1.return)) _a.call(links_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        return out;
+    };
+    /** Parent via reverse parOf (first match). */
+    DiagramDataModel.prototype.parentOf = function (nodeId) {
+        var link = this._connections.find(function (c) { return c.type === 'parOf' && c.destId === nodeId; });
+        if (!link)
+            return undefined;
+        return this.getPoint(link.srcId);
+    };
+    /**
+     * Replace text content of the point's `t` (dgm:t / a:t shape) body fragment.
+     * If no body/`t` exists, creates a minimal text body hook for the serializer.
+     * Requirement §12 setNodeText.
+     */
+    DiagramDataModel.prototype.setNodeText = function (modelId, value) {
+        var pt = this.getPoint(modelId);
+        if (!pt) {
+            throw new DiagramModelError('unknown_point', "No point with modelId=" + modelId + ".");
+        }
+        // Store text as a synthetic body element `t` with a text child.
+        // Parsers preserve full dgm:t trees when present; this API replaces/creates.
+        pt.body = { kind: 'element',
+            localName: 't',
+            namespaceUri: null,
+            attributes: [],
+            children: [{ kind: 'text', text: value
+                }]
+        };
+        this.markDirty();
+    };
+    /** Read text from point body (`t` localName preferred). */
+    DiagramDataModel.prototype.getNodeText = function (modelId) {
+        var e_4, _a;
+        var pt = this.getPoint(modelId);
+        if (!(pt == null ? void 0 : pt.body))
+            return undefined;
+        if (pt.body.localName === 't') {
+            return pt.body.children.map(function (c) { return c.kind === 'text' ? c.text : ''; }).join('');
+        }
+        // Search first t descendant.
+        var stack = [pt.body];
+        while (stack.length > 0) {
+            var n = stack.pop();
+            if (n === undefined)
+                break;
+            if (n.localName === 't') {
+                return n.children.map(function (c) { return c.kind === 'text' ? c.text : ''; }).join('');
+            }
+            try {
+                for (var _b = __values(n.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var c = _c.value;
+                    if (c.kind === 'element')
+                        stack.push(c);
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+        }
+        return undefined;
+    };
+    DiagramDataModel.prototype.addPoint = function (props) {
+        if (this._points.length >= MAX_DIAGRAM_POINTS) {
+            throw new DiagramModelError('limit_exceeded', "Cannot add point: MAX_DIAGRAM_POINTS (" + String(MAX_DIAGRAM_POINTS) + ") reached.");
+        }
+        if (this._points.some(function (p) { return p.modelId === props.modelId; })) {
+            throw new DiagramModelError('inconsistent_graph', "Duplicate point modelId=" + props.modelId + ".");
+        }
+        var pt = normalizePoint(props);
+        this._points.push(pt);
+        this.markDirty();
+        return pt;
+    };
+    DiagramDataModel.prototype.addConnection = function (props) {
+        if (this._connections.length >= MAX_DIAGRAM_CONNECTIONS) {
+            throw new DiagramModelError('limit_exceeded', "Cannot add connection: MAX_DIAGRAM_CONNECTIONS (" + String(MAX_DIAGRAM_CONNECTIONS) + ") reached.");
+        }
+        if (this._connections.some(function (c) { return c.modelId === props.modelId; })) {
+            throw new DiagramModelError('inconsistent_graph', "Duplicate connection modelId=" + props.modelId + ".");
+        }
+        var cxn = normalizeConnection(props);
+        this._connections.push(cxn);
+        this.markDirty();
+        return cxn;
+    };
+    /**
+     * Append a child node under parent via parOf.
+     * Creates point + connection; assigns next srcOrd.
+     */
+    DiagramDataModel.prototype.appendChild = function (parentId, child, connectionModelId) {
+        if (!this.getPoint(parentId)) {
+            throw new DiagramModelError('unknown_point', "Parent modelId=" + parentId + " not found.");
+        }
+        var siblings = this._connections.filter(function (c) { return c.type === 'parOf' && c.srcId === parentId; });
+        var nextOrd = siblings.length === 0 ? 0 : Math.max.apply(Math, __spread(siblings.map(function (s) { return s.srcOrd; }))) + 1;
+        var point = this.addPoint(child);
+        var connection = this.addConnection({
+            modelId: connectionModelId,
+            type: 'parOf',
+            srcId: parentId,
+            destId: child.modelId,
+            srcOrd: nextOrd,
+            destOrd: 0
+        });
+        return {
+            point: point,
+            connection: connection
+        };
+    };
+    /**
+     * Remove a node and its incident connections (and optionally subtree).
+     * When `recursive` is true, removes descendants via parOf.
+     */
+    DiagramDataModel.prototype.removeNode = function (modelId, recursive) {
+        var _this = this;
+        if (recursive === void 0) { recursive = true; }
+        if (!this.getPoint(modelId)) {
+            throw new DiagramModelError('unknown_point', "No point with modelId=" + modelId + ".");
+        }
+        var toRemove = new Set();
+        var visit = function (id) {
+            var e_5, _a;
+            if (toRemove.has(id))
+                return;
+            toRemove.add(id);
+            if (!recursive)
+                return;
+            try {
+                for (var _b = __values(_this._connections), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var c = _c.value;
+                    if (c.type === 'parOf' && c.srcId === id)
+                        visit(c.destId);
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+        };
+        visit(modelId);
+        for (var i = this._connections.length - 1; i >= 0; i--) {
+            var c = this._connections[i];
+            if (c === undefined)
+                continue;
+            if (toRemove.has(c.srcId) || toRemove.has(c.destId) || toRemove.has(c.modelId)) {
+                this._connections.splice(i, 1);
+            }
+        }
+        for (var i = this._points.length - 1; i >= 0; i--) {
+            var p = this._points[i];
+            if (p !== undefined && toRemove.has(p.modelId)) {
+                this._points.splice(i, 1);
+            }
+        }
+        this.markDirty();
+    };
+    /**
+     * Deep clone of the model (new instance, dirty=false unless copyDirty).
+     */
+    DiagramDataModel.prototype.clone = function (options) {
+        var m = new DiagramDataModel({
+            points: this._points.map(function (p) { return ({
+                modelId: p.modelId,
+                type: p.type,
+                cxnId: p.cxnId,
+                body: p.body
+            }); }),
+            connections: this._connections.map(function (c) { return ({
+                modelId: c.modelId,
+                type: c.type,
+                srcId: c.srcId,
+                destId: c.destId,
+                srcOrd: c.srcOrd,
+                destOrd: c.destOrd,
+                parTransId: c.parTransId,
+                sibTransId: c.sibTransId,
+                presId: c.presId,
+                body: c.body
+            }); }),
+            background: this._background,
+            whole: this._whole,
+            extLst: this._extLst
+        });
+        if ((options == null ? void 0 : options.copyDirty) && this._dirty) {
+            m.markDirty();
+        }
+        else if (this._originalBytes && !this._dirty) {
+            m.setOriginalBytes(this._originalBytes);
+            m.clearDirty(this._originalBytes);
+        }
+        return m;
+    };
+    return DiagramDataModel;
+}());
+export { DiagramDataModel };
+_a = DIAGRAM_DATA_MODEL_BRAND;
+/**
+ * @private
+ */
+export function isDiagramDataModel(value) {
+    return value instanceof DiagramDataModel;
+}

package/src/features/diagrams/diagram-parsers.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Parsers: ElementTree → diagram models/views.
+ * NEVER invent markup; preserve unknown children under body/extLst.
+ *
+ * Citations: dml-diagram.xsd CT_DataModel/CT_Pt/CT_Cxn/CT_RelIds,
+ * CT_DiagramDefinition, CT_StyleDefinition, CT_ColorTransform;
+ * [MS-ODRAWXML] drawing root.
+ */
+import { DiagramDataModel } from './diagram-data-model';
+import { DiagramColors, DiagramDrawing, DiagramLayout, DiagramQuickStyle } from './diagram-views';
+import { ElementNode } from './element-tree';
+/**
+ * Parse CT_DataModel (`dgm:dataModel`).
+ * dml-diagram.xsd CT_DataModel: ptLst, cxnLst, bg, whole, extLst.
+ */
+export declare function parseDiagramData(tree: ElementNode): DiagramDataModel;
+/** Parse CT_DiagramDefinition (`dgm:layoutDef`). */
+export declare function parseDiagramLayout(tree: ElementNode): DiagramLayout;
+/** Parse CT_StyleDefinition (`dgm:styleDef`). */
+export declare function parseDiagramQuickStyle(tree: ElementNode): DiagramQuickStyle;
+/** Parse CT_ColorTransform (`dgm:colorsDef`). */
+export declare function parseDiagramColors(tree: ElementNode): DiagramColors;
+/**
+ * Parse Microsoft diagram drawing root.
+ * Accepts `dsp:drawing` or any element in DSP_NAMESPACE; also tolerates
+ * unknown root when namespace matches MS drawing content (preserve tree).
+ */
+export declare function parseDiagramDrawing(tree: ElementNode): DiagramDrawing;

package/src/features/diagrams/diagram-parsers.js

@@ -0,0 +1,182 @@
+/**
+ * Parsers: ElementTree → diagram models/views.
+ * NEVER invent markup; preserve unknown children under body/extLst.
+ *
+ * Citations: dml-diagram.xsd CT_DataModel/CT_Pt/CT_Cxn/CT_RelIds,
+ * CT_DiagramDefinition, CT_StyleDefinition, CT_ColorTransform;
+ * [MS-ODRAWXML] drawing root.
+ */
+import { isANamespace, isDgmNamespace, MAX_DIAGRAM_CONNECTIONS, MAX_DIAGRAM_POINTS } from './constants';
+import { DiagramDataModel } from './diagram-data-model';
+import { DiagramColors, DiagramDrawing, DiagramLayout, DiagramQuickStyle } from './diagram-views';
+import { cloneElement, findChild, findChildren, getAttr } from './element-tree';
+import { DiagramParseError } from './errors';
+var PT_TYPES = new Set(['node', 'asst', 'doc', 'pres', 'parTrans', 'sibTrans']);
+var CXN_TYPES = new Set(['parOf', 'presOf', 'presParOf', 'unknownRelationship']);
+function requireDgmRoot(tree, localName) {
+    if (!isDgmNamespace(tree.namespaceUri) || tree.localName !== localName) {
+        throw new DiagramParseError('invalid_root', "Expected dgm:" + localName + " root, got {" + (tree.namespaceUri != null ? tree.namespaceUri : 'null') + "}" + tree.localName + ".");
+    }
+}
+function parsePointType(raw) {
+    if (raw == null || raw === '')
+        return 'node';
+    if (!PT_TYPES.has(raw)) {
+        // Preserve unknown as node with body? Prefer strict enum — map unknown to node
+        // but keep attribute via body is not needed; XSD enumeration — accept known only.
+        return 'node';
+    }
+    return raw;
+}
+function parseCxnType(raw) {
+    // XSD default parOf
+    if (raw == null || raw === '')
+        return 'parOf';
+    if (!CXN_TYPES.has(raw))
+        return 'parOf';
+    return raw;
+}
+function parseOrd(raw, attrName) {
+    if (raw == null || raw === '') {
+        throw new DiagramParseError('missing_required', "Connection missing required attribute " + attrName + ".");
+    }
+    var n = Number(raw);
+    if (!Number.isFinite(n)) {
+        throw new DiagramParseError('invalid_attribute', "Connection " + attrName + " is not a number: " + raw);
+    }
+    return n;
+}
+/**
+ * Wrap remaining element children as a synthetic body root when multiple,
+ * or single child as body, so round-trip can re-emit them under pt/cxn.
+ */
+function bodyFromRemainder(children) {
+    if (children.length === 0)
+        return null;
+    var first = children[0];
+    if (children.length === 1 && first !== undefined)
+        return cloneElement(first);
+    return { kind: 'element',
+        localName: '_body',
+        namespaceUri: null,
+        attributes: [],
+        children: children.map(function (c) { return cloneElement(c); })
+    };
+}
+function parsePt(el) {
+    var modelId = getAttr(el, 'modelId');
+    if (modelId == null || modelId === '') {
+        throw new DiagramParseError('missing_required', 'dgm:pt missing required modelId.');
+    }
+    var type = parsePointType(getAttr(el, 'type'));
+    var cxnId = function () {
+        var _nc = getAttr(el, 'cxnId');
+        return _nc != null ? _nc : '0';
+    }();
+    // Known child names kept under body as full subtrees (prSet, spPr, t, extLst, unknown).
+    var kids = el.children.filter(function (c) { return c.kind === 'element'; });
+    return {
+        modelId: modelId,
+        type: type,
+        cxnId: cxnId,
+        body: bodyFromRemainder(kids)
+    };
+}
+function parseCxn(el) {
+    var modelId = getAttr(el, 'modelId');
+    if (modelId == null || modelId === '') {
+        throw new DiagramParseError('missing_required', 'dgm:cxn missing required modelId.');
+    }
+    var srcId = getAttr(el, 'srcId');
+    var destId = getAttr(el, 'destId');
+    if (srcId == null || srcId === '' || destId == null || destId === '') {
+        throw new DiagramParseError('missing_required', "dgm:cxn modelId=" + modelId + " missing srcId/destId.");
+    }
+    var kids = el.children.filter(function (c) { return c.kind === 'element'; });
+    return {
+        modelId: modelId,
+        type: parseCxnType(getAttr(el, 'type')),
+        srcId: srcId,
+        destId: destId,
+        srcOrd: parseOrd(getAttr(el, 'srcOrd'), 'srcOrd'),
+        destOrd: parseOrd(getAttr(el, 'destOrd'), 'destOrd'),
+        parTransId: function () {
+            var _nc = getAttr(el, 'parTransId');
+            return _nc != null ? _nc : '0';
+        }(),
+        sibTransId: function () {
+            var _nc = getAttr(el, 'sibTransId');
+            return _nc != null ? _nc : '0';
+        }(),
+        presId: function () {
+            var _nc = getAttr(el, 'presId');
+            return _nc != null ? _nc : '';
+        }(),
+        body: bodyFromRemainder(kids)
+    };
+}
+/**
+ * Parse CT_DataModel (`dgm:dataModel`).
+ * dml-diagram.xsd CT_DataModel: ptLst, cxnLst, bg, whole, extLst.
+ */
+export function parseDiagramData(tree) {
+    requireDgmRoot(tree, 'dataModel');
+    var ptLst = findChild(tree, 'ptLst', isDgmNamespace);
+    var cxnLst = findChild(tree, 'cxnLst', isDgmNamespace);
+    var bg = findChild(tree, 'bg', isDgmNamespace);
+    var whole = findChild(tree, 'whole', isDgmNamespace);
+    // extLst is typically a:extLst under dataModel (DrawingML).
+    var extLst = function () {
+        var _nc = function () {
+            var _nc = findChild(tree, 'extLst', isANamespace);
+            return _nc != null ? _nc : findChild(tree, 'extLst', isDgmNamespace);
+        }();
+        return _nc != null ? _nc : findChild(tree, 'extLst');
+    }();
+    var ptEls = ptLst ? findChildren(ptLst, 'pt', isDgmNamespace) : [];
+    var cxnEls = cxnLst ? findChildren(cxnLst, 'cxn', isDgmNamespace) : [];
+    if (ptEls.length > MAX_DIAGRAM_POINTS) {
+        throw new DiagramParseError('limit_exceeded', "Point count " + String(ptEls.length) + " exceeds MAX_DIAGRAM_POINTS (" + String(MAX_DIAGRAM_POINTS) + ").");
+    }
+    if (cxnEls.length > MAX_DIAGRAM_CONNECTIONS) {
+        throw new DiagramParseError('limit_exceeded', "Connection count " + String(cxnEls.length) + " exceeds MAX_DIAGRAM_CONNECTIONS (" + String(MAX_DIAGRAM_CONNECTIONS) + ").");
+    }
+    var points = ptEls.map(parsePt);
+    var connections = cxnEls.map(parseCxn);
+    return new DiagramDataModel({
+        points: points,
+        connections: connections,
+        background: bg ? cloneElement(bg) : null,
+        whole: whole ? cloneElement(whole) : null,
+        extLst: extLst ? cloneElement(extLst) : null
+    });
+}
+/** Parse CT_DiagramDefinition (`dgm:layoutDef`). */
+export function parseDiagramLayout(tree) {
+    requireDgmRoot(tree, 'layoutDef');
+    return new DiagramLayout(tree);
+}
+/** Parse CT_StyleDefinition (`dgm:styleDef`). */
+export function parseDiagramQuickStyle(tree) {
+    requireDgmRoot(tree, 'styleDef');
+    return new DiagramQuickStyle(tree);
+}
+/** Parse CT_ColorTransform (`dgm:colorsDef`). */
+export function parseDiagramColors(tree) {
+    requireDgmRoot(tree, 'colorsDef');
+    return new DiagramColors(tree);
+}
+/**
+ * Parse Microsoft diagram drawing root.
+ * Accepts `dsp:drawing` or any element in DSP_NAMESPACE; also tolerates
+ * unknown root when namespace matches MS drawing content (preserve tree).
+ */
+export function parseDiagramDrawing(tree) {
+    // Prefer dsp:drawing; if not, still wrap as opaque drawing view so
+    // round-trip of unknown MS roots is possible without inventing markup.
+    if (tree.localName === 'drawing' || (tree.namespaceUri != null && tree.namespaceUri.indexOf('drawing/2008/diagram') !== -1)) {
+        return new DiagramDrawing(tree);
+    }
+    // Accept any tree as opaque drawing for catalog load of non-standard caches.
+    return new DiagramDrawing(tree);
+}

package/src/features/diagrams/diagram-serializers.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Serializers: diagram models/views → ElementTree (Transitional write).
+ * Never invent optional markup beyond model state; emit XSD defaults only
+ * when the model holds non-default values or required attributes.
+ *
+ * Citations: dml-diagram.xsd; ECMA-376 Transitional namespaces.
+ */
+import { DiagramDataModel } from './diagram-data-model';
+import { DiagramColors, DiagramDrawing, DiagramLayout, DiagramQuickStyle } from './diagram-views';
+import { ElementNode } from './element-tree';
+/**
+ * Serialize CT_DataModel as `dgm:dataModel` (Transitional NS).
+ */
+export declare function serializeDiagramData(model: DiagramDataModel): ElementNode;
+export declare function serializeDiagramLayout(view: DiagramLayout): ElementNode;
+export declare function serializeDiagramQuickStyle(view: DiagramQuickStyle): ElementNode;
+export declare function serializeDiagramColors(view: DiagramColors): ElementNode;
+export declare function serializeDiagramDrawing(view: DiagramDrawing): ElementNode;
+/** Helper: emit a minimal a:extLst shell (for tests / extensions). */
+export declare function extLst(children?: ElementNode[]): ElementNode;