@luminocity/lemonate-engine 26.6.4 → 26.6.5

package/dist/Engine.d.ts

@@ -108,6 +108,7 @@ export declare class Engine {
     activeSceneGraphCollection: SceneGraphCollection;
     private _reactiveCallback?;
     private _externalEmitFunc?;
+    private _loadBaselineEstablished;
     private readonly _onItemRepoListEntryAdded;
     private readonly _onItemRepoListEntryDeleted;
     private readonly _onItemRepoFieldChanged;
@@ -150,6 +151,7 @@ export declare class Engine {
     setReactiveCallback(callback: Function): void;
     _makeReactive(obj: any): any;
     saveChanges(): Promise<void>;
+    _establishLoadBaseline(): void;
     getInfo(): {
         capabilities: import("three").WebGLCapabilities;
         extensions: import("three").WebGLExtensions;

package/dist/lemonate.es.js

@@ -11447,7 +11447,7 @@ class Item extends EventEmitter {
     }
 }
 
-var engine$1 = "26.6.4";
+var engine$1 = "26.6.5";
 var bullet = "3.26";
 var lua = "5.4.3";
 var packageVersionInfo = {
@@ -92435,21 +92435,24 @@ class ProjectItem extends Item {
         this._loadingManagerProgress(LoadingState.DONE);
     }
     updateLayerNames() {
-        const layers = this.getFieldValue("LayerNames");
-        if (layers.length > MaxLayerCount) {
-            layers.splice(MaxLayerCount - 1);
+        let layers = this.getFieldValue("LayerNames");
+        if (!Array.isArray(layers)) {
+            layers = [];
         }
-        if (layers.length < MaxLayerCount) {
-            while (layers.length < MaxLayerCount) {
-                layers.push("");
-            }
-            this.setFieldValue("LayerNames", layers);
+        const normalized = layers.slice(0, MaxLayerCount);
+        while (normalized.length < MaxLayerCount) {
+            normalized.push("");
+        }
+        const changed = normalized.length !== layers.length
+            || normalized.some((value, index) => value !== layers[index]);
+        if (changed) {
+            this.setFieldValue("LayerNames", normalized);
         }
         try {
-            this.engine.renderer.setLayers(layers);
+            this.engine.renderer.setLayers(normalized);
         }
         catch (err) {
-            console.log(layers);
+            console.log(normalized);
             console.error(err);
         }
     }
@@ -117979,6 +117982,7 @@ class Engine {
     // reactive for use in a UI. typically you would pass vue.js's reactive function to it.
     _reactiveCallback;
     _externalEmitFunc;
+    _loadBaselineEstablished = false;
     _onItemRepoListEntryAdded;
     _onItemRepoListEntryDeleted;
     _onItemRepoFieldChanged;
@@ -118164,6 +118168,7 @@ class Engine {
             }
         };
         this._onReadyForUse = () => {
+            this._establishLoadBaseline();
             // we only want the auto updates during initial loading, later it can be switched off
             //this.autoUpdateCameraOnContentUpdate = false;
         };
@@ -118270,6 +118275,15 @@ class Engine {
             console.error(err);
         }
     }
+    _establishLoadBaseline() {
+        if (this._loadBaselineEstablished)
+            return;
+        this._loadBaselineEstablished = true;
+        Proxifier.instance.suppressDirtyFlag(false);
+        this.undoManager.setEnabled(true);
+        this.itemRepo.clearDirtyFlags();
+        this.undoManager.clear();
+    }
     getInfo() {
         if (this.renderer) {
             return this.renderer.getInfo();
@@ -118447,6 +118461,9 @@ class Engine {
                     this.apiClient.itemRepo.revokePackageItemUrl(url);
             };
             phase = "Importing";
+            this._loadBaselineEstablished = false;
+            Proxifier.instance.suppressDirtyFlag(true);
+            this.undoManager.setEnabled(false);
             switch (itemType) {
                 case "Project": {
                     let waitMode = options.waitMode;
@@ -118582,6 +118599,13 @@ class Engine {
             }
             this.centerStandardView();
         }
+        catch (err) {
+            if (!this._loadBaselineEstablished) {
+                Proxifier.instance.suppressDirtyFlag(false);
+                this.undoManager.setEnabled(true);
+            }
+            throw err;
+        }
         finally {
             if (loadingInterval) {
                 clearInterval(loadingInterval);