@promoboxx/use-filter 1.5.1 → 1.5.4

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

@@ -33,7 +33,10 @@ var shallowEqual_1 = __importDefault(require("./lib/shallowEqual"));
 var store_1 = require("./store");
 function useFilter(namespace, options) {
     var _a = react_1.useState(function () {
-        return store_1.getFilterStore().getFilter(namespace);
+        var existing = store_1.getFilterStore().getFilter(namespace);
+        var initialValue = existing
+            ? __assign(__assign({}, existing), { shouldRunImmediately: true }) : undefined;
+        return initialValue;
     }), filterInfo = _a[0], setFilterInfoState = _a[1];
     var _b = react_1.useState(function () {
         return store_1.getFilterStore().getData(namespace);
@@ -158,33 +161,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

@@ -13,17 +13,33 @@ interface UseSimpleFilterOptions<TFilter> {
 }
 declare function useSimpleFilter<TFilter>(namespace: string, options: UseSimpleFilterOptions<TFilter>): {
     isLoading: boolean;
-    filterInfo: SimpleFilterInfo<TFilter>;
-    debouncedFilterInfo: SimpleFilterInfo<TFilter>;
+    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?: any) => void;
-    setOffset: (offset: number | string, shouldRunImmediately?: any) => void;
-    setPage: (page: number | string, shouldRunImmediately?: any) => void;
-    setSort: (sort: string, shouldRunImmediately?: any) => void;
-    forceRefresh: (shouldRunImmediately?: any) => void;
+    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

@@ -32,10 +32,8 @@ function useSimpleFilter(namespace, options) {
         ctxRef.current = ctxRefValue;
     });
     var _a = react_1.useState(false), isLoading = _a[0], setIsLoading = _a[1];
-    var _b = react_1.useState(function () {
-        return store_1.getFilterStore().getFilter(namespace) ||
-            buildDefaultFilterInfo(options.defaultFilterInfo);
-    }), filterInfo = _b[0], setFilterInfoState = _b[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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@promoboxx/use-filter",
-  "version": "1.5.1",
+  "version": "1.5.4",
   "description": "",
   "main": "dist/useFilter.js",
   "keywords": [],