@dynamic-labs/sdk-react-core 0.17.16 → 0.17.100-viem.1

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

@@ -14,25 +14,25 @@ require('react');
 var isSSR = require('../../../shared/utils/functions/isSSR/isSSR.cjs');
 require('@dynamic-labs/utils');
 require('../../constants/colors.cjs');
-require('ethers');
+require('viem');
 require('../../../shared/consts/index.cjs');
 var useOnlyConnectedMode = require('../useOnlyConnectedMode/useOnlyConnectedMode.cjs');
 
-const isMultiWalletEnabledInURL = () => {
-    const flag = 'multiwallet.widget';
-    const searchParams = new URLSearchParams(!isSSR.isSSR() ? window.location.search : '');
-    // by default, enable the widget
-    if (!searchParams.has(flag)) {
-        return true;
-    }
-    return searchParams.get(flag) === 'true';
-};
-const useMultiWalletFlag = () => {
-    const { multiWallet: isMultiWalletEnabled } = useInternalDynamicContext.useInternalDynamicContext();
-    const isOnlyConnected = useOnlyConnectedMode.useOnlyConnectedMode();
-    if (isOnlyConnected)
-        return false;
-    return isMultiWalletEnabled && isMultiWalletEnabledInURL();
+const isMultiWalletEnabledInURL = () => {
+    const flag = 'multiwallet.widget';
+    const searchParams = new URLSearchParams(!isSSR.isSSR() ? window.location.search : '');
+    // by default, enable the widget
+    if (!searchParams.has(flag)) {
+        return true;
+    }
+    return searchParams.get(flag) === 'true';
+};
+const useMultiWalletFlag = () => {
+    const { multiWallet: isMultiWalletEnabled } = useInternalDynamicContext.useInternalDynamicContext();
+    const isOnlyConnected = useOnlyConnectedMode.useOnlyConnectedMode();
+    if (isOnlyConnected)
+        return false;
+    return isMultiWalletEnabled && isMultiWalletEnabledInURL();
 };
 
 exports.isMultiWalletEnabledInURL = isMultiWalletEnabledInURL;

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

@@ -1,2 +1,2 @@
-export declare const isMultiWalletEnabledInURL: () => boolean;
-export declare const useMultiWalletFlag: () => boolean;
+export declare const isMultiWalletEnabledInURL: () => boolean;
+export declare const useMultiWalletFlag: () => boolean;

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

@@ -10,25 +10,25 @@ import 'react';
 import { isSSR } from '../../../shared/utils/functions/isSSR/isSSR.js';
 import '@dynamic-labs/utils';
 import '../../constants/colors.js';
-import 'ethers';
+import 'viem';
 import '../../../shared/consts/index.js';
 import { useOnlyConnectedMode } from '../useOnlyConnectedMode/useOnlyConnectedMode.js';
 
-const isMultiWalletEnabledInURL = () => {
-    const flag = 'multiwallet.widget';
-    const searchParams = new URLSearchParams(!isSSR() ? window.location.search : '');
-    // by default, enable the widget
-    if (!searchParams.has(flag)) {
-        return true;
-    }
-    return searchParams.get(flag) === 'true';
-};
-const useMultiWalletFlag = () => {
-    const { multiWallet: isMultiWalletEnabled } = useInternalDynamicContext();
-    const isOnlyConnected = useOnlyConnectedMode();
-    if (isOnlyConnected)
-        return false;
-    return isMultiWalletEnabled && isMultiWalletEnabledInURL();
+const isMultiWalletEnabledInURL = () => {
+    const flag = 'multiwallet.widget';
+    const searchParams = new URLSearchParams(!isSSR() ? window.location.search : '');
+    // by default, enable the widget
+    if (!searchParams.has(flag)) {
+        return true;
+    }
+    return searchParams.get(flag) === 'true';
+};
+const useMultiWalletFlag = () => {
+    const { multiWallet: isMultiWalletEnabled } = useInternalDynamicContext();
+    const isOnlyConnected = useOnlyConnectedMode();
+    if (isOnlyConnected)
+        return false;
+    return isMultiWalletEnabled && isMultiWalletEnabledInURL();
 };
 
 export { isMultiWalletEnabledInURL, useMultiWalletFlag };

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

@@ -1 +1 @@
-export { useMutation } from './useMutation';
+export { useMutation } from './useMutation';

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

@@ -6,49 +6,49 @@ var _tslib = require('../../../../../_virtual/_tslib.cjs');
 var React = require('react');
 var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
 
-const useMutation = (mutation, options = {}) => {
-    const [state, setState] = React.useState({
-        isLoading: false,
-    });
-    const mutate = React.useCallback((variables) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
-        var _a, _b;
-        let data;
-        setState({
-            isLoading: true,
-        });
-        try {
-            const mutationResult = mutation(variables);
-            if (mutationResult instanceof Promise) {
-                data = yield mutationResult;
-            }
-            else {
-                data = mutationResult;
-            }
-            setState({
-                data,
-                isLoading: false,
-            });
-            try {
-                (_a = options === null || options === void 0 ? void 0 : options.onSuccess) === null || _a === void 0 ? void 0 : _a.call(options, data, variables);
-            }
-            catch (err) {
-                walletConnectorCore.logger.error(err);
-            }
-            return data;
-        }
-        catch (error) {
-            setState({ error: error, isLoading: false });
-            walletConnectorCore.logger.error(error);
-            try {
-                (_b = options === null || options === void 0 ? void 0 : options.onFailure) === null || _b === void 0 ? void 0 : _b.call(options, error, variables);
-            }
-            catch (err) {
-                walletConnectorCore.logger.error(err);
-            }
-        }
-        return undefined;
-    }), [mutation, options]);
-    return Object.assign(Object.assign({}, state), { hasData: Boolean(state.data), hasError: Boolean(state.error), mutate });
+const useMutation = (mutation, options = {}) => {
+    const [state, setState] = React.useState({
+        isLoading: false,
+    });
+    const mutate = React.useCallback((variables) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        let data;
+        setState({
+            isLoading: true,
+        });
+        try {
+            const mutationResult = mutation(variables);
+            if (mutationResult instanceof Promise) {
+                data = yield mutationResult;
+            }
+            else {
+                data = mutationResult;
+            }
+            setState({
+                data,
+                isLoading: false,
+            });
+            try {
+                (_a = options === null || options === void 0 ? void 0 : options.onSuccess) === null || _a === void 0 ? void 0 : _a.call(options, data, variables);
+            }
+            catch (err) {
+                walletConnectorCore.logger.error(err);
+            }
+            return data;
+        }
+        catch (error) {
+            setState({ error: error, isLoading: false });
+            walletConnectorCore.logger.error(error);
+            try {
+                (_b = options === null || options === void 0 ? void 0 : options.onFailure) === null || _b === void 0 ? void 0 : _b.call(options, error, variables);
+            }
+            catch (err) {
+                walletConnectorCore.logger.error(err);
+            }
+        }
+        return undefined;
+    }), [mutation, options]);
+    return Object.assign(Object.assign({}, state), { hasData: Boolean(state.data), hasError: Boolean(state.error), mutate });
 };
 
 exports.useMutation = useMutation;

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

@@ -1,16 +1,16 @@
-type MutationHookOptions<TData, TError, TVariables> = {
-    onFailure?: (error: TError, variables: TVariables) => void;
-    onSuccess?: (data: TData, variables: TVariables) => void;
-};
-type MutateFunction<TData = unknown, TVariables = unknown> = (variables: TVariables) => TData | Promise<TData>;
-type UseMutateFunction<TData = unknown, TVariables = unknown> = (...args: Parameters<MutateFunction<TData, TVariables>>) => void;
-type MutationHookResult<TData = unknown, TError = unknown, TVariables = unknown> = {
-    data?: TData;
-    error?: TError;
-    hasData: boolean;
-    hasError: boolean;
-    isLoading: boolean;
-    mutate: UseMutateFunction<TData, TVariables>;
-};
-export declare const useMutation: <TData = unknown, TError = unknown, TVariables = void>(mutation: MutateFunction<TData, TVariables>, options?: MutationHookOptions<TData, TError, TVariables>) => MutationHookResult<TData, TError, TVariables>;
-export {};
+type MutationHookOptions<TData, TError, TVariables> = {
+    onFailure?: (error: TError, variables: TVariables) => void;
+    onSuccess?: (data: TData, variables: TVariables) => void;
+};
+type MutateFunction<TData = unknown, TVariables = unknown> = (variables: TVariables) => TData | Promise<TData>;
+type UseMutateFunction<TData = unknown, TVariables = unknown> = (...args: Parameters<MutateFunction<TData, TVariables>>) => void;
+type MutationHookResult<TData = unknown, TError = unknown, TVariables = unknown> = {
+    data?: TData;
+    error?: TError;
+    hasData: boolean;
+    hasError: boolean;
+    isLoading: boolean;
+    mutate: UseMutateFunction<TData, TVariables>;
+};
+export declare const useMutation: <TData = unknown, TError = unknown, TVariables = void>(mutation: MutateFunction<TData, TVariables>, options?: MutationHookOptions<TData, TError, TVariables>) => MutationHookResult<TData, TError, TVariables>;
+export {};

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

@@ -2,49 +2,49 @@ import { __awaiter } from '../../../../../_virtual/_tslib.js';
 import { useState, useCallback } from 'react';
 import { logger } from '@dynamic-labs/wallet-connector-core';
 
-const useMutation = (mutation, options = {}) => {
-    const [state, setState] = useState({
-        isLoading: false,
-    });
-    const mutate = useCallback((variables) => __awaiter(void 0, void 0, void 0, function* () {
-        var _a, _b;
-        let data;
-        setState({
-            isLoading: true,
-        });
-        try {
-            const mutationResult = mutation(variables);
-            if (mutationResult instanceof Promise) {
-                data = yield mutationResult;
-            }
-            else {
-                data = mutationResult;
-            }
-            setState({
-                data,
-                isLoading: false,
-            });
-            try {
-                (_a = options === null || options === void 0 ? void 0 : options.onSuccess) === null || _a === void 0 ? void 0 : _a.call(options, data, variables);
-            }
-            catch (err) {
-                logger.error(err);
-            }
-            return data;
-        }
-        catch (error) {
-            setState({ error: error, isLoading: false });
-            logger.error(error);
-            try {
-                (_b = options === null || options === void 0 ? void 0 : options.onFailure) === null || _b === void 0 ? void 0 : _b.call(options, error, variables);
-            }
-            catch (err) {
-                logger.error(err);
-            }
-        }
-        return undefined;
-    }), [mutation, options]);
-    return Object.assign(Object.assign({}, state), { hasData: Boolean(state.data), hasError: Boolean(state.error), mutate });
+const useMutation = (mutation, options = {}) => {
+    const [state, setState] = useState({
+        isLoading: false,
+    });
+    const mutate = useCallback((variables) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        let data;
+        setState({
+            isLoading: true,
+        });
+        try {
+            const mutationResult = mutation(variables);
+            if (mutationResult instanceof Promise) {
+                data = yield mutationResult;
+            }
+            else {
+                data = mutationResult;
+            }
+            setState({
+                data,
+                isLoading: false,
+            });
+            try {
+                (_a = options === null || options === void 0 ? void 0 : options.onSuccess) === null || _a === void 0 ? void 0 : _a.call(options, data, variables);
+            }
+            catch (err) {
+                logger.error(err);
+            }
+            return data;
+        }
+        catch (error) {
+            setState({ error: error, isLoading: false });
+            logger.error(error);
+            try {
+                (_b = options === null || options === void 0 ? void 0 : options.onFailure) === null || _b === void 0 ? void 0 : _b.call(options, error, variables);
+            }
+            catch (err) {
+                logger.error(err);
+            }
+        }
+        return undefined;
+    }), [mutation, options]);
+    return Object.assign(Object.assign({}, state), { hasData: Boolean(state.data), hasError: Boolean(state.error), mutate });
 };
 
 export { useMutation };

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

@@ -1 +1 @@
-export { useOnlyConnectedMode } from './useOnlyConnectedMode';
+export { useOnlyConnectedMode } from './useOnlyConnectedMode';

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

@@ -4,9 +4,9 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var useInternalDynamicContext = require('../../../context/DynamicContext/useInternalDynamicContext.cjs');
 
-const useOnlyConnectedMode = () => {
-    const { authMode, user } = useInternalDynamicContext.useInternalDynamicContext();
-    return authMode === 'connect-only' && !user;
+const useOnlyConnectedMode = () => {
+    const { authMode, user } = useInternalDynamicContext.useInternalDynamicContext();
+    return authMode === 'connect-only' && !user;
 };
 
 exports.useOnlyConnectedMode = useOnlyConnectedMode;

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

@@ -1 +1 @@
-export declare const useOnlyConnectedMode: () => boolean;
+export declare const useOnlyConnectedMode: () => boolean;

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

@@ -1,8 +1,8 @@
 import { useInternalDynamicContext } from '../../../context/DynamicContext/useInternalDynamicContext.js';
 
-const useOnlyConnectedMode = () => {
-    const { authMode, user } = useInternalDynamicContext();
-    return authMode === 'connect-only' && !user;
+const useOnlyConnectedMode = () => {
+    const { authMode, user } = useInternalDynamicContext();
+    return authMode === 'connect-only' && !user;
 };
 
 export { useOnlyConnectedMode };

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

@@ -1 +1 @@
-export * from './usePrevious';
+export * from './usePrevious';

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

@@ -4,30 +4,30 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var React = require('react');
 
-/**
- * This is used to track a previous value of a variable.
- *
- * Example:
- *   const someHook = ({ value }) => {
- *     const previousValue = usePrevious(value);
- *     useEffect(() => {
- *      if (previousValue !== value) {
- *        // do something
- *      }
- *     }, [value, previousValue]);
- *   }
- *
- * When someHook is rendered for the first time with value = true, previousValue will be undefined
- * so the condition will be true and the effect will run. When someHook is rendered again with
- * value = true, previousValue will have been set to true so the condition will be false and the
- * effect will not run.
- */
-const usePrevious = (value) => {
-    const ref = React.useRef();
-    React.useEffect(() => {
-        ref.current = value;
-    }, [value]);
-    return ref.current;
+/**
+ * This is used to track a previous value of a variable.
+ *
+ * Example:
+ *   const someHook = ({ value }) => {
+ *     const previousValue = usePrevious(value);
+ *     useEffect(() => {
+ *      if (previousValue !== value) {
+ *        // do something
+ *      }
+ *     }, [value, previousValue]);
+ *   }
+ *
+ * When someHook is rendered for the first time with value = true, previousValue will be undefined
+ * so the condition will be true and the effect will run. When someHook is rendered again with
+ * value = true, previousValue will have been set to true so the condition will be false and the
+ * effect will not run.
+ */
+const usePrevious = (value) => {
+    const ref = React.useRef();
+    React.useEffect(() => {
+        ref.current = value;
+    }, [value]);
+    return ref.current;
 };
 
 exports.usePrevious = usePrevious;

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

@@ -1,19 +1,19 @@
-/**
- * This is used to track a previous value of a variable.
- *
- * Example:
- *   const someHook = ({ value }) => {
- *     const previousValue = usePrevious(value);
- *     useEffect(() => {
- *      if (previousValue !== value) {
- *        // do something
- *      }
- *     }, [value, previousValue]);
- *   }
- *
- * When someHook is rendered for the first time with value = true, previousValue will be undefined
- * so the condition will be true and the effect will run. When someHook is rendered again with
- * value = true, previousValue will have been set to true so the condition will be false and the
- * effect will not run.
- */
-export declare const usePrevious: <T>(value: T) => T | undefined;
+/**
+ * This is used to track a previous value of a variable.
+ *
+ * Example:
+ *   const someHook = ({ value }) => {
+ *     const previousValue = usePrevious(value);
+ *     useEffect(() => {
+ *      if (previousValue !== value) {
+ *        // do something
+ *      }
+ *     }, [value, previousValue]);
+ *   }
+ *
+ * When someHook is rendered for the first time with value = true, previousValue will be undefined
+ * so the condition will be true and the effect will run. When someHook is rendered again with
+ * value = true, previousValue will have been set to true so the condition will be false and the
+ * effect will not run.
+ */
+export declare const usePrevious: <T>(value: T) => T | undefined;

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

@@ -1,29 +1,29 @@
 import { useRef, useEffect } from 'react';
 
-/**
- * This is used to track a previous value of a variable.
- *
- * Example:
- *   const someHook = ({ value }) => {
- *     const previousValue = usePrevious(value);
- *     useEffect(() => {
- *      if (previousValue !== value) {
- *        // do something
- *      }
- *     }, [value, previousValue]);
- *   }
- *
- * When someHook is rendered for the first time with value = true, previousValue will be undefined
- * so the condition will be true and the effect will run. When someHook is rendered again with
- * value = true, previousValue will have been set to true so the condition will be false and the
- * effect will not run.
- */
-const usePrevious = (value) => {
-    const ref = useRef();
-    useEffect(() => {
-        ref.current = value;
-    }, [value]);
-    return ref.current;
+/**
+ * This is used to track a previous value of a variable.
+ *
+ * Example:
+ *   const someHook = ({ value }) => {
+ *     const previousValue = usePrevious(value);
+ *     useEffect(() => {
+ *      if (previousValue !== value) {
+ *        // do something
+ *      }
+ *     }, [value, previousValue]);
+ *   }
+ *
+ * When someHook is rendered for the first time with value = true, previousValue will be undefined
+ * so the condition will be true and the effect will run. When someHook is rendered again with
+ * value = true, previousValue will have been set to true so the condition will be false and the
+ * effect will not run.
+ */
+const usePrevious = (value) => {
+    const ref = useRef();
+    useEffect(() => {
+        ref.current = value;
+    }, [value]);
+    return ref.current;
 };
 
 export { usePrevious };

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

@@ -1,2 +1,2 @@
-export { usePromise } from './usePromise';
-export type { PromiseState } from './usePromise.types';
+export { usePromise } from './usePromise';
+export type { PromiseState } from './usePromise.types';

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

@@ -5,39 +5,39 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var _tslib = require('../../../../../_virtual/_tslib.cjs');
 var React = require('react');
 
-const usePromise = (fetcher, deps = []) => {
-    const [state, setState] = React.useState({
-        active: false,
-    });
-    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,
-            });
-        }
-        catch (error) {
-            setState({
-                active: false,
-                error: error,
-            });
-        }
-    }), [setState, fetcher]);
-    React.useEffect(() => {
-        fetch();
-    }, deps);
-    return Object.assign(Object.assign({}, state), { isLoading: state.active });
+const usePromise = (fetcher, deps = []) => {
+    const [state, setState] = React.useState({
+        active: false,
+    });
+    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,
+            });
+        }
+        catch (error) {
+            setState({
+                active: false,
+                error: error,
+            });
+        }
+    }), [setState, fetcher]);
+    React.useEffect(() => {
+        fetch();
+    }, deps);
+    return Object.assign(Object.assign({}, state), { isLoading: state.active });
 };
 
 exports.usePromise = usePromise;

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

@@ -1,3 +1,3 @@
-import { DependencyList } from 'react';
-import { PromiseState } from './usePromise.types';
-export declare const usePromise: <T = unknown, E = unknown>(fetcher: () => T | Promise<T>, deps?: DependencyList) => PromiseState<T, E>;
+import { DependencyList } from 'react';
+import { PromiseState } from './usePromise.types';
+export declare const usePromise: <T = unknown, E = unknown>(fetcher: () => T | Promise<T>, deps?: DependencyList) => PromiseState<T, E>;