@thalesrc/hermes 7.3.0 → 7.5.1

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"]}