@dynamic-labs/utils 0.0.0-exp20240808.0

package/src/parseEvmNetworks.js

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

package/src/pipe/index.d.ts

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

package/src/pipe/pipe.cjs

@@ -0,0 +1,40 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Creates a chainable function that allows adding additional transformations
+ * or operations via the `pipe` method, where each function in the chain
+ * can operate on the output type of the previous function.
+ * @param initialFunc The initial function to start the chain.
+ *  @returns An object representing the chain of functions. The returned object
+ * has a `pipe` method to add more functions to the chain and can be invoked
+ * directly to execute the chain of functions with an input.
+ * @example
+ * ```
+ * // Define a function that increments its input
+ * const increment = (x: number) => x + 1;
+ * // Create a function chain starting with the increment function
+ * const chain = createFnPipe(increment)
+ *   .pipe(x => x * 2) // After incrementing, multiply the result by 2
+ *   .pipe(x => `Result: ${x}`); // Then, convert the number to a string with a prefix
+ *
+ * console.log(chain(3)); // Output: "Result: 8"
+ * ```
+ */
+const pipe = (initialFunc) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const funcs = [initialFunc];
+    const executeFn = (input) => funcs.reduce((acc, func) => func(acc), input);
+    const pipe = (newFunc) => {
+        funcs.push(newFunc);
+        // The type assertion to Func<T, V> is necessary to align with the evolving return type.
+        return Object.assign((input) => executeFn(input), {
+            pipe,
+        });
+    };
+    return Object.assign(executeFn, { pipe });
+};
+
+exports.pipe = pipe;

package/src/pipe/pipe.d.ts

@@ -0,0 +1,27 @@
+type Func<T, U> = (input: T) => U;
+/**
+ * Creates a chainable function that allows adding additional transformations
+ * or operations via the `pipe` method, where each function in the chain
+ * can operate on the output type of the previous function.
+ * @param initialFunc The initial function to start the chain.
+ *  @returns An object representing the chain of functions. The returned object
+ * has a `pipe` method to add more functions to the chain and can be invoked
+ * directly to execute the chain of functions with an input.
+ * @example
+ * ```
+ * // Define a function that increments its input
+ * const increment = (x: number) => x + 1;
+ * // Create a function chain starting with the increment function
+ * const chain = createFnPipe(increment)
+ *   .pipe(x => x * 2) // After incrementing, multiply the result by 2
+ *   .pipe(x => `Result: ${x}`); // Then, convert the number to a string with a prefix
+ *
+ * console.log(chain(3)); // Output: "Result: 8"
+ * ```
+ */
+export declare const pipe: <T, U>(initialFunc: Func<T, U>) => Func<T, U> & {
+    pipe: <V>(newFunc: Func<U, V>) => Func<T, V> & {
+        pipe: any;
+    };
+};
+export {};

package/src/pipe/pipe.js

@@ -0,0 +1,36 @@
+'use client'
+/**
+ * Creates a chainable function that allows adding additional transformations
+ * or operations via the `pipe` method, where each function in the chain
+ * can operate on the output type of the previous function.
+ * @param initialFunc The initial function to start the chain.
+ *  @returns An object representing the chain of functions. The returned object
+ * has a `pipe` method to add more functions to the chain and can be invoked
+ * directly to execute the chain of functions with an input.
+ * @example
+ * ```
+ * // Define a function that increments its input
+ * const increment = (x: number) => x + 1;
+ * // Create a function chain starting with the increment function
+ * const chain = createFnPipe(increment)
+ *   .pipe(x => x * 2) // After incrementing, multiply the result by 2
+ *   .pipe(x => `Result: ${x}`); // Then, convert the number to a string with a prefix
+ *
+ * console.log(chain(3)); // Output: "Result: 8"
+ * ```
+ */
+const pipe = (initialFunc) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const funcs = [initialFunc];
+    const executeFn = (input) => funcs.reduce((acc, func) => func(acc), input);
+    const pipe = (newFunc) => {
+        funcs.push(newFunc);
+        // The type assertion to Func<T, V> is necessary to align with the evolving return type.
+        return Object.assign((input) => executeFn(input), {
+            pipe,
+        });
+    };
+    return Object.assign(executeFn, { pipe });
+};
+
+export { pipe };

package/src/retryableFn.cjs

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

package/src/retryableFn.d.ts

@@ -0,0 +1,19 @@
+import { Logger } from '@dynamic-labs/logger';
+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';
+    /** Set the logger to be used */
+    logger?: Logger | typeof console;
+    /** Ms to wait before a retry */
+    retryIntervalMs?: number;
+};
+export declare const retryableFn: <T>(fn: () => Promise<T>, options?: RetryableFnOptions<T>) => Promise<T>;

package/src/retryableFn.js

@@ -0,0 +1,68 @@
+'use client'
+import { __awaiter } from '../_virtual/_tslib.js';
+import { sleep } from './sleep/sleep.js';
+
+const FALLBACK_UNDEFINED = 'FALLBACK_UNDEFINED';
+const retryableFn = (fn_1, ...args_1) => __awaiter(void 0, [fn_1, ...args_1], void 0, function* (fn, options = {}) {
+    const { maxRetries = 3, currentRetry = 0, timeoutMs = 100, fallbackValue = new Error('Max retries reached'), retryStrategy = 'timeout-only', retryIntervalMs = 0, logger, } = options;
+    logger === null || logger === void 0 ? void 0 : logger.debug('Configured retryableFn with options: ', {
+        currentRetry,
+        fallbackValue,
+        maxRetries,
+        retryStrategy,
+        timeoutMs,
+    });
+    const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => {
+            reject(new Error('Timeout'));
+        }, timeoutMs);
+    });
+    try {
+        const result = yield Promise.race([fn(), timeoutPromise]);
+        return result;
+    }
+    catch (err) {
+        logger === null || logger === void 0 ? void 0 : logger.debug('retryableFn caught error: ', err);
+        if (currentRetry >= maxRetries) {
+            logger === null || logger === void 0 ? void 0 : logger.error('Error while retrying function, returning/throwing fallback value', err, fallbackValue);
+            if (fallbackValue instanceof Error) {
+                throw fallbackValue;
+            }
+            else if (fallbackValue === FALLBACK_UNDEFINED) {
+                return undefined;
+            }
+            return fallbackValue;
+        }
+        const isTimeout = (err === null || err === void 0 ? void 0 : err.message) === 'Timeout';
+        const shouldRetry = retryStrategy === 'timeout-and-rejection' ||
+            (retryStrategy === 'timeout-only' && isTimeout) ||
+            (retryStrategy === 'rejection-only' && !isTimeout);
+        logger === null || logger === void 0 ? void 0 : logger.debug('retryableFn shouldRetry: ', shouldRetry);
+        if (!shouldRetry) {
+            if (fallbackValue instanceof Error) {
+                logger === null || logger === void 0 ? void 0 : logger.debug('retryableFn throwing fallbackValue error: ', fallbackValue);
+                throw err;
+            }
+            else if (fallbackValue === FALLBACK_UNDEFINED) {
+                logger === null || logger === void 0 ? void 0 : logger.debug('retryableFn returning undefined');
+                return undefined;
+            }
+            logger === null || logger === void 0 ? void 0 : logger.debug('retryableFn returning fallbackValue: ', fallbackValue);
+            logger === null || logger === void 0 ? void 0 : logger.error('Error while retrying function, returning fallback value', err);
+            return fallbackValue;
+        }
+        if (retryIntervalMs)
+            yield sleep(retryIntervalMs);
+        return retryableFn(fn, {
+            currentRetry: currentRetry + 1,
+            fallbackValue,
+            logger,
+            maxRetries,
+            retryIntervalMs,
+            retryStrategy,
+            timeoutMs,
+        });
+    }
+});
+
+export { FALLBACK_UNDEFINED, retryableFn };

package/src/runSafe/index.d.ts

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

package/src/runSafe/runSafe.cjs

@@ -0,0 +1,25 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+
+/**
+ * Safely executes a callback function.
+ * @template T The type of the callback's return value.
+ * @template E The type of the error.
+ * @param {() => Promise<T> | T} callback A function that might throw an error.
+ * @returns {Promise<[T | undefined, E | undefined]>} A tuple with either the result or the error.
+ */
+const runSafe = (callback) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const resolved = yield callback();
+        return [resolved, undefined];
+    }
+    catch (error) {
+        return [undefined, error];
+    }
+});
+
+exports.runSafe = runSafe;

package/src/runSafe/runSafe.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Safely executes a callback function.
+ * @template T The type of the callback's return value.
+ * @template E The type of the error.
+ * @param {() => Promise<T> | T} callback A function that might throw an error.
+ * @returns {Promise<[T | undefined, E | undefined]>} A tuple with either the result or the error.
+ */
+export declare const runSafe: <T, E>(callback: () => Promise<T> | T) => Promise<[T | undefined, E | undefined]>;

package/src/runSafe/runSafe.js

@@ -0,0 +1,21 @@
+'use client'
+import { __awaiter } from '../../_virtual/_tslib.js';
+
+/**
+ * Safely executes a callback function.
+ * @template T The type of the callback's return value.
+ * @template E The type of the error.
+ * @param {() => Promise<T> | T} callback A function that might throw an error.
+ * @returns {Promise<[T | undefined, E | undefined]>} A tuple with either the result or the error.
+ */
+const runSafe = (callback) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const resolved = yield callback();
+        return [resolved, undefined];
+    }
+    catch (error) {
+        return [undefined, error];
+    }
+});
+
+export { runSafe };

package/src/services/FetchService/FetchService.cjs

@@ -0,0 +1,29 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+
+var _a, _FetchService_implementation;
+/**
+ * Class implementing the fetch service with a configurable fetch implementation.
+ */
+class FetchService {
+    static get implementation() {
+        if (!_tslib.__classPrivateFieldGet(_a, _a, "f", _FetchService_implementation)) {
+            return { fetch: window.fetch.bind(window) };
+        }
+        return _tslib.__classPrivateFieldGet(_a, _a, "f", _FetchService_implementation);
+    }
+    static set implementation(implementation) {
+        _tslib.__classPrivateFieldSet(_a, _a, implementation, "f", _FetchService_implementation);
+    }
+    static get fetch() {
+        return _a.implementation.fetch;
+    }
+}
+_a = FetchService;
+_FetchService_implementation = { value: void 0 };
+
+exports.FetchService = FetchService;

package/src/services/FetchService/FetchService.d.ts

@@ -0,0 +1,10 @@
+import { IFetchService } from './types';
+/**
+ * Class implementing the fetch service with a configurable fetch implementation.
+ */
+export declare class FetchService {
+    #private;
+    static get implementation(): IFetchService;
+    static set implementation(implementation: IFetchService);
+    static get fetch(): (input: RequestInfo, init?: RequestInit | undefined) => Promise<Response>;
+}

package/src/services/FetchService/FetchService.js

@@ -0,0 +1,25 @@
+'use client'
+import { __classPrivateFieldGet, __classPrivateFieldSet } from '../../../_virtual/_tslib.js';
+
+var _a, _FetchService_implementation;
+/**
+ * Class implementing the fetch service with a configurable fetch implementation.
+ */
+class FetchService {
+    static get implementation() {
+        if (!__classPrivateFieldGet(_a, _a, "f", _FetchService_implementation)) {
+            return { fetch: window.fetch.bind(window) };
+        }
+        return __classPrivateFieldGet(_a, _a, "f", _FetchService_implementation);
+    }
+    static set implementation(implementation) {
+        __classPrivateFieldSet(_a, _a, implementation, "f", _FetchService_implementation);
+    }
+    static get fetch() {
+        return _a.implementation.fetch;
+    }
+}
+_a = FetchService;
+_FetchService_implementation = { value: void 0 };
+
+export { FetchService };

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

@@ -0,0 +1,2 @@
+export { FetchService } from './FetchService';
+export type { IFetchService } from './types';

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

@@ -0,0 +1,3 @@
+export type IFetchService = {
+    fetch: (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+};

package/src/services/Oauth2Service/Oauth2Service.cjs

@@ -0,0 +1,38 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var types = require('@dynamic-labs/types');
+var createWindowOauth2Service = require('./createWindowOauth2Service/createWindowOauth2Service.cjs');
+
+var _a, _Oauth2Service_implementation;
+/**
+ * Class implementing the fetch service with a configurable fetch implementation.
+ */
+class Oauth2Service {
+    static get implementation() {
+        if (!_tslib.__classPrivateFieldGet(_a, _a, "f", _Oauth2Service_implementation)) {
+            return createWindowOauth2Service.createWindowOauth2Service();
+        }
+        return _tslib.__classPrivateFieldGet(_a, _a, "f", _Oauth2Service_implementation);
+    }
+    static set implementation(implementation) {
+        _tslib.__classPrivateFieldSet(_a, _a, implementation, "f", _Oauth2Service_implementation);
+    }
+    static get getOauthCode() {
+        return _a.implementation.getOauthCode;
+    }
+}
+_a = Oauth2Service;
+_Oauth2Service_implementation = { value: void 0 };
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+Oauth2Service.isGetOauthCodeError = (error) => error === 'user-cancelled' ||
+    (typeof error === 'object' &&
+        'code' in error &&
+        Object.values(types.SocialOAuthErrorCode).includes(error.code) &&
+        'message' in error &&
+        typeof error.message === 'string');
+
+exports.Oauth2Service = Oauth2Service;

package/src/services/Oauth2Service/Oauth2Service.d.ts

@@ -0,0 +1,34 @@
+import { OauthResultResponse, Provider, ProviderEnum } from '@dynamic-labs/sdk-api-core';
+import { SocialOAuthErrorCode } from '@dynamic-labs/types';
+export type GetOauthCodeProps = {
+    provider: ProviderEnum;
+    apiProvider: Provider | undefined;
+    setIsProcessing: (value: boolean) => void;
+    onSettled?: VoidFunction;
+    getOAuthResultFromApi: () => Promise<OauthResultResponse | undefined>;
+    state: string;
+    oauthLoginUrl: URL;
+    sessionTimeout: number;
+    /**
+     * Overrides the default redirectUrl coming from the DynamicContextProvider
+     */
+    redirectUrl?: string;
+    isMobile?: boolean;
+};
+export type IOauth2Service = {
+    getOauthCode: (props: GetOauthCodeProps) => Promise<string>;
+};
+export type GetOauthCodeError = 'user-cancelled' | {
+    code: SocialOAuthErrorCode;
+    message: string;
+};
+/**
+ * Class implementing the fetch service with a configurable fetch implementation.
+ */
+export declare class Oauth2Service {
+    #private;
+    static get implementation(): IOauth2Service;
+    static set implementation(implementation: IOauth2Service);
+    static get getOauthCode(): (props: GetOauthCodeProps) => Promise<string>;
+    static isGetOauthCodeError: (error: any) => error is GetOauthCodeError;
+}

package/src/services/Oauth2Service/Oauth2Service.js

@@ -0,0 +1,34 @@
+'use client'
+import { __classPrivateFieldGet, __classPrivateFieldSet } from '../../../_virtual/_tslib.js';
+import { SocialOAuthErrorCode } from '@dynamic-labs/types';
+import { createWindowOauth2Service } from './createWindowOauth2Service/createWindowOauth2Service.js';
+
+var _a, _Oauth2Service_implementation;
+/**
+ * Class implementing the fetch service with a configurable fetch implementation.
+ */
+class Oauth2Service {
+    static get implementation() {
+        if (!__classPrivateFieldGet(_a, _a, "f", _Oauth2Service_implementation)) {
+            return createWindowOauth2Service();
+        }
+        return __classPrivateFieldGet(_a, _a, "f", _Oauth2Service_implementation);
+    }
+    static set implementation(implementation) {
+        __classPrivateFieldSet(_a, _a, implementation, "f", _Oauth2Service_implementation);
+    }
+    static get getOauthCode() {
+        return _a.implementation.getOauthCode;
+    }
+}
+_a = Oauth2Service;
+_Oauth2Service_implementation = { value: void 0 };
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+Oauth2Service.isGetOauthCodeError = (error) => error === 'user-cancelled' ||
+    (typeof error === 'object' &&
+        'code' in error &&
+        Object.values(SocialOAuthErrorCode).includes(error.code) &&
+        'message' in error &&
+        typeof error.message === 'string');
+
+export { Oauth2Service };