@thalesrc/hermes 7.4.7 → 7.5.2

package/worker/message-client.js

@@ -1,9 +1,12 @@
 import { uniqueId } from "@thalesrc/js-utils/unique-id";
 import { noop } from "@thalesrc/js-utils/function/noop";
-import { promisify } from '@thalesrc/js-utils/promise/promisify';
 import { Subject } from "rxjs";
 import { MessageClient } from "../message-client";
 import { GET_NEW_ID, RESPONSES$, SEND } from "../selectors";
+import { initializer } from "./initializer";
+const WORKER = Symbol('Client Worker');
+const HANDLER = Symbol('Client Message Handler');
+const INSTANCE_ID = Symbol('Client Instance ID');
 /**
  * WorkerMessageClient
  *
@@ -54,12 +57,12 @@ export class WorkerMessageClient extends MessageClient {
      * Promise resolving to the Worker instance or undefined if running in worker context
      * @private
      */
-    #worker = Promise.resolve(undefined);
+    [WORKER] = Promise.resolve(undefined);
     /**
      * Unique identifier for this client instance to prevent ID collisions
      * @private
      */
-    #instanceId = Date.now();
+    [INSTANCE_ID] = '' + Math.floor(Math.random() * 10000);
     /**
      * Observable stream of message responses from the worker or main thread
      */
@@ -107,30 +110,11 @@ export class WorkerMessageClient extends MessageClient {
      * };
      */
     initialize(worker) {
-        // Deinitialize previous worker if any
-        this.#worker.then(prevWorker => {
-            if (prevWorker) {
-                prevWorker.removeEventListener('message', this.#handler);
-            }
-            else {
-                removeEventListener('message', this.#handler);
-            }
-        }).catch(noop);
-        // Resolve worker parameter: execute function if provided, otherwise use value directly
-        const _worker = typeof worker === 'function' ? worker() : worker;
-        // Ensure worker is wrapped in a promise for consistent async handling
-        this.#worker = promisify(_worker);
-        // Set up message listener once worker is resolved
-        this.#worker.then(worker => {
-            if (worker) {
-                // Main thread context: listen to specific worker
-                worker.addEventListener('message', this.#handler);
-            }
-            else {
-                // Worker thread context: listen to messages from main thread
-                addEventListener('message', this.#handler);
-            }
-        }).catch(noop);
+        // Ensure WORKER is initialized if not already
+        if (!this[WORKER]) {
+            this[WORKER] = Promise.resolve(undefined);
+        }
+        this[WORKER] = initializer(this[WORKER], worker, this[HANDLER]);
     }
     /**
      * Sends a message to the worker or main thread
@@ -140,7 +124,7 @@ export class WorkerMessageClient extends MessageClient {
      * @internal Used by @Request decorator
      */
     [SEND](message) {
-        this.#worker.then(worker => {
+        this[WORKER].then(worker => {
             if (worker) {
                 // Main thread: send to worker
                 worker.postMessage(message);
@@ -155,7 +139,7 @@ export class WorkerMessageClient extends MessageClient {
      * Handles incoming messages and forwards them to the responses stream
      * @private
      */
-    #handler = (event) => {
+    [HANDLER] = (event) => {
         this[RESPONSES$].next(event.data);
     };
     /**
@@ -165,7 +149,7 @@ export class WorkerMessageClient extends MessageClient {
      * @internal Used by @Request decorator
      */
     [GET_NEW_ID]() {
-        return uniqueId('hermes-worker-message-' + this.#instanceId);
+        return uniqueId('hermes-worker-message-' + this[INSTANCE_ID]);
     }
 }
 

package/worker/message-client.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../libs/hermes/src/worker/message-client.ts"],"names":[],"mappings":"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","file":"message-client.js","sourcesContent":["import { uniqueId } from \"@thalesrc/js-utils/unique-id\";\nimport { noop } from \"@thalesrc/js-utils/function/noop\";\nimport { promisify } from '@thalesrc/js-utils/promise/promisify';\nimport { Subject } from \"rxjs\";\nimport { MessageClient } from \"../message-client\";\nimport { MessageResponse } from \"../message-response.type\";\nimport { Message } from \"../message.interface\";\nimport { GET_NEW_ID, RESPONSES$, SEND } from \"../selectors\";\n\ntype ClientWorkerType = Worker | undefined;\ntype ClientWorkerPromise = Promise<ClientWorkerType>;\ntype ClientWorkerFactory = () => ClientWorkerType | ClientWorkerPromise;\ntype ClientWorkerArg = ClientWorkerType | ClientWorkerPromise | ClientWorkerFactory;\n\n/**\n * WorkerMessageClient\n *\n * Client implementation for Web Worker communication. Sends messages to and receives\n * responses from Web Workers using the Worker postMessage API.\n *\n * This class can be used in two contexts:\n * - **Main thread**: Provide a Worker instance to communicate with that specific worker\n * - **Worker thread**: Omit the worker parameter to communicate with the main thread via self\n *\n * The worker parameter supports multiple types for flexibility:\n * - Direct Worker instance\n * - Promise that resolves to a Worker (for async worker initialization)\n * - Function that returns a Worker (for lazy initialization)\n * - Function that returns a Promise<Worker> (for async lazy initialization)\n *\n * The `initialize()` method allows dynamic worker management, enabling you to switch\n * workers at runtime or re-establish connections after errors.\n *\n * @example\n * // In main thread - communicate with a specific worker\n * const worker = new Worker('./worker.js');\n * const client = new WorkerMessageClient(worker);\n *\n * @example\n * // In worker thread - communicate with main thread\n * const client = new WorkerMessageClient();\n *\n * @example\n * // With async worker initialization\n * const workerPromise = import('./worker.js').then(m => new m.MyWorker());\n * const client = new WorkerMessageClient(workerPromise);\n *\n * @example\n * // With lazy initialization\n * const client = new WorkerMessageClient(() =>\n *   document.querySelector('[data-worker]') ? new Worker('./worker.js') : undefined\n * );\n *\n * @example\n * // Re-initialize with a different worker\n * const client = new WorkerMessageClient();\n * // Later, switch to a different worker\n * client.initialize(new Worker('./different-worker.js'));\n */\nexport class WorkerMessageClient extends MessageClient {\n  /**\n   * Promise resolving to the Worker instance or undefined if running in worker context\n   * @private\n   */\n  #worker: ClientWorkerPromise = Promise.resolve(undefined);\n\n  /**\n   * Unique identifier for this client instance to prevent ID collisions\n   * @private\n   */\n  #instanceId = Date.now();\n\n  /**\n   * Observable stream of message responses from the worker or main thread\n   */\n  public [RESPONSES$] = new Subject<MessageResponse>();\n\n  /**\n   * Creates a new WorkerMessageClient instance\n   *\n   * @param worker - Optional worker configuration:\n   *   - Worker: Direct worker instance (main thread)\n   *   - Promise<Worker>: Promise resolving to worker (async initialization)\n   *   - () => Worker: Function returning worker (lazy initialization)\n   *   - () => Promise<Worker>: Function returning promise (async lazy initialization)\n   *   - undefined: Omit for worker thread context (uses self)\n   */\n  constructor(worker?: ClientWorkerArg) {\n    super();\n\n    this.initialize(worker);\n  }\n\n  /**\n   * Initializes or re-initializes the worker connection.\n   *\n   * This method sets up message listeners for the provided worker. If a worker\n   * was previously initialized, it cleans up the old connection before establishing\n   * the new one. This allows for dynamic worker management, such as:\n   * - Switching between different workers at runtime\n   * - Re-establishing connections after worker errors\n   * - Lazy initialization when the worker is conditionally needed\n   *\n   * @param worker - Optional worker configuration:\n   *   - Worker: Direct worker instance (main thread)\n   *   - Promise<Worker>: Promise resolving to worker (async initialization)\n   *   - () => Worker: Function returning worker (lazy initialization)\n   *   - () => Promise<Worker>: Function returning promise (async lazy initialization)\n   *   - undefined: Omit for worker thread context (uses self)\n   *\n   * @example\n   * // Switch to a different worker dynamically\n   * const client = new WorkerMessageClient(oldWorker);\n   * client.initialize(newWorker); // Cleans up old listener, sets up new one\n   *\n   * @example\n   * // Re-initialize after worker error\n   * worker.onerror = () => {\n   *   client.initialize(new Worker('./worker.js'));\n   * };\n   */\n  initialize(worker?: ClientWorkerArg) {\n    // Deinitialize previous worker if any\n    this.#worker.then(prevWorker => {\n      if (prevWorker) {\n        prevWorker.removeEventListener('message', this.#handler);\n      } else {\n        removeEventListener('message', this.#handler);\n      }\n    }).catch(noop);\n\n    // Resolve worker parameter: execute function if provided, otherwise use value directly\n    const _worker: ClientWorkerType | ClientWorkerPromise | undefined = typeof worker === 'function' ? worker() : worker;\n    // Ensure worker is wrapped in a promise for consistent async handling\n    this.#worker = promisify(_worker);\n\n    // Set up message listener once worker is resolved\n    this.#worker.then(worker => {\n      if (worker) {\n        // Main thread context: listen to specific worker\n        worker.addEventListener('message', this.#handler);\n      } else {\n        // Worker thread context: listen to messages from main thread\n        addEventListener('message', this.#handler);\n      }\n    }).catch(noop);\n  }\n\n  /**\n   * Sends a message to the worker or main thread\n   *\n   * @param message - The message to send\n   * @template T - Type of the message body\n   * @internal Used by @Request decorator\n   */\n  public [SEND]<T>(message: Message<T>) {\n    this.#worker.then(worker => {\n      if (worker) {\n        // Main thread: send to worker\n        worker.postMessage(message);\n      } else {\n        // Worker thread: send to main thread\n        (postMessage as any)(message);\n      }\n    }).catch(noop);\n  }\n\n  /**\n   * Handles incoming messages and forwards them to the responses stream\n   * @private\n   */\n  #handler = (event: MessageEvent<MessageResponse>) => {\n    this[RESPONSES$].next(event.data);\n  }\n\n  /**\n   * Generates a unique message ID for tracking request-response pairs\n   *\n   * @returns Unique message identifier\n   * @internal Used by @Request decorator\n   */\n  protected [GET_NEW_ID](): string {\n    return uniqueId('hermes-worker-message-' + this.#instanceId) as string;\n  }\n}\n"]}
+{"version":3,"sources":["../../../../../libs/hermes/src/worker/message-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AACxD,OAAO,EAAE,IAAI,EAAE,MAAM,kCAAkC,CAAC;AACxD,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAGlD,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAC5D,OAAO,EAAwC,WAAW,EAAE,MAAM,eAAe,CAAC;AAElF,MAAM,MAAM,GAAG,MAAM,CAAC,eAAe,CAAC,CAAC;AACvC,MAAM,OAAO,GAAG,MAAM,CAAC,wBAAwB,CAAC,CAAC;AACjD,MAAM,WAAW,GAAG,MAAM,CAAC,oBAAoB,CAAC,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,OAAO,mBAAoB,SAAQ,aAAa;IACpD;;;OAGG;IACK,CAAC,MAAM,CAAC,GAAwB,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IAEnE;;;OAGG;IACK,CAAC,WAAW,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,KAAK,CAAC,CAAC;IAE/D;;OAEG;IACI,CAAC,UAAU,CAAC,GAAG,IAAI,OAAO,EAAmB,CAAC;IAErD;;;;;;;;;OASG;IACH,YAAY,MAAwB;QAClC,KAAK,EAAE,CAAC;QAER,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;IAC1B,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,UAAU,CAAC,MAAwB;QACjC,8CAA8C;QAC9C,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;YAClB,IAAI,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAC5C,CAAC;QAED,IAAI,CAAC,MAAM,CAAC,GAAG,WAAW,CACxB,IAAI,CAAC,MAAM,CAAC,EACZ,MAAM,EACN,IAAI,CAAC,OAAO,CAAC,CACd,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACI,CAAC,IAAI,CAAC,CAAI,OAAmB;QAClC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE;YACzB,IAAI,MAAM,EAAE,CAAC;gBACX,8BAA8B;gBAC9B,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;YAC9B,CAAC;iBAAM,CAAC;gBACN,qCAAqC;gBACpC,WAAmB,CAAC,OAAO,CAAC,CAAC;YAChC,CAAC;QACH,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACjB,CAAC;IAED;;;OAGG;IACK,CAAC,OAAO,CAAC,GAAG,CAAC,KAAoC,EAAE,EAAE;QAC3D,IAAI,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACpC,CAAC,CAAA;IAED;;;;;OAKG;IACO,CAAC,UAAU,CAAC;QACpB,OAAO,QAAQ,CAAC,wBAAwB,GAAG,IAAI,CAAC,WAAW,CAAC,CAAW,CAAC;IAC1E,CAAC;CACF","file":"message-client.js","sourcesContent":["import { uniqueId } from \"@thalesrc/js-utils/unique-id\";\nimport { noop } from \"@thalesrc/js-utils/function/noop\";\nimport { Subject } from \"rxjs\";\nimport { MessageClient } from \"../message-client\";\nimport { MessageResponse } from \"../message-response.type\";\nimport { Message } from \"../message.interface\";\nimport { GET_NEW_ID, RESPONSES$, SEND } from \"../selectors\";\nimport { ClientWorkerArg, ClientWorkerPromise, initializer } from \"./initializer\";\n\nconst WORKER = Symbol('Client Worker');\nconst HANDLER = Symbol('Client Message Handler');\nconst INSTANCE_ID = Symbol('Client Instance ID');\n\n/**\n * WorkerMessageClient\n *\n * Client implementation for Web Worker communication. Sends messages to and receives\n * responses from Web Workers using the Worker postMessage API.\n *\n * This class can be used in two contexts:\n * - **Main thread**: Provide a Worker instance to communicate with that specific worker\n * - **Worker thread**: Omit the worker parameter to communicate with the main thread via self\n *\n * The worker parameter supports multiple types for flexibility:\n * - Direct Worker instance\n * - Promise that resolves to a Worker (for async worker initialization)\n * - Function that returns a Worker (for lazy initialization)\n * - Function that returns a Promise<Worker> (for async lazy initialization)\n *\n * The `initialize()` method allows dynamic worker management, enabling you to switch\n * workers at runtime or re-establish connections after errors.\n *\n * @example\n * // In main thread - communicate with a specific worker\n * const worker = new Worker('./worker.js');\n * const client = new WorkerMessageClient(worker);\n *\n * @example\n * // In worker thread - communicate with main thread\n * const client = new WorkerMessageClient();\n *\n * @example\n * // With async worker initialization\n * const workerPromise = import('./worker.js').then(m => new m.MyWorker());\n * const client = new WorkerMessageClient(workerPromise);\n *\n * @example\n * // With lazy initialization\n * const client = new WorkerMessageClient(() =>\n *   document.querySelector('[data-worker]') ? new Worker('./worker.js') : undefined\n * );\n *\n * @example\n * // Re-initialize with a different worker\n * const client = new WorkerMessageClient();\n * // Later, switch to a different worker\n * client.initialize(new Worker('./different-worker.js'));\n */\nexport class WorkerMessageClient extends MessageClient {\n  /**\n   * Promise resolving to the Worker instance or undefined if running in worker context\n   * @private\n   */\n  private [WORKER]: ClientWorkerPromise = Promise.resolve(undefined);\n\n  /**\n   * Unique identifier for this client instance to prevent ID collisions\n   * @private\n   */\n  private [INSTANCE_ID] = '' + Math.floor(Math.random() * 10000);\n\n  /**\n   * Observable stream of message responses from the worker or main thread\n   */\n  public [RESPONSES$] = new Subject<MessageResponse>();\n\n  /**\n   * Creates a new WorkerMessageClient instance\n   *\n   * @param worker - Optional worker configuration:\n   *   - Worker: Direct worker instance (main thread)\n   *   - Promise<Worker>: Promise resolving to worker (async initialization)\n   *   - () => Worker: Function returning worker (lazy initialization)\n   *   - () => Promise<Worker>: Function returning promise (async lazy initialization)\n   *   - undefined: Omit for worker thread context (uses self)\n   */\n  constructor(worker?: ClientWorkerArg) {\n    super();\n\n    this.initialize(worker);\n  }\n\n  /**\n   * Initializes or re-initializes the worker connection.\n   *\n   * This method sets up message listeners for the provided worker. If a worker\n   * was previously initialized, it cleans up the old connection before establishing\n   * the new one. This allows for dynamic worker management, such as:\n   * - Switching between different workers at runtime\n   * - Re-establishing connections after worker errors\n   * - Lazy initialization when the worker is conditionally needed\n   *\n   * @param worker - Optional worker configuration:\n   *   - Worker: Direct worker instance (main thread)\n   *   - Promise<Worker>: Promise resolving to worker (async initialization)\n   *   - () => Worker: Function returning worker (lazy initialization)\n   *   - () => Promise<Worker>: Function returning promise (async lazy initialization)\n   *   - undefined: Omit for worker thread context (uses self)\n   *\n   * @example\n   * // Switch to a different worker dynamically\n   * const client = new WorkerMessageClient(oldWorker);\n   * client.initialize(newWorker); // Cleans up old listener, sets up new one\n   *\n   * @example\n   * // Re-initialize after worker error\n   * worker.onerror = () => {\n   *   client.initialize(new Worker('./worker.js'));\n   * };\n   */\n  initialize(worker?: ClientWorkerArg) {\n    // Ensure WORKER is initialized if not already\n    if (!this[WORKER]) {\n      this[WORKER] = Promise.resolve(undefined);\n    }\n\n    this[WORKER] = initializer(\n      this[WORKER],\n      worker,\n      this[HANDLER]\n    );\n  }\n\n  /**\n   * Sends a message to the worker or main thread\n   *\n   * @param message - The message to send\n   * @template T - Type of the message body\n   * @internal Used by @Request decorator\n   */\n  public [SEND]<T>(message: Message<T>) {\n    this[WORKER].then(worker => {\n      if (worker) {\n        // Main thread: send to worker\n        worker.postMessage(message);\n      } else {\n        // Worker thread: send to main thread\n        (postMessage as any)(message);\n      }\n    }).catch(noop);\n  }\n\n  /**\n   * Handles incoming messages and forwards them to the responses stream\n   * @private\n   */\n  private [HANDLER] = (event: MessageEvent<MessageResponse>) => {\n    this[RESPONSES$].next(event.data);\n  }\n\n  /**\n   * Generates a unique message ID for tracking request-response pairs\n   *\n   * @returns Unique message identifier\n   * @internal Used by @Request decorator\n   */\n  protected [GET_NEW_ID](): string {\n    return uniqueId('hermes-worker-message-' + this[INSTANCE_ID]) as string;\n  }\n}\n"]}

package/worker/message-host.cjs

@@ -4,38 +4,162 @@ exports.WorkerMessageHost = void 0;
 const rxjs_1 = require("rxjs");
 const message_host_1 = require("../message-host");
 const selectors_1 = require("../selectors");
+const initializer_1 = require("./initializer");
+const noop_1 = require("@thalesrc/js-utils/function/noop");
+const WORKER = Symbol('Host Worker');
+const HANDLER = Symbol('Host Message Handler');
+const REQUESTS$ = Symbol('Host Requests Stream');
+/**
+ * WorkerMessageHost
+ *
+ * Host implementation for Web Worker communication. Receives messages from and sends
+ * responses to Web Workers using the Worker postMessage API.
+ *
+ * This class can be used in two contexts:
+ * - **Main thread**: Provide a Worker instance to receive messages from that specific worker
+ * - **Worker thread**: Omit the worker parameter to receive messages from the main thread via self
+ *
+ * The worker parameter supports multiple types for flexibility:
+ * - Direct Worker instance
+ * - Promise that resolves to a Worker (for async worker initialization)
+ * - Function that returns a Worker (for lazy initialization)
+ * - Function that returns a Promise<Worker> (for async lazy initialization)
+ *
+ * The `initialize()` method allows dynamic worker management, enabling you to switch
+ * workers at runtime or re-establish connections after errors.
+ *
+ * @example
+ * // In main thread - receive messages from a specific worker
+ * const worker = new Worker('./worker.js');
+ * const host = new WorkerMessageHost(worker);
+ *
+ * @example
+ * // In worker thread - receive messages from main thread
+ * const host = new WorkerMessageHost();
+ *
+ * @example
+ * // With async worker initialization
+ * const workerPromise = import('./worker.js').then(m => new m.MyWorker());
+ * const host = new WorkerMessageHost(workerPromise);
+ *
+ * @example
+ * // With lazy initialization
+ * const host = new WorkerMessageHost(() =>
+ *   document.querySelector('[data-worker]') ? new Worker('./worker.js') : undefined
+ * );
+ *
+ * @example
+ * // Re-initialize with a different worker
+ * const host = new WorkerMessageHost();
+ * // Later, switch to a different worker
+ * host.initialize(new Worker('./different-worker.js'));
+ */
 class WorkerMessageHost extends message_host_1.MessageHost {
-    #requests$ = new rxjs_1.Subject();
-    #worker;
+    /**
+     * Observable stream of incoming messages from the worker or main thread
+     * @private
+     */
+    [REQUESTS$] = new rxjs_1.Subject();
+    /**
+     * Promise resolving to the Worker instance or undefined if running in worker context
+     * @private
+     */
+    [WORKER] = Promise.resolve(undefined);
+    /**
+     * Creates a new WorkerMessageHost instance
+     *
+     * @param worker - Optional worker configuration:
+     *   - Worker: Direct worker instance (main thread)
+     *   - Promise<Worker>: Promise resolving to worker (async initialization)
+     *   - () => Worker: Function returning worker (lazy initialization)
+     *   - () => Promise<Worker>: Function returning promise (async lazy initialization)
+     *   - undefined: Omit for worker thread context (uses self)
+     */
     constructor(worker) {
         super();
-        if (worker) {
-            this.#worker = worker;
-            worker.addEventListener('message', this.#handler);
-        }
-        else {
-            addEventListener('message', this.#handler);
+        this.initialize(worker);
+        this[selectors_1.LISTEN](this[REQUESTS$]);
+    }
+    /**
+     * Initializes or re-initializes the worker connection.
+     *
+     * This method sets up message listeners for the provided worker. If a worker
+     * was previously initialized, it cleans up the old connection before establishing
+     * the new one. This allows for dynamic worker management, such as:
+     * - Switching between different workers at runtime
+     * - Re-establishing connections after worker errors
+     * - Lazy initialization when the worker is conditionally needed
+     *
+     * @param worker - Optional worker configuration:
+     *   - Worker: Direct worker instance (main thread)
+     *   - Promise<Worker>: Promise resolving to worker (async initialization)
+     *   - () => Worker: Function returning worker (lazy initialization)
+     *   - () => Promise<Worker>: Function returning promise (async lazy initialization)
+     *   - undefined: Omit for worker thread context (uses self)
+     *
+     * @example
+     * // Switch to a different worker dynamically
+     * const host = new WorkerMessageHost(oldWorker);
+     * host.initialize(newWorker); // Cleans up old listener, sets up new one
+     *
+     * @example
+     * // Re-initialize after worker error
+     * worker.onerror = () => {
+     *   host.initialize(new Worker('./worker.js'));
+     * };
+     */
+    initialize(worker) {
+        // Ensure WORKER is initialized if not already
+        if (!this[WORKER]) {
+            this[WORKER] = Promise.resolve(undefined);
         }
-        this[selectors_1.LISTEN](this.#requests$);
+        this[WORKER] = (0, initializer_1.initializer)(this[WORKER], worker, this[HANDLER]);
     }
+    /**
+     * Sends a response message back to the worker or main thread
+     *
+     * @param message - The response message to send
+     * @internal Used by the message handling system to send responses
+     */
     [selectors_1.RESPONSE](message) {
-        if (this.#worker) {
-            this.#worker.postMessage(message);
-        }
-        else {
-            postMessage(message);
-        }
+        this[WORKER].then(worker => {
+            if (worker) {
+                worker.postMessage(message);
+            }
+            else {
+                postMessage(message);
+            }
+        }).catch(noop_1.noop);
     }
+    /**
+     * Terminates the worker connection and cleans up message listeners.
+     *
+     * This method should be called when you're done with the host to prevent memory leaks.
+     * It removes the message event listener from either the Worker instance (main thread)
+     * or the global scope (worker thread).
+     *
+     * @example
+     * // Clean up when done
+     * const host = new WorkerMessageHost(worker);
+     * // ... use the host ...
+     * host.terminate(); // Clean up listeners
+     */
     terminate() {
-        if (this.#worker) {
-            this.#worker.removeEventListener('message', this.#handler);
-        }
-        else {
-            removeEventListener('message', this.#handler);
-        }
+        this[WORKER].then(worker => {
+            if (worker) {
+                worker.removeEventListener('message', this[HANDLER]);
+            }
+            else {
+                removeEventListener('message', this[HANDLER]);
+            }
+        }).catch(noop_1.noop);
     }
-    #handler = (event) => {
-        this.#requests$.next(event.data);
+    /**
+     * Handles incoming messages and forwards them to the requests stream
+     * @private
+     */
+    [HANDLER] = (event) => {
+        this[REQUESTS$].next(event.data);
     };
 }
 exports.WorkerMessageHost = WorkerMessageHost;

package/worker/message-host.d.ts

@@ -1,9 +1,131 @@
 import { MessageHost } from "../message-host";
 import { MessageResponse } from "../message-response.type";
 import { RESPONSE } from "../selectors";
+import { ClientWorkerArg } from "./initializer";
+declare const WORKER: unique symbol;
+declare const HANDLER: unique symbol;
+declare const REQUESTS$: unique symbol;
+/**
+ * WorkerMessageHost
+ *
+ * Host implementation for Web Worker communication. Receives messages from and sends
+ * responses to Web Workers using the Worker postMessage API.
+ *
+ * This class can be used in two contexts:
+ * - **Main thread**: Provide a Worker instance to receive messages from that specific worker
+ * - **Worker thread**: Omit the worker parameter to receive messages from the main thread via self
+ *
+ * The worker parameter supports multiple types for flexibility:
+ * - Direct Worker instance
+ * - Promise that resolves to a Worker (for async worker initialization)
+ * - Function that returns a Worker (for lazy initialization)
+ * - Function that returns a Promise<Worker> (for async lazy initialization)
+ *
+ * The `initialize()` method allows dynamic worker management, enabling you to switch
+ * workers at runtime or re-establish connections after errors.
+ *
+ * @example
+ * // In main thread - receive messages from a specific worker
+ * const worker = new Worker('./worker.js');
+ * const host = new WorkerMessageHost(worker);
+ *
+ * @example
+ * // In worker thread - receive messages from main thread
+ * const host = new WorkerMessageHost();
+ *
+ * @example
+ * // With async worker initialization
+ * const workerPromise = import('./worker.js').then(m => new m.MyWorker());
+ * const host = new WorkerMessageHost(workerPromise);
+ *
+ * @example
+ * // With lazy initialization
+ * const host = new WorkerMessageHost(() =>
+ *   document.querySelector('[data-worker]') ? new Worker('./worker.js') : undefined
+ * );
+ *
+ * @example
+ * // Re-initialize with a different worker
+ * const host = new WorkerMessageHost();
+ * // Later, switch to a different worker
+ * host.initialize(new Worker('./different-worker.js'));
+ */
 export declare class WorkerMessageHost extends MessageHost {
-    #private;
+    /**
+     * Observable stream of incoming messages from the worker or main thread
+     * @private
+     */
+    private [REQUESTS$];
+    /**
+     * Promise resolving to the Worker instance or undefined if running in worker context
+     * @private
+     */
+    private [WORKER];
+    /**
+     * Creates a new WorkerMessageHost instance
+     *
+     * @param worker - Optional worker configuration:
+     *   - Worker: Direct worker instance (main thread)
+     *   - Promise<Worker>: Promise resolving to worker (async initialization)
+     *   - () => Worker: Function returning worker (lazy initialization)
+     *   - () => Promise<Worker>: Function returning promise (async lazy initialization)
+     *   - undefined: Omit for worker thread context (uses self)
+     */
     constructor(worker?: Worker);
+    /**
+     * Initializes or re-initializes the worker connection.
+     *
+     * This method sets up message listeners for the provided worker. If a worker
+     * was previously initialized, it cleans up the old connection before establishing
+     * the new one. This allows for dynamic worker management, such as:
+     * - Switching between different workers at runtime
+     * - Re-establishing connections after worker errors
+     * - Lazy initialization when the worker is conditionally needed
+     *
+     * @param worker - Optional worker configuration:
+     *   - Worker: Direct worker instance (main thread)
+     *   - Promise<Worker>: Promise resolving to worker (async initialization)
+     *   - () => Worker: Function returning worker (lazy initialization)
+     *   - () => Promise<Worker>: Function returning promise (async lazy initialization)
+     *   - undefined: Omit for worker thread context (uses self)
+     *
+     * @example
+     * // Switch to a different worker dynamically
+     * const host = new WorkerMessageHost(oldWorker);
+     * host.initialize(newWorker); // Cleans up old listener, sets up new one
+     *
+     * @example
+     * // Re-initialize after worker error
+     * worker.onerror = () => {
+     *   host.initialize(new Worker('./worker.js'));
+     * };
+     */
+    initialize(worker: ClientWorkerArg): void;
+    /**
+     * Sends a response message back to the worker or main thread
+     *
+     * @param message - The response message to send
+     * @internal Used by the message handling system to send responses
+     */
     protected [RESPONSE](message: MessageResponse): void;
+    /**
+     * Terminates the worker connection and cleans up message listeners.
+     *
+     * This method should be called when you're done with the host to prevent memory leaks.
+     * It removes the message event listener from either the Worker instance (main thread)
+     * or the global scope (worker thread).
+     *
+     * @example
+     * // Clean up when done
+     * const host = new WorkerMessageHost(worker);
+     * // ... use the host ...
+     * host.terminate(); // Clean up listeners
+     */
     terminate(): void;
+    /**
+     * Handles incoming messages and forwards them to the requests stream
+     * @private
+     */
+    private [HANDLER];
 }
+export {};

package/worker/message-host.js

@@ -1,38 +1,162 @@
 import { Subject } from "rxjs";
 import { MessageHost } from "../message-host";
 import { LISTEN, RESPONSE } from "../selectors";
+import { initializer } from "./initializer";
+import { noop } from "@thalesrc/js-utils/function/noop";
+const WORKER = Symbol('Host Worker');
+const HANDLER = Symbol('Host Message Handler');
+const REQUESTS$ = Symbol('Host Requests Stream');
+/**
+ * WorkerMessageHost
+ *
+ * Host implementation for Web Worker communication. Receives messages from and sends
+ * responses to Web Workers using the Worker postMessage API.
+ *
+ * This class can be used in two contexts:
+ * - **Main thread**: Provide a Worker instance to receive messages from that specific worker
+ * - **Worker thread**: Omit the worker parameter to receive messages from the main thread via self
+ *
+ * The worker parameter supports multiple types for flexibility:
+ * - Direct Worker instance
+ * - Promise that resolves to a Worker (for async worker initialization)
+ * - Function that returns a Worker (for lazy initialization)
+ * - Function that returns a Promise<Worker> (for async lazy initialization)
+ *
+ * The `initialize()` method allows dynamic worker management, enabling you to switch
+ * workers at runtime or re-establish connections after errors.
+ *
+ * @example
+ * // In main thread - receive messages from a specific worker
+ * const worker = new Worker('./worker.js');
+ * const host = new WorkerMessageHost(worker);
+ *
+ * @example
+ * // In worker thread - receive messages from main thread
+ * const host = new WorkerMessageHost();
+ *
+ * @example
+ * // With async worker initialization
+ * const workerPromise = import('./worker.js').then(m => new m.MyWorker());
+ * const host = new WorkerMessageHost(workerPromise);
+ *
+ * @example
+ * // With lazy initialization
+ * const host = new WorkerMessageHost(() =>
+ *   document.querySelector('[data-worker]') ? new Worker('./worker.js') : undefined
+ * );
+ *
+ * @example
+ * // Re-initialize with a different worker
+ * const host = new WorkerMessageHost();
+ * // Later, switch to a different worker
+ * host.initialize(new Worker('./different-worker.js'));
+ */
 export class WorkerMessageHost extends MessageHost {
-    #requests$ = new Subject();
-    #worker;
+    /**
+     * Observable stream of incoming messages from the worker or main thread
+     * @private
+     */
+    [REQUESTS$] = new Subject();
+    /**
+     * Promise resolving to the Worker instance or undefined if running in worker context
+     * @private
+     */
+    [WORKER] = Promise.resolve(undefined);
+    /**
+     * Creates a new WorkerMessageHost instance
+     *
+     * @param worker - Optional worker configuration:
+     *   - Worker: Direct worker instance (main thread)
+     *   - Promise<Worker>: Promise resolving to worker (async initialization)
+     *   - () => Worker: Function returning worker (lazy initialization)
+     *   - () => Promise<Worker>: Function returning promise (async lazy initialization)
+     *   - undefined: Omit for worker thread context (uses self)
+     */
     constructor(worker) {
         super();
-        if (worker) {
-            this.#worker = worker;
-            worker.addEventListener('message', this.#handler);
-        }
-        else {
-            addEventListener('message', this.#handler);
+        this.initialize(worker);
+        this[LISTEN](this[REQUESTS$]);
+    }
+    /**
+     * Initializes or re-initializes the worker connection.
+     *
+     * This method sets up message listeners for the provided worker. If a worker
+     * was previously initialized, it cleans up the old connection before establishing
+     * the new one. This allows for dynamic worker management, such as:
+     * - Switching between different workers at runtime
+     * - Re-establishing connections after worker errors
+     * - Lazy initialization when the worker is conditionally needed
+     *
+     * @param worker - Optional worker configuration:
+     *   - Worker: Direct worker instance (main thread)
+     *   - Promise<Worker>: Promise resolving to worker (async initialization)
+     *   - () => Worker: Function returning worker (lazy initialization)
+     *   - () => Promise<Worker>: Function returning promise (async lazy initialization)
+     *   - undefined: Omit for worker thread context (uses self)
+     *
+     * @example
+     * // Switch to a different worker dynamically
+     * const host = new WorkerMessageHost(oldWorker);
+     * host.initialize(newWorker); // Cleans up old listener, sets up new one
+     *
+     * @example
+     * // Re-initialize after worker error
+     * worker.onerror = () => {
+     *   host.initialize(new Worker('./worker.js'));
+     * };
+     */
+    initialize(worker) {
+        // Ensure WORKER is initialized if not already
+        if (!this[WORKER]) {
+            this[WORKER] = Promise.resolve(undefined);
         }
-        this[LISTEN](this.#requests$);
+        this[WORKER] = initializer(this[WORKER], worker, this[HANDLER]);
     }
+    /**
+     * Sends a response message back to the worker or main thread
+     *
+     * @param message - The response message to send
+     * @internal Used by the message handling system to send responses
+     */
     [RESPONSE](message) {
-        if (this.#worker) {
-            this.#worker.postMessage(message);
-        }
-        else {
-            postMessage(message);
-        }
+        this[WORKER].then(worker => {
+            if (worker) {
+                worker.postMessage(message);
+            }
+            else {
+                postMessage(message);
+            }
+        }).catch(noop);
     }
+    /**
+     * Terminates the worker connection and cleans up message listeners.
+     *
+     * This method should be called when you're done with the host to prevent memory leaks.
+     * It removes the message event listener from either the Worker instance (main thread)
+     * or the global scope (worker thread).
+     *
+     * @example
+     * // Clean up when done
+     * const host = new WorkerMessageHost(worker);
+     * // ... use the host ...
+     * host.terminate(); // Clean up listeners
+     */
     terminate() {
-        if (this.#worker) {
-            this.#worker.removeEventListener('message', this.#handler);
-        }
-        else {
-            removeEventListener('message', this.#handler);
-        }
+        this[WORKER].then(worker => {
+            if (worker) {
+                worker.removeEventListener('message', this[HANDLER]);
+            }
+            else {
+                removeEventListener('message', this[HANDLER]);
+            }
+        }).catch(noop);
     }
-    #handler = (event) => {
-        this.#requests$.next(event.data);
+    /**
+     * Handles incoming messages and forwards them to the requests stream
+     * @private
+     */
+    [HANDLER] = (event) => {
+        this[REQUESTS$].next(event.data);
     };
 }