@hkdigital/lib-core 0.4.77 → 0.4.78

package/dist/network/loaders/base/SceneBase.svelte.js

@@ -380,31 +380,43 @@ export default class SceneBase {
       return;
     }
 
-    // Start all loaders
+    let completedCount = 0;
+    const totalLoaders = this.sources.length;
+
+    // Start all loaders with completion callbacks
     for (let i = 0; i < this.sources.length; i++) {
       const source = this.sources[i];
       const loader = this.getLoaderFromSource(source);
-      loader.load();
-    }
 
-    // Check if all loaders have already completed synchronously (e.g., from cache)
-    setTimeout(() => {
-      if (this.#state.current === STATE_LOADING) {
-        let allLoaded = true;
-        for (const source of this.sources) {
-          const loader = this.getLoaderFromSource(source);
-          if (loader.state !== STATE_LOADED) {
-            allLoaded = false;
-            break;
-          }
+      loader.load((completedLoader, finalState) => {
+        console.debug(`SceneBase:loader-finished [${completedLoader._url}] ${finalState}`);
+
+        // Check for errors
+        if (finalState === STATE_ERROR) {
+          this.#state.send(ERROR, completedLoader.error || new Error('Loader failed'));
+          return;
         }
 
-        if (allLoaded) {
-          console.debug('SceneBase:all-loaders-already-loaded, sending LOADED');
-          this.#state.send(LOADED);
+        // Check for abort - don't count aborted loaders as completed
+        if (finalState === STATE_ABORTED) {
+          // Aborted loaders are handled by SceneBase's own abort logic
+          console.debug(`SceneBase:loader-aborted [${completedLoader._url}] - not counting toward completion`);
+          return;
         }
-      }
-    }, 0);
+
+        // Only count successfully loaded loaders
+        if (finalState === STATE_LOADED) {
+          completedCount++;
+          console.debug(`SceneBase:loader-completed [${completedLoader._url}] (${completedCount}/${totalLoaders})`);
+
+          // Check for completion
+          if (completedCount === totalLoaders) {
+            console.debug('SceneBase:all-loaders-completed-via-callback');
+            this.#state.send(LOADED);
+          }
+        }
+      });
+    }
   }
 
   #startAbort() {

package/dist/network/states/NetworkLoader.svelte.d.ts

@@ -35,8 +35,11 @@ export default class NetworkLoader {
     _abortLoading: null | (() => void);
     /**
      * Start loading all network data
+     *
+     * @param {null|((loader: NetworkLoader, finalState: string) => void)} [onCompletion]
+     *   Optional callback called when loader reaches a terminal state (loaded/error/aborted)
      */
-    load(): void;
+    load(onCompletion?: null | ((loader: NetworkLoader, finalState: string) => void)): void;
     /**
      * Unoad all network data
      */

package/dist/network/states/NetworkLoader.svelte.js

@@ -8,6 +8,8 @@ import {
   STATE_UNLOADING,
   STATE_LOADED,
   STATE_ABORTING,
+  STATE_ABORTED,
+  STATE_ERROR,
   LOAD,
   ERROR,
   LOADED,
@@ -89,6 +91,9 @@ export default class NetworkLoader {
   /** @type {null|(()=>void)} */
   _abortLoading = null;
 
+  /** @type {null|((loader: NetworkLoader, finalState: string) => void)} */
+  #completionCallback = null;
+
   /**
    * Construct NetworkLoader
    *
@@ -104,6 +109,17 @@ export default class NetworkLoader {
       console.debug(`loader:onenter [${this._url}] ${currentState}`);
       this.state = currentState;
 
+      // Check if we've reached a terminal state
+      const isTerminalState = currentState === STATE_LOADED || 
+                             currentState === STATE_ERROR || 
+                             currentState === STATE_ABORTED;
+
+      if (isTerminalState && this.#completionCallback) {
+        const callback = this.#completionCallback;
+        this.#completionCallback = null; // Clean up immediately
+        callback(this, currentState); // Call with loader and final state
+      }
+
       switch (currentState) {
         case STATE_LOADING:
           {
@@ -155,8 +171,12 @@ export default class NetworkLoader {
 
   /**
    * Start loading all network data
+   *
+   * @param {null|((loader: NetworkLoader, finalState: string) => void)} [onCompletion]
+   *   Optional callback called when loader reaches a terminal state (loaded/error/aborted)
    */
-  load() {
+  load(onCompletion = null) {
+    this.#completionCallback = onCompletion;
     this.#state.send(LOAD);
   }
 
@@ -327,6 +347,12 @@ export default class NetworkLoader {
       //   this._size = this._buffer.byteLength;
       // }
 
+      // Check if we've been aborted before sending LOADED
+      if (this.#state.current === STATE_ABORTING || this.#state.current === STATE_ABORTED) {
+        console.debug(`loader:already-aborted [${this._url}] - not sending LOADED`);
+        return;
+      }
+      
       console.debug(`loader:sending-LOADED [${this._url}]`);
       this.#state.send(LOADED);
     } catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@hkdigital/lib-core",
-	"version": "0.4.77",
+	"version": "0.4.78",
 	"author": {
 		"name": "HKdigital",
 		"url": "https://hkdigital.nl"