ducjs 3.0.5 → 3.1.1

package/dist/ducjs_wasm.js

@@ -279,7 +279,7 @@ export function readVersionGraph(duc_buf) {
  * @returns {number}
  */
 export function getCurrentSchemaVersion() {
-    return 3000000;
+    return 3000001;
 }
 
 /**

package/dist/lazy-files.d.ts

@@ -1,4 +1,4 @@
-import type { DucExternalFileData, DucExternalFiles } from "./types";
+import type { DucExternalFile, DucExternalFiles, ExternalFileRevision } from "./types";
 export type LazyFileMetadata = {
     id: string;
     mimeType: string;
@@ -26,17 +26,19 @@ export declare class LazyExternalFileStore {
     getMetadata(fileId: string): LazyFileMetadata | undefined;
     /** Get metadata for all files. */
     getAllMetadata(): LazyFileMetadata[];
-    /** Fetch the full file data (including blob) for a specific file. */
-    getFileData(fileId: string): DucExternalFileData | null;
-    /** Fetch file data and return a copy of the data buffer (safe for transfer). */
-    getFileDataCopy(fileId: string): DucExternalFileData | null;
+    /** Fetch the full file (including data blobs for all revisions) for a specific file. */
+    getFile(fileId: string): DucExternalFile | null;
+    /** Get the active revision data for a specific file. */
+    getFileData(fileId: string): ExternalFileRevision | null;
+    /** Fetch active revision data and return a copy of the data buffer (safe for transfer). */
+    getFileDataCopy(fileId: string): ExternalFileRevision | null;
     /** Add a file at runtime (not persisted in .duc until next serialize). */
-    addRuntimeFile(fileId: string, data: DucExternalFileData): void;
+    addRuntimeFile(fileId: string, file: DucExternalFile): void;
     /** Remove a runtime file. */
     removeRuntimeFile(fileId: string): boolean;
     /** Export all files eagerly as a DucExternalFiles record. */
     toExternalFiles(): DucExternalFiles;
-    /** Merge files from another source (only adds missing). */
+    /** Merge files from another source. Adds missing files and merges new revisions into existing ones. */
     mergeFiles(files: DucExternalFiles): void;
     /** Release the underlying buffer to free memory. */
     release(): void;

package/dist/lazy-files.js

@@ -26,11 +26,14 @@ export class LazyExternalFileStore {
     getMetadata(fileId) {
         const rt = this.runtimeFiles.get(fileId);
         if (rt) {
+            const active = rt.revisions[rt.activeRevisionId];
+            if (!active)
+                return undefined;
             return {
                 id: rt.id,
-                mimeType: rt.mimeType,
-                created: rt.created,
-                lastRetrieved: rt.lastRetrieved,
+                mimeType: active.mimeType,
+                created: active.created,
+                lastRetrieved: active.lastRetrieved,
                 version: rt.version,
             };
         }
@@ -39,24 +42,28 @@ export class LazyExternalFileStore {
     /** Get metadata for all files. */
     getAllMetadata() {
         const result = [];
-        for (const meta of this.getMetadataMap().values()) {
+        const persisted = this.getMetadataMap();
+        for (const meta of persisted.values()) {
             result.push(meta);
         }
-        for (const [id, data] of this.runtimeFiles) {
-            if (!this.getMetadataMap().has(id)) {
-                result.push({
-                    id: data.id,
-                    mimeType: data.mimeType,
-                    created: data.created,
-                    lastRetrieved: data.lastRetrieved,
-                    version: data.version,
-                });
+        for (const [id, file] of this.runtimeFiles) {
+            if (!persisted.has(id)) {
+                const active = file.revisions[file.activeRevisionId];
+                if (active) {
+                    result.push({
+                        id: file.id,
+                        mimeType: active.mimeType,
+                        created: active.created,
+                        lastRetrieved: active.lastRetrieved,
+                        version: file.version,
+                    });
+                }
             }
         }
         return result;
     }
-    /** Fetch the full file data (including blob) for a specific file. */
-    getFileData(fileId) {
+    /** Fetch the full file (including data blobs for all revisions) for a specific file. */
+    getFile(fileId) {
         const rt = this.runtimeFiles.get(fileId);
         if (rt)
             return rt;
@@ -65,15 +72,17 @@ export class LazyExternalFileStore {
         const result = wasmGetExternalFile(this.buffer, fileId);
         if (!result)
             return null;
-        // WASM returns DucExternalFileEntry { key, value: DucExternalFileData }.
-        // Unwrap to get the actual file data.
-        const entry = result;
-        if (entry.value && typeof entry.value === "object") {
-            return entry.value;
-        }
-        return entry;
+        return result;
     }
-    /** Fetch file data and return a copy of the data buffer (safe for transfer). */
+    /** Get the active revision data for a specific file. */
+    getFileData(fileId) {
+        var _a;
+        const file = this.getFile(fileId);
+        if (!file)
+            return null;
+        return (_a = file.revisions[file.activeRevisionId]) !== null && _a !== void 0 ? _a : null;
+    }
+    /** Fetch active revision data and return a copy of the data buffer (safe for transfer). */
     getFileDataCopy(fileId) {
         const data = this.getFileData(fileId);
         if (!data)
@@ -81,8 +90,8 @@ export class LazyExternalFileStore {
         return Object.assign(Object.assign({}, data), { data: new Uint8Array(data.data) });
     }
     /** Add a file at runtime (not persisted in .duc until next serialize). */
-    addRuntimeFile(fileId, data) {
-        this.runtimeFiles.set(fileId, data);
+    addRuntimeFile(fileId, file) {
+        this.runtimeFiles.set(fileId, file);
     }
     /** Remove a runtime file. */
     removeRuntimeFile(fileId) {
@@ -92,24 +101,42 @@ export class LazyExternalFileStore {
     toExternalFiles() {
         const result = {};
         if (this.buffer) {
-            const metas = this.getMetadataMap();
-            for (const [id] of metas) {
-                const data = this.getFileData(id);
-                if (data) {
-                    result[id] = data;
+            for (const [id] of this.getMetadataMap()) {
+                const file = this.getFile(id);
+                if (file) {
+                    result[id] = file;
                 }
             }
         }
-        for (const [id, data] of this.runtimeFiles) {
-            result[id] = data;
+        for (const [id, file] of this.runtimeFiles) {
+            result[id] = file;
         }
         return result;
     }
-    /** Merge files from another source (only adds missing). */
+    /** Merge files from another source. Adds missing files and merges new revisions into existing ones. */
     mergeFiles(files) {
-        for (const [id, data] of Object.entries(files)) {
+        var _a, _b, _c;
+        for (const [id, file] of Object.entries(files)) {
             if (!this.has(id)) {
-                this.runtimeFiles.set(id, data);
+                this.runtimeFiles.set(id, file);
+                continue;
+            }
+            const existing = (_a = this.runtimeFiles.get(id)) !== null && _a !== void 0 ? _a : this.getFile(id);
+            if (!existing) {
+                this.runtimeFiles.set(id, file);
+                continue;
+            }
+            // Merge: add any new revisions that don't exist yet, and update metadata
+            let merged = false;
+            const mergedRevisions = Object.assign({}, existing.revisions);
+            for (const [revId, rev] of Object.entries(file.revisions)) {
+                if (!mergedRevisions[revId]) {
+                    mergedRevisions[revId] = rev;
+                    merged = true;
+                }
+            }
+            if (merged || file.updated > existing.updated) {
+                this.runtimeFiles.set(id, Object.assign(Object.assign({}, existing), { activeRevisionId: file.activeRevisionId, updated: Math.max(file.updated, existing.updated), version: Math.max((_b = file.version) !== null && _b !== void 0 ? _b : 0, (_c = existing.version) !== null && _c !== void 0 ? _c : 0), revisions: mergedRevisions }));
             }
         }
     }

package/dist/restore/restoreDataState.js

@@ -41,46 +41,94 @@ export const restore = (data, elementsConfig, restoreConfig = {}) => {
     };
 };
 export const restoreFiles = (importedFiles) => {
-    var _a;
+    var _a, _b;
     if (!importedFiles || typeof importedFiles !== "object") {
         return {};
     }
     const restoredFiles = {};
     const files = importedFiles;
     for (const key in files) {
-        if (Object.prototype.hasOwnProperty.call(files, key)) {
-            let fileData = files[key];
-            if (!fileData || typeof fileData !== "object") {
+        if (!Object.prototype.hasOwnProperty.call(files, key))
+            continue;
+        const fileData = files[key];
+        if (!fileData || typeof fileData !== "object")
+            continue;
+        const fd = fileData;
+        // New format: DucExternalFile with revisions map
+        if (fd.revisions && typeof fd.revisions === "object" && fd.activeRevisionId) {
+            const id = isValidExternalFileId(fd.id);
+            if (!id)
                 continue;
-            }
-            // Handle the nested DucExternalFileEntry structure { key, value: { ... } }
-            // produced by Rust serde or legacy exports.
-            if (fileData.value && typeof fileData.value === "object") {
-                fileData = fileData.value;
-            }
-            const id = isValidExternalFileId(fileData.id);
-            const mimeType = isValidString(fileData.mimeType);
-            const created = isFiniteNumber(fileData.created)
-                ? fileData.created
-                : Date.now();
-            // Check for data under 'data' or 'dataURL' to be more flexible.
-            const dataSource = (_a = fileData.data) !== null && _a !== void 0 ? _a : fileData.dataURL;
-            const data = isValidUint8Array(dataSource);
-            if (id && mimeType && data) {
-                restoredFiles[id] = {
-                    id,
+            const restoredRevisions = {};
+            const rawRevisions = fd.revisions;
+            for (const revKey in rawRevisions) {
+                if (!Object.prototype.hasOwnProperty.call(rawRevisions, revKey))
+                    continue;
+                const rev = rawRevisions[revKey];
+                if (!rev || typeof rev !== "object")
+                    continue;
+                const r = rev;
+                const revId = isValidString(r.id);
+                const mimeType = isValidString(r.mimeType);
+                const dataSource = (_a = r.data) !== null && _a !== void 0 ? _a : r.dataURL;
+                const data = isValidUint8Array(dataSource);
+                if (!revId || !mimeType || !data)
+                    continue;
+                restoredRevisions[revKey] = {
+                    id: revId,
+                    sizeBytes: isFiniteNumber(r.sizeBytes) ? r.sizeBytes : data.byteLength,
+                    checksum: isValidString(r.checksum) || undefined,
+                    sourceName: isValidString(r.sourceName) || undefined,
                     mimeType,
+                    message: isValidString(r.message) || undefined,
+                    created: isFiniteNumber(r.created) ? r.created : Date.now(),
+                    lastRetrieved: isFiniteNumber(r.lastRetrieved) ? r.lastRetrieved : undefined,
                     data,
-                    created,
-                    lastRetrieved: isFiniteNumber(fileData.lastRetrieved)
-                        ? fileData.lastRetrieved
-                        : undefined,
-                    version: isFiniteNumber(fileData.version)
-                        ? fileData.version
-                        : undefined,
                 };
             }
+            if (Object.keys(restoredRevisions).length === 0)
+                continue;
+            restoredFiles[id] = {
+                id,
+                activeRevisionId: isValidString(fd.activeRevisionId) || Object.keys(restoredRevisions)[0],
+                updated: isFiniteNumber(fd.updated) ? fd.updated : Date.now(),
+                revisions: restoredRevisions,
+                version: isFiniteNumber(fd.version) ? fd.version : undefined,
+            };
+            continue;
         }
+        // Legacy flat format: DucExternalFileData — wrap in a single-revision DucExternalFile.
+        let legacyData = fd;
+        // Handle the nested { key, value: { ... } } structure from old Rust serde output.
+        if (fd.value && typeof fd.value === "object") {
+            legacyData = fd.value;
+        }
+        const id = isValidExternalFileId(legacyData.id);
+        const mimeType = isValidString(legacyData.mimeType);
+        const dataSource = (_b = legacyData.data) !== null && _b !== void 0 ? _b : legacyData.dataURL;
+        const data = isValidUint8Array(dataSource);
+        if (!id || !mimeType || !data)
+            continue;
+        const revId = `${id}_rev1`;
+        const created = isFiniteNumber(legacyData.created) ? legacyData.created : Date.now();
+        restoredFiles[id] = {
+            id,
+            activeRevisionId: revId,
+            updated: created,
+            version: isFiniteNumber(legacyData.version) ? legacyData.version : undefined,
+            revisions: {
+                [revId]: {
+                    id: revId,
+                    sizeBytes: data.byteLength,
+                    mimeType,
+                    created,
+                    lastRetrieved: isFiniteNumber(legacyData.lastRetrieved)
+                        ? legacyData.lastRetrieved
+                        : undefined,
+                    data,
+                },
+            },
+        };
     }
     return restoredFiles;
 };

package/dist/types/index.d.ts

@@ -79,30 +79,36 @@ export type DucUcs = {
     angle: Radian;
 };
 export type Scope = SupportedMeasures;
-export type DucExternalFileData = {
+export type ExternalFileRevision = {
+    id: string;
+    sizeBytes: number;
+    /** Content hash for integrity checks and optional deduplication. */
+    checksum?: string;
+    /** Original upload filename shown to the user. */
+    sourceName?: string;
     mimeType: string;
-    id: ExternalFileId;
-    data: Uint8Array;
-    /**
-     * Epoch timestamp in milliseconds
-     */
+    /** Optional note describing what changed in this revision. */
+    message?: string;
+    /** Epoch timestamp in milliseconds when this revision was created. */
     created: number;
     /**
-     * Indicates when the file was last retrieved from storage to be loaded
-     * onto the scene. We use this flag to determine whether to delete unused
-     * files from storage.
-     *
-     * Epoch timestamp in milliseconds.
+     * Epoch timestamp in milliseconds when this revision was last loaded onto
+     * the scene. Used to determine whether to delete unused files from storage.
      */
     lastRetrieved?: number;
-    /**
-     * indicates the version of the file. This can be used to determine whether
-     * the file data has changed e.g. as part of restore due to schema update.
-     */
+    /** The actual file content bytes. */
+    data: Uint8Array;
+};
+export type DucExternalFile = {
+    id: ExternalFileId;
+    activeRevisionId: string;
+    /** Epoch ms when the logical file was last mutated (revision added or active changed). */
+    updated: number;
+    /** All revisions of this file, keyed by their id. */
+    revisions: Record<string, ExternalFileRevision>;
     version?: number;
 };
-export type DucExternalFileMetadata = Omit<DucExternalFileData, "data">;
-export type DucExternalFiles = Record<DucElement["id"], DucExternalFileData>;
+export type DucExternalFiles = Record<ExternalFileId, DucExternalFile>;
 export type SuggestedBinding = NonDeleted<DucBindableElement> | SuggestedPointBinding;
 export type SuggestedPointBinding = [
     NonDeleted<DucLinearElement>,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ducjs",
-  "version": "3.0.5",
+  "version": "3.1.1",
   "description": "The duc 2D CAD file format is a cornerstone of our advanced design system, conceived to cater to professionals seeking precision and efficiency in their design work.",
   "type": "module",
   "main": "dist/index.js",