floppy-disk 3.0.0-experimental.1 → 3.0.1

package/lib/react/create-query.js

@@ -1,438 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createQuery = void 0;
-const react_1 = require("react");
-const utils_1 = require("../utils");
-const create_stores_1 = require("./create-stores");
-const INITIAL_QUERY_STATE = {
-    isWaiting: false,
-    isWaitingNextPage: false,
-    status: 'loading',
-    isLoading: true,
-    isSuccess: false,
-    isError: false,
-    isRefetching: false,
-    isRefetchError: false,
-    isPreviousData: false,
-    isOptimisticData: false,
-    data: undefined,
-    response: undefined,
-    responseUpdatedAt: undefined,
-    error: undefined,
-    errorUpdatedAt: undefined,
-    retryCount: 0,
-    isGoingToRetry: false,
-    pageParam: undefined,
-    pageParams: [undefined],
-    hasNextPage: false,
-    retryNextPageCount: 0,
-    isGoingToRetryNextPage: false,
-};
-const useQueryDefaultDeps = (state) => [
-    state.data,
-    state.error,
-    state.isWaitingNextPage,
-    state.hasNextPage,
-];
-const fallbackComponent = () => null;
-/**
- * @see https://floppy-disk.vercel.app/docs/api#createquery
- */
-const createQuery = (queryFn, options = {}) => {
-    const defaultFetchOnWindowFocus = options.fetchOnMount ?? true;
-    const defaultFetchOnReconnect = options.fetchOnMount ?? true;
-    const { onFirstSubscribe = utils_1.noop, onSubscribe = utils_1.noop, onLastUnsubscribe = utils_1.noop, onBeforeChangeKey = utils_1.noop, defaultDeps = useQueryDefaultDeps, select = utils_1.identityFn, staleTime = 3000, // 3 seconds
-    fetchOnMount = true, fetchOnWindowFocus = defaultFetchOnWindowFocus, fetchOnReconnect = defaultFetchOnReconnect, enabled = true, retry = 1, retryDelay = 2000, // 2 seconds
-    keepPreviousData, getNextPageParam = () => undefined, onSuccess = utils_1.noop, onError, onSettled = utils_1.noop, cacheTime = 5 * 60 * 1000, refetchInterval = false, ...createStoresOptions } = options;
-    const retryTimeoutId = new Map();
-    const retryNextPageTimeoutId = new Map();
-    const resetTimeoutId = new Map();
-    const refetchIntervalTimeoutId = new Map();
-    const preventReplaceResponse = new Map(); // Prevent optimistic data to be replaced
-    const useQuery = (0, create_stores_1.createStores)(({ get, set, key: _key, keyHash }) => {
-        const key = _key;
-        const getRetryProps = (error, retryCount) => {
-            const prevState = get();
-            const maxRetryCount = (0, utils_1.getValue)(retry, error, prevState) || 0;
-            const delay = (0, utils_1.getValue)(retryDelay, error, prevState) || 0;
-            return { shouldRetry: retryCount < maxRetryCount, delay };
-        };
-        const forceFetch = () => new Promise((resolve) => {
-            const state = get();
-            const { isWaiting, isLoading, pageParams } = state;
-            const responseAllPages = [];
-            const newPageParams = [pageParams[0]];
-            let pageParam = pageParams[0];
-            clearTimeout(refetchIntervalTimeoutId.get(keyHash));
-            if (isWaiting || !(0, utils_1.getValue)(enabled, key))
-                return resolve(state);
-            if (isLoading)
-                set({ isWaiting: true });
-            else
-                set({ isWaiting: true, isRefetching: true });
-            const callQuery = (innerResolve = resolve) => {
-                if (get().isGoingToRetry) {
-                    if (isLoading)
-                        set({ isGoingToRetry: false, isWaiting: true });
-                    else
-                        set({ isGoingToRetry: false, isWaiting: true, isRefetching: true });
-                    clearTimeout(retryTimeoutId.get(keyHash));
-                }
-                preventReplaceResponse.set(keyHash, false);
-                const stateBeforeCallQuery = { ...get(), pageParam };
-                queryFn(key, stateBeforeCallQuery)
-                    .then((response) => {
-                    if (preventReplaceResponse.get(keyHash)) {
-                        set({ isWaiting: false, isRefetching: false });
-                        return innerResolve(get());
-                    }
-                    responseAllPages.push(response);
-                    const newPageParam = getNextPageParam(response, responseAllPages.length, stateBeforeCallQuery);
-                    newPageParams.push(newPageParam);
-                    if ((0, utils_1.hasValue)(newPageParam) && newPageParams.length < pageParams.length) {
-                        pageParam = newPageParam;
-                        callQuery();
-                        return;
-                    }
-                    const nextState = {
-                        isWaiting: false,
-                        status: 'success',
-                        isLoading: false,
-                        isSuccess: true,
-                        isError: false,
-                        isRefetching: false,
-                        isRefetchError: false,
-                        isPreviousData: false,
-                        isOptimisticData: false,
-                        data: responseAllPages.reduce((prev, responseCurrentPage) => {
-                            return select(responseCurrentPage, { key, data: prev });
-                        }, undefined),
-                        response,
-                        responseUpdatedAt: Date.now(),
-                        error: undefined,
-                        errorUpdatedAt: undefined,
-                        retryCount: 0,
-                        pageParam: newPageParam,
-                        pageParams: newPageParams,
-                        hasNextPage: (0, utils_1.hasValue)(newPageParam),
-                    };
-                    const refetchIntervalValue = utils_1.isClient && (0, utils_1.getValue)(refetchInterval, { ...get(), ...nextState });
-                    if (refetchIntervalValue) {
-                        refetchIntervalTimeoutId.set(keyHash, window.setTimeout(() => {
-                            forceFetch();
-                        }, refetchIntervalValue));
-                    }
-                    set(nextState);
-                    onSuccess(response, stateBeforeCallQuery);
-                    onSettled(stateBeforeCallQuery);
-                    innerResolve(get());
-                })
-                    .catch((error) => {
-                    const prevState = get();
-                    const errorUpdatedAt = Date.now();
-                    const { shouldRetry, delay } = getRetryProps(error, prevState.retryCount);
-                    if (shouldRetry) {
-                        set({
-                            isWaiting: false,
-                            isGoingToRetry: true,
-                        });
-                        if (utils_1.isClient) {
-                            retryTimeoutId.set(keyHash, window.setTimeout(() => {
-                                set({ retryCount: prevState.retryCount + 1 });
-                                callQuery(innerResolve);
-                            }, delay));
-                        }
-                        return;
-                    }
-                    set(prevState.isSuccess && !prevState.isPreviousData
-                        ? {
-                            isWaiting: false,
-                            isRefetching: false,
-                            isRefetchError: true,
-                            data: responseAllPages.length
-                                ? responseAllPages.reduce((prev, response) => {
-                                    return select(response, { key, data: prev });
-                                }, undefined)
-                                : prevState.data,
-                            error,
-                            errorUpdatedAt,
-                            pageParam,
-                            hasNextPage: (0, utils_1.hasValue)(pageParam),
-                        }
-                        : {
-                            isWaiting: false,
-                            status: 'error',
-                            isLoading: false,
-                            isError: true,
-                            data: undefined,
-                            error,
-                            errorUpdatedAt,
-                            pageParam,
-                            hasNextPage: (0, utils_1.hasValue)(pageParam),
-                        });
-                    if (onError)
-                        onError(error, stateBeforeCallQuery);
-                    else
-                        console.error(error, get());
-                    onSettled(stateBeforeCallQuery);
-                    innerResolve(get());
-                });
-            };
-            callQuery();
-        });
-        const fetch = () => {
-            const { responseUpdatedAt } = get();
-            const isStale = !responseUpdatedAt || Date.now() > responseUpdatedAt + staleTime;
-            if (!isStale)
-                return;
-            forceFetch();
-        };
-        const fetchNextPage = () => new Promise((resolve) => {
-            const state = get();
-            if (typeof options.getNextPageParam !== 'function') {
-                console.warn('fetchNextPage with invalid getNextPageParam option');
-                return resolve(state);
-            }
-            const { isLoading, isWaitingNextPage, data, hasNextPage, pageParam, pageParams } = state;
-            if (isLoading)
-                return resolve(forceFetch());
-            if (isWaitingNextPage || !hasNextPage || !(0, utils_1.getValue)(enabled, key))
-                return resolve(state);
-            set({ isWaitingNextPage: true, isGoingToRetryNextPage: false });
-            clearTimeout(retryNextPageTimeoutId.get(keyHash));
-            const stateBeforeCallQuery = get();
-            queryFn(key, { ...state, pageParam })
-                .then((response) => {
-                if (preventReplaceResponse.get(keyHash)) {
-                    set({ isWaitingNextPage: false });
-                    return resolve(get());
-                }
-                const newPageParam = getNextPageParam(response, pageParams.length, stateBeforeCallQuery);
-                set({
-                    isWaitingNextPage: false,
-                    response,
-                    responseUpdatedAt: Date.now(),
-                    data: select(response, { key, data }),
-                    pageParam: newPageParam,
-                    pageParams: pageParams.concat(newPageParam),
-                    hasNextPage: (0, utils_1.hasValue)(newPageParam),
-                });
-                onSuccess(response, stateBeforeCallQuery);
-                onSettled(stateBeforeCallQuery);
-                resolve(get());
-            })
-                .catch((error) => {
-                const prevState = get();
-                const { shouldRetry, delay } = getRetryProps(error, prevState.retryNextPageCount);
-                if (shouldRetry) {
-                    set({
-                        isWaitingNextPage: false,
-                        isGoingToRetryNextPage: true,
-                    });
-                    retryNextPageTimeoutId.set(keyHash, window.setTimeout(() => {
-                        set({ retryNextPageCount: prevState.retryNextPageCount + 1 });
-                        resolve(fetchNextPage());
-                    }, delay));
-                    return;
-                }
-                set({
-                    isWaitingNextPage: false,
-                    isError: true,
-                    error,
-                    errorUpdatedAt: Date.now(),
-                });
-                if (onError)
-                    onError(error, stateBeforeCallQuery);
-                else
-                    console.error(error, get());
-                onSettled(stateBeforeCallQuery);
-                resolve(get());
-            });
-        });
-        return {
-            ...INITIAL_QUERY_STATE,
-            key,
-            keyHash,
-            fetch,
-            forceFetch,
-            fetchNextPage,
-            reset: () => {
-                preventReplaceResponse.set(keyHash, true);
-                clearTimeout(retryTimeoutId.get(keyHash));
-                clearTimeout(retryNextPageTimeoutId.get(keyHash));
-                set(INITIAL_QUERY_STATE);
-            },
-            optimisticUpdate: (response) => useQuery.optimisticUpdate({ key, response }),
-        };
-    }, (() => {
-        const windowFocusHandler = () => {
-            useQuery.getAllWithSubscriber().forEach((state) => {
-                const result = (0, utils_1.getValue)(fetchOnWindowFocus, state.key);
-                if (result === 'always')
-                    state.forceFetch();
-                else if (result)
-                    state.fetch();
-            });
-        };
-        const reconnectHandler = () => {
-            useQuery.getAllWithSubscriber().forEach((state) => {
-                const result = (0, utils_1.getValue)(fetchOnReconnect, state.key);
-                if (result === 'always')
-                    state.forceFetch();
-                else if (result)
-                    state.fetch();
-            });
-        };
-        return {
-            ...createStoresOptions,
-            defaultDeps,
-            onFirstSubscribe: (state) => {
-                if (state.isSuccess) {
-                    const refetchIntervalValue = utils_1.isClient && (0, utils_1.getValue)(refetchInterval, state);
-                    if (refetchIntervalValue) {
-                        refetchIntervalTimeoutId.set(state.keyHash, window.setTimeout(() => {
-                            state.forceFetch();
-                        }, refetchIntervalValue));
-                    }
-                }
-                if (utils_1.isClient) {
-                    if (fetchOnWindowFocus)
-                        window.addEventListener('focus', windowFocusHandler);
-                    if (fetchOnReconnect)
-                        window.addEventListener('online', reconnectHandler);
-                }
-                clearTimeout(resetTimeoutId.get(state.keyHash));
-                onFirstSubscribe(state);
-            },
-            onSubscribe: (state) => {
-                const result = (0, utils_1.getValue)(fetchOnMount, state.key);
-                if (result === 'always')
-                    state.forceFetch();
-                else if (result)
-                    state.fetch();
-                onSubscribe(state);
-            },
-            onLastUnsubscribe: (state) => {
-                const totalSubs = useQuery.getAllWithSubscriber().length;
-                if (utils_1.isClient && totalSubs === 0) {
-                    if (fetchOnWindowFocus)
-                        window.removeEventListener('focus', windowFocusHandler);
-                    if (fetchOnReconnect)
-                        window.removeEventListener('online', reconnectHandler);
-                }
-                useQuery.set(state.key, { retryCount: 0, retryNextPageCount: 0 }, true);
-                clearTimeout(retryTimeoutId.get(state.keyHash));
-                clearTimeout(retryNextPageTimeoutId.get(state.keyHash));
-                clearTimeout(refetchIntervalTimeoutId.get(state.keyHash));
-                if (utils_1.isClient && cacheTime !== Infinity) {
-                    resetTimeoutId.set(state.keyHash, window.setTimeout(() => {
-                        useQuery.set(state.key, INITIAL_QUERY_STATE);
-                    }, cacheTime));
-                }
-                onLastUnsubscribe(state);
-            },
-            onBeforeChangeKey: (nextKey, prevKey) => {
-                if (keepPreviousData) {
-                    const nextData = useQuery.get(nextKey);
-                    if (!nextData.data) {
-                        const prevData = useQuery.get(prevKey);
-                        if (prevData.data) {
-                            useQuery.set(nextKey, {
-                                status: 'success',
-                                isLoading: false,
-                                isSuccess: true,
-                                isError: false,
-                                data: prevData.data,
-                                response: prevData.response,
-                                isPreviousData: true,
-                            }, true);
-                        }
-                    }
-                }
-                onBeforeChangeKey(nextKey, prevKey);
-            },
-        };
-    })());
-    useQuery.setInitialResponse = ({ key, response, skipRevalidation }) => {
-        // eslint-disable-next-line react-hooks/rules-of-hooks
-        (0, react_1.useState)(() => {
-            const state = useQuery.get(key);
-            if (response === undefined || state.isSuccess)
-                return;
-            const newPageParam = getNextPageParam(response, 1, state);
-            useQuery.set(key, {
-                status: 'success',
-                isLoading: false,
-                isSuccess: true,
-                isError: false,
-                response,
-                responseUpdatedAt: skipRevalidation ? Date.now() : undefined,
-                data: select(response, { key: key, data: undefined }),
-                pageParam: newPageParam,
-                pageParams: [undefined, newPageParam],
-                hasNextPage: (0, utils_1.hasValue)(newPageParam),
-            });
-        });
-    };
-    useQuery.reset = () => {
-        useQuery.getStores().forEach((store, keyHash) => {
-            preventReplaceResponse.set(keyHash, true);
-            clearTimeout(retryTimeoutId.get(keyHash));
-            clearTimeout(retryNextPageTimeoutId.get(keyHash));
-            store.set(INITIAL_QUERY_STATE);
-        });
-    };
-    useQuery.resetSpecificKey = (key) => useQuery.get(key).reset();
-    useQuery.invalidate = () => {
-        useQuery.getStores().forEach((store) => {
-            const { get, set, getSubscribers } = store;
-            set({ responseUpdatedAt: undefined });
-            if (getSubscribers().size > 0)
-                get().forceFetch();
-        });
-    };
-    useQuery.invalidateSpecificKey = (key) => {
-        const { get, set, getSubscribers } = useQuery.getStore(key);
-        set({ responseUpdatedAt: undefined });
-        if (getSubscribers().size > 0)
-            get().forceFetch();
-    };
-    useQuery.optimisticUpdate = ({ key, response }) => {
-        const prevState = useQuery.get(key);
-        const optimisticResponse = (0, utils_1.getValue)(response, prevState);
-        useQuery.set(key, {
-            isOptimisticData: true,
-            response: optimisticResponse,
-            data: select(optimisticResponse, { key: key, data: undefined }),
-        });
-        preventReplaceResponse.set(prevState.keyHash, true);
-        const revert = () => {
-            useQuery.set(key, {
-                isOptimisticData: false,
-                response: prevState.response,
-                data: prevState.data,
-            });
-        };
-        const invalidate = () => useQuery.invalidateSpecificKey(key);
-        return { revert, invalidate };
-    };
-    useQuery.suspend = (key) => {
-        // eslint-disable-next-line react-hooks/rules-of-hooks
-        const state = useQuery(key);
-        if (state.isLoading)
-            throw state.forceFetch();
-        if (state.isError)
-            throw state.error;
-        return state;
-    };
-    useQuery.Render = (props) => {
-        const { queryKey, loading = fallbackComponent, success = fallbackComponent, error = fallbackComponent, } = props;
-        // eslint-disable-next-line react-hooks/rules-of-hooks
-        const state = useQuery(queryKey);
-        if (state.data)
-            return (0, react_1.createElement)(success, state);
-        return (0, react_1.createElement)(state.isLoading ? loading : error, state);
-    };
-    return useQuery;
-};
-exports.createQuery = createQuery;

package/lib/react/create-store.d.ts

@@ -1,38 +0,0 @@
-import { InitStoreOptions, SelectDeps, SetStoreState, StoreInitializer, StoreState, Subscribers } from '../vanilla/init-store';
-export type WatchProps<T> = {
-    selectDeps?: SelectDeps<T>;
-    render: (state: T) => any;
-};
-export type UseStore<T extends StoreState> = {
-    /**
-     * @param selectDeps A function that return the dependency array (just like in `useEffect`), to trigger reactivity.
-     *
-     * Defaults to `undefined` (reactive to all state change) if you didn't set `defaultDeps` on `createStore`.
-     *
-     * Value of `null` will also make it reactive to all state change.
-     *
-     * **IMPORTANT NOTE:** `selectDeps` must not be changed after initialization.
-     */
-    (selectDeps?: SelectDeps<T>): T;
-    get: () => T;
-    set: (value: SetStoreState<T>, silent?: boolean) => void;
-    subscribe: (fn: (state: T) => void, selectDeps?: SelectDeps<T>) => () => void;
-    getSubscribers: () => Subscribers<T>;
-    /**
-     * ⚛️ (**_Hook_**)
-     *
-     * Set default values **inside of a component**.
-     *
-     * **IMPORTANT NOTE:**
-     * - This is a hook, put it inside of a React component
-     * - Put this on the root component or parent component, before any component subscribed!
-     */
-    setDefaultValues: (values: SetStoreState<T>) => void;
-    Watch: (props: WatchProps<T>) => any;
-};
-/**
- * @see https://floppy-disk.vercel.app/docs/api#createstore
- */
-export declare const createStore: <T extends StoreState>(initializer: StoreInitializer<T>, options?: InitStoreOptions<T> & {
-    defaultDeps?: SelectDeps<T>;
-}) => UseStore<T>;

package/lib/react/create-store.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createStore = void 0;
-const react_1 = require("react");
-const init_store_1 = require("../vanilla/init-store");
-/**
- * @see https://floppy-disk.vercel.app/docs/api#createstore
- */
-const createStore = (initializer, options = {}) => {
-    const { get, set, subscribe, getSubscribers } = (0, init_store_1.initStore)(initializer, options);
-    const { defaultDeps } = options;
-    /**
-     * **IMPORTANT NOTE:** `selectDeps` function must not be changed after initialization.
-     */
-    const useStore = (selectDeps = defaultDeps) => {
-        const [state, setState] = (0, react_1.useState)(get);
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-        (0, react_1.useEffect)(() => subscribe(setState, selectDeps), []);
-        return state;
-    };
-    useStore.get = get;
-    useStore.set = set;
-    useStore.subscribe = subscribe;
-    useStore.getSubscribers = getSubscribers;
-    useStore.setDefaultValues = (value) => {
-        // eslint-disable-next-line react-hooks/rules-of-hooks
-        (0, react_1.useState)(() => {
-            const subscribers = getSubscribers();
-            if (subscribers.size > 0) {
-                console.warn('Put setDefaultValues on the root component or parent component, before any component subscribed!');
-            }
-            set(value);
-        });
-    };
-    const Watch = ({ selectDeps = defaultDeps, render }) => {
-        const store = useStore(selectDeps);
-        return render(store);
-    };
-    useStore.Watch = Watch;
-    return useStore;
-};
-exports.createStore = createStore;

package/lib/react/create-stores.d.ts

@@ -1,61 +0,0 @@
-import { Maybe } from '../utils';
-import { InitStoreOptions, InitStoreReturn, SelectDeps, SetStoreState, StoreState, Subscribers } from '../vanilla/init-store';
-import { WatchProps } from './create-store';
-export type StoreKey = Record<string, any> | undefined;
-export type StoresInitializer<TKey extends StoreKey = StoreKey, T extends StoreState = StoreState> = T | ((api: {
-    get: () => T;
-    set: (value: SetStoreState<T>, silent?: boolean) => void;
-    key: TKey;
-    keyHash: string;
-}) => T);
-export type UseStores<TKey extends StoreKey = StoreKey, T extends StoreState = StoreState> = {
-    /**
-     * @param key (Optional) Store key, an object that will be hashed into a string as a store identifier.
-     * No need to memoize the store key.
-     *
-     * @param selectDeps (Optional) A function that return the dependency array (just like in `useEffect`), to trigger reactivity.
-     *
-     * Defaults to `undefined` (reactive to all state change) if you didn't set `defaultDeps` on `createStores`.
-     *
-     * Value of `null` will also make it reactive to all state change.
-     *
-     * **IMPORTANT NOTE:** `selectDeps` must not be changed after initialization.
-     */
-    (...args: [Maybe<TKey>, SelectDeps<T>?] | [SelectDeps<T>?]): T;
-    get: (key?: Maybe<TKey>) => T;
-    getAll: () => T[];
-    getAllWithSubscriber: () => T[];
-    set: (key: Maybe<TKey>, value: SetStoreState<T>, silent?: boolean) => void;
-    setAll: (value: SetStoreState<T>, silent?: boolean) => void;
-    subscribe: (key: Maybe<TKey>, fn: (state: T) => void, selectDeps?: SelectDeps<T>) => () => void;
-    getSubscribers: (key: Maybe<TKey>) => Subscribers<T>;
-    getStore: (key?: Maybe<TKey>) => InitStoreReturn<T>;
-    getStores: () => Map<string, InitStoreReturn<T>>;
-    /**
-     * ⚛️ (**_Hook_**)
-     *
-     * Set default values **inside of a component**.
-     *
-     * **IMPORTANT NOTE:**
-     * - This is a hook, put it inside of a React component
-     * - Put this on the root component or parent component, before any component subscribed!
-     */
-    setDefaultValues: (key: Maybe<TKey>, values: SetStoreState<T>) => void;
-    Watch: (props: WatchProps<T> & {
-        storeKey?: Maybe<TKey>;
-    }) => any;
-};
-export type CreateStoresOptions<TKey extends StoreKey = StoreKey, T extends StoreState = StoreState> = InitStoreOptions<T> & {
-    onBeforeChangeKey?: (nextKey: TKey, prevKey: TKey) => void;
-    /**
-     * Will be triggered when a single store with a specific key was initialized.
-     */
-    onStoreInitialized?: (key: TKey, keyHash: string) => void;
-    defaultDeps?: SelectDeps<T>;
-    hashKeyFn?: (obj: TKey) => string;
-};
-export declare const hashStoreKey: (obj?: any) => string;
-/**
- * @see https://floppy-disk.vercel.app/docs/api#createstores
- */
-export declare const createStores: <TKey extends StoreKey = StoreKey, T extends StoreState = StoreState>(initializer: StoresInitializer<TKey, T>, options?: CreateStoresOptions<TKey, T>) => UseStores<TKey, T>;

package/lib/react/create-stores.js

@@ -1,104 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createStores = exports.hashStoreKey = void 0;
-const react_1 = require("react");
-const utils_1 = require("../utils");
-const init_store_1 = require("../vanilla/init-store");
-const hashStoreKey = (obj) => JSON.stringify(obj, Object.keys(obj).sort());
-exports.hashStoreKey = hashStoreKey;
-/**
- * @see https://floppy-disk.vercel.app/docs/api#createstores
- */
-const createStores = (initializer, options = {}) => {
-    const { onBeforeChangeKey = utils_1.noop, onStoreInitialized = utils_1.noop, defaultDeps, hashKeyFn = exports.hashStoreKey, } = options;
-    const stores = new Map();
-    const getStore = (_key) => {
-        const key = _key || {};
-        const keyHash = hashKeyFn(key);
-        if (!stores.has(keyHash)) {
-            stores.set(keyHash, (0, init_store_1.initStore)((api) => (0, utils_1.getValue)(initializer, { key, keyHash, ...api }), options));
-            onStoreInitialized(key, keyHash);
-        }
-        return stores.get(keyHash);
-    };
-    /**
-     * **IMPORTANT NOTE:** `selectDeps` function must not be changed after initialization.
-     */
-    const useStores = (...args) => {
-        const [_key, selectDeps = defaultDeps] = (typeof args[0] === 'function' ? [{}, args[0]] : args);
-        const key = _key || {};
-        const keyHash = hashKeyFn(key);
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-        const { get, subscribe } = (0, react_1.useMemo)(() => getStore(key), [keyHash]);
-        const [, setState] = (0, react_1.useState)(get);
-        const prevKey = (0, react_1.useRef)(key);
-        const prevKeyHash = (0, react_1.useRef)(keyHash);
-        (0, react_1.useEffect)(() => {
-            prevKey.current = key;
-            prevKeyHash.current = keyHash;
-            const unsubs = subscribe(setState, selectDeps);
-            return unsubs;
-            // eslint-disable-next-line react-hooks/exhaustive-deps
-        }, [keyHash]);
-        if (keyHash !== prevKeyHash.current)
-            onBeforeChangeKey(key, prevKey.current);
-        return get();
-    };
-    useStores.get = (key) => {
-        const store = getStore(key);
-        return store.get();
-    };
-    useStores.getAll = () => {
-        const allStores = [];
-        stores.forEach((store) => {
-            allStores.push(store.get());
-        });
-        return allStores;
-    };
-    useStores.getAllWithSubscriber = () => {
-        const allStores = [];
-        stores.forEach((store) => {
-            const subscribers = store.getSubscribers();
-            if (subscribers.size > 0)
-                allStores.push(store.get());
-        });
-        return allStores;
-    };
-    useStores.set = (key, value, silent) => {
-        const store = getStore(key);
-        store.set(value, silent);
-    };
-    useStores.setAll = (value, silent) => {
-        stores.forEach((store) => {
-            store.set(value, silent);
-        });
-    };
-    useStores.subscribe = (key, fn, selectDeps = defaultDeps) => {
-        const store = getStore(key);
-        return store.subscribe(fn, selectDeps);
-    };
-    useStores.getSubscribers = (key) => {
-        const store = getStore(key);
-        return store.getSubscribers();
-    };
-    useStores.getStore = (key) => getStore(key);
-    useStores.getStores = () => stores;
-    useStores.setDefaultValues = (key, value) => {
-        // eslint-disable-next-line react-hooks/rules-of-hooks
-        (0, react_1.useState)(() => {
-            const store = getStore(key);
-            const subscribers = store.getSubscribers();
-            if (subscribers.size > 0) {
-                console.warn('Put setDefaultValues on the root component or parent component, before any component subscribed!');
-            }
-            store.set(value);
-        });
-    };
-    const Watch = ({ storeKey, selectDeps = defaultDeps, render, }) => {
-        const store = useStores(storeKey, selectDeps);
-        return render(store);
-    };
-    useStores.Watch = Watch;
-    return useStores;
-};
-exports.createStores = createStores;