floppy-disk 2.7.2 → 2.8.0-beta.1

package/esm/preact/create-query.js

@@ -1,416 +0,0 @@
-import { h as createElement } from 'preact';
-import { useState } from 'preact/hooks';
-import { getValueOrComputedValue, hasValue, identityFn, isClient, noop } from '../utils';
-import { createStores } from './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,
-];
-/**
- * @see https://floppy-disk.vercel.app/docs/api#createquery
- */
-export const createQuery = (queryFn, options = {}) => {
-    const defaultFetchOnWindowFocus = options.fetchOnMount ?? true;
-    const defaultFetchOnReconnect = options.fetchOnMount ?? true;
-    const { onFirstSubscribe = noop, onSubscribe = noop, onLastUnsubscribe = noop, onBeforeChangeKey = noop, defaultDeps = useQueryDefaultDeps, select = identityFn, staleTime = 3000, // 3 seconds
-    fetchOnMount = true, fetchOnWindowFocus = defaultFetchOnWindowFocus, fetchOnReconnect = defaultFetchOnReconnect, enabled = true, retry = 1, retryDelay = 2000, // 2 seconds
-    keepPreviousData, getNextPageParam = () => undefined, onSuccess = noop, onError = noop, onSettled = 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 = createStores(({ get, set, key: _key, keyHash }) => {
-        const key = _key;
-        const getRetryProps = (error, retryCount) => {
-            const prevState = get();
-            const maxRetryCount = getValueOrComputedValue(retry, error, prevState) || 0;
-            const delay = getValueOrComputedValue(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 || !getValueOrComputedValue(enabled, key))
-                return resolve(state);
-            if (isLoading)
-                set({ isWaiting: true });
-            else
-                set({ isWaiting: true, isRefetching: true });
-            const callQuery = () => {
-                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 resolve(get());
-                    }
-                    responseAllPages.push(response);
-                    const newPageParam = getNextPageParam(response, responseAllPages.length, stateBeforeCallQuery);
-                    newPageParams.push(newPageParam);
-                    if (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: hasValue(newPageParam),
-                    };
-                    const refetchIntervalValue = isClient && getValueOrComputedValue(refetchInterval, { ...get(), ...nextState });
-                    if (refetchIntervalValue) {
-                        refetchIntervalTimeoutId.set(keyHash, window.setTimeout(() => {
-                            forceFetch();
-                        }, refetchIntervalValue));
-                    }
-                    set(nextState);
-                    onSuccess(response, stateBeforeCallQuery);
-                })
-                    .catch((error) => {
-                    const prevState = get();
-                    const errorUpdatedAt = Date.now();
-                    const { shouldRetry, delay } = getRetryProps(error, prevState.retryCount);
-                    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,
-                            isGoingToRetry: shouldRetry,
-                            pageParam,
-                            hasNextPage: hasValue(pageParam),
-                        }
-                        : {
-                            isWaiting: false,
-                            status: 'error',
-                            isLoading: false,
-                            isError: true,
-                            data: undefined,
-                            error,
-                            errorUpdatedAt,
-                            isGoingToRetry: shouldRetry,
-                            pageParam,
-                            hasNextPage: hasValue(pageParam),
-                        });
-                    if (shouldRetry && isClient) {
-                        retryTimeoutId.set(keyHash, window.setTimeout(() => {
-                            set({ retryCount: prevState.retryCount + 1 });
-                            callQuery();
-                        }, delay));
-                    }
-                    onError(error, stateBeforeCallQuery);
-                })
-                    .finally(() => {
-                    onSettled(stateBeforeCallQuery);
-                    resolve(get());
-                });
-            };
-            callQuery();
-        });
-        const fetch = () => {
-            const { responseUpdatedAt } = get();
-            const isStale = Date.now() > (responseUpdatedAt || 0) + 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 || !getValueOrComputedValue(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: hasValue(newPageParam),
-                });
-                onSuccess(response, stateBeforeCallQuery);
-            })
-                .catch((error) => {
-                const prevState = get();
-                const { shouldRetry, delay } = getRetryProps(error, prevState.retryNextPageCount);
-                set({
-                    isWaitingNextPage: false,
-                    isError: true,
-                    error,
-                    errorUpdatedAt: Date.now(),
-                    isGoingToRetryNextPage: shouldRetry,
-                });
-                if (shouldRetry) {
-                    retryNextPageTimeoutId.set(keyHash, window.setTimeout(() => {
-                        set({ retryNextPageCount: prevState.retryNextPageCount + 1 });
-                        fetchNextPage();
-                    }, delay));
-                }
-                onError(error, stateBeforeCallQuery);
-            })
-                .finally(() => {
-                onSettled(stateBeforeCallQuery);
-                resolve(get());
-            });
-        });
-        return {
-            ...INITIAL_QUERY_STATE,
-            key,
-            keyHash,
-            fetch,
-            forceFetch,
-            fetchNextPage,
-            reset: () => {
-                preventReplaceResponse.set(keyHash, true);
-                set(INITIAL_QUERY_STATE);
-            },
-            optimisticUpdate: (response) => useQuery.optimisticUpdate({ key, response }),
-        };
-    }, (() => {
-        const windowFocusHandler = () => {
-            useQuery.getAllWithSubscriber().forEach((state) => {
-                const result = getValueOrComputedValue(fetchOnWindowFocus, state.key);
-                if (result === 'always')
-                    state.forceFetch();
-                else if (result)
-                    state.fetch();
-            });
-        };
-        const reconnectHandler = () => {
-            useQuery.getAllWithSubscriber().forEach((state) => {
-                const result = getValueOrComputedValue(fetchOnReconnect, state.key);
-                if (result === 'always')
-                    state.forceFetch();
-                else if (result)
-                    state.fetch();
-            });
-        };
-        return {
-            ...createStoresOptions,
-            defaultDeps,
-            onFirstSubscribe: (state) => {
-                if (state.isSuccess) {
-                    const refetchIntervalValue = isClient && getValueOrComputedValue(refetchInterval, state);
-                    if (refetchIntervalValue) {
-                        refetchIntervalTimeoutId.set(state.keyHash, window.setTimeout(() => {
-                            state.forceFetch();
-                        }, refetchIntervalValue));
-                    }
-                }
-                if (isClient) {
-                    if (fetchOnWindowFocus)
-                        window.addEventListener('focus', windowFocusHandler);
-                    if (fetchOnReconnect)
-                        window.addEventListener('online', reconnectHandler);
-                }
-                clearTimeout(resetTimeoutId.get(state.keyHash));
-                onFirstSubscribe(state);
-            },
-            onSubscribe: (state) => {
-                const result = getValueOrComputedValue(fetchOnMount, state.key);
-                if (result === 'always')
-                    state.forceFetch();
-                else if (result)
-                    state.fetch();
-                onSubscribe(state);
-            },
-            onLastUnsubscribe: (state) => {
-                const totalSubs = useQuery.getAllWithSubscriber().length;
-                if (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 (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
-        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: hasValue(newPageParam),
-            });
-        });
-    };
-    useQuery.reset = () => {
-        useQuery.getStores().forEach((store, keyHash) => {
-            preventReplaceResponse.set(keyHash, true);
-            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 = getValueOrComputedValue(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;
-    };
-    const defaultElement = () => null;
-    useQuery.Render = (props) => {
-        const { queryKey, loading = defaultElement, success = defaultElement, error = defaultElement, } = props;
-        // eslint-disable-next-line react-hooks/rules-of-hooks
-        const state = useQuery(queryKey);
-        if (state.data)
-            return createElement(success, state.key);
-        return createElement(state.isLoading ? loading : error, state.key);
-    };
-    return useQuery;
-};

package/esm/preact/create-store.d.ts

@@ -1,31 +0,0 @@
-import { InitStoreOptions, SelectDeps, SetStoreData, StoreData, StoreInitializer, Subscribers } from '../vanilla';
-export type WatchProps<T> = {
-    selectDeps?: SelectDeps<T>;
-    render: (state: T) => any;
-};
-export type UseStore<T extends StoreData> = {
-    /**
-     * @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`.
-     *
-     * IMPORTANT NOTE: `selectDeps` must not be changed after initialization.
-     */
-    (selectDeps?: SelectDeps<T>): T;
-    get: () => T;
-    set: (value: SetStoreData<T>, silent?: boolean) => void;
-    subscribe: (fn: (state: T) => void, selectDeps?: SelectDeps<T>) => () => void;
-    getSubscribers: () => Subscribers<T>;
-    /**
-     * Set default values inside a component.
-     *
-     * IMPORTANT NOTE: Put this on the root component or parent component, before any component subscribed!
-     */
-    setDefaultValues: (values: SetStoreData<T>) => void;
-    Watch: (props: WatchProps<T>) => any;
-};
-/**
- * @see https://floppy-disk.vercel.app/docs/api#createstore
- */
-export declare const createStore: <T extends StoreData>(initializer: StoreInitializer<T>, options?: InitStoreOptions<T> & {
-    defaultDeps?: SelectDeps<T>;
-}) => UseStore<T>;

package/esm/preact/create-store.js

@@ -1,38 +0,0 @@
-import { useEffect, useState } from 'preact/hooks';
-import { initStore, } from '../vanilla';
-/**
- * @see https://floppy-disk.vercel.app/docs/api#createstore
- */
-export const createStore = (initializer, options = {}) => {
-    const { get, set, subscribe, getSubscribers } = initStore(initializer, options);
-    const { defaultDeps } = options;
-    /**
-     * IMPORTANT NOTE: selectDeps function must not be changed after initialization.
-     */
-    const useStore = (selectDeps = defaultDeps) => {
-        const [state, setState] = useState(get);
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-        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
-        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, render }) => {
-        const store = useStore(selectDeps);
-        return render(store);
-    };
-    useStore.Watch = Watch;
-    return useStore;
-};

package/esm/preact/create-stores.d.ts

@@ -1,52 +0,0 @@
-import { Maybe } from '../utils';
-import { InitStoreOptions, InitStoreReturn, SelectDeps, SetStoreData, StoreData, Subscribers } from '../vanilla';
-import { WatchProps } from './create-store';
-export type StoreKey = Record<string, any> | undefined;
-export type StoresInitializer<TKey extends StoreKey = StoreKey, T extends StoreData = StoreData> = (api: {
-    get: () => T;
-    set: (value: SetStoreData<T>, silent?: boolean) => void;
-    key: TKey;
-    keyHash: string;
-}) => T;
-export type UseStores<TKey extends StoreKey = StoreKey, T extends StoreData = StoreData> = {
-    /**
-     * @param key (Optional) Store key, an object that will be hashed into a string as a store identifier.
-     *
-     * @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 `createStores`.
-     *
-     * 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: SetStoreData<T>, silent?: boolean) => void;
-    setAll: (value: SetStoreData<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>>;
-    /**
-     * Set default values inside a component.
-     *
-     * IMPORTANT NOTE: Put this on the root component or parent component, before any component subscribed!
-     */
-    setDefaultValues: (key: Maybe<TKey>, values: SetStoreData<T>) => void;
-    Watch: (props: WatchProps<T> & {
-        storeKey?: Maybe<TKey>;
-    }) => any;
-};
-export type CreateStoresOptions<TKey extends StoreKey = StoreKey, T extends StoreData = StoreData> = 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;
-};
-/**
- * @see https://floppy-disk.vercel.app/docs/api#createstores
- */
-export declare const createStores: <TKey extends StoreKey = StoreKey, T extends StoreData = StoreData>(initializer: StoresInitializer<TKey, T>, options?: CreateStoresOptions<TKey, T>) => UseStores<TKey, T>;

package/esm/preact/create-stores.js

@@ -1,100 +0,0 @@
-import { useEffect, useMemo, useRef, useState } from 'preact/hooks';
-import { hashStoreKey, noop } from '../utils';
-import { initStore, } from '../vanilla';
-/**
- * @see https://floppy-disk.vercel.app/docs/api#createstores
- */
-export const createStores = (initializer, options = {}) => {
-    const { onBeforeChangeKey = noop, onStoreInitialized = noop, defaultDeps, hashKeyFn = hashStoreKey, } = options;
-    const stores = new Map();
-    const getStore = (_key) => {
-        const key = _key || {};
-        const keyHash = hashKeyFn(key);
-        if (!stores.has(keyHash)) {
-            stores.set(keyHash, initStore((api) => 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 } = useMemo(() => getStore(key), [keyHash]);
-        const [state, setState] = useState(get);
-        const isFirstRender = useRef(true);
-        const prevKey = useRef(key);
-        useEffect(() => {
-            if (!isFirstRender.current) {
-                onBeforeChangeKey(key, prevKey.current);
-                setState(get);
-            }
-            isFirstRender.current = false;
-            prevKey.current = key;
-            const unsubs = subscribe(setState, selectDeps);
-            return unsubs;
-            // eslint-disable-next-line react-hooks/exhaustive-deps
-        }, [keyHash]);
-        return state;
-    };
-    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) => {
-        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
-        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, render }) => {
-        const store = useStores(storeKey, selectDeps);
-        return render(store);
-    };
-    useStores.Watch = Watch;
-    return useStores;
-};

package/esm/preact/index.d.ts

@@ -1,6 +0,0 @@
-export * from './create-store';
-export * from './create-stores';
-export * from './create-query';
-export * from './create-bi-direction-query';
-export * from './create-mutation';
-export * from './with-context';

package/esm/preact/index.js

@@ -1,6 +0,0 @@
-export * from './create-store';
-export * from './create-stores';
-export * from './create-query';
-export * from './create-bi-direction-query';
-export * from './create-mutation';
-export * from './with-context';