@dynamic-labs/message-transport 4.0.0-alpha.0 → 4.0.0-alpha.10

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;
 }
 

package/src/store/createEventEmitterForMessages/createEventEmitterForMessages.d.ts

@@ -1,22 +1,19 @@
 import EventEmitter from 'eventemitter3';
 import { MessageTransportWithDefaultOrigin } from '../../messageTransport';
-export type MessagesForEventEmitter<T extends Record<string, (...args: any[]) => any>, U extends string> = {
-    eventEmitted: <E extends keyof T>(key: U, eventName: E, payload: Parameters<T[E]>) => void;
-};
 /**
  * Use this function when you want to get an event emitter that will raise events for
- * messages of type MessagesForEventEmitter
+ * messages that have a name inside eventNames
  */
-export declare function createEventEmitterForMessages<T extends Record<string, (...args: any[]) => any> = never, U extends string = never>(params: {
+export declare function createEventEmitterForMessages<T extends Record<string, (...args: any[]) => any> = never>(params: {
     messageTransport: MessageTransportWithDefaultOrigin;
-    key: U;
+    eventNames: string[];
 }): EventEmitter<T>;
 /**
  * Use this function when you want to get an event emitter that will raise events for
  * messages of type MessagesForEventEmitter
  */
-export declare function createEventEmitterForMessages<T extends Record<string, (...args: any[]) => any> = never, U extends string = never, E extends EventEmitter<any> = never>(params: {
+export declare function createEventEmitterForMessages<T extends Record<string, (...args: any[]) => any> = never, E extends EventEmitter<any> = never>(params: {
     messageTransport: MessageTransportWithDefaultOrigin;
     initialEventEmitter: E;
-    key: U;
+    eventNames: string[];
 }): E extends EventEmitter<infer V> ? EventEmitter<T & V> : never;

package/src/store/createEventEmitterForMessages/createEventEmitterForMessages.js

@@ -3,13 +3,12 @@ import EventEmitter from 'eventemitter3';
 import { createRequestChannel } from '../../requestChannel/requestChannel.js';
 
 // 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();
     const requestChannel = createRequestChannel(messageTransport);
-    requestChannel.handle('eventEmitted', (eventKey, eventName, payload) => {
-        if (eventKey === key)
-            events.emit(eventName, ...payload);
-    });
+    for (const eventName of eventNames) {
+        requestChannel.handle(eventName, (...payload) => events.emit(eventName, ...payload));
+    }
     return events;
 }
 

package/src/store/types.d.ts

@@ -1,5 +1,6 @@
 import EventEmitter from 'eventemitter3';
-export type StoreKeys = 'auth' | 'sdk' | 'wallets' | 'embeddedWallets' | 'platform' | 'networks';
+import { PickedEventListeners } from '../types';
+export type StoreKeys = 'auth' | 'sdk' | 'wallets' | 'embeddedWallets' | 'platform' | 'userInterface' | 'otp' | 'networks';
 /**
  * Readonly getters for the store values
  */
@@ -38,16 +39,7 @@ export type StoreStateChangeEvent<T extends Record<string, unknown>, K extends E
 export type StoreStateEvents<T extends Record<string, unknown>> = {
     [K in Extract<keyof T, string> as StoreStateChangeEvent<T, K>]: (value: T[K]) => void;
 };
-/**
- * Generates the event listener methods for a StoreState.
- * The methods still return the original type of the eventemitter3 class.
- * Use StoreEventListeners instead, which hides these return types.
- */
-type RawStoreEventListeners<T extends Record<string, unknown>> = Pick<EventEmitter<StoreStateEvents<T>>, 'on' | 'off' | 'once'>;
 /**
  * The event listener methods for a StoreState
  */
-export type StoreEventListeners<T extends Record<string, unknown>> = {
-    [M in keyof RawStoreEventListeners<T>]: (...args: Parameters<RawStoreEventListeners<T>[M]>) => void;
-};
-export {};
+export type StoreEventListeners<T extends Record<string, unknown>> = PickedEventListeners<StoreStateEvents<T>>;

package/src/types.d.ts

@@ -0,0 +1,5 @@
+export type PickedEventListeners<T extends Record<string, unknown>> = {
+    on: <K extends keyof T>(eventName: K, listener: T[K]) => void;
+    once: <K extends keyof T>(eventName: K, listener: T[K]) => void;
+    off: <K extends keyof T>(eventName: K, listener: T[K]) => void;
+};

package/src/utils/logger.cjs

@@ -0,0 +1,10 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var logger$1 = require('@dynamic-labs/logger');
+
+const logger = new logger$1.Logger('message-transport');
+
+exports.logger = logger;

package/src/utils/logger.d.ts

@@ -0,0 +1,2 @@
+import { Logger } from '@dynamic-labs/logger';
+export declare const logger: Logger;

package/src/utils/logger.js

@@ -0,0 +1,6 @@
+'use client'
+import { Logger } from '@dynamic-labs/logger';
+
+const logger = new Logger('message-transport');
+
+export { logger };