floppy-disk 2.5.0 → 2.6.0-beta.2

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

@@ -0,0 +1,167 @@
+import { Maybe } from '../utils';
+import { SelectDeps } from '../vanilla';
+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;
+}) => {
+    (...args: [Maybe<TKey>, SelectDeps<QueryState<TKey, TResponse, TData, TError, TPageParam>>?] | [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/preact/create-bi-direction-query.js

@@ -0,0 +1,78 @@
+"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;

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

@@ -191,7 +191,7 @@ export type CreateQueryOptions<TKey extends StoreKey = StoreKey, TResponse = any
      *
      * This function should return a variable that will be stored as `pageParam` that can be used when fetching next page.
      */
-    getNextPageParam?: (lastPage: TResponse, index: number) => Maybe<TPageParam>;
+    getNextPageParam?: (lastPage: TResponse, index: number, stateBeforeCallQuery: QueryState<TKey, TResponse, TData, TError, TPageParam>) => Maybe<TPageParam>;
     onBeforeFetch?: (cancel: () => void, state: QueryState<TKey, TResponse, TData, TError, TPageParam>) => void;
     onSuccess?: (response: TResponse, stateBeforeCallQuery: QueryState<TKey, TResponse, TData, TError, TPageParam>) => void;
     onError?: (error: TError, stateBeforeCallQuery: QueryState<TKey, TResponse, TData, TError, TPageParam>) => void;

package/lib/preact/create-query.js

@@ -58,11 +58,11 @@ const createQuery = (queryFn, options = {}) => {
         };
         const forceFetch = () => new Promise((resolve) => {
             const state = get();
+            const { isWaiting, isLoading, pageParams } = state;
             const responseAllPages = [];
-            const newPageParams = [state.pageParams[0]];
-            let pageParam = state.pageParams[0];
+            const newPageParams = [pageParams[0]];
+            let pageParam = pageParams[0];
             clearTimeout(refetchIntervalTimeoutId.get(keyHash));
-            const { isWaiting, isLoading, pageParams } = state;
             if (isWaiting || !(0, utils_1.getValueOrComputedValue)(enabled, key))
                 return resolve(state);
             let shouldcancel = false;
@@ -84,8 +84,8 @@ const createQuery = (queryFn, options = {}) => {
                         set({ isGoingToRetry: false, isWaiting: true, isRefetching: true });
                     clearTimeout(retryTimeoutId.get(keyHash));
                 }
-                const stateBeforeCallQuery = { ...get(), pageParam };
                 preventReplaceResponse.set(keyHash, false);
+                const stateBeforeCallQuery = { ...get(), pageParam };
                 queryFn(key, stateBeforeCallQuery)
                     .then((response) => {
                     if (preventReplaceResponse.get(keyHash)) {
@@ -93,7 +93,7 @@ const createQuery = (queryFn, options = {}) => {
                         return resolve(get());
                     }
                     responseAllPages.push(response);
-                    const newPageParam = getNextPageParam(response, responseAllPages.length);
+                    const newPageParam = getNextPageParam(response, responseAllPages.length, stateBeforeCallQuery);
                     newPageParams.push(newPageParam);
                     if ((0, utils_1.hasValue)(newPageParam) && newPageParams.length < pageParams.length) {
                         pageParam = newPageParam;
@@ -209,7 +209,7 @@ const createQuery = (queryFn, options = {}) => {
             const stateBeforeCallQuery = get();
             queryFn(key, { ...state, pageParam })
                 .then((response) => {
-                const newPageParam = getNextPageParam(response, pageParams.length);
+                const newPageParam = getNextPageParam(response, pageParams.length, stateBeforeCallQuery);
                 set({
                     isWaitingNextPage: false,
                     response,
@@ -330,9 +330,10 @@ const createQuery = (queryFn, options = {}) => {
     useQuery.setInitialResponse = ({ key, response, skipRevalidation }) => {
         // eslint-disable-next-line react-hooks/rules-of-hooks
         (0, hooks_1.useState)(() => {
-            if (response === undefined || useQuery.get(key).data)
+            const state = useQuery.get(key);
+            if (response === undefined || state.isSuccess)
                 return;
-            const newPageParam = getNextPageParam(response, 1);
+            const newPageParam = getNextPageParam(response, 1, state);
             useQuery.set(key, {
                 status: 'success',
                 isLoading: false,

package/lib/preact/index.d.ts

@@ -1,5 +1,6 @@
 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/lib/preact/index.js

@@ -4,5 +4,6 @@ const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./create-store"), exports);
 tslib_1.__exportStar(require("./create-stores"), exports);
 tslib_1.__exportStar(require("./create-query"), exports);
+tslib_1.__exportStar(require("./create-bi-direction-query"), exports);
 tslib_1.__exportStar(require("./create-mutation"), exports);
 tslib_1.__exportStar(require("./with-context"), exports);

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

@@ -0,0 +1,167 @@
+import { Maybe } from '../utils';
+import { SelectDeps } from '../vanilla';
+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;
+}) => {
+    (...args: [Maybe<TKey>, SelectDeps<QueryState<TKey, TResponse, TData, TError, TPageParam>>?] | [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

@@ -0,0 +1,78 @@
+"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;

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

@@ -190,7 +190,7 @@ export type CreateQueryOptions<TKey extends StoreKey = StoreKey, TResponse = any
      *
      * This function should return a variable that will be stored as `pageParam` that can be used when fetching next page.
      */
-    getNextPageParam?: (lastPage: TResponse, index: number) => Maybe<TPageParam>;
+    getNextPageParam?: (lastPage: TResponse, index: number, stateBeforeCallQuery: QueryState<TKey, TResponse, TData, TError, TPageParam>) => Maybe<TPageParam>;
     onBeforeFetch?: (cancel: () => void, state: QueryState<TKey, TResponse, TData, TError, TPageParam>) => void;
     onSuccess?: (response: TResponse, stateBeforeCallQuery: QueryState<TKey, TResponse, TData, TError, TPageParam>) => void;
     onError?: (error: TError, stateBeforeCallQuery: QueryState<TKey, TResponse, TData, TError, TPageParam>) => void;

package/lib/react/create-query.js

@@ -57,11 +57,11 @@ const createQuery = (queryFn, options = {}) => {
         };
         const forceFetch = () => new Promise((resolve) => {
             const state = get();
+            const { isWaiting, isLoading, pageParams } = state;
             const responseAllPages = [];
-            const newPageParams = [state.pageParams[0]];
-            let pageParam = state.pageParams[0];
+            const newPageParams = [pageParams[0]];
+            let pageParam = pageParams[0];
             clearTimeout(refetchIntervalTimeoutId.get(keyHash));
-            const { isWaiting, isLoading, pageParams } = state;
             if (isWaiting || !(0, utils_1.getValueOrComputedValue)(enabled, key))
                 return resolve(state);
             let shouldcancel = false;
@@ -83,8 +83,8 @@ const createQuery = (queryFn, options = {}) => {
                         set({ isGoingToRetry: false, isWaiting: true, isRefetching: true });
                     clearTimeout(retryTimeoutId.get(keyHash));
                 }
-                const stateBeforeCallQuery = { ...get(), pageParam };
                 preventReplaceResponse.set(keyHash, false);
+                const stateBeforeCallQuery = { ...get(), pageParam };
                 queryFn(key, stateBeforeCallQuery)
                     .then((response) => {
                     if (preventReplaceResponse.get(keyHash)) {
@@ -92,7 +92,7 @@ const createQuery = (queryFn, options = {}) => {
                         return resolve(get());
                     }
                     responseAllPages.push(response);
-                    const newPageParam = getNextPageParam(response, responseAllPages.length);
+                    const newPageParam = getNextPageParam(response, responseAllPages.length, stateBeforeCallQuery);
                     newPageParams.push(newPageParam);
                     if ((0, utils_1.hasValue)(newPageParam) && newPageParams.length < pageParams.length) {
                         pageParam = newPageParam;
@@ -208,7 +208,7 @@ const createQuery = (queryFn, options = {}) => {
             const stateBeforeCallQuery = get();
             queryFn(key, { ...state, pageParam })
                 .then((response) => {
-                const newPageParam = getNextPageParam(response, pageParams.length);
+                const newPageParam = getNextPageParam(response, pageParams.length, stateBeforeCallQuery);
                 set({
                     isWaitingNextPage: false,
                     response,
@@ -329,9 +329,10 @@ const createQuery = (queryFn, options = {}) => {
     useQuery.setInitialResponse = ({ key, response, skipRevalidation }) => {
         // eslint-disable-next-line react-hooks/rules-of-hooks
         (0, react_1.useState)(() => {
-            if (response === undefined || useQuery.get(key).data)
+            const state = useQuery.get(key);
+            if (response === undefined || state.isSuccess)
                 return;
-            const newPageParam = getNextPageParam(response, 1);
+            const newPageParam = getNextPageParam(response, 1, state);
             useQuery.set(key, {
                 status: 'success',
                 isLoading: false,

package/lib/react/index.d.ts

@@ -1,5 +1,6 @@
 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/lib/react/index.js

@@ -4,5 +4,6 @@ const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./create-store"), exports);
 tslib_1.__exportStar(require("./create-stores"), exports);
 tslib_1.__exportStar(require("./create-query"), exports);
+tslib_1.__exportStar(require("./create-bi-direction-query"), exports);
 tslib_1.__exportStar(require("./create-mutation"), exports);
 tslib_1.__exportStar(require("./with-context"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "floppy-disk",
-  "version": "2.5.0",
+  "version": "2.6.0-beta.2",
   "description": "FloppyDisk - lightweight, simple, and powerful state management library",
   "keywords": [
     "state",