floppy-disk 2.4.0-beta.1 → 2.4.0-beta.2

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

@@ -178,6 +178,7 @@ export type CreateQueryOptions<TKey extends StoreKey = StoreKey, TResponse = any
      * This function should return a variable that will be used when fetching next page (`pageParam`).
      */
     getNextPageParam?: (lastPage: TResponse, index: number) => any;
+    onBeforeFetch?: (cancel: () => void, state: QueryState<TKey, TResponse, TData, TError>) => void;
     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;
@@ -192,6 +193,14 @@ export type CreateQueryOptions<TKey extends StoreKey = StoreKey, TResponse = any
      * Defaults to `5 * 60 * 1000` (5 minutes).
      */
     cacheTime?: number;
+    /**
+     * Polling interval in milliseconds.
+     *
+     * Disabled by default.
+     *
+     * If the query is on error state, the polling interval will be disabled, and it will use `retry` instead.
+     */
+    refetchInterval?: number | false | (() => number | false);
 };
 export type UseQuery<TKey extends StoreKey = StoreKey, TResponse = any, TData = TResponse, TError = unknown> = UseStores<TKey, QueryState<TKey, TResponse, TData, TError>> & {
     /**

package/esm/preact/create-query.js

@@ -1,15 +1,7 @@
 import { h as createElement } from 'preact';
 import { useState } from 'preact/hooks';
-import { hasValue, identityFn, noop } from '../utils';
+import { getValueOrComputedValue, hasValue, 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 INITIAL_QUERY_STATE = {
     isWaiting: false,
     isWaitingNextPage: false,
@@ -44,27 +36,36 @@ export const createQuery = (queryFn, options = {}) => {
     const defaultFetchOnWindowFocus = options.fetchOnMount ?? true;
     const { onFirstSubscribe = noop, onSubscribe = noop, onLastUnsubscribe = noop, onBeforeChangeKey = noop, defaultDeps = useQueryDefaultDeps, select = identityFn, staleTime = 3000, // 3 seconds
     fetchOnMount = true, fetchOnWindowFocus = defaultFetchOnWindowFocus, enabled = true, retry = 1, retryDelay = 2000, // 2 seconds
-    keepPreviousData, getNextPageParam = () => undefined, onSuccess = noop, onError = noop, onSettled = noop, cacheTime = 5 * 60 * 1000, ...createStoresOptions } = options;
+    keepPreviousData, getNextPageParam = () => undefined, onBeforeFetch = noop, onSuccess = noop, onError = noop, onSettled = noop, cacheTime = 5 * 60 * 1000, refetchInterval = false, ...createStoresOptions } = options;
     const retryTimeoutId = new Map();
     const retryNextPageTimeoutId = new Map();
     const resetTimeoutId = new Map();
+    const refetchIntervalTimeoutId = new Map();
     const preventReplaceResponse = new Map(); // Prevent optimistic data to be replaced
     const useQuery = createStores(({ get, set, key: _key, keyHash }) => {
         const key = _key;
         const getRetryProps = (error, retryCount) => {
             const prevState = get();
-            const maxRetryCount = (typeof retry === 'function' ? retry(error, prevState) : retry) || 0;
-            const shouldRetry = retryCount < maxRetryCount;
-            const delay = (typeof retryDelay === 'function' ? retryDelay(error, prevState) : retryDelay) || 0;
-            return { shouldRetry, delay };
+            const maxRetryCount = getValueOrComputedValue(retry, error, prevState) || 0;
+            const delay = getValueOrComputedValue(retryDelay, error, prevState) || 0;
+            return { shouldRetry: retryCount < maxRetryCount, delay };
         };
         const forceFetch = () => new Promise((resolve) => {
             const responseAllPages = [];
             const newPageParams = [undefined];
             let pageParam = undefined;
-            const { isWaiting, isLoading, pageParams } = get();
-            if (isWaiting || enabled === false || (typeof enabled === 'function' && !enabled(key)))
-                return;
+            clearTimeout(refetchIntervalTimeoutId.get(keyHash));
+            const state = get();
+            const { isWaiting, isLoading, pageParams } = state;
+            if (isWaiting || !getValueOrComputedValue(enabled, key))
+                return resolve(state);
+            let shouldcancel = false;
+            const cancel = () => {
+                shouldcancel = true;
+            };
+            onBeforeFetch(cancel, state);
+            if (shouldcancel)
+                return resolve(state);
             if (isLoading)
                 set({ isWaiting: true });
             else
@@ -115,6 +116,12 @@ export const createQuery = (queryFn, options = {}) => {
                         pageParams: newPageParams,
                         hasNextPage: hasValue(newPageParam),
                     });
+                    const refetchIntervalValue = typeof window !== 'undefined' && getValueOrComputedValue(refetchInterval);
+                    if (refetchIntervalValue) {
+                        refetchIntervalTimeoutId.set(keyHash, window.setTimeout(() => {
+                            forceFetch();
+                        }, refetchIntervalValue));
+                    }
                     onSuccess(response, stateBeforeCallQuery);
                     resolve(get());
                 })
@@ -228,16 +235,25 @@ export const createQuery = (queryFn, options = {}) => {
     }, (() => {
         const fetchWindowFocusHandler = () => {
             useQuery.getAllWithSubscriber().forEach((state) => {
-                getDecision(fetchOnWindowFocus, state.key, {
-                    ifTrue: state.fetch,
-                    ifAlways: state.forceFetch,
-                });
+                const result = getValueOrComputedValue(fetchOnWindowFocus, state.key);
+                if (result === 'always')
+                    state.forceFetch();
+                else if (result)
+                    state.fetch();
             });
         };
         return {
             ...createStoresOptions,
             defaultDeps,
             onFirstSubscribe: (state) => {
+                if (state.isSuccess) {
+                    const refetchIntervalValue = typeof window !== 'undefined' && getValueOrComputedValue(refetchInterval);
+                    if (refetchIntervalValue) {
+                        refetchIntervalTimeoutId.set(state.keyHash, window.setTimeout(() => {
+                            state.forceFetch();
+                        }, refetchIntervalValue));
+                    }
+                }
                 if (typeof window !== 'undefined' && fetchOnWindowFocus) {
                     window.addEventListener('focus', fetchWindowFocusHandler);
                 }
@@ -245,10 +261,11 @@ export const createQuery = (queryFn, options = {}) => {
                 onFirstSubscribe(state);
             },
             onSubscribe: (state) => {
-                getDecision(fetchOnMount, state.key, {
-                    ifTrue: state.fetch,
-                    ifAlways: state.forceFetch,
-                });
+                const result = getValueOrComputedValue(fetchOnMount, state.key);
+                if (result === 'always')
+                    state.forceFetch();
+                else if (result)
+                    state.fetch();
                 onSubscribe(state);
             },
             onLastUnsubscribe: (state) => {
@@ -258,6 +275,7 @@ export const createQuery = (queryFn, options = {}) => {
                 useQuery.set(state.key, { retryCount: 0, retryNextPageCount: 0 }, true);
                 clearTimeout(retryTimeoutId.get(state.keyHash));
                 clearTimeout(retryNextPageTimeoutId.get(state.keyHash));
+                clearTimeout(refetchIntervalTimeoutId.get(state.keyHash));
                 if (typeof window !== 'undefined' && cacheTime !== Infinity) {
                     resetTimeoutId.set(state.keyHash, window.setTimeout(() => {
                         useQuery.set(state.key, INITIAL_QUERY_STATE);

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

@@ -177,6 +177,7 @@ export type CreateQueryOptions<TKey extends StoreKey = StoreKey, TResponse = any
      * This function should return a variable that will be used when fetching next page (`pageParam`).
      */
     getNextPageParam?: (lastPage: TResponse, index: number) => any;
+    onBeforeFetch?: (cancel: () => void, state: QueryState<TKey, TResponse, TData, TError>) => void;
     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;
@@ -191,6 +192,14 @@ export type CreateQueryOptions<TKey extends StoreKey = StoreKey, TResponse = any
      * Defaults to `5 * 60 * 1000` (5 minutes).
      */
     cacheTime?: number;
+    /**
+     * Polling interval in milliseconds.
+     *
+     * Disabled by default.
+     *
+     * If the query is on error state, the polling interval will be disabled, and it will use `retry` instead.
+     */
+    refetchInterval?: number | false | (() => number | false);
 };
 export type UseQuery<TKey extends StoreKey = StoreKey, TResponse = any, TData = TResponse, TError = unknown> = UseStores<TKey, QueryState<TKey, TResponse, TData, TError>> & {
     /**

package/esm/react/create-query.js

@@ -1,14 +1,6 @@
 import { createElement, useState } from 'react';
-import { hasValue, identityFn, noop } from '../utils';
+import { getValueOrComputedValue, hasValue, 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 INITIAL_QUERY_STATE = {
     isWaiting: false,
     isWaitingNextPage: false,
@@ -43,27 +35,36 @@ export const createQuery = (queryFn, options = {}) => {
     const defaultFetchOnWindowFocus = options.fetchOnMount ?? true;
     const { onFirstSubscribe = noop, onSubscribe = noop, onLastUnsubscribe = noop, onBeforeChangeKey = noop, defaultDeps = useQueryDefaultDeps, select = identityFn, staleTime = 3000, // 3 seconds
     fetchOnMount = true, fetchOnWindowFocus = defaultFetchOnWindowFocus, enabled = true, retry = 1, retryDelay = 2000, // 2 seconds
-    keepPreviousData, getNextPageParam = () => undefined, onSuccess = noop, onError = noop, onSettled = noop, cacheTime = 5 * 60 * 1000, ...createStoresOptions } = options;
+    keepPreviousData, getNextPageParam = () => undefined, onBeforeFetch = noop, onSuccess = noop, onError = noop, onSettled = noop, cacheTime = 5 * 60 * 1000, refetchInterval = false, ...createStoresOptions } = options;
     const retryTimeoutId = new Map();
     const retryNextPageTimeoutId = new Map();
     const resetTimeoutId = new Map();
+    const refetchIntervalTimeoutId = new Map();
     const preventReplaceResponse = new Map(); // Prevent optimistic data to be replaced
     const useQuery = createStores(({ get, set, key: _key, keyHash }) => {
         const key = _key;
         const getRetryProps = (error, retryCount) => {
             const prevState = get();
-            const maxRetryCount = (typeof retry === 'function' ? retry(error, prevState) : retry) || 0;
-            const shouldRetry = retryCount < maxRetryCount;
-            const delay = (typeof retryDelay === 'function' ? retryDelay(error, prevState) : retryDelay) || 0;
-            return { shouldRetry, delay };
+            const maxRetryCount = getValueOrComputedValue(retry, error, prevState) || 0;
+            const delay = getValueOrComputedValue(retryDelay, error, prevState) || 0;
+            return { shouldRetry: retryCount < maxRetryCount, delay };
         };
         const forceFetch = () => new Promise((resolve) => {
             const responseAllPages = [];
             const newPageParams = [undefined];
             let pageParam = undefined;
-            const { isWaiting, isLoading, pageParams } = get();
-            if (isWaiting || enabled === false || (typeof enabled === 'function' && !enabled(key)))
-                return;
+            clearTimeout(refetchIntervalTimeoutId.get(keyHash));
+            const state = get();
+            const { isWaiting, isLoading, pageParams } = state;
+            if (isWaiting || !getValueOrComputedValue(enabled, key))
+                return resolve(state);
+            let shouldcancel = false;
+            const cancel = () => {
+                shouldcancel = true;
+            };
+            onBeforeFetch(cancel, state);
+            if (shouldcancel)
+                return resolve(state);
             if (isLoading)
                 set({ isWaiting: true });
             else
@@ -114,6 +115,12 @@ export const createQuery = (queryFn, options = {}) => {
                         pageParams: newPageParams,
                         hasNextPage: hasValue(newPageParam),
                     });
+                    const refetchIntervalValue = typeof window !== 'undefined' && getValueOrComputedValue(refetchInterval);
+                    if (refetchIntervalValue) {
+                        refetchIntervalTimeoutId.set(keyHash, window.setTimeout(() => {
+                            forceFetch();
+                        }, refetchIntervalValue));
+                    }
                     onSuccess(response, stateBeforeCallQuery);
                     resolve(get());
                 })
@@ -227,16 +234,25 @@ export const createQuery = (queryFn, options = {}) => {
     }, (() => {
         const fetchWindowFocusHandler = () => {
             useQuery.getAllWithSubscriber().forEach((state) => {
-                getDecision(fetchOnWindowFocus, state.key, {
-                    ifTrue: state.fetch,
-                    ifAlways: state.forceFetch,
-                });
+                const result = getValueOrComputedValue(fetchOnWindowFocus, state.key);
+                if (result === 'always')
+                    state.forceFetch();
+                else if (result)
+                    state.fetch();
             });
         };
         return {
             ...createStoresOptions,
             defaultDeps,
             onFirstSubscribe: (state) => {
+                if (state.isSuccess) {
+                    const refetchIntervalValue = typeof window !== 'undefined' && getValueOrComputedValue(refetchInterval);
+                    if (refetchIntervalValue) {
+                        refetchIntervalTimeoutId.set(state.keyHash, window.setTimeout(() => {
+                            state.forceFetch();
+                        }, refetchIntervalValue));
+                    }
+                }
                 if (typeof window !== 'undefined' && fetchOnWindowFocus) {
                     window.addEventListener('focus', fetchWindowFocusHandler);
                 }
@@ -244,10 +260,11 @@ export const createQuery = (queryFn, options = {}) => {
                 onFirstSubscribe(state);
             },
             onSubscribe: (state) => {
-                getDecision(fetchOnMount, state.key, {
-                    ifTrue: state.fetch,
-                    ifAlways: state.forceFetch,
-                });
+                const result = getValueOrComputedValue(fetchOnMount, state.key);
+                if (result === 'always')
+                    state.forceFetch();
+                else if (result)
+                    state.fetch();
                 onSubscribe(state);
             },
             onLastUnsubscribe: (state) => {
@@ -257,6 +274,7 @@ export const createQuery = (queryFn, options = {}) => {
                 useQuery.set(state.key, { retryCount: 0, retryNextPageCount: 0 }, true);
                 clearTimeout(retryTimeoutId.get(state.keyHash));
                 clearTimeout(retryNextPageTimeoutId.get(state.keyHash));
+                clearTimeout(refetchIntervalTimeoutId.get(state.keyHash));
                 if (typeof window !== 'undefined' && cacheTime !== Infinity) {
                     resetTimeoutId.set(state.keyHash, window.setTimeout(() => {
                         useQuery.set(state.key, INITIAL_QUERY_STATE);

package/esm/utils/index.d.ts

@@ -2,3 +2,4 @@ export declare const noop: () => void;
 export declare const identityFn: <T>(value: T) => T;
 export declare const hasValue: (value: any) => boolean;
 export declare const hashStoreKey: (obj?: any) => string;
+export declare const getValueOrComputedValue: <T, P extends any[]>(valueOrComputeValueFn: T | ((...params: P) => T), ...params: P) => T;

package/esm/utils/index.js

@@ -2,3 +2,9 @@ export const noop = () => { };
 export const identityFn = (value) => value;
 export const hasValue = (value) => value !== undefined && value !== null;
 export const hashStoreKey = (obj) => JSON.stringify(obj, Object.keys(obj).sort());
+export const getValueOrComputedValue = (valueOrComputeValueFn, ...params) => {
+    if (typeof valueOrComputeValueFn === 'function') {
+        return valueOrComputeValueFn(...params);
+    }
+    return valueOrComputeValueFn;
+};

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

@@ -178,6 +178,7 @@ export type CreateQueryOptions<TKey extends StoreKey = StoreKey, TResponse = any
      * This function should return a variable that will be used when fetching next page (`pageParam`).
      */
     getNextPageParam?: (lastPage: TResponse, index: number) => any;
+    onBeforeFetch?: (cancel: () => void, state: QueryState<TKey, TResponse, TData, TError>) => void;
     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;
@@ -192,6 +193,14 @@ export type CreateQueryOptions<TKey extends StoreKey = StoreKey, TResponse = any
      * Defaults to `5 * 60 * 1000` (5 minutes).
      */
     cacheTime?: number;
+    /**
+     * Polling interval in milliseconds.
+     *
+     * Disabled by default.
+     *
+     * If the query is on error state, the polling interval will be disabled, and it will use `retry` instead.
+     */
+    refetchInterval?: number | false | (() => number | false);
 };
 export type UseQuery<TKey extends StoreKey = StoreKey, TResponse = any, TData = TResponse, TError = unknown> = UseStores<TKey, QueryState<TKey, TResponse, TData, TError>> & {
     /**

package/lib/preact/create-query.js

@@ -5,14 +5,6 @@ const preact_1 = require("preact");
 const hooks_1 = require("preact/hooks");
 const utils_1 = require("../utils");
 const create_stores_1 = require("./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 INITIAL_QUERY_STATE = {
     isWaiting: false,
     isWaitingNextPage: false,
@@ -47,27 +39,36 @@ const createQuery = (queryFn, options = {}) => {
     const defaultFetchOnWindowFocus = options.fetchOnMount ?? true;
     const { onFirstSubscribe = utils_1.noop, onSubscribe = utils_1.noop, onLastUnsubscribe = utils_1.noop, onBeforeChangeKey = utils_1.noop, defaultDeps = useQueryDefaultDeps, select = utils_1.identityFn, staleTime = 3000, // 3 seconds
     fetchOnMount = true, fetchOnWindowFocus = defaultFetchOnWindowFocus, enabled = true, retry = 1, retryDelay = 2000, // 2 seconds
-    keepPreviousData, getNextPageParam = () => undefined, onSuccess = utils_1.noop, onError = utils_1.noop, onSettled = utils_1.noop, cacheTime = 5 * 60 * 1000, ...createStoresOptions } = options;
+    keepPreviousData, getNextPageParam = () => undefined, onBeforeFetch = utils_1.noop, onSuccess = utils_1.noop, onError = utils_1.noop, onSettled = utils_1.noop, cacheTime = 5 * 60 * 1000, refetchInterval = false, ...createStoresOptions } = options;
     const retryTimeoutId = new Map();
     const retryNextPageTimeoutId = new Map();
     const resetTimeoutId = new Map();
+    const refetchIntervalTimeoutId = new Map();
     const preventReplaceResponse = new Map(); // Prevent optimistic data to be replaced
     const useQuery = (0, create_stores_1.createStores)(({ get, set, key: _key, keyHash }) => {
         const key = _key;
         const getRetryProps = (error, retryCount) => {
             const prevState = get();
-            const maxRetryCount = (typeof retry === 'function' ? retry(error, prevState) : retry) || 0;
-            const shouldRetry = retryCount < maxRetryCount;
-            const delay = (typeof retryDelay === 'function' ? retryDelay(error, prevState) : retryDelay) || 0;
-            return { shouldRetry, delay };
+            const maxRetryCount = (0, utils_1.getValueOrComputedValue)(retry, error, prevState) || 0;
+            const delay = (0, utils_1.getValueOrComputedValue)(retryDelay, error, prevState) || 0;
+            return { shouldRetry: retryCount < maxRetryCount, delay };
         };
         const forceFetch = () => new Promise((resolve) => {
             const responseAllPages = [];
             const newPageParams = [undefined];
             let pageParam = undefined;
-            const { isWaiting, isLoading, pageParams } = get();
-            if (isWaiting || enabled === false || (typeof enabled === 'function' && !enabled(key)))
-                return;
+            clearTimeout(refetchIntervalTimeoutId.get(keyHash));
+            const state = get();
+            const { isWaiting, isLoading, pageParams } = state;
+            if (isWaiting || !(0, utils_1.getValueOrComputedValue)(enabled, key))
+                return resolve(state);
+            let shouldcancel = false;
+            const cancel = () => {
+                shouldcancel = true;
+            };
+            onBeforeFetch(cancel, state);
+            if (shouldcancel)
+                return resolve(state);
             if (isLoading)
                 set({ isWaiting: true });
             else
@@ -118,6 +119,12 @@ const createQuery = (queryFn, options = {}) => {
                         pageParams: newPageParams,
                         hasNextPage: (0, utils_1.hasValue)(newPageParam),
                     });
+                    const refetchIntervalValue = typeof window !== 'undefined' && (0, utils_1.getValueOrComputedValue)(refetchInterval);
+                    if (refetchIntervalValue) {
+                        refetchIntervalTimeoutId.set(keyHash, window.setTimeout(() => {
+                            forceFetch();
+                        }, refetchIntervalValue));
+                    }
                     onSuccess(response, stateBeforeCallQuery);
                     resolve(get());
                 })
@@ -231,16 +238,25 @@ const createQuery = (queryFn, options = {}) => {
     }, (() => {
         const fetchWindowFocusHandler = () => {
             useQuery.getAllWithSubscriber().forEach((state) => {
-                getDecision(fetchOnWindowFocus, state.key, {
-                    ifTrue: state.fetch,
-                    ifAlways: state.forceFetch,
-                });
+                const result = (0, utils_1.getValueOrComputedValue)(fetchOnWindowFocus, state.key);
+                if (result === 'always')
+                    state.forceFetch();
+                else if (result)
+                    state.fetch();
             });
         };
         return {
             ...createStoresOptions,
             defaultDeps,
             onFirstSubscribe: (state) => {
+                if (state.isSuccess) {
+                    const refetchIntervalValue = typeof window !== 'undefined' && (0, utils_1.getValueOrComputedValue)(refetchInterval);
+                    if (refetchIntervalValue) {
+                        refetchIntervalTimeoutId.set(state.keyHash, window.setTimeout(() => {
+                            state.forceFetch();
+                        }, refetchIntervalValue));
+                    }
+                }
                 if (typeof window !== 'undefined' && fetchOnWindowFocus) {
                     window.addEventListener('focus', fetchWindowFocusHandler);
                 }
@@ -248,10 +264,11 @@ const createQuery = (queryFn, options = {}) => {
                 onFirstSubscribe(state);
             },
             onSubscribe: (state) => {
-                getDecision(fetchOnMount, state.key, {
-                    ifTrue: state.fetch,
-                    ifAlways: state.forceFetch,
-                });
+                const result = (0, utils_1.getValueOrComputedValue)(fetchOnMount, state.key);
+                if (result === 'always')
+                    state.forceFetch();
+                else if (result)
+                    state.fetch();
                 onSubscribe(state);
             },
             onLastUnsubscribe: (state) => {
@@ -261,6 +278,7 @@ const createQuery = (queryFn, options = {}) => {
                 useQuery.set(state.key, { retryCount: 0, retryNextPageCount: 0 }, true);
                 clearTimeout(retryTimeoutId.get(state.keyHash));
                 clearTimeout(retryNextPageTimeoutId.get(state.keyHash));
+                clearTimeout(refetchIntervalTimeoutId.get(state.keyHash));
                 if (typeof window !== 'undefined' && cacheTime !== Infinity) {
                     resetTimeoutId.set(state.keyHash, window.setTimeout(() => {
                         useQuery.set(state.key, INITIAL_QUERY_STATE);

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

@@ -177,6 +177,7 @@ export type CreateQueryOptions<TKey extends StoreKey = StoreKey, TResponse = any
      * This function should return a variable that will be used when fetching next page (`pageParam`).
      */
     getNextPageParam?: (lastPage: TResponse, index: number) => any;
+    onBeforeFetch?: (cancel: () => void, state: QueryState<TKey, TResponse, TData, TError>) => void;
     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;
@@ -191,6 +192,14 @@ export type CreateQueryOptions<TKey extends StoreKey = StoreKey, TResponse = any
      * Defaults to `5 * 60 * 1000` (5 minutes).
      */
     cacheTime?: number;
+    /**
+     * Polling interval in milliseconds.
+     *
+     * Disabled by default.
+     *
+     * If the query is on error state, the polling interval will be disabled, and it will use `retry` instead.
+     */
+    refetchInterval?: number | false | (() => number | false);
 };
 export type UseQuery<TKey extends StoreKey = StoreKey, TResponse = any, TData = TResponse, TError = unknown> = UseStores<TKey, QueryState<TKey, TResponse, TData, TError>> & {
     /**

package/lib/react/create-query.js

@@ -4,14 +4,6 @@ exports.createQuery = void 0;
 const react_1 = require("react");
 const utils_1 = require("../utils");
 const create_stores_1 = require("./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 INITIAL_QUERY_STATE = {
     isWaiting: false,
     isWaitingNextPage: false,
@@ -46,27 +38,36 @@ const createQuery = (queryFn, options = {}) => {
     const defaultFetchOnWindowFocus = options.fetchOnMount ?? true;
     const { onFirstSubscribe = utils_1.noop, onSubscribe = utils_1.noop, onLastUnsubscribe = utils_1.noop, onBeforeChangeKey = utils_1.noop, defaultDeps = useQueryDefaultDeps, select = utils_1.identityFn, staleTime = 3000, // 3 seconds
     fetchOnMount = true, fetchOnWindowFocus = defaultFetchOnWindowFocus, enabled = true, retry = 1, retryDelay = 2000, // 2 seconds
-    keepPreviousData, getNextPageParam = () => undefined, onSuccess = utils_1.noop, onError = utils_1.noop, onSettled = utils_1.noop, cacheTime = 5 * 60 * 1000, ...createStoresOptions } = options;
+    keepPreviousData, getNextPageParam = () => undefined, onBeforeFetch = utils_1.noop, onSuccess = utils_1.noop, onError = utils_1.noop, onSettled = utils_1.noop, cacheTime = 5 * 60 * 1000, refetchInterval = false, ...createStoresOptions } = options;
     const retryTimeoutId = new Map();
     const retryNextPageTimeoutId = new Map();
     const resetTimeoutId = new Map();
+    const refetchIntervalTimeoutId = new Map();
     const preventReplaceResponse = new Map(); // Prevent optimistic data to be replaced
     const useQuery = (0, create_stores_1.createStores)(({ get, set, key: _key, keyHash }) => {
         const key = _key;
         const getRetryProps = (error, retryCount) => {
             const prevState = get();
-            const maxRetryCount = (typeof retry === 'function' ? retry(error, prevState) : retry) || 0;
-            const shouldRetry = retryCount < maxRetryCount;
-            const delay = (typeof retryDelay === 'function' ? retryDelay(error, prevState) : retryDelay) || 0;
-            return { shouldRetry, delay };
+            const maxRetryCount = (0, utils_1.getValueOrComputedValue)(retry, error, prevState) || 0;
+            const delay = (0, utils_1.getValueOrComputedValue)(retryDelay, error, prevState) || 0;
+            return { shouldRetry: retryCount < maxRetryCount, delay };
         };
         const forceFetch = () => new Promise((resolve) => {
             const responseAllPages = [];
             const newPageParams = [undefined];
             let pageParam = undefined;
-            const { isWaiting, isLoading, pageParams } = get();
-            if (isWaiting || enabled === false || (typeof enabled === 'function' && !enabled(key)))
-                return;
+            clearTimeout(refetchIntervalTimeoutId.get(keyHash));
+            const state = get();
+            const { isWaiting, isLoading, pageParams } = state;
+            if (isWaiting || !(0, utils_1.getValueOrComputedValue)(enabled, key))
+                return resolve(state);
+            let shouldcancel = false;
+            const cancel = () => {
+                shouldcancel = true;
+            };
+            onBeforeFetch(cancel, state);
+            if (shouldcancel)
+                return resolve(state);
             if (isLoading)
                 set({ isWaiting: true });
             else
@@ -117,6 +118,12 @@ const createQuery = (queryFn, options = {}) => {
                         pageParams: newPageParams,
                         hasNextPage: (0, utils_1.hasValue)(newPageParam),
                     });
+                    const refetchIntervalValue = typeof window !== 'undefined' && (0, utils_1.getValueOrComputedValue)(refetchInterval);
+                    if (refetchIntervalValue) {
+                        refetchIntervalTimeoutId.set(keyHash, window.setTimeout(() => {
+                            forceFetch();
+                        }, refetchIntervalValue));
+                    }
                     onSuccess(response, stateBeforeCallQuery);
                     resolve(get());
                 })
@@ -230,16 +237,25 @@ const createQuery = (queryFn, options = {}) => {
     }, (() => {
         const fetchWindowFocusHandler = () => {
             useQuery.getAllWithSubscriber().forEach((state) => {
-                getDecision(fetchOnWindowFocus, state.key, {
-                    ifTrue: state.fetch,
-                    ifAlways: state.forceFetch,
-                });
+                const result = (0, utils_1.getValueOrComputedValue)(fetchOnWindowFocus, state.key);
+                if (result === 'always')
+                    state.forceFetch();
+                else if (result)
+                    state.fetch();
             });
         };
         return {
             ...createStoresOptions,
             defaultDeps,
             onFirstSubscribe: (state) => {
+                if (state.isSuccess) {
+                    const refetchIntervalValue = typeof window !== 'undefined' && (0, utils_1.getValueOrComputedValue)(refetchInterval);
+                    if (refetchIntervalValue) {
+                        refetchIntervalTimeoutId.set(state.keyHash, window.setTimeout(() => {
+                            state.forceFetch();
+                        }, refetchIntervalValue));
+                    }
+                }
                 if (typeof window !== 'undefined' && fetchOnWindowFocus) {
                     window.addEventListener('focus', fetchWindowFocusHandler);
                 }
@@ -247,10 +263,11 @@ const createQuery = (queryFn, options = {}) => {
                 onFirstSubscribe(state);
             },
             onSubscribe: (state) => {
-                getDecision(fetchOnMount, state.key, {
-                    ifTrue: state.fetch,
-                    ifAlways: state.forceFetch,
-                });
+                const result = (0, utils_1.getValueOrComputedValue)(fetchOnMount, state.key);
+                if (result === 'always')
+                    state.forceFetch();
+                else if (result)
+                    state.fetch();
                 onSubscribe(state);
             },
             onLastUnsubscribe: (state) => {
@@ -260,6 +277,7 @@ const createQuery = (queryFn, options = {}) => {
                 useQuery.set(state.key, { retryCount: 0, retryNextPageCount: 0 }, true);
                 clearTimeout(retryTimeoutId.get(state.keyHash));
                 clearTimeout(retryNextPageTimeoutId.get(state.keyHash));
+                clearTimeout(refetchIntervalTimeoutId.get(state.keyHash));
                 if (typeof window !== 'undefined' && cacheTime !== Infinity) {
                     resetTimeoutId.set(state.keyHash, window.setTimeout(() => {
                         useQuery.set(state.key, INITIAL_QUERY_STATE);

package/lib/utils/index.d.ts

@@ -2,3 +2,4 @@ export declare const noop: () => void;
 export declare const identityFn: <T>(value: T) => T;
 export declare const hasValue: (value: any) => boolean;
 export declare const hashStoreKey: (obj?: any) => string;
+export declare const getValueOrComputedValue: <T, P extends any[]>(valueOrComputeValueFn: T | ((...params: P) => T), ...params: P) => T;

package/lib/utils/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hashStoreKey = exports.hasValue = exports.identityFn = exports.noop = void 0;
+exports.getValueOrComputedValue = exports.hashStoreKey = exports.hasValue = exports.identityFn = exports.noop = void 0;
 const noop = () => { };
 exports.noop = noop;
 const identityFn = (value) => value;
@@ -9,3 +9,10 @@ const hasValue = (value) => value !== undefined && value !== null;
 exports.hasValue = hasValue;
 const hashStoreKey = (obj) => JSON.stringify(obj, Object.keys(obj).sort());
 exports.hashStoreKey = hashStoreKey;
+const getValueOrComputedValue = (valueOrComputeValueFn, ...params) => {
+    if (typeof valueOrComputeValueFn === 'function') {
+        return valueOrComputeValueFn(...params);
+    }
+    return valueOrComputeValueFn;
+};
+exports.getValueOrComputedValue = getValueOrComputedValue;

package/package.json

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