floppy-disk 1.0.0

package/esm/react/create-mutation.js

@@ -0,0 +1,48 @@
+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 state = get();
+            onMutate(variables, state);
+            return new Promise((resolve, reject) => {
+                mutationFn(variables, state)
+                    .then((response) => {
+                    set({
+                        isWaiting: false,
+                        isSuccess: true,
+                        response,
+                        responseUpdatedAt: Date.now(),
+                        error: null,
+                        errorUpdatedAt: null,
+                    });
+                    onSuccess(response, variables, state);
+                    resolve(response);
+                })
+                    .catch((error) => {
+                    set({
+                        isWaiting: true,
+                        isError: true,
+                        error,
+                        errorUpdatedAt: Date.now(),
+                    });
+                    onError(error, variables, state);
+                    reject(error);
+                })
+                    .finally(() => {
+                    onSettled(variables, state);
+                });
+            });
+        },
+    }), createStoreOptions);
+    return useMutation;
+};

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

@@ -0,0 +1,150 @@
+import { CreateStoresOptions, StoreKey } from './create-stores';
+export declare type QueryStatus = 'loading' | 'success' | 'error';
+export declare 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;
+    markAsStale: () => void;
+    reset: () => void;
+    helpers: {
+        /**
+         * Fetch all active queries.
+         *
+         * Same as `fetch` method, this will only be called if the data is stale or empty.
+         */
+        fetchAllActiveQueries: () => void;
+        /**
+         * Fetch all active queries.
+         *
+         * Same as `fetch` method, this will only be called if the data is stale or empty.
+         */
+        forceFetchAllActiveQueries: () => void;
+        /**
+         * Delete query data for all query keys.
+         */
+        resetAllQueries: () => 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;
+    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;
+};
+export declare 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;
+    /**
+     * Number of maximum retries.
+     *
+     * Defaults to `1`.
+     */
+    retry?: 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);
+    /**
+     * 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, inputState: QueryState<TKey, TResponse, TData, TError>) => void;
+    onError?: (error: TError, inputState: QueryState<TKey, TResponse, TData, TError>) => void;
+    onSettled?: (inputState: QueryState<TKey, TResponse, TData, TError>) => 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>) => import("./create-stores").UseStores<TKey, QueryState<TKey, TResponse, TData, TError>>;

package/esm/react/create-query.js

@@ -0,0 +1,251 @@
+import { 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,
+    data: null,
+    response: null,
+    responseUpdatedAt: null,
+    error: null,
+    errorUpdatedAt: null,
+    retryCount: 0,
+    isGoingToRetry: false,
+    pageParam: undefined,
+    pageParams: [undefined],
+    hasNextPage: 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, retry = 1, fetchOnMount = true, fetchOnWindowFocus = true, enabled = true, keepPreviousData, getNextPageParam = () => undefined, onSuccess = noop, onError = noop, onSettled = noop, ...createStoresOptions } = options;
+    const useQuery = createStores(({ key: _key, get, set }) => {
+        const key = _key;
+        const forceFetch = () => {
+            const responseAllPages = [];
+            const newPageParams = [undefined];
+            let pageParam = undefined;
+            const { isWaiting, isLoading, isGoingToRetry, 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 (isGoingToRetry) {
+                    if (isLoading)
+                        set({ isGoingToRetry: false, isWaiting: true });
+                    else
+                        set({ isGoingToRetry: false, isWaiting: true, isRefetching: true });
+                }
+                const inputState = { ...get(), pageParam };
+                queryFn(key, inputState)
+                    .then((response) => {
+                    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,
+                        data: responseAllPages.reduce((prev, response) => {
+                            return select(response, { key, data: prev });
+                        }, null),
+                        response,
+                        responseUpdatedAt: Date.now(),
+                        error: null,
+                        errorUpdatedAt: null,
+                        retryCount: 0,
+                        pageParam: newPageParam,
+                        pageParams: newPageParams,
+                        hasNextPage: newPageParam !== undefined,
+                    });
+                    onSuccess(response, inputState);
+                })
+                    .catch((error) => {
+                    const prevState = get();
+                    const errorUpdatedAt = Date.now();
+                    set(prevState.isSuccess
+                        ? {
+                            isWaiting: false,
+                            isRefetching: false,
+                            isRefetchError: true,
+                            data: responseAllPages.reduce((prev, response) => {
+                                return select(response, { key, data: prev });
+                            }, null),
+                            error,
+                            errorUpdatedAt,
+                            pageParam,
+                            hasNextPage: pageParam !== undefined,
+                        }
+                        : {
+                            isWaiting: false,
+                            isError: true,
+                            error,
+                            errorUpdatedAt,
+                            pageParam,
+                            hasNextPage: pageParam !== undefined,
+                        });
+                    if (prevState.retryCount < retry) {
+                        set({ retryCount: prevState.retryCount + 1, isGoingToRetry: true });
+                        callQuery();
+                    }
+                    onError(error, inputState);
+                })
+                    .finally(() => {
+                    onSettled(inputState);
+                });
+            };
+            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;
+            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) => {
+                set({
+                    isWaitingNextPage: false,
+                    isError: true,
+                    error,
+                    errorUpdatedAt: Date.now(),
+                });
+            });
+        };
+        const fetchAllActiveQueries = () => {
+            useQuery.getAllWithSubscriber().forEach((state) => {
+                state.fetch();
+            });
+        };
+        const forceFetchAllActiveQueries = () => {
+            useQuery.getAllWithSubscriber().forEach((state) => {
+                state.forceFetch();
+            });
+        };
+        const resetAllQueries = () => {
+            useQuery.getAll().forEach((state) => {
+                state.reset();
+            });
+        };
+        return {
+            ...INITIAL_QUERY_STATE,
+            key,
+            fetch,
+            forceFetch,
+            fetchNextPage,
+            markAsStale: () => set({ responseUpdatedAt: null }),
+            reset: () => set(INITIAL_QUERY_STATE),
+            helpers: {
+                fetchAllActiveQueries,
+                forceFetchAllActiveQueries,
+                resetAllQueries,
+            },
+        };
+    }, (() => {
+        const resetRetryCount = (key) => {
+            useQuery.set(key, { retryCount: 0 }, true);
+        };
+        const fetchWindowFocusHandler = () => {
+            useQuery.getAllWithSubscriber().forEach((state) => {
+                getDecision(fetchOnWindowFocus, state.key, {
+                    ifTrue: state.fetch,
+                    ifAlways: state.forceFetch,
+                });
+            });
+        };
+        return {
+            ...createStoresOptions,
+            defaultDeps,
+            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.addEventListener('focus', fetchWindowFocusHandler);
+                }
+                resetRetryCount(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);
+            },
+        };
+    })());
+    return useQuery;
+};

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

@@ -0,0 +1,22 @@
+import { InitStoreOptions, SelectDeps, SetStoreData, StoreData, StoreInitializer, Subscribers } from '../vanilla';
+export declare type WatchProps<T> = {
+    selectDeps?: SelectDeps<T>;
+    render: (state: T) => any;
+};
+export declare 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>;
+    Watch: (props: WatchProps<T>) => any;
+};
+export declare const createStore: <T extends StoreData>(initializer: StoreInitializer<T>, options?: InitStoreOptions<T> & {
+    defaultDeps?: SelectDeps<T>;
+}) => UseStore<T>;

package/esm/react/create-store.js

@@ -0,0 +1,25 @@
+import { useEffect, useState } from 'react';
+import { initStore, } from '../vanilla';
+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;
+    const Watch = ({ selectDeps, render }) => {
+        const store = useStore(selectDeps);
+        return render(store);
+    };
+    useStore.Watch = Watch;
+    return useStore;
+};

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

@@ -0,0 +1,34 @@
+import { InitStoreOptions, SelectDeps, SetStoreData, StoreData, Subscribers } from '../vanilla';
+import { WatchProps } from './create-store';
+export declare type StoreKey = Record<string, any> | undefined;
+export declare type StoresInitializer<TKey extends StoreKey = StoreKey, T extends StoreData = StoreData> = (api: {
+    key: TKey;
+    get: () => T;
+    set: (value: SetStoreData<T>, silent?: boolean) => void;
+}) => T;
+export declare 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: [TKey?, SelectDeps<T>?] | [SelectDeps<T>?]): T;
+    get: (key?: TKey) => T;
+    getAll: () => T[];
+    getAllWithSubscriber: () => T[];
+    set: (key: TKey, value: SetStoreData<T>, silent?: boolean) => void;
+    setAll: (value: SetStoreData<T>, silent?: boolean) => void;
+    subscribe: (key: TKey, fn: (state: T) => void, selectDeps?: SelectDeps<T>) => () => void;
+    getSubscribers: (key: TKey) => Subscribers<T>;
+    Watch: (props: WatchProps<T> & {
+        storeKey?: TKey;
+    }) => any;
+};
+export declare type CreateStoresOptions<TKey extends StoreKey = StoreKey, T extends StoreData = StoreData> = InitStoreOptions<T> & {
+    onBeforeChangeKey?: (nextKey: TKey, prevKey: TKey) => void;
+    defaultDeps?: SelectDeps<T>;
+};
+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/react/create-stores.js

@@ -0,0 +1,83 @@
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { noop } from '../utils';
+import { initStore, } from '../vanilla';
+const hashStoreKey = (obj) => JSON.stringify(obj, Object.keys(obj).sort());
+export const createStores = (initializer, options = {}) => {
+    const { onBeforeChangeKey = noop, defaultDeps } = options;
+    const stores = new Map();
+    const getStore = (key) => {
+        const normalizedKey = hashStoreKey(key);
+        if (!stores.has(normalizedKey)) {
+            stores.set(normalizedKey, initStore((api) => initializer({ key, ...api }), options));
+        }
+        return stores.get(normalizedKey);
+    };
+    /**
+     * 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 normalizedKey = hashStoreKey(key);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+        const { get, subscribe } = useMemo(() => getStore(key), [normalizedKey]);
+        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
+        }, [normalizedKey]);
+        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();
+    };
+    const Watch = ({ storeKey = {}, selectDeps, render }) => {
+        const store = useStores(storeKey, selectDeps);
+        return render(store);
+    };
+    useStores.Watch = Watch;
+    return useStores;
+};

package/esm/react/with-context.d.ts

@@ -0,0 +1,5 @@
+import { ReactNode } from 'react';
+export declare const withContext: <T>(initFn: () => T) => readonly [({ children, onInitialize, }: {
+    children: ReactNode;
+    onInitialize?: ((value: T) => void) | undefined;
+}) => JSX.Element, () => T | null];

package/esm/react/with-context.js

@@ -0,0 +1,14 @@
+import React, { createContext, useContext, useState } from 'react';
+export const withContext = (initFn) => {
+    const Context = createContext(null);
+    const Provider = ({ children, onInitialize, }) => {
+        const [value] = useState(() => {
+            const store = initFn();
+            onInitialize && onInitialize(store);
+            return store;
+        });
+        return React.createElement(Context.Provider, { value: value }, children);
+    };
+    const useCurrentContext = () => useContext(Context);
+    return [Provider, useCurrentContext];
+};

package/esm/utils/index.d.ts

@@ -0,0 +1,2 @@
+export declare const noop: () => void;
+export declare const identityFn: <T>(a: T) => T;

package/esm/utils/index.js

@@ -0,0 +1,2 @@
+export const noop = () => { };
+export const identityFn = (a) => a;

package/esm/vanilla.d.ts

@@ -0,0 +1,23 @@
+export declare type StoreData = Record<string, any>;
+export declare type SetStoreData<T> = Partial<T> | ((prevState: T) => Partial<T>);
+export declare type SelectDeps<T> = ((state: T) => any[]) | undefined;
+export declare type Subscribers<T> = Map<(state: T) => void, SelectDeps<T>>;
+export declare type StoreInitializer<T> = (api: {
+    get: () => T;
+    set: (value: SetStoreData<T>, silent?: boolean) => void;
+}) => T;
+export declare type StoreEvent<T> = (state: T) => void;
+export declare type InitStoreOptions<T> = {
+    intercept?: (nextState: T, prevState: T) => Partial<T>;
+    onFirstSubscribe?: StoreEvent<T>;
+    onSubscribe?: StoreEvent<T>;
+    onUnsubscribe?: StoreEvent<T>;
+    onLastUnsubscribe?: StoreEvent<T>;
+};
+export declare type InitStoreReturn<T> = {
+    get: () => T;
+    set: (value: SetStoreData<T>, silent?: boolean) => void;
+    subscribe: (fn: (state: T) => void, selectDeps?: SelectDeps<T>) => () => void;
+    getSubscribers: () => Subscribers<T>;
+};
+export declare const initStore: <T extends StoreData>(initializer: StoreInitializer<T>, options?: InitStoreOptions<T>) => InitStoreReturn<T>;