@dynamic-labs/sdk-react-core 0.16.0

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

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

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

@@ -0,0 +1,34 @@
+'use strict';
+
+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.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+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

@@ -0,0 +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: (value: any) => undefined;

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

@@ -0,0 +1,30 @@
+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.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+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

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

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

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../../../_virtual/_tslib.cjs.js');
+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 });
+};
+
+exports.usePromise = usePromise;

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

@@ -0,0 +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>;

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

@@ -0,0 +1,39 @@
+import { __awaiter } from '../../../../../_virtual/_tslib.es.js';
+import { useState, useCallback, useEffect } from 'react';
+
+const usePromise = (fetcher, deps = []) => {
+    const [state, setState] = useState({
+        active: false,
+    });
+    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,
+            });
+        }
+        catch (error) {
+            setState({
+                active: false,
+                error: error,
+            });
+        }
+    }), [setState, fetcher]);
+    useEffect(() => {
+        fetch();
+    }, deps);
+    return Object.assign(Object.assign({}, state), { isLoading: state.active });
+};
+
+export { usePromise };

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

@@ -0,0 +1,5 @@
+export type PromiseState<T, E> = {
+    data?: T;
+    error?: E;
+    isLoading: boolean;
+};

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

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

package/src/lib/utils/hooks/useResizeObserver/useResizeObserver.cjs.js

@@ -0,0 +1,33 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+
+const useResizeObserver = (ref, callback) => {
+    const [rect, setRect] = React.useState();
+    const onResize = React.useCallback((entries) => {
+        if (!Array.isArray(entries)) {
+            return;
+        }
+        const [entry] = entries;
+        setRect(entry.contentRect);
+        if (callback) {
+            callback(entry.contentRect);
+        }
+    }, [callback, setRect]);
+    React.useLayoutEffect(() => {
+        if (!ref.current) {
+            return;
+        }
+        let observer = new ResizeObserver(onResize);
+        observer.observe(ref.current);
+        return () => {
+            observer === null || observer === void 0 ? void 0 : observer.disconnect();
+            observer = null;
+        };
+    }, [ref]);
+    return [rect];
+};
+
+exports.useResizeObserver = useResizeObserver;

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

@@ -0,0 +1,6 @@
+import { RefObject } from 'react';
+export interface ResizeObserverEntry {
+    contentRect: DOMRectReadOnly;
+    target: HTMLElement;
+}
+export declare const useResizeObserver: (ref: RefObject<HTMLElement>, callback?: ((entry: DOMRectReadOnly) => void) | undefined) => [DOMRectReadOnly | undefined];

package/src/lib/utils/hooks/useResizeObserver/useResizeObserver.es.js

@@ -0,0 +1,29 @@
+import { useState, useCallback, useLayoutEffect } from 'react';
+
+const useResizeObserver = (ref, callback) => {
+    const [rect, setRect] = useState();
+    const onResize = useCallback((entries) => {
+        if (!Array.isArray(entries)) {
+            return;
+        }
+        const [entry] = entries;
+        setRect(entry.contentRect);
+        if (callback) {
+            callback(entry.contentRect);
+        }
+    }, [callback, setRect]);
+    useLayoutEffect(() => {
+        if (!ref.current) {
+            return;
+        }
+        let observer = new ResizeObserver(onResize);
+        observer.observe(ref.current);
+        return () => {
+            observer === null || observer === void 0 ? void 0 : observer.disconnect();
+            observer = null;
+        };
+    }, [ref]);
+    return [rect];
+};
+
+export { useResizeObserver };

package/src/lib/utils/hooks/useRpcProviders/useRpcProviders.cjs.js

@@ -0,0 +1,64 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var multiWallet = require('@dynamic-labs/multi-wallet');
+require('@dynamic-labs/sdk-api');
+var logger = require('../../../shared/logger.cjs.js');
+require('@dynamic-labs/iconic');
+require('react/jsx-runtime');
+require('../../../context/ViewContext/ViewContext.cjs.js');
+require('../../constants/colors.cjs.js');
+require('../../../shared/consts/index.cjs.js');
+
+const useRpcProviders = ({ networkConfigurations, }) => {
+    const [providers, setProviders] = React.useState();
+    const [evmDefaultProvider, setEvmDefaultProvider] = React.useState();
+    const [solanaDefaultProvider, setSolanaDefaultProvider] = React.useState();
+    React.useEffect(() => {
+        try {
+            if (networkConfigurations) {
+                setProviders(multiWallet.getRpcProviders(networkConfigurations));
+            }
+        }
+        catch (error) {
+            logger.logger.error(error);
+        }
+    }, [networkConfigurations]);
+    const getEvmRpcProviderByChainId = React.useCallback((chainId) => {
+        if (!networkConfigurations) {
+            return undefined;
+        }
+        return multiWallet.getEvmRpcProviderByChainId(networkConfigurations, chainId);
+    }, [networkConfigurations]);
+    React.useEffect(() => {
+        try {
+            if (networkConfigurations) {
+                setEvmDefaultProvider(multiWallet.getEvmDefaultRpcProvider(networkConfigurations));
+            }
+        }
+        catch (error) {
+            logger.logger.error(error);
+        }
+    }, [networkConfigurations]);
+    React.useEffect(() => {
+        try {
+            if (networkConfigurations) {
+                setSolanaDefaultProvider(multiWallet.getSolanaDefaultRpcProvider(networkConfigurations));
+            }
+        }
+        catch (error) {
+            logger.logger.error(error);
+        }
+    }, [networkConfigurations]);
+    return {
+        evmDefaultProvider,
+        evmProviders: providers === null || providers === void 0 ? void 0 : providers.evm,
+        getEvmRpcProviderByChainId,
+        solanaDefaultProvider,
+        solanaProviders: providers === null || providers === void 0 ? void 0 : providers.solana,
+    };
+};
+
+exports.useRpcProviders = useRpcProviders;

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

@@ -0,0 +1,8 @@
+import { NetworkConfigurationMap } from '@dynamic-labs/multi-wallet';
+import { DynamicRPCProviders } from '../../../shared';
+type Props = {
+    networkConfigurations: NetworkConfigurationMap | undefined;
+    networkId: number | undefined;
+};
+export declare const useRpcProviders: ({ networkConfigurations, }: Props) => DynamicRPCProviders;
+export {};

package/src/lib/utils/hooks/useRpcProviders/useRpcProviders.es.js

@@ -0,0 +1,60 @@
+import { useState, useEffect, useCallback } from 'react';
+import { getRpcProviders, getEvmRpcProviderByChainId, getEvmDefaultRpcProvider, getSolanaDefaultRpcProvider } from '@dynamic-labs/multi-wallet';
+import '@dynamic-labs/sdk-api';
+import { logger } from '../../../shared/logger.es.js';
+import '@dynamic-labs/iconic';
+import 'react/jsx-runtime';
+import '../../../context/ViewContext/ViewContext.es.js';
+import '../../constants/colors.es.js';
+import '../../../shared/consts/index.es.js';
+
+const useRpcProviders = ({ networkConfigurations, }) => {
+    const [providers, setProviders] = useState();
+    const [evmDefaultProvider, setEvmDefaultProvider] = useState();
+    const [solanaDefaultProvider, setSolanaDefaultProvider] = useState();
+    useEffect(() => {
+        try {
+            if (networkConfigurations) {
+                setProviders(getRpcProviders(networkConfigurations));
+            }
+        }
+        catch (error) {
+            logger.error(error);
+        }
+    }, [networkConfigurations]);
+    const getEvmRpcProviderByChainId$1 = useCallback((chainId) => {
+        if (!networkConfigurations) {
+            return undefined;
+        }
+        return getEvmRpcProviderByChainId(networkConfigurations, chainId);
+    }, [networkConfigurations]);
+    useEffect(() => {
+        try {
+            if (networkConfigurations) {
+                setEvmDefaultProvider(getEvmDefaultRpcProvider(networkConfigurations));
+            }
+        }
+        catch (error) {
+            logger.error(error);
+        }
+    }, [networkConfigurations]);
+    useEffect(() => {
+        try {
+            if (networkConfigurations) {
+                setSolanaDefaultProvider(getSolanaDefaultRpcProvider(networkConfigurations));
+            }
+        }
+        catch (error) {
+            logger.error(error);
+        }
+    }, [networkConfigurations]);
+    return {
+        evmDefaultProvider,
+        evmProviders: providers === null || providers === void 0 ? void 0 : providers.evm,
+        getEvmRpcProviderByChainId: getEvmRpcProviderByChainId$1,
+        solanaDefaultProvider,
+        solanaProviders: providers === null || providers === void 0 ? void 0 : providers.solana,
+    };
+};
+
+export { useRpcProviders };

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

@@ -0,0 +1,2 @@
+export { useTransition } from './useTransition';
+export type { UseTransitionEvents, TransitionStage } from './useTransition';

package/src/lib/utils/hooks/useTransition/useTransition.cjs.js

@@ -0,0 +1,73 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../../../_virtual/_tslib.cjs.js');
+var React = require('react');
+var animationFrameTimeout = require('../../functions/animationFrameTimeout/animationFrameTimeout.cjs.js');
+var useTransitionEvents = require('../useTransitionEvents/useTransitionEvents.cjs.js');
+
+const DEFAULT_DURATION = 100;
+// The hook inspired by https://github.com/reactjs/react-transition-group/blob/master/src/Transition.js
+const useTransition = (_a) => {
+    var { isShown, inDuration, outDuration, duration = DEFAULT_DURATION, timeout, inTimeout, outTimeout, animateOnMount = true } = _a, events = _tslib.__rest(_a, ["isShown", "inDuration", "outDuration", "duration", "timeout", "inTimeout", "outTimeout", "animateOnMount"]);
+    const initialState = animateOnMount ? 'UNMOUNT' : 'ENTERED';
+    const animationFrameTimeoutIdRef = React.useRef({ id: -1 });
+    const timeoutIdRef = React.useRef({ id: -1 });
+    const [stage, setStage] = React.useState(initialState);
+    const [mount, setMount] = React.useState(!animateOnMount);
+    const [currentDuration, setCurrentDuration] = React.useState(duration);
+    const conditionTimeout = (callback, timeout) => {
+        if (timeout) {
+            timeoutIdRef.current = animationFrameTimeout.animationFrameTimeout(callback, timeout);
+        }
+        else {
+            callback();
+        }
+    };
+    const performEnter = React.useCallback(() => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        const animationDuration = inDuration || duration;
+        setCurrentDuration(animationDuration);
+        setMount(true);
+        setStage('ENTERING');
+        animationFrameTimeoutIdRef.current = animationFrameTimeout.animationFrameTimeout(() => {
+            setStage('ENTERED');
+        }, animationDuration);
+    }), [duration, inDuration]);
+    const performExit = React.useCallback(() => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        const animationDuration = outDuration || duration;
+        setCurrentDuration(animationDuration);
+        setStage('EXITING');
+        animationFrameTimeoutIdRef.current = animationFrameTimeout.animationFrameTimeout(() => {
+            setMount(false);
+            setStage('UNMOUNT');
+        }, animationDuration);
+    }), [duration, outDuration]);
+    React.useEffect(() => {
+        if (isShown && stage !== 'ENTERED') {
+            const enterTimeout = timeout || inTimeout;
+            conditionTimeout(performEnter, enterTimeout);
+        }
+        else if (!isShown && stage !== 'UNMOUNT') {
+            const exitTimeout = timeout || outTimeout;
+            conditionTimeout(performExit, exitTimeout);
+        }
+        return () => {
+            animationFrameTimeout.clearAnimationFrameTimeout(animationFrameTimeoutIdRef.current);
+            animationFrameTimeout.clearAnimationFrameTimeout(timeoutIdRef.current);
+        };
+    }, [
+        inTimeout,
+        outTimeout,
+        performEnter,
+        performExit,
+        isShown,
+        timeout,
+        stage,
+    ]);
+    useTransitionEvents.useTransitionEvents(stage, events);
+    return { currentDuration, mount, stage };
+};
+
+exports.DEFAULT_DURATION = DEFAULT_DURATION;
+exports.useTransition = useTransition;

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

@@ -0,0 +1,26 @@
+export type UseTransitionEvents = {
+    onEntered?: () => void;
+    onEntering?: () => void;
+    onExiting?: () => void;
+    onUnmount?: () => void;
+};
+export type UseTransitionProps = {
+    animateOnMount?: boolean;
+    duration?: number;
+    inDuration?: number;
+    inTimeout?: number;
+    isShown?: boolean;
+    outDuration?: number;
+    outTimeout?: number;
+    timeout?: number;
+};
+export type Props = UseTransitionProps & UseTransitionEvents;
+export type TransitionStage = 'ENTERED' | 'ENTERING' | 'EXITING' | 'UNMOUNT';
+export type UseTransitionResult = {
+    currentDuration: number;
+    mount: boolean;
+    stage: TransitionStage;
+};
+export type UseTransitionType = (props: Props) => UseTransitionResult;
+export declare const DEFAULT_DURATION = 100;
+export declare const useTransition: UseTransitionType;

package/src/lib/utils/hooks/useTransition/useTransition.es.js

@@ -0,0 +1,68 @@
+import { __rest, __awaiter } from '../../../../../_virtual/_tslib.es.js';
+import { useRef, useState, useCallback, useEffect } from 'react';
+import { animationFrameTimeout, clearAnimationFrameTimeout } from '../../functions/animationFrameTimeout/animationFrameTimeout.es.js';
+import { useTransitionEvents } from '../useTransitionEvents/useTransitionEvents.es.js';
+
+const DEFAULT_DURATION = 100;
+// The hook inspired by https://github.com/reactjs/react-transition-group/blob/master/src/Transition.js
+const useTransition = (_a) => {
+    var { isShown, inDuration, outDuration, duration = DEFAULT_DURATION, timeout, inTimeout, outTimeout, animateOnMount = true } = _a, events = __rest(_a, ["isShown", "inDuration", "outDuration", "duration", "timeout", "inTimeout", "outTimeout", "animateOnMount"]);
+    const initialState = animateOnMount ? 'UNMOUNT' : 'ENTERED';
+    const animationFrameTimeoutIdRef = useRef({ id: -1 });
+    const timeoutIdRef = useRef({ id: -1 });
+    const [stage, setStage] = useState(initialState);
+    const [mount, setMount] = useState(!animateOnMount);
+    const [currentDuration, setCurrentDuration] = useState(duration);
+    const conditionTimeout = (callback, timeout) => {
+        if (timeout) {
+            timeoutIdRef.current = animationFrameTimeout(callback, timeout);
+        }
+        else {
+            callback();
+        }
+    };
+    const performEnter = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
+        const animationDuration = inDuration || duration;
+        setCurrentDuration(animationDuration);
+        setMount(true);
+        setStage('ENTERING');
+        animationFrameTimeoutIdRef.current = animationFrameTimeout(() => {
+            setStage('ENTERED');
+        }, animationDuration);
+    }), [duration, inDuration]);
+    const performExit = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
+        const animationDuration = outDuration || duration;
+        setCurrentDuration(animationDuration);
+        setStage('EXITING');
+        animationFrameTimeoutIdRef.current = animationFrameTimeout(() => {
+            setMount(false);
+            setStage('UNMOUNT');
+        }, animationDuration);
+    }), [duration, outDuration]);
+    useEffect(() => {
+        if (isShown && stage !== 'ENTERED') {
+            const enterTimeout = timeout || inTimeout;
+            conditionTimeout(performEnter, enterTimeout);
+        }
+        else if (!isShown && stage !== 'UNMOUNT') {
+            const exitTimeout = timeout || outTimeout;
+            conditionTimeout(performExit, exitTimeout);
+        }
+        return () => {
+            clearAnimationFrameTimeout(animationFrameTimeoutIdRef.current);
+            clearAnimationFrameTimeout(timeoutIdRef.current);
+        };
+    }, [
+        inTimeout,
+        outTimeout,
+        performEnter,
+        performExit,
+        isShown,
+        timeout,
+        stage,
+    ]);
+    useTransitionEvents(stage, events);
+    return { currentDuration, mount, stage };
+};
+
+export { DEFAULT_DURATION, useTransition };

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

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

package/src/lib/utils/hooks/useTransitionEvents/useTransitionEvents.cjs.js

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var useUpdateEffect = require('../useUpdateEffect/useUpdateEffect.cjs.js');
+
+const useTransitionEvents = (stage, events) => useUpdateEffect.useUpdateEffect(() => {
+    var _a;
+    const mapCallbackToStage = {
+        ENTERED: events === null || events === void 0 ? void 0 : events.onEntered,
+        ENTERING: events === null || events === void 0 ? void 0 : events.onEntering,
+        EXITING: events === null || events === void 0 ? void 0 : events.onExiting,
+        UNMOUNT: events === null || events === void 0 ? void 0 : events.onUnmount,
+    };
+    (_a = mapCallbackToStage[stage]) === null || _a === void 0 ? void 0 : _a.call(mapCallbackToStage);
+    return () => {
+        var _a;
+        if (stage === 'EXITING') {
+            (_a = mapCallbackToStage.UNMOUNT) === null || _a === void 0 ? void 0 : _a.call(mapCallbackToStage);
+        }
+    };
+}, [stage]);
+
+exports.useTransitionEvents = useTransitionEvents;

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

@@ -0,0 +1,2 @@
+import { TransitionStage, UseTransitionEvents } from '../useTransition';
+export declare const useTransitionEvents: (stage: TransitionStage, events: UseTransitionEvents) => void;

package/src/lib/utils/hooks/useTransitionEvents/useTransitionEvents.es.js

@@ -0,0 +1,20 @@
+import { useUpdateEffect } from '../useUpdateEffect/useUpdateEffect.es.js';
+
+const useTransitionEvents = (stage, events) => useUpdateEffect(() => {
+    var _a;
+    const mapCallbackToStage = {
+        ENTERED: events === null || events === void 0 ? void 0 : events.onEntered,
+        ENTERING: events === null || events === void 0 ? void 0 : events.onEntering,
+        EXITING: events === null || events === void 0 ? void 0 : events.onExiting,
+        UNMOUNT: events === null || events === void 0 ? void 0 : events.onUnmount,
+    };
+    (_a = mapCallbackToStage[stage]) === null || _a === void 0 ? void 0 : _a.call(mapCallbackToStage);
+    return () => {
+        var _a;
+        if (stage === 'EXITING') {
+            (_a = mapCallbackToStage.UNMOUNT) === null || _a === void 0 ? void 0 : _a.call(mapCallbackToStage);
+        }
+    };
+}, [stage]);
+
+export { useTransitionEvents };

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

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

package/src/lib/utils/hooks/useUpdateEffect/useUpdateEffect.cjs.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var useIsFirstRender = require('../useIsFirstRender/useIsFirstRender.cjs.js');
+
+const useUpdateEffect = (effect, deps) => {
+    const isFirst = useIsFirstRender.useIsFirstRender();
+    React.useEffect(() => {
+        if (!isFirst) {
+            return effect();
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, deps);
+};
+
+exports.useUpdateEffect = useUpdateEffect;

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

@@ -0,0 +1,2 @@
+import { DependencyList, EffectCallback } from 'react';
+export declare const useUpdateEffect: (effect: EffectCallback, deps?: DependencyList) => void;