@thalesrc/hermes 7.1.0 → 7.3.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019 Thales Rocks
+Copyright (c) 2019 Thalesrc
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -231,6 +231,63 @@ mainService.sendDataToWorker([1, 2, 3, 4, 5]).subscribe(result => {
 });
 ```
 
+##### Flexible Worker Initialization
+
+The worker parameter supports multiple initialization patterns for different use cases:
+
+```typescript
+// Direct Worker instance
+const service1 = new MainThread(new Worker('./worker.js'));
+
+// Promise that resolves to a Worker (for async initialization)
+const workerPromise = import('./worker.js').then(m => new Worker(m.default));
+const service2 = new MainThread(workerPromise);
+
+// Function that returns a Worker (for lazy initialization)
+const service3 = new MainThread(() => new Worker('./worker.js'));
+
+// Function that returns a Promise<Worker> (for async lazy initialization)
+const service4 = new MainThread(async () => {
+  const module = await import('./worker.js');
+  return new Worker(module.default);
+});
+```
+
+##### Dynamic Worker Management with `initialize()`
+
+The `initialize()` method allows you to switch workers at runtime or re-establish connections:
+
+```typescript
+class MainThread extends WorkerMessageService {
+  // ... decorators and methods
+}
+
+// Start without a worker
+const service = new MainThread();
+
+// Later, connect to a worker dynamically
+service.initialize(new Worker('./worker.js'));
+
+// Switch to a different worker
+service.initialize(new Worker('./different-worker.js'));
+
+// Re-establish connection after worker error
+const worker = new Worker('./worker.js');
+worker.onerror = (error) => {
+  console.error('Worker error, reinitializing...', error);
+  service.initialize(new Worker('./worker.js'));
+};
+service.initialize(worker);
+
+// Conditional worker initialization
+function getWorker() {
+  return navigator.hardwareConcurrency > 2 
+    ? new Worker('./heavy-worker.js')
+    : new Worker('./light-worker.js');
+}
+service.initialize(getWorker);
+```
+
 #### Worker Thread
 
 ```typescript

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thalesrc/hermes",
-  "version": "7.1.0",
+  "version": "7.3.0",
   "description": "Javascript messaging library",
   "keywords": [
     "javascript",

package/worker/index.cjs

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Listen = exports.Request = exports.WorkerMessageService = void 0;
+exports.Listen = exports.Request = exports.WorkerMessageHost = exports.WorkerMessageClient = exports.WorkerMessageService = void 0;
 var message_service_1 = require("./message-service");
 Object.defineProperty(exports, "WorkerMessageService", { enumerable: true, get: function () { return message_service_1.WorkerMessageService; } });
+var message_client_1 = require("./message-client");
+Object.defineProperty(exports, "WorkerMessageClient", { enumerable: true, get: function () { return message_client_1.WorkerMessageClient; } });
+var message_host_1 = require("./message-host");
+Object.defineProperty(exports, "WorkerMessageHost", { enumerable: true, get: function () { return message_host_1.WorkerMessageHost; } });
 var request_decorator_1 = require("../request.decorator");
 Object.defineProperty(exports, "Request", { enumerable: true, get: function () { return request_decorator_1.Request; } });
 var listen_decorator_1 = require("../listen.decorator");

package/worker/index.d.ts

@@ -1,3 +1,5 @@
 export { WorkerMessageService } from './message-service';
+export { WorkerMessageClient } from './message-client';
+export { WorkerMessageHost } from './message-host';
 export { Request } from '../request.decorator';
 export { Listen } from '../listen.decorator';

package/worker/index.js

@@ -1,4 +1,6 @@
 export { WorkerMessageService } from './message-service';
+export { WorkerMessageClient } from './message-client';
+export { WorkerMessageHost } from './message-host';
 export { Request } from '../request.decorator';
 export { Listen } from '../listen.decorator';
 

package/worker/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../libs/hermes/src/worker/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAC/C,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC","file":"index.js","sourcesContent":["export { WorkerMessageService } from './message-service';\nexport { Request } from '../request.decorator';\nexport { Listen } from '../listen.decorator';\n"]}
+{"version":3,"sources":["../../../../../libs/hermes/src/worker/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAC/C,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC","file":"index.js","sourcesContent":["export { WorkerMessageService } from './message-service';\nexport { WorkerMessageClient } from './message-client';\nexport { WorkerMessageHost } from './message-host';\nexport { Request } from '../request.decorator';\nexport { Listen } from '../listen.decorator';\n"]}

package/worker/message-client.cjs

@@ -1,40 +1,174 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkerMessageClient = void 0;
-const js_utils_1 = require("@thalesrc/js-utils");
+const unique_id_1 = require("@thalesrc/js-utils/unique-id");
+const noop_1 = require("@thalesrc/js-utils/function/noop");
+const promisify_1 = require("@thalesrc/js-utils/promise/promisify");
 const rxjs_1 = require("rxjs");
 const message_client_1 = require("../message-client");
 const selectors_1 = require("../selectors");
-const WORKER = Symbol('Worker');
-const HANDLER = Symbol('Handler');
-const INSTANCE_ID = Symbol('Instance Id');
+/**
+ * WorkerMessageClient
+ *
+ * Client implementation for Web Worker communication. Sends messages to and receives
+ * responses from Web Workers using the Worker postMessage API.
+ *
+ * This class can be used in two contexts:
+ * - **Main thread**: Provide a Worker instance to communicate with that specific worker
+ * - **Worker thread**: Omit the worker parameter to communicate with 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 - communicate with a specific worker
+ * const worker = new Worker('./worker.js');
+ * const client = new WorkerMessageClient(worker);
+ *
+ * @example
+ * // In worker thread - communicate with main thread
+ * const client = new WorkerMessageClient();
+ *
+ * @example
+ * // With async worker initialization
+ * const workerPromise = import('./worker.js').then(m => new m.MyWorker());
+ * const client = new WorkerMessageClient(workerPromise);
+ *
+ * @example
+ * // With lazy initialization
+ * const client = new WorkerMessageClient(() =>
+ *   document.querySelector('[data-worker]') ? new Worker('./worker.js') : undefined
+ * );
+ *
+ * @example
+ * // Re-initialize with a different worker
+ * const client = new WorkerMessageClient();
+ * // Later, switch to a different worker
+ * client.initialize(new Worker('./different-worker.js'));
+ */
 class WorkerMessageClient extends message_client_1.MessageClient {
+    /**
+     * Promise resolving to the Worker instance or undefined if running in worker context
+     * @private
+     */
+    #worker = Promise.resolve(undefined);
+    /**
+     * Unique identifier for this client instance to prevent ID collisions
+     * @private
+     */
+    #instanceId = Date.now();
+    /**
+     * Observable stream of message responses from the worker or main thread
+     */
     [selectors_1.RESPONSES$] = new rxjs_1.Subject();
-    [WORKER];
-    [INSTANCE_ID] = Date.now();
+    /**
+     * Creates a new WorkerMessageClient 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();
-        this[WORKER] = worker;
-        if (worker) {
-            worker.addEventListener('message', this[HANDLER]);
-        }
-        else {
-            addEventListener('message', this[HANDLER]);
-        }
+        this.initialize(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 client = new WorkerMessageClient(oldWorker);
+     * client.initialize(newWorker); // Cleans up old listener, sets up new one
+     *
+     * @example
+     * // Re-initialize after worker error
+     * worker.onerror = () => {
+     *   client.initialize(new Worker('./worker.js'));
+     * };
+     */
+    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_1.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 = (0, promisify_1.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_1.noop);
+    }
+    /**
+     * Sends a message to the worker or main thread
+     *
+     * @param message - The message to send
+     * @template T - Type of the message body
+     * @internal Used by @Request decorator
+     */
     [selectors_1.SEND](message) {
-        if (this[WORKER]) {
-            this[WORKER].postMessage(message);
-        }
-        else {
-            postMessage(message);
-        }
+        this.#worker.then(worker => {
+            if (worker) {
+                // Main thread: send to worker
+                worker.postMessage(message);
+            }
+            else {
+                // Worker thread: send to main thread
+                postMessage(message);
+            }
+        }).catch(noop_1.noop);
     }
-    [HANDLER] = (event) => {
+    /**
+     * Handles incoming messages and forwards them to the responses stream
+     * @private
+     */
+    #handler = (event) => {
         this[selectors_1.RESPONSES$].next(event.data);
     };
+    /**
+     * Generates a unique message ID for tracking request-response pairs
+     *
+     * @returns Unique message identifier
+     * @internal Used by @Request decorator
+     */
     [selectors_1.GET_NEW_ID]() {
-        return (0, js_utils_1.uniqueId)('hermes-worker-message-' + this[INSTANCE_ID]);
+        return (0, unique_id_1.uniqueId)('hermes-worker-message-' + this.#instanceId);
     }
 }
 exports.WorkerMessageClient = WorkerMessageClient;

package/worker/message-client.d.ts

@@ -3,19 +3,115 @@ import { MessageClient } from "../message-client";
 import { MessageResponse } from "../message-response.type";
 import { Message } from "../message.interface";
 import { GET_NEW_ID, RESPONSES$, SEND } from "../selectors";
-interface MessageEvent<T> {
-    data: T;
-}
-declare const WORKER: unique symbol;
-declare const HANDLER: unique symbol;
-declare const INSTANCE_ID: unique symbol;
+type ClientWorkerType = Worker | undefined;
+type ClientWorkerPromise = Promise<ClientWorkerType>;
+type ClientWorkerFactory = () => ClientWorkerType | ClientWorkerPromise;
+type ClientWorkerArg = ClientWorkerType | ClientWorkerPromise | ClientWorkerFactory;
+/**
+ * WorkerMessageClient
+ *
+ * Client implementation for Web Worker communication. Sends messages to and receives
+ * responses from Web Workers using the Worker postMessage API.
+ *
+ * This class can be used in two contexts:
+ * - **Main thread**: Provide a Worker instance to communicate with that specific worker
+ * - **Worker thread**: Omit the worker parameter to communicate with 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 - communicate with a specific worker
+ * const worker = new Worker('./worker.js');
+ * const client = new WorkerMessageClient(worker);
+ *
+ * @example
+ * // In worker thread - communicate with main thread
+ * const client = new WorkerMessageClient();
+ *
+ * @example
+ * // With async worker initialization
+ * const workerPromise = import('./worker.js').then(m => new m.MyWorker());
+ * const client = new WorkerMessageClient(workerPromise);
+ *
+ * @example
+ * // With lazy initialization
+ * const client = new WorkerMessageClient(() =>
+ *   document.querySelector('[data-worker]') ? new Worker('./worker.js') : undefined
+ * );
+ *
+ * @example
+ * // Re-initialize with a different worker
+ * const client = new WorkerMessageClient();
+ * // Later, switch to a different worker
+ * client.initialize(new Worker('./different-worker.js'));
+ */
 export declare class WorkerMessageClient extends MessageClient {
+    #private;
+    /**
+     * Observable stream of message responses from the worker or main thread
+     */
     [RESPONSES$]: Subject<MessageResponse>;
-    protected [WORKER]: Worker | undefined;
-    private [INSTANCE_ID];
-    constructor(worker?: Worker);
+    /**
+     * Creates a new WorkerMessageClient 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?: ClientWorkerArg);
+    /**
+     * 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 client = new WorkerMessageClient(oldWorker);
+     * client.initialize(newWorker); // Cleans up old listener, sets up new one
+     *
+     * @example
+     * // Re-initialize after worker error
+     * worker.onerror = () => {
+     *   client.initialize(new Worker('./worker.js'));
+     * };
+     */
+    initialize(worker?: ClientWorkerArg): void;
+    /**
+     * Sends a message to the worker or main thread
+     *
+     * @param message - The message to send
+     * @template T - Type of the message body
+     * @internal Used by @Request decorator
+     */
     [SEND]<T>(message: Message<T>): void;
-    protected [HANDLER]: (event: MessageEvent<MessageResponse>) => void;
+    /**
+     * Generates a unique message ID for tracking request-response pairs
+     *
+     * @returns Unique message identifier
+     * @internal Used by @Request decorator
+     */
     protected [GET_NEW_ID](): string;
 }
 export {};

package/worker/message-client.js

@@ -1,37 +1,171 @@
-import { uniqueId } from "@thalesrc/js-utils";
+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";
-const WORKER = Symbol('Worker');
-const HANDLER = Symbol('Handler');
-const INSTANCE_ID = Symbol('Instance Id');
+/**
+ * WorkerMessageClient
+ *
+ * Client implementation for Web Worker communication. Sends messages to and receives
+ * responses from Web Workers using the Worker postMessage API.
+ *
+ * This class can be used in two contexts:
+ * - **Main thread**: Provide a Worker instance to communicate with that specific worker
+ * - **Worker thread**: Omit the worker parameter to communicate with 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 - communicate with a specific worker
+ * const worker = new Worker('./worker.js');
+ * const client = new WorkerMessageClient(worker);
+ *
+ * @example
+ * // In worker thread - communicate with main thread
+ * const client = new WorkerMessageClient();
+ *
+ * @example
+ * // With async worker initialization
+ * const workerPromise = import('./worker.js').then(m => new m.MyWorker());
+ * const client = new WorkerMessageClient(workerPromise);
+ *
+ * @example
+ * // With lazy initialization
+ * const client = new WorkerMessageClient(() =>
+ *   document.querySelector('[data-worker]') ? new Worker('./worker.js') : undefined
+ * );
+ *
+ * @example
+ * // Re-initialize with a different worker
+ * const client = new WorkerMessageClient();
+ * // Later, switch to a different worker
+ * client.initialize(new Worker('./different-worker.js'));
+ */
 export class WorkerMessageClient extends MessageClient {
+    /**
+     * Promise resolving to the Worker instance or undefined if running in worker context
+     * @private
+     */
+    #worker = Promise.resolve(undefined);
+    /**
+     * Unique identifier for this client instance to prevent ID collisions
+     * @private
+     */
+    #instanceId = Date.now();
+    /**
+     * Observable stream of message responses from the worker or main thread
+     */
     [RESPONSES$] = new Subject();
-    [WORKER];
-    [INSTANCE_ID] = Date.now();
+    /**
+     * Creates a new WorkerMessageClient 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();
-        this[WORKER] = worker;
-        if (worker) {
-            worker.addEventListener('message', this[HANDLER]);
-        }
-        else {
-            addEventListener('message', this[HANDLER]);
-        }
+        this.initialize(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 client = new WorkerMessageClient(oldWorker);
+     * client.initialize(newWorker); // Cleans up old listener, sets up new one
+     *
+     * @example
+     * // Re-initialize after worker error
+     * worker.onerror = () => {
+     *   client.initialize(new Worker('./worker.js'));
+     * };
+     */
+    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);
+    }
+    /**
+     * Sends a message to the worker or main thread
+     *
+     * @param message - The message to send
+     * @template T - Type of the message body
+     * @internal Used by @Request decorator
+     */
     [SEND](message) {
-        if (this[WORKER]) {
-            this[WORKER].postMessage(message);
-        }
-        else {
-            postMessage(message);
-        }
+        this.#worker.then(worker => {
+            if (worker) {
+                // Main thread: send to worker
+                worker.postMessage(message);
+            }
+            else {
+                // Worker thread: send to main thread
+                postMessage(message);
+            }
+        }).catch(noop);
     }
-    [HANDLER] = (event) => {
+    /**
+     * Handles incoming messages and forwards them to the responses stream
+     * @private
+     */
+    #handler = (event) => {
         this[RESPONSES$].next(event.data);
     };
+    /**
+     * Generates a unique message ID for tracking request-response pairs
+     *
+     * @returns Unique message identifier
+     * @internal Used by @Request decorator
+     */
     [GET_NEW_ID]() {
-        return uniqueId('hermes-worker-message-' + this[INSTANCE_ID]);
+        return uniqueId('hermes-worker-message-' + this.#instanceId);
     }
 }
 

package/worker/message-client.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../libs/hermes/src/worker/message-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,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;AAM5D,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;AAChC,MAAM,OAAO,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;AAClC,MAAM,WAAW,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC;AAE1C,MAAM,OAAO,mBAAoB,SAAQ,aAAa;IAC7C,CAAC,UAAU,CAAC,GAAG,IAAI,OAAO,EAAmB,CAAC;IAC3C,CAAC,MAAM,CAAC,CAAqB;IAC/B,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAEnC,YAAY,MAAe;QACzB,KAAK,EAAE,CAAC;QAER,IAAI,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;QAEtB,IAAI,MAAM,EAAE,CAAC;YACX,MAAM,CAAC,gBAAgB,CAAC,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;QACpD,CAAC;aAAM,CAAC;YACN,gBAAgB,CAAC,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;QAC7C,CAAC;IACH,CAAC;IAEM,CAAC,IAAI,CAAC,CAAI,OAAmB;QAClC,IAAI,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;YACjB,IAAI,CAAC,MAAM,CAAC,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QACpC,CAAC;aAAM,CAAC;YACL,WAAmB,CAAC,OAAO,CAAC,CAAC;QAChC,CAAC;IACH,CAAC;IAES,CAAC,OAAO,CAAC,GAAG,CAAC,KAAoC,EAAE,EAAE;QAC7D,IAAI,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACpC,CAAC,CAAA;IAES,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\";\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\ninterface MessageEvent<T> {\n  data: T;\n}\n\nconst WORKER = Symbol('Worker');\nconst HANDLER = Symbol('Handler');\nconst INSTANCE_ID = Symbol('Instance Id');\n\nexport class WorkerMessageClient extends MessageClient {\n  public [RESPONSES$] = new Subject<MessageResponse>();\n  protected [WORKER]: Worker | undefined;\n  private [INSTANCE_ID] = Date.now();\n\n  constructor(worker?: Worker) {\n    super();\n\n    this[WORKER] = worker;\n\n    if (worker) {\n      worker.addEventListener('message', this[HANDLER]);\n    } else {\n      addEventListener('message', this[HANDLER]);\n    }\n  }\n\n  public [SEND]<T>(message: Message<T>) {\n    if (this[WORKER]) {\n      this[WORKER].postMessage(message);\n    } else {\n      (postMessage as any)(message);\n    }\n  }\n\n  protected [HANDLER] = (event: MessageEvent<MessageResponse>) => {\n    this[RESPONSES$].next(event.data);\n  }\n\n  protected [GET_NEW_ID](): string {\n    return uniqueId('hermes-worker-message-' + this[INSTANCE_ID]) 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,SAAS,EAAE,MAAM,sCAAsC,CAAC;AACjE,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;AAO5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,OAAO,mBAAoB,SAAQ,aAAa;IACpD;;;OAGG;IACH,OAAO,GAAwB,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IAE1D;;;OAGG;IACH,WAAW,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAEzB;;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,sCAAsC;QACtC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE;YAC7B,IAAI,UAAU,EAAE,CAAC;gBACf,UAAU,CAAC,mBAAmB,CAAC,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;YAC3D,CAAC;iBAAM,CAAC;gBACN,mBAAmB,CAAC,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;YAChD,CAAC;QACH,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAEf,uFAAuF;QACvF,MAAM,OAAO,GAAuD,OAAO,MAAM,KAAK,UAAU,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC;QACrH,sEAAsE;QACtE,IAAI,CAAC,OAAO,GAAG,SAAS,CAAC,OAAO,CAAC,CAAC;QAElC,kDAAkD;QAClD,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE;YACzB,IAAI,MAAM,EAAE,CAAC;gBACX,iDAAiD;gBACjD,MAAM,CAAC,gBAAgB,CAAC,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;YACpD,CAAC;iBAAM,CAAC;gBACN,6DAA6D;gBAC7D,gBAAgB,CAAC,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;YAC7C,CAAC;QACH,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACjB,CAAC;IAED;;;;;;OAMG;IACI,CAAC,IAAI,CAAC,CAAI,OAAmB;QAClC,IAAI,CAAC,OAAO,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;IACH,QAAQ,GAAG,CAAC,KAAoC,EAAE,EAAE;QAClD,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,CAAW,CAAC;IACzE,CAAC;CACF","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"]}

package/worker/message-service.d.ts

@@ -1,5 +1,5 @@
 import { WorkerMessageClient } from "./message-client";
-declare const WorkerMessageService_base: new (args_0: [worker?: Worker | undefined], args_1: [worker?: Worker | undefined]) => {
+declare const WorkerMessageService_base: new (args_0: [worker?: Worker | undefined], args_1: [worker?: (Worker | undefined) | Promise<Worker | undefined> | (() => (Worker | undefined) | Promise<Worker | undefined>)]) => {
     terminate: () => void;
 } & WorkerMessageClient;
 export declare class WorkerMessageService extends WorkerMessageService_base {