@dynamic-labs/utils 3.0.0-alpha.62 → 3.0.0-alpha.63

package/CHANGELOG.md

@@ -1,4 +1,21 @@
 
+## [3.0.0-alpha.63](https://github.com/dynamic-labs/DynamicAuth/compare/v3.0.0-alpha.62...v3.0.0-alpha.63) (2024-09-10)
+
+
+### ⚠ BREAKING CHANGES
+
+* remove signWithEmailWalletName (#6824)
+
+### Features
+
+* remove signWithEmailWalletName ([#6824](https://github.com/dynamic-labs/DynamicAuth/issues/6824)) ([9da06ce](https://github.com/dynamic-labs/DynamicAuth/commit/9da06ce6f83813e00827295a2952a805e0ef5ec0))
+
+
+### Bug Fixes
+
+* omit body when creating 204 response data ([#6458](https://github.com/dynamic-labs/DynamicAuth/issues/6458)) ([06aab01](https://github.com/dynamic-labs/DynamicAuth/commit/06aab016eed0fa5ac41e43ece73780844d8d12ad))
+* use a better object clone function to clone wallet signers ([#6835](https://github.com/dynamic-labs/DynamicAuth/issues/6835)) ([d88c195](https://github.com/dynamic-labs/DynamicAuth/commit/d88c195ce8e3af8e2fd8e6d76fbbdad618bc6c85))
+
 ## [3.0.0-alpha.62](https://github.com/dynamic-labs/DynamicAuth/compare/v3.0.0-alpha.61...v3.0.0-alpha.62) (2024-09-08)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs/utils",
-  "version": "3.0.0-alpha.62",
+  "version": "3.0.0-alpha.63",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/dynamic-labs/dynamic-auth.git",
@@ -28,9 +28,10 @@
   "dependencies": {
     "@dynamic-labs/sdk-api-core": "0.0.526",
     "tldts": "6.0.16",
-    "@dynamic-labs/logger": "3.0.0-alpha.62",
-    "@dynamic-labs/types": "3.0.0-alpha.62",
+    "@dynamic-labs/logger": "3.0.0-alpha.63",
+    "@dynamic-labs/types": "3.0.0-alpha.63",
     "buffer": "6.0.3",
+    "eventemitter3": "5.0.1",
     "stream": "0.0.2"
   },
   "peerDependencies": {}

package/src/cloneObjectWithOverrides/cloneObjectWithOverrides.cjs

@@ -0,0 +1,37 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Clones an object and includes properties with `enumerable: false`, unlike the spread
+ * operator which will leave these properties out.
+ *
+ * Optionally pass in overrides to apply to the cloned object.
+ *
+ * @param original The object to clone
+ * @param overrides An object containing properties to override on the cloned object
+ * @returns A new object that is a clone of the original object with the specified overrides
+ */
+const cloneObjectWithOverrides = (original, overrides = {}) => {
+    var _a, _b;
+    // Get the property descriptors from the original object
+    const descriptors = Object.getOwnPropertyDescriptors(original);
+    // Create a new object using the same prototype as the original
+    const clone = Object.create(Object.getPrototypeOf(original), descriptors);
+    // // Loop through the overrides to redefine any read-only methods
+    for (const [key, value] of Object.entries(overrides)) {
+        // Redefine the method even if it was read-only on the original object
+        Object.defineProperty(clone, key, {
+            // Make it writable if necessary
+            configurable: true,
+            // Allow future modifications
+            enumerable: (_b = (_a = descriptors[key]) === null || _a === void 0 ? void 0 : _a.enumerable) !== null && _b !== void 0 ? _b : true,
+            value: value,
+            writable: true, // Preserve enumerability
+        });
+    }
+    return clone;
+};
+
+exports.cloneObjectWithOverrides = cloneObjectWithOverrides;

package/src/cloneObjectWithOverrides/cloneObjectWithOverrides.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Clones an object and includes properties with `enumerable: false`, unlike the spread
+ * operator which will leave these properties out.
+ *
+ * Optionally pass in overrides to apply to the cloned object.
+ *
+ * @param original The object to clone
+ * @param overrides An object containing properties to override on the cloned object
+ * @returns A new object that is a clone of the original object with the specified overrides
+ */
+export declare const cloneObjectWithOverrides: (original: object, overrides?: {}) => any;

package/src/cloneObjectWithOverrides/cloneObjectWithOverrides.js

@@ -0,0 +1,33 @@
+'use client'
+/**
+ * Clones an object and includes properties with `enumerable: false`, unlike the spread
+ * operator which will leave these properties out.
+ *
+ * Optionally pass in overrides to apply to the cloned object.
+ *
+ * @param original The object to clone
+ * @param overrides An object containing properties to override on the cloned object
+ * @returns A new object that is a clone of the original object with the specified overrides
+ */
+const cloneObjectWithOverrides = (original, overrides = {}) => {
+    var _a, _b;
+    // Get the property descriptors from the original object
+    const descriptors = Object.getOwnPropertyDescriptors(original);
+    // Create a new object using the same prototype as the original
+    const clone = Object.create(Object.getPrototypeOf(original), descriptors);
+    // // Loop through the overrides to redefine any read-only methods
+    for (const [key, value] of Object.entries(overrides)) {
+        // Redefine the method even if it was read-only on the original object
+        Object.defineProperty(clone, key, {
+            // Make it writable if necessary
+            configurable: true,
+            // Allow future modifications
+            enumerable: (_b = (_a = descriptors[key]) === null || _a === void 0 ? void 0 : _a.enumerable) !== null && _b !== void 0 ? _b : true,
+            value: value,
+            writable: true, // Preserve enumerability
+        });
+    }
+    return clone;
+};
+
+export { cloneObjectWithOverrides };

package/src/cloneObjectWithOverrides/index.d.ts

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

package/src/index.cjs

@@ -71,6 +71,9 @@ var template = require('./template/template.cjs');
 var get = require('./get/get.cjs');
 var hexToString = require('./hexToString/hexToString.cjs');
 var isHex = require('./isHex/isHex.cjs');
+var StorageService = require('./services/StorageService/StorageService.cjs');
+var createStorageService = require('./services/StorageService/createStorageService/createStorageService.cjs');
+var cloneObjectWithOverrides = require('./cloneObjectWithOverrides/cloneObjectWithOverrides.cjs');
 
 
 
@@ -156,3 +159,6 @@ exports.template = template.template;
 exports.get = get.get;
 exports.hexToString = hexToString.hexToString;
 exports.isHex = isHex.isHex;
+exports.StorageService = StorageService.StorageService;
+exports.createStorageService = createStorageService.createStorageService;
+exports.cloneObjectWithOverrides = cloneObjectWithOverrides.cloneObjectWithOverrides;

package/src/index.d.ts

@@ -30,3 +30,5 @@ export { template } from './template';
 export { get } from './get';
 export { hexToString } from './hexToString';
 export { isHex } from './isHex';
+export { type IStorageService, type StorageOptions, StorageService, createStorageService, } from './services/StorageService';
+export { cloneObjectWithOverrides } from './cloneObjectWithOverrides';

package/src/index.js

@@ -67,3 +67,6 @@ export { template } from './template/template.js';
 export { get } from './get/get.js';
 export { hexToString } from './hexToString/hexToString.js';
 export { isHex } from './isHex/isHex.js';
+export { StorageService } from './services/StorageService/StorageService.js';
+export { createStorageService } from './services/StorageService/createStorageService/createStorageService.js';
+export { cloneObjectWithOverrides } from './cloneObjectWithOverrides/cloneObjectWithOverrides.js';

package/src/services/StorageService/StorageService.cjs

@@ -0,0 +1,59 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var EventEmitter = require('eventemitter3');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var EventEmitter__default = /*#__PURE__*/_interopDefaultLegacy(EventEmitter);
+
+class StorageService {
+    static clearRegistry() {
+        StorageService.registry = {
+            localStorage: undefined,
+            secureStorage: undefined,
+            sessionStorage: undefined,
+        };
+    }
+    static registerSourceStorage(source, implementation) {
+        StorageService.registry[source] = implementation;
+    }
+    static getSourceStorage(source) {
+        return StorageService.registry[source];
+    }
+    static resolveStorage(options) {
+        const priority = (options === null || options === void 0 ? void 0 : options.priority) || ['localStorage'];
+        for (const source of priority) {
+            const storage = StorageService.getSourceStorage(source);
+            if (storage) {
+                return storage;
+            }
+        }
+        throw new Error('No available storage found based on the specified priority');
+    }
+    static getItem(key, options) {
+        const storage = StorageService.resolveStorage(options);
+        return storage.getItem(key);
+    }
+    static setItem(key, value, options) {
+        const storage = StorageService.resolveStorage(options);
+        storage.setItem(key, value);
+    }
+    static removeItem(key, options) {
+        const storage = StorageService.resolveStorage(options);
+        storage.removeItem(key);
+    }
+    static getKeys(options) {
+        return StorageService.resolveStorage(options).getKeys();
+    }
+}
+StorageService.registry = {
+    localStorage: undefined,
+    secureStorage: undefined,
+    sessionStorage: undefined,
+};
+StorageService.events = new EventEmitter__default["default"]();
+
+exports.StorageService = StorageService;

package/src/services/StorageService/StorageService.d.ts

@@ -0,0 +1,30 @@
+import EventEmitter from 'eventemitter3';
+import { IStorageService } from './types';
+export type StorageSource = 'secureStorage' | 'localStorage' | 'sessionStorage';
+export type StorageOptions = {
+    /**
+     * An ordered array of storage sources by priority.
+     * The service will use the first available storage source in this order.
+     *
+     * Example:
+     * StorageService.setItem('key', 'value', { priority: ['secureStorage', 'sessionStorage', 'localStorage'] });
+     * The line above will first try to store the value in secure storage,
+     * if the secure storage is not available, it try to store in session storage,
+     * and finally if both secure and session storage are not available, it will store in local storage.
+     */
+    priority: StorageSource[];
+};
+export declare class StorageService {
+    static registry: Record<StorageSource, IStorageService | undefined>;
+    static clearRegistry(): void;
+    static registerSourceStorage(source: StorageSource, implementation: IStorageService): void;
+    static getSourceStorage(source: StorageSource): IStorageService | undefined;
+    static resolveStorage(options?: StorageOptions): IStorageService;
+    static getItem<T = string>(key: string, options?: StorageOptions): T | undefined;
+    static setItem<T>(key: string, value: T, options?: StorageOptions): void;
+    static removeItem(key: string, options?: StorageOptions): void;
+    static getKeys(options?: StorageOptions): string[];
+    static events: EventEmitter<{
+        parseFailure: (error: unknown, key: string) => void;
+    }, any>;
+}

package/src/services/StorageService/StorageService.js

@@ -0,0 +1,51 @@
+'use client'
+import EventEmitter from 'eventemitter3';
+
+class StorageService {
+    static clearRegistry() {
+        StorageService.registry = {
+            localStorage: undefined,
+            secureStorage: undefined,
+            sessionStorage: undefined,
+        };
+    }
+    static registerSourceStorage(source, implementation) {
+        StorageService.registry[source] = implementation;
+    }
+    static getSourceStorage(source) {
+        return StorageService.registry[source];
+    }
+    static resolveStorage(options) {
+        const priority = (options === null || options === void 0 ? void 0 : options.priority) || ['localStorage'];
+        for (const source of priority) {
+            const storage = StorageService.getSourceStorage(source);
+            if (storage) {
+                return storage;
+            }
+        }
+        throw new Error('No available storage found based on the specified priority');
+    }
+    static getItem(key, options) {
+        const storage = StorageService.resolveStorage(options);
+        return storage.getItem(key);
+    }
+    static setItem(key, value, options) {
+        const storage = StorageService.resolveStorage(options);
+        storage.setItem(key, value);
+    }
+    static removeItem(key, options) {
+        const storage = StorageService.resolveStorage(options);
+        storage.removeItem(key);
+    }
+    static getKeys(options) {
+        return StorageService.resolveStorage(options).getKeys();
+    }
+}
+StorageService.registry = {
+    localStorage: undefined,
+    secureStorage: undefined,
+    sessionStorage: undefined,
+};
+StorageService.events = new EventEmitter();
+
+export { StorageService };

package/src/services/StorageService/createStorageService/createStorageService.cjs

@@ -0,0 +1,46 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var logger = require('../../../logger/logger.cjs');
+var StorageService = require('../StorageService.cjs');
+
+const createStorageService = ({ prefix, storage, }) => {
+    const getKey = (key) => (prefix ? `${key}_${prefix}` : key);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const packValue = (value) => JSON.stringify(value);
+    const unpackValue = (value) => JSON.parse(value);
+    const getItem = (key) => {
+        const value = storage.getItem(getKey(key));
+        if (!value) {
+            return undefined;
+        }
+        try {
+            return unpackValue(value);
+        }
+        catch (error) {
+            logger.logger.error(`Error while parsing ${key} from local storage`, {
+                value,
+            });
+            removeItem(key);
+            StorageService.StorageService.events.emit('parseFailure', error, key);
+        }
+        return undefined;
+    };
+    const setItem = (key, value) => {
+        storage.setItem(getKey(key), packValue(value));
+    };
+    const removeItem = (key) => {
+        storage.removeItem(getKey(key));
+    };
+    const getKeys = () => Object.keys(storage);
+    return {
+        getItem,
+        getKeys,
+        removeItem,
+        setItem,
+    };
+};
+
+exports.createStorageService = createStorageService;

package/src/services/StorageService/createStorageService/createStorageService.d.ts

@@ -0,0 +1,7 @@
+import { IStorageService } from '../types';
+type CreateStorageServiceProps = {
+    prefix?: string;
+    storage: Storage;
+};
+export declare const createStorageService: ({ prefix, storage, }: CreateStorageServiceProps) => IStorageService;
+export {};

package/src/services/StorageService/createStorageService/createStorageService.js

@@ -0,0 +1,42 @@
+'use client'
+import { logger } from '../../../logger/logger.js';
+import { StorageService } from '../StorageService.js';
+
+const createStorageService = ({ prefix, storage, }) => {
+    const getKey = (key) => (prefix ? `${key}_${prefix}` : key);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const packValue = (value) => JSON.stringify(value);
+    const unpackValue = (value) => JSON.parse(value);
+    const getItem = (key) => {
+        const value = storage.getItem(getKey(key));
+        if (!value) {
+            return undefined;
+        }
+        try {
+            return unpackValue(value);
+        }
+        catch (error) {
+            logger.error(`Error while parsing ${key} from local storage`, {
+                value,
+            });
+            removeItem(key);
+            StorageService.events.emit('parseFailure', error, key);
+        }
+        return undefined;
+    };
+    const setItem = (key, value) => {
+        storage.setItem(getKey(key), packValue(value));
+    };
+    const removeItem = (key) => {
+        storage.removeItem(getKey(key));
+    };
+    const getKeys = () => Object.keys(storage);
+    return {
+        getItem,
+        getKeys,
+        removeItem,
+        setItem,
+    };
+};
+
+export { createStorageService };

package/src/services/StorageService/createStorageService/index.d.ts

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

package/src/services/StorageService/index.d.ts

@@ -0,0 +1,3 @@
+export { StorageService, type StorageOptions } from './StorageService';
+export { createStorageService } from './createStorageService';
+export type { IStorageService } from './types';

package/src/services/StorageService/types.d.ts

@@ -0,0 +1,6 @@
+export type IStorageService = {
+    getItem: <T = string>(key: string) => T | undefined;
+    setItem: <T>(key: string, value: T) => void;
+    removeItem: (key: string) => void;
+    getKeys: () => string[];
+};