@dynamic-labs/message-transport 0.0.0-exp20240808.0

package/src/store/store.cjs

@@ -0,0 +1,59 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var EventEmitter = require('eventemitter3');
+var reactivity = require('@vue/reactivity');
+var requestChannel = require('../requestChannel/requestChannel.cjs');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var EventEmitter__default = /*#__PURE__*/_interopDefaultLegacy(EventEmitter);
+
+const createStore = ({ initialState, key, messageTransport, }) => {
+    // We don't know what these types are yet, so any will do
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const requestChannel$1 = requestChannel.createRequestChannel(messageTransport);
+    /**
+     * The event emitter for this store getter.
+     *
+     * Not to be confused with the events that come from the messageTransport:
+     * - The messageTransport is a tool for sending/receiving messages to/from a webview.
+     * - This event emitter allows raising events exclusively for change events of this store's variables,
+     * and will only be used by the modules that are reading from the store, most likely to be forwarded
+     * for clients to have access to.
+     */
+    const eventEmitter = new EventEmitter__default["default"]();
+    const state = reactivity.reactive(Object.assign({}, initialState));
+    const getters = {};
+    for (const variable in state) {
+        // Add the state getter
+        Object.defineProperty(getters, variable, {
+            get: () => state[variable],
+        });
+        // We need to add a listener for each of this store's variables.
+        // That listener will listen for messageTransport "value changed" events,
+        // which we will use to update the store's values and raise events.
+        const messageName = `${key}__${variable}Changed`;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        requestChannel$1.handle(messageName, (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.
+            // Read above for elaboration.
+            //
+            // There are some limitation on what we can achieve with typescript in this file,
+            // 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 {
+        eventEmitter,
+        getters,
+    };
+};
+
+exports.createStore = createStore;

package/src/store/store.d.ts

@@ -0,0 +1,8 @@
+import { MessageTransportWithDefaultOrigin } from '../messageTransport';
+import { Store } from './types';
+export type CreateStoreProps<T extends Record<string, unknown>, U extends string> = {
+    messageTransport: MessageTransportWithDefaultOrigin;
+    key: U;
+    initialState: T;
+};
+export declare const createStore: <T extends Record<string, unknown> = never, U extends string = never>({ initialState, key, messageTransport, }: CreateStoreProps<T, U>) => Store<T>;

package/src/store/store.js

@@ -0,0 +1,51 @@
+'use client'
+import EventEmitter from 'eventemitter3';
+import { reactive } from '@vue/reactivity';
+import { createRequestChannel } from '../requestChannel/requestChannel.js';
+
+const createStore = ({ initialState, key, messageTransport, }) => {
+    // We don't know what these types are yet, so any will do
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const requestChannel = createRequestChannel(messageTransport);
+    /**
+     * The event emitter for this store getter.
+     *
+     * Not to be confused with the events that come from the messageTransport:
+     * - The messageTransport is a tool for sending/receiving messages to/from a webview.
+     * - This event emitter allows raising events exclusively for change events of this store's variables,
+     * and will only be used by the modules that are reading from the store, most likely to be forwarded
+     * for clients to have access to.
+     */
+    const eventEmitter = new EventEmitter();
+    const state = reactive(Object.assign({}, initialState));
+    const getters = {};
+    for (const variable in state) {
+        // Add the state getter
+        Object.defineProperty(getters, variable, {
+            get: () => state[variable],
+        });
+        // We need to add a listener for each of this store's variables.
+        // That listener will listen for messageTransport "value changed" events,
+        // which we will use to update the store's values and raise events.
+        const messageName = `${key}__${variable}Changed`;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        requestChannel.handle(messageName, (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.
+            // Read above for elaboration.
+            //
+            // There are some limitation on what we can achieve with typescript in this file,
+            // 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 {
+        eventEmitter,
+        getters,
+    };
+};
+
+export { createStore };

package/src/store/storeSetter/index.d.ts

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

package/src/store/storeSetter/storeSetter.cjs

@@ -0,0 +1,23 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var requestChannel = require('../../requestChannel/requestChannel.cjs');
+
+const createStoreSetter = ({ key, messageTransport, }) => {
+    // We don't know what these types are yet, so any will do
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const requestChannel$1 = requestChannel.createRequestChannel(messageTransport);
+    return {
+        set: (newValues) => {
+            const entries = Object.entries(newValues);
+            for (const [variable, newValue] of entries) {
+                const messageName = `${key}__${variable}Changed`;
+                requestChannel$1.emit(messageName, newValue);
+            }
+        },
+    };
+};
+
+exports.createStoreSetter = createStoreSetter;

package/src/store/storeSetter/storeSetter.d.ts

@@ -0,0 +1,8 @@
+import { MessageTransportWithDefaultOrigin } from '../../messageTransport';
+import { StoreSetter } from '../types';
+type CreateStoreSetterProps<U extends string> = {
+    messageTransport: MessageTransportWithDefaultOrigin;
+    key: U;
+};
+export declare const createStoreSetter: <T extends Record<string, unknown> = never, U extends string = never>({ key, messageTransport, }: CreateStoreSetterProps<U>) => StoreSetter<T>;
+export {};

package/src/store/storeSetter/storeSetter.js

@@ -0,0 +1,19 @@
+'use client'
+import { createRequestChannel } from '../../requestChannel/requestChannel.js';
+
+const createStoreSetter = ({ key, messageTransport, }) => {
+    // We don't know what these types are yet, so any will do
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const requestChannel = createRequestChannel(messageTransport);
+    return {
+        set: (newValues) => {
+            const entries = Object.entries(newValues);
+            for (const [variable, newValue] of entries) {
+                const messageName = `${key}__${variable}Changed`;
+                requestChannel.emit(messageName, newValue);
+            }
+        },
+    };
+};
+
+export { createStoreSetter };

package/src/store/types.d.ts

@@ -0,0 +1,53 @@
+import EventEmitter from 'eventemitter3';
+export type StoreKeys = 'auth' | 'sdk' | 'wallets' | 'embeddedWallets' | 'platform' | 'networks';
+/**
+ * Readonly getters for the store values
+ */
+export type StoreStateGetters<T extends Record<string, unknown>> = {
+    readonly [K in keyof T]: T[K];
+};
+/**
+ * The type of a getter that allows reading and listening to values from a store
+ */
+export type Store<T extends Record<string, unknown>> = {
+    getters: StoreStateGetters<T>;
+    eventEmitter: EventEmitter<StoreStateEvents<T>>;
+};
+/**
+ * The type of a setter that allows setting values of all stores connected to the same
+ * messageTransport
+ */
+export type StoreSetter<T extends Record<string, unknown>> = {
+    set: (values: Partial<T>) => void;
+};
+/**
+ * Defines how state change messages, to be sent across messageTransport, are named.
+ * These messages are not made public. They are only used to communicate state changes across the webview.
+ */
+export type StoreStateChangeMessage<T extends Record<string, unknown>, K extends Extract<keyof T, string>, U extends string> = `${U}__${K}Changed`;
+/**
+ * Defines how state change events are named.
+ * These events are emitted by the store, and are made public for client consumption.
+ *
+ * Do not confuse these with StoreStateChangeMessage, which are only for internal communication.
+ */
+export type StoreStateChangeEvent<T extends Record<string, unknown>, K extends Extract<keyof T, string>> = `${K}Changed`;
+/**
+ * Generates the event types for a StoreState
+ */
+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 {};

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

@@ -0,0 +1 @@
+export { isSerializedError } from './isSerializedError';

package/src/utils/isSerializedError/isSerializedError.cjs

@@ -0,0 +1,14 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const isSerializedError = (serializedError) => {
+    if (typeof serializedError !== 'object' || serializedError === null) {
+        return false;
+    }
+    const { message, stack } = serializedError;
+    return typeof message === 'string' && typeof stack === 'string';
+};
+
+exports.isSerializedError = isSerializedError;

package/src/utils/isSerializedError/isSerializedError.d.ts

@@ -0,0 +1,2 @@
+import { SerializedError } from '../serializeErrorForTransport';
+export declare const isSerializedError: (serializedError: SerializedError | unknown) => serializedError is SerializedError;

package/src/utils/isSerializedError/isSerializedError.js

@@ -0,0 +1,10 @@
+'use client'
+const isSerializedError = (serializedError) => {
+    if (typeof serializedError !== 'object' || serializedError === null) {
+        return false;
+    }
+    const { message, stack } = serializedError;
+    return typeof message === 'string' && typeof stack === 'string';
+};
+
+export { isSerializedError };

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

@@ -0,0 +1 @@
+export { parseErrorFromTransport } from './parseErrorFromTransport';

package/src/utils/parseErrorFromTransport/parseErrorFromTransport.cjs

@@ -0,0 +1,54 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+
+/**
+ * Parses a serialized error object back into an Error instance.
+ * This function will recreate an Error or a specific subclass of Error
+ * based on the name property if it matches known error types.
+ * Additional properties are added back to the reconstructed error object.
+ *
+ * @param {SerializedError} serializedError - The serialized error object to parse.
+ * @returns {Error} - The reconstructed Error instance.
+ */
+const parseErrorFromTransport = (serializedError) => {
+    const { message, name, stack } = serializedError, otherProps = _tslib.__rest(serializedError, ["message", "name", "stack"]);
+    let error;
+    // Determine the type of the error based on the 'name' property and instantiate accordingly
+    switch (name) {
+        case 'TypeError':
+            error = new TypeError(message);
+            break;
+        case 'ReferenceError':
+            error = new ReferenceError(message);
+            break;
+        case 'SyntaxError':
+            error = new SyntaxError(message);
+            break;
+        case 'RangeError':
+            error = new RangeError(message);
+            break;
+        case 'EvalError':
+            error = new EvalError(message);
+            break;
+        case 'URIError':
+            error = new URIError(message);
+            break;
+        default:
+            // Default to a generic Error if the specific type isn't recognized
+            error = new Error(message);
+            error.name = name || 'Error'; // Ensure the name is set, defaulting to 'Error' if not provided
+    }
+    // Reattach the stack trace and any other enumerable properties
+    if (stack) {
+        error.stack = [message, stack].join('\n');
+    }
+    // Reattach other custom properties that may have been serialized
+    Object.assign(error, otherProps);
+    return error;
+};
+
+exports.parseErrorFromTransport = parseErrorFromTransport;

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

@@ -0,0 +1,11 @@
+import { SerializedError } from '../serializeErrorForTransport';
+/**
+ * Parses a serialized error object back into an Error instance.
+ * This function will recreate an Error or a specific subclass of Error
+ * based on the name property if it matches known error types.
+ * Additional properties are added back to the reconstructed error object.
+ *
+ * @param {SerializedError} serializedError - The serialized error object to parse.
+ * @returns {Error} - The reconstructed Error instance.
+ */
+export declare const parseErrorFromTransport: (serializedError: SerializedError) => Error;

package/src/utils/parseErrorFromTransport/parseErrorFromTransport.js

@@ -0,0 +1,50 @@
+'use client'
+import { __rest } from '../../../_virtual/_tslib.js';
+
+/**
+ * Parses a serialized error object back into an Error instance.
+ * This function will recreate an Error or a specific subclass of Error
+ * based on the name property if it matches known error types.
+ * Additional properties are added back to the reconstructed error object.
+ *
+ * @param {SerializedError} serializedError - The serialized error object to parse.
+ * @returns {Error} - The reconstructed Error instance.
+ */
+const parseErrorFromTransport = (serializedError) => {
+    const { message, name, stack } = serializedError, otherProps = __rest(serializedError, ["message", "name", "stack"]);
+    let error;
+    // Determine the type of the error based on the 'name' property and instantiate accordingly
+    switch (name) {
+        case 'TypeError':
+            error = new TypeError(message);
+            break;
+        case 'ReferenceError':
+            error = new ReferenceError(message);
+            break;
+        case 'SyntaxError':
+            error = new SyntaxError(message);
+            break;
+        case 'RangeError':
+            error = new RangeError(message);
+            break;
+        case 'EvalError':
+            error = new EvalError(message);
+            break;
+        case 'URIError':
+            error = new URIError(message);
+            break;
+        default:
+            // Default to a generic Error if the specific type isn't recognized
+            error = new Error(message);
+            error.name = name || 'Error'; // Ensure the name is set, defaulting to 'Error' if not provided
+    }
+    // Reattach the stack trace and any other enumerable properties
+    if (stack) {
+        error.stack = [message, stack].join('\n');
+    }
+    // Reattach other custom properties that may have been serialized
+    Object.assign(error, otherProps);
+    return error;
+};
+
+export { parseErrorFromTransport };

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

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

package/src/utils/parseMessageTransportData/parseMessageTransportData.cjs

@@ -0,0 +1,27 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const parseMessageTransportData = (
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+parsedData) => {
+    if (!parsedData || typeof parsedData !== 'object') {
+        return undefined;
+    }
+    const message = {
+        args: parsedData.args,
+        messageSessionId: parsedData.messageSessionId,
+        origin: parsedData.origin,
+        type: parsedData.type,
+    };
+    if (!Array.isArray(message.args) ||
+        typeof message.messageSessionId !== 'string' ||
+        typeof message.origin !== 'string' ||
+        typeof message.type !== 'string') {
+        return undefined;
+    }
+    return message;
+};
+
+exports.parseMessageTransportData = parseMessageTransportData;

package/src/utils/parseMessageTransportData/parseMessageTransportData.d.ts

@@ -0,0 +1,2 @@
+import { MessageTransportData } from '../../messageTransport';
+export declare const parseMessageTransportData: (parsedData: any) => MessageTransportData | undefined;

package/src/utils/parseMessageTransportData/parseMessageTransportData.js

@@ -0,0 +1,23 @@
+'use client'
+const parseMessageTransportData = (
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+parsedData) => {
+    if (!parsedData || typeof parsedData !== 'object') {
+        return undefined;
+    }
+    const message = {
+        args: parsedData.args,
+        messageSessionId: parsedData.messageSessionId,
+        origin: parsedData.origin,
+        type: parsedData.type,
+    };
+    if (!Array.isArray(message.args) ||
+        typeof message.messageSessionId !== 'string' ||
+        typeof message.origin !== 'string' ||
+        typeof message.type !== 'string') {
+        return undefined;
+    }
+    return message;
+};
+
+export { parseMessageTransportData };

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

@@ -0,0 +1 @@
+export { serializeErrorForTransport, type SerializedError, } from './serializeErrorForTransport';

package/src/utils/serializeErrorForTransport/serializeErrorForTransport.cjs

@@ -0,0 +1,33 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Serializes an error to a JSON object to be sent by transport.
+ * This function checks if the input is an instance of Error to capture
+ * standard properties like message, name, and stack. It also attempts to
+ * serialize any enumerable properties that are present on error-like objects.
+ *
+ * @param {unknown} err - The error or error-like object to serialize.
+ * @returns {SerializedError} - The serialized error object.
+ */
+const serializeErrorForTransport = (err) => {
+    if (err instanceof Error) {
+        return Object.assign({ 
+            // @ts-expect-error message is a standard property of Error
+            message: err.message, 
+            // @ts-expect-error name is a standard property of Error
+            name: err.name, stack: err.stack }, err);
+    }
+    else if (typeof err === 'object' && err !== null) {
+        const plainObject = {};
+        for (const [key, value] of Object.entries(err)) {
+            plainObject[key] = value;
+        }
+        return plainObject;
+    }
+    return { message: String(err) };
+};
+
+exports.serializeErrorForTransport = serializeErrorForTransport;

package/src/utils/serializeErrorForTransport/serializeErrorForTransport.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Defines the shape of a serialized error object.
+ */
+export type SerializedError = {
+    message?: string;
+    name?: string;
+    stack?: string;
+    [key: string]: unknown;
+};
+/**
+ * Serializes an error to a JSON object to be sent by transport.
+ * This function checks if the input is an instance of Error to capture
+ * standard properties like message, name, and stack. It also attempts to
+ * serialize any enumerable properties that are present on error-like objects.
+ *
+ * @param {unknown} err - The error or error-like object to serialize.
+ * @returns {SerializedError} - The serialized error object.
+ */
+export declare const serializeErrorForTransport: (err: unknown) => SerializedError;

package/src/utils/serializeErrorForTransport/serializeErrorForTransport.js

@@ -0,0 +1,29 @@
+'use client'
+/**
+ * Serializes an error to a JSON object to be sent by transport.
+ * This function checks if the input is an instance of Error to capture
+ * standard properties like message, name, and stack. It also attempts to
+ * serialize any enumerable properties that are present on error-like objects.
+ *
+ * @param {unknown} err - The error or error-like object to serialize.
+ * @returns {SerializedError} - The serialized error object.
+ */
+const serializeErrorForTransport = (err) => {
+    if (err instanceof Error) {
+        return Object.assign({ 
+            // @ts-expect-error message is a standard property of Error
+            message: err.message, 
+            // @ts-expect-error name is a standard property of Error
+            name: err.name, stack: err.stack }, err);
+    }
+    else if (typeof err === 'object' && err !== null) {
+        const plainObject = {};
+        for (const [key, value] of Object.entries(err)) {
+            plainObject[key] = value;
+        }
+        return plainObject;
+    }
+    return { message: String(err) };
+};
+
+export { serializeErrorForTransport };