@thalesrc/hermes 7.4.7 → 7.5.2

package/worker/message-host.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../libs/hermes/src/worker/message-host.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAG9C,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAMhD,MAAM,OAAO,iBAAkB,SAAQ,WAAW;IAChD,UAAU,GAAG,IAAI,OAAO,EAAW,CAAC;IACpC,OAAO,CAAqB;IAE5B,YAAY,MAAe;QACzB,KAAK,EAAE,CAAC;QAER,IAAI,MAAM,EAAE,CAAC;YACX,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;YACtB,MAAM,CAAC,gBAAgB,CAAC,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;QACpD,CAAC;aAAM,CAAC;YACN,gBAAgB,CAAC,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC7C,CAAC;QAED,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAChC,CAAC;IAES,CAAC,QAAQ,CAAC,CAAC,OAAwB;QAC3C,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QACpC,CAAC;aAAM,CAAC;YACL,WAAmB,CAAC,OAAO,CAAC,CAAC;QAChC,CAAC;IACH,CAAC;IAEM,SAAS;QACd,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,IAAI,CAAC,OAAO,CAAC,mBAAmB,CAAC,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC7D,CAAC;aAAM,CAAC;YACN,mBAAmB,CAAC,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;QAChD,CAAC;IACH,CAAC;IAED,QAAQ,GAAG,CAAC,KAA4B,EAAE,EAAE;QAC1C,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACnC,CAAC,CAAA;CACF","file":"message-host.js","sourcesContent":["import { Subject } from \"rxjs\";\nimport { MessageHost } from \"../message-host\";\nimport { MessageResponse } from \"../message-response.type\";\nimport { Message } from \"../message.interface\";\nimport { LISTEN, RESPONSE } from \"../selectors\";\n\ninterface MessageEvent<T> {\n  data: T;\n}\n\nexport class WorkerMessageHost extends MessageHost {\n  #requests$ = new Subject<Message>();\n  #worker: Worker | undefined;\n\n  constructor(worker?: Worker) {\n    super();\n\n    if (worker) {\n      this.#worker = worker;\n      worker.addEventListener('message', this.#handler);\n    } else {\n      addEventListener('message', this.#handler);\n    }\n\n    this[LISTEN](this.#requests$);\n  }\n\n  protected [RESPONSE](message: MessageResponse) {\n    if (this.#worker) {\n      this.#worker.postMessage(message);\n    } else {\n      (postMessage as any)(message);\n    }\n  }\n\n  public terminate() {\n    if (this.#worker) {\n      this.#worker.removeEventListener('message', this.#handler);\n    } else {\n      removeEventListener('message', this.#handler);\n    }\n  }\n\n  #handler = (event: MessageEvent<Message>) => {\n    this.#requests$.next(event.data);\n  }\n}\n"]}
+{"version":3,"sources":["../../../../../libs/hermes/src/worker/message-host.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAG9C,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,EAAwC,WAAW,EAAE,MAAM,eAAe,CAAC;AAClF,OAAO,EAAE,IAAI,EAAE,MAAM,kCAAkC,CAAC;AAExD,MAAM,MAAM,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC;AACrC,MAAM,OAAO,GAAG,MAAM,CAAC,sBAAsB,CAAC,CAAC;AAC/C,MAAM,SAAS,GAAG,MAAM,CAAC,sBAAsB,CAAC,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,OAAO,iBAAkB,SAAQ,WAAW;IAChD;;;OAGG;IACK,CAAC,SAAS,CAAC,GAAG,IAAI,OAAO,EAAW,CAAC;IAE7C;;;OAGG;IACK,CAAC,MAAM,CAAC,GAAwB,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IAEnE;;;;;;;;;OASG;IACH,YAAY,MAAe;QACzB,KAAK,EAAE,CAAC;QAER,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QACxB,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;IAChC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,UAAU,CAAC,MAAuB;QAChC,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;;;;;OAKG;IACO,CAAC,QAAQ,CAAC,CAAC,OAAwB;QAC3C,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE;YACzB,IAAI,MAAM,EAAE,CAAC;gBACX,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;YAC9B,CAAC;iBAAM,CAAC;gBACL,WAAmB,CAAC,OAAO,CAAC,CAAC;YAChC,CAAC;QACH,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACjB,CAAC;IAED;;;;;;;;;;;;OAYG;IACI,SAAS;QACd,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE;YACzB,IAAI,MAAM,EAAE,CAAC;gBACX,MAAM,CAAC,mBAAmB,CAAC,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;YACvD,CAAC;iBAAM,CAAC;gBACN,mBAAmB,CAAC,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;YAChD,CAAC;QACH,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACjB,CAAC;IAED;;;OAGG;IACK,CAAC,OAAO,CAAC,GAAG,CAAC,KAA4B,EAAE,EAAE;QACnD,IAAI,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACnC,CAAC,CAAC;CACH","file":"message-host.js","sourcesContent":["import { Subject } from \"rxjs\";\nimport { MessageHost } from \"../message-host\";\nimport { MessageResponse } from \"../message-response.type\";\nimport { Message } from \"../message.interface\";\nimport { LISTEN, RESPONSE } from \"../selectors\";\nimport { ClientWorkerArg, ClientWorkerPromise, initializer } from \"./initializer\";\nimport { noop } from \"@thalesrc/js-utils/function/noop\";\n\nconst WORKER = Symbol('Host Worker');\nconst HANDLER = Symbol('Host Message Handler');\nconst REQUESTS$ = Symbol('Host Requests Stream');\n\n/**\n * WorkerMessageHost\n *\n * Host implementation for Web Worker communication. Receives messages from and sends\n * responses to 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 receive messages from that specific worker\n * - **Worker thread**: Omit the worker parameter to receive messages from 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 - receive messages from a specific worker\n * const worker = new Worker('./worker.js');\n * const host = new WorkerMessageHost(worker);\n *\n * @example\n * // In worker thread - receive messages from main thread\n * const host = new WorkerMessageHost();\n *\n * @example\n * // With async worker initialization\n * const workerPromise = import('./worker.js').then(m => new m.MyWorker());\n * const host = new WorkerMessageHost(workerPromise);\n *\n * @example\n * // With lazy initialization\n * const host = new WorkerMessageHost(() =>\n *   document.querySelector('[data-worker]') ? new Worker('./worker.js') : undefined\n * );\n *\n * @example\n * // Re-initialize with a different worker\n * const host = new WorkerMessageHost();\n * // Later, switch to a different worker\n * host.initialize(new Worker('./different-worker.js'));\n */\nexport class WorkerMessageHost extends MessageHost {\n  /**\n   * Observable stream of incoming messages from the worker or main thread\n   * @private\n   */\n  private [REQUESTS$] = new Subject<Message>();\n\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   * Creates a new WorkerMessageHost 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?: Worker) {\n    super();\n\n    this.initialize(worker);\n    this[LISTEN](this[REQUESTS$]);\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 host = new WorkerMessageHost(oldWorker);\n   * host.initialize(newWorker); // Cleans up old listener, sets up new one\n   *\n   * @example\n   * // Re-initialize after worker error\n   * worker.onerror = () => {\n   *   host.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 response message back to the worker or main thread\n   *\n   * @param message - The response message to send\n   * @internal Used by the message handling system to send responses\n   */\n  protected [RESPONSE](message: MessageResponse) {\n    this[WORKER].then(worker => {\n      if (worker) {\n        worker.postMessage(message);\n      } else {\n        (postMessage as any)(message);\n      }\n    }).catch(noop);\n  }\n\n  /**\n   * Terminates the worker connection and cleans up message listeners.\n   *\n   * This method should be called when you're done with the host to prevent memory leaks.\n   * It removes the message event listener from either the Worker instance (main thread)\n   * or the global scope (worker thread).\n   *\n   * @example\n   * // Clean up when done\n   * const host = new WorkerMessageHost(worker);\n   * // ... use the host ...\n   * host.terminate(); // Clean up listeners\n   */\n  public terminate() {\n    this[WORKER].then(worker => {\n      if (worker) {\n        worker.removeEventListener('message', this[HANDLER]);\n      } else {\n        removeEventListener('message', this[HANDLER]);\n      }\n    }).catch(noop);\n  }\n\n  /**\n   * Handles incoming messages and forwards them to the requests stream\n   * @private\n   */\n  private [HANDLER] = (event: MessageEvent<Message>) => {\n    this[REQUESTS$].next(event.data);\n  };\n}\n"]}

package/worker/message-service.cjs

@@ -4,9 +4,120 @@ exports.WorkerMessageService = void 0;
 const mixin_1 = require("@thalesrc/js-utils/class/mixin");
 const message_client_1 = require("./message-client");
 const message_host_1 = require("./message-host");
+/**
+ * WorkerMessageService
+ *
+ * Bidirectional communication service for Web Workers that combines both client and host
+ * capabilities. This class extends both WorkerMessageClient and WorkerMessageHost through
+ * mixin composition, enabling full duplex communication - it can both send messages and
+ * respond to incoming requests simultaneously.
+ *
+ * This class is useful when you need a single instance to handle both:
+ * - **Sending messages**: Using the @Request decorator to call methods on the other side
+ * - **Receiving messages**: Using the @Response decorator to handle incoming requests
+ *
+ * Like its parent classes, this can be used in two contexts:
+ * - **Main thread**: Provide a Worker instance for bidirectional communication with that worker
+ * - **Worker thread**: Omit the worker parameter for bidirectional communication with main thread
+ *
+ * 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)
+ *
+ * @example
+ * // In main thread - full duplex communication with worker
+ * const worker = new Worker('./worker.js');
+ * const service = new WorkerMessageService(worker);
+ *
+ * class MainAPI extends WorkerMessageService {
+ *   // Send messages to worker
+ *   @Request()
+ *   fetchData(): Observable<Data> {
+ *     return null!;
+ *   }
+ *
+ *   // Respond to worker requests
+ *   @Listen()
+ *   saveToLocalStorage(data: any) {
+ *     localStorage.setItem('data', JSON.stringify(data));
+ *     return [];
+ *   }
+ * }
+ *
+ * @example
+ * // In worker thread - full duplex communication with main thread
+ * const service = new WorkerMessageService();
+ *
+ * class WorkerAPI extends WorkerMessageService {
+ *   // Respond to main thread requests
+ *   @Listen()
+ *   fetchData() {
+ *     return from(fetch('/api/data').then(r => r.json()));
+ *   }
+ *
+ *   // Send messages to main thread
+ *   @Request()
+ *   saveToLocalStorage(data: any): Observable<void> {
+ *     return null!;
+ *   }
+ * }
+ *
+ * @example
+ * // With async worker initialization
+ * const workerPromise = import('./worker.js').then(m => new m.MyWorker());
+ * const service = new WorkerMessageService(workerPromise);
+ *
+ * @example
+ * // Re-initialize with a different worker
+ * const service = new WorkerMessageService();
+ * // Later, switch to a different worker
+ * service.initialize(new Worker('./different-worker.js'));
+ */
 class WorkerMessageService extends (0, mixin_1.mixin)(message_host_1.WorkerMessageHost, message_client_1.WorkerMessageClient) {
+    /**
+     * Creates a new WorkerMessageService instance with bidirectional communication
+     *
+     * @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([worker], [worker]);
+        this.initialize(worker);
     }
+    /**
+     * Initializes or re-initializes the worker connection for both client and host.
+     *
+     * This method sets up message listeners for both sending and receiving messages.
+     * If a worker was previously initialized, it cleans up the old connections before
+     * establishing new ones. This allows for dynamic worker management.
+     *
+     * @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 service = new WorkerMessageService(oldWorker);
+     * service.initialize(newWorker); // Cleans up old listeners, sets up new ones
+     *
+     * @example
+     * // Re-initialize after worker error
+     * worker.onerror = () => {
+     *   service.initialize(new Worker('./worker.js'));
+     * };
+     */
+    initialize = (worker) => {
+        message_host_1.WorkerMessageHost.prototype.initialize.call(this, worker);
+        message_client_1.WorkerMessageClient.prototype.initialize.call(this, worker);
+    };
 }
 exports.WorkerMessageService = WorkerMessageService;

package/worker/message-service.d.ts

@@ -1,8 +1,117 @@
 import { WorkerMessageClient } from "./message-client";
-declare const WorkerMessageService_base: new (args_0: [worker?: Worker | undefined], args_1: [worker?: (Worker | undefined) | Promise<Worker | undefined> | (() => (Worker | undefined) | Promise<Worker | undefined>)]) => {
+import { ClientWorkerArg } from "./initializer";
+declare const WorkerMessageService_base: new (args_0: [worker?: Worker | undefined], args_1: [worker?: ClientWorkerArg]) => {
+    initialize: (worker?: ClientWorkerArg) => void;
     terminate: () => void;
 } & WorkerMessageClient;
+/**
+ * WorkerMessageService
+ *
+ * Bidirectional communication service for Web Workers that combines both client and host
+ * capabilities. This class extends both WorkerMessageClient and WorkerMessageHost through
+ * mixin composition, enabling full duplex communication - it can both send messages and
+ * respond to incoming requests simultaneously.
+ *
+ * This class is useful when you need a single instance to handle both:
+ * - **Sending messages**: Using the @Request decorator to call methods on the other side
+ * - **Receiving messages**: Using the @Response decorator to handle incoming requests
+ *
+ * Like its parent classes, this can be used in two contexts:
+ * - **Main thread**: Provide a Worker instance for bidirectional communication with that worker
+ * - **Worker thread**: Omit the worker parameter for bidirectional communication with main thread
+ *
+ * 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)
+ *
+ * @example
+ * // In main thread - full duplex communication with worker
+ * const worker = new Worker('./worker.js');
+ * const service = new WorkerMessageService(worker);
+ *
+ * class MainAPI extends WorkerMessageService {
+ *   // Send messages to worker
+ *   @Request()
+ *   fetchData(): Observable<Data> {
+ *     return null!;
+ *   }
+ *
+ *   // Respond to worker requests
+ *   @Listen()
+ *   saveToLocalStorage(data: any) {
+ *     localStorage.setItem('data', JSON.stringify(data));
+ *     return [];
+ *   }
+ * }
+ *
+ * @example
+ * // In worker thread - full duplex communication with main thread
+ * const service = new WorkerMessageService();
+ *
+ * class WorkerAPI extends WorkerMessageService {
+ *   // Respond to main thread requests
+ *   @Listen()
+ *   fetchData() {
+ *     return from(fetch('/api/data').then(r => r.json()));
+ *   }
+ *
+ *   // Send messages to main thread
+ *   @Request()
+ *   saveToLocalStorage(data: any): Observable<void> {
+ *     return null!;
+ *   }
+ * }
+ *
+ * @example
+ * // With async worker initialization
+ * const workerPromise = import('./worker.js').then(m => new m.MyWorker());
+ * const service = new WorkerMessageService(workerPromise);
+ *
+ * @example
+ * // Re-initialize with a different worker
+ * const service = new WorkerMessageService();
+ * // Later, switch to a different worker
+ * service.initialize(new Worker('./different-worker.js'));
+ */
 export declare class WorkerMessageService extends WorkerMessageService_base {
+    /**
+     * Creates a new WorkerMessageService instance with bidirectional communication
+     *
+     * @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 for both client and host.
+     *
+     * This method sets up message listeners for both sending and receiving messages.
+     * If a worker was previously initialized, it cleans up the old connections before
+     * establishing new ones. This allows for dynamic worker management.
+     *
+     * @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 service = new WorkerMessageService(oldWorker);
+     * service.initialize(newWorker); // Cleans up old listeners, sets up new ones
+     *
+     * @example
+     * // Re-initialize after worker error
+     * worker.onerror = () => {
+     *   service.initialize(new Worker('./worker.js'));
+     * };
+     */
+    initialize: (worker: ClientWorkerArg) => void;
 }
 export {};

package/worker/message-service.js

@@ -1,10 +1,121 @@
 import { mixin } from "@thalesrc/js-utils/class/mixin";
 import { WorkerMessageClient } from "./message-client";
 import { WorkerMessageHost } from "./message-host";
+/**
+ * WorkerMessageService
+ *
+ * Bidirectional communication service for Web Workers that combines both client and host
+ * capabilities. This class extends both WorkerMessageClient and WorkerMessageHost through
+ * mixin composition, enabling full duplex communication - it can both send messages and
+ * respond to incoming requests simultaneously.
+ *
+ * This class is useful when you need a single instance to handle both:
+ * - **Sending messages**: Using the @Request decorator to call methods on the other side
+ * - **Receiving messages**: Using the @Response decorator to handle incoming requests
+ *
+ * Like its parent classes, this can be used in two contexts:
+ * - **Main thread**: Provide a Worker instance for bidirectional communication with that worker
+ * - **Worker thread**: Omit the worker parameter for bidirectional communication with main thread
+ *
+ * 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)
+ *
+ * @example
+ * // In main thread - full duplex communication with worker
+ * const worker = new Worker('./worker.js');
+ * const service = new WorkerMessageService(worker);
+ *
+ * class MainAPI extends WorkerMessageService {
+ *   // Send messages to worker
+ *   @Request()
+ *   fetchData(): Observable<Data> {
+ *     return null!;
+ *   }
+ *
+ *   // Respond to worker requests
+ *   @Listen()
+ *   saveToLocalStorage(data: any) {
+ *     localStorage.setItem('data', JSON.stringify(data));
+ *     return [];
+ *   }
+ * }
+ *
+ * @example
+ * // In worker thread - full duplex communication with main thread
+ * const service = new WorkerMessageService();
+ *
+ * class WorkerAPI extends WorkerMessageService {
+ *   // Respond to main thread requests
+ *   @Listen()
+ *   fetchData() {
+ *     return from(fetch('/api/data').then(r => r.json()));
+ *   }
+ *
+ *   // Send messages to main thread
+ *   @Request()
+ *   saveToLocalStorage(data: any): Observable<void> {
+ *     return null!;
+ *   }
+ * }
+ *
+ * @example
+ * // With async worker initialization
+ * const workerPromise = import('./worker.js').then(m => new m.MyWorker());
+ * const service = new WorkerMessageService(workerPromise);
+ *
+ * @example
+ * // Re-initialize with a different worker
+ * const service = new WorkerMessageService();
+ * // Later, switch to a different worker
+ * service.initialize(new Worker('./different-worker.js'));
+ */
 export class WorkerMessageService extends mixin(WorkerMessageHost, WorkerMessageClient) {
+    /**
+     * Creates a new WorkerMessageService instance with bidirectional communication
+     *
+     * @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([worker], [worker]);
+        this.initialize(worker);
     }
+    /**
+     * Initializes or re-initializes the worker connection for both client and host.
+     *
+     * This method sets up message listeners for both sending and receiving messages.
+     * If a worker was previously initialized, it cleans up the old connections before
+     * establishing new ones. This allows for dynamic worker management.
+     *
+     * @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 service = new WorkerMessageService(oldWorker);
+     * service.initialize(newWorker); // Cleans up old listeners, sets up new ones
+     *
+     * @example
+     * // Re-initialize after worker error
+     * worker.onerror = () => {
+     *   service.initialize(new Worker('./worker.js'));
+     * };
+     */
+    initialize = (worker) => {
+        WorkerMessageHost.prototype.initialize.call(this, worker);
+        WorkerMessageClient.prototype.initialize.call(this, worker);
+    };
 }
 
 //# sourceMappingURL=message-service.js.map

package/worker/message-service.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../libs/hermes/src/worker/message-service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAC;AACvD,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAEnD,MAAM,OAAO,oBAAqB,SAAQ,KAAK,CAAC,iBAAiB,EAAE,mBAAmB,CAAC;IACrF,YAAY,MAAe;QACzB,KAAK,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC;IAC5B,CAAC;CACF","file":"message-service.js","sourcesContent":["import { mixin } from \"@thalesrc/js-utils/class/mixin\";\nimport { WorkerMessageClient } from \"./message-client\";\nimport { WorkerMessageHost } from \"./message-host\";\n\nexport class WorkerMessageService extends mixin(WorkerMessageHost, WorkerMessageClient) {\n  constructor(worker?: Worker) {\n    super([worker], [worker]);\n  }\n}\n"]}
+{"version":3,"sources":["../../../../../libs/hermes/src/worker/message-service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAC;AACvD,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAGnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AACH,MAAM,OAAO,oBAAqB,SAAQ,KAAK,CAAC,iBAAiB,EAAE,mBAAmB,CAAC;IACrF;;;;;;;;;OASG;IACH,YAAY,MAAe;QACzB,KAAK,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC;QAE1B,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;IAC1B,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACa,UAAU,GAAG,CAAC,MAAuB,EAAQ,EAAE;QAC7D,iBAAiB,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAC1D,mBAAmB,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IAC9D,CAAC,CAAC;CACH","file":"message-service.js","sourcesContent":["import { mixin } from \"@thalesrc/js-utils/class/mixin\";\nimport { WorkerMessageClient } from \"./message-client\";\nimport { WorkerMessageHost } from \"./message-host\";\nimport { ClientWorkerArg } from \"./initializer\";\n\n/**\n * WorkerMessageService\n *\n * Bidirectional communication service for Web Workers that combines both client and host\n * capabilities. This class extends both WorkerMessageClient and WorkerMessageHost through\n * mixin composition, enabling full duplex communication - it can both send messages and\n * respond to incoming requests simultaneously.\n *\n * This class is useful when you need a single instance to handle both:\n * - **Sending messages**: Using the @Request decorator to call methods on the other side\n * - **Receiving messages**: Using the @Response decorator to handle incoming requests\n *\n * Like its parent classes, this can be used in two contexts:\n * - **Main thread**: Provide a Worker instance for bidirectional communication with that worker\n * - **Worker thread**: Omit the worker parameter for bidirectional communication with main thread\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 * @example\n * // In main thread - full duplex communication with worker\n * const worker = new Worker('./worker.js');\n * const service = new WorkerMessageService(worker);\n *\n * class MainAPI extends WorkerMessageService {\n *   // Send messages to worker\n *   @Request()\n *   fetchData(): Observable<Data> {\n *     return null!;\n *   }\n *\n *   // Respond to worker requests\n *   @Listen()\n *   saveToLocalStorage(data: any) {\n *     localStorage.setItem('data', JSON.stringify(data));\n *     return [];\n *   }\n * }\n *\n * @example\n * // In worker thread - full duplex communication with main thread\n * const service = new WorkerMessageService();\n *\n * class WorkerAPI extends WorkerMessageService {\n *   // Respond to main thread requests\n *   @Listen()\n *   fetchData() {\n *     return from(fetch('/api/data').then(r => r.json()));\n *   }\n *\n *   // Send messages to main thread\n *   @Request()\n *   saveToLocalStorage(data: any): Observable<void> {\n *     return null!;\n *   }\n * }\n *\n * @example\n * // With async worker initialization\n * const workerPromise = import('./worker.js').then(m => new m.MyWorker());\n * const service = new WorkerMessageService(workerPromise);\n *\n * @example\n * // Re-initialize with a different worker\n * const service = new WorkerMessageService();\n * // Later, switch to a different worker\n * service.initialize(new Worker('./different-worker.js'));\n */\nexport class WorkerMessageService extends mixin(WorkerMessageHost, WorkerMessageClient) {\n  /**\n   * Creates a new WorkerMessageService instance with bidirectional communication\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?: Worker) {\n    super([worker], [worker]);\n\n    this.initialize(worker);\n  }\n\n  /**\n   * Initializes or re-initializes the worker connection for both client and host.\n   *\n   * This method sets up message listeners for both sending and receiving messages.\n   * If a worker was previously initialized, it cleans up the old connections before\n   * establishing new ones. This allows for dynamic worker management.\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 service = new WorkerMessageService(oldWorker);\n   * service.initialize(newWorker); // Cleans up old listeners, sets up new ones\n   *\n   * @example\n   * // Re-initialize after worker error\n   * worker.onerror = () => {\n   *   service.initialize(new Worker('./worker.js'));\n   * };\n   */\n  public override initialize = (worker: ClientWorkerArg): void => {\n    WorkerMessageHost.prototype.initialize.call(this, worker);\n    WorkerMessageClient.prototype.initialize.call(this, worker);\n  };\n}\n"]}