@aztec/foundation 0.0.0-test.0

package/dest/timer/timeout.d.ts

@@ -0,0 +1,41 @@
+/**
+ * TimeoutTask class creates an instance for managing and executing a given asynchronous function with a specified timeout duration.
+ * The task will be automatically interrupted if it exceeds the given timeout duration, and will throw a custom error message.
+ * Additional information such as execution time can be retrieved using getTime method after the task has been executed.
+ *
+ * @typeparam T - The return type of the asynchronous function to be executed.
+ */
+export declare class TimeoutTask<T> {
+    private fn;
+    private timeout;
+    private interruptPromise;
+    private interrupt;
+    private totalTime;
+    constructor(fn: () => Promise<T>, timeout: number, errorFn: () => any);
+    /**
+     * Executes the given function with a specified timeout.
+     * If the function takes longer than the timeout, it will be interrupted and an error will be thrown.
+     * The total execution time of the function will be stored in the totalTime property.
+     *
+     * @returns The result of the executed function if completed within the timeout.
+     * @throws An error with a message indicating the function was interrupted due to exceeding the specified timeout.
+     */
+    exec(): Promise<T>;
+    /**
+     * Returns the interrupt promise associated with the TimeoutTask instance.
+     * The interrupt promise is used internally to reject the task when a timeout occurs.
+     * This method can be helpful when debugging or tracking the state of the task.
+     *
+     * @returns The interrupt promise associated with the task.
+     */
+    getInterruptPromise(): Promise<any>;
+    /**
+     * Get the total time spent on the most recent execution of the wrapped function.
+     * This method provides the duration from the start to the end of the function execution, whether it completed or timed out.
+     *
+     * @returns The total time in milliseconds spent on the most recent function execution.
+     */
+    getTime(): number;
+}
+export declare function executeTimeout<T>(fn: () => Promise<T>, timeout: number, errorOrFnName?: string | (() => any)): Promise<T>;
+//# sourceMappingURL=timeout.d.ts.map

package/dest/timer/timeout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeout.d.ts","sourceRoot":"","sources":["../../src/timer/timeout.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,qBAAa,WAAW,CAAC,CAAC;IAKZ,OAAO,CAAC,EAAE;IAAoB,OAAO,CAAC,OAAO;IAJzD,OAAO,CAAC,gBAAgB,CAAgB;IACxC,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,SAAS,CAAK;gBAEF,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAU,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG;IAMrF;;;;;;;OAOG;IACU,IAAI;IAYjB;;;;;;OAMG;IACI,mBAAmB;IAI1B;;;;;OAKG;IACI,OAAO;CAGf;AAED,wBAAsB,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,CAAC,MAAM,GAAG,CAAC,cAOlH"}

package/dest/timer/timeout.js

@@ -0,0 +1,66 @@
+import { TimeoutError } from '../error/index.js';
+/**
+ * TimeoutTask class creates an instance for managing and executing a given asynchronous function with a specified timeout duration.
+ * The task will be automatically interrupted if it exceeds the given timeout duration, and will throw a custom error message.
+ * Additional information such as execution time can be retrieved using getTime method after the task has been executed.
+ *
+ * @typeparam T - The return type of the asynchronous function to be executed.
+ */ export class TimeoutTask {
+    fn;
+    timeout;
+    interruptPromise;
+    interrupt;
+    totalTime;
+    constructor(fn, timeout, errorFn){
+        this.fn = fn;
+        this.timeout = timeout;
+        this.interrupt = ()=>{};
+        this.totalTime = 0;
+        this.interruptPromise = new Promise((_, reject)=>{
+            this.interrupt = ()=>reject(errorFn());
+        });
+    }
+    /**
+   * Executes the given function with a specified timeout.
+   * If the function takes longer than the timeout, it will be interrupted and an error will be thrown.
+   * The total execution time of the function will be stored in the totalTime property.
+   *
+   * @returns The result of the executed function if completed within the timeout.
+   * @throws An error with a message indicating the function was interrupted due to exceeding the specified timeout.
+   */ async exec() {
+        const interruptTimeout = setTimeout(this.interrupt, this.timeout);
+        try {
+            const start = Date.now();
+            const result = await Promise.race([
+                this.fn(),
+                this.interruptPromise
+            ]);
+            this.totalTime = Date.now() - start;
+            return result;
+        } finally{
+            clearTimeout(interruptTimeout);
+        }
+    }
+    /**
+   * Returns the interrupt promise associated with the TimeoutTask instance.
+   * The interrupt promise is used internally to reject the task when a timeout occurs.
+   * This method can be helpful when debugging or tracking the state of the task.
+   *
+   * @returns The interrupt promise associated with the task.
+   */ getInterruptPromise() {
+        return this.interruptPromise;
+    }
+    /**
+   * Get the total time spent on the most recent execution of the wrapped function.
+   * This method provides the duration from the start to the end of the function execution, whether it completed or timed out.
+   *
+   * @returns The total time in milliseconds spent on the most recent function execution.
+   */ getTime() {
+        return this.totalTime;
+    }
+}
+export async function executeTimeout(fn, timeout, errorOrFnName) {
+    const errorFn = typeof errorOrFnName === 'function' ? errorOrFnName : ()=>new TimeoutError(`Timeout running ${errorOrFnName ?? 'function'} after ${timeout}ms.`);
+    const task = new TimeoutTask(fn, timeout, errorFn);
+    return await task.exec();
+}

package/dest/timer/timer.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Timer class to measure time intervals in milliseconds and seconds.
+ * Upon instantiation, it stores the current timestamp as the starting point.
+ * The 'ms()' method returns the elapsed time in milliseconds,
+ * while the 's()' method returns the elapsed time in seconds.
+ *
+ * @example
+ * const timer = new Timer();
+ * setTimeout(() =\> \{
+ *   console.log(`Elapsed time: ${timer.ms()} ms`);
+ * \}, 1000);
+ */
+export declare class Timer {
+    private start;
+    constructor();
+    /**
+     * Return microseconds.
+     */
+    us(): number;
+    /**
+     * Returns the elapsed time in milliseconds since the Timer instance was created.
+     * Provides a simple and convenient way to measure the time duration between two events
+     * or monitor performance of specific code sections.
+     *
+     * @returns The elapsed time in milliseconds.
+     */
+    ms(): number;
+    /**
+     * Returns the time elapsed since the Timer instance was created, in seconds.
+     * The value is calculated by subtracting the initial start time from the current time
+     * and dividing the result by 1000 to convert milliseconds to seconds.
+     *
+     * @returns The elapsed time in seconds.
+     */
+    s(): number;
+}
+//# sourceMappingURL=timer.d.ts.map

package/dest/timer/timer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer.d.ts","sourceRoot":"","sources":["../../src/timer/timer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,qBAAa,KAAK;IAChB,OAAO,CAAC,KAAK,CAAS;;IAMtB;;OAEG;IACI,EAAE;IAIT;;;;;;OAMG;IACI,EAAE;IAIT;;;;;;OAMG;IACI,CAAC;CAGT"}

package/dest/timer/timer.js

@@ -0,0 +1,40 @@
+/**
+ * Timer class to measure time intervals in milliseconds and seconds.
+ * Upon instantiation, it stores the current timestamp as the starting point.
+ * The 'ms()' method returns the elapsed time in milliseconds,
+ * while the 's()' method returns the elapsed time in seconds.
+ *
+ * @example
+ * const timer = new Timer();
+ * setTimeout(() =\> \{
+ *   console.log(`Elapsed time: ${timer.ms()} ms`);
+ * \}, 1000);
+ */ export class Timer {
+    start;
+    constructor(){
+        this.start = performance ? performance.now() : Date.now();
+    }
+    /**
+   * Return microseconds.
+   */ us() {
+        return this.ms() * 1000;
+    }
+    /**
+   * Returns the elapsed time in milliseconds since the Timer instance was created.
+   * Provides a simple and convenient way to measure the time duration between two events
+   * or monitor performance of specific code sections.
+   *
+   * @returns The elapsed time in milliseconds.
+   */ ms() {
+        return (performance ? performance.now() : Date.now()) - this.start;
+    }
+    /**
+   * Returns the time elapsed since the Timer instance was created, in seconds.
+   * The value is calculated by subtracting the initial start time from the current time
+   * and dividing the result by 1000 to convert milliseconds to seconds.
+   *
+   * @returns The elapsed time in seconds.
+   */ s() {
+        return this.ms() / 1000;
+    }
+}

package/dest/transport/browser/index.d.ts

@@ -0,0 +1,5 @@
+export * from './worker_connector.js';
+export * from './worker_listener.js';
+export * from './shared_worker_connector.js';
+export * from './shared_worker_listener.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/transport/browser/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/transport/browser/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC"}

package/dest/transport/browser/index.js

@@ -0,0 +1,4 @@
+export * from './worker_connector.js';
+export * from './worker_listener.js';
+export * from './shared_worker_connector.js';
+export * from './shared_worker_listener.js';

package/dest/transport/browser/message_port_socket.d.ts

@@ -0,0 +1,37 @@
+import type { Socket } from '../interface/socket.js';
+/**
+ * An implementation of a TransportSocket using MessagePorts.
+ */
+export declare class MessagePortSocket implements Socket {
+    private port;
+    constructor(port: MessagePort);
+    /**
+     * Send a message to the connected MessagePort, optionally transferring ownership of certain objects.
+     * The 'msg' parameter can be any structured data type and will be sent to the other end of the MessagePort.
+     * The optional 'transfer' parameter is an array of Transferable objects whose ownership will be transferred,
+     * making them inaccessible on the sending side. This can improve performance for large data transfers.
+     *
+     * @param msg - The message to be sent through the MessagePort.
+     * @param transfer - An optional array of Transferable objects to transfer ownership.
+     * @returns A Promise that resolves when the message has been sent.
+     */
+    send(msg: any, transfer?: Transferable[]): Promise<void>;
+    /**
+     * Register a callback function to handle incoming messages from the MessagePort.
+     * The provided callback will be invoked with the message data whenever a new message arrives.
+     * Note that only one callback can be registered at a time. Subsequent calls to this method
+     * will overwrite the previously registered callback.
+     *
+     * @param cb - The callback function to handle incoming messages.
+     */
+    registerHandler(cb: (msg: any) => any): void;
+    /**
+     * Close the MessagePort, unregister the message handler, and send an undefined message.
+     * The 'close' function is useful for gracefully shutting down a connection between two
+     * endpoints by sending an undefined message as an indication of disconnection before
+     * closing the port. After calling this method, the MessagePortSocket instance should not
+     * be used again.
+     */
+    close(): void;
+}
+//# sourceMappingURL=message_port_socket.d.ts.map

package/dest/transport/browser/message_port_socket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message_port_socket.d.ts","sourceRoot":"","sources":["../../../src/transport/browser/message_port_socket.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAErD;;GAEG;AACH,qBAAa,iBAAkB,YAAW,MAAM;IAClC,OAAO,CAAC,IAAI;gBAAJ,IAAI,EAAE,WAAW;IAErC;;;;;;;;;OASG;IACH,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,GAAE,YAAY,EAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAK5D;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,GAAG,GAAG,IAAI;IAI5C;;;;;;OAMG;IACH,KAAK;CAKN"}

package/dest/transport/browser/message_port_socket.js

@@ -0,0 +1,42 @@
+/**
+ * An implementation of a TransportSocket using MessagePorts.
+ */ export class MessagePortSocket {
+    port;
+    constructor(port){
+        this.port = port;
+    }
+    /**
+   * Send a message to the connected MessagePort, optionally transferring ownership of certain objects.
+   * The 'msg' parameter can be any structured data type and will be sent to the other end of the MessagePort.
+   * The optional 'transfer' parameter is an array of Transferable objects whose ownership will be transferred,
+   * making them inaccessible on the sending side. This can improve performance for large data transfers.
+   *
+   * @param msg - The message to be sent through the MessagePort.
+   * @param transfer - An optional array of Transferable objects to transfer ownership.
+   * @returns A Promise that resolves when the message has been sent.
+   */ send(msg, transfer = []) {
+        this.port.postMessage(msg, transfer);
+        return Promise.resolve();
+    }
+    /**
+   * Register a callback function to handle incoming messages from the MessagePort.
+   * The provided callback will be invoked with the message data whenever a new message arrives.
+   * Note that only one callback can be registered at a time. Subsequent calls to this method
+   * will overwrite the previously registered callback.
+   *
+   * @param cb - The callback function to handle incoming messages.
+   */ registerHandler(cb) {
+        this.port.onmessage = (event)=>cb(event.data);
+    }
+    /**
+   * Close the MessagePort, unregister the message handler, and send an undefined message.
+   * The 'close' function is useful for gracefully shutting down a connection between two
+   * endpoints by sending an undefined message as an indication of disconnection before
+   * closing the port. After calling this method, the MessagePortSocket instance should not
+   * be used again.
+   */ close() {
+        void this.send(undefined);
+        this.port.onmessage = null;
+        this.port.close();
+    }
+}

package/dest/transport/browser/shared_worker_connector.d.ts

@@ -0,0 +1,19 @@
+import type { Connector } from '../interface/connector.js';
+import { MessagePortSocket } from './message_port_socket.js';
+/**
+ * SharedWorkerConnector is an implementation of the Connector interface, specifically for SharedWorkers.
+ * It enables the creation of MessagePortSockets that communicate with a shared worker and allow
+ * multiple scripts to communicate with the worker using the same connection.
+ */
+export declare class SharedWorkerConnector implements Connector {
+    private worker;
+    constructor(worker: SharedWorker);
+    /**
+     * Creates a new MessagePortSocket instance using the SharedWorker's port.
+     * This method allows for easy creation of sockets to communicate with the SharedWorker.
+     *
+     * @returns A Promise that resolves to a new MessagePortSocket instance.
+     */
+    createSocket(): Promise<MessagePortSocket>;
+}
+//# sourceMappingURL=shared_worker_connector.d.ts.map

package/dest/transport/browser/shared_worker_connector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared_worker_connector.d.ts","sourceRoot":"","sources":["../../../src/transport/browser/shared_worker_connector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D;;;;GAIG;AACH,qBAAa,qBAAsB,YAAW,SAAS;IACzC,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,YAAY;IAExC;;;;;OAKG;IACH,YAAY;CAGb"}

package/dest/transport/browser/shared_worker_connector.js

@@ -0,0 +1,19 @@
+import { MessagePortSocket } from './message_port_socket.js';
+/**
+ * SharedWorkerConnector is an implementation of the Connector interface, specifically for SharedWorkers.
+ * It enables the creation of MessagePortSockets that communicate with a shared worker and allow
+ * multiple scripts to communicate with the worker using the same connection.
+ */ export class SharedWorkerConnector {
+    worker;
+    constructor(worker){
+        this.worker = worker;
+    }
+    /**
+   * Creates a new MessagePortSocket instance using the SharedWorker's port.
+   * This method allows for easy creation of sockets to communicate with the SharedWorker.
+   *
+   * @returns A Promise that resolves to a new MessagePortSocket instance.
+   */ createSocket() {
+        return Promise.resolve(new MessagePortSocket(this.worker.port));
+    }
+}

package/dest/transport/browser/shared_worker_listener.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="node" resolution-mode="require"/>
+import EventEmitter from 'events';
+import type { Listener } from '../interface/listener.js';
+/**
+ * Represents the global scope of a Shared Worker.
+ * Provides functionality to handle incoming connections and manage communication with other scripts
+ * running in a shared context, enabling concurrent access and efficient resource sharing among those scripts.
+ */
+declare interface SharedWorkerGlobalScope {
+    /**
+     * Event handler for new connections to the Shared Worker.
+     */
+    onconnect: (...args: any) => any;
+}
+/**
+ * SharedWorkerListener is an extension of the EventEmitter class that implements the Listener interface.
+ * It provides functionality to handle incoming messages from a shared worker and emit events for new sockets
+ * created in response to these incoming connections. This class is meant to be used in the context of managing
+ * MessagePort connections within the SharedWorkerGlobalScope.
+ */
+export declare class SharedWorkerListener extends EventEmitter implements Listener {
+    private worker;
+    constructor(worker: SharedWorkerGlobalScope);
+    /**
+     * Initializes the shared worker listener by assigning the 'handleMessageEvent' method as the event handler
+     * for the 'onconnect' event of the SharedWorkerGlobalScope. The 'handleMessageEvent' function will be called
+     * whenever a new connection is established with the shared worker.
+     */
+    open(): void;
+    /**
+     * Closes the SharedWorkerListener by detaching the 'onconnect' event handler.
+     * This stops the listener from emitting new sockets on incoming connections.
+     */
+    close(): void;
+    private handleMessageEvent;
+}
+export {};
+//# sourceMappingURL=shared_worker_listener.d.ts.map

package/dest/transport/browser/shared_worker_listener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared_worker_listener.d.ts","sourceRoot":"","sources":["../../../src/transport/browser/shared_worker_listener.ts"],"names":[],"mappings":";AAAA,OAAO,YAAY,MAAM,QAAQ,CAAC;AAElC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAGzD;;;;GAIG;AACH,OAAO,WAAW,uBAAuB;IACvC;;OAEG;IACH,SAAS,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,GAAG,CAAC;CAClC;AAED;;;;;GAKG;AACH,qBAAa,oBAAqB,SAAQ,YAAa,YAAW,QAAQ;IAC5D,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,uBAAuB;IAInD;;;;OAIG;IACH,IAAI;IAIJ;;;OAGG;IACH,KAAK;IAIL,OAAO,CAAC,kBAAkB,CAMxB;CACH"}

package/dest/transport/browser/shared_worker_listener.js

@@ -0,0 +1,33 @@
+import EventEmitter from 'events';
+import { MessagePortSocket } from './message_port_socket.js';
+/**
+ * SharedWorkerListener is an extension of the EventEmitter class that implements the Listener interface.
+ * It provides functionality to handle incoming messages from a shared worker and emit events for new sockets
+ * created in response to these incoming connections. This class is meant to be used in the context of managing
+ * MessagePort connections within the SharedWorkerGlobalScope.
+ */ export class SharedWorkerListener extends EventEmitter {
+    worker;
+    constructor(worker){
+        super(), this.worker = worker, this.handleMessageEvent = (event)=>{
+            const [port] = event.ports;
+            if (!port) {
+                return;
+            }
+            this.emit('new_socket', new MessagePortSocket(port));
+        };
+    }
+    /**
+   * Initializes the shared worker listener by assigning the 'handleMessageEvent' method as the event handler
+   * for the 'onconnect' event of the SharedWorkerGlobalScope. The 'handleMessageEvent' function will be called
+   * whenever a new connection is established with the shared worker.
+   */ open() {
+        this.worker.onconnect = this.handleMessageEvent;
+    }
+    /**
+   * Closes the SharedWorkerListener by detaching the 'onconnect' event handler.
+   * This stops the listener from emitting new sockets on incoming connections.
+   */ close() {
+        this.worker.onconnect = ()=>{};
+    }
+    handleMessageEvent;
+}

package/dest/transport/browser/worker_connector.d.ts

@@ -0,0 +1,26 @@
+import type { Connector } from '../interface/connector.js';
+import { MessagePortSocket } from './message_port_socket.js';
+/**
+ * WorkerConnector is a class implementing the Connector interface for creating communication sockets
+ * with Web Workers. It allows to establish a connection with the worker and create MessagePortSockets
+ * using MessageChannels, enabling seamless communication between the main thread and worker threads.
+ *
+ * @example
+ * const worker = new Worker('./myWorker.js');
+ * const connector = new WorkerConnector(worker);
+ * const socket = await connector.createSocket();
+ * socket.send('Hello, worker!');
+ */
+export declare class WorkerConnector implements Connector {
+    private worker;
+    constructor(worker: Worker);
+    /**
+     * Creates a new MessagePortSocket instance by establishing a connection between the Worker and the main thread.
+     * A MessageChannel is created, and one of its ports is sent to the Worker using postMessage.
+     * The other port is used to create a new MessagePortSocket which is then returned as a Promise.
+     *
+     * @returns A Promise that resolves to a new MessagePortSocket instance.
+     */
+    createSocket(): Promise<MessagePortSocket>;
+}
+//# sourceMappingURL=worker_connector.d.ts.map

package/dest/transport/browser/worker_connector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker_connector.d.ts","sourceRoot":"","sources":["../../../src/transport/browser/worker_connector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D;;;;;;;;;;GAUG;AACH,qBAAa,eAAgB,YAAW,SAAS;IACnC,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,MAAM;IAElC;;;;;;OAMG;IACH,YAAY;CAKb"}

package/dest/transport/browser/worker_connector.js

@@ -0,0 +1,30 @@
+import { MessagePortSocket } from './message_port_socket.js';
+/**
+ * WorkerConnector is a class implementing the Connector interface for creating communication sockets
+ * with Web Workers. It allows to establish a connection with the worker and create MessagePortSockets
+ * using MessageChannels, enabling seamless communication between the main thread and worker threads.
+ *
+ * @example
+ * const worker = new Worker('./myWorker.js');
+ * const connector = new WorkerConnector(worker);
+ * const socket = await connector.createSocket();
+ * socket.send('Hello, worker!');
+ */ export class WorkerConnector {
+    worker;
+    constructor(worker){
+        this.worker = worker;
+    }
+    /**
+   * Creates a new MessagePortSocket instance by establishing a connection between the Worker and the main thread.
+   * A MessageChannel is created, and one of its ports is sent to the Worker using postMessage.
+   * The other port is used to create a new MessagePortSocket which is then returned as a Promise.
+   *
+   * @returns A Promise that resolves to a new MessagePortSocket instance.
+   */ createSocket() {
+        const channel = new MessageChannel();
+        this.worker.postMessage('', [
+            channel.port2
+        ]);
+        return Promise.resolve(new MessagePortSocket(channel.port1));
+    }
+}

package/dest/transport/browser/worker_listener.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="node" resolution-mode="require"/>
+import EventEmitter from 'events';
+import type { Listener } from '../interface/listener.js';
+/**
+ * Represents a DedicatedWorkerGlobalScope, which is the global execution context for a dedicated worker.
+ * Provides properties and methods to manage the worker's lifecycle and communication with other threads or workers.
+ */
+declare interface DedicatedWorkerGlobalScope {
+    /**
+     * Handler for incoming messages from other threads or workers.
+     */
+    onmessage: any;
+}
+/**
+ * WorkerListener is a class that extends EventEmitter and implements the Listener interface.
+ * It listens for incoming connections on a dedicated worker global scope, and emits a 'new_socket' event
+ * with a MessagePortSocket instance for each new connection. This allows applications to communicate
+ * with other workers or main thread through the MessagePortSocket abstraction.
+ *
+ * The open() method starts listening for incoming connections, while the close() method stops it.
+ */
+export declare class WorkerListener extends EventEmitter implements Listener {
+    private worker;
+    constructor(worker: DedicatedWorkerGlobalScope);
+    /**
+     * Initializes the WorkerListener by setting the 'onmessage' event handler of the worker.
+     * The 'onmessage' event will be triggered when the worker receives a message, and it will then
+     * call the handleMessageEvent method to handle incoming connections.
+     */
+    open(): void;
+    /**
+     * Close the worker listener by removing the 'onmessage' event handler.
+     * This method effectively stops the WorkerListener from reacting to new incoming messages.
+     */
+    close(): void;
+    private handleMessageEvent;
+}
+export {};
+//# sourceMappingURL=worker_listener.d.ts.map

package/dest/transport/browser/worker_listener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker_listener.d.ts","sourceRoot":"","sources":["../../../src/transport/browser/worker_listener.ts"],"names":[],"mappings":";AAAA,OAAO,YAAY,MAAM,QAAQ,CAAC;AAElC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAGzD;;;GAGG;AACH,OAAO,WAAW,0BAA0B;IAC1C;;OAEG;IACH,SAAS,EAAE,GAAG,CAAC;CAChB;AAED;;;;;;;GAOG;AACH,qBAAa,cAAe,SAAQ,YAAa,YAAW,QAAQ;IACtD,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,0BAA0B;IAItD;;;;OAIG;IACH,IAAI;IAIJ;;;OAGG;IACH,KAAK;IAIL,OAAO,CAAC,kBAAkB,CAMxB;CACH"}

package/dest/transport/browser/worker_listener.js

@@ -0,0 +1,35 @@
+import EventEmitter from 'events';
+import { MessagePortSocket } from './message_port_socket.js';
+/**
+ * WorkerListener is a class that extends EventEmitter and implements the Listener interface.
+ * It listens for incoming connections on a dedicated worker global scope, and emits a 'new_socket' event
+ * with a MessagePortSocket instance for each new connection. This allows applications to communicate
+ * with other workers or main thread through the MessagePortSocket abstraction.
+ *
+ * The open() method starts listening for incoming connections, while the close() method stops it.
+ */ export class WorkerListener extends EventEmitter {
+    worker;
+    constructor(worker){
+        super(), this.worker = worker, this.handleMessageEvent = (event)=>{
+            const [port] = event.ports;
+            if (!port) {
+                return;
+            }
+            this.emit('new_socket', new MessagePortSocket(port));
+        };
+    }
+    /**
+   * Initializes the WorkerListener by setting the 'onmessage' event handler of the worker.
+   * The 'onmessage' event will be triggered when the worker receives a message, and it will then
+   * call the handleMessageEvent method to handle incoming connections.
+   */ open() {
+        this.worker.onmessage = this.handleMessageEvent;
+    }
+    /**
+   * Close the worker listener by removing the 'onmessage' event handler.
+   * This method effectively stops the WorkerListener from reacting to new incoming messages.
+   */ close() {
+        this.worker.onmessage = ()=>{};
+    }
+    handleMessageEvent;
+}

package/dest/transport/dispatch/create_dispatch_fn.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Represents a message object for dispatching function calls.
+ * Contains the function name ('fn') and an array of arguments ('args') required to call the target method.
+ */
+export interface DispatchMsg {
+    /**
+     * Name of the target method to be called.
+     */
+    fn: string;
+    /**
+     * An array of arguments to be passed to the target method.
+     */
+    args: any[];
+}
+/**
+ * Creates a dispatch function that calls the target's specified method with provided arguments.
+ * The created dispatch function takes a DispatchMsg object as input, which contains the name of
+ * the method to be called ('fn') and an array of arguments to be passed to the method ('args').
+ *
+ * @param targetFn - A function that returns the target object containing the methods to be dispatched.
+ * @param log - Optional logging function for debugging purposes.
+ * @returns A dispatch function that accepts a DispatchMsg object and calls the target's method with provided arguments.
+ */
+export declare function createDispatchFn(targetFn: () => any, log?: import("../../log/pino-logger.js").Logger): ({ fn, args }: DispatchMsg) => Promise<any>;
+//# sourceMappingURL=create_dispatch_fn.d.ts.map

package/dest/transport/dispatch/create_dispatch_fn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_dispatch_fn.d.ts","sourceRoot":"","sources":["../../../src/transport/dispatch/create_dispatch_fn.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,EAAE,EAAE,MAAM,CAAC;IACX;;OAEG;IACH,IAAI,EAAE,GAAG,EAAE,CAAC;CACb;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,EAAE,GAAG,4CAAsC,kBACjE,WAAW,kBAKxC"}

package/dest/transport/dispatch/create_dispatch_fn.js

@@ -0,0 +1,17 @@
+import { format } from 'util';
+import { createLogger } from '../../log/index.js';
+/**
+ * Creates a dispatch function that calls the target's specified method with provided arguments.
+ * The created dispatch function takes a DispatchMsg object as input, which contains the name of
+ * the method to be called ('fn') and an array of arguments to be passed to the method ('args').
+ *
+ * @param targetFn - A function that returns the target object containing the methods to be dispatched.
+ * @param log - Optional logging function for debugging purposes.
+ * @returns A dispatch function that accepts a DispatchMsg object and calls the target's method with provided arguments.
+ */ export function createDispatchFn(targetFn, log = createLogger('foundation:dispatch')) {
+    return async ({ fn, args })=>{
+        const target = targetFn();
+        log.debug(format(`dispatching to ${target}: ${fn}`, args));
+        return await target[fn](...args);
+    };
+}