@dynamic-labs/utils 0.19.0-alpha.2 → 0.19.0-alpha.21

package/src/localStorageAsync.js

@@ -1,22 +1,22 @@
 import { __awaiter } from '../_virtual/_tslib.js';
 
-const getItemAsync = (key) => __awaiter(void 0, void 0, void 0, function* () {
-    if (typeof window === 'undefined') {
-        return undefined;
-    }
-    return window.localStorage.getItem(key) || undefined;
-});
-const setItemAsync = (key, value) => __awaiter(void 0, void 0, void 0, function* () {
-    if (typeof window === 'undefined') {
-        return undefined;
-    }
-    return window.localStorage.setItem(key, value);
-});
-const removeItemAsync = (key) => __awaiter(void 0, void 0, void 0, function* () {
-    if (typeof window === 'undefined') {
-        return undefined;
-    }
-    return localStorage.removeItem(key);
+const getItemAsync = (key) => __awaiter(void 0, void 0, void 0, function* () {
+    if (typeof window === 'undefined') {
+        return undefined;
+    }
+    return window.localStorage.getItem(key) || undefined;
+});
+const setItemAsync = (key, value) => __awaiter(void 0, void 0, void 0, function* () {
+    if (typeof window === 'undefined') {
+        return undefined;
+    }
+    return window.localStorage.setItem(key, value);
+});
+const removeItemAsync = (key) => __awaiter(void 0, void 0, void 0, function* () {
+    if (typeof window === 'undefined') {
+        return undefined;
+    }
+    return localStorage.removeItem(key);
 });
 
 export { getItemAsync, removeItemAsync, setItemAsync };

package/src/logger/index.d.ts

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

package/src/logger/logger.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var logger$1 = require('@dynamic-labs/logger');
+
+const logger = new logger$1.Logger('magic');
+
+exports.logger = logger;

package/src/logger/logger.d.ts

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

package/src/logger/logger.js

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

package/src/parseChainId.d.ts

@@ -1 +1 @@
-export declare const parseChainId: (chainId: number | string) => number;
+export declare const parseChainId: (chainId: number | string) => number;

package/src/parseEvmNetworks.cjs

@@ -4,12 +4,12 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var parseChainId = require('./parseChainId.cjs');
 
-const parseEvmNetworks = (networks) => {
-    const clone = networks.slice();
-    return clone.map((network) => {
-        network.chainId = parseChainId.parseChainId(network.chainId);
-        return network;
-    });
+const parseEvmNetworks = (networks) => {
+    const clone = networks.slice();
+    return clone.map((network) => {
+        network.chainId = parseChainId.parseChainId(network.chainId);
+        return network;
+    });
 };
 
 exports.parseEvmNetworks = parseEvmNetworks;

package/src/parseEvmNetworks.d.ts

@@ -1,2 +1,2 @@
-import { EvmNetwork, GenericNetwork } from '@dynamic-labs/types';
-export declare const parseEvmNetworks: (networks: GenericNetwork[]) => EvmNetwork[];
+import { EvmNetwork, GenericNetwork } from '@dynamic-labs/types';
+export declare const parseEvmNetworks: (networks: GenericNetwork[]) => EvmNetwork[];

package/src/parseEvmNetworks.js

@@ -1,11 +1,11 @@
 import { parseChainId } from './parseChainId.js';
 
-const parseEvmNetworks = (networks) => {
-    const clone = networks.slice();
-    return clone.map((network) => {
-        network.chainId = parseChainId(network.chainId);
-        return network;
-    });
+const parseEvmNetworks = (networks) => {
+    const clone = networks.slice();
+    return clone.map((network) => {
+        network.chainId = parseChainId(network.chainId);
+        return network;
+    });
 };
 
 export { parseEvmNetworks };

package/src/retryableFn.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../_virtual/_tslib.cjs');
+
+const FALLBACK_UNDEFINED = 'FALLBACK_UNDEFINED';
+const retryableFn = (fn, options = {}) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    const { maxRetries = 3, currentRetry = 0, timeoutMs = 100, fallbackValue = new Error('Max retries reached'), retryStrategy = 'timeout-only', } = options;
+    const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => {
+            reject(new Error('Timeout'));
+        }, timeoutMs);
+    });
+    try {
+        const result = yield Promise.race([fn(), timeoutPromise]);
+        return result;
+    }
+    catch (err) {
+        if (currentRetry >= maxRetries) {
+            if (fallbackValue instanceof Error) {
+                throw fallbackValue;
+            }
+            else if (fallbackValue === FALLBACK_UNDEFINED) {
+                return undefined;
+            }
+            return fallbackValue;
+        }
+        const isTimeout = err.message === 'Timeout';
+        const shouldRetry = retryStrategy === 'timeout-and-rejection' ||
+            (retryStrategy === 'timeout-only' && isTimeout) ||
+            (retryStrategy === 'rejection-only' && !isTimeout);
+        if (!shouldRetry) {
+            if (fallbackValue instanceof Error) {
+                throw err;
+            }
+            else if (fallbackValue === FALLBACK_UNDEFINED) {
+                return undefined;
+            }
+            return fallbackValue;
+        }
+        return retryableFn(fn, {
+            currentRetry: currentRetry + 1,
+            fallbackValue,
+            maxRetries,
+            retryStrategy,
+            timeoutMs,
+        });
+    }
+});
+
+exports.FALLBACK_UNDEFINED = FALLBACK_UNDEFINED;
+exports.retryableFn = retryableFn;

package/src/retryableFn.d.ts

@@ -0,0 +1,14 @@
+export declare const FALLBACK_UNDEFINED = "FALLBACK_UNDEFINED";
+export type RetryableFnOptions<T> = {
+    /** Maximum number of retry attempts before returning fallbackValue */
+    maxRetries?: number;
+    /** Internal only. Do not use */
+    currentRetry?: number;
+    /** Timeout in ms to wait before executing retryStrategy */
+    timeoutMs?: number;
+    /** The value to fallback to when function rejects or times out */
+    fallbackValue?: T | Error | typeof FALLBACK_UNDEFINED;
+    /** Configure whether the fn should be retried only on timeout, only on rejection, or both */
+    retryStrategy?: 'timeout-only' | 'rejection-only' | 'timeout-and-rejection';
+};
+export declare const retryableFn: <T>(fn: () => Promise<T>, options?: RetryableFnOptions<T>) => Promise<T>;

package/src/retryableFn.js

@@ -0,0 +1,48 @@
+import { __awaiter } from '../_virtual/_tslib.js';
+
+const FALLBACK_UNDEFINED = 'FALLBACK_UNDEFINED';
+const retryableFn = (fn, options = {}) => __awaiter(void 0, void 0, void 0, function* () {
+    const { maxRetries = 3, currentRetry = 0, timeoutMs = 100, fallbackValue = new Error('Max retries reached'), retryStrategy = 'timeout-only', } = options;
+    const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => {
+            reject(new Error('Timeout'));
+        }, timeoutMs);
+    });
+    try {
+        const result = yield Promise.race([fn(), timeoutPromise]);
+        return result;
+    }
+    catch (err) {
+        if (currentRetry >= maxRetries) {
+            if (fallbackValue instanceof Error) {
+                throw fallbackValue;
+            }
+            else if (fallbackValue === FALLBACK_UNDEFINED) {
+                return undefined;
+            }
+            return fallbackValue;
+        }
+        const isTimeout = err.message === 'Timeout';
+        const shouldRetry = retryStrategy === 'timeout-and-rejection' ||
+            (retryStrategy === 'timeout-only' && isTimeout) ||
+            (retryStrategy === 'rejection-only' && !isTimeout);
+        if (!shouldRetry) {
+            if (fallbackValue instanceof Error) {
+                throw err;
+            }
+            else if (fallbackValue === FALLBACK_UNDEFINED) {
+                return undefined;
+            }
+            return fallbackValue;
+        }
+        return retryableFn(fn, {
+            currentRetry: currentRetry + 1,
+            fallbackValue,
+            maxRetries,
+            retryStrategy,
+            timeoutMs,
+        });
+    }
+});
+
+export { FALLBACK_UNDEFINED, retryableFn };

package/src/sleep/index.d.ts

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

package/src/sleep/sleep.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// eslint-disable-next-line prefer-arrow/prefer-arrow-functions
+function sleep(timeoutMs, valueToResolve) {
+    return new Promise((resolve) => {
+        setTimeout(() => resolve(valueToResolve), timeoutMs);
+    });
+}
+
+exports.sleep = sleep;

package/src/sleep/sleep.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Delays the execution of subsequent code by a specified amount of time.
+ * If a value is provided, the promise will resolve with that value after the timeout.
+ *
+ * @template T - The type of the value to resolve with.
+ * @param {number} timeoutMs - The number of milliseconds to delay.
+ * @param {T} [valueToResolve] - Optional value to resolve the promise with after the timeout.
+ * @returns {Promise<T | void>} - Resolves after the specified timeout with valueToResolve or void.
+ */
+export declare function sleep(timeoutMs: number): Promise<void>;
+export declare function sleep<T>(timeoutMs: number, valueToResolve: T): Promise<T>;

package/src/sleep/sleep.js

@@ -0,0 +1,8 @@
+// eslint-disable-next-line prefer-arrow/prefer-arrow-functions
+function sleep(timeoutMs, valueToResolve) {
+    return new Promise((resolve) => {
+        setTimeout(() => resolve(valueToResolve), timeoutMs);
+    });
+}
+
+export { sleep };