@thalesrc/hermes 0.0.0

package/worker/message-client.js

@@ -0,0 +1,172 @@
+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";
+/**
+ * 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();
+    /**
+     * 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.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) {
+        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);
+    }
+    /**
+     * 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.#instanceId);
+    }
+}
+
+//# sourceMappingURL=message-client.js.map

package/worker/message-client.js.map

@@ -0,0 +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"]}

package/worker/message-host.cjs

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerMessageHost = void 0;
+const rxjs_1 = require("rxjs");
+const message_host_1 = require("../message-host");
+const selectors_1 = require("../selectors");
+class WorkerMessageHost extends message_host_1.MessageHost {
+    #requests$ = new rxjs_1.Subject();
+    #worker;
+    constructor(worker) {
+        super();
+        if (worker) {
+            this.#worker = worker;
+            worker.addEventListener('message', this.#handler);
+        }
+        else {
+            addEventListener('message', this.#handler);
+        }
+        this[selectors_1.LISTEN](this.#requests$);
+    }
+    [selectors_1.RESPONSE](message) {
+        if (this.#worker) {
+            this.#worker.postMessage(message);
+        }
+        else {
+            postMessage(message);
+        }
+    }
+    terminate() {
+        if (this.#worker) {
+            this.#worker.removeEventListener('message', this.#handler);
+        }
+        else {
+            removeEventListener('message', this.#handler);
+        }
+    }
+    #handler = (event) => {
+        this.#requests$.next(event.data);
+    };
+}
+exports.WorkerMessageHost = WorkerMessageHost;

package/worker/message-host.d.ts

@@ -0,0 +1,9 @@
+import { MessageHost } from "../message-host";
+import { MessageResponse } from "../message-response.type";
+import { RESPONSE } from "../selectors";
+export declare class WorkerMessageHost extends MessageHost {
+    #private;
+    constructor(worker?: Worker);
+    protected [RESPONSE](message: MessageResponse): void;
+    terminate(): void;
+}

package/worker/message-host.js

@@ -0,0 +1,39 @@
+import { Subject } from "rxjs";
+import { MessageHost } from "../message-host";
+import { LISTEN, RESPONSE } from "../selectors";
+export class WorkerMessageHost extends MessageHost {
+    #requests$ = new Subject();
+    #worker;
+    constructor(worker) {
+        super();
+        if (worker) {
+            this.#worker = worker;
+            worker.addEventListener('message', this.#handler);
+        }
+        else {
+            addEventListener('message', this.#handler);
+        }
+        this[LISTEN](this.#requests$);
+    }
+    [RESPONSE](message) {
+        if (this.#worker) {
+            this.#worker.postMessage(message);
+        }
+        else {
+            postMessage(message);
+        }
+    }
+    terminate() {
+        if (this.#worker) {
+            this.#worker.removeEventListener('message', this.#handler);
+        }
+        else {
+            removeEventListener('message', this.#handler);
+        }
+    }
+    #handler = (event) => {
+        this.#requests$.next(event.data);
+    };
+}
+
+//# sourceMappingURL=message-host.js.map

package/worker/message-host.js.map

@@ -0,0 +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"]}

package/worker/message-service.cjs

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+class WorkerMessageService extends (0, mixin_1.mixin)(message_host_1.WorkerMessageHost, message_client_1.WorkerMessageClient) {
+    constructor(worker) {
+        super([worker], [worker]);
+    }
+}
+exports.WorkerMessageService = WorkerMessageService;

package/worker/message-service.d.ts

@@ -0,0 +1,8 @@
+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>)]) => {
+    terminate: () => void;
+} & WorkerMessageClient;
+export declare class WorkerMessageService extends WorkerMessageService_base {
+    constructor(worker?: Worker);
+}
+export {};

package/worker/message-service.js

@@ -0,0 +1,10 @@
+import { mixin } from "@thalesrc/js-utils/class/mixin";
+import { WorkerMessageClient } from "./message-client";
+import { WorkerMessageHost } from "./message-host";
+export class WorkerMessageService extends mixin(WorkerMessageHost, WorkerMessageClient) {
+    constructor(worker) {
+        super([worker], [worker]);
+    }
+}
+
+//# sourceMappingURL=message-service.js.map

package/worker/message-service.js.map

@@ -0,0 +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"]}