@hkdigital/lib-core 0.4.46 → 0.4.48

package/dist/logging/README.md

@@ -12,13 +12,14 @@ pnpm add -D pino-pretty
 
 ```javascript
 import { createServerLogger,
-         createClientLogger } from '@hkdigital/lib-core/logging/index.js';
+         createClientLogger,
+         DEBUG } from '@hkdigital/lib-core/logging/index.js';
 
 // Server-side logging (uses pino)
-const serverLogger = createServerLogger('app');
+const serverLogger = createServerLogger('app', DEBUG);
 
 // Client-side logging (uses console)
-const clientLogger = createClientLogger('app'); 
+const clientLogger = createClientLogger('app', DEBUG); 
 
 // Log at different levels
 serverLogger.debug('Debug info', { data: 'details' });
@@ -32,13 +33,13 @@ serverLogger.error('Error message', { error: new Error('Something went wrong') }
 ### Server-side logging (src/hooks.server.js)
 
 ```javascript
-import { createServerLogger } from '@hkdigital/lib-core/logging/index.js';
+import { createServerLogger, DEBUG } from '@hkdigital/lib-core/logging/index.js';
 
 let logger;
 
 // Initialize server logging and services
 export async function init() {
-  logger = createServerLogger('server');
+  logger = createServerLogger('server', DEBUG);
   
   try {
     logger.info('Initializing server');

package/dist/network/loaders/base/SceneBase.svelte.d.ts

@@ -4,7 +4,10 @@
  */
 export default class SceneBase {
     state: string;
+    initial: boolean;
     loaded: boolean;
+    /** @type {SceneLoadingProgress} */
+    progress: SceneLoadingProgress;
     /**
      * Get the array of sources managed by this scene
      *
@@ -19,17 +22,6 @@ export default class SceneBase {
      * @returns {import('../../states/index.js').NetworkLoader} loader
      */
     getLoaderFromSource(source: object): import("../../states/index.js").NetworkLoader;
-    /**
-     * Get scene loading progress
-     */
-    get progress(): import("./typedef.js").SceneLoadingProgress;
-    /**
-     * Get scene abort progress
-     */
-    get abortProgress(): {
-        sourcesAborted: number;
-        numberOfSources: number;
-    };
     /**
      * Start loading all sources
      */

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

@@ -27,12 +27,22 @@ export default class SceneBase {
   // @note this exported state is set by onenter
   state = $state(STATE_INITIAL);
 
+  initial = $derived.by(() => {
+    return this.state === STATE_INITIAL;
+  });
+
   loaded = $derived.by(() => {
     return this.state === STATE_LOADED;
   });
 
+  // aborted = $derived.by(() => {
+  //   return this.state === STATE_ABORTED;
+  // });
+
+
+
   /** @type {SceneLoadingProgress} */
-  #progress = $derived.by(() => {
+  progress = $derived.by(() => {
     let totalSize = 0;
     let totalBytesLoaded = 0;
     let sourcesLoaded = 0;
@@ -62,36 +72,24 @@ export default class SceneBase {
     };
   });
 
-  #abortProgress = $derived.by(() => {
-    let sourcesAborted = 0;
-    const sources = this.sources;
-    const numberOfSources = sources.length;
-
-    for (let j = 0; j < numberOfSources; j++) {
-      const source = sources[j];
-      const loader = this.getLoaderFromSource(source);
-      const loaderState = loader.state;
-
-      if (loaderState === STATE_ABORTED || loaderState === STATE_ERROR) {
-        sourcesAborted++;
-      }
-    }
-
-    return {
-      sourcesAborted,
-      numberOfSources
-    };
-  });
 
   /**
    * Construct SceneBase
    */
   constructor() {
-    const state = this.#state;
+    this.#state.onenter = (currentState) => {
+      if (currentState === STATE_LOADING) {
+        this.#startLoading();
+      } else if (currentState === STATE_ABORTING) {
+        this.#startAbort();
+      }
+
+      this.state = currentState;
+    };
 
     $effect(() => {
-      if (this.#state.current === STATE_LOADING) {
-        const { sourcesLoaded, numberOfSources } = this.#progress;
+      if (this.state === STATE_LOADING) {
+        const { sourcesLoaded, numberOfSources } = this.progress;
 
         if (sourcesLoaded === numberOfSources && numberOfSources > 0) {
           this.#state.send(LOADED);
@@ -99,20 +97,13 @@ export default class SceneBase {
       }
     });
 
-    $effect(() => {
-      if (this.#state.current === STATE_ABORTING) {
-        const { sourcesAborted, numberOfSources } = this.#abortProgress;
-
-        if (sourcesAborted === numberOfSources && numberOfSources > 0) {
-          this.#state.send(ABORTED);
-        }
-      }
-    });
 
     $effect(() => {
-      if (this.#state.current === STATE_LOADING) {
+      if (this.state === STATE_LOADING) {
+
         // Check if any source failed during loading
         const sources = this.sources;
+
         for (const source of sources) {
           const loader = this.getLoaderFromSource(source);
           if (loader.state === STATE_ERROR) {
@@ -121,18 +112,9 @@ export default class SceneBase {
           }
         }
       }
-    });
 
-    state.onenter = (currentState) => {
-      if (currentState === STATE_LOADING) {
-        this.#startLoading();
-      } else if (currentState === STATE_ABORTING) {
-        this.#startAbort();
-      }
-
-      this.state = currentState;
-    };
-  }
+    });
+  } // end constructor
 
   /* ==== Abstract methods - must be implemented by subclasses */
 
@@ -159,20 +141,6 @@ export default class SceneBase {
 
   /* ==== Common loader interface */
 
-  /**
-   * Get scene loading progress
-   */
-  get progress() {
-    return this.#progress;
-  }
-
-  /**
-   * Get scene abort progress
-   */
-  get abortProgress() {
-    return this.#abortProgress;
-  }
-
   /**
    * Start loading all sources
    */
@@ -289,8 +257,10 @@ export default class SceneBase {
   /* ==== Internal methods */
 
   #startLoading() {
-    for (const source of this.sources) {
+    for (let i = 0; i < this.sources.length; i++) {
+      const source = this.sources[i];
       const loader = this.getLoaderFromSource(source);
+
       loader.load();
     }
   }
@@ -300,5 +270,13 @@ export default class SceneBase {
       const loader = this.getLoaderFromSource(source);
       loader.abort();
     }
+    
+    // Defer ABORTED transition to avoid re-entrant state machine calls
+    setTimeout(() => {
+      // Only transition to ABORTED if still in ABORTING state
+      if (this.#state.current === STATE_ABORTING) {
+        this.#state.send(ABORTED);
+      }
+    }, 0);
   }
 }

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

@@ -13,8 +13,7 @@ export default class NetworkLoader {
     constructor({ url }: {
         url: string;
     });
-    _state: LoadingStateMachine;
-    state: any;
+    state: string;
     initial: boolean;
     loaded: boolean;
     /** @type {string|null} */
@@ -94,4 +93,3 @@ export default class NetworkLoader {
     getObjectURL(): string;
     #private;
 }
-import { LoadingStateMachine } from '../../state/machines.js';

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

@@ -29,21 +29,34 @@ import { ERROR_NOT_LOADED, ERROR_TRANSFERRED } from './constants.js';
  * - Loaded data can be transferred to an AudioBufferSourceNode
  */
 export default class NetworkLoader {
-  // _state = $state(new LoadingStateMachine());
-  _state = new LoadingStateMachine();
+  #state = $state(new LoadingStateMachine());
 
-  state = $derived.by(() => {
-    return this._state.current;
-  });
+  // state = $derived.by(() => {
+  //   return this.#state.current;
+  // });
+
+  // initial = $derived.by(() => {
+  //   return this.#state.current === STATE_INITIAL;
+  // });
+
+  // loaded = $derived.by(() => {
+  //   return this.#state.current === STATE_LOADED;
+  // });
+
+  state = $state(STATE_INITIAL);
 
   initial = $derived.by(() => {
-    return this._state.current === STATE_INITIAL;
+    return this.state === STATE_INITIAL;
   });
 
   loaded = $derived.by(() => {
-    return this._state.current === STATE_LOADED;
+    return this.state === STATE_LOADED;
   });
 
+  // aborted = $derived.by(() => {
+  //   return this.state === STATE_ABORTED;
+  // });
+
   /** @type {string|null} */
   _url = null;
 
@@ -87,37 +100,24 @@ export default class NetworkLoader {
 
     this._url = url;
 
-    const state = this._state;
-    // const progress = this.progress;
+    this.#state.onenter = (currentState) => {
+      this.state = currentState;
 
-    this._state.onenter = () => {
-      switch (state.current) {
+      switch (currentState) {
         case STATE_LOADING:
           {
-            // console.log('**** NetworkLoader:loading');
             this.#load();
           }
           break;
 
         case STATE_UNLOADING:
           {
-            // console.log('NetworkLoader:unloading');
             this.#unload();
           }
           break;
 
         case STATE_LOADED:
           {
-            // console.debug('NetworkLoader:loaded', $state.snapshot(state));
-
-            // setTimeout(() => {
-            //   console.debug(
-            //     'NetworkLoader:loaded',
-            //     $state.snapshot(state),
-            //     progress
-            //   );
-            // }, 500);
-
             // Abort function is no longer needed
             this._abortLoading = null;
           }
@@ -125,13 +125,21 @@ export default class NetworkLoader {
 
         case STATE_ABORTING:
           {
-            // console.log('NetworkLoader:aborting');
             if (this._abortLoading) {
               this._abortLoading();
               this._abortLoading = null;
             }
-            // Transition to aborted state after abort completes
-            this._state.send(ABORTED);
+
+            //
+            // _abortLoading has been called (is set)
+            // => Transition to state ABORTED (deferred to avoid re-entrant call)
+            //
+            setTimeout(() => {
+              // Only transition to ABORTED if still in ABORTING state
+              if (this.#state.current === STATE_ABORTING) {
+                this.#state.send(ABORTED);
+              }
+            }, 0);
           }
           break;
 
@@ -148,15 +156,14 @@ export default class NetworkLoader {
    * Start loading all network data
    */
   load() {
-    // console.debug('NetworkLoader: load() called');
-    this._state.send(LOAD);
+    this.#state.send(LOAD);
   }
 
   /**
    * Unoad all network data
    */
   unload() {
-    this._state.send(UNLOAD);
+    this.#state.send(UNLOAD);
   }
 
   /**
@@ -165,7 +172,7 @@ export default class NetworkLoader {
    * - Aborts network requests and transitions to STATE_ABORTING
    */
   abort() {
-    this._state.send(ABORT);
+    this.#state.send(ABORT);
   }
 
   /**
@@ -273,10 +280,7 @@ export default class NetworkLoader {
    */
   async #load() {
     try {
-      // console.log('>>>> NetworkLoader:#load', this._url);
-
       if (this._abortLoading) {
-        // console.log('Abort loading');
         this._abortLoading();
         this._abortLoading = null;
       }
@@ -300,9 +304,6 @@ export default class NetworkLoader {
 
       this._headers = response.headers;
 
-      // console.log('headers', this._headers);
-      // console.log('response', response);
-
       const { bufferPromise, abort: abortLoadBody } = loadResponseBuffer(
         response,
         ({ bytesLoaded, size }) => {
@@ -318,11 +319,15 @@ export default class NetworkLoader {
 
       this._buffer = await bufferPromise;
 
-      // console.debug('#load', this._buffer, this._bytesLoaded);
+      // if (this._size === 0 && this._buffer) {
+      //   // Fallback: if size was unknown (0),
+      //   // => set it to actual buffer size when loaded
+      //   this._size = this._buffer.byteLength;
+      // }
 
-      this._state.send(LOADED);
+      this.#state.send(LOADED);
     } catch (e) {
-      this._state.send(ERROR, e);
+      this.#state.send(ERROR, e);
     }
   }
 
@@ -342,9 +347,9 @@ export default class NetworkLoader {
       this._headers = null;
       this._buffer = null;
 
-      this._state.send(INITIAL);
+      this.#state.send(INITIAL);
     } catch (e) {
-      this._state.send(ERROR, e);
+      this.#state.send(ERROR, e);
     }
   }
 } // end class

package/dist/services/README.md

@@ -296,10 +296,10 @@ Forward all service log events to a centralised logger:
 
 ```javascript
 import { ServiceManager } from '$lib/services/index.js';
-import { createServerLogger } from '$lib/logging/index.js';
+import { createServerLogger, DEBUG } from '$lib/logging/index.js';
 
 const manager = new ServiceManager();
-const logger = createServerLogger('SystemLogger');
+const logger = createServerLogger('SystemLogger', DEBUG);
 
 // Listen to all log events and forward them to the logger
 const unsubscribe = manager.onLogEvent((logEvent) => {

package/dist/state/machines/finite-state-machine/FiniteStateMachine.svelte.js

@@ -45,6 +45,9 @@ export default class FiniteStateMachine extends EventEmitter {
   /** @type {boolean} */
   #enableConsoleWarnings = !isTestEnv;
 
+  /** @type {boolean} */
+  #isTransitioning = false;
+
   /**
    * Constructor
    *
@@ -81,21 +84,27 @@ export default class FiniteStateMachine extends EventEmitter {
     /** @type {TransitionData} */
     const transition = { from: this.#current, to: newState, event, args };
 
-    // Call onexit callback before leaving current state
-    this.onexit?.(this.#current, transition);
+    this.#isTransitioning = true;
+
+    try {
+      // Call onexit callback before leaving current state
+      this.onexit?.(this.#current, transition);
 
-    // Emit EXIT event for external listeners
-    this.emit(EXIT, { state: this.#current, transition });
+      // Emit EXIT event for external listeners
+      this.emit(EXIT, { state: this.#current, transition });
 
-    this.#executeAction('_exit', transition);
-    this.#current = newState;
-    this.#executeAction('_enter', transition);
+      this.#executeAction('_exit', transition);
+      this.#current = newState;
+      this.#executeAction('_enter', transition);
 
-    // Emit ENTER event for external listeners
-    this.emit(ENTER, { state: newState, transition });
+      // Emit ENTER event for external listeners
+      this.emit(ENTER, { state: newState, transition });
 
-    // Call onenter callback after state change
-    this.onenter?.(newState, transition);
+      // Call onenter callback after state change
+      this.onenter?.(newState, transition);
+    } finally {
+      this.#isTransitioning = false;
+    }
   }
 
   /**
@@ -147,6 +156,15 @@ export default class FiniteStateMachine extends EventEmitter {
    * @param {any[]} args
    */
   send(event, ...args) {
+    if (this.#isTransitioning) {
+      throw new Error(
+        `Cannot send event '${event}' while state machine is transitioning. ` +
+        `This indicates a re-entrant call from within onenter, onexit, or ` +
+        `lifecycle callbacks (_enter/_exit). Consider using setTimeout() to ` +
+        `defer the event or restructure to avoid nested state transitions.`
+      );
+    }
+
     const newState = this.#executeAction(event, ...args);
 
     if (newState && newState !== this.#current) {

package/dist/state/machines/loading-state-machine/LoadingStateMachine.svelte.js

@@ -61,11 +61,12 @@ export default class LoadingStateMachine extends FiniteStateMachine {
       },
       [STATE_ABORTING]: {
         [ERROR]: STATE_ERROR,
+        [LOADED]: STATE_LOADED, // A load signal might still come during ABORT
         [ABORTED]: STATE_ABORTED
       },
       [STATE_ABORTED]: {
         [LOAD]: STATE_LOADING,
-        [LOADED]: STATE_LOADED,
+        [LOADED]: STATE_LOADED, // A load signal might still come after ABORT
         [UNLOAD]: STATE_UNLOADING
       },
       [STATE_TIMEOUT]: {

package/dist/util/svelte/wait/index.js

@@ -30,7 +30,7 @@ export function waitForState(checkFn, maxWaitMs = 1000) {
       }
 
       await tick();
-      checkLoop();
+      setTimeout( checkLoop, 10 );
     }
 
     checkLoop();

package/package.json

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