@dynamic-labs/message-transport 4.0.0-alpha.6 → 4.0.0-alpha.8

package/src/requestChannel/createRequestChannelMessageSender/createRequestChannelMessageSender.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import { MessageTransportData, WithBlock } from '../../messageTransport';
+import { MessageTransportWithDefaultOrigin } from '../../messageTransport/decorators/applyDefaultMessageOrigin/applyDefaultMessageOrigin';
+import { RequestTypes } from '../types';
+type RequestChannelMessageSenderParams<T extends RequestTypes, K extends Extract<keyof T, string>> = {
+    requestType: K;
+    messageSessionId: string;
+    timeoutMap: Record<string, NodeJS.Timer>;
+    onReceiveAck?: VoidFunction;
+    onTimeout: VoidFunction;
+    messageTransport: MessageTransportWithDefaultOrigin | WithBlock<MessageTransportWithDefaultOrigin>;
+    params: Parameters<T[K]>;
+};
+export declare const createRequestChannelMessageSender: <T extends RequestTypes, K extends Extract<keyof T, string>>({ requestType, messageSessionId, timeoutMap, onReceiveAck, messageTransport, onTimeout, params, }: RequestChannelMessageSenderParams<T, K>) => {
+    handleAckMessage: ({ messageSessionId: incomingSessionId, type: incomingType, }: MessageTransportData) => void;
+    sendMessage: () => void;
+};
+export {};

package/src/requestChannel/createRequestChannelMessageSender/createRequestChannelMessageSender.js

@@ -0,0 +1,39 @@
+'use client'
+import { getAckMessageType, TIMEOUT_DURATION } from '../utils/utils.js';
+
+const createRequestChannelMessageSender = ({ requestType, messageSessionId, timeoutMap, onReceiveAck, messageTransport, onTimeout, params, }) => {
+    const ackMessageType = getAckMessageType(requestType);
+    const message = {
+        args: params,
+        messageSessionId,
+        type: requestType,
+    };
+    // We must listen for acks
+    const handleAckMessage = ({ messageSessionId: incomingSessionId, type: incomingType, }) => {
+        if (incomingSessionId !== messageSessionId ||
+            incomingType !== ackMessageType)
+            return;
+        clearTimeout(timeoutMap[messageSessionId]);
+        delete timeoutMap[messageSessionId];
+        onReceiveAck === null || onReceiveAck === void 0 ? void 0 : onReceiveAck();
+    };
+    const sendMessage = () => {
+        const startTimer = () => {
+            const timeoutTimer = setTimeout(onTimeout, TIMEOUT_DURATION);
+            timeoutMap[messageSessionId] = timeoutTimer;
+        };
+        // If this message transport is currently blocked, we must only start
+        // the timeout once the message is actually emitted
+        if ('isBlocked' in messageTransport && messageTransport.isBlocked) {
+            messageTransport.emit(message, { onEmit: startTimer });
+            return;
+        }
+        // Now we emit the event to set off the request
+        messageTransport.emit(message);
+        // We start the timer immediately since the message was not blocked
+        startTimer();
+    };
+    return { handleAckMessage, sendMessage };
+};
+
+export { createRequestChannelMessageSender };

package/src/requestChannel/createRequestChannelMessageSender/index.d.ts

@@ -0,0 +1 @@
+export * from './createRequestChannelMessageSender';

package/src/requestChannel/index.d.ts

@@ -1 +1,2 @@
 export * from './requestChannel';
+export * from './types';

package/src/requestChannel/requestChannel.cjs

@@ -4,32 +4,12 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var _tslib = require('../../_virtual/_tslib.cjs');
-var utils = require('@dynamic-labs/utils');
 var isSerializedError = require('../utils/isSerializedError/isSerializedError.cjs');
-var logger = require('../utils/logger.cjs');
 var parseErrorFromTransport = require('../utils/parseErrorFromTransport/parseErrorFromTransport.cjs');
 var serializeErrorForTransport = require('../utils/serializeErrorForTransport/serializeErrorForTransport.cjs');
+var createRequestChannelMessageSender = require('./createRequestChannelMessageSender/createRequestChannelMessageSender.cjs');
+var utils = require('./utils/utils.cjs');
 
-/** Given a request event name, returns the event name for its resolve */
-const getResolveMessageType = (type) => `${type}__resolve`;
-/** Given a request event name, returns the event name for its reject */
-const getRejectMessageType = (type) => `${type}__reject`;
-/** Given a request event name, returns the event name for its acknowledgement */
-const getAckMessageType = (type) => `${type}__ack`;
-/** Returns a "no handlers registered" error for a message type */
-const createNoHandlerError = (type, cleanup) => {
-    const message = `No handlers were registered for message of type ${type}`;
-    logger.logger.error(message);
-    cleanup();
-    return new utils.RequestChannelNotHandledError(message);
-};
-/**
- * When a request is sent, a timer will be started. If it times out before
- * a corresponding ack message is received, we reject the request with NO_HANDLERS_REGISTERED.
- *
- * This controls how many ms we should wait before we time out.
- */
-const TIMEOUT_DURATION = 3000;
 /**
  * Allows handling and submitting requests to and from a webview.
  * Requests are messages that (can) expect some response.
@@ -63,31 +43,24 @@ const createRequestChannel = (messageTransport) => {
             // Although we won't listen for a response, it must still be unique
             // to avoid tangling with other requests.
             const messageSessionId = getUniqueId();
-            const ackMessageType = getAckMessageType(requestType);
-            // Before actually emitting the event, we start listening to the
-            // response events
-            const handleMessage = ({ messageSessionId: incomingSessionId, type: incomingType, }) => {
-                if (incomingSessionId !== messageSessionId ||
-                    incomingType !== ackMessageType)
-                    return;
-                clearTimeout(timeoutMap[messageSessionId]);
-                delete timeoutMap[messageSessionId];
-                resolve();
-                cleanup();
-            };
-            const cleanup = () => messageTransport.off(handleMessage);
-            messageTransport.on(handleMessage);
-            // Now we emit the event to set off the request
-            messageTransport.emit({
-                args: params,
+            const { handleAckMessage, sendMessage } = createRequestChannelMessageSender.createRequestChannelMessageSender({
                 messageSessionId,
-                type: requestType,
+                messageTransport,
+                onReceiveAck: () => {
+                    cleanupMessageHandler();
+                    resolve();
+                },
+                onTimeout: () => {
+                    cleanupMessageHandler();
+                    reject(utils.createNoHandlerError(requestType));
+                },
+                params,
+                requestType,
+                timeoutMap,
             });
-            // And start the time out timer
-            const timeoutTimer = setTimeout(() => {
-                reject(createNoHandlerError(requestType, cleanup));
-            }, TIMEOUT_DURATION);
-            timeoutMap[messageSessionId] = timeoutTimer;
+            const cleanupMessageHandler = () => messageTransport.off(handleAckMessage);
+            messageTransport.on(handleAckMessage);
+            sendMessage();
         }),
         handle: (requestType, handler) => {
             const messageHandler = (_a) => _tslib.__awaiter(void 0, [_a], void 0, function* ({ args, messageSessionId, type: incomingType, }) {
@@ -97,7 +70,7 @@ const createRequestChannel = (messageTransport) => {
                 messageTransport.emit({
                     args: [],
                     messageSessionId,
-                    type: getAckMessageType(requestType),
+                    type: utils.getAckMessageType(requestType),
                 });
                 const result = handler(...args);
                 // If the handler doesn't return a promise,
@@ -109,14 +82,14 @@ const createRequestChannel = (messageTransport) => {
                     messageTransport.emit({
                         args: [response],
                         messageSessionId,
-                        type: getResolveMessageType(requestType),
+                        type: utils.getResolveMessageType(requestType),
                     });
                 }
                 catch (error) {
                     messageTransport.emit({
                         args: [serializeErrorForTransport.serializeErrorForTransport(error)],
                         messageSessionId,
-                        type: getRejectMessageType(requestType),
+                        type: utils.getRejectMessageType(requestType),
                     });
                 }
             });
@@ -127,52 +100,49 @@ const createRequestChannel = (messageTransport) => {
         },
         request: (requestType, ...params) => new Promise((resolve, reject) => {
             // Generate the unique id for this message exchange session
+            // Although we won't listen for a response, it must still be unique
+            // to avoid tangling with other requests.
             const messageSessionId = getUniqueId();
-            const resolveMessageType = getResolveMessageType(requestType);
-            const rejectMessageType = getRejectMessageType(requestType);
-            const ackMessageType = getAckMessageType(requestType);
-            // Before actually emitting the event, we start listening to the
-            // response events
-            const handleMessage = ({ args: [result], messageSessionId: incomingSessionId, type: incomingType, }) => {
-                if (incomingSessionId !== messageSessionId)
-                    return;
-                if (incomingType === ackMessageType) {
-                    clearTimeout(timeoutMap[messageSessionId]);
-                    delete timeoutMap[messageSessionId];
+            const resolveMessageType = utils.getResolveMessageType(requestType);
+            const rejectMessageType = utils.getRejectMessageType(requestType);
+            const { handleAckMessage, sendMessage } = createRequestChannelMessageSender.createRequestChannelMessageSender({
+                messageSessionId,
+                messageTransport,
+                onTimeout: () => {
+                    cleanupMessageHandler();
+                    reject(utils.createNoHandlerError(requestType));
+                },
+                params,
+                requestType,
+                timeoutMap,
+            });
+            // We also need to listen to resolve and reject messages, besides acks
+            const handleMessage = (message) => {
+                if (message.messageSessionId !== messageSessionId)
                     return;
-                }
+                const { args: [result], type: incomingType, } = message;
                 if (incomingType === resolveMessageType) {
+                    cleanupMessageHandler();
                     resolve(result);
-                    cleanup();
                     return;
                 }
                 if (incomingType === rejectMessageType) {
+                    cleanupMessageHandler();
                     if (isSerializedError.isSerializedError(result)) {
                         reject(parseErrorFromTransport.parseErrorFromTransport(result));
                     }
                     else {
                         reject(result);
                     }
-                    cleanup();
+                    return;
                 }
+                handleAckMessage(message);
             };
-            const cleanup = () => messageTransport.off(handleMessage);
+            const cleanupMessageHandler = () => messageTransport.off(handleMessage);
             messageTransport.on(handleMessage);
-            // And start the time out timer
-            const timeoutTimer = setTimeout(() => reject(createNoHandlerError(requestType, cleanup)), TIMEOUT_DURATION);
-            timeoutMap[messageSessionId] = timeoutTimer;
-            // Now we emit the event to set off the request
-            messageTransport.emit({
-                args: params,
-                messageSessionId,
-                type: requestType,
-            });
+            sendMessage();
         }),
     };
 };
 
-exports.TIMEOUT_DURATION = TIMEOUT_DURATION;
 exports.createRequestChannel = createRequestChannel;
-exports.getAckMessageType = getAckMessageType;
-exports.getRejectMessageType = getRejectMessageType;
-exports.getResolveMessageType = getResolveMessageType;

package/src/requestChannel/requestChannel.d.ts

@@ -1,71 +1,6 @@
+import { WithBlock } from '../messageTransport';
 import { MessageTransportWithDefaultOrigin } from '../messageTransport/decorators/applyDefaultMessageOrigin/applyDefaultMessageOrigin';
-/**
- * An object that defines request types, and whether they expect a response
- */
-export type RequestTypes = Record<string, (...params: any[]) => Promise<any> | void>;
-/**
- * Only the request types from T that return promises
- * i.e. those that expect a response
- */
-type TypesExpectingResponse<T extends RequestTypes> = Extract<{
-    [K in keyof T]: ReturnType<T[K]> extends Promise<any> ? K : never;
-}[keyof T], string>;
-export type RequestChannel<T extends RequestTypes> = {
-    /**
-     * Listens to incoming requests of this type, and calls the handler when they arrive.
-     * If the type of this request expects some response, the handler must return a promise
-     * that resolves to this response.
-     *
-     * @returns an unsubscribe function.
-     */
-    handle: <K extends Extract<keyof T, string>>(requestType: K, handler: T[K]) => VoidFunction;
-    /**
-     * Triggers handlers for this request type, with the given params.
-     * Doesn't expect a response. Resolves as soon as the message is acknowledged by
-     * any handler.
-     *
-     * If no handlers emit an ack for this message, this will reject.
-     *
-     * Lifetime of an "emit" message:
-     * 1. "Emit" message is sent.
-     * 2. A handler receives the message.
-     * 3. The handler immediately emits an ack message for it, acknowledging it.
-     * 4. This method's promise resolves.
-     */
-    emit: <K extends Extract<keyof T, string>>(requestName: K, ...params: Parameters<T[K]>) => Promise<void>;
-    /**
-     * Triggers handlers for this request type, with the given params.
-     * As opposed to emit, this expects a response message. A handler must still
-     * acknowledge this message, but the promise will only resolve when the handler
-     * emits back a response message. The promise resolves with whatever data was sent
-     * in the response.
-     *
-     * If no handlers emit an ack for this message, or if a handler responds
-     * with a failure, this will reject.
-     *
-     * Lifetime of a "request" message:
-     * 1. "Request" message is sent.
-     * 2. A handler receives the message.
-     * 3. The handler immediately emits an ack message for it, acknowledging it.
-     * 4. The handler performs the requested action.
-     * 5. The handler emits a response message.
-     * 6. This method's promise resolves with the response's data.
-     */
-    request: <K extends TypesExpectingResponse<T>>(requestName: K, ...params: Parameters<T[K]>) => ReturnType<T[K]>;
-};
-/** Given a request event name, returns the event name for its resolve */
-export declare const getResolveMessageType: (type: string) => string;
-/** Given a request event name, returns the event name for its reject */
-export declare const getRejectMessageType: (type: string) => string;
-/** Given a request event name, returns the event name for its acknowledgement */
-export declare const getAckMessageType: (type: string) => string;
-/**
- * When a request is sent, a timer will be started. If it times out before
- * a corresponding ack message is received, we reject the request with NO_HANDLERS_REGISTERED.
- *
- * This controls how many ms we should wait before we time out.
- */
-export declare const TIMEOUT_DURATION = 3000;
+import { RequestChannel, RequestTypes } from './types';
 /**
  * Allows handling and submitting requests to and from a webview.
  * Requests are messages that (can) expect some response.
@@ -84,5 +19,4 @@ export declare const TIMEOUT_DURATION = 3000;
  *
  * This is an abstraction built on top of the MessageTransport interface.
  */
-export declare const createRequestChannel: <T extends RequestTypes = never>(messageTransport: MessageTransportWithDefaultOrigin) => RequestChannel<T>;
-export {};
+export declare const createRequestChannel: <T extends RequestTypes = never>(messageTransport: MessageTransportWithDefaultOrigin | WithBlock<MessageTransportWithDefaultOrigin>) => RequestChannel<T>;

package/src/requestChannel/requestChannel.js

@@ -1,31 +1,11 @@
 'use client'
 import { __awaiter } from '../../_virtual/_tslib.js';
-import { RequestChannelNotHandledError } from '@dynamic-labs/utils';
 import { isSerializedError } from '../utils/isSerializedError/isSerializedError.js';
-import { logger } from '../utils/logger.js';
 import { parseErrorFromTransport } from '../utils/parseErrorFromTransport/parseErrorFromTransport.js';
 import { serializeErrorForTransport } from '../utils/serializeErrorForTransport/serializeErrorForTransport.js';
+import { createRequestChannelMessageSender } from './createRequestChannelMessageSender/createRequestChannelMessageSender.js';
+import { createNoHandlerError, getAckMessageType, getResolveMessageType, getRejectMessageType } from './utils/utils.js';
 
-/** Given a request event name, returns the event name for its resolve */
-const getResolveMessageType = (type) => `${type}__resolve`;
-/** Given a request event name, returns the event name for its reject */
-const getRejectMessageType = (type) => `${type}__reject`;
-/** Given a request event name, returns the event name for its acknowledgement */
-const getAckMessageType = (type) => `${type}__ack`;
-/** Returns a "no handlers registered" error for a message type */
-const createNoHandlerError = (type, cleanup) => {
-    const message = `No handlers were registered for message of type ${type}`;
-    logger.error(message);
-    cleanup();
-    return new RequestChannelNotHandledError(message);
-};
-/**
- * When a request is sent, a timer will be started. If it times out before
- * a corresponding ack message is received, we reject the request with NO_HANDLERS_REGISTERED.
- *
- * This controls how many ms we should wait before we time out.
- */
-const TIMEOUT_DURATION = 3000;
 /**
  * Allows handling and submitting requests to and from a webview.
  * Requests are messages that (can) expect some response.
@@ -59,31 +39,24 @@ const createRequestChannel = (messageTransport) => {
             // Although we won't listen for a response, it must still be unique
             // to avoid tangling with other requests.
             const messageSessionId = getUniqueId();
-            const ackMessageType = getAckMessageType(requestType);
-            // Before actually emitting the event, we start listening to the
-            // response events
-            const handleMessage = ({ messageSessionId: incomingSessionId, type: incomingType, }) => {
-                if (incomingSessionId !== messageSessionId ||
-                    incomingType !== ackMessageType)
-                    return;
-                clearTimeout(timeoutMap[messageSessionId]);
-                delete timeoutMap[messageSessionId];
-                resolve();
-                cleanup();
-            };
-            const cleanup = () => messageTransport.off(handleMessage);
-            messageTransport.on(handleMessage);
-            // Now we emit the event to set off the request
-            messageTransport.emit({
-                args: params,
+            const { handleAckMessage, sendMessage } = createRequestChannelMessageSender({
                 messageSessionId,
-                type: requestType,
+                messageTransport,
+                onReceiveAck: () => {
+                    cleanupMessageHandler();
+                    resolve();
+                },
+                onTimeout: () => {
+                    cleanupMessageHandler();
+                    reject(createNoHandlerError(requestType));
+                },
+                params,
+                requestType,
+                timeoutMap,
             });
-            // And start the time out timer
-            const timeoutTimer = setTimeout(() => {
-                reject(createNoHandlerError(requestType, cleanup));
-            }, TIMEOUT_DURATION);
-            timeoutMap[messageSessionId] = timeoutTimer;
+            const cleanupMessageHandler = () => messageTransport.off(handleAckMessage);
+            messageTransport.on(handleAckMessage);
+            sendMessage();
         }),
         handle: (requestType, handler) => {
             const messageHandler = (_a) => __awaiter(void 0, [_a], void 0, function* ({ args, messageSessionId, type: incomingType, }) {
@@ -123,48 +96,49 @@ const createRequestChannel = (messageTransport) => {
         },
         request: (requestType, ...params) => new Promise((resolve, reject) => {
             // Generate the unique id for this message exchange session
+            // Although we won't listen for a response, it must still be unique
+            // to avoid tangling with other requests.
             const messageSessionId = getUniqueId();
             const resolveMessageType = getResolveMessageType(requestType);
             const rejectMessageType = getRejectMessageType(requestType);
-            const ackMessageType = getAckMessageType(requestType);
-            // Before actually emitting the event, we start listening to the
-            // response events
-            const handleMessage = ({ args: [result], messageSessionId: incomingSessionId, type: incomingType, }) => {
-                if (incomingSessionId !== messageSessionId)
-                    return;
-                if (incomingType === ackMessageType) {
-                    clearTimeout(timeoutMap[messageSessionId]);
-                    delete timeoutMap[messageSessionId];
+            const { handleAckMessage, sendMessage } = createRequestChannelMessageSender({
+                messageSessionId,
+                messageTransport,
+                onTimeout: () => {
+                    cleanupMessageHandler();
+                    reject(createNoHandlerError(requestType));
+                },
+                params,
+                requestType,
+                timeoutMap,
+            });
+            // We also need to listen to resolve and reject messages, besides acks
+            const handleMessage = (message) => {
+                if (message.messageSessionId !== messageSessionId)
                     return;
-                }
+                const { args: [result], type: incomingType, } = message;
                 if (incomingType === resolveMessageType) {
+                    cleanupMessageHandler();
                     resolve(result);
-                    cleanup();
                     return;
                 }
                 if (incomingType === rejectMessageType) {
+                    cleanupMessageHandler();
                     if (isSerializedError(result)) {
                         reject(parseErrorFromTransport(result));
                     }
                     else {
                         reject(result);
                     }
-                    cleanup();
+                    return;
                 }
+                handleAckMessage(message);
             };
-            const cleanup = () => messageTransport.off(handleMessage);
+            const cleanupMessageHandler = () => messageTransport.off(handleMessage);
             messageTransport.on(handleMessage);
-            // And start the time out timer
-            const timeoutTimer = setTimeout(() => reject(createNoHandlerError(requestType, cleanup)), TIMEOUT_DURATION);
-            timeoutMap[messageSessionId] = timeoutTimer;
-            // Now we emit the event to set off the request
-            messageTransport.emit({
-                args: params,
-                messageSessionId,
-                type: requestType,
-            });
+            sendMessage();
         }),
     };
 };
 
-export { TIMEOUT_DURATION, createRequestChannel, getAckMessageType, getRejectMessageType, getResolveMessageType };
+export { createRequestChannel };

package/src/requestChannel/types.d.ts

@@ -0,0 +1,55 @@
+/**
+ * An object that defines request types, and whether they expect a response
+ */
+export type RequestTypes = Record<string, (...params: any[]) => Promise<any> | void>;
+/**
+ * Only the request types from T that return promises
+ * i.e. those that expect a response
+ */
+type TypesExpectingResponse<T extends RequestTypes> = Extract<{
+    [K in keyof T]: ReturnType<T[K]> extends Promise<any> ? K : never;
+}[keyof T], string>;
+export type RequestChannel<T extends RequestTypes> = {
+    /**
+     * Listens to incoming requests of this type, and calls the handler when they arrive.
+     * If the type of this request expects some response, the handler must return a promise
+     * that resolves to this response.
+     *
+     * @returns an unsubscribe function.
+     */
+    handle: <K extends Extract<keyof T, string>>(requestType: K, handler: T[K]) => VoidFunction;
+    /**
+     * Triggers handlers for this request type, with the given params.
+     * Doesn't expect a response. Resolves as soon as the message is acknowledged by
+     * any handler.
+     *
+     * If no handlers emit an ack for this message, this will reject.
+     *
+     * Lifetime of an "emit" message:
+     * 1. "Emit" message is sent.
+     * 2. A handler receives the message.
+     * 3. The handler immediately emits an ack message for it, acknowledging it.
+     * 4. This method's promise resolves.
+     */
+    emit: <K extends Extract<keyof T, string>>(requestName: K, ...params: Parameters<T[K]>) => Promise<void>;
+    /**
+     * Triggers handlers for this request type, with the given params.
+     * As opposed to emit, this expects a response message. A handler must still
+     * acknowledge this message, but the promise will only resolve when the handler
+     * emits back a response message. The promise resolves with whatever data was sent
+     * in the response.
+     *
+     * If no handlers emit an ack for this message, or if a handler responds
+     * with a failure, this will reject.
+     *
+     * Lifetime of a "request" message:
+     * 1. "Request" message is sent.
+     * 2. A handler receives the message.
+     * 3. The handler immediately emits an ack message for it, acknowledging it.
+     * 4. The handler performs the requested action.
+     * 5. The handler emits a response message.
+     * 6. This method's promise resolves with the response's data.
+     */
+    request: <K extends TypesExpectingResponse<T>>(requestName: K, ...params: Parameters<T[K]>) => ReturnType<T[K]>;
+};
+export {};

package/src/requestChannel/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './utils';

package/src/requestChannel/utils/utils.cjs

@@ -0,0 +1,33 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils = require('@dynamic-labs/utils');
+var logger = require('../../utils/logger.cjs');
+
+/** Given a request event name, returns the event name for its resolve */
+const getResolveMessageType = (type) => `${type}__resolve`;
+/** Given a request event name, returns the event name for its reject */
+const getRejectMessageType = (type) => `${type}__reject`;
+/** Given a request event name, returns the event name for its acknowledgement */
+const getAckMessageType = (type) => `${type}__ack`;
+/** Returns a "no handlers registered" error for a message type */
+const createNoHandlerError = (type) => {
+    const message = `No handlers were registered for message of type ${type}`;
+    logger.logger.error(message);
+    return new utils.RequestChannelNotHandledError(message);
+};
+/**
+ * When a request is sent, a timer will be started. If it times out before
+ * a corresponding ack message is received, we reject the request with NO_HANDLERS_REGISTERED.
+ *
+ * This controls how many ms we should wait before we time out.
+ */
+const TIMEOUT_DURATION = 3000;
+
+exports.TIMEOUT_DURATION = TIMEOUT_DURATION;
+exports.createNoHandlerError = createNoHandlerError;
+exports.getAckMessageType = getAckMessageType;
+exports.getRejectMessageType = getRejectMessageType;
+exports.getResolveMessageType = getResolveMessageType;

package/src/requestChannel/utils/utils.d.ts

@@ -0,0 +1,16 @@
+import { RequestChannelNotHandledError } from '@dynamic-labs/utils';
+/** Given a request event name, returns the event name for its resolve */
+export declare const getResolveMessageType: (type: string) => string;
+/** Given a request event name, returns the event name for its reject */
+export declare const getRejectMessageType: (type: string) => string;
+/** Given a request event name, returns the event name for its acknowledgement */
+export declare const getAckMessageType: (type: string) => string;
+/** Returns a "no handlers registered" error for a message type */
+export declare const createNoHandlerError: (type: string) => RequestChannelNotHandledError;
+/**
+ * When a request is sent, a timer will be started. If it times out before
+ * a corresponding ack message is received, we reject the request with NO_HANDLERS_REGISTERED.
+ *
+ * This controls how many ms we should wait before we time out.
+ */
+export declare const TIMEOUT_DURATION = 3000;

package/src/requestChannel/utils/utils.js

@@ -0,0 +1,25 @@
+'use client'
+import { RequestChannelNotHandledError } from '@dynamic-labs/utils';
+import { logger } from '../../utils/logger.js';
+
+/** Given a request event name, returns the event name for its resolve */
+const getResolveMessageType = (type) => `${type}__resolve`;
+/** Given a request event name, returns the event name for its reject */
+const getRejectMessageType = (type) => `${type}__reject`;
+/** Given a request event name, returns the event name for its acknowledgement */
+const getAckMessageType = (type) => `${type}__ack`;
+/** Returns a "no handlers registered" error for a message type */
+const createNoHandlerError = (type) => {
+    const message = `No handlers were registered for message of type ${type}`;
+    logger.error(message);
+    return new RequestChannelNotHandledError(message);
+};
+/**
+ * When a request is sent, a timer will be started. If it times out before
+ * a corresponding ack message is received, we reject the request with NO_HANDLERS_REGISTERED.
+ *
+ * This controls how many ms we should wait before we time out.
+ */
+const TIMEOUT_DURATION = 3000;
+
+export { TIMEOUT_DURATION, createNoHandlerError, getAckMessageType, getRejectMessageType, getResolveMessageType };

package/src/store/createEventEmitterForMessages/createEventEmitterForMessages.cjs

@@ -11,13 +11,12 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 var EventEmitter__default = /*#__PURE__*/_interopDefaultLegacy(EventEmitter);
 
 // There are way too many "any"s in this file. They are necessary because otherwise the generics won't work
-function createEventEmitterForMessages({ messageTransport, initialEventEmitter, key, }) {
+function createEventEmitterForMessages({ messageTransport, initialEventEmitter, eventNames, }) {
     const events = initialEventEmitter !== null && initialEventEmitter !== void 0 ? initialEventEmitter : new EventEmitter__default["default"]();
     const requestChannel$1 = requestChannel.createRequestChannel(messageTransport);
-    requestChannel$1.handle('eventEmitted', (eventKey, eventName, payload) => {
-        if (eventKey === key)
-            events.emit(eventName, ...payload);
-    });
+    for (const eventName of eventNames) {
+        requestChannel$1.handle(eventName, (...payload) => events.emit(eventName, ...payload));
+    }
     return events;
 }