@dynamic-labs/message-transport 4.0.0-alpha.3 → 4.0.0-alpha.31

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

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/store.cjs

@@ -38,6 +38,7 @@ const createStore = ({ initialState, key, messageTransport, }) => {
         const messageName = `${key}__${variable}Changed`;
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         requestChannel$1.handle(messageName, (newValue) => {
+            state[variable] = newValue;
             const eventName = `${variable}Changed`;
             // We emit with the same event name for simplicity, but keep in mind
             // the eventEmitter events are different from the messageTransport message we are handling.
@@ -47,7 +48,6 @@ const createStore = ({ initialState, key, messageTransport, }) => {
             // but all this is encapsulated in this function and it works like a charm for whoever calls it.
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             eventEmitter.emit(eventName, newValue);
-            state[variable] = newValue;
         });
     }
     return {

package/src/store/store.js

@@ -30,6 +30,7 @@ const createStore = ({ initialState, key, messageTransport, }) => {
         const messageName = `${key}__${variable}Changed`;
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         requestChannel.handle(messageName, (newValue) => {
+            state[variable] = newValue;
             const eventName = `${variable}Changed`;
             // We emit with the same event name for simplicity, but keep in mind
             // the eventEmitter events are different from the messageTransport message we are handling.
@@ -39,7 +40,6 @@ const createStore = ({ initialState, key, messageTransport, }) => {
             // but all this is encapsulated in this function and it works like a charm for whoever calls it.
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             eventEmitter.emit(eventName, newValue);
-            state[variable] = newValue;
         });
     }
     return {

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/parseErrorFromTransport/parseErrorFromTransport.cjs

@@ -17,6 +17,17 @@ var _tslib = require('../../../_virtual/_tslib.cjs');
 const parseErrorFromTransport = (serializedError) => {
     const { message, name, stack } = serializedError, otherProps = _tslib.__rest(serializedError, ["message", "name", "stack"]);
     let error;
+    // If we have passed in a array of values, we just use it directly
+    if (message) {
+        try {
+            const data = JSON.parse(message);
+            if (Array.isArray(data))
+                return data;
+        }
+        catch (_a) {
+            /* empty */
+        }
+    }
     // Determine the type of the error based on the 'name' property and instantiate accordingly
     switch (name) {
         case 'TypeError':

package/src/utils/parseErrorFromTransport/parseErrorFromTransport.d.ts

@@ -8,4 +8,4 @@ import { SerializedError } from '../serializeErrorForTransport';
  * @param {SerializedError} serializedError - The serialized error object to parse.
  * @returns {Error} - The reconstructed Error instance.
  */
-export declare const parseErrorFromTransport: (serializedError: SerializedError) => Error;
+export declare const parseErrorFromTransport: (serializedError: SerializedError) => Error | unknown[];

package/src/utils/parseErrorFromTransport/parseErrorFromTransport.js

@@ -13,6 +13,17 @@ import { __rest } from '../../../_virtual/_tslib.js';
 const parseErrorFromTransport = (serializedError) => {
     const { message, name, stack } = serializedError, otherProps = __rest(serializedError, ["message", "name", "stack"]);
     let error;
+    // If we have passed in a array of values, we just use it directly
+    if (message) {
+        try {
+            const data = JSON.parse(message);
+            if (Array.isArray(data))
+                return data;
+        }
+        catch (_a) {
+            /* empty */
+        }
+    }
     // Determine the type of the error based on the 'name' property and instantiate accordingly
     switch (name) {
         case 'TypeError':

package/src/utils/serializeErrorForTransport/serializeErrorForTransport.cjs

@@ -20,6 +20,9 @@ const serializeErrorForTransport = (err) => {
             // @ts-expect-error name is a standard property of Error
             name: err.name, stack: err.stack }, err);
     }
+    else if (Array.isArray(err)) {
+        return { message: JSON.stringify(err) };
+    }
     else if (typeof err === 'object' && err !== null) {
         const plainObject = {};
         for (const [key, value] of Object.entries(err)) {

package/src/utils/serializeErrorForTransport/serializeErrorForTransport.js

@@ -16,6 +16,9 @@ const serializeErrorForTransport = (err) => {
             // @ts-expect-error name is a standard property of Error
             name: err.name, stack: err.stack }, err);
     }
+    else if (Array.isArray(err)) {
+        return { message: JSON.stringify(err) };
+    }
     else if (typeof err === 'object' && err !== null) {
         const plainObject = {};
         for (const [key, value] of Object.entries(err)) {

package/src/messageTypes/SecureStorageMessages.d.ts

@@ -1,5 +0,0 @@
-export type SecureStorageMessages = {
-    getSecureItem: (key: string) => Promise<string | null>;
-    setSecureItem: (key: string, data: string) => Promise<void>;
-    deleteSecureItem: (key: string) => Promise<void>;
-};