@dynamic-labs/client 0.0.0-exp20240808.0

package/src/modules/walletsModule/walletsModule.js

@@ -0,0 +1,28 @@
+'use client'
+import { createRequestChannel, createStore } from '@dynamic-labs/message-transport';
+import { pickListenerActions } from '../../utils/pickListenerActions/pickListenerActions.js';
+import { createEmbeddedWalletsModule } from './embeddedWalletsModule/embeddedWalletsModule.js';
+
+const createWalletsModule = (core) => {
+    const requestChannel = createRequestChannel(core.messageTransport);
+    const store = createStore({
+        initialState: { primary: undefined, userWallets: [] },
+        key: 'wallets',
+        messageTransport: core.messageTransport,
+    });
+    const signMessage = (params) => requestChannel.request('signMessage', params);
+    const getBalance = (params) => requestChannel.request('getBalance', params);
+    const switchNetwork = (params) => requestChannel.request('switchNetwork', params);
+    const getNetwork = (params) => requestChannel.request('getNetwork', params);
+    const setPrimary = (params) => requestChannel.request('setPrimary', params);
+    return Object.assign(store.getters, pickListenerActions(store.eventEmitter), {
+        embedded: createEmbeddedWalletsModule(core),
+        getBalance,
+        getNetwork,
+        setPrimary,
+        signMessage,
+        switchNetwork,
+    });
+};
+
+export { createWalletsModule };

package/src/utils/Extendable/Extendable.cjs

@@ -0,0 +1,29 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var deepMergeInto = require('./deepMerge/deepMergeInto.cjs');
+
+// Class here is necessary to have access to "this" keyword
+/**
+ * An object that can be extended.
+ *
+ * To extend here means to add or replace the existing properties of this object,
+ * as well as kicking off any related procedures. Like a structure on which you can
+ * attach lego bricks.
+ *
+ * Ex: a { movie: "Up" } object can be extended by adding an audienceScore
+ * property to it, and kicking off an api call that will constantly update this property from
+ * an IMDb api.
+ */
+class Extendable {
+    constructor(core) {
+        this.core = core;
+    }
+    extend(extension) {
+        return deepMergeInto.deepMergeInto(this, extension(this, this.core));
+    }
+}
+
+exports.Extendable = Extendable;

package/src/utils/Extendable/Extendable.d.ts

@@ -0,0 +1,25 @@
+import { Core } from '../../client/core';
+/**
+ * Allows extending properties and methods of an Extendable
+ */
+export type Extension<T extends Record<string, unknown>> = (
+/** The extendable object to which this extension will be applied */
+extendable: Extendable, 
+/** An object with internal properties and methods not publicly accessible */
+core: Core) => T;
+/**
+ * An object that can be extended.
+ *
+ * To extend here means to add or replace the existing properties of this object,
+ * as well as kicking off any related procedures. Like a structure on which you can
+ * attach lego bricks.
+ *
+ * Ex: a { movie: "Up" } object can be extended by adding an audienceScore
+ * property to it, and kicking off an api call that will constantly update this property from
+ * an IMDb api.
+ */
+export declare class Extendable {
+    private readonly core;
+    constructor(core: Core);
+    extend<T extends Record<string, unknown>>(extension: Extension<T>): T & typeof this;
+}

package/src/utils/Extendable/Extendable.js

@@ -0,0 +1,25 @@
+'use client'
+import { deepMergeInto } from './deepMerge/deepMergeInto.js';
+
+// Class here is necessary to have access to "this" keyword
+/**
+ * An object that can be extended.
+ *
+ * To extend here means to add or replace the existing properties of this object,
+ * as well as kicking off any related procedures. Like a structure on which you can
+ * attach lego bricks.
+ *
+ * Ex: a { movie: "Up" } object can be extended by adding an audienceScore
+ * property to it, and kicking off an api call that will constantly update this property from
+ * an IMDb api.
+ */
+class Extendable {
+    constructor(core) {
+        this.core = core;
+    }
+    extend(extension) {
+        return deepMergeInto(this, extension(this, this.core));
+    }
+}
+
+export { Extendable };

package/src/utils/Extendable/deepMerge/deepMergeInto.cjs

@@ -0,0 +1,26 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/** Performs a deep merge into obj1 */
+const deepMergeInto = (obj1, obj2) => {
+    // Merge obj2 into obj1, recursively if the property is an object
+    for (const key in obj2) {
+        if (!Object.prototype.hasOwnProperty.call(obj2, key))
+            continue;
+        // If key exists in obj1 and both are objects, recurse
+        if (Object.prototype.hasOwnProperty.call(obj1, key) &&
+            typeof obj1[key] === 'object' &&
+            typeof obj2[key] === 'object') {
+            obj1[key] = deepMergeInto(obj1[key], obj2[key]);
+        }
+        else {
+            // Otherwise, just overwrite/add the property from obj2
+            obj1[key] = obj2[key];
+        }
+    }
+    return obj1;
+};
+
+exports.deepMergeInto = deepMergeInto;

package/src/utils/Extendable/deepMerge/deepMergeInto.d.ts

@@ -0,0 +1,6 @@
+type GenericObject = {
+    [key: string]: any;
+};
+/** Performs a deep merge into obj1 */
+export declare const deepMergeInto: <T extends GenericObject>(obj1: GenericObject, obj2: GenericObject) => T;
+export {};

package/src/utils/Extendable/deepMerge/deepMergeInto.js

@@ -0,0 +1,22 @@
+'use client'
+/** Performs a deep merge into obj1 */
+const deepMergeInto = (obj1, obj2) => {
+    // Merge obj2 into obj1, recursively if the property is an object
+    for (const key in obj2) {
+        if (!Object.prototype.hasOwnProperty.call(obj2, key))
+            continue;
+        // If key exists in obj1 and both are objects, recurse
+        if (Object.prototype.hasOwnProperty.call(obj1, key) &&
+            typeof obj1[key] === 'object' &&
+            typeof obj2[key] === 'object') {
+            obj1[key] = deepMergeInto(obj1[key], obj2[key]);
+        }
+        else {
+            // Otherwise, just overwrite/add the property from obj2
+            obj1[key] = obj2[key];
+        }
+    }
+    return obj1;
+};
+
+export { deepMergeInto };

package/src/utils/Extendable/deepMerge/index.d.ts

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

package/src/utils/Extendable/hasExtension/hasExtension.cjs

@@ -0,0 +1,14 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * This method allows safely type casting an Extendable object to include an extension type.
+ *
+ * It assumes you are checking if the target extension has declared its name to the core,
+ * and if that name is found in core's declaredExtensionNames, it will complete the type cast.
+ */
+const hasExtension = (extendable, core, extensionName) => core.declaredExtensionNames.includes(extensionName);
+
+exports.hasExtension = hasExtension;

package/src/utils/Extendable/hasExtension/hasExtension.d.ts

@@ -0,0 +1,9 @@
+import { Extendable } from '..';
+import { Core } from '../../..';
+/**
+ * This method allows safely type casting an Extendable object to include an extension type.
+ *
+ * It assumes you are checking if the target extension has declared its name to the core,
+ * and if that name is found in core's declaredExtensionNames, it will complete the type cast.
+ */
+export declare const hasExtension: <T>(extendable: Extendable, core: Core, extensionName: string) => extendable is Extendable & T;

package/src/utils/Extendable/hasExtension/hasExtension.js

@@ -0,0 +1,10 @@
+'use client'
+/**
+ * This method allows safely type casting an Extendable object to include an extension type.
+ *
+ * It assumes you are checking if the target extension has declared its name to the core,
+ * and if that name is found in core's declaredExtensionNames, it will complete the type cast.
+ */
+const hasExtension = (extendable, core, extensionName) => core.declaredExtensionNames.includes(extensionName);
+
+export { hasExtension };

package/src/utils/Extendable/hasExtension/index.d.ts

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

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

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

package/src/utils/addProperty/addProperty.cjs

@@ -0,0 +1,21 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Adds a new property to an object with a specified key and value.
+ * @template T - The type of the object.
+ * @param {T} obj - The object to add the property to.
+ * @param {string} key - The key of the new property.
+ * @param {PropertyDescriptor} descriptor - The property descriptor.
+ * @returns {T & Record<K, V>} The object with the added property.
+ * @template K - The key type.
+ * @template V - The value type.
+ */
+const addProperty = (obj, key, descriptor) => {
+    Object.defineProperty(obj, key, descriptor);
+    return obj;
+};
+
+exports.addProperty = addProperty;

package/src/utils/addProperty/addProperty.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Adds a new property to an object with a specified key and value.
+ * @template T - The type of the object.
+ * @param {T} obj - The object to add the property to.
+ * @param {string} key - The key of the new property.
+ * @param {PropertyDescriptor} descriptor - The property descriptor.
+ * @returns {T & Record<K, V>} The object with the added property.
+ * @template K - The key type.
+ * @template V - The value type.
+ */
+export declare const addProperty: <T extends object, K extends string, V>(obj: T, key: K, descriptor: {
+    get: () => V;
+}) => T & Record<K, V>;

package/src/utils/addProperty/addProperty.js

@@ -0,0 +1,17 @@
+'use client'
+/**
+ * Adds a new property to an object with a specified key and value.
+ * @template T - The type of the object.
+ * @param {T} obj - The object to add the property to.
+ * @param {string} key - The key of the new property.
+ * @param {PropertyDescriptor} descriptor - The property descriptor.
+ * @returns {T & Record<K, V>} The object with the added property.
+ * @template K - The key type.
+ * @template V - The value type.
+ */
+const addProperty = (obj, key, descriptor) => {
+    Object.defineProperty(obj, key, descriptor);
+    return obj;
+};
+
+export { addProperty };

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

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

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

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

package/src/utils/logger/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('@dynamic-labs/client');
+
+exports.logger = logger;

package/src/utils/logger/logger.d.ts

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

package/src/utils/logger/logger.js

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

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

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

package/src/utils/pickListenerActions/pickListenerActions.cjs

@@ -0,0 +1,17 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * This only serves to limit the methods of an event emitter to
+ * only the ones necessary for event listening
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const pickListenerActions = (emitter) => ({
+    off: emitter.off.bind(emitter),
+    on: emitter.on.bind(emitter),
+    once: emitter.once.bind(emitter),
+});
+
+exports.pickListenerActions = pickListenerActions;

package/src/utils/pickListenerActions/pickListenerActions.d.ts

@@ -0,0 +1,6 @@
+import EventEmitter from 'eventemitter3';
+/**
+ * This only serves to limit the methods of an event emitter to
+ * only the ones necessary for event listening
+ */
+export declare const pickListenerActions: <T extends EventEmitter<any, any>>(emitter: T) => Pick<T, 'on' | 'off' | 'once'>;

package/src/utils/pickListenerActions/pickListenerActions.js

@@ -0,0 +1,13 @@
+'use client'
+/**
+ * This only serves to limit the methods of an event emitter to
+ * only the ones necessary for event listening
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const pickListenerActions = (emitter) => ({
+    off: emitter.off.bind(emitter),
+    on: emitter.on.bind(emitter),
+    once: emitter.once.bind(emitter),
+});
+
+export { pickListenerActions };