@dynamic-labs/sdk-react-core 0.18.0-RC.9 → 0.18.0-beta.28

package/src/lib/utils/hooks/useFetchProjectSettings/useFetchProjectSettings.js

@@ -1,6 +1,6 @@
 import { useState, useEffect, useMemo } from 'react';
 import { DynamicError } from '@dynamic-labs/utils';
-import { fetchProjectSettings } from '../../../data/api.js';
+import { sendDynamicProps, fetchProjectSettings } from '../../../data/api.js';
 import '@dynamic-labs/sdk-api';
 import '../../../shared/logger.js';
 import '@dynamic-labs/iconic';
@@ -18,7 +18,7 @@ import { validateLocalStorageExpiry } from '../../../context/DynamicContext/vali
 import '@dynamic-labs/multi-wallet';
 import { getEnabledProviders } from '../../functions/getEnabledProviders/index.js';
 
-const useFetchProjectSettings = ({ authToken, environmentId, maxRetries = 2, }) => {
+const useFetchProjectSettings = ({ authToken, environmentId, maxRetries = 2, dynamicContextProps, }) => {
     const [lsSettings, setLsSettings, removeLsSettings] = useLocalStorage(PROJECT_SETTINGS_STORAGE_KEY, undefined, validateLocalStorageExpiry);
     const [isLoading, setLoading] = useState(false);
     const [retries, setRetries] = useState(0);
@@ -40,6 +40,7 @@ const useFetchProjectSettings = ({ authToken, environmentId, maxRetries = 2, })
             environmentId &&
             retries < maxRetries) {
             setLoading(true);
+            sendDynamicProps(environmentId, { dynamicContextProps });
             fetchProjectSettings(environmentId)
                 .then((response) => {
                 if (!response)

package/src/lib/utils/hooks/useHandleWalletsToConnect/useHandleWalletsToConnect.cjs

@@ -6,14 +6,19 @@ var useInternalDynamicContext = require('../../../context/DynamicContext/useInte
 var ViewContext = require('../../../context/ViewContext/ViewContext.cjs');
 
 const useHandleWalletsToConnect = () => {
-    const { walletsToConnectByChain, setWalletsToConnectByChain, setShowAuthFlow, setConnectedUser, isUserConnected, } = useInternalDynamicContext.useInternalDynamicContext();
+    const { walletsToConnectByChain, setWalletsToConnectByChain, setShowAuthFlow, setIsFullyConnected, isFullyConnected, } = useInternalDynamicContext.useInternalDynamicContext();
     const { setView, goToInitialView } = ViewContext.useViewContext();
     const handleWalletsToConnect = () => {
         if (!walletsToConnectByChain) {
-            setConnectedUser(true);
+            setIsFullyConnected(true);
             setShowAuthFlow(false);
             return;
         }
+        // Avoid showing wallet-list when wallet updates network to the correct one in run time (bridge mode)
+        if (walletsToConnectByChain.length === 0) {
+            setShowAuthFlow(false);
+            return goToInitialView();
+        }
         const [firstWallet, ...restOfTheWallets] = walletsToConnectByChain;
         if (firstWallet.numberOfWallets > 1) {
             const updatedWallets = [
@@ -27,8 +32,8 @@ const useHandleWalletsToConnect = () => {
         setWalletsToConnectByChain(restOfTheWallets);
         const allWalletsConnected = restOfTheWallets.length === 0;
         if (allWalletsConnected) {
-            if (!isUserConnected) {
-                setConnectedUser(true);
+            if (!isFullyConnected) {
+                setIsFullyConnected(true);
                 setView('bridge-summary');
             }
             else {
@@ -37,7 +42,7 @@ const useHandleWalletsToConnect = () => {
             }
             return;
         }
-        setView('wallet-list');
+        setView('bridge-next-wallet-connection');
     };
     return { handleWalletsToConnect };
 };

package/src/lib/utils/hooks/useHandleWalletsToConnect/useHandleWalletsToConnect.js

@@ -2,14 +2,19 @@ import { useInternalDynamicContext } from '../../../context/DynamicContext/useIn
 import { useViewContext } from '../../../context/ViewContext/ViewContext.js';
 
 const useHandleWalletsToConnect = () => {
-    const { walletsToConnectByChain, setWalletsToConnectByChain, setShowAuthFlow, setConnectedUser, isUserConnected, } = useInternalDynamicContext();
+    const { walletsToConnectByChain, setWalletsToConnectByChain, setShowAuthFlow, setIsFullyConnected, isFullyConnected, } = useInternalDynamicContext();
     const { setView, goToInitialView } = useViewContext();
     const handleWalletsToConnect = () => {
         if (!walletsToConnectByChain) {
-            setConnectedUser(true);
+            setIsFullyConnected(true);
             setShowAuthFlow(false);
             return;
         }
+        // Avoid showing wallet-list when wallet updates network to the correct one in run time (bridge mode)
+        if (walletsToConnectByChain.length === 0) {
+            setShowAuthFlow(false);
+            return goToInitialView();
+        }
         const [firstWallet, ...restOfTheWallets] = walletsToConnectByChain;
         if (firstWallet.numberOfWallets > 1) {
             const updatedWallets = [
@@ -23,8 +28,8 @@ const useHandleWalletsToConnect = () => {
         setWalletsToConnectByChain(restOfTheWallets);
         const allWalletsConnected = restOfTheWallets.length === 0;
         if (allWalletsConnected) {
-            if (!isUserConnected) {
-                setConnectedUser(true);
+            if (!isFullyConnected) {
+                setIsFullyConnected(true);
                 setView('bridge-summary');
             }
             else {
@@ -33,7 +38,7 @@ const useHandleWalletsToConnect = () => {
             }
             return;
         }
-        setView('wallet-list');
+        setView('bridge-next-wallet-connection');
     };
     return { handleWalletsToConnect };
 };

package/src/lib/utils/hooks/useKYCFlag/useKYCFlag.cjs

@@ -5,8 +5,23 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var useInternalDynamicContext = require('../../../context/DynamicContext/useInternalDynamicContext.cjs');
 var useOnlyConnectedMode = require('../useOnlyConnectedMode/useOnlyConnectedMode.cjs');
 var getUserProfileFields = require('../../functions/getUserProfileFields/getUserProfileFields.cjs');
+require('@dynamic-labs/sdk-api');
+require('../../../shared/logger.cjs');
+require('@dynamic-labs/iconic');
+require('@dynamic-labs/wallet-connector-core');
+require('react/jsx-runtime');
+require('../../../context/ViewContext/ViewContext.cjs');
+require('react');
+require('@dynamic-labs/wallet-book');
+require('@dynamic-labs/utils');
+require('../../constants/colors.cjs');
+require('../../../shared/utils/classes/storage/localStorage.cjs');
+require('ethers');
+require('../../../shared/consts/index.cjs');
+require('@dynamic-labs/multi-wallet');
+var isSocialKycEnabled = require('../../functions/isSocialKycEnabled/isSocialKycEnabled.cjs');
 
-const isSocialEnabled = (kyc = []) => { var _a; return Boolean((_a = kyc.find(({ name }) => name === 'social')) === null || _a === void 0 ? void 0 : _a.enabled); };
+/* eslint-disable max-len */
 /**
  * A custom React hook that checks if KYC fields are enabled in the project settings or defined in the user profile.
  *
@@ -21,7 +36,7 @@ const useKYCFlag = () => {
         projectSettingsKyc: projectSettings === null || projectSettings === void 0 ? void 0 : projectSettings.kyc,
         user,
     });
-    return hasAnyKYCFields.length > 0 || isSocialEnabled(projectSettings === null || projectSettings === void 0 ? void 0 : projectSettings.kyc);
+    return hasAnyKYCFields.length > 0 || isSocialKycEnabled.isSocialKycEnabled(projectSettings);
 };
 
 exports.useKYCFlag = useKYCFlag;

package/src/lib/utils/hooks/useKYCFlag/useKYCFlag.js

@@ -1,8 +1,23 @@
 import { useInternalDynamicContext } from '../../../context/DynamicContext/useInternalDynamicContext.js';
 import { useOnlyConnectedMode } from '../useOnlyConnectedMode/useOnlyConnectedMode.js';
 import { getUserProfileFields } from '../../functions/getUserProfileFields/getUserProfileFields.js';
+import '@dynamic-labs/sdk-api';
+import '../../../shared/logger.js';
+import '@dynamic-labs/iconic';
+import '@dynamic-labs/wallet-connector-core';
+import 'react/jsx-runtime';
+import '../../../context/ViewContext/ViewContext.js';
+import 'react';
+import '@dynamic-labs/wallet-book';
+import '@dynamic-labs/utils';
+import '../../constants/colors.js';
+import '../../../shared/utils/classes/storage/localStorage.js';
+import 'ethers';
+import '../../../shared/consts/index.js';
+import '@dynamic-labs/multi-wallet';
+import { isSocialKycEnabled } from '../../functions/isSocialKycEnabled/isSocialKycEnabled.js';
 
-const isSocialEnabled = (kyc = []) => { var _a; return Boolean((_a = kyc.find(({ name }) => name === 'social')) === null || _a === void 0 ? void 0 : _a.enabled); };
+/* eslint-disable max-len */
 /**
  * A custom React hook that checks if KYC fields are enabled in the project settings or defined in the user profile.
  *
@@ -17,7 +32,7 @@ const useKYCFlag = () => {
         projectSettingsKyc: projectSettings === null || projectSettings === void 0 ? void 0 : projectSettings.kyc,
         user,
     });
-    return hasAnyKYCFields.length > 0 || isSocialEnabled(projectSettings === null || projectSettings === void 0 ? void 0 : projectSettings.kyc);
+    return hasAnyKYCFields.length > 0 || isSocialKycEnabled(projectSettings);
 };
 
 export { useKYCFlag };

package/src/lib/utils/hooks/usePromise/usePromise.cjs

@@ -2,46 +2,106 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var _tslib = require('../../../../../_virtual/_tslib.cjs');
 var React = require('react');
+require('@dynamic-labs/sdk-api');
+var logger = require('../../../shared/logger.cjs');
+require('@dynamic-labs/iconic');
+require('@dynamic-labs/wallet-connector-core');
+require('react/jsx-runtime');
+require('../../../context/ViewContext/ViewContext.cjs');
+require('@dynamic-labs/wallet-book');
+require('@dynamic-labs/utils');
+require('../../constants/colors.cjs');
+require('../../../shared/utils/classes/storage/localStorage.cjs');
+require('ethers');
+require('../../../shared/consts/index.cjs');
+var resolveFetcher = require('./utils/resolveFetcher/resolveFetcher.cjs');
+var createReducer = require('./utils/createReducer/createReducer.cjs');
 
-const usePromise = (fetcher, deps = [], options = {
-    enabled: true,
-}) => {
-    const [state, setState] = React.useState({
-        active: false,
+/**
+ * Custom hook for handling promises and fetching data.
+ * @template T - The type of the data returned by the promise.
+ * @template E - The type of the error thrown by the promise.
+ * @param {() => T | Promise<T>} fetcher - A function that returns the data or a promise that resolves to the data.
+ * @param {UsePromiseOptions<T, E>} [options={}] - Options for the hook.
+ * @param {number} [options.retries] - The number of times to retry the fetch in case of failure.
+ * @param {T} [options.initialData] - The initial data the hook will use until the promise is resolved.
+ * @param {DependencyList} [options.deps=[]] - An array of dependencies for the hook.
+ * @param {boolean} [options.enabled] - Flag indicating whether the fetch should be enabled or not.
+ * @param {(data: T) => void} [options.onResolve] - Callback to be called when the fetch is resolved successfully.
+ * @param {(error: E) => void} [options.onReject] - Callback to be called when the fetch is rejected with an error.
+ * @returns {PromiseState<T, E>} - The state object containing the data, error, and loading status.
+ * @example
+ * // Example usage with a simple fetcher function
+ * const fetcher = fetch('https://api.example.com/data');
+ *
+ * const MyComponent = () => {
+ *  const { data, isLoading, error } = usePromise(fetcher);
+ *
+ *  if (isLoading) {
+ *    return <div>Loading...</div>;
+ *  }
+ *
+ *  if (error) {
+ *    return <div>Error: {error.message}</div>;
+ *  }
+ *
+ * return <div>Data: {data}</div>;
+ * };
+ */
+const usePromise = (fetcher, options) => {
+    const lastCallTimestamp = React.useRef(new Date().getTime());
+    const { deps = [], initialData = undefined, enabled = true, retries = 0, onReject = () => { }, onResolve = () => { }, } = options || {};
+    const [state, dispatch] = React.useReducer(createReducer.createReducer(), {
+        data: initialData,
+        isLoading: true,
     });
-    const fetch = React.useCallback(() => _tslib.__awaiter(void 0, void 0, void 0, function* () {
-        setState({
-            active: true,
-        });
-        try {
-            let data;
-            const fetchData = fetcher();
-            if (fetchData instanceof Promise) {
-                data = yield fetchData;
-            }
-            else {
-                data = fetchData;
-            }
-            setState({
-                active: false,
-                data,
-            });
+    const callback = React.useCallback(() => {
+        const callTimestamp = new Date().getTime();
+        const diffFromLastCall = callTimestamp - lastCallTimestamp.current;
+        if (diffFromLastCall < 5) {
+            logger.logger.warn('usePromise: Fetcher function was called too soon. Please make sure you are not calling the fetcher function inside a loop or a synchronous function.', deps);
         }
-        catch (error) {
-            setState({
-                active: false,
-                error: error,
+        lastCallTimestamp.current = callTimestamp;
+        if (!state.isLoading) {
+            dispatch({
+                payload: true,
+                type: 'SET_LOADING',
             });
         }
-    }), [setState, fetcher]);
+        resolveFetcher.resolveFetcher(fetcher, { retries }, (error, data) => {
+            if (callTimestamp !== lastCallTimestamp.current)
+                return;
+            if (error) {
+                logger.logger.error(error);
+                dispatch({
+                    payload: error,
+                    type: 'SET_ERROR',
+                });
+                onReject === null || onReject === void 0 ? void 0 : onReject(error);
+                return;
+            }
+            if (data) {
+                dispatch({
+                    payload: data,
+                    type: 'SET_DATA',
+                });
+                onResolve === null || onResolve === void 0 ? void 0 : onResolve(data);
+                return;
+            }
+            dispatch({
+                payload: false,
+                type: 'SET_LOADING',
+            });
+        });
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, deps);
     React.useEffect(() => {
-        if (options.enabled) {
-            fetch();
+        if (enabled) {
+            callback();
         }
-    }, deps);
-    return Object.assign(Object.assign({}, state), { isLoading: state.active });
+    }, [callback, enabled]);
+    return state;
 };
 
 exports.usePromise = usePromise;

package/src/lib/utils/hooks/usePromise/usePromise.d.ts

@@ -1,6 +1,33 @@
-import { DependencyList } from 'react';
-import { PromiseState } from './usePromise.types';
-export type UsePromiseOptions = {
-    enabled?: boolean;
-};
-export declare const usePromise: <T = unknown, E = unknown>(fetcher: () => T | Promise<T>, deps?: DependencyList, options?: UsePromiseOptions) => PromiseState<T, E>;
+import { UsePromiseOptions, PromiseState } from './usePromise.types';
+/**
+ * Custom hook for handling promises and fetching data.
+ * @template T - The type of the data returned by the promise.
+ * @template E - The type of the error thrown by the promise.
+ * @param {() => T | Promise<T>} fetcher - A function that returns the data or a promise that resolves to the data.
+ * @param {UsePromiseOptions<T, E>} [options={}] - Options for the hook.
+ * @param {number} [options.retries] - The number of times to retry the fetch in case of failure.
+ * @param {T} [options.initialData] - The initial data the hook will use until the promise is resolved.
+ * @param {DependencyList} [options.deps=[]] - An array of dependencies for the hook.
+ * @param {boolean} [options.enabled] - Flag indicating whether the fetch should be enabled or not.
+ * @param {(data: T) => void} [options.onResolve] - Callback to be called when the fetch is resolved successfully.
+ * @param {(error: E) => void} [options.onReject] - Callback to be called when the fetch is rejected with an error.
+ * @returns {PromiseState<T, E>} - The state object containing the data, error, and loading status.
+ * @example
+ * // Example usage with a simple fetcher function
+ * const fetcher = fetch('https://api.example.com/data');
+ *
+ * const MyComponent = () => {
+ *  const { data, isLoading, error } = usePromise(fetcher);
+ *
+ *  if (isLoading) {
+ *    return <div>Loading...</div>;
+ *  }
+ *
+ *  if (error) {
+ *    return <div>Error: {error.message}</div>;
+ *  }
+ *
+ * return <div>Data: {data}</div>;
+ * };
+ */
+export declare const usePromise: <T, E = Error>(fetcher: () => T | Promise<T>, options?: UsePromiseOptions<T, E> | undefined) => PromiseState<T, E>;

package/src/lib/utils/hooks/usePromise/usePromise.js

@@ -1,43 +1,103 @@
-import { __awaiter } from '../../../../../_virtual/_tslib.js';
-import { useState, useCallback, useEffect } from 'react';
+import { useRef, useReducer, useCallback, useEffect } from 'react';
+import '@dynamic-labs/sdk-api';
+import { logger } from '../../../shared/logger.js';
+import '@dynamic-labs/iconic';
+import '@dynamic-labs/wallet-connector-core';
+import 'react/jsx-runtime';
+import '../../../context/ViewContext/ViewContext.js';
+import '@dynamic-labs/wallet-book';
+import '@dynamic-labs/utils';
+import '../../constants/colors.js';
+import '../../../shared/utils/classes/storage/localStorage.js';
+import 'ethers';
+import '../../../shared/consts/index.js';
+import { resolveFetcher } from './utils/resolveFetcher/resolveFetcher.js';
+import { createReducer } from './utils/createReducer/createReducer.js';
 
-const usePromise = (fetcher, deps = [], options = {
-    enabled: true,
-}) => {
-    const [state, setState] = useState({
-        active: false,
+/**
+ * Custom hook for handling promises and fetching data.
+ * @template T - The type of the data returned by the promise.
+ * @template E - The type of the error thrown by the promise.
+ * @param {() => T | Promise<T>} fetcher - A function that returns the data or a promise that resolves to the data.
+ * @param {UsePromiseOptions<T, E>} [options={}] - Options for the hook.
+ * @param {number} [options.retries] - The number of times to retry the fetch in case of failure.
+ * @param {T} [options.initialData] - The initial data the hook will use until the promise is resolved.
+ * @param {DependencyList} [options.deps=[]] - An array of dependencies for the hook.
+ * @param {boolean} [options.enabled] - Flag indicating whether the fetch should be enabled or not.
+ * @param {(data: T) => void} [options.onResolve] - Callback to be called when the fetch is resolved successfully.
+ * @param {(error: E) => void} [options.onReject] - Callback to be called when the fetch is rejected with an error.
+ * @returns {PromiseState<T, E>} - The state object containing the data, error, and loading status.
+ * @example
+ * // Example usage with a simple fetcher function
+ * const fetcher = fetch('https://api.example.com/data');
+ *
+ * const MyComponent = () => {
+ *  const { data, isLoading, error } = usePromise(fetcher);
+ *
+ *  if (isLoading) {
+ *    return <div>Loading...</div>;
+ *  }
+ *
+ *  if (error) {
+ *    return <div>Error: {error.message}</div>;
+ *  }
+ *
+ * return <div>Data: {data}</div>;
+ * };
+ */
+const usePromise = (fetcher, options) => {
+    const lastCallTimestamp = useRef(new Date().getTime());
+    const { deps = [], initialData = undefined, enabled = true, retries = 0, onReject = () => { }, onResolve = () => { }, } = options || {};
+    const [state, dispatch] = useReducer(createReducer(), {
+        data: initialData,
+        isLoading: true,
     });
-    const fetch = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
-        setState({
-            active: true,
-        });
-        try {
-            let data;
-            const fetchData = fetcher();
-            if (fetchData instanceof Promise) {
-                data = yield fetchData;
-            }
-            else {
-                data = fetchData;
-            }
-            setState({
-                active: false,
-                data,
-            });
+    const callback = useCallback(() => {
+        const callTimestamp = new Date().getTime();
+        const diffFromLastCall = callTimestamp - lastCallTimestamp.current;
+        if (diffFromLastCall < 5) {
+            logger.warn('usePromise: Fetcher function was called too soon. Please make sure you are not calling the fetcher function inside a loop or a synchronous function.', deps);
         }
-        catch (error) {
-            setState({
-                active: false,
-                error: error,
+        lastCallTimestamp.current = callTimestamp;
+        if (!state.isLoading) {
+            dispatch({
+                payload: true,
+                type: 'SET_LOADING',
             });
         }
-    }), [setState, fetcher]);
+        resolveFetcher(fetcher, { retries }, (error, data) => {
+            if (callTimestamp !== lastCallTimestamp.current)
+                return;
+            if (error) {
+                logger.error(error);
+                dispatch({
+                    payload: error,
+                    type: 'SET_ERROR',
+                });
+                onReject === null || onReject === void 0 ? void 0 : onReject(error);
+                return;
+            }
+            if (data) {
+                dispatch({
+                    payload: data,
+                    type: 'SET_DATA',
+                });
+                onResolve === null || onResolve === void 0 ? void 0 : onResolve(data);
+                return;
+            }
+            dispatch({
+                payload: false,
+                type: 'SET_LOADING',
+            });
+        });
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, deps);
     useEffect(() => {
-        if (options.enabled) {
-            fetch();
+        if (enabled) {
+            callback();
         }
-    }, deps);
-    return Object.assign(Object.assign({}, state), { isLoading: state.active });
+    }, [callback, enabled]);
+    return state;
 };
 
 export { usePromise };

package/src/lib/utils/hooks/usePromise/usePromise.types.d.ts

@@ -1,5 +1,14 @@
+import { DependencyList } from 'react';
 export type PromiseState<T, E> = {
     data?: T;
     error?: E;
     isLoading: boolean;
 };
+export type UsePromiseOptions<T, E> = {
+    deps?: DependencyList;
+    retries?: number;
+    enabled?: boolean;
+    initialData?: T;
+    onResolve?: (data: T) => void;
+    onReject?: (error: E) => void;
+};

package/src/lib/utils/hooks/usePromise/utils/createReducer/createReducer.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const createReducer = () => (state, action) => {
+    switch (action.type) {
+        case 'SET_DATA':
+            return Object.assign(Object.assign({}, state), { data: action.payload, isLoading: false });
+        case 'SET_ERROR':
+            return Object.assign(Object.assign({}, state), { error: action.payload, isLoading: false });
+        case 'SET_LOADING':
+            return Object.assign(Object.assign({}, state), { isLoading: action.payload });
+        default:
+            return state;
+    }
+};
+
+exports.createReducer = createReducer;

package/src/lib/utils/hooks/usePromise/utils/createReducer/createReducer.d.ts

@@ -0,0 +1,13 @@
+import { PromiseState } from '../../usePromise.types';
+type ReducerAction<T = unknown, E = unknown> = {
+    type: 'SET_DATA';
+    payload: T;
+} | {
+    type: 'SET_ERROR';
+    payload: E;
+} | {
+    type: 'SET_LOADING';
+    payload: boolean;
+};
+export declare const createReducer: <T = unknown, E = unknown>() => (state: PromiseState<T, E>, action: ReducerAction<T, E>) => PromiseState<T, E>;
+export {};

package/src/lib/utils/hooks/usePromise/utils/createReducer/createReducer.js

@@ -0,0 +1,14 @@
+const createReducer = () => (state, action) => {
+    switch (action.type) {
+        case 'SET_DATA':
+            return Object.assign(Object.assign({}, state), { data: action.payload, isLoading: false });
+        case 'SET_ERROR':
+            return Object.assign(Object.assign({}, state), { error: action.payload, isLoading: false });
+        case 'SET_LOADING':
+            return Object.assign(Object.assign({}, state), { isLoading: action.payload });
+        default:
+            return state;
+    }
+};
+
+export { createReducer };

package/src/lib/utils/hooks/usePromise/utils/createReducer/index.d.ts

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

package/src/lib/utils/hooks/usePromise/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './resolveFetcher';
+export * from './createReducer';

package/src/lib/utils/hooks/usePromise/utils/resolveFetcher/index.d.ts

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

package/src/lib/utils/hooks/usePromise/utils/resolveFetcher/resolveFetcher.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../../../../../_virtual/_tslib.cjs');
+
+const isPromise = (value) => value instanceof Promise;
+const resolveFetcher = (fetcher, { retries }, callback) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    const totalNumberOfAttempts = retries ? retries + 1 : 1;
+    let currentAttempt = 0;
+    let data;
+    let err;
+    while (currentAttempt < totalNumberOfAttempts) {
+        currentAttempt = currentAttempt + 1;
+        try {
+            const result = fetcher();
+            if (isPromise(result)) {
+                data = yield result;
+            }
+            else {
+                data = result;
+            }
+            err = undefined;
+        }
+        catch (error) {
+            err = error;
+        }
+    }
+    callback(err, data);
+});
+
+exports.resolveFetcher = resolveFetcher;

package/src/lib/utils/hooks/usePromise/utils/resolveFetcher/resolveFetcher.d.ts

@@ -0,0 +1,5 @@
+type ResolveFetcherOptions = {
+    retries?: number;
+};
+export declare const resolveFetcher: <E, T>(fetcher: () => T | Promise<T>, { retries }: ResolveFetcherOptions, callback: (err: E | undefined, data: T | undefined) => void) => Promise<void>;
+export {};

package/src/lib/utils/hooks/usePromise/utils/resolveFetcher/resolveFetcher.js

@@ -0,0 +1,28 @@
+import { __awaiter } from '../../../../../../../_virtual/_tslib.js';
+
+const isPromise = (value) => value instanceof Promise;
+const resolveFetcher = (fetcher, { retries }, callback) => __awaiter(void 0, void 0, void 0, function* () {
+    const totalNumberOfAttempts = retries ? retries + 1 : 1;
+    let currentAttempt = 0;
+    let data;
+    let err;
+    while (currentAttempt < totalNumberOfAttempts) {
+        currentAttempt = currentAttempt + 1;
+        try {
+            const result = fetcher();
+            if (isPromise(result)) {
+                data = yield result;
+            }
+            else {
+                data = result;
+            }
+            err = undefined;
+        }
+        catch (error) {
+            err = error;
+        }
+    }
+    callback(err, data);
+});
+
+export { resolveFetcher };

package/src/lib/utils/hooks/useSocialAccounts/index.d.ts

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