@dynamic-labs/message-transport 4.0.0-alpha.5 → 4.0.0-alpha.50

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