@syncfusion/ej2-office-common 35.1.37

package/src/features/smart-art/minimal-samples.js

@@ -0,0 +1,40 @@
+/**
+ * Built-in minimal diagram part XML seeds for {@link createDiagramInstance}.
+ *
+ * @remarks
+ * Documented sample only — not a layout catalog. Roots match Transitional
+ * `dml-diagram.xsd` (`dataModel`, `layoutDef`, `colorsDef`, `styleDef`).
+ * ECMA-376 Part 1 §14.2.3–14.2.6.
+ *
+ * @private
+ */
+/** Minimal `dgm:dataModel` with required `ptLst` (doc + one node). */
+export var MINIMAL_DIAGRAM_DATA_XML = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>' +
+    '<dgm:dataModel xmlns:dgm="http://schemas.openxmlformats.org/drawingml/2006/diagram"' +
+    ' xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main">' +
+    '<dgm:ptLst>' +
+    '<dgm:pt modelId="{00000000-0000-0000-0000-000000000001}" type="doc"/>' +
+    '<dgm:pt modelId="{00000000-0000-0000-0000-000000000002}"/>' +
+    '</dgm:ptLst>' +
+    '</dgm:dataModel>';
+/** Minimal `dgm:layoutDef` with title/desc. */
+export var MINIMAL_DIAGRAM_LAYOUT_XML = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>' +
+    '<dgm:layoutDef xmlns:dgm="http://schemas.openxmlformats.org/drawingml/2006/diagram"' +
+    ' uniqueId="urn:@syncfusion/ej2-office-common:sample:layout">' +
+    '<dgm:title lang="" val="Sample Layout"/>' +
+    '<dgm:desc lang="" val="Built-in minimal layoutDef"/>' +
+    '</dgm:layoutDef>';
+/** Minimal `dgm:colorsDef`. */
+export var MINIMAL_DIAGRAM_COLORS_XML = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>' +
+    '<dgm:colorsDef xmlns:dgm="http://schemas.openxmlformats.org/drawingml/2006/diagram"' +
+    ' uniqueId="urn:@syncfusion/ej2-office-common:sample:colors">' +
+    '<dgm:title lang="" val="Sample Colors"/>' +
+    '<dgm:desc lang="" val="Built-in minimal colorsDef"/>' +
+    '</dgm:colorsDef>';
+/** Minimal `dgm:styleDef`. */
+export var MINIMAL_DIAGRAM_STYLE_XML = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>' +
+    '<dgm:styleDef xmlns:dgm="http://schemas.openxmlformats.org/drawingml/2006/diagram"' +
+    ' uniqueId="urn:@syncfusion/ej2-office-common:sample:style">' +
+    '<dgm:title lang="" val="Sample Style"/>' +
+    '<dgm:desc lang="" val="Built-in minimal styleDef"/>' +
+    '</dgm:styleDef>';

package/src/features/smart-art/mutators.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Create / remove DrawingML diagram instances on a host-neutral package graph.
+ *
+ * @remarks
+ * - {@link createDiagramInstance}: factory per API-RULES R1.6 (not a banned
+ *   content `add*` verb). Add algorithm in the SmartArt technical spec.
+ * - {@link removeDiagramInstance}: content `remove*` verb (R1.1). Remove
+ *   algorithm: delete four owned diagram parts, drop package-graph relationships
+ *   targeting or sourced from those parts, and GC image targets from the Data
+ *   part only when reference count across the graph becomes zero (Part 1 §14.2.4).
+ *
+ * Host must remove graphic-frame / `dgm:relIds` markup; this module never imports
+ * PPT/Word/Excel product types.
+ *
+ * Citations: ECMA-376 Part 1 §14.2.3–14.2.6; Part 4 §12.2.3–12.2.6;
+ * Part 4 Transitional `relationships/image`; `dml-diagram.xsd` `CT_RelIds`.
+ *
+ * @public
+ */
+import { CreateDiagramInstanceOptions, CreateDiagramInstanceResult, DiagramPackageGraph, RemoveDiagramInstanceOptions, RemoveDiagramInstanceResult } from './types';
+/**
+ * Creates a new diagram instance: four package parts (exactly one of each type),
+ * optional source relationships, and a graphic-frame hook DTO.
+ *
+ * @param graph - Existing host-neutral package graph (not mutated).
+ * @param options - Seeds, optional source part name, optional part name prefix.
+ * @returns Updated graph, bound instance, and hook for host markup.
+ * @throws {DiagramPartError} When any seed is empty or fails parse — before writing parts.
+ *
+ * @public
+ */
+export declare function createDiagramInstance(graph: DiagramPackageGraph, options?: CreateDiagramInstanceOptions): CreateDiagramInstanceResult;
+/**
+ * Removes a diagram instance from a host-neutral package graph.
+ *
+ * @remarks
+ * Implements the Remove algorithm in `docs/specs/smart-art-shared-common.md`:
+ * 1. Resolve four owned diagram part names (from `instance` and/or id matchers).
+ * 2. Collect Data-part outbound {@link OFFICE_IMAGE_RELATIONSHIP_TYPE} targets;
+ *    delete image parts only when no remaining graph relationship (outside the
+ *    deleted diagram parts) still references them (Part 1 §14.2.4).
+ * 3. Delete the four diagram parts (content-type entries travel with parts on
+ *    this host-neutral graph).
+ * 4. Delete relationships that target any removed part, or whose source is one
+ *    of the four diagram parts.
+ * 5. Host graphic-frame / `dgm:relIds` XML cleanup remains the host’s duty.
+ *
+ * Unknown instance id throws {@link DiagramPartError} (explicit mutate policy).
+ * Input `graph` is never mutated. Part names that do not carry diagram content
+ * types are refused (forged-id safety).
+ *
+ * @param graph - Current package graph (not mutated).
+ * @param options - Instance handle and/or id / dataPartName matchers.
+ * @returns Updated graph and list of removed part names.
+ * @throws {DiagramPartError} When matchers are missing, the instance is unknown,
+ *   or claimed part names are not owned diagram parts.
+ *
+ * @public
+ */
+export declare function removeDiagramInstance(graph: DiagramPackageGraph, options: RemoveDiagramInstanceOptions): RemoveDiagramInstanceResult;

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

@@ -0,0 +1,566 @@
+/**
+ * Create / remove DrawingML diagram instances on a host-neutral package graph.
+ *
+ * @remarks
+ * - {@link createDiagramInstance}: factory per API-RULES R1.6 (not a banned
+ *   content `add*` verb). Add algorithm in the SmartArt technical spec.
+ * - {@link removeDiagramInstance}: content `remove*` verb (R1.1). Remove
+ *   algorithm: delete four owned diagram parts, drop package-graph relationships
+ *   targeting or sourced from those parts, and GC image targets from the Data
+ *   part only when reference count across the graph becomes zero (Part 1 §14.2.4).
+ *
+ * Host must remove graphic-frame / `dgm:relIds` markup; this module never imports
+ * PPT/Word/Excel product types.
+ *
+ * Citations: ECMA-376 Part 1 §14.2.3–14.2.6; Part 4 §12.2.3–12.2.6;
+ * Part 4 Transitional `relationships/image`; `dml-diagram.xsd` `CT_RelIds`.
+ *
+ * @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 { MINIMAL_DIAGRAM_COLORS_XML, MINIMAL_DIAGRAM_DATA_XML, MINIMAL_DIAGRAM_LAYOUT_XML, MINIMAL_DIAGRAM_STYLE_XML } from './minimal-samples';
+import { DIAGRAM_COLORS_CONTENT_TYPE, DIAGRAM_COLORS_RELATIONSHIP_TYPE, DIAGRAM_DATA_CONTENT_TYPE, DIAGRAM_DATA_RELATIONSHIP_TYPE, DIAGRAM_GRAPHIC_DATA_URI, DIAGRAM_LAYOUT_CONTENT_TYPE, DIAGRAM_LAYOUT_RELATIONSHIP_TYPE, DIAGRAM_QUICK_STYLE_RELATIONSHIP_TYPE, DIAGRAM_STYLE_CONTENT_TYPE, OFFICE_IMAGE_RELATIONSHIP_TYPE } from './namespaces';
+import { getDiagramInstance, normalizePartName } from './package-graph';
+import { parseDiagramColors } from './parse-colors';
+import { parseDiagramData } from './parse-data';
+import { parseDiagramLayout } from './parse-layout';
+import { parseDiagramStyle } from './parse-style';
+var DEFAULT_PART_PREFIX = '/diagrams';
+function requireNonEmptyXml(label, xml, fallback) {
+    if (xml === undefined) {
+        return fallback;
+    }
+    if (xml.trim().length === 0) {
+        throw new DiagramPartError("createDiagramInstance: seeds." + label + " must be non-empty XML when provided");
+    }
+    return xml;
+}
+function resolveSeeds(seeds) {
+    var s = seeds != null ? seeds : {};
+    return {
+        dataXml: requireNonEmptyXml('dataXml', s.dataXml, MINIMAL_DIAGRAM_DATA_XML),
+        layoutXml: requireNonEmptyXml('layoutXml', s.layoutXml, MINIMAL_DIAGRAM_LAYOUT_XML),
+        colorsXml: requireNonEmptyXml('colorsXml', s.colorsXml, MINIMAL_DIAGRAM_COLORS_XML),
+        styleXml: requireNonEmptyXml('styleXml', s.styleXml, MINIMAL_DIAGRAM_STYLE_XML)
+    };
+}
+function parseValidatedSeeds(resolved) {
+    // Parse before any graph mutation — incomplete seeds must not write parts.
+    var data;
+    var layout;
+    var colors;
+    var style;
+    try {
+        data = parseDiagramData(resolved.dataXml);
+    }
+    catch (e) {
+        var msg = e instanceof Error ? e.message : String(e);
+        throw new DiagramPartError("createDiagramInstance: invalid data seed: " + msg);
+    }
+    try {
+        layout = parseDiagramLayout(resolved.layoutXml);
+    }
+    catch (e) {
+        var msg = e instanceof Error ? e.message : String(e);
+        throw new DiagramPartError("createDiagramInstance: invalid layout seed: " + msg);
+    }
+    try {
+        colors = parseDiagramColors(resolved.colorsXml);
+    }
+    catch (e) {
+        var msg = e instanceof Error ? e.message : String(e);
+        throw new DiagramPartError("createDiagramInstance: invalid colors seed: " + msg);
+    }
+    try {
+        style = parseDiagramStyle(resolved.styleXml);
+    }
+    catch (e) {
+        var msg = e instanceof Error ? e.message : String(e);
+        throw new DiagramPartError("createDiagramInstance: invalid style seed: " + msg);
+    }
+    return {
+        data: data,
+        layout: layout,
+        colors: colors,
+        style: style,
+        dataXml: resolved.dataXml,
+        layoutXml: resolved.layoutXml,
+        colorsXml: resolved.colorsXml,
+        styleXml: resolved.styleXml
+    };
+}
+function occupiedPartNames(parts) {
+    var e_1, _a;
+    var set = new Set();
+    try {
+        for (var parts_1 = __values(parts), parts_1_1 = parts_1.next(); !parts_1_1.done; parts_1_1 = parts_1.next()) {
+            var p = parts_1_1.value;
+            set.add(normalizePartName(p.name));
+        }
+    }
+    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 set;
+}
+function normalizePrefix(prefix) {
+    var raw = prefix === undefined || prefix.trim().length === 0 ? DEFAULT_PART_PREFIX : prefix;
+    var p = normalizePartName(raw);
+    // Drop trailing slash for join consistency (normalizePartName keeps leading /).
+    if (p.length > 1 && p.endsWith('/')) {
+        p = p.slice(0, -1);
+    }
+    return p;
+}
+function allocatePartNames(existing, prefix) {
+    var n = 1;
+    for (;;) {
+        var suffix = String(n);
+        var data = prefix + "/data" + suffix + ".xml";
+        var layout = prefix + "/layout" + suffix + ".xml";
+        var colors = prefix + "/colors" + suffix + ".xml";
+        var style = prefix + "/quickStyle" + suffix + ".xml";
+        if (!existing.has(data) && !existing.has(layout) && !existing.has(colors) && !existing.has(style)) {
+            return {
+                data: data,
+                layout: layout,
+                colors: colors,
+                style: style
+            };
+        }
+        n += 1;
+        if (n > 1000000) {
+            throw new DiagramPartError('createDiagramInstance: could not allocate unique part names');
+        }
+    }
+}
+/**
+ * Collect relationship ids already used from a given source (and globally when
+ * source is empty — still avoid id collisions in the graph slice).
+ */
+function usedRelationshipIds(relationships, sourceNorm) {
+    var e_2, _a, e_3, _b;
+    var used = new Set();
+    try {
+        for (var relationships_1 = __values(relationships), relationships_1_1 = relationships_1.next(); !relationships_1_1.done; relationships_1_1 = relationships_1.next()) {
+            var rel = relationships_1_1.value;
+            if (sourceNorm !== undefined) {
+                if (normalizePartName(rel.source) !== sourceNorm) {
+                    continue;
+                }
+            }
+            used.add(rel.id);
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (relationships_1_1 && !relationships_1_1.done && (_a = relationships_1.return)) _a.call(relationships_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    try {
+        // Also avoid any id already present in the graph (OPC ids are unique per .rels).
+        for (var relationships_2 = __values(relationships), relationships_2_1 = relationships_2.next(); !relationships_2_1.done; relationships_2_1 = relationships_2.next()) {
+            var rel = relationships_2_1.value;
+            used.add(rel.id);
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (relationships_2_1 && !relationships_2_1.done && (_b = relationships_2.return)) _b.call(relationships_2);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return used;
+}
+function allocateRelIds(used) {
+    var n = 1;
+    var take = function () {
+        for (;;) {
+            var id = "rId" + String(n);
+            n += 1;
+            if (!used.has(id)) {
+                used.add(id);
+                return id;
+            }
+            if (n > 1000000) {
+                throw new DiagramPartError('createDiagramInstance: could not allocate relationship ids');
+            }
+        }
+    };
+    return {
+        dm: take(),
+        lo: take(),
+        qs: take(),
+        cs: take()
+    };
+}
+/**
+ * Creates a new diagram instance: four package parts (exactly one of each type),
+ * optional source relationships, and a graphic-frame hook DTO.
+ *
+ * @param graph - Existing host-neutral package graph (not mutated).
+ * @param options - Seeds, optional source part name, optional part name prefix.
+ * @returns Updated graph, bound instance, and hook for host markup.
+ * @throws {DiagramPartError} When any seed is empty or fails parse — before writing parts.
+ *
+ * @public
+ */
+export function createDiagramInstance(graph, options) {
+    if (options === void 0) { options = {}; }
+    var resolved = resolveSeeds(options.seeds);
+    var parsed = parseValidatedSeeds(resolved);
+    var prefix = normalizePrefix(options.partNamePrefix);
+    var occupied = occupiedPartNames(graph.parts);
+    var partNames = allocatePartNames(occupied, prefix);
+    var sourceRaw = (options.sourcePartName == null ? void 0 : options.sourcePartName.trim());
+    var sourcePartName = sourceRaw !== undefined && sourceRaw.length > 0 ? normalizePartName(sourceRaw) : '';
+    var usedIds = usedRelationshipIds(graph.relationships, sourcePartName.length > 0 ? sourcePartName : undefined);
+    var relIds = allocateRelIds(usedIds);
+    var newParts = [{
+            name: partNames.data,
+            contentType: DIAGRAM_DATA_CONTENT_TYPE,
+            xml: parsed.dataXml
+        }, {
+            name: partNames.layout,
+            contentType: DIAGRAM_LAYOUT_CONTENT_TYPE,
+            xml: parsed.layoutXml
+        }, {
+            name: partNames.colors,
+            contentType: DIAGRAM_COLORS_CONTENT_TYPE,
+            xml: parsed.colorsXml
+        }, {
+            name: partNames.style,
+            contentType: DIAGRAM_STYLE_CONTENT_TYPE,
+            xml: parsed.styleXml
+        }];
+    var newRels = [];
+    if (sourcePartName.length > 0) {
+        newRels.push({
+            id: relIds.dm,
+            type: DIAGRAM_DATA_RELATIONSHIP_TYPE,
+            target: partNames.data,
+            source: sourcePartName
+        }, {
+            id: relIds.lo,
+            type: DIAGRAM_LAYOUT_RELATIONSHIP_TYPE,
+            target: partNames.layout,
+            source: sourcePartName
+        }, {
+            id: relIds.qs,
+            type: DIAGRAM_QUICK_STYLE_RELATIONSHIP_TYPE,
+            target: partNames.style,
+            source: sourcePartName
+        }, {
+            id: relIds.cs,
+            type: DIAGRAM_COLORS_RELATIONSHIP_TYPE,
+            target: partNames.colors,
+            source: sourcePartName
+        });
+    }
+    var nextGraph = {
+        parts: __spread(graph.parts, newParts),
+        relationships: __spread(graph.relationships, newRels)
+    };
+    var instance = {
+        id: partNames.data,
+        data: parsed.data,
+        layout: parsed.layout,
+        colors: parsed.colors,
+        style: parsed.style,
+        relIds: relIds,
+        partNames: partNames,
+        sourcePartName: sourcePartName
+    };
+    return {
+        graph: nextGraph,
+        instance: instance,
+        hook: {
+            graphicDataUri: DIAGRAM_GRAPHIC_DATA_URI,
+            relIds: relIds
+        }
+    };
+}
+function partNamesSet(names) {
+    return new Set([normalizePartName(names.data), normalizePartName(names.layout), normalizePartName(names.colors), normalizePartName(names.style)]);
+}
+/**
+ * Validates that each claimed diagram part exists with a diagram content type.
+ * Rejects forged ids that would delete non-diagram package parts.
+ */
+function requireOwnedDiagramParts(graph, names) {
+    var e_4, _a, e_5, _b;
+    var byName = new Map();
+    try {
+        for (var _c = __values(graph.parts), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var part = _d.value;
+            byName.set(normalizePartName(part.name), part);
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    var roles = [{
+            role: 'data',
+            name: names.data,
+            expected: DIAGRAM_DATA_CONTENT_TYPE
+        }, {
+            role: 'layout',
+            name: names.layout,
+            expected: DIAGRAM_LAYOUT_CONTENT_TYPE
+        }, {
+            role: 'colors',
+            name: names.colors,
+            expected: DIAGRAM_COLORS_CONTENT_TYPE
+        }, {
+            role: 'style',
+            name: names.style,
+            expected: DIAGRAM_STYLE_CONTENT_TYPE
+        }];
+    var resolved = {};
+    try {
+        for (var roles_1 = __values(roles), roles_1_1 = roles_1.next(); !roles_1_1.done; roles_1_1 = roles_1.next()) {
+            var _e = roles_1_1.value, role = _e.role, name_1 = _e.name, expected = _e.expected;
+            var key = normalizePartName(name_1);
+            var part = byName.get(key);
+            if (part === undefined) {
+                throw new DiagramPartError("removeDiagramInstance: diagram " + role + " part not found: " + key);
+            }
+            if (part.contentType !== expected) {
+                throw new DiagramPartError("removeDiagramInstance: refused to delete non-diagram part " + key + " " + ("(content type " + part.contentType + ", expected " + expected + ")"));
+            }
+            resolved[role] = key;
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (roles_1_1 && !roles_1_1.done && (_b = roles_1.return)) _b.call(roles_1);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    var data = resolved.data;
+    var layout = resolved.layout;
+    var colors = resolved.colors;
+    var style = resolved.style;
+    if (data === undefined || layout === undefined || colors === undefined || style === undefined) {
+        throw new DiagramPartError('removeDiagramInstance: incomplete diagram part set');
+    }
+    return {
+        data: data,
+        layout: layout,
+        colors: colors,
+        style: style
+    };
+}
+function resolveInstanceForRemove(graph, options) {
+    var hasInstance = options.instance !== undefined;
+    var idRaw = (options.id == null ? void 0 : options.id.trim());
+    var dataRaw = (options.dataPartName == null ? void 0 : options.dataPartName.trim());
+    var hasId = idRaw !== undefined && idRaw.length > 0;
+    var hasData = dataRaw !== undefined && dataRaw.length > 0;
+    if (!hasInstance && !hasId && !hasData) {
+        throw new DiagramPartError('removeDiagramInstance requires options.instance and/or options.id and/or options.dataPartName');
+    }
+    if (hasInstance) {
+        var inst = options.instance;
+        // Prefer live graph binding when id/data matchers are also supplied.
+        if (hasId || hasData) {
+            var lookup_1 = {};
+            if (hasId) {
+                lookup_1.id = idRaw;
+            }
+            lookup_1.dataPartName = hasData ? dataRaw : inst.partNames.data;
+            var found_1 = getDiagramInstance(graph, lookup_1);
+            if (found_1 === undefined) {
+                throw new DiagramPartError('removeDiagramInstance: no diagram instance matches the given id/dataPartName');
+            }
+            if (normalizePartName(found_1.partNames.data) !== normalizePartName(inst.partNames.data)) {
+                throw new DiagramPartError('removeDiagramInstance: options.instance does not match id/dataPartName');
+            }
+            return requireOwnedDiagramParts(graph, found_1.partNames);
+        }
+        return requireOwnedDiagramParts(graph, inst.partNames);
+    }
+    var lookup = {};
+    if (hasId) {
+        lookup.id = idRaw;
+    }
+    if (hasData) {
+        lookup.dataPartName = dataRaw;
+    }
+    var found = getDiagramInstance(graph, lookup);
+    if (found === undefined) {
+        throw new DiagramPartError('removeDiagramInstance: unknown diagram instance (no match for id/dataPartName)');
+    }
+    return requireOwnedDiagramParts(graph, found.partNames);
+}
+/**
+ * Image part names referenced only from the Data part’s outbound image rels
+ * that should be deleted after the Data part is removed (ref-count → 0).
+ */
+function exclusiveImageTargets(relationships, dataPartName, diagramParts) {
+    var e_6, _a, e_7, _b, e_8, _c;
+    var dataKey = normalizePartName(dataPartName);
+    var candidates = new Set();
+    try {
+        for (var relationships_3 = __values(relationships), relationships_3_1 = relationships_3.next(); !relationships_3_1.done; relationships_3_1 = relationships_3.next()) {
+            var rel = relationships_3_1.value;
+            if (rel.type !== OFFICE_IMAGE_RELATIONSHIP_TYPE) {
+                continue;
+            }
+            if (normalizePartName(rel.source) !== dataKey) {
+                continue;
+            }
+            var target = normalizePartName(rel.target);
+            // Never treat a diagram part name as an image GC target.
+            if (diagramParts.has(target)) {
+                continue;
+            }
+            candidates.add(target);
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (relationships_3_1 && !relationships_3_1.done && (_a = relationships_3.return)) _a.call(relationships_3);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    var exclusive = [];
+    try {
+        for (var candidates_1 = __values(candidates), candidates_1_1 = candidates_1.next(); !candidates_1_1.done; candidates_1_1 = candidates_1.next()) {
+            var target = candidates_1_1.value;
+            // After Data-part (and other deleted diagram) outbound edges are dropped,
+            // count surviving image edges from sources outside the deleted set.
+            var surviving = 0;
+            try {
+                for (var relationships_4 = __values(relationships), relationships_4_1 = relationships_4.next(); !relationships_4_1.done; relationships_4_1 = relationships_4.next()) {
+                    var rel = relationships_4_1.value;
+                    if (rel.type !== OFFICE_IMAGE_RELATIONSHIP_TYPE) {
+                        continue;
+                    }
+                    if (normalizePartName(rel.target) !== target) {
+                        continue;
+                    }
+                    var src = normalizePartName(rel.source);
+                    if (src === dataKey || diagramParts.has(src)) {
+                        continue;
+                    }
+                    surviving += 1;
+                }
+            }
+            catch (e_8_1) { e_8 = { error: e_8_1 }; }
+            finally {
+                try {
+                    if (relationships_4_1 && !relationships_4_1.done && (_c = relationships_4.return)) _c.call(relationships_4);
+                }
+                finally { if (e_8) throw e_8.error; }
+            }
+            if (surviving === 0) {
+                exclusive.push(target);
+            }
+        }
+    }
+    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    finally {
+        try {
+            if (candidates_1_1 && !candidates_1_1.done && (_b = candidates_1.return)) _b.call(candidates_1);
+        }
+        finally { if (e_7) throw e_7.error; }
+    }
+    return exclusive;
+}
+/**
+ * Removes a diagram instance from a host-neutral package graph.
+ *
+ * @remarks
+ * Implements the Remove algorithm in `docs/specs/smart-art-shared-common.md`:
+ * 1. Resolve four owned diagram part names (from `instance` and/or id matchers).
+ * 2. Collect Data-part outbound {@link OFFICE_IMAGE_RELATIONSHIP_TYPE} targets;
+ *    delete image parts only when no remaining graph relationship (outside the
+ *    deleted diagram parts) still references them (Part 1 §14.2.4).
+ * 3. Delete the four diagram parts (content-type entries travel with parts on
+ *    this host-neutral graph).
+ * 4. Delete relationships that target any removed part, or whose source is one
+ *    of the four diagram parts.
+ * 5. Host graphic-frame / `dgm:relIds` XML cleanup remains the host’s duty.
+ *
+ * Unknown instance id throws {@link DiagramPartError} (explicit mutate policy).
+ * Input `graph` is never mutated. Part names that do not carry diagram content
+ * types are refused (forged-id safety).
+ *
+ * @param graph - Current package graph (not mutated).
+ * @param options - Instance handle and/or id / dataPartName matchers.
+ * @returns Updated graph and list of removed part names.
+ * @throws {DiagramPartError} When matchers are missing, the instance is unknown,
+ *   or claimed part names are not owned diagram parts.
+ *
+ * @public
+ */
+export function removeDiagramInstance(graph, options) {
+    var partNames = resolveInstanceForRemove(graph, options);
+    var diagramParts = partNamesSet(partNames);
+    var imageGc = exclusiveImageTargets(graph.relationships, partNames.data, diagramParts);
+    var removeParts = new Set(__spread(diagramParts, imageGc));
+    var nextParts = graph.parts.filter(function (p) { return !removeParts.has(normalizePartName(p.name)); });
+    var nextRels = graph.relationships.filter(function (r) {
+        var src = normalizePartName(r.source);
+        var tgt = normalizePartName(r.target);
+        if (removeParts.has(tgt)) {
+            return false;
+        }
+        if (diagramParts.has(src)) {
+            return false;
+        }
+        return true;
+    });
+    var removedPartNames = __spread(removeParts).sort(function (a, b) { return a.localeCompare(b); });
+    return {
+        graph: {
+            parts: nextParts,
+            relationships: nextRels
+        },
+        removedPartNames: removedPartNames
+    };
+}