floppy-disk 2.0.0-beta.1 → 2.0.0-beta.3

package/esm/index.d.ts

@@ -1,6 +1,2 @@
 export * from './vanilla';
-export * from './react/create-store';
-export * from './react/create-stores';
-export * from './react/create-query';
-export * from './react/create-mutation';
-export * from './react/with-context';
+export * from './react';

package/esm/index.js

@@ -1,6 +1,2 @@
 export * from './vanilla';
-export * from './react/create-store';
-export * from './react/create-stores';
-export * from './react/create-query';
-export * from './react/create-mutation';
-export * from './react/with-context';
+export * from './react';

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

@@ -0,0 +1,28 @@
+import { InitStoreOptions } from '../vanilla';
+export type MutationState<TVar, TResponse = any, TError = unknown> = {
+    /**
+     * Network fetching status.
+     */
+    isWaiting: boolean;
+    isSuccess: boolean;
+    isError: boolean;
+    response: TResponse | null;
+    responseUpdatedAt: number | null;
+    error: TError | null;
+    errorUpdatedAt: number | null;
+    /**
+     * Mutate function is a promise that will always resolve.
+     */
+    mutate: (variables?: TVar) => Promise<{
+        response?: TResponse;
+        error?: TError;
+        variables?: TVar;
+    }>;
+};
+export type CreateMutationOptions<TVar, TResponse = any, TError = unknown> = InitStoreOptions<MutationState<TVar, TResponse, TError>> & {
+    onMutate?: (variables: TVar | undefined, stateBeforeMutate: MutationState<TVar, TResponse, TError>) => void;
+    onSuccess?: (response: TResponse, variables: TVar | undefined, stateBeforeMutate: MutationState<TVar, TResponse, TError>) => void;
+    onError?: (error: TError, variables: TVar | undefined, stateBeforeMutate: MutationState<TVar, TResponse, TError>) => void;
+    onSettled?: (variables: TVar | undefined, stateBeforeMutate: MutationState<TVar, TResponse, TError>) => void;
+};
+export declare const createMutation: <TVar, TResponse = any, TError = unknown>(mutationFn: (variables: TVar | undefined, state: MutationState<TVar, TResponse, TError>) => Promise<TResponse>, options?: CreateMutationOptions<TVar, TResponse, TError>) => import("./create-store").UseStore<MutationState<TVar, TResponse, TError>>;

package/esm/preact/create-mutation.js

@@ -0,0 +1,50 @@
+import { noop } from '../utils';
+import { createStore } from './create-store';
+export const createMutation = (mutationFn, options = {}) => {
+    const { onMutate = noop, onSuccess = noop, onError = noop, onSettled = noop, ...createStoreOptions } = options;
+    const useMutation = createStore(({ set, get }) => ({
+        isWaiting: false,
+        isSuccess: false,
+        isError: false,
+        response: null,
+        responseUpdatedAt: null,
+        error: null,
+        errorUpdatedAt: null,
+        mutate: (variables) => {
+            set({ isWaiting: true });
+            const stateBeforeMutate = get();
+            onMutate(variables, stateBeforeMutate);
+            return new Promise((resolve) => {
+                mutationFn(variables, stateBeforeMutate)
+                    .then((response) => {
+                    set({
+                        isWaiting: false,
+                        isSuccess: true,
+                        isError: false,
+                        response,
+                        responseUpdatedAt: Date.now(),
+                        error: null,
+                        errorUpdatedAt: null,
+                    });
+                    onSuccess(response, variables, stateBeforeMutate);
+                    resolve({ response, variables });
+                })
+                    .catch((error) => {
+                    set({
+                        isWaiting: false,
+                        isSuccess: false,
+                        isError: true,
+                        error,
+                        errorUpdatedAt: Date.now(),
+                    });
+                    onError(error, variables, stateBeforeMutate);
+                    resolve({ error, variables });
+                })
+                    .finally(() => {
+                    onSettled(variables, stateBeforeMutate);
+                });
+            });
+        },
+    }), createStoreOptions);
+    return useMutation;
+};

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

@@ -0,0 +1,197 @@
+import { CreateStoresOptions, StoreKey, UseStores } from './create-stores';
+export type QueryStatus = 'loading' | 'success' | 'error';
+export type QueryState<TKey extends StoreKey = StoreKey, TResponse = any, TData = TResponse, TError = unknown> = {
+    /**
+     * Query store key, an object that will be hashed into a string as a query store identifier.
+     */
+    key: TKey;
+    /**
+     * Will only be called if the data is stale or empty.
+     */
+    fetch: () => void;
+    /**
+     * Will be called even if the data is still fresh (not stale).
+     */
+    forceFetch: () => void;
+    /**
+     * Fetch next page if has next page.
+     *
+     * If the data is empty, it will just fetch the first page.
+     *
+     * You can ignore this if your query is not paginated.
+     */
+    fetchNextPage: () => void;
+    /**
+     * Set query state (data, error, etc) to initial state.
+     */
+    reset: () => void;
+    /**
+     * Optimistic update.
+     *
+     * @returns function to revert the changes & function to invalidate the query
+     *
+     * IMPORTANT NOTE: This won't work well on infinite query.
+     */
+    optimisticUpdate: (response: TResponse | ((prevState: QueryState<TKey, TResponse, TData, TError>) => TResponse)) => {
+        revert: () => void;
+        invalidate: () => void;
+    };
+    /**
+     * Network fetching status.
+     */
+    isWaiting: boolean;
+    /**
+     * Network fetching status for fetching next page.
+     */
+    isWaitingNextPage: boolean;
+    /**
+     * Status of the data.
+     *
+     * `"loading"` = no data.
+     *
+     * `"success"` = has data.
+     *
+     * `"error"` = has error.
+     *
+     * It has no relation with network fetching state.
+     * If you're looking for network fetching state, use `isWaiting` instead.
+     */
+    status: QueryStatus;
+    /**
+     * Data state, will be `true` if the query has no data.
+     *
+     * It has no relation with network fetching state.
+     * If you're looking for network fetching state, use `isWaiting` instead.
+     */
+    isLoading: boolean;
+    /**
+     * Data state, will be `true` if the query has a data.
+     */
+    isSuccess: boolean;
+    /**
+     * Error state, will be `true` after data fetching error.
+     */
+    isError: boolean;
+    isRefetching: boolean;
+    isRefetchError: boolean;
+    isPreviousData: boolean;
+    isOptimisticData: boolean;
+    data: TData | null;
+    response: TResponse | null;
+    responseUpdatedAt: number | null;
+    error: TError | null;
+    errorUpdatedAt: number | null;
+    retryCount: number;
+    isGoingToRetry: boolean;
+    pageParam: any;
+    pageParams: any[];
+    hasNextPage: boolean;
+    retryNextPageCount: number;
+    isGoingToRetryNextPage: boolean;
+};
+export type CreateQueryOptions<TKey extends StoreKey = StoreKey, TResponse = any, TData = TResponse, TError = unknown> = CreateStoresOptions<TKey, QueryState<TKey, TResponse, TData, TError>> & {
+    select?: (response: TResponse, state: Pick<QueryState<TKey, TResponse, TData, TError>, 'data' | 'key'>) => TData;
+    /**
+     * Stale time in miliseconds.
+     *
+     * Defaults to `3000` (3 seconds).
+     */
+    staleTime?: number;
+    /**
+     * Auto call the query when the component is mounted.
+     *
+     * Defaults to `true`.
+     *
+     * - If set to `true`, the query will be called on mount focus **if the data is stale**.
+     * - If set to `false`, the query won't be called on mount focus.
+     * - If set to `"always"`, the query will be called on mount focus.
+     */
+    fetchOnMount?: boolean | 'always' | ((key: TKey) => boolean | 'always');
+    /**
+     * Defaults to `true`.
+     *
+     * - If set to `true`, the query will be called on window focus **if the data is stale**.
+     * - If set to `false`, the query won't be called on window focus.
+     * - If set to `"always"`, the query will be called on window focus.
+     */
+    fetchOnWindowFocus?: boolean | 'always' | ((key: TKey) => boolean | 'always');
+    /**
+     * If set to `false` or return `false`, the query won't be called in any condition.
+     * Auto fetch on mount will be disabled.
+     * Manually trigger `fetch` method (returned from `createQuery`) won't work too.
+     *
+     * Defaults to `true`.
+     */
+    enabled?: boolean | ((key: TKey) => boolean);
+    /**
+     * Number of maximum error retries.
+     *
+     * Defaults to `1`.
+     */
+    retry?: number | ((error: TError, key: TKey) => number);
+    /**
+     * Error retry delay in miliseconds.
+     *
+     * Defaults to `3000` (3 seconds).
+     */
+    retryDelay?: number | ((error: TError, key: TKey) => number);
+    /**
+     * If set to `true`, previous `data` will be kept when fetching new data because the query key changed.
+     *
+     * This will only happened if there is no `data` in the next query.
+     */
+    keepPreviousData?: boolean;
+    /**
+     * Only set this if you have an infinite query.
+     *
+     * This function should return a variable that will be used when fetching next page (`pageParam`).
+     */
+    getNextPageParam?: (lastPage: TResponse, index: number) => any;
+    onSuccess?: (response: TResponse, stateBeforeCallQuery: QueryState<TKey, TResponse, TData, TError>) => void;
+    onError?: (error: TError, stateBeforeCallQuery: QueryState<TKey, TResponse, TData, TError>) => void;
+    onSettled?: (stateBeforeCallQuery: QueryState<TKey, TResponse, TData, TError>) => void;
+};
+export type UseQuery<TKey extends StoreKey = StoreKey, TResponse = any, TData = TResponse, TError = unknown> = UseStores<TKey, QueryState<TKey, TResponse, TData, TError>> & {
+    /**
+     * Set query's initial response.
+     *
+     * This is used for server-side rendered page or static page.
+     *
+     * IMPORTANT NOTE: Put this on the root component or parent component, before any component subscribed!
+     */
+    setInitialResponse: (options: {
+        key?: TKey;
+        response: TResponse;
+    }) => void;
+    /**
+     * Set query state (data, error, etc) to initial state.
+     */
+    reset: () => void;
+    /**
+     * Set query state (data, error, etc) to initial state.
+     */
+    resetSpecificKey: (key?: TKey | null) => void;
+    /**
+     * Invalidate query means marking a query as stale, and will refetch only if the query is active (has subscriber)
+     */
+    invalidate: () => void;
+    /**
+     * Invalidate query means marking a query as stale, and will refetch only if the query is active (has subscriber)
+     */
+    invalidateSpecificKey: (key?: TKey | null) => void;
+    /**
+     * Optimistic update.
+     *
+     * @returns function to revert the changes & function to invalidate the query
+     *
+     * IMPORTANT NOTE: This won't work well on infinite query.
+     */
+    optimisticUpdate: (options: {
+        key?: TKey | null;
+        response: TResponse | ((prevState: QueryState<TKey, TResponse, TData, TError>) => TResponse);
+    }) => {
+        revert: () => void;
+        invalidate: () => void;
+    };
+};
+export declare const createQuery: <TKey extends StoreKey = StoreKey, TResponse = any, TData = TResponse, TError = unknown>(queryFn: (key: TKey, state: QueryState<TKey, TResponse, TData, TError>) => Promise<TResponse>, options?: CreateQueryOptions<TKey, TResponse, TData, TError>) => UseQuery<TKey, TResponse, TData, TError>;

package/esm/preact/create-query.js

@@ -0,0 +1,333 @@
+import { useState } from 'preact/hooks';
+import { hashStoreKey, identityFn, noop } from '../utils';
+import { createStores } from './create-stores';
+const getDecision = (value, param, { ifTrue, ifAlways }) => {
+    if (value === true || (typeof value === 'function' && value(param) === true)) {
+        ifTrue();
+    }
+    else if (value === 'always' || (typeof value === 'function' && value(param) === 'always')) {
+        ifAlways();
+    }
+};
+const DEFAULT_STALE_TIME = 3000; // 3 seconds
+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: null,
+    response: null,
+    responseUpdatedAt: null,
+    error: null,
+    errorUpdatedAt: null,
+    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,
+];
+export const createQuery = (queryFn, options = {}) => {
+    const { onFirstSubscribe = noop, onSubscribe = noop, onLastUnsubscribe = noop, onBeforeChangeKey = noop, defaultDeps = useQueryDefaultDeps, select = identityFn, staleTime = DEFAULT_STALE_TIME, fetchOnMount = true, fetchOnWindowFocus = true, enabled = true, retry = 1, retryDelay = 3000, keepPreviousData, getNextPageParam = () => undefined, onSuccess = noop, onError = noop, onSettled = noop, hashKeyFn = hashStoreKey, ...createStoresOptions } = options;
+    const retryTimeoutId = new Map();
+    const retryNextPageTimeoutId = new Map();
+    const preventReplaceResponse = new Map(); // Prevent optimistic data to be replaced
+    const useQuery = createStores(({ key: _key, get, set }) => {
+        const key = _key;
+        const getRetryProps = (error, retryCount) => {
+            const maxRetryCount = (typeof retry === 'function' ? retry(error, key) : retry) || 0;
+            const shouldRetry = retryCount < maxRetryCount;
+            const delay = (typeof retryDelay === 'function' ? retryDelay(error, key) : retryDelay) || 0;
+            return { shouldRetry, delay };
+        };
+        const forceFetch = () => {
+            const responseAllPages = [];
+            const newPageParams = [undefined];
+            let pageParam = undefined;
+            const { isWaiting, isLoading, pageParams } = get();
+            if (isWaiting || enabled === false || (typeof enabled === 'function' && !enabled(key)))
+                return;
+            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(hashKeyFn(key)));
+                }
+                const stateBeforeCallQuery = { ...get(), pageParam };
+                preventReplaceResponse.set(hashKeyFn(key), false);
+                queryFn(key, stateBeforeCallQuery)
+                    .then((response) => {
+                    if (preventReplaceResponse.get(hashKeyFn(key))) {
+                        set({ isWaiting: false });
+                        return;
+                    }
+                    responseAllPages.push(response);
+                    const newPageParam = getNextPageParam(response, responseAllPages.length);
+                    newPageParams.push(newPageParam);
+                    if (newPageParam !== undefined && newPageParams.length < pageParams.length) {
+                        pageParam = newPageParam;
+                        callQuery();
+                        return;
+                    }
+                    set({
+                        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 });
+                        }, null),
+                        response,
+                        responseUpdatedAt: Date.now(),
+                        error: null,
+                        errorUpdatedAt: null,
+                        retryCount: 0,
+                        pageParam: newPageParam,
+                        pageParams: newPageParams,
+                        hasNextPage: newPageParam !== undefined,
+                    });
+                    onSuccess(response, stateBeforeCallQuery);
+                })
+                    .catch((error) => {
+                    const prevState = get();
+                    const errorUpdatedAt = Date.now();
+                    const { shouldRetry, delay } = getRetryProps(error, prevState.retryCount);
+                    set(prevState.isSuccess
+                        ? {
+                            isWaiting: false,
+                            isRefetching: false,
+                            isRefetchError: true,
+                            data: responseAllPages.length
+                                ? responseAllPages.reduce((prev, response) => {
+                                    return select(response, { key, data: prev });
+                                }, null)
+                                : prevState.data,
+                            error,
+                            errorUpdatedAt,
+                            isGoingToRetry: shouldRetry,
+                            pageParam,
+                            hasNextPage: pageParam !== undefined,
+                        }
+                        : {
+                            isWaiting: false,
+                            isError: true,
+                            error,
+                            errorUpdatedAt,
+                            isGoingToRetry: shouldRetry,
+                            pageParam,
+                            hasNextPage: pageParam !== undefined,
+                        });
+                    if (shouldRetry) {
+                        retryTimeoutId.set(hashKeyFn(key), window.setTimeout(() => {
+                            set({ retryCount: prevState.retryCount + 1 });
+                            callQuery();
+                        }, delay));
+                    }
+                    onError(error, stateBeforeCallQuery);
+                })
+                    .finally(() => {
+                    onSettled(stateBeforeCallQuery);
+                });
+            };
+            callQuery();
+        };
+        const fetch = () => {
+            const { responseUpdatedAt } = get();
+            const isStale = Date.now() > Number(responseUpdatedAt) + staleTime;
+            if (!isStale)
+                return;
+            forceFetch();
+        };
+        const fetchNextPage = () => {
+            const state = get();
+            const { isLoading, isWaitingNextPage, data, hasNextPage, pageParam, pageParams } = state;
+            if (isLoading)
+                return forceFetch();
+            if (isWaitingNextPage || !hasNextPage)
+                return;
+            set({ isWaitingNextPage: true, isGoingToRetryNextPage: false });
+            clearTimeout(retryNextPageTimeoutId.get(hashKeyFn(key)));
+            queryFn(key, { ...state, pageParam })
+                .then((response) => {
+                const newPageParam = getNextPageParam(response, pageParams.length);
+                set({
+                    isWaitingNextPage: false,
+                    response,
+                    responseUpdatedAt: Date.now(),
+                    data: select(response, { key, data }),
+                    pageParam: newPageParam,
+                    pageParams: pageParams.concat(newPageParam),
+                    hasNextPage: newPageParam !== undefined,
+                });
+            })
+                .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(hashKeyFn(key), window.setTimeout(() => {
+                        set({ retryNextPageCount: prevState.retryNextPageCount + 1 });
+                        fetchNextPage();
+                    }, delay));
+                }
+            });
+        };
+        return {
+            ...INITIAL_QUERY_STATE,
+            key,
+            fetch,
+            forceFetch,
+            fetchNextPage,
+            reset: () => set(INITIAL_QUERY_STATE),
+            optimisticUpdate: (response) => useQuery.optimisticUpdate({ key, response }),
+        };
+    }, (() => {
+        const fetchWindowFocusHandler = () => {
+            useQuery.getAllWithSubscriber().forEach((state) => {
+                getDecision(fetchOnWindowFocus, state.key, {
+                    ifTrue: state.fetch,
+                    ifAlways: state.forceFetch,
+                });
+            });
+        };
+        return {
+            ...createStoresOptions,
+            defaultDeps,
+            hashKeyFn,
+            onFirstSubscribe: (state) => {
+                if (typeof window !== 'undefined' && fetchOnWindowFocus) {
+                    window.addEventListener('focus', fetchWindowFocusHandler);
+                }
+                onFirstSubscribe(state);
+            },
+            onSubscribe: (state) => {
+                getDecision(fetchOnMount, state.key, {
+                    ifTrue: state.fetch,
+                    ifAlways: state.forceFetch,
+                });
+                onSubscribe(state);
+            },
+            onLastUnsubscribe: (state) => {
+                if (typeof window !== 'undefined' && fetchOnWindowFocus) {
+                    window.removeEventListener('focus', fetchWindowFocusHandler);
+                }
+                useQuery.set(state.key, { retryCount: 0, retryNextPageCount: 0 }, true);
+                clearTimeout(retryTimeoutId.get(hashKeyFn(state.key)));
+                clearTimeout(retryNextPageTimeoutId.get(hashKeyFn(state.key)));
+                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, {
+                                data: prevData.data,
+                                response: prevData.response,
+                                isLoading: false,
+                                isPreviousData: true,
+                            }, true);
+                        }
+                    }
+                }
+                onBeforeChangeKey(nextKey, prevKey);
+            },
+        };
+    })());
+    useQuery.setInitialResponse = ({ key, response }) => {
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        useState(() => {
+            if (response === undefined)
+                return;
+            const newPageParam = getNextPageParam(response, 1);
+            useQuery.set(key, {
+                status: 'success',
+                isLoading: false,
+                isSuccess: true,
+                isError: false,
+                response,
+                responseUpdatedAt: Date.now(),
+                data: select(response, { key: key, data: null }),
+                pageParam: newPageParam,
+                pageParams: [undefined, newPageParam],
+                hasNextPage: newPageParam !== undefined,
+            });
+        });
+    };
+    useQuery.reset = () => {
+        useQuery.getStores().forEach((store) => {
+            store.set(INITIAL_QUERY_STATE);
+        });
+    };
+    useQuery.resetSpecificKey = (key) => {
+        const store = useQuery.getStore(key);
+        store.set(INITIAL_QUERY_STATE);
+    };
+    useQuery.invalidate = () => {
+        useQuery.getStores().forEach((store) => {
+            const { set, getSubscribers } = store;
+            set({ responseUpdatedAt: null });
+            if (getSubscribers().size > 0)
+                store.get().forceFetch();
+        });
+    };
+    useQuery.invalidateSpecificKey = (key) => {
+        const { set, getSubscribers } = useQuery.getStore(key);
+        set({ responseUpdatedAt: null });
+        if (getSubscribers().size > 0)
+            useQuery.get(key).forceFetch();
+    };
+    useQuery.optimisticUpdate = ({ key, response }) => {
+        const prevState = useQuery.get(key);
+        const optimisticResponse = typeof response === 'function'
+            ? response(prevState)
+            : response;
+        useQuery.set(key, {
+            isOptimisticData: true,
+            response: optimisticResponse,
+            data: select(optimisticResponse, { key: key, data: null }),
+        });
+        preventReplaceResponse.set(hashKeyFn(key), true);
+        const revert = () => {
+            useQuery.set(key, {
+                isOptimisticData: false,
+                response: prevState.response,
+                data: prevState.data,
+            });
+        };
+        const invalidate = () => useQuery.invalidateSpecificKey(key);
+        return { revert, invalidate };
+    };
+    return useQuery;
+};

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

@@ -0,0 +1,28 @@
+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;
+};
+export declare const createStore: <T extends StoreData>(initializer: StoreInitializer<T>, options?: InitStoreOptions<T> & {
+    defaultDeps?: SelectDeps<T>;
+}) => UseStore<T>;