@syncfusion/ej2-office-common 35.1.37

package/src/features/diagrams/errors.js

@@ -0,0 +1,59 @@
+/**
+ * Typed errors for diagram parse / model / catalog operations.
+ * Load of recoverable diagram damage MUST NOT throw at package level;
+ * parsers of a single part MAY throw DiagramParseError for that part.
+ */
+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 DiagramError = /** @class */ (function (_super) {
+    __extends(DiagramError, _super);
+    function DiagramError(code, message) {
+        var _newTarget = this.constructor;
+        var _this = _super.call(this, message) || this;
+        _this.name = 'DiagramError';
+        _this.code = code;
+        // ES5 / AMD emit: restore prototype so `instanceof` works in browsers.
+        Object.setPrototypeOf(_this, _newTarget.prototype);
+        return _this;
+    }
+    return DiagramError;
+}(Error));
+export { DiagramError };
+var DiagramParseError = /** @class */ (function (_super) {
+    __extends(DiagramParseError, _super);
+    function DiagramParseError(code, message) {
+        var _newTarget = this.constructor;
+        var _this = _super.call(this, code, message) || this;
+        _this.name = 'DiagramParseError';
+        Object.setPrototypeOf(_this, _newTarget.prototype);
+        return _this;
+    }
+    return DiagramParseError;
+}(DiagramError));
+export { DiagramParseError };
+var DiagramModelError = /** @class */ (function (_super) {
+    __extends(DiagramModelError, _super);
+    function DiagramModelError(code, message) {
+        var _newTarget = this.constructor;
+        var _this = _super.call(this, code, message) || this;
+        _this.name = 'DiagramModelError';
+        Object.setPrototypeOf(_this, _newTarget.prototype);
+        return _this;
+    }
+    return DiagramModelError;
+}(DiagramError));
+export { DiagramModelError };
+export function isDiagramError(value) {
+    return value instanceof DiagramError;
+}

package/src/features/diagrams/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Public surface: `@syncfusion/ej2-office-common/diagrams`
+ *
+ * SmartArt / DrawingML diagram parser, model, serializer, and catalog.
+ * TASK-9008. Host wiring for docx is TASK-9009.
+ *
+ * @packageDocumentation
+ */
+export { A_NAMESPACE, A_NAMESPACE_STRICT, DGM14_NAMESPACE, DGM14_RECOLOR_IMG_EXT_URI, DGM_NAMESPACE, DGM_NAMESPACE_STRICT, DIAGRAMS_FEATURE_ID, DIAGRAM_COLORS_CONTENT_TYPE, DIAGRAM_COLORS_RELATIONSHIP_TYPE, DIAGRAM_DATA_CONTENT_TYPE, DIAGRAM_DATA_RELATIONSHIP_TYPE, DIAGRAM_DRAWING_CONTENT_TYPE, DIAGRAM_DRAWING_RELATIONSHIP_TYPE, DIAGRAM_GRAPHIC_DATA_URI, DIAGRAM_GRAPHIC_DATA_URI_STRICT, DIAGRAM_LAYOUT_CONTENT_TYPE, DIAGRAM_LAYOUT_RELATIONSHIP_TYPE, DIAGRAM_QUICK_STYLE_CONTENT_TYPE, DIAGRAM_QUICK_STYLE_RELATIONSHIP_TYPE, DSP_NAMESPACE, isANamespace, isDgmNamespace, isDiagramGraphicDataUri, isRNamespace, MAX_DIAGRAM_CONNECTIONS, MAX_DIAGRAM_POINTS, MS_DIAGRAM_DATA_MODEL_EXT_URI, R_NAMESPACE, R_NAMESPACE_STRICT, W_NAMESPACE, WP_NAMESPACE, } from './constants';
+export { attr, cloneElement, el, elementChildren, findChild, findChildren, getAttr, getAttrNS, isElementNode, isTextNode, text, textContent, ElementAttr, ElementChild, ElementNode, ElementTree, TextNode, } from './element-tree';
+export { DiagramError, DiagramModelError, DiagramParseError, isDiagramError, DiagramErrorCode, } from './errors';
+export { DiagramDataModel, isDiagramDataModel, DiagramConnection, DiagramConnectionProps, DiagramConnectionType, DiagramDataModelInit, DiagramPoint, DiagramPointProps, DiagramPointType, ModelId, } from './diagram-data-model';
+export { DiagramColors, DiagramDrawing, DiagramLayout, DiagramQuickStyle, isDiagramColors, isDiagramDrawing, isDiagramLayout, isDiagramQuickStyle, } from './diagram-views';
+export { parseDiagramColors, parseDiagramData, parseDiagramDrawing, parseDiagramLayout, parseDiagramQuickStyle, } from './diagram-parsers';
+export { extLst, serializeDiagramColors, serializeDiagramData, serializeDiagramDrawing, serializeDiagramLayout, serializeDiagramQuickStyle, } from './diagram-serializers';
+export { detectSmartArtInTree, findDiagramRelIdsInGraphicData, isSmartArtDiagram, isSmartArtGraphicDataUri, parseRelIds, SmartArtDiagram, DiagramRelIds, SmartArtDiagramInit, } from './smart-art-diagram';
+export { isSmartArtCatalog, relIds, SmartArtCatalog, ApplyToPackageOptions, ApplyToPackageResult, DiagramPartKind, DiagramPartRecord, PackageView, SmartArtRecord, } from './smart-art-catalog';

package/src/features/diagrams/index.js

@@ -0,0 +1,17 @@
+/**
+ * Public surface: `@syncfusion/ej2-office-common/diagrams`
+ *
+ * SmartArt / DrawingML diagram parser, model, serializer, and catalog.
+ * TASK-9008. Host wiring for docx is TASK-9009.
+ *
+ * @packageDocumentation
+ */
+export { A_NAMESPACE, A_NAMESPACE_STRICT, DGM14_NAMESPACE, DGM14_RECOLOR_IMG_EXT_URI, DGM_NAMESPACE, DGM_NAMESPACE_STRICT, DIAGRAMS_FEATURE_ID, DIAGRAM_COLORS_CONTENT_TYPE, DIAGRAM_COLORS_RELATIONSHIP_TYPE, DIAGRAM_DATA_CONTENT_TYPE, DIAGRAM_DATA_RELATIONSHIP_TYPE, DIAGRAM_DRAWING_CONTENT_TYPE, DIAGRAM_DRAWING_RELATIONSHIP_TYPE, DIAGRAM_GRAPHIC_DATA_URI, DIAGRAM_GRAPHIC_DATA_URI_STRICT, DIAGRAM_LAYOUT_CONTENT_TYPE, DIAGRAM_LAYOUT_RELATIONSHIP_TYPE, DIAGRAM_QUICK_STYLE_CONTENT_TYPE, DIAGRAM_QUICK_STYLE_RELATIONSHIP_TYPE, DSP_NAMESPACE, isANamespace, isDgmNamespace, isDiagramGraphicDataUri, isRNamespace, MAX_DIAGRAM_CONNECTIONS, MAX_DIAGRAM_POINTS, MS_DIAGRAM_DATA_MODEL_EXT_URI, R_NAMESPACE, R_NAMESPACE_STRICT, W_NAMESPACE, WP_NAMESPACE, } from './constants';
+export { attr, cloneElement, el, elementChildren, findChild, findChildren, getAttr, getAttrNS, isElementNode, isTextNode, text, textContent, } from './element-tree';
+export { DiagramError, DiagramModelError, DiagramParseError, isDiagramError, } from './errors';
+export { DiagramDataModel, isDiagramDataModel, } from './diagram-data-model';
+export { DiagramColors, DiagramDrawing, DiagramLayout, DiagramQuickStyle, isDiagramColors, isDiagramDrawing, isDiagramLayout, isDiagramQuickStyle, } from './diagram-views';
+export { parseDiagramColors, parseDiagramData, parseDiagramDrawing, parseDiagramLayout, parseDiagramQuickStyle, } from './diagram-parsers';
+export { extLst, serializeDiagramColors, serializeDiagramData, serializeDiagramDrawing, serializeDiagramLayout, serializeDiagramQuickStyle, } from './diagram-serializers';
+export { detectSmartArtInTree, findDiagramRelIdsInGraphicData, isSmartArtDiagram, isSmartArtGraphicDataUri, parseRelIds, SmartArtDiagram, } from './smart-art-diagram';
+export { isSmartArtCatalog, relIds, SmartArtCatalog, } from './smart-art-catalog';

package/src/features/diagrams/smart-art-catalog.d.ts

@@ -0,0 +1,107 @@
+/**
+ * SmartArtCatalog — package-level index of diagram parts and SmartArt instances.
+ *
+ * D14: when a part is clean and originalBytes are present, applyToPackage
+ * writes those bytes; otherwise serializes ElementTree (caller encodes XML).
+ *
+ * Clone remaps modelIds; orphan-GC drops unreferenced parts after apply plan.
+ *
+ * Citations: requirement §12–§14; TASK-9008 catalog contract.
+ */
+import { DiagramDataModel } from './diagram-data-model';
+import { DiagramColors, DiagramDrawing, DiagramLayout, DiagramQuickStyle } from './diagram-views';
+import { ElementNode } from './element-tree';
+import { DiagramRelIds, SmartArtDiagram } from './smart-art-diagram';
+declare const CATALOG_BRAND: unique symbol;
+export declare type DiagramPartKind = 'data' | 'layout' | 'quickStyle' | 'colors' | 'drawing';
+export interface DiagramPartRecord {
+    readonly kind: DiagramPartKind;
+    readonly partName: string;
+    readonly relationshipId?: string;
+    readonly contentType: string;
+    readonly relationshipType: string;
+    /** Model or view instance. */
+    readonly part: DiagramDataModel | DiagramLayout | DiagramQuickStyle | DiagramColors | DiagramDrawing;
+}
+export interface SmartArtRecord {
+    readonly id: string;
+    readonly diagram: SmartArtDiagram;
+    /** Package part names keyed by role. */
+    readonly partNames: {
+        readonly data: string;
+        readonly layout: string;
+        readonly quickStyle: string;
+        readonly colors: string;
+        readonly drawing?: string;
+    };
+}
+/**
+ * Minimal package mutation view for applyToPackage.
+ * Hosts (docx) implement this against their OPC layer.
+ */
+export interface PackageView {
+    /** Upsert part bytes. */
+    putPart(partName: string, contentType: string, bytes: Uint8Array): void;
+    /** Optional: remove part. */
+    removePart?(partName: string): void;
+    /** Optional: ensure relationship. */
+    ensureRelationship?(sourcePartName: string, relationshipId: string, relationshipType: string, target: string): void;
+}
+export interface ApplyToPackageOptions {
+    /**
+     * Encode ElementTree → UTF-8 bytes. Required when a dirty part lacks originalBytes.
+     */
+    encodeXml: (tree: ElementNode) => Uint8Array;
+    /** When true, remove parts not referenced by any SmartArtRecord (orphan-GC). */
+    garbageCollectOrphans?: boolean;
+}
+export interface ApplyToPackageResult {
+    readonly written: string[];
+    readonly reusedBytes: string[];
+    readonly removed: string[];
+}
+export declare class SmartArtCatalog {
+    readonly [CATALOG_BRAND]: true;
+    private readonly _parts;
+    private readonly _smartArts;
+    private _seq;
+    readonly parts: ReadonlyArray<DiagramPartRecord>;
+    readonly smartArts: ReadonlyArray<SmartArtRecord>;
+    partCount(): number;
+    smartArtCount(): number;
+    getPart(partName: string): DiagramPartRecord | undefined;
+    getSmartArt(id: string): SmartArtRecord | undefined;
+    registerPart(record: DiagramPartRecord): void;
+    registerSmartArt(record: SmartArtRecord): void;
+    /**
+     * Allocate a new SmartArt id and register the diagram + its parts.
+     */
+    addSmartArt(diagram: SmartArtDiagram, partNames: SmartArtRecord['partNames'], id?: string): SmartArtRecord;
+    removeSmartArt(id: string): void;
+    /**
+     * Deep-clone a SmartArt instance with optional modelId remap prefix.
+     * Registers the clone under a new id; parts get new names when `partNamePrefix` set.
+     */
+    cloneSmartArt(id: string, options?: {
+        newId?: string;
+        partNamePrefix?: string;
+        modelIdPrefix?: string;
+    }): SmartArtRecord;
+    /**
+     * Parts referenced by at least one SmartArtRecord.
+     */
+    referencedPartNames(): Set<string>;
+    /**
+     * Remove part records not referenced by any SmartArt (in-memory orphan-GC).
+     */
+    garbageCollectOrphans(): string[];
+    /**
+     * Apply dirty (or all) parts to a PackageView.
+     * Clean parts with originalBytes reuse bytes (D14).
+     */
+    applyToPackage(pkg: PackageView, options: ApplyToPackageOptions): ApplyToPackageResult;
+}
+export declare function isSmartArtCatalog(value: unknown): value is SmartArtCatalog;
+/** Build DiagramRelIds helper for tests/hosts. */
+export declare function relIds(dm: string, lo: string, qs: string, cs: string): DiagramRelIds;
+export {};

package/src/features/diagrams/smart-art-catalog.js

@@ -0,0 +1,422 @@
+/**
+ * SmartArtCatalog — package-level index of diagram parts and SmartArt instances.
+ *
+ * D14: when a part is clean and originalBytes are present, applyToPackage
+ * writes those bytes; otherwise serializes ElementTree (caller encodes XML).
+ *
+ * Clone remaps modelIds; orphan-GC drops unreferenced parts after apply plan.
+ *
+ * Citations: requirement §12–§14; TASK-9008 catalog contract.
+ */
+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;
+};
+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 _a;
+import { DIAGRAM_COLORS_CONTENT_TYPE, DIAGRAM_COLORS_RELATIONSHIP_TYPE, DIAGRAM_DATA_CONTENT_TYPE, DIAGRAM_DATA_RELATIONSHIP_TYPE, DIAGRAM_DRAWING_CONTENT_TYPE, DIAGRAM_DRAWING_RELATIONSHIP_TYPE, DIAGRAM_LAYOUT_CONTENT_TYPE, DIAGRAM_LAYOUT_RELATIONSHIP_TYPE, DIAGRAM_QUICK_STYLE_CONTENT_TYPE, DIAGRAM_QUICK_STYLE_RELATIONSHIP_TYPE } from './constants';
+import { serializeDiagramData } from './diagram-serializers';
+import { serializeDiagramColors, serializeDiagramDrawing, serializeDiagramLayout, serializeDiagramQuickStyle } from './diagram-serializers';
+import { DiagramError } from './errors';
+var CATALOG_BRAND = Symbol.for('@syncfusion/ej2-office-common.SmartArtCatalog');
+function contentTypeFor(kind) {
+    switch (kind) {
+        case 'data':
+            return DIAGRAM_DATA_CONTENT_TYPE;
+        case 'layout':
+            return DIAGRAM_LAYOUT_CONTENT_TYPE;
+        case 'quickStyle':
+            return DIAGRAM_QUICK_STYLE_CONTENT_TYPE;
+        case 'colors':
+            return DIAGRAM_COLORS_CONTENT_TYPE;
+        case 'drawing':
+            return DIAGRAM_DRAWING_CONTENT_TYPE;
+    }
+}
+function relationshipTypeFor(kind) {
+    switch (kind) {
+        case 'data':
+            return DIAGRAM_DATA_RELATIONSHIP_TYPE;
+        case 'layout':
+            return DIAGRAM_LAYOUT_RELATIONSHIP_TYPE;
+        case 'quickStyle':
+            return DIAGRAM_QUICK_STYLE_RELATIONSHIP_TYPE;
+        case 'colors':
+            return DIAGRAM_COLORS_RELATIONSHIP_TYPE;
+        case 'drawing':
+            return DIAGRAM_DRAWING_RELATIONSHIP_TYPE;
+    }
+}
+function isDirtyPart(part) {
+    return part.dirty;
+}
+function originalBytesOf(part) {
+    return part.originalBytes;
+}
+function serializePart(kind, part) {
+    switch (kind) {
+        case 'data':
+            return serializeDiagramData(part);
+        case 'layout':
+            return serializeDiagramLayout(part);
+        case 'quickStyle':
+            return serializeDiagramQuickStyle(part);
+        case 'colors':
+            return serializeDiagramColors(part);
+        case 'drawing':
+            return serializeDiagramDrawing(part);
+    }
+}
+function clearPartDirty(part, bytes) {
+    part.clearDirty(bytes);
+}
+var SmartArtCatalog = /** @class */ (function () {
+    function SmartArtCatalog() {
+        this[_a] = true;
+        this._parts = new Map();
+        this._smartArts = new Map();
+        this._seq = 0;
+    }
+    Object.defineProperty(SmartArtCatalog.prototype, "parts", {
+        get: function () {
+            return __spread(this._parts.values());
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(SmartArtCatalog.prototype, "smartArts", {
+        get: function () {
+            return __spread(this._smartArts.values());
+        },
+        enumerable: true,
+        configurable: true
+    });
+    SmartArtCatalog.prototype.partCount = function () {
+        return this._parts.size;
+    };
+    SmartArtCatalog.prototype.smartArtCount = function () {
+        return this._smartArts.size;
+    };
+    SmartArtCatalog.prototype.getPart = function (partName) {
+        return this._parts.get(partName);
+    };
+    SmartArtCatalog.prototype.getSmartArt = function (id) {
+        return this._smartArts.get(id);
+    };
+    SmartArtCatalog.prototype.registerPart = function (record) {
+        this._parts.set(record.partName, __assign({}, record, { contentType: record.contentType || contentTypeFor(record.kind), relationshipType: record.relationshipType || relationshipTypeFor(record.kind) }));
+    };
+    SmartArtCatalog.prototype.registerSmartArt = function (record) {
+        this._smartArts.set(record.id, record);
+    };
+    /**
+     * Allocate a new SmartArt id and register the diagram + its parts.
+     */
+    SmartArtCatalog.prototype.addSmartArt = function (diagram, partNames, id) {
+        var _this = this;
+        var sid = id != null ? id : "smartart-" + String(++this._seq);
+        if (this._smartArts.has(sid)) {
+            throw new DiagramError('catalog_error', "SmartArt id already exists: " + sid);
+        }
+        var rec = {
+            id: sid,
+            diagram: diagram,
+            partNames: partNames
+        };
+        this._smartArts.set(sid, rec);
+        var ensure = function (kind, name, part) {
+            if (!_this._parts.has(name)) {
+                _this.registerPart({
+                    kind: kind,
+                    partName: name,
+                    contentType: contentTypeFor(kind),
+                    relationshipType: relationshipTypeFor(kind),
+                    part: part
+                });
+            }
+        };
+        ensure('data', partNames.data, diagram.data());
+        ensure('layout', partNames.layout, diagram.layout());
+        ensure('quickStyle', partNames.quickStyle, diagram.quickStyle());
+        ensure('colors', partNames.colors, diagram.colors());
+        var drawingPart = diagram.drawing();
+        if (partNames.drawing && drawingPart) {
+            ensure('drawing', partNames.drawing, drawingPart);
+        }
+        return rec;
+    };
+    SmartArtCatalog.prototype.removeSmartArt = function (id) {
+        this._smartArts.delete(id);
+    };
+    /**
+     * Deep-clone a SmartArt instance with optional modelId remap prefix.
+     * Registers the clone under a new id; parts get new names when `partNamePrefix` set.
+     */
+    SmartArtCatalog.prototype.cloneSmartArt = function (id, options) {
+        var e_1, _a, e_2, _b;
+        var src = this._smartArts.get(id);
+        if (!src) {
+            throw new DiagramError('catalog_error', "SmartArt not found: " + id);
+        }
+        var cloned = src.diagram.clone();
+        if (options == null ? void 0 : options.modelIdPrefix) {
+            var prefix = options.modelIdPrefix;
+            var data = cloned.data();
+            try {
+                for (var _c = __values(data.points), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var p = _d.value;
+                    p.modelId = prefix + p.modelId;
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            try {
+                for (var _e = __values(data.connections), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var c = _f.value;
+                    c.modelId = prefix + c.modelId;
+                    c.srcId = prefix + c.srcId;
+                    c.destId = prefix + c.destId;
+                    if (c.parTransId !== '0') {
+                        c.parTransId = prefix + c.parTransId;
+                    }
+                    if (c.sibTransId !== '0') {
+                        c.sibTransId = prefix + c.sibTransId;
+                    }
+                    data.markDirty();
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        }
+        var pfx = function () {
+            var _nc = options == null ? void 0 : options.partNamePrefix;
+            return _nc != null ? _nc : "cloned/" + id + "/";
+        }();
+        var partNames = __assign({ data: pfx + "data.xml", layout: pfx + "layout.xml", quickStyle: pfx + "quickStyle.xml", colors: pfx + "colors.xml" }, (src.partNames.drawing ? {
+            drawing: pfx + "drawing.xml"
+        } : {}));
+        return this.addSmartArt(cloned, partNames, options == null ? void 0 : options.newId);
+    };
+    /**
+     * Parts referenced by at least one SmartArtRecord.
+     */
+    SmartArtCatalog.prototype.referencedPartNames = function () {
+        var e_3, _a;
+        var set = new Set();
+        try {
+            for (var _b = __values(this._smartArts.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var s = _c.value;
+                set.add(s.partNames.data);
+                set.add(s.partNames.layout);
+                set.add(s.partNames.quickStyle);
+                set.add(s.partNames.colors);
+                if (s.partNames.drawing)
+                    set.add(s.partNames.drawing);
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        return set;
+    };
+    /**
+     * Remove part records not referenced by any SmartArt (in-memory orphan-GC).
+     */
+    SmartArtCatalog.prototype.garbageCollectOrphans = function () {
+        var e_4, _a;
+        var ref = this.referencedPartNames();
+        var removed = [];
+        try {
+            for (var _b = __values(__spread(this._parts.keys())), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var name_1 = _c.value;
+                if (!ref.has(name_1)) {
+                    this._parts.delete(name_1);
+                    removed.push(name_1);
+                }
+            }
+        }
+        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 removed;
+    };
+    /**
+     * Apply dirty (or all) parts to a PackageView.
+     * Clean parts with originalBytes reuse bytes (D14).
+     */
+    SmartArtCatalog.prototype.applyToPackage = function (pkg, options) {
+        var e_5, _a, e_6, _b, e_7, _c;
+        var written = [];
+        var reusedBytes = [];
+        var removed = [];
+        try {
+            // Sync part map from smart arts (model identity may share).
+            for (var _d = __values(this._smartArts.values()), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var s = _e.value;
+                var d = s.diagram;
+                this.registerPart({
+                    kind: 'data',
+                    partName: s.partNames.data,
+                    contentType: DIAGRAM_DATA_CONTENT_TYPE,
+                    relationshipType: DIAGRAM_DATA_RELATIONSHIP_TYPE,
+                    part: d.data()
+                });
+                this.registerPart({
+                    kind: 'layout',
+                    partName: s.partNames.layout,
+                    contentType: DIAGRAM_LAYOUT_CONTENT_TYPE,
+                    relationshipType: DIAGRAM_LAYOUT_RELATIONSHIP_TYPE,
+                    part: d.layout()
+                });
+                this.registerPart({
+                    kind: 'quickStyle',
+                    partName: s.partNames.quickStyle,
+                    contentType: DIAGRAM_QUICK_STYLE_CONTENT_TYPE,
+                    relationshipType: DIAGRAM_QUICK_STYLE_RELATIONSHIP_TYPE,
+                    part: d.quickStyle()
+                });
+                this.registerPart({
+                    kind: 'colors',
+                    partName: s.partNames.colors,
+                    contentType: DIAGRAM_COLORS_CONTENT_TYPE,
+                    relationshipType: DIAGRAM_COLORS_RELATIONSHIP_TYPE,
+                    part: d.colors()
+                });
+                var drawingPart = d.drawing();
+                if (s.partNames.drawing && drawingPart) {
+                    this.registerPart({
+                        kind: 'drawing',
+                        partName: s.partNames.drawing,
+                        contentType: DIAGRAM_DRAWING_CONTENT_TYPE,
+                        relationshipType: DIAGRAM_DRAWING_RELATIONSHIP_TYPE,
+                        part: drawingPart
+                    });
+                }
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+        try {
+            for (var _f = __values(this._parts.values()), _g = _f.next(); !_g.done; _g = _f.next()) {
+                var rec = _g.value;
+                var dirty = isDirtyPart(rec.part);
+                var orig = originalBytesOf(rec.part);
+                var bytes = void 0;
+                if (!dirty && orig) {
+                    bytes = orig;
+                    reusedBytes.push(rec.partName);
+                }
+                else {
+                    var tree = serializePart(rec.kind, rec.part);
+                    bytes = options.encodeXml(tree);
+                    written.push(rec.partName);
+                }
+                pkg.putPart(rec.partName, rec.contentType, bytes);
+                clearPartDirty(rec.part, bytes);
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+        if (options.garbageCollectOrphans) {
+            var gone = this.garbageCollectOrphans();
+            try {
+                for (var gone_1 = __values(gone), gone_1_1 = gone_1.next(); !gone_1_1.done; gone_1_1 = gone_1.next()) {
+                    var name_2 = gone_1_1.value;
+                    pkg.removePart == null ? void 0 : pkg.removePart(name_2);
+                    removed.push(name_2);
+                }
+            }
+            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+            finally {
+                try {
+                    if (gone_1_1 && !gone_1_1.done && (_c = gone_1.return)) _c.call(gone_1);
+                }
+                finally { if (e_7) throw e_7.error; }
+            }
+        }
+        return {
+            written: written,
+            reusedBytes: reusedBytes,
+            removed: removed
+        };
+    };
+    return SmartArtCatalog;
+}());
+export { SmartArtCatalog };
+_a = CATALOG_BRAND;
+export function isSmartArtCatalog(value) {
+    return value instanceof SmartArtCatalog;
+}
+/** Build DiagramRelIds helper for tests/hosts. */
+export function relIds(dm, lo, qs, cs) {
+    return {
+        dm: dm,
+        lo: lo,
+        qs: qs,
+        cs: cs
+    };
+}