@lifi/widget 2.9.3 → 3.0.0-alpha.0

package/providers/WalletProvider/WalletProvider.js

@@ -1,183 +1,7 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { LiFiWalletManagement, readActiveWallets, supportedWallets, addChain as walletAgnosticAddChain, switchChainAndAddToken as walletAgnosticAddToken, switchChain as walletAgnosticSwitchChain, } from '@lifi/wallet-management';
-import { createContext, useCallback, useContext, useEffect, useMemo, useState, } from 'react';
-import { useWidgetEvents } from '../../hooks';
-import { WidgetEvent } from '../../types';
-import { useWidgetConfig } from '../WidgetProvider';
-const liFiWalletManagement = new LiFiWalletManagement();
-const stub = () => {
-    throw new Error(`You forgot to wrap your component in <${WalletProvider.name}>.`);
-};
-const initialContext = {
-    connect: stub,
-    disconnect: stub,
-    switchChain: stub,
-    addChain: stub,
-    addToken: stub,
-    account: {},
-};
-const WalletContext = createContext(initialContext);
-export const useWallet = () => useContext(WalletContext);
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { EVMProvider } from './EVMProvider';
+import { SDKProviders } from './SDKProviders';
+import { SolanaProvider } from './SolanaProvider';
 export const WalletProvider = ({ children }) => {
-    const emitter = useWidgetEvents();
-    const { walletManagement } = useWidgetConfig();
-    const [account, setAccount] = useState({});
-    const [currentWallet, setCurrentWallet] = useState();
-    const handleWalletUpdate = async (wallet) => {
-        setCurrentWallet(wallet);
-        const account = await extractAccountFromSigner(wallet?.account?.signer);
-        setAccount(account);
-        return account;
-    };
-    const connect = useCallback(async (wallet) => {
-        if (walletManagement) {
-            const signer = await walletManagement.connect();
-            const account = await extractAccountFromSigner(signer);
-            setAccount(account);
-            emitter.emit(WidgetEvent.WalletConnected, {
-                address: account.address,
-                chainId: account.chainId,
-            });
-            return;
-        }
-        await liFiWalletManagement.connect(wallet);
-        wallet.on('walletAccountChanged', handleWalletUpdate);
-        const account = await handleWalletUpdate(wallet);
-        emitter.emit(WidgetEvent.WalletConnected, {
-            address: account.address,
-            chainId: account.chainId,
-        });
-    }, [emitter, walletManagement]);
-    const disconnect = useCallback(async () => {
-        if (walletManagement) {
-            await walletManagement.disconnect();
-            setAccount({});
-            return;
-        }
-        if (currentWallet) {
-            await liFiWalletManagement.disconnect(currentWallet);
-            currentWallet.removeAllListeners();
-            await handleWalletUpdate(undefined);
-        }
-    }, [currentWallet, walletManagement]);
-    const switchChain = useCallback(async (chainId) => {
-        try {
-            if (walletManagement?.switchChain) {
-                const signer = await walletManagement.switchChain(chainId);
-                const account = await extractAccountFromSigner(signer);
-                setAccount(account);
-                return signer;
-            }
-            else if (!currentWallet) {
-                const provider = account.signer?.provider;
-                if (!provider) {
-                    throw new Error(`Switch chain: No provider available`);
-                }
-                await walletAgnosticSwitchChain(provider, chainId);
-            }
-            else {
-                await currentWallet?.switchChain(chainId);
-                await handleWalletUpdate(currentWallet);
-            }
-            // TODO: this will fail if it's not created with ethers 'any' network, replace with the new signer when possible
-            return account.signer;
-        }
-        catch {
-            return account.signer;
-        }
-    }, [account.signer, currentWallet, walletManagement]);
-    const addChain = useCallback(async (chainId) => {
-        try {
-            if (walletManagement?.addChain) {
-                return walletManagement.addChain(chainId);
-            }
-            else if (!currentWallet) {
-                const provider = account.signer?.provider;
-                if (!provider) {
-                    throw new Error(`Add chain: No provider available`);
-                }
-                await walletAgnosticAddChain(provider, chainId);
-            }
-            else {
-                await currentWallet?.addChain(chainId);
-                await handleWalletUpdate(currentWallet);
-            }
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }, [account.signer?.provider, currentWallet, walletManagement]);
-    const addToken = useCallback(async (chainId, token) => {
-        try {
-            if (walletManagement?.addToken) {
-                return walletManagement.addToken(token, chainId);
-            }
-            else if (!currentWallet) {
-                const provider = account.signer?.provider;
-                if (!provider) {
-                    throw new Error(`Add token: No provider available`);
-                }
-                await walletAgnosticAddToken(provider, chainId, token);
-            }
-            else {
-                await currentWallet?.addToken(chainId, token);
-                await handleWalletUpdate(currentWallet);
-            }
-        }
-        catch { }
-    }, [account.signer?.provider, currentWallet, walletManagement]);
-    useEffect(() => {
-        const autoConnect = async () => {
-            const persistedActiveWallets = readActiveWallets();
-            const activeWallets = supportedWallets.filter((wallet) => persistedActiveWallets.some((perstistedWallet) => perstistedWallet.name === wallet.name));
-            if (!activeWallets.length) {
-                return;
-            }
-            await liFiWalletManagement.autoConnect(activeWallets);
-            activeWallets[0].on('walletAccountChanged', handleWalletUpdate);
-            await handleWalletUpdate(activeWallets[0]);
-        };
-        autoConnect();
-    }, []);
-    // keep widget in sync with changing external signer object
-    useEffect(() => {
-        if (walletManagement) {
-            let ignore = false;
-            const updateAccount = async () => {
-                const account = await extractAccountFromSigner(walletManagement?.signer);
-                // we should ignore the update if there is a newer one
-                if (!ignore) {
-                    setAccount(account);
-                }
-            };
-            updateAccount();
-            return () => {
-                ignore = true;
-            };
-        }
-    }, [walletManagement]);
-    const value = useMemo(() => ({
-        connect,
-        disconnect,
-        switchChain,
-        addChain,
-        addToken,
-        account,
-    }), [account, addChain, addToken, connect, disconnect, switchChain]);
-    return (_jsx(WalletContext.Provider, { value: value, children: children }));
-};
-export const extractAccountFromSigner = async (signer) => {
-    try {
-        return {
-            address: await signer?.getAddress(),
-            isActive: (signer && !!(await signer.getAddress()) === null) || !!signer,
-            signer,
-            chainId: await signer?.getChainId(),
-        };
-    }
-    catch (error) {
-        console.error(error);
-        return {};
-    }
+    return (_jsx(SolanaProvider, { children: _jsxs(EVMProvider, { children: [_jsx(SDKProviders, {}), children] }) }));
 };

package/providers/WalletProvider/index.d.ts

@@ -1,2 +1,2 @@
 export * from './WalletProvider';
-export * from './types';
+export * from './utils';

package/providers/WalletProvider/index.js

@@ -1,2 +1,2 @@
 export * from './WalletProvider';
-export * from './types';
+export * from './utils';

package/providers/WalletProvider/utils.d.ts

@@ -0,0 +1,3 @@
+import type { ExtendedChain } from '@lifi/sdk';
+import type { Chain } from 'viem';
+export declare const formatChain: (chain: ExtendedChain) => Chain;

package/providers/WalletProvider/utils.js

@@ -0,0 +1,21 @@
+export const formatChain = (chain) => ({
+    ...chain,
+    ...chain.metamask,
+    blockExplorers: chain.metamask.blockExplorerUrls.reduce((blockExplorers, blockExplorer, index) => {
+        blockExplorers[index === 0 ? 'default' : `${index}`] = {
+            name: blockExplorer,
+            url: blockExplorer,
+        };
+        return blockExplorers;
+    }, {}),
+    name: chain.metamask.chainName,
+    rpcUrls: {
+        default: { http: chain.metamask.rpcUrls },
+        public: { http: chain.metamask.rpcUrls },
+    },
+    contracts: {
+        ...(chain.multicallAddress
+            ? { multicall3: { address: chain.multicallAddress } }
+            : undefined),
+    },
+});

package/providers/WidgetProvider/WidgetProvider.js

@@ -1,6 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { getChainByKey } from '@lifi/sdk';
+import { config, createConfig } from '@lifi/sdk';
 import { createContext, useContext, useId, useMemo } from 'react';
+import { version } from '../../config/version';
 import { setDefaultSettings } from '../../stores';
 import { formatInputAmount } from '../../utils';
 const initialContext = {
@@ -9,13 +10,15 @@ const initialContext = {
 };
 const WidgetContext = createContext(initialContext);
 export const useWidgetConfig = () => useContext(WidgetContext);
-export const WidgetProvider = ({ children, config: { fromChain, fromToken, toChain, toToken, fromAmount, toAddress, integrator, ...config } = {}, }) => {
+let sdkInitialized = false;
+export const WidgetProvider = ({ children, config: widgetConfig }) => {
     const elementId = useId();
-    if (!integrator) {
+    if (!widgetConfig?.integrator) {
         throw Error('Required property "integrator" is missing.');
     }
     const value = useMemo(() => {
         try {
+            // Get search params from URL
             const searchParams = Object.fromEntries(new URLSearchParams(window?.location.search));
             // Prevent using fromToken/toToken params if chain is not selected
             ['from', 'to'].forEach((key) => {
@@ -23,51 +26,64 @@ export const WidgetProvider = ({ children, config: { fromChain, fromToken, toCha
                     delete searchParams[`${key}Token`];
                 }
             });
+            // Create widget configuration object
             const value = {
-                ...config,
+                ...widgetConfig,
                 fromChain: (searchParams.fromChain &&
-                    isNaN(parseInt(searchParams.fromChain, 10))) ||
-                    typeof fromChain === 'string'
-                    ? getChainByKey((searchParams.fromChain || fromChain)?.toLowerCase())?.id
-                    : (searchParams.fromChain &&
-                        !isNaN(parseInt(searchParams.fromChain, 10))) ||
-                        typeof fromChain === 'number'
-                        ? parseInt(searchParams.fromChain, 10) || fromChain
-                        : undefined,
-                toChain: (searchParams.toChain && isNaN(parseInt(searchParams.toChain, 10))) ||
-                    typeof toChain === 'string'
-                    ? getChainByKey((searchParams.toChain || toChain)?.toLowerCase())?.id
-                    : (searchParams.toChain &&
-                        !isNaN(parseInt(searchParams.toChain, 10))) ||
-                        typeof toChain === 'number'
-                        ? parseInt(searchParams.toChain, 10) || toChain
-                        : undefined,
-                fromToken: searchParams.fromToken?.toLowerCase() || fromToken?.toLowerCase(),
-                toToken: searchParams.toToken?.toLowerCase() || toToken?.toLowerCase(),
+                    !isNaN(parseInt(searchParams.fromChain, 10))) ||
+                    typeof widgetConfig.fromChain === 'number'
+                    ? parseInt(searchParams.fromChain, 10) || widgetConfig.fromChain
+                    : undefined,
+                toChain: (searchParams.toChain &&
+                    !isNaN(parseInt(searchParams.toChain, 10))) ||
+                    typeof widgetConfig.toChain === 'number'
+                    ? parseInt(searchParams.toChain, 10) || widgetConfig.toChain
+                    : undefined,
+                fromToken: searchParams.fromToken || widgetConfig.fromToken,
+                toToken: searchParams.toToken || widgetConfig.toToken,
                 fromAmount: typeof searchParams.fromAmount === 'string' &&
                     !isNaN(parseFloat(searchParams.fromAmount))
                     ? formatInputAmount(searchParams.fromAmount)
-                    : fromAmount,
-                toAddress: searchParams.toAddress || toAddress,
+                    : widgetConfig.fromAmount,
+                toAddress: searchParams.toAddress || widgetConfig.toAddress,
+                integrator: widgetConfig.integrator,
                 elementId,
-                integrator,
             };
+            // Set default settings for widget settings store
             setDefaultSettings(value);
+            // Configure SDK
+            const _config = {
+                ...widgetConfig.sdkConfig,
+                apiKey: widgetConfig.apiKey,
+                integrator: widgetConfig.integrator ?? window?.location.hostname,
+                routeOptions: {
+                    fee: widgetConfig.fee,
+                    referrer: widgetConfig.referrer,
+                    order: widgetConfig.routePriority,
+                    slippage: widgetConfig.slippage,
+                    ...widgetConfig.sdkConfig?.routeOptions,
+                },
+                disableVersionCheck: true,
+                widgetVersion: version,
+                preloadChains: false,
+            };
+            if (!sdkInitialized) {
+                createConfig(_config);
+                sdkInitialized = true;
+            }
+            else {
+                config.set(_config);
+            }
             return value;
         }
         catch (e) {
             console.warn(e);
-            return { ...config, elementId, integrator };
+            return {
+                ...widgetConfig,
+                elementId,
+                integrator: widgetConfig.integrator,
+            };
         }
-    }, [
-        config,
-        elementId,
-        fromAmount,
-        fromChain,
-        fromToken,
-        integrator,
-        toChain,
-        toToken,
-    ]);
+    }, [elementId, widgetConfig]);
     return (_jsx(WidgetContext.Provider, { value: value, children: children }));
 };

package/providers/index.d.ts

@@ -1,6 +1,5 @@
 export * from './FormProvider';
 export * from './I18nProvider';
-export * from './SDKProvider';
 export * from './ThemeProvider';
 export * from './WalletProvider';
 export * from './WidgetProvider';

package/providers/index.js

@@ -1,6 +1,5 @@
 export * from './FormProvider';
 export * from './I18nProvider';
-export * from './SDKProvider';
 export * from './ThemeProvider';
 export * from './WalletProvider';
 export * from './WidgetProvider';

package/stores/chains/ChainOrderStore.js

@@ -1,12 +1,36 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useContext, useRef } from 'react';
+import { createContext, useContext, useEffect, useRef } from 'react';
+import { useFormContext } from 'react-hook-form';
+import { useChains } from '../../hooks';
+import { FormKey } from '../../providers';
 import { createChainOrderStore } from './createChainOrderStore';
 export const ChainOrderStoreContext = createContext(null);
 export function ChainOrderStoreProvider({ children, ...props }) {
     const storeRef = useRef();
+    const { chains: filteredChains } = useChains();
+    const { setValue, getValues } = useFormContext();
     if (!storeRef.current) {
         storeRef.current = createChainOrderStore(props);
     }
+    useEffect(() => {
+        if (filteredChains) {
+            const chainOrder = storeRef.current
+                ?.getState()
+                .initializeChains(filteredChains.map((chain) => chain.id));
+            if (chainOrder) {
+                const [fromChainValue, toChainValue] = getValues([
+                    FormKey.FromChain,
+                    FormKey.ToChain,
+                ]);
+                if (!fromChainValue) {
+                    setValue(FormKey.FromChain, chainOrder[0]);
+                }
+                if (!toChainValue) {
+                    setValue(FormKey.ToChain, chainOrder[0]);
+                }
+            }
+        }
+    }, [filteredChains, getValues, setValue]);
     return (_jsx(ChainOrderStoreContext.Provider, { value: storeRef.current, children: children }));
 }
 export function useChainOrderStore(selector, equalityFn) {

package/stores/header/useHeaderStore.d.ts

@@ -3,6 +3,6 @@ import type { PersistStoreProps, PersistStoreProviderProps } from '../types';
 import type { HeaderState, HeaderStore } from './types';
 export declare const HeaderStoreContext: import("react").Context<HeaderStore | null>;
 export declare function HeaderStoreProvider({ children, ...props }: PersistStoreProviderProps): import("react/jsx-runtime").JSX.Element;
-export declare function useHeaderStore<T>(selector: (state: HeaderState) => T, equalityFn?: (left: T, right: T) => boolean): T;
+export declare function useHeaderStore<T>(selector: (state: HeaderState) => T): T;
 export declare function useHeaderStoreContext(): HeaderStore;
 export declare const createHeaderStore: ({ namePrefix }: PersistStoreProps) => import("zustand/traditional").UseBoundStoreWithEqualityFn<import("zustand").StoreApi<HeaderState>>;

package/stores/header/useHeaderStore.js

@@ -9,12 +9,12 @@ export function HeaderStoreProvider({ children, ...props }) {
     }
     return (_jsx(HeaderStoreContext.Provider, { value: storeRef.current, children: children }));
 }
-export function useHeaderStore(selector, equalityFn) {
+export function useHeaderStore(selector) {
     const useStore = useContext(HeaderStoreContext);
     if (!useStore) {
         throw new Error(`You forgot to wrap your component in <${HeaderStoreProvider.name}>.`);
     }
-    return useStore(selector, equalityFn);
+    return useStore(selector);
 }
 export function useHeaderStoreContext() {
     const useStore = useContext(HeaderStoreContext);

package/stores/routes/createRouteExecutionStore.js

@@ -9,10 +9,11 @@ export const createRouteExecutionStore = ({ namePrefix }) => createWithEqualityF
         if (!get().routes[route.id]) {
             set((state) => {
                 const routes = { ...state.routes };
-                // clean previous idle routes that were not executed
+                // clean previous idle and done routes
                 Object.keys(routes)
-                    .filter((routeId) => routeId !== insurableRouteId &&
-                    routes[routeId]?.status === RouteExecutionStatus.Idle)
+                    .filter((routeId) => (routeId !== insurableRouteId &&
+                    hasEnumFlag(routes[routeId].status, RouteExecutionStatus.Idle)) ||
+                    hasEnumFlag(routes[routeId].status, RouteExecutionStatus.Done))
                     .forEach((routeId) => delete routes[routeId]);
                 routes[route.id] = {
                     route,
@@ -107,7 +108,7 @@ export const createRouteExecutionStore = ({ namePrefix }) => createWithEqualityF
             ...persistedState,
         };
         try {
-            // Move transactions to history after 1 day
+            // Remove failed transactions from history after 1 day
             const currentTime = new Date().getTime();
             const oneDay = 1000 * 60 * 60 * 24;
             Object.values(state.routes).forEach((routeExecution) => {
@@ -117,68 +118,13 @@ export const createRouteExecutionStore = ({ namePrefix }) => createWithEqualityF
                     ?.startedAt ?? 0;
                 const outdated = startedAt > 0 && currentTime - startedAt > oneDay;
                 if (routeExecution?.route && outdated) {
-                    routeExecution.status |= RouteExecutionStatus.Done;
+                    delete state.routes[routeExecution.route.id];
                 }
             });
-            // migrate old routes
-            const routeString = localStorage.getItem('routes');
-            if (routeString) {
-                const routes = JSON.parse(routeString);
-                routes.forEach((route) => {
-                    if (state.routes[route.id]) {
-                        return;
-                    }
-                    state.routes[route.id] = {
-                        route,
-                        status: RouteExecutionStatus.Idle,
-                    };
-                    const isFailed = isRouteFailed(route);
-                    if (isFailed) {
-                        state.routes[route.id].status = RouteExecutionStatus.Failed;
-                        return;
-                    }
-                    const isDone = isRouteDone(route);
-                    if (isDone) {
-                        state.routes[route.id].status = RouteExecutionStatus.Done;
-                        return;
-                    }
-                    const isLoading = route.steps.some((step) => step.execution);
-                    if (isLoading) {
-                        state.routes[route.id].status = RouteExecutionStatus.Pending;
-                    }
-                });
-                localStorage.removeItem('routes');
-            }
         }
         catch (error) {
             console.error(error);
         }
         return state;
     },
-    migrate: (persistedState, version) => {
-        if (version === 0) {
-            Object.values(persistedState.routes).forEach((route) => {
-                if (route) {
-                    switch (route.status) {
-                        case 'idle':
-                            route.status = RouteExecutionStatus.Idle;
-                            break;
-                        case 'loading':
-                            route.status = RouteExecutionStatus.Pending;
-                            break;
-                        case 'success':
-                        case 'warning':
-                            route.status = RouteExecutionStatus.Done;
-                            break;
-                        case 'error':
-                            route.status = RouteExecutionStatus.Failed;
-                            break;
-                        default:
-                            break;
-                    }
-                }
-            });
-        }
-        return persistedState;
-    },
 }), Object.is);

package/stores/routes/index.d.ts

@@ -2,5 +2,4 @@ export * from './RouteExecutionStore';
 export * from './types';
 export * from './useExecutingRoutesIds';
 export * from './useSetExecutableRoute';
-export * from './useTransactionHistory';
 export * from './utils';

package/stores/routes/index.js

@@ -2,5 +2,4 @@ export * from './RouteExecutionStore';
 export * from './types';
 export * from './useExecutingRoutesIds';
 export * from './useSetExecutableRoute';
-export * from './useTransactionHistory';
 export * from './utils';

package/stores/routes/types.d.ts

@@ -1,6 +1,6 @@
-import type { Route } from '@lifi/sdk';
+import type { Route, RouteExtended } from '@lifi/sdk';
 export interface RouteExecution {
-    route: Route;
+    route: RouteExtended;
     status: RouteExecutionStatus;
 }
 export interface RouteExecutionState {

package/stores/routes/utils.d.ts

@@ -1,8 +1,8 @@
-import type { Process, Route } from '@lifi/sdk';
-export declare const isRouteDone: (route: Route) => boolean;
-export declare const isRoutePartiallyDone: (route: Route) => boolean;
-export declare const isRouteRefunded: (route: Route) => boolean;
-export declare const isRouteFailed: (route: Route) => boolean;
-export declare const isRouteActive: (route?: Route) => boolean;
-export declare const doesRouteHaveCustomTool: (route: Route) => boolean;
-export declare const getUpdatedProcess: (currentRoute: Route, updatedRoute: Route) => Process | undefined;
+import type { Process, RouteExtended } from '@lifi/sdk';
+export declare const isRouteDone: (route: RouteExtended) => boolean;
+export declare const isRoutePartiallyDone: (route: RouteExtended) => boolean;
+export declare const isRouteRefunded: (route: RouteExtended) => boolean;
+export declare const isRouteFailed: (route: RouteExtended) => boolean;
+export declare const isRouteActive: (route?: RouteExtended) => boolean;
+export declare const getUpdatedProcess: (currentRoute: RouteExtended, updatedRoute: RouteExtended) => Process | undefined;
+export declare const getSourceTxHash: (route?: RouteExtended) => string | undefined;

package/stores/routes/utils.js

@@ -20,9 +20,6 @@ export const isRouteActive = (route) => {
     const alreadyStarted = route.steps.some((step) => step.execution);
     return !isDone && !isFailed && alreadyStarted;
 };
-export const doesRouteHaveCustomTool = (route) => {
-    return route.steps.some((step) => step.tool === 'custom' || step.toolDetails.key === 'custom');
-};
 export const getUpdatedProcess = (currentRoute, updatedRoute) => {
     const processDiff = microdiff(currentRoute, updatedRoute).find((diff) => diff.path.includes('process'));
     if (!processDiff) {
@@ -34,3 +31,8 @@ export const getUpdatedProcess = (currentRoute, updatedRoute) => {
         .reduce((obj, path) => obj[path], updatedRoute);
     return process;
 };
+export const getSourceTxHash = (route) => {
+    return route?.steps[0].execution?.process
+        .filter((process) => process.type !== 'TOKEN_ALLOWANCE')
+        .find((process) => process.txHash)?.txHash;
+};

package/stores/settings/useSettingsStore.js

@@ -101,10 +101,8 @@ export const useSettingsStore = createWithEqualityFn(persist((set, get) => ({
 }), Object.is);
 export const setDefaultSettings = (config) => {
     const { slippage, routePriority, setValue, gasPrice } = useSettingsStore.getState();
-    const defaultSlippage = (config?.slippage ||
-        config?.sdkConfig?.defaultRouteOptions?.slippage ||
-        0) * 100;
-    const defaultRoutePriority = config?.routePriority || config?.sdkConfig?.defaultRouteOptions?.order;
+    const defaultSlippage = (config?.slippage || config?.sdkConfig?.routeOptions?.slippage || 0) * 100;
+    const defaultRoutePriority = config?.routePriority || config?.sdkConfig?.routeOptions?.order;
     defaultConfigurableSettings.slippage = (defaultSlippage || defaultConfigurableSettings.slippage)?.toString();
     defaultConfigurableSettings.routePriority =
         defaultRoutePriority || defaultConfigurableSettings.routePriority;

package/stores/settings/useSplitSubvariantStore.d.ts

@@ -2,6 +2,6 @@
 import type { SplitSubvariantProps, SplitSubvariantProviderProps, SplitSubvariantState, SplitSubvariantStore } from './types';
 export declare const SplitSubvariantStoreContext: import("react").Context<SplitSubvariantStore | null>;
 export declare function SplitSubvariantStoreProvider({ children, ...props }: SplitSubvariantProviderProps): import("react/jsx-runtime").JSX.Element;
-export declare function useSplitSubvariantStore<T>(selector: (state: SplitSubvariantState) => T, equalityFn?: (left: T, right: T) => boolean): T;
+export declare function useSplitSubvariantStore<T>(selector: (state: SplitSubvariantState) => T): T;
 export declare function useSplitSubvariantStoreContext(): SplitSubvariantStore;
 export declare const createSplitSubvariantStore: ({ state }: SplitSubvariantProps) => import("zustand/traditional").UseBoundStoreWithEqualityFn<import("zustand").StoreApi<SplitSubvariantState>>;

package/stores/settings/useSplitSubvariantStore.js

@@ -13,12 +13,12 @@ export function SplitSubvariantStoreProvider({ children, ...props }) {
     }
     return (_jsx(SplitSubvariantStoreContext.Provider, { value: storeRef.current, children: children }));
 }
-export function useSplitSubvariantStore(selector, equalityFn) {
+export function useSplitSubvariantStore(selector) {
     const useStore = useContext(SplitSubvariantStoreContext);
     if (!useStore) {
         throw new Error(`You forgot to wrap your component in <${SplitSubvariantStoreProvider.name}>.`);
     }
-    return useStore(selector, equalityFn);
+    return useStore(selector);
 }
 export function useSplitSubvariantStoreContext() {
     const useStore = useContext(SplitSubvariantStoreContext);