@syncfusion/ej2-office-common 35.1.37

package/src/features/smart-art/package-graph.js

@@ -0,0 +1,413 @@
+/**
+ * Host-neutral discovery of DrawingML diagram instances from a package graph.
+ *
+ * @remarks
+ * Locates the four diagram parts (content types / relationship types from
+ * ECMA-376 Part 1 §14.2.3–14.2.6 and Part 4 §12.2.3–12.2.6) and binds them via
+ * `dgm:relIds` (`CT_RelIds`) and/or outbound diagram relationships from a common
+ * source part. Layout parts are never shared across instances (§14.2.5).
+ *
+ * This module does not import PPT/Word/Excel product types. Callers supply a
+ * {@link DiagramPackageGraph} (parts + relationships).
+ *
+ * @public
+ */
+var __values = (this && this.__values) || function (o) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+    if (m) return m.call(o);
+    return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+import { DiagramPartError } from './errors';
+import { DIAGRAM_COLORS_CONTENT_TYPE, DIAGRAM_COLORS_RELATIONSHIP_TYPE, DIAGRAM_DATA_CONTENT_TYPE, DIAGRAM_DATA_RELATIONSHIP_TYPE, DIAGRAM_LAYOUT_CONTENT_TYPE, DIAGRAM_LAYOUT_RELATIONSHIP_TYPE, DIAGRAM_QUICK_STYLE_RELATIONSHIP_TYPE, DIAGRAM_STYLE_CONTENT_TYPE } from './namespaces';
+import { parseDiagramColors } from './parse-colors';
+import { parseDiagramData } from './parse-data';
+import { parseDiagramLayout } from './parse-layout';
+import { findDiagramRelIds } from './parse-rel-ids';
+import { parseDiagramStyle } from './parse-style';
+/** Normalize package part names for map keys (leading `/`, no trailing `/`). */
+export function normalizePartName(name) {
+    var n = name.trim().replace(/\\/g, '/');
+    if (n.length === 0) {
+        return '/';
+    }
+    if (!n.startsWith('/')) {
+        n = "/" + n;
+    }
+    if (n.length > 1 && n.endsWith('/')) {
+        n = n.slice(0, -1);
+    }
+    return n;
+}
+function buildPartMap(parts) {
+    var e_1, _a;
+    var map = new Map();
+    try {
+        for (var parts_1 = __values(parts), parts_1_1 = parts_1.next(); !parts_1_1.done; parts_1_1 = parts_1.next()) {
+            var part = parts_1_1.value;
+            map.set(normalizePartName(part.name), part);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (parts_1_1 && !parts_1_1.done && (_a = parts_1.return)) _a.call(parts_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return map;
+}
+function relationshipsFromSource(relationships, source) {
+    var src = normalizePartName(source);
+    return relationships.filter(function (r) { return normalizePartName(r.source) === src; });
+}
+function resolveTarget(rels, relId) {
+    var e_2, _a;
+    try {
+        for (var rels_1 = __values(rels), rels_1_1 = rels_1.next(); !rels_1_1.done; rels_1_1 = rels_1.next()) {
+            var r = rels_1_1.value;
+            if (r.id === relId) {
+                return normalizePartName(r.target);
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (rels_1_1 && !rels_1_1.done && (_a = rels_1.return)) _a.call(rels_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return undefined;
+}
+function requirePart(map, name, role) {
+    var part = map.get(normalizePartName(name));
+    if (part === undefined) {
+        throw new DiagramPartError("Diagram " + role + " part not found: " + name);
+    }
+    return part;
+}
+function parseFourParts(map, names) {
+    var dataPart = requirePart(map, names.data, 'data');
+    var layoutPart = requirePart(map, names.layout, 'layout');
+    var colorsPart = requirePart(map, names.colors, 'colors');
+    var stylePart = requirePart(map, names.style, 'style');
+    if (dataPart.contentType !== DIAGRAM_DATA_CONTENT_TYPE) {
+        throw new DiagramPartError("Expected diagram data content type for " + names.data + ", got " + dataPart.contentType);
+    }
+    if (layoutPart.contentType !== DIAGRAM_LAYOUT_CONTENT_TYPE) {
+        throw new DiagramPartError("Expected diagram layout content type for " + names.layout + ", got " + layoutPart.contentType);
+    }
+    if (colorsPart.contentType !== DIAGRAM_COLORS_CONTENT_TYPE) {
+        throw new DiagramPartError("Expected diagram colors content type for " + names.colors + ", got " + colorsPart.contentType);
+    }
+    if (stylePart.contentType !== DIAGRAM_STYLE_CONTENT_TYPE) {
+        throw new DiagramPartError("Expected diagram style content type for " + names.style + ", got " + stylePart.contentType);
+    }
+    return {
+        data: parseDiagramData(dataPart.xml),
+        layout: parseDiagramLayout(layoutPart.xml),
+        colors: parseDiagramColors(colorsPart.xml),
+        style: parseDiagramStyle(stylePart.xml)
+    };
+}
+function instanceFromBinding(map, sourcePartName, relIds, names) {
+    var parsed = parseFourParts(map, names);
+    var id = normalizePartName(names.data);
+    return {
+        id: id,
+        data: parsed.data,
+        layout: parsed.layout,
+        colors: parsed.colors,
+        style: parsed.style,
+        relIds: {
+            dm: relIds.dm,
+            lo: relIds.lo,
+            qs: relIds.qs,
+            cs: relIds.cs
+        },
+        partNames: {
+            data: normalizePartName(names.data),
+            layout: normalizePartName(names.layout),
+            colors: normalizePartName(names.colors),
+            style: normalizePartName(names.style)
+        },
+        sourcePartName: sourcePartName.length > 0 ? normalizePartName(sourcePartName) : ''
+    };
+}
+function tryBindRelIds(map, sourceRels, sourcePartName, relIds) {
+    var data = resolveTarget(sourceRels, relIds.dm);
+    var layout = resolveTarget(sourceRels, relIds.lo);
+    var style = resolveTarget(sourceRels, relIds.qs);
+    var colors = resolveTarget(sourceRels, relIds.cs);
+    if (data === undefined || layout === undefined || style === undefined || colors === undefined) {
+        return undefined;
+    }
+    try {
+        return instanceFromBinding(map, sourcePartName, relIds, {
+            data: data,
+            layout: layout,
+            colors: colors,
+            style: style
+        });
+    }
+    catch (_a) {
+        // Orphan/partial graph: missing part or wrong content type — skip for enumerate.
+        return undefined;
+    }
+}
+/**
+ * Groups outbound diagram relationship types from one source into part names.
+ *
+ * @returns Names + synthetic relIds when exactly one of each role is present.
+ */
+function clusterFromSourceRels(sourceRels) {
+    var dataRels = sourceRels.filter(function (r) { return r.type === DIAGRAM_DATA_RELATIONSHIP_TYPE; });
+    var layoutRels = sourceRels.filter(function (r) { return r.type === DIAGRAM_LAYOUT_RELATIONSHIP_TYPE; });
+    var styleRels = sourceRels.filter(function (r) { return r.type === DIAGRAM_QUICK_STYLE_RELATIONSHIP_TYPE; });
+    var colorsRels = sourceRels.filter(function (r) { return r.type === DIAGRAM_COLORS_RELATIONSHIP_TYPE; });
+    if (dataRels.length !== 1 || layoutRels.length !== 1 || styleRels.length !== 1 || colorsRels.length !== 1) {
+        return undefined;
+    }
+    var dataRel = dataRels[0];
+    var layoutRel = layoutRels[0];
+    var styleRel = styleRels[0];
+    var colorsRel = colorsRels[0];
+    if (dataRel === undefined || layoutRel === undefined || styleRel === undefined || colorsRel === undefined) {
+        return undefined;
+    }
+    return {
+        relIds: {
+            dm: dataRel.id,
+            lo: layoutRel.id,
+            qs: styleRel.id,
+            cs: colorsRel.id
+        },
+        names: {
+            data: normalizePartName(dataRel.target),
+            layout: normalizePartName(layoutRel.target),
+            colors: normalizePartName(colorsRel.target),
+            style: normalizePartName(styleRel.target)
+        }
+    };
+}
+/**
+ * Lists diagram instances discoverable from the package graph.
+ *
+ * @remarks
+ * Discovery order:
+ * 1. Complete `dgm:relIds` hooks in part XML (incomplete hooks skipped —
+ *    preserve-on-load).
+ * 2. Source parts with exactly one outbound relationship of each diagram type
+ *    (when not already covered by a relIds binding).
+ *
+ * Layout part names used by more than one instance violate Part 1 §14.2.5;
+ * each binding is still returned so callers can detect the clash.
+ *
+ * Partial graphs (missing target part, wrong content type, incomplete relIds)
+ * do not throw; they simply omit that candidate. Explicit {@link parseDiagramRelIds}
+ * and mutate APIs throw instead.
+ *
+ * @param graph - Host-neutral parts + relationships.
+ * @returns Instances in stable order (first by source part name, then data part name).
+ *
+ * @public
+ */
+export function enumerateDiagramInstances(graph) {
+    var e_3, _a, e_4, _b, e_5, _c, e_6, _d;
+    var map = buildPartMap(graph.parts);
+    var byId = new Map();
+    try {
+        // Path 1: relIds in part XML.
+        for (var _e = __values(graph.parts), _f = _e.next(); !_f.done; _f = _e.next()) {
+            var part = _f.value;
+            var sourceName = normalizePartName(part.name);
+            var hooks = void 0;
+            try {
+                hooks = findDiagramRelIds(part.xml);
+            }
+            catch (_g) {
+                // Malformed host XML — skip this part for discovery.
+                continue;
+            }
+            if (hooks.length === 0) {
+                continue;
+            }
+            var sourceRels = relationshipsFromSource(graph.relationships, sourceName);
+            try {
+                for (var hooks_1 = __values(hooks), hooks_1_1 = hooks_1.next(); !hooks_1_1.done; hooks_1_1 = hooks_1.next()) {
+                    var relIds = hooks_1_1.value;
+                    var inst = tryBindRelIds(map, sourceRels, sourceName, relIds);
+                    if (inst !== undefined && !byId.has(inst.id)) {
+                        byId.set(inst.id, inst);
+                    }
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (hooks_1_1 && !hooks_1_1.done && (_b = hooks_1.return)) _b.call(hooks_1);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    // Path 2: relationship clustering by source (exactly one of each role).
+    var sources = new Set();
+    try {
+        for (var _h = __values(graph.relationships), _j = _h.next(); !_j.done; _j = _h.next()) {
+            var rel = _j.value;
+            if (rel.type === DIAGRAM_DATA_RELATIONSHIP_TYPE || rel.type === DIAGRAM_LAYOUT_RELATIONSHIP_TYPE || rel.type === DIAGRAM_QUICK_STYLE_RELATIONSHIP_TYPE || rel.type === DIAGRAM_COLORS_RELATIONSHIP_TYPE) {
+                sources.add(normalizePartName(rel.source));
+            }
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    try {
+        for (var sources_1 = __values(sources), sources_1_1 = sources_1.next(); !sources_1_1.done; sources_1_1 = sources_1.next()) {
+            var sourceName = sources_1_1.value;
+            var sourceRels = relationshipsFromSource(graph.relationships, sourceName);
+            var clustered = clusterFromSourceRels(sourceRels);
+            if (clustered === undefined) {
+                continue;
+            }
+            try {
+                var inst = instanceFromBinding(map, sourceName, clustered.relIds, clustered.names);
+                if (!byId.has(inst.id)) {
+                    byId.set(inst.id, inst);
+                }
+            }
+            catch (_k) {
+                // Partial graph — skip.
+            }
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (sources_1_1 && !sources_1_1.done && (_d = sources_1.return)) _d.call(sources_1);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    var list = __spread(byId.values());
+    list.sort(function (a, b) {
+        var s = a.sourcePartName.localeCompare(b.sourcePartName);
+        if (s !== 0) {
+            return s;
+        }
+        return a.id.localeCompare(b.id);
+    });
+    return list;
+}
+/**
+ * Resolves a single diagram instance from the package graph.
+ *
+ * @param graph - Host-neutral parts + relationships.
+ * @param options - Match by {@link GetDiagramInstanceOptions.id} and/or
+ * `dataPartName` (normalized). At least one matcher is required.
+ * @returns The instance, or `undefined` when not found.
+ * @throws {DiagramPartError} When no matcher is provided.
+ *
+ * @public
+ */
+export function getDiagramInstance(graph, options) {
+    var e_7, _a;
+    var idOpt = (options.id == null ? void 0 : options.id.trim());
+    var dataOpt = (options.dataPartName == null ? void 0 : options.dataPartName.trim());
+    if ((idOpt === undefined || idOpt.length === 0) && (dataOpt === undefined || dataOpt.length === 0)) {
+        throw new DiagramPartError('getDiagramInstance requires options.id and/or options.dataPartName');
+    }
+    var wantId = idOpt !== undefined && idOpt.length > 0 ? normalizePartName(idOpt) : undefined;
+    var wantData = dataOpt !== undefined && dataOpt.length > 0 ? normalizePartName(dataOpt) : undefined;
+    var all = enumerateDiagramInstances(graph);
+    try {
+        for (var all_1 = __values(all), all_1_1 = all_1.next(); !all_1_1.done; all_1_1 = all_1.next()) {
+            var inst = all_1_1.value;
+            if (wantId !== undefined && inst.id !== wantId) {
+                continue;
+            }
+            if (wantData !== undefined && inst.partNames.data !== wantData) {
+                continue;
+            }
+            return inst;
+        }
+    }
+    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    finally {
+        try {
+            if (all_1_1 && !all_1_1.done && (_a = all_1.return)) _a.call(all_1);
+        }
+        finally { if (e_7) throw e_7.error; }
+    }
+    return undefined;
+}
+/**
+ * Lists package parts whose content type is one of the four diagram types.
+ *
+ * @param graph - Host-neutral package graph.
+ * @returns Matching parts in input order (names normalized on the returned copies).
+ *
+ * @public
+ */
+export function listDiagramParts(graph) {
+    var e_8, _a;
+    var types = new Set([DIAGRAM_DATA_CONTENT_TYPE, DIAGRAM_LAYOUT_CONTENT_TYPE, DIAGRAM_COLORS_CONTENT_TYPE, DIAGRAM_STYLE_CONTENT_TYPE]);
+    var out = [];
+    try {
+        for (var _b = __values(graph.parts), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var part = _c.value;
+            if (types.has(part.contentType)) {
+                out.push({
+                    name: normalizePartName(part.name),
+                    contentType: part.contentType,
+                    xml: part.xml
+                });
+            }
+        }
+    }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_8) throw e_8.error; }
+    }
+    return out;
+}

package/src/features/smart-art/parse-colors.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Parse Diagram Colors part (`dgm:colorsDef` / `CT_ColorTransform`).
+ *
+ * @remarks
+ * Citations: Transitional `dml-diagram.xsd` (`CT_ColorTransform`);
+ * ECMA-376 Part 1 §14.2.3. v1: optional `uniqueId` + opaque root preserve.
+ *
+ * @public
+ */
+import { DiagramColorsPart } from './types';
+/**
+ * Parses a Diagram Colors part XML document into a {@link DiagramColorsPart}.
+ *
+ * @param xml - UTF-8 XML for a single `dgm:colorsDef` root.
+ * @throws {DiagramPartError} Malformed XML or wrong root element.
+ *
+ * @public
+ */
+export declare function parseDiagramColors(xml: string): DiagramColorsPart;

package/src/features/smart-art/parse-colors.js

@@ -0,0 +1,39 @@
+/**
+ * Parse Diagram Colors part (`dgm:colorsDef` / `CT_ColorTransform`).
+ *
+ * @remarks
+ * Citations: Transitional `dml-diagram.xsd` (`CT_ColorTransform`);
+ * ECMA-376 Part 1 §14.2.3. v1: optional `uniqueId` + opaque root preserve.
+ *
+ * @public
+ */
+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);
+};
+import { cloneElement, getAttribute, parseDiagramXml } from './diagram-xml';
+import { DiagramPartError } from './errors';
+import { DIAGRAM_NAMESPACE } from './namespaces';
+/**
+ * Parses a Diagram Colors part XML document into a {@link DiagramColorsPart}.
+ *
+ * @param xml - UTF-8 XML for a single `dgm:colorsDef` root.
+ * @throws {DiagramPartError} Malformed XML or wrong root element.
+ *
+ * @public
+ */
+export function parseDiagramColors(xml) {
+    var root = parseDiagramXml(xml);
+    if (root.localName !== 'colorsDef' || root.namespaceUri !== DIAGRAM_NAMESPACE) {
+        throw new DiagramPartError("Expected dgm:colorsDef root, got " + root.qName + " in ns \"" + root.namespaceUri + "\"");
+    }
+    var uniqueId = getAttribute(root, 'uniqueId');
+    return __assign({ kind: 'diagramColors' }, (uniqueId !== undefined ? { uniqueId: uniqueId } : {}), { root: cloneElement(root) });
+}

package/src/features/smart-art/parse-data.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Parse Diagram Data part (`dgm:dataModel` / `CT_DataModel`).
+ *
+ * @remarks
+ * Citations: Transitional `dml-diagram.xsd` (`CT_DataModel`, `CT_Pt`, `ST_PtType`,
+ * `CT_Cxn`); ECMA-376 Part 1 §14.2.4. Required `ptLst`; optional `cxnLst` /
+ * `bg` / `whole` / `extLst` preserved on the root element.
+ *
+ * @public
+ */
+import { DiagramDataPart } from './types';
+/**
+ * Parses a Diagram Data part XML document into a {@link DiagramDataPart}.
+ *
+ * @param xml - UTF-8 XML for a single `dgm:dataModel` root.
+ * @returns Modeled points/connections plus full root for preserve serialize.
+ * @throws {DiagramPartError} Malformed XML, wrong root, or missing `ptLst`.
+ *
+ * @public
+ */
+export declare function parseDiagramData(xml: string): DiagramDataPart;

package/src/features/smart-art/parse-data.js

@@ -0,0 +1,121 @@
+/**
+ * Parse Diagram Data part (`dgm:dataModel` / `CT_DataModel`).
+ *
+ * @remarks
+ * Citations: Transitional `dml-diagram.xsd` (`CT_DataModel`, `CT_Pt`, `ST_PtType`,
+ * `CT_Cxn`); ECMA-376 Part 1 §14.2.4. Required `ptLst`; optional `cxnLst` /
+ * `bg` / `whole` / `extLst` preserved on the root element.
+ *
+ * @public
+ */
+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 __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 { cloneElement, findChild, findChildren, getAttribute, parseDiagramXml, } from './diagram-xml';
+import { DiagramPartError } from './errors';
+import { DIAGRAM_NAMESPACE } from './namespaces';
+import { DiagramPointType, } from './types';
+var POINT_TYPES = new Set((function (_o) { return Object.keys(_o).map(function (k) { return _o[k]; }); })(DiagramPointType));
+function parsePoint(el) {
+    var modelId = getAttribute(el, 'modelId');
+    if (modelId === undefined || modelId.length === 0) {
+        throw new DiagramPartError('dgm:pt requires modelId');
+    }
+    var typeRaw = getAttribute(el, 'type');
+    var typeAttributePresent = typeRaw !== undefined;
+    var type = DiagramPointType.Node;
+    if (typeRaw !== undefined) {
+        if (!POINT_TYPES.has(typeRaw)) {
+            throw new DiagramPartError("dgm:pt has unsupported type \"" + typeRaw + "\"");
+        }
+        type = typeRaw;
+    }
+    var connectionId = getAttribute(el, 'cxnId');
+    var textBody = findChild(el, 't', DIAGRAM_NAMESPACE);
+    var point = __assign({ modelId: modelId,
+        type: type,
+        typeAttributePresent: typeAttributePresent }, (connectionId !== undefined ? { connectionId: connectionId } : {}), (textBody !== undefined ? { textBody: cloneElement(textBody) } : {}), { element: cloneElement(el) });
+    return point;
+}
+function parseConnection(el) {
+    var modelId = getAttribute(el, 'modelId');
+    var sourceId = getAttribute(el, 'srcId');
+    var destinationId = getAttribute(el, 'destId');
+    if (modelId === undefined || modelId.length === 0) {
+        throw new DiagramPartError('dgm:cxn requires modelId');
+    }
+    if (sourceId === undefined || sourceId.length === 0) {
+        throw new DiagramPartError('dgm:cxn requires srcId');
+    }
+    if (destinationId === undefined || destinationId.length === 0) {
+        throw new DiagramPartError('dgm:cxn requires destId');
+    }
+    return {
+        modelId: modelId,
+        sourceId: sourceId,
+        destinationId: destinationId,
+        element: cloneElement(el),
+    };
+}
+/**
+ * Parses a Diagram Data part XML document into a {@link DiagramDataPart}.
+ *
+ * @param xml - UTF-8 XML for a single `dgm:dataModel` root.
+ * @returns Modeled points/connections plus full root for preserve serialize.
+ * @throws {DiagramPartError} Malformed XML, wrong root, or missing `ptLst`.
+ *
+ * @public
+ */
+export function parseDiagramData(xml) {
+    var e_1, _a;
+    var root = parseDiagramXml(xml);
+    if (root.localName !== 'dataModel' || root.namespaceUri !== DIAGRAM_NAMESPACE) {
+        throw new DiagramPartError("Expected dgm:dataModel root, got " + root.qName + " in ns \"" + root.namespaceUri + "\"");
+    }
+    var ptLst = findChild(root, 'ptLst', DIAGRAM_NAMESPACE);
+    if (ptLst === undefined) {
+        throw new DiagramPartError('dgm:dataModel requires dgm:ptLst');
+    }
+    var points = findChildren(ptLst, 'pt', DIAGRAM_NAMESPACE).map(parsePoint);
+    var connections = [];
+    var cxnLst = findChild(root, 'cxnLst', DIAGRAM_NAMESPACE);
+    if (cxnLst !== undefined) {
+        try {
+            for (var _b = __values(findChildren(cxnLst, 'cxn', DIAGRAM_NAMESPACE)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var cxn = _c.value;
+                connections.push(parseConnection(cxn));
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+    return {
+        kind: 'diagramData',
+        points: points,
+        connections: connections,
+        root: cloneElement(root),
+    };
+}

package/src/features/smart-art/parse-layout.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Parse Diagram Layout Definition part (`dgm:layoutDef` / `CT_DiagramDefinition`).
+ *
+ * @remarks
+ * Citations: Transitional `dml-diagram.xsd` (`CT_DiagramDefinition`);
+ * ECMA-376 Part 1 §14.2.5. v1: optional `uniqueId` + opaque root preserve.
+ * Layout parts are not shared across diagrams (Part 1 §14.2.5).
+ *
+ * @public
+ */
+import { DiagramLayoutPart } from './types';
+/**
+ * Parses a Diagram Layout Definition part XML document into a {@link DiagramLayoutPart}.
+ *
+ * @param xml - UTF-8 XML for a single `dgm:layoutDef` root.
+ * @throws {DiagramPartError} Malformed XML or wrong root element.
+ *
+ * @public
+ */
+export declare function parseDiagramLayout(xml: string): DiagramLayoutPart;

package/src/features/smart-art/parse-layout.js

@@ -0,0 +1,40 @@
+/**
+ * Parse Diagram Layout Definition part (`dgm:layoutDef` / `CT_DiagramDefinition`).
+ *
+ * @remarks
+ * Citations: Transitional `dml-diagram.xsd` (`CT_DiagramDefinition`);
+ * ECMA-376 Part 1 §14.2.5. v1: optional `uniqueId` + opaque root preserve.
+ * Layout parts are not shared across diagrams (Part 1 §14.2.5).
+ *
+ * @public
+ */
+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);
+};
+import { cloneElement, getAttribute, parseDiagramXml } from './diagram-xml';
+import { DiagramPartError } from './errors';
+import { DIAGRAM_NAMESPACE } from './namespaces';
+/**
+ * Parses a Diagram Layout Definition part XML document into a {@link DiagramLayoutPart}.
+ *
+ * @param xml - UTF-8 XML for a single `dgm:layoutDef` root.
+ * @throws {DiagramPartError} Malformed XML or wrong root element.
+ *
+ * @public
+ */
+export function parseDiagramLayout(xml) {
+    var root = parseDiagramXml(xml);
+    if (root.localName !== 'layoutDef' || root.namespaceUri !== DIAGRAM_NAMESPACE) {
+        throw new DiagramPartError("Expected dgm:layoutDef root, got " + root.qName + " in ns \"" + root.namespaceUri + "\"");
+    }
+    var uniqueId = getAttribute(root, 'uniqueId');
+    return __assign({ kind: 'diagramLayout' }, (uniqueId !== undefined ? { uniqueId: uniqueId } : {}), { root: cloneElement(root) });
+}