@promoboxx/use-filter 1.11.2 → 2.0.1

package/dist/store/reduxStore.js

@@ -1,67 +0,0 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useFilterReduxReducer = exports.createReduxStore = void 0;
-var createActions_1 = __importDefault(require("./reduxHelpers/createActions"));
-var createReducer_1 = __importDefault(require("./reduxHelpers/createReducer"));
-function createReduxStore(config) {
-    var reduxStoreStore = {
-        getFilter: function (namespace) {
-            return config.store.getState().useFilter.filters[namespace];
-        },
-        saveFilter: function (namespace, filter) {
-            config.store.dispatch(actions.saveFilter(namespace, filter));
-        },
-        getData: function (namespace) {
-            return config.store.getState().useFilter.data[namespace];
-        },
-        saveData: function (namespace, data) {
-            config.store.dispatch(actions.saveData(namespace, data));
-        },
-        clear: function () {
-            config.store.dispatch(actions.clear());
-        },
-    };
-    return reduxStoreStore;
-}
-exports.createReduxStore = createReduxStore;
-var actions = createActions_1.default('useFilter', {
-    saveData: function (namespace, data) { return ({
-        namespace: namespace,
-        data: data,
-    }); },
-    saveFilter: function (namespace, filter) { return ({
-        namespace: namespace,
-        filter: filter,
-    }); },
-    clear: function () { return undefined; },
-});
-var initialState = {
-    data: {},
-    filters: {},
-};
-exports.useFilterReduxReducer = createReducer_1.default(initialState, function (builder) {
-    builder
-        .addHandler(actions.saveFilter, function (state, action) {
-        var _a;
-        return (__assign(__assign({}, state), { filters: __assign(__assign({}, state.filters), (_a = {}, _a[action.payload.namespace] = action.payload.filter, _a)) }));
-    })
-        .addHandler(actions.saveData, function (state, action) {
-        var _a;
-        return (__assign(__assign({}, state), { data: __assign(__assign({}, state.data), (_a = {}, _a[action.payload.namespace] = action.payload.data, _a)) }));
-    })
-        .addHandler(actions.clear, function (state) { return (__assign(__assign({}, state), { filters: {}, data: {} })); });
-});

package/dist/store/urlParamStore.d.ts

@@ -1,4 +0,0 @@
-import { FilterStore } from './index';
-export declare const createUrlParamStore: () => FilterStore;
-export declare function replaceQueryParams(newParams: string): void;
-export declare function naivelyParseExistingParams(): any;

package/dist/store/urlParamStore.js

@@ -1,91 +0,0 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.naivelyParseExistingParams = exports.replaceQueryParams = exports.createUrlParamStore = void 0;
-var qs_1 = __importDefault(require("qs"));
-var createUrlParamStore = function () {
-    var urlParamStore = {
-        getFilter: function (namespace) {
-            var parsed = naivelyParseExistingParams();
-            var parsedInfo = parsed["info." + namespace];
-            var parsedFilter = parsed["filter." + namespace];
-            // useFilter doesn't really support returning a partial FilterInfo, so both
-            // need to be present,
-            if (parsedInfo || parsedFilter) {
-                var _a = parsedInfo || {}, page = _a.page, offset = _a.offset, pageSize = _a.pageSize, rest = __rest(_a, ["page", "offset", "pageSize"]);
-                return __assign(__assign({}, __assign({ page: 1 / page ? +page : undefined, pageSize: 1 / pageSize ? +pageSize : undefined, offset: 1 / offset ? +offset : undefined }, rest)), { filter: parsedFilter });
-            }
-        },
-        saveFilter: function (namespace, filterInfo) {
-            var parsed = naivelyParseExistingParams();
-            // Setting the params to the equivalent of { [namespace]: filterInfo }
-            // takes up more room. The idea is that this ...
-            //     'filter.filterName%5BfilterValueKey%5D=filterValueValue'
-            // ... is smaller than ...
-            //     filterName%5Bfilter%5D%5BfilterValueKey%5D=filterValueValue
-            // ... by 5 characters per value in a filter. So excuse us for a second ...
-            var clonedInfo = __assign({}, filterInfo);
-            var clonedFilter = filterInfo.filter;
-            delete clonedInfo.filter;
-            delete clonedInfo.lastRefreshAt;
-            delete clonedInfo.shouldRunImmediately;
-            delete clonedInfo.totalResults;
-            delete clonedInfo.totalPages;
-            delete clonedInfo.nextCursor;
-            parsed["filter." + namespace] = clonedFilter;
-            parsed["info." + namespace] = clonedInfo;
-            replaceQueryParams(qs_1.default.stringify(parsed));
-        },
-        clear: function () {
-            var parsed = naivelyParseExistingParams();
-            for (var key in parsed) {
-                if (key.startsWith('filter.') || key.startsWith('info.')) {
-                    delete parsed[key];
-                }
-            }
-            replaceQueryParams(qs_1.default.stringify(parsed));
-        },
-        getData: function () {
-            return undefined;
-        },
-        saveData: function () { },
-    };
-    return urlParamStore;
-};
-exports.createUrlParamStore = createUrlParamStore;
-function replaceQueryParams(newParams) {
-    var nextUrl = new URL(window.location.toString());
-    nextUrl.search = newParams;
-    window.history.replaceState(undefined, '', nextUrl.toString());
-}
-exports.replaceQueryParams = replaceQueryParams;
-function naivelyParseExistingParams() {
-    // Don't really want to do any casting, especially not to `any`, but the type
-    // of `qs.parse` is so wide we'd have to litter checks all over the place.
-    return qs_1.default.parse(window.location.search.substring(1));
-}
-exports.naivelyParseExistingParams = naivelyParseExistingParams;

package/dist/useFilter.d.ts

@@ -1,103 +0,0 @@
-import { FilterStore } from './store';
-declare type MaybePromise<T> = T | Promise<T>;
-interface UseFilterOptions<TFilter, TResult> {
-    /**
-     * Default values for your filter. When calling `.reset` your filter will be
-     * set to this.
-     * Changing these values does not cause a call to happen.
-     */
-    defaultFilterInfo?: Partial<FilterInfo<TFilter>>;
-    /**
-     * Enable this if you are not using the data caching of this hook.
-     */
-    shouldForceRunOnMount?: boolean;
-    /**
-     * Called whenever the filter changes.
-     */
-    onChange: (filterInfo: FilterInfo<TFilter>, reason: UseFilterUpdateReason) => MaybePromise<UseFilterOnChangeResult<TFilter, TResult>>;
-    /**
-     * In case you want to change the default debounce duration.
-     */
-    debounceDuration?: number;
-    onBeforeSaveFilter?: (filterInfo: FilterInfo<TFilter>) => FilterInfo<TFilter>;
-    store?: FilterStore;
-}
-export interface FilterApi<TFilter, TResult> {
-    /**
-     * Whether the system is debouncing or waiting for your `onChange` to finish.
-     */
-    isLoading: boolean;
-    /**
-     * Any cached data for this filter.
-     */
-    data: TResult | null | undefined;
-    /**
-     * Access to the filter and its metadata.
-     */
-    filterInfo: FilterInfo<TFilter>;
-    /**
-     * Whether the filter existed in the system when the component mounted.
-     * @deprecated
-     */
-    doesFilterExist: boolean;
-    /**
-     * Why the last update happened.
-     */
-    updateReason: UseFilterUpdateReason;
-    /**
-     * Update one or more values in your filter.
-     */
-    updateFilter: (filter: Partial<TFilter>, shouldRunImmediately?: boolean) => void;
-    /**
-     * Resets the filter back to `defaultFilterInfo`.
-     */
-    resetFilter: (shouldRunImmediately?: boolean) => void;
-    /**
-     * Changes the offset. Will update `page`.
-     */
-    setOffset: (offset: number | string, shouldRunImmediately?: boolean) => void;
-    /**
-     * Changes the page. Will update `offset`.
-     */
-    setPage: (page: number | string, shouldRunImmediately?: boolean) => void;
-    /**
-     * Changes the page size.
-     */
-    setPageSize: (pageSize: number | string, shouldRunImmediately?: boolean) => void;
-    /**
-     * Change the sort method.
-     */
-    setSort: (sort: string | undefined, shouldRunImmediately?: boolean) => void;
-    /**
-     * Changes the cursor.
-     */
-    setCursor: (cursor: string | null | undefined, shouldRunImmediately?: boolean) => void;
-    /**
-     * Forces a refresh of the filter.
-     */
-    forceRefresh: (shouldRunImmediately?: boolean) => void;
-}
-export declare type UseFilterUpdateReason = 'initial' | 'filter' | 'pagination';
-declare function useFilter<TFilter, TResult>(namespace: string, options: UseFilterOptions<TFilter, TResult>): FilterApi<TFilter, TResult>;
-export default useFilter;
-export interface FilterInfo<TFilter> {
-    filter: TFilter;
-    offset: number;
-    page: number;
-    sort?: string;
-    pageSize: number;
-    lastRefreshAt: number;
-    totalResults: number;
-    totalPages: number;
-    shouldRunImmediately: boolean;
-    cursor?: string | null;
-    nextCursor?: string | null;
-}
-declare type UseFilterOnChangeResult<TFilter, TResult> = void | {
-    filterInfo?: Partial<Omit<FilterInfo<TFilter>, 'totalResults' | 'offset' | 'pageSize'> & {
-        totalResults: string | number;
-        offset: string | number;
-        pageSize: string | number;
-    }>;
-    data?: TResult;
-};

package/dist/useFilter.js

@@ -1,254 +0,0 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var react_1 = require("react");
-var buildDefaultFilterInfo_1 = __importDefault(require("./lib/buildDefaultFilterInfo"));
-var getOffsetFromPage_1 = __importDefault(require("./lib/getOffsetFromPage"));
-var getPageFromOffset_1 = __importDefault(require("./lib/getPageFromOffset"));
-var shallowEqual_1 = __importDefault(require("./lib/shallowEqual"));
-var store_1 = require("./store");
-function useFilter(namespace, options) {
-    // Having these types of refs helps get around rules of hooks, and they need
-    // to be updated each render.
-    var ctxRefValue = {
-        namespace: namespace,
-        onChange: options.onChange,
-        debounceDuration: options.debounceDuration,
-        defaultFilterInfo: options.defaultFilterInfo,
-        onBeforeSaveFilter: options.onBeforeSaveFilter,
-        store: options.store,
-    };
-    var ctxRef = react_1.useRef(ctxRefValue);
-    react_1.useEffect(function () {
-        ctxRef.current = ctxRefValue;
-    });
-    var _a = react_1.useState(function () {
-        var _a;
-        var fromStore = store_1.getFilterStore(ctxRef.current.store).getFilter(namespace);
-        // If the filter is already in the store, we have to make sure it ...
-        // - has both the filter and filterInfo
-        // - has all the fields the user passed to the hook
-        if (fromStore) {
-            var filterInfo_1 = buildDefaultFilterInfo_1.default(__assign(__assign({}, fromStore), { shouldRunImmediately: true, filter: __assign(__assign({}, (_a = options.defaultFilterInfo) === null || _a === void 0 ? void 0 : _a.filter), fromStore.filter) }));
-            return filterInfo_1;
-        }
-    }), filterInfo = _a[0], setFilterInfoState = _a[1];
-    var _b = react_1.useState(function () {
-        return store_1.getFilterStore(ctxRef.current.store).getData(namespace);
-    }), data = _b[0], setData = _b[1];
-    var _c = react_1.useState(!filterInfo), isLoading = _c[0], setIsLoading = _c[1];
-    var doesFilterExist = react_1.useRef(!!filterInfo);
-    var lastRefreshAtRef = react_1.useRef(
-    // if shouldForceRunOnMount is set, always use -1
-    // otherwise, try grabbing lastRefreshAt
-    // then, just use -1 cause there's no other option
-    options.shouldForceRunOnMount
-        ? -1
-        : filterInfo
-            ? filterInfo.lastRefreshAt
-            : -1);
-    var updateReasonRef = react_1.useRef('initial');
-    // Call onChange when data changes.
-    react_1.useEffect(function () {
-        setIsLoading(true);
-        // If there is no existing filter info, set it to the defaults and return.
-        // This same effect will trigger next go.
-        if (!filterInfo) {
-            setFilterInfoState(__assign(__assign({}, buildDefaultFilterInfo_1.default(ctxRef.current.defaultFilterInfo)), { shouldRunImmediately: true }));
-            return;
-        }
-        // If the lastRefreshAt hasn't changed, don't make a request.
-        if (lastRefreshAtRef.current === filterInfo.lastRefreshAt) {
-            setIsLoading(false);
-            return;
-        }
-        var makeRequest = function () {
-            lastRefreshAtRef.current = filterInfo.lastRefreshAt;
-            var response = ctxRef.current.onChange(filterInfo, updateReasonRef.current);
-            store_1.getFilterStore(ctxRef.current.store).saveFilter(namespace, ctxRef.current.onBeforeSaveFilter
-                ? ctxRef.current.onBeforeSaveFilter(filterInfo)
-                : filterInfo);
-            if (!response) {
-                setIsLoading(false);
-                return;
-            }
-            function handleResponse(response) {
-                if (!response) {
-                    return;
-                }
-                if (response.filterInfo) {
-                    setFilterInfoState(function (previous) {
-                        // Even though we've already checked for response.filterInfo, since
-                        // we're in a callback TypeScript still considers accessing it
-                        // unsafe, so do another check.
-                        invariant(!!response.filterInfo, '');
-                        invariant(previous != null, 'handleResponse called without filterInfo');
-                        var extra = {};
-                        var _a = response.filterInfo, page = _a.page, offset = _a.offset, totalResults = _a.totalResults, pageSize = _a.pageSize, nextCursor = _a.nextCursor, filterInfoFromResponse = __rest(_a, ["page", "offset", "totalResults", "pageSize", "nextCursor"]);
-                        var pageSizeNumber = Number(pageSize || previous.pageSize);
-                        if (page != null && offset == null) {
-                            extra.offset = getOffsetFromPage_1.default(page, pageSizeNumber);
-                            extra.page = page;
-                            // If there's an offset but no page, set the page.
-                        }
-                        else if (page == null && offset != null) {
-                            var offsetNumber = Number(offset);
-                            extra.offset = offsetNumber;
-                            extra.page = getPageFromOffset_1.default(offsetNumber, pageSizeNumber);
-                        }
-                        // `null` / `undefined` are valid here, it means there is zero
-                        // results, so we can't just check if it's truthy, we need to check
-                        // for presence.
-                        if ('totalResults' in response.filterInfo) {
-                            extra.totalResults = Number(totalResults || 0);
-                            extra.totalPages = Math.ceil(extra.totalResults / pageSizeNumber);
-                        }
-                        // `null` / `undefined` are valid here, it means there is no next
-                        // cursor, so we can't just check if it's truthy, we need to check
-                        // for presence.
-                        if ('nextCursor' in response.filterInfo) {
-                            extra.nextCursor = nextCursor;
-                        }
-                        return __assign(__assign(__assign({}, previous), filterInfoFromResponse), extra);
-                    });
-                }
-                if (response.data) {
-                    setData(response.data);
-                    store_1.getFilterStore(ctxRef.current.store).saveData(namespace, response.data);
-                }
-            }
-            if (isPromise(response)) {
-                response.then(handleResponse).finally(function () { return setIsLoading(false); });
-            }
-            else {
-                handleResponse(response);
-                setIsLoading(false);
-            }
-        };
-        var timeout = undefined;
-        if (filterInfo.shouldRunImmediately) {
-            makeRequest();
-        }
-        else {
-            timeout = setTimeout(makeRequest, ctxRef.current.debounceDuration != null
-                ? ctxRef.current.debounceDuration
-                : 500);
-        }
-        return function () {
-            if (timeout) {
-                clearTimeout(timeout);
-            }
-        };
-    }, [filterInfo, namespace]);
-    var api = {
-        isLoading: isLoading,
-        data: data,
-        doesFilterExist: doesFilterExist.current,
-        filterInfo: filterInfo || buildDefaultFilterInfo_1.default(options.defaultFilterInfo),
-        updateReason: updateReasonRef.current,
-        updateFilter: react_1.useCallback(function (filter, shouldRunImmediately) {
-            if (shouldRunImmediately === void 0) { shouldRunImmediately = false; }
-            updateReasonRef.current = 'filter';
-            setFilterInfoState(function (previous) {
-                invariant(previous != null, 'updateFilter called without filterInfo');
-                var nextFilter = __assign(__assign({}, previous.filter), filter);
-                if (shallowEqual_1.default(previous.filter, nextFilter)) {
-                    return previous;
-                }
-                return __assign(__assign({}, previous), { offset: 0, page: 1, totalResults: 1, totalPages: 1, filter: nextFilter, lastRefreshAt: new Date().getTime(), cursor: undefined, nextCursor: undefined, shouldRunImmediately: shouldRunImmediately });
-            });
-        }, []),
-        resetFilter: react_1.useCallback(function (shouldRunImmediately) {
-            if (shouldRunImmediately === void 0) { shouldRunImmediately = false; }
-            updateReasonRef.current = 'filter';
-            setFilterInfoState(__assign(__assign({}, buildDefaultFilterInfo_1.default(ctxRef.current.defaultFilterInfo)), { lastRefreshAt: new Date().getTime(), shouldRunImmediately: shouldRunImmediately }));
-        }, []),
-        setOffset: react_1.useCallback(function (offset, shouldRunImmediately) {
-            if (shouldRunImmediately === void 0) { shouldRunImmediately = false; }
-            updateReasonRef.current = 'pagination';
-            setFilterInfoState(function (previous) {
-                invariant(previous != null, 'setOffset called without filterInfo');
-                var offsetNumber = Number(offset);
-                return __assign(__assign({}, previous), { offset: offsetNumber, page: getPageFromOffset_1.default(offsetNumber, previous.pageSize), lastRefreshAt: new Date().getTime(), shouldRunImmediately: shouldRunImmediately });
-            });
-        }, []),
-        setPage: react_1.useCallback(function (page, shouldRunImmediately) {
-            if (shouldRunImmediately === void 0) { shouldRunImmediately = false; }
-            updateReasonRef.current = 'pagination';
-            setFilterInfoState(function (previous) {
-                invariant(previous != null, 'setPage called without filterInfo');
-                var pageNumber = Number(page);
-                return __assign(__assign({}, previous), { offset: getOffsetFromPage_1.default(pageNumber, previous.pageSize), page: pageNumber, lastRefreshAt: new Date().getTime(), shouldRunImmediately: shouldRunImmediately });
-            });
-        }, []),
-        setPageSize: react_1.useCallback(function (pageSize, shouldRunImmediately) {
-            if (shouldRunImmediately === void 0) { shouldRunImmediately = false; }
-            updateReasonRef.current = 'pagination';
-            setFilterInfoState(function (previous) {
-                invariant(previous != null, 'setPageSize called without filterInfo');
-                var pageSizeNumber = Number(pageSize);
-                var page = getPageFromOffset_1.default(previous.offset, pageSizeNumber);
-                var offset = getOffsetFromPage_1.default(page, pageSizeNumber);
-                return __assign(__assign({}, previous), { pageSize: pageSizeNumber, offset: offset, page: page, lastRefreshAt: new Date().getTime(), shouldRunImmediately: shouldRunImmediately });
-            });
-        }, []),
-        setSort: react_1.useCallback(function (sort, shouldRunImmediately) {
-            if (shouldRunImmediately === void 0) { shouldRunImmediately = false; }
-            updateReasonRef.current = 'filter';
-            setFilterInfoState(function (previous) {
-                invariant(previous != null, 'setSort called without filterInfo');
-                return __assign(__assign({}, previous), { sort: sort, lastRefreshAt: new Date().getTime(), shouldRunImmediately: shouldRunImmediately });
-            });
-        }, []),
-        setCursor: react_1.useCallback(function (cursor, shouldRunImmediately) {
-            if (shouldRunImmediately === void 0) { shouldRunImmediately = false; }
-            setFilterInfoState(function (previous) {
-                updateReasonRef.current = 'pagination';
-                invariant(previous != null, 'setCursor called without filterInfo');
-                return __assign(__assign({}, previous), { cursor: cursor, lastRefreshAt: new Date().getTime(), shouldRunImmediately: shouldRunImmediately });
-            });
-        }, []),
-        forceRefresh: react_1.useCallback(function (shouldRunImmediately) {
-            if (shouldRunImmediately === void 0) { shouldRunImmediately = false; }
-            updateReasonRef.current = 'filter';
-            setFilterInfoState(function (previous) {
-                invariant(previous != null, 'forceRefresh called without filterInfo');
-                return __assign(__assign({}, previous), { lastRefreshAt: new Date().getTime(), shouldRunImmediately: shouldRunImmediately });
-            });
-        }, []),
-    };
-    return api;
-}
-exports.default = useFilter;
-function invariant(input, message) {
-    if (!input) {
-        throw new Error("Invariant error: " + message);
-    }
-}
-function isPromise(t) {
-    return !!(t === null || t === void 0 ? void 0 : t.then);
-}

package/dist/useSimpleFilter.d.ts

@@ -1,86 +0,0 @@
-import { FilterStore } from './store';
-import { UseFilterUpdateReason } from './useFilter';
-interface UseSimpleFilterOptions<TFilter> {
-    /**
-     * Default values for your filter. When calling `.reset` your filter will be
-     * set to this.
-     * Changing these values does not cause a call to happen.
-     */
-    defaultFilterInfo?: Partial<SimpleFilterInfo<TFilter>>;
-    /**
-     * In case you want to change the default debounce duration.
-     */
-    debounceDuration?: number;
-    onBeforeSaveFilter?: (filterInfo: SimpleFilterInfo<TFilter>) => SimpleFilterInfo<TFilter>;
-    store?: FilterStore;
-}
-export interface SimpleFilterApi<TFilter> {
-    /**
-     * Really more "is debouncing", since simple mode doesn't know when your code
-     * is doing anything.
-     */
-    isLoading: boolean;
-    /**
-     * Access to the filter and its metadata.
-     */
-    filterInfo: SimpleFilterInfo<TFilter>;
-    /**
-     * Same as the regular `filterInfo`, but updates in a debounced fashion.
-     */
-    debouncedFilterInfo: SimpleFilterInfo<TFilter>;
-    /**
-     * Why the last update happened.
-     */
-    updateReason: UseFilterUpdateReason;
-    /**
-     * Update one or more values in your filter.
-     */
-    updateFilter: (filter: Partial<TFilter>, shouldRunImmediately?: boolean) => void;
-    /**
-     * Does the boring math for you based on your `pageSize` and `totalResults`.
-     */
-    pagingInfo: (total: string | number | null | undefined) => {
-        totalResults: number;
-        totalPages: number;
-    };
-    /**
-     * Resets the filter back to `defaultFilterInfo`.
-     */
-    resetFilter: (shouldRunImmediately?: boolean) => void;
-    /**
-     * Changes the offset. Will update `page`.
-     */
-    setOffset: (offset: number | string, shouldRunImmediately?: boolean) => void;
-    /**
-     * Changes the page. Will update `offset`.
-     */
-    setPage: (page: number | string, shouldRunImmediately?: boolean) => void;
-    /**
-     * Changes the page size.
-     */
-    setPageSize: (pageSize: number | string, shouldRunImmediately?: boolean) => void;
-    /**
-     * Change the sort method.
-     */
-    setSort: (sort: string, shouldRunImmediately?: boolean) => void;
-    /**
-     * Changes the cursor.
-     */
-    setCursor: (cursor: string | null | undefined, shouldRunImmediately?: boolean) => void;
-    /**
-     * Forces a refresh of the filter.
-     */
-    forceRefresh: (shouldRunImmediately?: boolean) => void;
-}
-export interface SimpleFilterInfo<TFilter> {
-    filter: TFilter;
-    sort?: string;
-    offset: number;
-    page: number;
-    pageSize: number;
-    lastRefreshAt: number;
-    cursor?: string | null;
-    shouldRunImmediately: boolean;
-}
-declare function useSimpleFilter<TFilter>(namespace: string, options: UseSimpleFilterOptions<TFilter>): SimpleFilterApi<TFilter>;
-export default useSimpleFilter;