@hkdigital/lib-core 0.4.62 → 0.4.63

package/dist/generic/errors/generic.d.ts

@@ -1,9 +1,3 @@
-export class TypeOrValueError extends Error {
-}
-export class InternalError extends Error {
-}
-export class InternalEventOrLogError extends Error {
-}
 export class DetailedError extends Error {
     /**
      * @param {string} [message]
@@ -16,3 +10,11 @@ export class DetailedError extends Error {
     } | null;
     cause: unknown;
 }
+export class TypeOrValueError extends Error {
+}
+export class InternalError extends Error {
+}
+export class InternalEventOrLogError extends Error {
+}
+export class TimeoutError extends DetailedError {
+}

package/dist/generic/errors/generic.js

@@ -1,9 +1,3 @@
-export class TypeOrValueError extends Error {}
-
-export class InternalError extends Error {}
-
-export class InternalEventOrLogError extends Error {}
-
 export class DetailedError extends Error
 {
   /**
@@ -28,3 +22,11 @@ export class DetailedError extends Error
     }
   }
 }
+
+export class TypeOrValueError extends Error {}
+
+export class InternalError extends Error {}
+
+export class InternalEventOrLogError extends Error {}
+
+export class TimeoutError extends DetailedError {}

package/dist/network/errors/api.d.ts

@@ -1,10 +1,9 @@
-export class ResponseError extends Error {
+export class ResponseError extends DetailedError {
 }
-export class AuthenticationError extends Error {
+export class AuthenticationError extends DetailedError {
 }
-export class BadRequestError extends Error {
+export class BadRequestError extends DetailedError {
 }
-export class AbortError extends Error {
-}
-export class TimeoutError extends Error {
+export class AbortError extends DetailedError {
 }
+import { DetailedError } from '../../generic/errors.js';

package/dist/network/errors/api.js

@@ -1,9 +1,11 @@
-export class ResponseError extends Error {}
+import { DetailedError } from '../../generic/errors.js';
 
-export class AuthenticationError extends Error {}
+export class ResponseError extends DetailedError {}
 
-export class BadRequestError extends Error {}
+export class AuthenticationError extends DetailedError {}
 
-export class AbortError extends Error {}
+export class BadRequestError extends DetailedError {}
 
-export class TimeoutError extends Error {}
+export class AbortError extends DetailedError {}
+
+// @note import TimeoutError from '../../generic/errors.js';

package/dist/network/http/http-request.js

@@ -11,7 +11,8 @@ import {
 import { APPLICATION_JSON } from '../../constants/mime/application.js';
 import { CONTENT_TYPE } from '../../constants/http/headers.js';
 
-import { AbortError, TimeoutError } from '../errors/api.js';
+import { AbortError } from '../errors/api.js';
+import { TimeoutError } from '../../generic/errors.js';
 
 import * as expect from '../../util/expect.js';
 

package/dist/network/http/json-request.js

@@ -93,9 +93,8 @@ export async function jsonGet(options) {
   } catch (e) {
     throw new ResponseError(
       `Failed to JSON decode server response from [${decodeURI(url.href)}]`,
-      {
-        cause: e
-      }
+      null,
+      e
     );
   }
 
@@ -206,9 +205,8 @@ export async function jsonPost(options) {
   } catch (e) {
     throw new ResponseError(
       `Failed to JSON decode server response from [${decodeURI(url.href)}]`,
-      {
-        cause: e
-      }
+      null,
+      e
     );
   }
 
@@ -322,9 +320,8 @@ export async function jsonPut(options) {
   } catch (e) {
     throw new ResponseError(
       `Failed to JSON decode server response from [${decodeURI(url.href)}]`,
-      {
-        cause: e
-      }
+      null,
+      e
     );
   }
 
@@ -437,9 +434,8 @@ export async function jsonPatch(options) {
   } catch (e) {
     throw new ResponseError(
       `Failed to JSON decode server response from [${decodeURI(url.href)}]`,
-      {
-        cause: e
-      }
+      null,
+      e
     );
   }
 
@@ -529,9 +525,8 @@ export async function jsonDelete(options) {
   } catch (e) {
     throw new ResponseError(
       `Failed to JSON decode server response from [${decodeURI(url.href)}]`,
-      {
-        cause: e
-      }
+      null,
+      e
     );
   }
 

package/dist/network/http/response.js

@@ -91,7 +91,8 @@ export async function expectResponseOk(response, url) {
   throw new ResponseError(
     `Server returned - ${response.status} ${response.statusText} ` +
       `[url=${href(url)}]`,
-    { cause: error }
+    null,
+    error
   );
 }
 
@@ -186,9 +187,8 @@ export async function waitForAndCheckResponse(responsePromise, url) {
     } else if (e instanceof TypeError || response?.ok === false) {
       throw new ResponseError(
         `A network error occurred for request [${href(url)}]`,
-        {
-          cause: e
-        }
+        null,
+        e
       );
     } else {
       throw e;

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

@@ -1,3 +1,5 @@
+import { DetailedError } from '../../../generic/errors.js';
+
 import { LoadingStateMachine } from '../../../state/machines.js';
 
 import {
@@ -15,6 +17,7 @@ import {
 } from '../../../state/machines.js';
 
 import { waitForState } from '../../../util/svelte.js';
+import { TimeoutError } from '../../../generic/errors.js';
 
 /** @typedef {import('./typedef.js').SceneLoadingProgress} SceneLoadingProgress */
 
@@ -39,7 +42,8 @@ export default class SceneBase {
   //   return this.state === STATE_ABORTED;
   // });
 
-
+  /** @type {((progress:SceneLoadingProgress)=>void)[]} */
+  #preloadListeners = [];
 
   /** @type {SceneLoadingProgress} */
   progress = $derived.by(() => {
@@ -85,7 +89,6 @@ export default class SceneBase {
     };
   });
 
-
   /**
    * Construct SceneBase
    */
@@ -110,25 +113,48 @@ export default class SceneBase {
       }
     });
 
-
     $effect(() => {
       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) {
-            this.#state.send(ERROR, loader.error || new Error('Source loading failed'));
+            this.#state.send(
+              ERROR,
+              loader.error || new Error('Source loading failed')
+            );
             break;
           }
         }
       }
+    });
 
+    $effect(() => {
+      this.#updatePreloadProgressListeners(this.progress);
     });
   } // end constructor
 
+  /**
+   * Call preload progress listeners
+   *
+   * @param {SceneLoadingProgress} progress
+   */
+  #updatePreloadProgressListeners(progress) {
+    for (const fn of this.#preloadListeners) {
+      try {
+        fn(progress);
+      } catch (e) {
+        throw new DetailedError(
+          'Error in progress listener',
+          null,
+          /** @type {Error} */ (e)
+        );
+      }
+    }
+  }
+
   /* ==== Abstract methods - must be implemented by subclasses */
 
   /**
@@ -181,7 +207,6 @@ export default class SceneBase {
    *   Object with promise that resolves when loaded and abort function
    */
   preload({ timeoutMs = 10000, onProgress } = {}) {
-
     /** @type {number|NodeJS.Timeout|null} */
     let timeoutId = null;
 
@@ -189,17 +214,17 @@ export default class SceneBase {
     let progressIntervalId = null;
 
     let isAborted = false;
-    
-    /** @type {SceneLoadingProgress|null} */
-    let lastSentProgress = null;
 
     const abort = () => {
       if (isAborted) return;
       isAborted = true;
 
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-        timeoutId = null;
+      // Remove progress listener
+      if (onProgress) {
+        const index = this.#preloadListeners.indexOf(onProgress);
+        if (index >= 0) {
+          this.#preloadListeners.splice(index, 1);
+        }
       }
 
       if (progressIntervalId) {
@@ -211,51 +236,64 @@ export default class SceneBase {
     };
 
     const promise = new Promise((resolve, reject) => {
-      // Set up progress tracking with polling
+      // Set up progress tracking with reactive listener
       if (onProgress) {
-        progressIntervalId = setInterval(() => {
-          if (!isAborted && this.state === STATE_LOADING) {
-            const currentProgress = this.progress;
-            lastSentProgress = currentProgress;
-            onProgress(currentProgress);
-          }
-        }, 50); // Poll every 50ms
+        this.#preloadListeners.push(onProgress);
       }
 
-      // Set up timeout
-      if (timeoutMs > 0) {
-        timeoutId = setTimeout(() => {
-          abort();
-          reject(new Error(`Preload timed out after ${timeoutMs}ms`));
-        }, timeoutMs);
-      }
+      // // Set up progress tracking with polling (fallback if reactive doesn't work)
+      // if (onProgress) {
+      //   progressIntervalId = setInterval(() => {
+      //     if (!isAborted && this.state === STATE_LOADING) {
+      //       const currentProgress = this.progress;
+      //       onProgress(currentProgress);
+      //     }
+      //   }, 50); // Poll every 50ms
+      // }
+
+      // // Set up progress tracking with polling (fallback if reactive doesn't work)
+      // if (onProgress) {
+      //   progressIntervalId = setInterval(() => {
+      //     if (!isAborted && this.state === STATE_LOADING) {
+      //       const currentProgress = this.progress;
+      //       onProgress(currentProgress);
+      //     }
+      //   }, 50); // Poll every 50ms
+      // }
 
       // Start loading
       this.load();
 
-      // Wait for completion with extended timeout
-      const waitTimeout = Math.max(timeoutMs + 1000, 2000);
+      // Wait for completion with timeout
+      // 0 means no timeout, but we still need a reasonable value for waitForState
+      const waitTimeout = timeoutMs > 0 ? timeoutMs : 120000;
+
       waitForState(() => {
-        return this.loaded ||
-               this.state === STATE_ABORTED ||
-               this.state === STATE_ERROR;
+        return (
+          this.loaded ||
+          this.state === STATE_ABORTED ||
+          this.state === STATE_ERROR
+        );
       }, waitTimeout)
         .then(() => {
-          if (timeoutId) {
-            clearTimeout(timeoutId);
-            timeoutId = null;
+          // Remove progress listener
+          if (onProgress) {
+            const index = this.#preloadListeners.indexOf(onProgress);
+            if (index >= 0) {
+              this.#preloadListeners.splice(index, 1);
+            }
+
           }
 
+          // Cleanup polling (fallback if reactive doesn't work)
           if (progressIntervalId) {
             clearInterval(progressIntervalId);
             progressIntervalId = null;
-            
-            if (onProgress) {
+
+            // Send final progress when loading completes (for polling fallback)
+            if (onProgress && this.loaded) {
               const finalProgress = this.progress;
-              // Always send final progress when loading completes
-              if (this.loaded) {
-                onProgress(finalProgress);
-              }
+              onProgress(finalProgress);
             }
           }
 
@@ -269,7 +307,34 @@ export default class SceneBase {
             reject(new Error(`Preload failed: unexpected state ${this.state}`));
           }
         })
-        .catch(reject);
+        .catch((error) => {
+          // Handle timeout errors from waitForState
+          if (error instanceof TimeoutError) {
+            abort();
+            reject(new Error(`Preload timed out after ${timeoutMs}ms`));
+          } else {
+            reject(error);
+          }
+        })
+        .finally(() => {
+          // Send final progress update regardless of success/failure
+          if (onProgress) {
+            const finalProgress = this.progress;
+            onProgress(finalProgress);
+            
+            // Remove progress listener
+            const index = this.#preloadListeners.indexOf(onProgress);
+            if (index >= 0) {
+              this.#preloadListeners.splice(index, 1);
+            }
+          }
+
+          // // Cleanup polling (fallback if reactive doesn't work)
+          // if (progressIntervalId) {
+          //   clearInterval(progressIntervalId);
+          //   progressIntervalId = null;
+          // }
+        });
     });
 
     return { promise, abort };
@@ -296,7 +361,7 @@ 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

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

@@ -1,5 +1,7 @@
 import { tick } from 'svelte';
 
+import { TimeoutError } from '../../../generic/errors.js';
+
 /**
  * Waits for a state condition to be met by running the checkFn
  * function after each Svelte tick
@@ -25,7 +27,7 @@ export function waitForState(checkFn, maxWaitMs = 1000) {
       }
 
       if (Date.now() - startedAt >= maxWaitMs) {
-        reject(new Error(`State change timeout`));
+        reject(new TimeoutError(`State change timeout`));
         return;
       }
 

package/package.json

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