@promoboxx/use-filter 1.5.0 → 1.5.3

package/dist/useFilter.d.ts

@@ -10,12 +10,12 @@ declare function useFilter<TFilter, TResult>(namespace: string, options: UseFilt
     data: TResult | null | undefined;
     doesFilterExist: boolean;
     filterInfo: FilterInfo<TFilter>;
-    updateFilter: (filter: Partial<TFilter>, shouldRunImmediately?: any) => void;
-    resetFilter: () => void;
-    setOffset: (offset: number | string) => void;
-    setPage: (page: number | string) => void;
-    setSort: (sort: string | undefined) => void;
-    forceRefresh: () => void;
+    updateFilter: (filter: Partial<TFilter>, shouldRunImmediately?: boolean) => void;
+    resetFilter: (shouldRunImmediately?: boolean) => void;
+    setOffset: (offset: number | string, shouldRunImmediately?: boolean) => void;
+    setPage: (page: number | string, shouldRunImmediately?: boolean) => void;
+    setSort: (sort: string | undefined, shouldRunImmediately?: boolean) => void;
+    forceRefresh: (shouldRunImmediately?: boolean) => void;
 };
 export default useFilter;
 export interface FilterInfo<TFilter> {

package/dist/useFilter.js

@@ -158,33 +158,38 @@ function useFilter(namespace, options) {
                 return __assign(__assign({}, previous), { offset: 0, page: 1, totalResults: 1, totalPages: 1, filter: nextFilter, lastRefreshAt: new Date().getTime(), shouldRunImmediately: shouldRunImmediately });
             });
         }, []),
-        resetFilter: react_1.useCallback(function () {
-            setFilterInfoState(__assign(__assign({}, buildDefaultFilterInfo_1.default(ctxRef.current.defaultFilterInfo)), { shouldRunImmediately: true, lastRefreshAt: new Date().getTime() }));
+        resetFilter: react_1.useCallback(function (shouldRunImmediately) {
+            if (shouldRunImmediately === void 0) { shouldRunImmediately = false; }
+            setFilterInfoState(__assign(__assign({}, buildDefaultFilterInfo_1.default(ctxRef.current.defaultFilterInfo)), { lastRefreshAt: new Date().getTime(), shouldRunImmediately: shouldRunImmediately }));
         }, []),
-        setOffset: react_1.useCallback(function (offset) {
+        setOffset: react_1.useCallback(function (offset, shouldRunImmediately) {
+            if (shouldRunImmediately === void 0) { shouldRunImmediately = false; }
             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() });
+                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) {
+        setPage: react_1.useCallback(function (page, shouldRunImmediately) {
+            if (shouldRunImmediately === void 0) { shouldRunImmediately = false; }
             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() });
+                return __assign(__assign({}, previous), { offset: getOffsetFromPage_1.default(pageNumber, previous.pageSize), page: pageNumber, lastRefreshAt: new Date().getTime(), shouldRunImmediately: shouldRunImmediately });
             });
         }, []),
-        setSort: react_1.useCallback(function (sort) {
+        setSort: react_1.useCallback(function (sort, shouldRunImmediately) {
+            if (shouldRunImmediately === void 0) { shouldRunImmediately = false; }
             setFilterInfoState(function (previous) {
                 invariant(previous != null, 'setSort called without filterInfo');
-                return __assign(__assign({}, previous), { sort: sort, lastRefreshAt: new Date().getTime() });
+                return __assign(__assign({}, previous), { sort: sort, lastRefreshAt: new Date().getTime(), shouldRunImmediately: shouldRunImmediately });
             });
         }, []),
-        forceRefresh: react_1.useCallback(function () {
+        forceRefresh: react_1.useCallback(function (shouldRunImmediately) {
+            if (shouldRunImmediately === void 0) { shouldRunImmediately = false; }
             setFilterInfoState(function (previous) {
                 invariant(previous != null, 'forceRefresh called without filterInfo');
-                return __assign(__assign({}, previous), { lastRefreshAt: new Date().getTime() });
+                return __assign(__assign({}, previous), { lastRefreshAt: new Date().getTime(), shouldRunImmediately: shouldRunImmediately });
             });
         }, []),
     };

package/dist/useSimpleFilter.d.ts

@@ -0,0 +1,45 @@
+export interface SimpleFilterInfo<TFilter> {
+    filter: TFilter;
+    sort?: string;
+    offset: number;
+    page: number;
+    pageSize: number;
+    lastRefreshAt: number;
+    shouldRunImmediately: boolean;
+}
+interface UseSimpleFilterOptions<TFilter> {
+    defaultFilterInfo?: Partial<SimpleFilterInfo<TFilter>>;
+    debounceDuration?: number;
+}
+declare function useSimpleFilter<TFilter>(namespace: string, options: UseSimpleFilterOptions<TFilter>): {
+    isLoading: boolean;
+    filterInfo: {
+        shouldRunImmediately: boolean;
+        filter: TFilter;
+        sort?: string | undefined;
+        offset: number;
+        page: number;
+        pageSize: number;
+        lastRefreshAt: number;
+    };
+    debouncedFilterInfo: {
+        shouldRunImmediately: boolean;
+        filter: TFilter;
+        sort?: string | undefined;
+        offset: number;
+        page: number;
+        pageSize: number;
+        lastRefreshAt: number;
+    };
+    updateFilter: (filter: Partial<TFilter>, shouldRunImmediately?: any) => void;
+    pagingInfo: (total: string | number | null | undefined) => {
+        totalResults: number;
+        totalPages: number;
+    };
+    resetFilter: (shouldRunImmediately?: boolean) => void;
+    setOffset: (offset: number | string, shouldRunImmediately?: boolean) => void;
+    setPage: (page: number | string, shouldRunImmediately?: boolean) => void;
+    setSort: (sort: string, shouldRunImmediately?: boolean) => void;
+    forceRefresh: (shouldRunImmediately?: boolean) => void;
+};
+export default useSimpleFilter;

package/dist/useSimpleFilter.js

@@ -0,0 +1,133 @@
+"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,
+    };
+    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 () { return (__assign(__assign({}, (store_1.getFilterStore().getFilter(namespace) ||
+        buildDefaultFilterInfo(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);
+    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().saveFilter(ctxRef.current.namespace, 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);
+    return {
+        isLoading: isLoading,
+        filterInfo: filterInfo,
+        debouncedFilterInfo: debouncedFilterInfo,
+        updateFilter: react_1.useCallback(function (filter, shouldRunImmediately) {
+            if (shouldRunImmediately === void 0) { shouldRunImmediately = false; }
+            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, 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; }
+            setFilterInfoState(__assign(__assign({}, buildDefaultFilterInfo(ctxRef.current.defaultFilterInfo)), { shouldRunImmediately: shouldRunImmediately }));
+        }, []),
+        setOffset: react_1.useCallback(function (offset, shouldRunImmediately) {
+            if (shouldRunImmediately === void 0) { shouldRunImmediately = false; }
+            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; }
+            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 })); });
+        }, []),
+        setSort: react_1.useCallback(function (sort, shouldRunImmediately) {
+            if (shouldRunImmediately === void 0) { shouldRunImmediately = false; }
+            setFilterInfoState(function (previous) { return (__assign(__assign({}, previous), { sort: sort, lastRefreshAt: new Date().getTime(), shouldRunImmediately: shouldRunImmediately })); });
+        }, []),
+        forceRefresh: react_1.useCallback(function (shouldRunImmediately) {
+            if (shouldRunImmediately === void 0) { shouldRunImmediately = false; }
+            setFilterInfoState(function (previous) { return (__assign(__assign({}, previous), { lastRefreshAt: new Date().getTime(), shouldRunImmediately: shouldRunImmediately })); });
+        }, []),
+    };
+}
+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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@promoboxx/use-filter",
-  "version": "1.5.0",
+  "version": "1.5.3",
   "description": "",
   "main": "dist/useFilter.js",
   "keywords": [],
@@ -21,27 +21,29 @@
     "typescript": "^4.3.5"
   },
   "files": [
+    "dist/lib/getOffsetFromPage.d.ts",
+    "dist/lib/getPageFromOffset.d.ts",
+    "dist/lib/getPageFromOffset.js",
+    "dist/lib/shallowEqual.d.ts",
+    "dist/lib/shallowEqual.js",
+    "dist/lib/buildDefaultFilterInfo.d.ts",
+    "dist/lib/getOffsetFromPage.js",
+    "dist/lib/buildDefaultFilterInfo.js",
     "dist/useFilter.d.ts",
+    "dist/useFilter.js",
+    "dist/useSimpleFilter.d.ts",
+    "dist/useSimpleFilter.js",
+    "dist/store/memoryStore.d.ts",
+    "dist/store/reduxStore.d.ts",
+    "dist/store/localStorageStore.d.ts",
+    "dist/store/reduxHelpers/createReducer.d.ts",
     "dist/store/reduxHelpers/createActions.d.ts",
-    "dist/store/reduxHelpers/createReducer.js",
     "dist/store/reduxHelpers/createActions.js",
-    "dist/store/reduxHelpers/createReducer.d.ts",
-    "dist/store/reduxStore.d.ts",
+    "dist/store/reduxHelpers/createReducer.js",
     "dist/store/index.d.ts",
     "dist/store/index.js",
     "dist/store/localStorageStore.js",
     "dist/store/memoryStore.js",
-    "dist/store/reduxStore.js",
-    "dist/store/memoryStore.d.ts",
-    "dist/store/localStorageStore.d.ts",
-    "dist/useFilter.js",
-    "dist/lib/buildDefaultFilterInfo.js",
-    "dist/lib/shallowEqual.js",
-    "dist/lib/getOffsetFromPage.js",
-    "dist/lib/buildDefaultFilterInfo.d.ts",
-    "dist/lib/getOffsetFromPage.d.ts",
-    "dist/lib/getPageFromOffset.js",
-    "dist/lib/shallowEqual.d.ts",
-    "dist/lib/getPageFromOffset.d.ts"
+    "dist/store/reduxStore.js"
   ]
 }