@telperion/messenger 7.6.1

package/selectors.js

@@ -0,0 +1,9 @@
+export const MESSAGE_LISTENERS = Symbol('Message Listeners');
+export const RESPONSES$ = Symbol('Responses');
+export const SEND = Symbol('Send');
+export const GET_NEW_ID = Symbol('Get New Id');
+export const LISTEN = Symbol('Listen');
+export const TERMINATE_MESSAGE$ = Symbol('Terminate Message');
+export const RESPONSE = Symbol('Response');
+
+//# sourceMappingURL=selectors.js.map

package/selectors.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../libs/messenger/src/selectors.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,iBAAiB,GAAG,MAAM,CAAC,mBAAmB,CAAC,CAAC;AAC7D,MAAM,CAAC,MAAM,UAAU,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;AAC9C,MAAM,CAAC,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;AACnC,MAAM,CAAC,MAAM,UAAU,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC;AAC/C,MAAM,CAAC,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;AACvC,MAAM,CAAC,MAAM,kBAAkB,GAAG,MAAM,CAAC,mBAAmB,CAAC,CAAC;AAC9D,MAAM,CAAC,MAAM,QAAQ,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC","file":"selectors.js","sourcesContent":["export const MESSAGE_LISTENERS = Symbol('Message Listeners');\nexport const RESPONSES$ = Symbol('Responses');\nexport const SEND = Symbol('Send');\nexport const GET_NEW_ID = Symbol('Get New Id');\nexport const LISTEN = Symbol('Listen');\nexport const TERMINATE_MESSAGE$ = Symbol('Terminate Message');\nexport const RESPONSE = Symbol('Response');\n"]}

package/worker/index.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+Object.defineProperty(exports, "Listen", { enumerable: true, get: function () { return listen_decorator_1.Listen; } });

package/worker/index.d.ts

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

@@ -0,0 +1,7 @@
+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';
+
+//# sourceMappingURL=index.js.map

package/worker/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../libs/messenger/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/initializer.cjs

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializer = initializer;
+const noop_1 = require("@telperion/js-utils/function/noop");
+const promisify_1 = require("@telperion/js-utils/promise/promisify");
+/**
+ * Initializes a Web Worker or the worker context for message communication.
+ * @param prevWorker The previous worker promise to deinitialize
+ * @param worker The new worker argument (Worker instance, promise, or factory function)
+ * @param handler The message event handler to attach
+ * @returns A promise resolving to the initialized Worker or undefined if in worker context
+ */
+function initializer(prevWorker, worker, handler) {
+    // Deinitialize previous worker if any
+    prevWorker.then(pw => {
+        if (pw) {
+            pw.removeEventListener('message', handler);
+        }
+        else {
+            removeEventListener('message', 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
+    const newWorker = (0, promisify_1.promisify)(_worker);
+    // Set up message listener once worker is resolved
+    newWorker.then(worker => {
+        if (worker) {
+            // Main thread context: listen to specific worker
+            worker.addEventListener('message', handler);
+        }
+        else {
+            // Worker thread context: listen to messages from main thread
+            addEventListener('message', handler);
+        }
+    }).catch(noop_1.noop);
+    return newWorker;
+}

package/worker/initializer.d.ts

@@ -0,0 +1,12 @@
+export type ClientWorkerType = Worker | undefined;
+export type ClientWorkerPromise = Promise<ClientWorkerType>;
+export type ClientWorkerFactory = () => ClientWorkerType | ClientWorkerPromise;
+export type ClientWorkerArg = ClientWorkerType | ClientWorkerPromise | ClientWorkerFactory;
+/**
+ * Initializes a Web Worker or the worker context for message communication.
+ * @param prevWorker The previous worker promise to deinitialize
+ * @param worker The new worker argument (Worker instance, promise, or factory function)
+ * @param handler The message event handler to attach
+ * @returns A promise resolving to the initialized Worker or undefined if in worker context
+ */
+export declare function initializer(prevWorker: ClientWorkerPromise, worker: ClientWorkerArg, handler: (event: MessageEvent) => void): Promise<Worker | undefined>;

package/worker/initializer.js

@@ -0,0 +1,38 @@
+import { noop } from "@telperion/js-utils/function/noop";
+import { promisify } from "@telperion/js-utils/promise/promisify";
+/**
+ * Initializes a Web Worker or the worker context for message communication.
+ * @param prevWorker The previous worker promise to deinitialize
+ * @param worker The new worker argument (Worker instance, promise, or factory function)
+ * @param handler The message event handler to attach
+ * @returns A promise resolving to the initialized Worker or undefined if in worker context
+ */
+export function initializer(prevWorker, worker, handler) {
+    // Deinitialize previous worker if any
+    prevWorker.then(pw => {
+        if (pw) {
+            pw.removeEventListener('message', handler);
+        }
+        else {
+            removeEventListener('message', 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
+    const newWorker = promisify(_worker);
+    // Set up message listener once worker is resolved
+    newWorker.then(worker => {
+        if (worker) {
+            // Main thread context: listen to specific worker
+            worker.addEventListener('message', handler);
+        }
+        else {
+            // Worker thread context: listen to messages from main thread
+            addEventListener('message', handler);
+        }
+    }).catch(noop);
+    return newWorker;
+}
+
+//# sourceMappingURL=initializer.js.map

package/worker/initializer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../libs/messenger/src/worker/initializer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,mCAAmC,CAAC;AACzD,OAAO,EAAE,SAAS,EAAE,MAAM,uCAAuC,CAAC;AAOlE;;;;;;GAMG;AACH,MAAM,UAAU,WAAW,CACzB,UAA+B,EAC/B,MAAuB,EACvB,OAAsC;IAEtC,sCAAsC;IACtC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE;QACnB,IAAI,EAAE,EAAE,CAAC;YACP,EAAE,CAAC,mBAAmB,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;QAC7C,CAAC;aAAM,CAAC;YACN,mBAAmB,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;QAC1C,CAAC;IACH,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAEf,uFAAuF;IACvF,MAAM,OAAO,GAAuD,OAAO,MAAM,KAAK,UAAU,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC;IACrH,sEAAsE;IACtE,MAAM,SAAS,GAAG,SAAS,CAAC,OAAO,CAAC,CAAC;IAErC,kDAAkD;IAClD,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE;QACtB,IAAI,MAAM,EAAE,CAAC;YACX,iDAAiD;YACjD,MAAM,CAAC,gBAAgB,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;QAC9C,CAAC;aAAM,CAAC;YACN,6DAA6D;YAC7D,gBAAgB,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;QACvC,CAAC;IACH,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAEf,OAAO,SAAS,CAAC;AACnB,CAAC","file":"initializer.js","sourcesContent":["import { noop } from \"@telperion/js-utils/function/noop\";\nimport { promisify } from \"@telperion/js-utils/promise/promisify\";\n\nexport type ClientWorkerType = Worker | undefined;\nexport type ClientWorkerPromise = Promise<ClientWorkerType>;\nexport type ClientWorkerFactory = () => ClientWorkerType | ClientWorkerPromise;\nexport type ClientWorkerArg = ClientWorkerType | ClientWorkerPromise | ClientWorkerFactory;\n\n/**\n * Initializes a Web Worker or the worker context for message communication.\n * @param prevWorker The previous worker promise to deinitialize\n * @param worker The new worker argument (Worker instance, promise, or factory function)\n * @param handler The message event handler to attach\n * @returns A promise resolving to the initialized Worker or undefined if in worker context\n */\nexport function initializer(\n  prevWorker: ClientWorkerPromise,\n  worker: ClientWorkerArg,\n  handler: (event: MessageEvent) => void\n) {\n  // Deinitialize previous worker if any\n  prevWorker.then(pw => {\n    if (pw) {\n      pw.removeEventListener('message', handler);\n    } else {\n      removeEventListener('message', 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  const newWorker = promisify(_worker);\n\n  // Set up message listener once worker is resolved\n  newWorker.then(worker => {\n    if (worker) {\n      // Main thread context: listen to specific worker\n      worker.addEventListener('message', handler);\n    } else {\n      // Worker thread context: listen to messages from main thread\n      addEventListener('message', handler);\n    }\n  }).catch(noop);\n\n  return newWorker;\n}\n"]}

package/worker/message-client.cjs

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerMessageClient = void 0;
+const unique_id_1 = require("@telperion/js-utils/unique-id");
+const noop_1 = require("@telperion/js-utils/function/noop");
+const rxjs_1 = require("rxjs");
+const message_client_1 = require("../message-client");
+const selectors_1 = require("../selectors");
+const initializer_1 = require("./initializer");
+const WORKER = Symbol('Client Worker');
+const HANDLER = Symbol('Client Message Handler');
+const INSTANCE_ID = Symbol('Client 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
+     */
+    [INSTANCE_ID] = '' + Math.floor(Math.random() * 10000);
+    /**
+     * Observable stream of message responses from the worker or main thread
+     */
+    [selectors_1.RESPONSES$] = new rxjs_1.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) {
+        // Ensure WORKER is initialized if not already
+        if (!this[WORKER]) {
+            this[WORKER] = Promise.resolve(undefined);
+        }
+        this[WORKER] = (0, initializer_1.initializer)(this[WORKER], worker, this[HANDLER]);
+    }
+    /**
+     * 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) {
+        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);
+    }
+    /**
+     * 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, unique_id_1.uniqueId)('messenger-worker-message-' + this[INSTANCE_ID]);
+    }
+}
+exports.WorkerMessageClient = WorkerMessageClient;

package/worker/message-client.d.ts

@@ -0,0 +1,131 @@
+import { Subject } from "rxjs";
+import { MessageClient } from "../message-client";
+import { MessageResponse } from "../message-response.type";
+import { Message } from "../message.interface";
+import { GET_NEW_ID, RESPONSES$, SEND } from "../selectors";
+import { ClientWorkerArg } from "./initializer";
+declare const WORKER: unique symbol;
+declare const HANDLER: unique symbol;
+declare const INSTANCE_ID: unique symbol;
+/**
+ * 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 {
+    /**
+     * Promise resolving to the Worker instance or undefined if running in worker context
+     * @private
+     */
+    private [WORKER];
+    /**
+     * Unique identifier for this client instance to prevent ID collisions
+     * @private
+     */
+    private [INSTANCE_ID];
+    /**
+     * Observable stream of message responses from the worker or main thread
+     */
+    [RESPONSES$]: Subject<MessageResponse>;
+    /**
+     * 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;
+    /**
+     * Handles incoming messages and forwards them to the responses stream
+     * @private
+     */
+    private [HANDLER];
+    /**
+     * 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

@@ -0,0 +1,156 @@
+import { uniqueId } from "@telperion/js-utils/unique-id";
+import { noop } from "@telperion/js-utils/function/noop";
+import { Subject } from "rxjs";
+import { MessageClient } from "../message-client";
+import { GET_NEW_ID, RESPONSES$, SEND } from "../selectors";
+import { initializer } from "./initializer";
+const WORKER = Symbol('Client Worker');
+const HANDLER = Symbol('Client Message Handler');
+const INSTANCE_ID = Symbol('Client Instance ID');
+/**
+ * WorkerMessageClient
+ *
+ * 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
+     */
+    [INSTANCE_ID] = '' + Math.floor(Math.random() * 10000);
+    /**
+     * 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) {
+        // Ensure WORKER is initialized if not already
+        if (!this[WORKER]) {
+            this[WORKER] = Promise.resolve(undefined);
+        }
+        this[WORKER] = initializer(this[WORKER], worker, this[HANDLER]);
+    }
+    /**
+     * Sends a message to the worker or main thread
+     *
+     * @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('messenger-worker-message-' + this[INSTANCE_ID]);
+    }
+}
+
+//# sourceMappingURL=message-client.js.map

package/worker/message-client.js.map

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