ducjs 2.1.0 → 2.2.2

package/dist/flatbuffers/duc/duc-block.js

@@ -2,7 +2,7 @@
 /* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
 import * as flatbuffers from 'flatbuffers';
 import { DucBlockAttributeDefinitionEntry } from '../duc/duc-block-attribute-definition-entry';
-import { ElementWrapper } from '../duc/element-wrapper';
+import { DucBlockMetadata } from '../duc/duc-block-metadata';
 export class DucBlock {
     constructor() {
         this.bb = null;
@@ -36,24 +36,32 @@ export class DucBlock {
         const offset = this.bb.__offset(this.bb_pos, 10);
         return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
     }
-    elements(index, obj) {
+    attributeDefinitions(index, obj) {
         const offset = this.bb.__offset(this.bb_pos, 12);
-        return offset ? (obj || new ElementWrapper()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+        return offset ? (obj || new DucBlockAttributeDefinitionEntry()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
     }
-    elementsLength() {
+    attributeDefinitionsLength() {
         const offset = this.bb.__offset(this.bb_pos, 12);
         return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
     }
-    attributeDefinitions(index, obj) {
+    metadata(obj) {
         const offset = this.bb.__offset(this.bb_pos, 14);
-        return offset ? (obj || new DucBlockAttributeDefinitionEntry()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+        return offset ? (obj || new DucBlockMetadata()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
     }
-    attributeDefinitionsLength() {
-        const offset = this.bb.__offset(this.bb_pos, 14);
+    thumbnail(index) {
+        const offset = this.bb.__offset(this.bb_pos, 16);
+        return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
+    }
+    thumbnailLength() {
+        const offset = this.bb.__offset(this.bb_pos, 16);
         return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
     }
+    thumbnailArray() {
+        const offset = this.bb.__offset(this.bb_pos, 16);
+        return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
+    }
     static startDucBlock(builder) {
-        builder.startObject(6);
+        builder.startObject(7);
     }
     static addId(builder, idOffset) {
         builder.addFieldOffset(0, idOffset, 0);
@@ -67,45 +75,38 @@ export class DucBlock {
     static addVersion(builder, version) {
         builder.addFieldInt32(3, version, 0);
     }
-    static addElements(builder, elementsOffset) {
-        builder.addFieldOffset(4, elementsOffset, 0);
+    static addAttributeDefinitions(builder, attributeDefinitionsOffset) {
+        builder.addFieldOffset(4, attributeDefinitionsOffset, 0);
     }
-    static createElementsVector(builder, data) {
+    static createAttributeDefinitionsVector(builder, data) {
         builder.startVector(4, data.length, 4);
         for (let i = data.length - 1; i >= 0; i--) {
             builder.addOffset(data[i]);
         }
         return builder.endVector();
     }
-    static startElementsVector(builder, numElems) {
+    static startAttributeDefinitionsVector(builder, numElems) {
         builder.startVector(4, numElems, 4);
     }
-    static addAttributeDefinitions(builder, attributeDefinitionsOffset) {
-        builder.addFieldOffset(5, attributeDefinitionsOffset, 0);
+    static addMetadata(builder, metadataOffset) {
+        builder.addFieldOffset(5, metadataOffset, 0);
     }
-    static createAttributeDefinitionsVector(builder, data) {
-        builder.startVector(4, data.length, 4);
+    static addThumbnail(builder, thumbnailOffset) {
+        builder.addFieldOffset(6, thumbnailOffset, 0);
+    }
+    static createThumbnailVector(builder, data) {
+        builder.startVector(1, data.length, 1);
         for (let i = data.length - 1; i >= 0; i--) {
-            builder.addOffset(data[i]);
+            builder.addInt8(data[i]);
         }
         return builder.endVector();
     }
-    static startAttributeDefinitionsVector(builder, numElems) {
-        builder.startVector(4, numElems, 4);
+    static startThumbnailVector(builder, numElems) {
+        builder.startVector(1, numElems, 1);
     }
     static endDucBlock(builder) {
         const offset = builder.endObject();
         builder.requiredField(offset, 4); // id
         return offset;
     }
-    static createDucBlock(builder, idOffset, labelOffset, descriptionOffset, version, elementsOffset, attributeDefinitionsOffset) {
-        DucBlock.startDucBlock(builder);
-        DucBlock.addId(builder, idOffset);
-        DucBlock.addLabel(builder, labelOffset);
-        DucBlock.addDescription(builder, descriptionOffset);
-        DucBlock.addVersion(builder, version);
-        DucBlock.addElements(builder, elementsOffset);
-        DucBlock.addAttributeDefinitions(builder, attributeDefinitionsOffset);
-        return DucBlock.endDucBlock(builder);
-    }
 }

package/dist/flatbuffers/duc/duc-element-base.d.ts

@@ -49,6 +49,11 @@ export declare class _DucElementBase {
     locked(): boolean;
     customData(): string | null;
     customData(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+    blockIds(index: number): string;
+    blockIds(index: number, optionalEncoding: flatbuffers.Encoding): string | Uint8Array;
+    blockIdsLength(): number;
+    instanceId(): string | null;
+    instanceId(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
     static start_DucElementBase(builder: flatbuffers.Builder): void;
     static addId(builder: flatbuffers.Builder, idOffset: flatbuffers.Offset): void;
     static addStyles(builder: flatbuffers.Builder, stylesOffset: flatbuffers.Offset): void;
@@ -84,5 +89,9 @@ export declare class _DucElementBase {
     static addLink(builder: flatbuffers.Builder, linkOffset: flatbuffers.Offset): void;
     static addLocked(builder: flatbuffers.Builder, locked: boolean): void;
     static addCustomData(builder: flatbuffers.Builder, customDataOffset: flatbuffers.Offset): void;
+    static addBlockIds(builder: flatbuffers.Builder, blockIdsOffset: flatbuffers.Offset): void;
+    static createBlockIdsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startBlockIdsVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addInstanceId(builder: flatbuffers.Builder, instanceIdOffset: flatbuffers.Offset): void;
     static end_DucElementBase(builder: flatbuffers.Builder): flatbuffers.Offset;
 }

package/dist/flatbuffers/duc/duc-element-base.js

@@ -144,8 +144,20 @@ export class _DucElementBase {
         const offset = this.bb.__offset(this.bb_pos, 58);
         return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
     }
+    blockIds(index, optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 60);
+        return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
+    }
+    blockIdsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 60);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    instanceId(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 62);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+    }
     static start_DucElementBase(builder) {
-        builder.startObject(28);
+        builder.startObject(30);
     }
     static addId(builder, idOffset) {
         builder.addFieldOffset(0, idOffset, 0);
@@ -261,6 +273,22 @@ export class _DucElementBase {
     static addCustomData(builder, customDataOffset) {
         builder.addFieldOffset(27, customDataOffset, 0);
     }
+    static addBlockIds(builder, blockIdsOffset) {
+        builder.addFieldOffset(28, blockIdsOffset, 0);
+    }
+    static createBlockIdsVector(builder, data) {
+        builder.startVector(4, data.length, 4);
+        for (let i = data.length - 1; i >= 0; i--) {
+            builder.addOffset(data[i]);
+        }
+        return builder.endVector();
+    }
+    static startBlockIdsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static addInstanceId(builder, instanceIdOffset) {
+        builder.addFieldOffset(29, instanceIdOffset, 0);
+    }
     static end_DucElementBase(builder) {
         const offset = builder.endObject();
         builder.requiredField(offset, 4); // id

package/dist/flatbuffers/duc/exported-data-state.d.ts

@@ -1,6 +1,8 @@
 import * as flatbuffers from 'flatbuffers';
 import { DictionaryEntry } from '../duc/dictionary-entry';
 import { DucBlock } from '../duc/duc-block';
+import { DucBlockCollection } from '../duc/duc-block-collection';
+import { DucBlockInstance } from '../duc/duc-block-instance';
 import { DucExternalFileEntry } from '../duc/duc-external-file-entry';
 import { DucGlobalState } from '../duc/duc-global-state';
 import { DucGroup } from '../duc/duc-group';
@@ -48,6 +50,10 @@ export declare class ExportedDataState {
     versionGraph(obj?: VersionGraph): VersionGraph | null;
     id(): string | null;
     id(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+    blockInstances(index: number, obj?: DucBlockInstance): DucBlockInstance | null;
+    blockInstancesLength(): number;
+    blockCollections(index: number, obj?: DucBlockCollection): DucBlockCollection | null;
+    blockCollectionsLength(): number;
     static startExportedDataState(builder: flatbuffers.Builder): void;
     static addType(builder: flatbuffers.Builder, typeOffset: flatbuffers.Offset): void;
     static addVersionLegacy(builder: flatbuffers.Builder, versionLegacy: number): void;
@@ -84,6 +90,12 @@ export declare class ExportedDataState {
     static startExternalFilesVector(builder: flatbuffers.Builder, numElems: number): void;
     static addVersionGraph(builder: flatbuffers.Builder, versionGraphOffset: flatbuffers.Offset): void;
     static addId(builder: flatbuffers.Builder, idOffset: flatbuffers.Offset): void;
+    static addBlockInstances(builder: flatbuffers.Builder, blockInstancesOffset: flatbuffers.Offset): void;
+    static createBlockInstancesVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startBlockInstancesVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addBlockCollections(builder: flatbuffers.Builder, blockCollectionsOffset: flatbuffers.Offset): void;
+    static createBlockCollectionsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startBlockCollectionsVector(builder: flatbuffers.Builder, numElems: number): void;
     static endExportedDataState(builder: flatbuffers.Builder): flatbuffers.Offset;
     static finishExportedDataStateBuffer(builder: flatbuffers.Builder, offset: flatbuffers.Offset): void;
     static finishSizePrefixedExportedDataStateBuffer(builder: flatbuffers.Builder, offset: flatbuffers.Offset): void;

package/dist/flatbuffers/duc/exported-data-state.js

@@ -3,6 +3,8 @@
 import * as flatbuffers from 'flatbuffers';
 import { DictionaryEntry } from '../duc/dictionary-entry';
 import { DucBlock } from '../duc/duc-block';
+import { DucBlockCollection } from '../duc/duc-block-collection';
+import { DucBlockInstance } from '../duc/duc-block-instance';
 import { DucExternalFileEntry } from '../duc/duc-external-file-entry';
 import { DucGlobalState } from '../duc/duc-global-state';
 import { DucGroup } from '../duc/duc-group';
@@ -140,8 +142,24 @@ export class ExportedDataState {
         const offset = this.bb.__offset(this.bb_pos, 36);
         return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
     }
+    blockInstances(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 38);
+        return offset ? (obj || new DucBlockInstance()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    blockInstancesLength() {
+        const offset = this.bb.__offset(this.bb_pos, 38);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    blockCollections(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 40);
+        return offset ? (obj || new DucBlockCollection()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    blockCollectionsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 40);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
     static startExportedDataState(builder) {
-        builder.startObject(17);
+        builder.startObject(19);
     }
     static addType(builder, typeOffset) {
         builder.addFieldOffset(0, typeOffset, 0);
@@ -284,6 +302,32 @@ export class ExportedDataState {
     static addId(builder, idOffset) {
         builder.addFieldOffset(16, idOffset, 0);
     }
+    static addBlockInstances(builder, blockInstancesOffset) {
+        builder.addFieldOffset(17, blockInstancesOffset, 0);
+    }
+    static createBlockInstancesVector(builder, data) {
+        builder.startVector(4, data.length, 4);
+        for (let i = data.length - 1; i >= 0; i--) {
+            builder.addOffset(data[i]);
+        }
+        return builder.endVector();
+    }
+    static startBlockInstancesVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static addBlockCollections(builder, blockCollectionsOffset) {
+        builder.addFieldOffset(18, blockCollectionsOffset, 0);
+    }
+    static createBlockCollectionsVector(builder, data) {
+        builder.startVector(4, data.length, 4);
+        for (let i = data.length - 1; i >= 0; i--) {
+            builder.addOffset(data[i]);
+        }
+        return builder.endVector();
+    }
+    static startBlockCollectionsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
     static endExportedDataState(builder) {
         const offset = builder.endObject();
         return offset;

package/dist/flatbuffers/duc.d.ts

@@ -35,8 +35,12 @@ export { DucArrowElement } from './duc/duc-arrow-element';
 export { DucBlock } from './duc/duc-block';
 export { DucBlockAttributeDefinition } from './duc/duc-block-attribute-definition';
 export { DucBlockAttributeDefinitionEntry } from './duc/duc-block-attribute-definition-entry';
+export { DucBlockCollection } from './duc/duc-block-collection';
+export { DucBlockCollectionEntry } from './duc/duc-block-collection-entry';
 export { DucBlockDuplicationArray } from './duc/duc-block-duplication-array';
+export { DucBlockInstance } from './duc/duc-block-instance';
 export { DucBlockInstanceElement } from './duc/duc-block-instance-element';
+export { DucBlockMetadata } from './duc/duc-block-metadata';
 export { DucCommonStyle } from './duc/duc-common-style';
 export { DucDimensionElement } from './duc/duc-dimension-element';
 export { DucDimensionStyle } from './duc/duc-dimension-style';

package/dist/flatbuffers/duc.js

@@ -37,8 +37,12 @@ export { DucArrowElement } from './duc/duc-arrow-element';
 export { DucBlock } from './duc/duc-block';
 export { DucBlockAttributeDefinition } from './duc/duc-block-attribute-definition';
 export { DucBlockAttributeDefinitionEntry } from './duc/duc-block-attribute-definition-entry';
+export { DucBlockCollection } from './duc/duc-block-collection';
+export { DucBlockCollectionEntry } from './duc/duc-block-collection-entry';
 export { DucBlockDuplicationArray } from './duc/duc-block-duplication-array';
+export { DucBlockInstance } from './duc/duc-block-instance';
 export { DucBlockInstanceElement } from './duc/duc-block-instance-element';
+export { DucBlockMetadata } from './duc/duc-block-metadata';
 export { DucCommonStyle } from './duc/duc-common-style';
 export { DucDimensionElement } from './duc/duc-dimension-element';
 export { DucDimensionStyle } from './duc/duc-dimension-style';

package/dist/parse.js

@@ -7,9 +7,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { DucArrowElement as DucArrowElementFb, DucBlockInstanceElement as DucBlockInstanceElementFb, DucDimensionElement as DucDimensionElementFb, DucDocElement as DucDocElementFb, DucEllipseElement as DucEllipseElementFb, DucEmbeddableElement as DucEmbeddableElementFb, DucFeatureControlFrameElement as DucFeatureControlFrameElementFb, DucFrameElement as DucFrameElementFb, DucFreeDrawElement as DucFreeDrawElementFb, DucImageElement as DucImageElementFb, DucLeaderElement as DucLeaderElementFb, DucLinearElement as DucLinearElementFb, DucMermaidElement as DucMermaidElementFb, DucParametricElement as DucParametricElementFb, DucPdfElement as DucPdfElementFb, DucPlotElement as DucPlotElementFb, DucPolygonElement as DucPolygonElementFb, DucRectangleElement as DucRectangleElementFb, DucTableElement as DucTableElementFb, DucTextDynamicDictionarySource as DucTextDynamicDictionarySourceFb, DucTextDynamicElementSource as DucTextDynamicElementSourceFb, DucTextElement as DucTextElementFb, DucViewportElement as DucViewportElementFb, DucXRayElement as DucXRayElementFb, Element as ElementUnion, ExportedDataState, LEADER_CONTENT_TYPE as LEADER_CONTENT_TYPE_ENUM, LeaderBlockContent as LeaderBlockContentFb, LeaderTextBlockContent as LeaderTextBlockContentFb, TEXT_FIELD_SOURCE_TYPE } from "./flatbuffers/duc";
+import { DucArrowElement as DucArrowElementFb, DucDimensionElement as DucDimensionElementFb, DucDocElement as DucDocElementFb, DucEllipseElement as DucEllipseElementFb, DucEmbeddableElement as DucEmbeddableElementFb, DucFeatureControlFrameElement as DucFeatureControlFrameElementFb, DucFrameElement as DucFrameElementFb, DucFreeDrawElement as DucFreeDrawElementFb, DucImageElement as DucImageElementFb, DucLeaderElement as DucLeaderElementFb, DucLinearElement as DucLinearElementFb, DucMermaidElement as DucMermaidElementFb, DucParametricElement as DucParametricElementFb, DucPdfElement as DucPdfElementFb, DucPlotElement as DucPlotElementFb, DucPolygonElement as DucPolygonElementFb, DucRectangleElement as DucRectangleElementFb, DucTableElement as DucTableElementFb, DucTextDynamicDictionarySource as DucTextDynamicDictionarySourceFb, DucTextDynamicElementSource as DucTextDynamicElementSourceFb, DucTextElement as DucTextElementFb, DucViewportElement as DucViewportElementFb, DucXRayElement as DucXRayElementFb, Element as ElementUnion, ExportedDataState, LEADER_CONTENT_TYPE as LEADER_CONTENT_TYPE_ENUM, LeaderBlockContent as LeaderBlockContentFb, LeaderTextBlockContent as LeaderTextBlockContentFb, TEXT_FIELD_SOURCE_TYPE } from "./flatbuffers/duc";
 import { restore } from "./restore";
 import * as flatbuffers from "flatbuffers";
+import { nanoid } from 'nanoid';
 // #region HELPERS & LOW-LEVEL CASTS
 // Helper functions for type casting
 const toPrecisionValue = (value) => ({
@@ -164,7 +165,7 @@ export function parseElementBase(base) {
         stroke: [],
         opacity: toPercentage(1),
     };
-    return Object.assign({ id: base.id(), x: toPrecisionValue(base.x()), y: toPrecisionValue(base.y()), width: toPrecisionValue(base.width()), height: toPrecisionValue(base.height()), angle: toRadian(base.angle()), scope: base.scope(), label: base.label(), description: base.description(), isVisible: base.isVisible(), seed: base.seed(), version: base.version(), versionNonce: base.versionNonce(), updated: Number(base.updated()), index: base.index(), isPlot: base.isPlot(), isAnnotative: base.isAnnotative(), isDeleted: base.isDeleted(), groupIds: Array.from({ length: base.groupIdsLength() }, (_, i) => base.groupIds(i)), regionIds: Array.from({ length: base.regionIdsLength() }, (_, i) => base.regionIds(i)), layerId: base.layerId(), frameId: base.frameId(), boundElements: base.boundElementsLength() > 0 ? Array.from({ length: base.boundElementsLength() }, (_, i) => ({
+    return Object.assign({ id: base.id(), x: toPrecisionValue(base.x()), y: toPrecisionValue(base.y()), width: toPrecisionValue(base.width()), height: toPrecisionValue(base.height()), angle: toRadian(base.angle()), scope: base.scope(), label: base.label(), description: base.description(), isVisible: base.isVisible(), seed: base.seed(), version: base.version(), versionNonce: base.versionNonce(), updated: Number(base.updated()), index: base.index(), isPlot: base.isPlot(), isAnnotative: base.isAnnotative(), isDeleted: base.isDeleted(), groupIds: Array.from({ length: base.groupIdsLength() }, (_, i) => base.groupIds(i)), regionIds: Array.from({ length: base.regionIdsLength() }, (_, i) => base.regionIds(i)), blockIds: Array.from({ length: base.blockIdsLength() }, (_, i) => base.blockIds(i)), instanceId: base.instanceId(), layerId: base.layerId(), frameId: base.frameId(), boundElements: base.boundElementsLength() > 0 ? Array.from({ length: base.boundElementsLength() }, (_, i) => ({
             id: base.boundElements(i).id(),
             type: base.boundElements(i).type(),
         })) : null, zIndex: base.zIndex(), link: base.link(), locked: base.locked(), customData: base.customData() ? JSON.parse(base.customData()) : undefined }, parsedStyles);
@@ -333,24 +334,72 @@ function parseFreeDrawElement(element) {
     const end = element.end();
     return Object.assign(Object.assign({ type: "freedraw" }, parseElementBase(element.base())), { points: Array.from({ length: element.pointsLength() }, (_, i) => parsePoint(element.points(i))), size: toPrecisionValue(element.size()), thinning: toPercentage(element.thinning()), smoothing: toPercentage(element.smoothing()), streamline: toPercentage(element.streamline()), easing: element.easing(), start: start ? { cap: start.cap(), taper: start.taper(), easing: start.easing() } : null, end: end ? { cap: end.cap(), taper: end.taper(), easing: end.easing() } : null, pressures: Array.from(element.pressuresArray() || []), simulatePressure: element.simulatePressure(), lastCommittedPoint: element.lastCommittedPoint() ? parsePoint(element.lastCommittedPoint()) : null, svgPath: element.svgPath() });
 }
-function parseBlockInstanceElement(element) {
-    const duplicationArray = element.duplicationArray();
+function parseBlockInstance(instance) {
+    const duplicationArray = instance.duplicationArray();
     const attributeValues = {};
-    for (let i = 0; i < element.attributeValuesLength(); i++) {
-        const entry = element.attributeValues(i);
+    for (let i = 0; i < instance.attributeValuesLength(); i++) {
+        const entry = instance.attributeValues(i);
         attributeValues[entry.key()] = entry.value();
     }
     const elementOverrides = {};
-    for (let i = 0; i < element.elementOverridesLength(); i++) {
-        const entry = element.elementOverrides(i);
+    for (let i = 0; i < instance.elementOverridesLength(); i++) {
+        const entry = instance.elementOverrides(i);
         elementOverrides[entry.key()] = entry.value();
     }
-    return Object.assign(Object.assign({ type: "blockinstance" }, parseElementBase(element.base())), { blockId: element.blockId(), attributeValues: attributeValues, elementOverrides: elementOverrides, duplicationArray: duplicationArray ? {
+    return {
+        id: instance.id(),
+        blockId: instance.blockId(),
+        version: instance.version(),
+        attributeValues: attributeValues,
+        elementOverrides: elementOverrides,
+        duplicationArray: duplicationArray ? {
             rows: duplicationArray.rows(),
             cols: duplicationArray.cols(),
             rowSpacing: toPrecisionValue(duplicationArray.rowSpacing()),
             colSpacing: toPrecisionValue(duplicationArray.colSpacing()),
-        } : null });
+        } : null,
+    };
+}
+// Helper function to parse block metadata from FlatBuffers
+function parseBlockMetadata(metadataFb) {
+    if (!metadataFb)
+        return undefined;
+    // localization is a JSON string containing the localization data
+    let localization;
+    const localizationStr = metadataFb.localization();
+    if (localizationStr) {
+        try {
+            localization = JSON.parse(localizationStr);
+        }
+        catch (e) {
+            // If parsing fails, leave localization undefined
+            console.warn('Failed to parse localization JSON:', e);
+        }
+    }
+    return {
+        source: metadataFb.source(),
+        usageCount: metadataFb.usageCount(),
+        createdAt: Number(metadataFb.createdAt()),
+        updatedAt: Number(metadataFb.updatedAt()),
+        localization,
+    };
+}
+function parseBlockCollection(collection) {
+    const children = Array.from({ length: collection.childrenLength() }, (_, i) => {
+        const child = collection.children(i);
+        return {
+            id: child.id(),
+            isCollection: child.isCollection(),
+        };
+    });
+    const metadata = parseBlockMetadata(collection.metadata());
+    return {
+        id: collection.id(),
+        label: collection.label(),
+        children,
+        metadata,
+        thumbnail: collection.thumbnailArray() || undefined,
+    };
 }
 function parseFrameElement(element) {
     return Object.assign({ type: "frame" }, parseStackElementBase(element.stackElementBase()));
@@ -687,9 +736,6 @@ export function parseElementFromBinary(wrapper) {
         case ElementUnion.DucFreeDrawElement:
             element = wrapper.element(new DucFreeDrawElementFb());
             break;
-        case ElementUnion.DucBlockInstanceElement:
-            element = wrapper.element(new DucBlockInstanceElementFb());
-            break;
         case ElementUnion.DucFrameElement:
             element = wrapper.element(new DucFrameElementFb());
             break;
@@ -749,8 +795,6 @@ export function parseElementFromBinary(wrapper) {
             return parseArrowElement(element);
         case ElementUnion.DucFreeDrawElement:
             return parseFreeDrawElement(element);
-        case ElementUnion.DucBlockInstanceElement:
-            return parseBlockInstanceElement(element);
         case ElementUnion.DucFrameElement:
             return parseFrameElement(element);
         case ElementUnion.DucPlotElement:
@@ -787,14 +831,18 @@ export function parseBlockFromBinary(block) {
             isConstant: def.isConstant(),
         };
     }
+    // Parse metadata if present
+    const metadata = parseBlockMetadata(block.metadata());
+    // Parse thumbnail if present
+    const thumbnail = block.thumbnailArray();
     return {
         id: block.id(),
         label: block.label(),
         description: block.description() || undefined,
         version: block.version(),
-        // Filter out any nulls that may arise from malformed entries
-        elements: Array.from({ length: block.elementsLength() }, (_, i) => parseElementFromBinary(block.elements(i))).filter(Boolean),
         attributeDefinitions,
+        metadata,
+        thumbnail: thumbnail || undefined,
     };
 }
 export function parseDictionaryFromBinary(data) {
@@ -1266,6 +1314,28 @@ export const parseDuc = (blob_1, ...args_1) => __awaiter(void 0, [blob_1, ...arg
             }
         }
     }
+    // Parse block instances
+    const blockInstances = [];
+    for (let i = 0; i < data.blockInstancesLength(); i++) {
+        const blockInstance = data.blockInstances(i);
+        if (blockInstance) {
+            const parsedBlockInstance = parseBlockInstance(blockInstance);
+            if (parsedBlockInstance) {
+                blockInstances.push(parsedBlockInstance);
+            }
+        }
+    }
+    // Parse block collections
+    const blockCollections = [];
+    for (let i = 0; i < data.blockCollectionsLength(); i++) {
+        const blockCollection = data.blockCollections(i);
+        if (blockCollection) {
+            const parsedBlockCollection = parseBlockCollection(blockCollection);
+            if (parsedBlockCollection) {
+                blockCollections.push(parsedBlockCollection);
+            }
+        }
+    }
     // Parse groups
     const groups = [];
     for (let i = 0; i < data.groupsLength(); i++) {
@@ -1317,21 +1387,24 @@ export const parseDuc = (blob_1, ...args_1) => __awaiter(void 0, [blob_1, ...arg
             }
         }
     }
-    const sanitized = restore({
+    const exportData = {
         thumbnail,
         dictionary,
         elements: elements,
         localState: parsedLocalState,
         globalState: parsedGlobalState,
         blocks,
+        blockInstances,
+        blockCollections,
         groups,
         regions,
         layers,
         standards,
         files: parsedFiles,
         versionGraph: versionGraph !== null && versionGraph !== void 0 ? versionGraph : undefined,
-        id: (_a = data.id()) !== null && _a !== void 0 ? _a : undefined,
-    }, {
+        id: (_a = data.id()) !== null && _a !== void 0 ? _a : nanoid(),
+    };
+    const sanitized = restore(exportData, {
         syncInvalidIndices: (elements) => elements,
         repairBindings: true,
         refreshDimensions: false,
@@ -1344,9 +1417,11 @@ export const parseDuc = (blob_1, ...args_1) => __awaiter(void 0, [blob_1, ...arg
         globalState: sanitized.globalState,
         files: sanitized.files,
         blocks: sanitized.blocks,
+        blockInstances: sanitized.blockInstances,
         groups: sanitized.groups,
         regions: sanitized.regions,
         layers: sanitized.layers,
+        blockCollections: sanitized.blockCollections,
         standards: sanitized.standards,
         versionGraph: sanitized.versionGraph,
         id: sanitized.id,

package/dist/restore/restoreDataState.d.ts

@@ -2,7 +2,7 @@ import { BLENDING } from "../flatbuffers/duc";
 import { Standard } from "../technical/standards";
 import type { Dictionary, DucExternalFiles, DucGlobalState, ImportedDataState, LibraryItems, PrecisionValue, Scope, VersionGraph } from "../types";
 import { DucLocalState } from "../types";
-import type { _DucStackBase, BezierMirroring, DucBlock, DucElement, DucGroup, DucHead, DucLayer, DucRegion, ElementBackground, ElementContentBase, ElementStroke, ExternalFileId, FillStyle, ImageStatus, LineHead, OrderedDucElement, StrokeCap, StrokeJoin, StrokePreference, StrokeSidePreference, StrokeStyle, TextAlign, VerticalAlign } from "../types/elements";
+import type { _DucStackBase, BezierMirroring, DucBlock, DucBlockCollection, DucBlockInstance, DucElement, DucGroup, DucHead, DucLayer, DucRegion, ElementBackground, ElementContentBase, ElementStroke, ExternalFileId, FillStyle, ImageStatus, LineHead, OrderedDucElement, StrokeCap, StrokeJoin, StrokePreference, StrokeSidePreference, StrokeStyle, TextAlign, VerticalAlign } from "../types/elements";
 import { Percentage, Radian } from "../types/geometryTypes";
 import { ValueOf } from "../types/utility-types";
 import { VERSIONS } from "../utils/constants";
@@ -15,6 +15,8 @@ export type RestoredDataState = {
     globalState: DucGlobalState;
     files: DucExternalFiles;
     blocks: DucBlock[];
+    blockInstances: DucBlockInstance[];
+    blockCollections: DucBlockCollection[];
     groups: DucGroup[];
     regions: DucRegion[];
     layers: DucLayer[];
@@ -87,6 +89,20 @@ export declare const restoreRegions: (regions: unknown) => RestoredDataState["re
  * providing the complete block list from Pass 1 as the necessary context.
  */
 export declare const restoreBlocks: (blocks: unknown, currentScope: Scope, elementsConfig: ElementsConfig) => RestoredDataState["blocks"];
+/**
+ * Restores the blockCollections array.
+ */
+export declare const restoreBlockCollections: (collections: unknown) => RestoredDataState["blockCollections"];
+/**
+ * Restores the blockInstances array from imported data, ensuring each item
+ * conforms to the DucBlockInstance type.
+ */
+export declare const restoreBlockInstances: (blockInstances: unknown) => RestoredDataState["blockInstances"];
+/**
+ * Restores instances from block instances data (alias for restoreBlockInstances)
+ * This method provides a consistent naming convention for instance restoration.
+ */
+export declare const restoreInstances: (instances: unknown) => RestoredDataState["blockInstances"];
 /**
  * Restores the global state of the document from imported data.
  * It validates and provides defaults for missing or invalid properties.
@@ -163,6 +179,12 @@ export declare const isValidColor: (value: any, defaultValue?: string) => string
  * Returns the string if valid, otherwise returns the provided defaultValue or an empty string.
  */
 export declare const isValidString: (value: any, defaultValue?: string) => string;
+/**
+ * Validates a number value.
+ * Returns the number if valid, otherwise returns the provided defaultValue or 0.
+ * Optionally parses numeric strings.
+ */
+export declare const isValidNumber: (value: any, defaultValue?: number, parseStrings?: boolean) => number;
 export declare const isValidExternalFileId: (value: any, defaultValue?: ExternalFileId) => ExternalFileId;
 /**
  * Validates a value to ensure it is or can be converted to a non-empty Uint8Array.