@promoboxx/use-filter 1.11.2 → 2.0.0

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;

package/dist/useSimpleFilter.js

@@ -1,173 +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 });
-var react_1 = require("react");
-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 useSimpleFilter(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,
-        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(false), isLoading = _a[0], setIsLoading = _a[1];
-    var _b = 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(__assign(__assign({}, fromStore), { shouldRunImmediately: true, filter: __assign(__assign({}, (_a = options.defaultFilterInfo) === null || _a === void 0 ? void 0 : _a.filter), fromStore.filter) }));
-            return filterInfo_1;
-        }
-        else {
-            return buildDefaultFilterInfo(__assign(__assign({}, options.defaultFilterInfo), { shouldRunImmediately: true }));
-        }
-    }), filterInfo = _b[0], setFilterInfoState = _b[1];
-    var _c = react_1.useState(filterInfo), debouncedFilterInfo = _c[0], setDebouncedFilterInfo = _c[1];
-    // Not sure this is needed in simple mode?
-    var lastRefreshAtRef = react_1.useRef(-1);
-    var updateReasonRef = react_1.useRef('initial');
-    react_1.useEffect(function () {
-        var _a;
-        setIsLoading(true);
-        // If the lastRefreshAt hasn't changed, don't do anything.
-        if (lastRefreshAtRef.current === filterInfo.lastRefreshAt) {
-            setIsLoading(false);
-            return;
-        }
-        var timeout = undefined;
-        function makeRequest() {
-            lastRefreshAtRef.current = filterInfo.lastRefreshAt;
-            store_1.getFilterStore(ctxRef.current.store).saveFilter(ctxRef.current.namespace, (ctxRef.current.onBeforeSaveFilter
-                ? ctxRef.current.onBeforeSaveFilter(filterInfo)
-                : filterInfo));
-            setDebouncedFilterInfo(filterInfo);
-            setIsLoading(false);
-        }
-        if (filterInfo.shouldRunImmediately) {
-            makeRequest();
-        }
-        else {
-            timeout = setTimeout(makeRequest, (_a = ctxRef.current.debounceDuration) !== null && _a !== void 0 ? _a : 500);
-        }
-        return function () {
-            if (timeout) {
-                clearTimeout(timeout);
-            }
-        };
-    }, [filterInfo]);
-    var previousTotalRef = react_1.useRef(0);
-    var api = {
-        isLoading: isLoading,
-        filterInfo: filterInfo,
-        debouncedFilterInfo: debouncedFilterInfo,
-        updateReason: updateReasonRef.current,
-        updateFilter: react_1.useCallback(function (filter, shouldRunImmediately) {
-            if (shouldRunImmediately === void 0) { shouldRunImmediately = false; }
-            updateReasonRef.current = 'filter';
-            setFilterInfoState(function (previous) {
-                var nextFilter = __assign(__assign({}, previous.filter), filter);
-                if (shallowEqual_1.default(previous.filter, nextFilter)) {
-                    return previous;
-                }
-                return __assign(__assign({}, previous), { shouldRunImmediately: shouldRunImmediately, offset: 0, page: 1, totalResults: 1, totalPages: 1, filter: nextFilter, cursor: undefined, lastRefreshAt: new Date().getTime() });
-            });
-        }, []),
-        pagingInfo: react_1.useCallback(function (total) {
-            var normalized = Number(
-            // Because we accept `null` as an argument, we can't do something as
-            // simple as `total ?? ...`
-            total == null ? previousTotalRef.current : total);
-            previousTotalRef.current = normalized;
-            return {
-                totalResults: normalized,
-                totalPages: Math.ceil(normalized / filterInfo.pageSize),
-            };
-        }, [filterInfo.pageSize]),
-        resetFilter: react_1.useCallback(function (shouldRunImmediately) {
-            if (shouldRunImmediately === void 0) { shouldRunImmediately = false; }
-            updateReasonRef.current = 'filter';
-            setFilterInfoState(__assign(__assign({}, buildDefaultFilterInfo(ctxRef.current.defaultFilterInfo)), { shouldRunImmediately: shouldRunImmediately }));
-        }, []),
-        setOffset: react_1.useCallback(function (offset, shouldRunImmediately) {
-            if (shouldRunImmediately === void 0) { shouldRunImmediately = false; }
-            updateReasonRef.current = 'pagination';
-            var offsetNumber = Number(offset);
-            setFilterInfoState(function (previous) { 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';
-            var pageNumber = Number(page);
-            setFilterInfoState(function (previous) { 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) {
-                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) { 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; }
-            updateReasonRef.current = 'pagination';
-            setFilterInfoState(function (previous) { 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) { return (__assign(__assign({}, previous), { lastRefreshAt: new Date().getTime(), shouldRunImmediately: shouldRunImmediately })); });
-        }, []),
-    };
-    return api;
-}
-function buildDefaultFilterInfo(filterInfo) {
-    if (filterInfo === void 0) { filterInfo = {}; }
-    var merged = __assign({ 
-        // Cast here to work around "'T' could be instantiated with an arbitrary
-        // type which could be unrelated to '{}'"
-        filter: {}, sort: undefined, pageSize: 20, lastRefreshAt: new Date().getTime(), offset: 0, page: 1, shouldRunImmediately: false }, filterInfo);
-    // If there's a page but no offset, set the offset.
-    if (filterInfo.page != null && filterInfo.offset == null) {
-        merged.offset = getOffsetFromPage_1.default(filterInfo.page, merged.pageSize);
-        // If there's an offset but no page, set the page.
-    }
-    else if (filterInfo.page == null && filterInfo.offset != null) {
-        merged.page = getPageFromOffset_1.default(filterInfo.offset, merged.pageSize);
-    }
-    return merged;
-}
-exports.default = useSimpleFilter;