floppy-disk 2.16.0 → 3.0.0-alpha.2

package/esm/react/create-stores.js

@@ -1,125 +0,0 @@
-import { useEffect, useMemo, useRef, useState } from 'react';
-import { initStore, } from '../store';
-import { getValue, noop } from '../utils';
-const hasObjectPrototype = (value) => {
-    return Object.prototype.toString.call(value) === '[object Object]';
-};
-const isPlainObject = (value) => {
-    if (!hasObjectPrototype(value))
-        return false;
-    const ctor = value.constructor;
-    if (typeof ctor === 'undefined')
-        return true;
-    const prot = ctor.prototype;
-    if (!hasObjectPrototype(prot))
-        return false;
-    if (!prot.hasOwnProperty('isPrototypeOf'))
-        return false;
-    return true;
-};
-export const hashStoreKey = (value) => 
-// Copied from: https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts
-JSON.stringify(value, (_, val) => isPlainObject(val)
-    ? Object.keys(val)
-        .sort()
-        .reduce((result, key) => {
-        result[key] = val[key];
-        return result;
-    }, {})
-    : val);
-/**
- * @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) => 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' || typeof args[0] === 'string' ? [{}, 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 [, setState] = useState(get);
-        const prevKey = useRef(key);
-        const prevKeyHash = useRef(keyHash);
-        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);
-        const state = get();
-        return (typeof selectDeps === 'string' ? state[selectDeps] : 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 = 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
-        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;
-};

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

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

package/esm/react/with-context.js

@@ -1,14 +0,0 @@
-import { createContext, createElement, 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 createElement(Context.Provider, { value, children });
-    };
-    const useCurrentContext = () => useContext(Context);
-    return [Provider, useCurrentContext];
-};

package/esm/store.d.ts

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

package/esm/store.js

@@ -1,51 +0,0 @@
-import { getValue, noop } from './utils';
-export const initStore = (initializer, options = {}) => {
-    const { intercept, onFirstSubscribe = noop, onSubscribe = noop, onUnsubscribe = noop, onLastUnsubscribe = noop, } = options;
-    const subscribers = new Map();
-    const getSubscribers = () => subscribers;
-    let data;
-    const get = () => data;
-    const set = (value, silent = false) => {
-        const prevData = data;
-        data = { ...data, ...getValue(value, data) };
-        if (intercept) {
-            data = { ...data, ...intercept(data, prevData) };
-        }
-        if (silent)
-            return;
-        const keys = Object.keys(data);
-        subscribers.forEach((selectDeps, fn) => {
-            if (!selectDeps) {
-                for (let i = 0, n = keys.length; i < n; i++) {
-                    if (prevData[keys[i]] !== data[keys[i]]) {
-                        fn(data);
-                        break;
-                    }
-                }
-                return;
-            }
-            const prevs = selectDeps(prevData);
-            const nexts = selectDeps(data);
-            for (let i = 0, n = prevs.length; i < n; i++) {
-                if (prevs[i] !== nexts[i]) {
-                    fn(data);
-                    break;
-                }
-            }
-        });
-    };
-    const subscribe = (fn, selectDeps) => {
-        subscribers.set(fn, (typeof selectDeps === 'string' ? (s) => [s[selectDeps]] : selectDeps));
-        if (subscribers.size === 1)
-            onFirstSubscribe(data);
-        onSubscribe(data);
-        return () => {
-            subscribers.delete(fn);
-            onUnsubscribe(data);
-            if (subscribers.size === 0)
-                onLastUnsubscribe(data);
-        };
-    };
-    data = getValue(initializer, { get, set });
-    return { get, set, subscribe, getSubscribers };
-};

package/esm/utils.d.ts

@@ -1,24 +0,0 @@
-export type Maybe<T> = T | null | undefined;
-/**
- * Check if this runs on browser.
- */
-export declare const isClient: boolean;
-export declare const noop: () => void;
-export declare const identityFn: <T>(value: T) => T;
-/**
- * Check if a value is not undefined and not null.
- *
- * ```ts
- * const hasValue = (value: any) => value !== undefined && value !== null;
- * ```
- */
-export declare const hasValue: (value: any) => boolean;
-/**
- * If the value is a function, it will invoke the function.\
- * If the value is not a function, it will just return it.
- */
-export declare const getValue: <T, P extends any[]>(valueOrComputeValueFn: T | ((...params: P) => T), ...params: P) => T;
-/**
- * Create an Error instance with custom props.
- */
-export declare const createError: (message: string, props: Record<string, any>) => Error & Record<string, any>;

package/esm/utils.js

@@ -1,31 +0,0 @@
-/**
- * Check if this runs on browser.
- */
-export const isClient = typeof window !== 'undefined' && !('Deno' in window);
-export const noop = () => { };
-export const identityFn = (value) => value;
-/**
- * Check if a value is not undefined and not null.
- *
- * ```ts
- * const hasValue = (value: any) => value !== undefined && value !== null;
- * ```
- */
-export const hasValue = (value) => value !== undefined && value !== null;
-/**
- * If the value is a function, it will invoke the function.\
- * If the value is not a function, it will just return it.
- */
-export const getValue = (valueOrComputeValueFn, ...params) => {
-    if (typeof valueOrComputeValueFn === 'function') {
-        return valueOrComputeValueFn(...params);
-    }
-    return valueOrComputeValueFn;
-};
-/**
- * Create an Error instance with custom props.
- */
-export const createError = (message, props) => {
-    const error = Object.assign(new Error(message), props);
-    return error;
-};

package/lib/fetcher.d.ts

@@ -1,27 +0,0 @@
-type FetcherOptions<TResponse = any> = {
-    url: string;
-    query?: string;
-    params?: Record<string, string | number | boolean> | null;
-    payload?: any;
-    interceptRequest?: (requestOptions: RequestInit & {
-        url: string;
-    }) => (RequestInit & {
-        url: string;
-    }) | Promise<RequestInit & {
-        url: string;
-    }>;
-    interceptResponse?: (response: TResponse) => TResponse | Promise<TResponse>;
-} & RequestInit;
-/**
- * Experimental fetcher - abstraction layer for query/mutation function creator.
- *
- * Can be used for REST or GraphQL.
- *
- * Only work for JSON response only.
- *
- * @see https://floppy-disk.vercel.app/docs/experimental
- *
- * @returns A function to fetch data
- */
-export declare const fetcher: <TResponse = any, TInput extends any[] = any[]>(options: FetcherOptions<TResponse> | ((...args: TInput) => FetcherOptions<TResponse>)) => (...args: TInput) => Promise<TResponse>;
-export {};

package/lib/fetcher.js

@@ -1,99 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetcher = void 0;
-const utils_1 = require("./utils");
-const encodeParams = (params) => Object.entries(params)
-    .filter(([, value]) => value !== undefined && value !== null)
-    .map((kv) => kv.map(encodeURIComponent).join('='))
-    .join('&');
-/**
- * Experimental fetcher - abstraction layer for query/mutation function creator.
- *
- * Can be used for REST or GraphQL.
- *
- * Only work for JSON response only.
- *
- * @see https://floppy-disk.vercel.app/docs/experimental
- *
- * @returns A function to fetch data
- */
-const fetcher = (options) => async (...args) => {
-    const { url, query, params, payload, headers, interceptRequest = utils_1.identityFn, interceptResponse, ...rest } = (0, utils_1.getValue)(options, ...args);
-    let autoOptions = {};
-    let searchParams = params;
-    if (query) {
-        // GraphQL
-        autoOptions = {
-            method: 'POST',
-            body: JSON.stringify({ query, variables: payload || args[0] }),
-        };
-    }
-    else if (rest.method && rest.method.toLowerCase() !== 'get') {
-        // REST - Mutation
-        autoOptions = {
-            body: JSON.stringify(payload === undefined ? args[0] : payload),
-        };
-    }
-    else {
-        // REST - Query
-        if (typeof options === 'object' && params === undefined)
-            searchParams = args[0];
-    }
-    const interceptedOptions = await interceptRequest({
-        url: searchParams ? [url, encodeParams(searchParams)].join('?') : url,
-        headers: { 'Content-Type': 'application/json', ...headers },
-        ...autoOptions,
-        ...rest,
-    });
-    const { url: finalUrl, ...finalOptions } = interceptedOptions;
-    const res = await fetch(finalUrl, finalOptions);
-    const contentType = res.headers.get('content-type');
-    const isJsonFile = /\.json(\?.+)?$/.test(finalUrl);
-    if (contentType?.includes('application/json') || isJsonFile) {
-        let resJson = await res.json();
-        if (query) {
-            if (resJson.errors) {
-                throw (0, utils_1.createError)('Error GraphQL response', {
-                    status: res.status,
-                    statusText: res.statusText,
-                    response: resJson.errors,
-                    request: interceptedOptions,
-                });
-            }
-            resJson = resJson.data;
-        }
-        if (res.ok) {
-            if (interceptResponse) {
-                try {
-                    const finalResponse = await interceptResponse(resJson);
-                    return finalResponse;
-                }
-                catch (error) {
-                    throw (0, utils_1.createError)('Error intercept response', {
-                        status: res.status,
-                        statusText: res.statusText,
-                        response: resJson,
-                        error,
-                        request: interceptedOptions,
-                    });
-                }
-            }
-            return resJson;
-        }
-        throw (0, utils_1.createError)('Fetch error', {
-            status: res.status,
-            statusText: res.statusText,
-            response: resJson,
-            request: interceptedOptions,
-        });
-    }
-    const resText = await res.text().catch(() => undefined);
-    throw (0, utils_1.createError)('Response type is not a JSON', {
-        status: res.status,
-        statusText: res.statusText,
-        response: resText,
-        contentType,
-        request: interceptedOptions,
-    });
-};
-exports.fetcher = fetcher;

package/lib/index.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./store"), exports);
-tslib_1.__exportStar(require("./fetcher"), exports);
-tslib_1.__exportStar(require("./react/create-store"), exports);
-tslib_1.__exportStar(require("./react/create-stores"), exports);
-tslib_1.__exportStar(require("./react/create-query"), exports);
-tslib_1.__exportStar(require("./react/create-bi-direction-query"), exports);
-tslib_1.__exportStar(require("./react/create-mutation"), exports);
-tslib_1.__exportStar(require("./react/with-context"), exports);

package/lib/react/create-bi-direction-query.d.ts

@@ -1,166 +0,0 @@
-import { Maybe } from '../utils';
-import { CreateQueryOptions, QueryState } from './create-query';
-import { StoreKey } from './create-stores';
-export declare const createBiDirectionQuery: <TKey extends StoreKey = StoreKey, TResponse = any, TData extends any[] = any[], TError = unknown, TPageParam = any>(queryFn: (key: TKey, state: QueryState<TKey, TResponse, TData, TError, TPageParam>, direction: 'prev' | 'next') => Promise<TResponse>, options: Omit<CreateQueryOptions<TKey, TResponse, TData, TError, TPageParam>, "select" | "getNextPageParam"> & {
-    getPrevPageParam: (lastPage: TResponse, index: number, stateBeforeCallQuery: QueryState<TKey, TResponse, TData, TError, TPageParam>) => Maybe<TPageParam>;
-    getNextPageParam: (lastPage: TResponse, index: number, stateBeforeCallQuery: QueryState<TKey, TResponse, TData, TError, TPageParam>) => Maybe<TPageParam>;
-    select: (response: TResponse, state: Pick<QueryState<TKey, TResponse, TData, TError, TPageParam>, "data" | "key">, direction: 'prev' | 'next') => TData;
-}) => {
-    (key: Maybe<TKey>, selectDeps?: "data" | "key" | "error" | "reset" | "status" | "fetch" | "response" | "keyHash" | "forceFetch" | "fetchNextPage" | "optimisticUpdate" | "isWaiting" | "isWaitingNextPage" | "isRefetching" | "isRefetchError" | "isPreviousData" | "isOptimisticData" | "errorUpdatedAt" | "retryCount" | "isGoingToRetry" | "pageParam" | "pageParams" | "hasNextPage" | "retryNextPageCount" | "isGoingToRetryNextPage" | "isLoading" | "isSuccess" | "isError" | "responseUpdatedAt" | import("..").SelectDeps<QueryState<TKey, TResponse, TData, TError, TPageParam>>): {
-        data: (never[] | TData)[number][];
-        fetchPrevPage: () => Promise<QueryState<TKey, TResponse, TData, TError, TPageParam>>;
-        hasPrevPage: boolean;
-        isWaitingPrevPage: boolean;
-        key: TKey;
-        keyHash: string;
-        fetch: () => void;
-        forceFetch: () => Promise<QueryState<TKey, TResponse, TData, TError, TPageParam>>;
-        fetchNextPage: () => Promise<QueryState<TKey, TResponse, TData, TError, TPageParam>>;
-        reset: () => void;
-        optimisticUpdate: (response: TResponse | ((prevState: QueryState<TKey, TResponse, TData, TError, TPageParam>) => TResponse)) => {
-            revert: () => void;
-            invalidate: () => void;
-        };
-        isWaiting: boolean;
-        isWaitingNextPage: boolean;
-        isRefetching: boolean;
-        isRefetchError: boolean;
-        isPreviousData: boolean;
-        isOptimisticData: boolean;
-        error: TError | undefined;
-        errorUpdatedAt: number | undefined;
-        retryCount: number;
-        isGoingToRetry: boolean;
-        pageParam: Maybe<TPageParam>;
-        pageParams: Maybe<TPageParam>[];
-        hasNextPage: boolean;
-        retryNextPageCount: number;
-        isGoingToRetryNextPage: boolean;
-        status: "loading";
-        isLoading: true;
-        isSuccess: false;
-        isError: false;
-        response: undefined;
-        responseUpdatedAt: undefined;
-    } | {
-        data: (never[] | TData)[number][];
-        fetchPrevPage: () => Promise<QueryState<TKey, TResponse, TData, TError, TPageParam>>;
-        hasPrevPage: boolean;
-        isWaitingPrevPage: boolean;
-        key: TKey;
-        keyHash: string;
-        fetch: () => void;
-        forceFetch: () => Promise<QueryState<TKey, TResponse, TData, TError, TPageParam>>;
-        fetchNextPage: () => Promise<QueryState<TKey, TResponse, TData, TError, TPageParam>>;
-        reset: () => void;
-        optimisticUpdate: (response: TResponse | ((prevState: QueryState<TKey, TResponse, TData, TError, TPageParam>) => TResponse)) => {
-            revert: () => void;
-            invalidate: () => void;
-        };
-        isWaiting: boolean;
-        isWaitingNextPage: boolean;
-        isRefetching: boolean;
-        isRefetchError: boolean;
-        isPreviousData: boolean;
-        isOptimisticData: boolean;
-        error: TError | undefined;
-        errorUpdatedAt: number | undefined;
-        retryCount: number;
-        isGoingToRetry: boolean;
-        pageParam: Maybe<TPageParam>;
-        pageParams: Maybe<TPageParam>[];
-        hasNextPage: boolean;
-        retryNextPageCount: number;
-        isGoingToRetryNextPage: boolean;
-        status: "error";
-        isLoading: false;
-        isSuccess: false;
-        isError: true;
-        response: undefined;
-        responseUpdatedAt: undefined;
-    } | {
-        data: (never[] | TData)[number][];
-        fetchPrevPage: () => Promise<QueryState<TKey, TResponse, TData, TError, TPageParam>>;
-        hasPrevPage: boolean;
-        isWaitingPrevPage: boolean;
-        key: TKey;
-        keyHash: string;
-        fetch: () => void;
-        forceFetch: () => Promise<QueryState<TKey, TResponse, TData, TError, TPageParam>>;
-        fetchNextPage: () => Promise<QueryState<TKey, TResponse, TData, TError, TPageParam>>;
-        reset: () => void;
-        optimisticUpdate: (response: TResponse | ((prevState: QueryState<TKey, TResponse, TData, TError, TPageParam>) => TResponse)) => {
-            revert: () => void;
-            invalidate: () => void;
-        };
-        isWaiting: boolean;
-        isWaitingNextPage: boolean;
-        isRefetching: boolean;
-        isRefetchError: boolean;
-        isPreviousData: boolean;
-        isOptimisticData: boolean;
-        error: TError | undefined;
-        errorUpdatedAt: number | undefined;
-        retryCount: number;
-        isGoingToRetry: boolean;
-        pageParam: Maybe<TPageParam>;
-        pageParams: Maybe<TPageParam>[];
-        hasNextPage: boolean;
-        retryNextPageCount: number;
-        isGoingToRetryNextPage: boolean;
-        status: "success";
-        isLoading: false;
-        isSuccess: true;
-        isError: false;
-        response: TResponse;
-        responseUpdatedAt: number | undefined;
-    };
-    get(): {
-        prev: QueryState<TKey, TResponse, TData, TError, TPageParam>;
-        next: QueryState<TKey, TResponse, TData, TError, TPageParam>;
-    };
-    setInitialResponse: (options: {
-        key?: Maybe<TKey>;
-        response: TResponse;
-        skipRevalidation?: boolean | undefined;
-    }) => void;
-    reset(): void;
-    resetSpecificKey(key: Maybe<TKey>): void;
-    invalidate: () => void;
-    invalidateSpecificKey: (key?: Maybe<TKey>) => void;
-    suspend: (key?: Maybe<TKey>) => {
-        key: TKey;
-        keyHash: string;
-        fetch: () => void;
-        forceFetch: () => Promise<QueryState<TKey, TResponse, TData, TError, TPageParam>>;
-        fetchNextPage: () => Promise<QueryState<TKey, TResponse, TData, TError, TPageParam>>;
-        reset: () => void;
-        optimisticUpdate: (response: TResponse | ((prevState: QueryState<TKey, TResponse, TData, TError, TPageParam>) => TResponse)) => {
-            revert: () => void;
-            invalidate: () => void;
-        };
-        isWaiting: boolean;
-        isWaitingNextPage: boolean;
-        isRefetching: boolean;
-        isRefetchError: boolean;
-        isPreviousData: boolean;
-        isOptimisticData: boolean;
-        error: TError | undefined;
-        errorUpdatedAt: number | undefined;
-        retryCount: number;
-        isGoingToRetry: boolean;
-        pageParam: Maybe<TPageParam>;
-        pageParams: Maybe<TPageParam>[];
-        hasNextPage: boolean;
-        retryNextPageCount: number;
-        isGoingToRetryNextPage: boolean;
-    } & {
-        status: "success";
-        isLoading: false;
-        isSuccess: true;
-        isError: false;
-        data: TData;
-        response: TResponse;
-        responseUpdatedAt: number | undefined;
-    };
-};

package/lib/react/create-bi-direction-query.js

@@ -1,78 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createBiDirectionQuery = void 0;
-const utils_1 = require("../utils");
-const create_query_1 = require("./create-query");
-const createBiDirectionQuery = (queryFn, options) => {
-    const { getPrevPageParam, getNextPageParam, select, ...restOptions } = options;
-    const usePrevPagesQuery = (0, create_query_1.createQuery)((key, state) => queryFn(key, state, 'prev'), {
-        defaultDeps: (state) => [
-            state.isWaiting,
-            state.data,
-            state.error,
-            state.isWaitingNextPage,
-            state.hasNextPage,
-        ],
-        fetchOnMount: false,
-        getNextPageParam: getPrevPageParam,
-        select: (response, state) => select(response, state, 'prev'),
-        ...restOptions,
-    });
-    const useNextPagesQuery = (0, create_query_1.createQuery)(async (key, state) => {
-        const isInitialPage = state.pageParam === undefined;
-        const pQuery = usePrevPagesQuery.get(key);
-        try {
-            const response = await queryFn(key, state, 'next');
-            if (isInitialPage) {
-                const prevPageParam = getPrevPageParam(response, 1, pQuery);
-                usePrevPagesQuery.set(key, (prev) => ({
-                    pageParams: [prevPageParam, ...prev.pageParams.slice(1)],
-                    hasNextPage: prev.isLoading ? (0, utils_1.hasValue)(prevPageParam) : prev.hasNextPage,
-                }));
-                if (!pQuery.isLoading)
-                    pQuery.forceFetch();
-            }
-            return response;
-        }
-        catch (error) {
-            if (isInitialPage && !pQuery.isLoading)
-                pQuery.reset();
-            throw error;
-        }
-    }, {
-        getNextPageParam: getNextPageParam,
-        select: (response, state) => select(response, state, 'next'),
-        ...restOptions,
-    });
-    const useBiDirectionQuery = (...args) => {
-        const pQuery = usePrevPagesQuery(...args);
-        const nQuery = useNextPagesQuery(...args);
-        return {
-            ...nQuery,
-            data: [...(pQuery.data || []), ...(nQuery.data || [])],
-            fetchPrevPage: pQuery.fetchNextPage,
-            hasPrevPage: pQuery.hasNextPage,
-            isWaitingPrevPage: pQuery.isWaitingNextPage || (pQuery.isLoading && pQuery.isWaiting),
-        };
-    };
-    useBiDirectionQuery.get = () => {
-        return {
-            prev: usePrevPagesQuery.get(),
-            next: useNextPagesQuery.get(),
-        };
-    };
-    useBiDirectionQuery.setInitialResponse = useNextPagesQuery.setInitialResponse;
-    useBiDirectionQuery.reset = () => {
-        usePrevPagesQuery.reset();
-        useNextPagesQuery.reset();
-    };
-    useBiDirectionQuery.resetSpecificKey = (key) => {
-        usePrevPagesQuery.resetSpecificKey(key);
-        useNextPagesQuery.resetSpecificKey(key);
-    };
-    useBiDirectionQuery.invalidate = useNextPagesQuery.invalidate;
-    useBiDirectionQuery.invalidateSpecificKey = useNextPagesQuery.invalidateSpecificKey;
-    useBiDirectionQuery.suspend = useNextPagesQuery.suspend;
-    return useBiDirectionQuery;
-};
-exports.createBiDirectionQuery = createBiDirectionQuery;