@promoboxx/use-filter 1.7.0 → 1.8.0

package/dist/useFilter.d.ts

@@ -2,14 +2,16 @@ declare type MaybePromise<T> = T | Promise<T>;
 interface UseFilterOptions<TFilter, TResult> {
     defaultFilterInfo?: Partial<FilterInfo<TFilter>>;
     shouldForceRunOnMount?: boolean;
-    onChange: (filterInfo: FilterInfo<TFilter>) => MaybePromise<UseFilterOnChangeResult<TFilter, TResult>>;
+    onChange: (filterInfo: FilterInfo<TFilter>, reason: UseFilterUpdateReason) => MaybePromise<UseFilterOnChangeResult<TFilter, TResult>>;
     debounceDuration?: number;
 }
+export declare type UseFilterUpdateReason = 'initial' | 'filter' | 'pagination';
 declare function useFilter<TFilter, TResult>(namespace: string, options: UseFilterOptions<TFilter, TResult>): {
     isLoading: boolean;
     data: TResult | null | undefined;
     doesFilterExist: boolean;
     filterInfo: FilterInfo<TFilter>;
+    updateReason: UseFilterUpdateReason;
     updateFilter: (filter: Partial<TFilter>, shouldRunImmediately?: boolean) => void;
     resetFilter: (shouldRunImmediately?: boolean) => void;
     setOffset: (offset: number | string, shouldRunImmediately?: boolean) => void;

package/dist/useFilter.js

@@ -64,6 +64,7 @@ function useFilter(namespace, options) {
         : filterInfo
             ? filterInfo.lastRefreshAt
             : -1);
+    var updateReasonRef = react_1.useRef('initial');
     // Call onChange when data changes.
     react_1.useEffect(function () {
         setIsLoading(true);
@@ -80,7 +81,7 @@ function useFilter(namespace, options) {
         }
         var makeRequest = function () {
             lastRefreshAtRef.current = filterInfo.lastRefreshAt;
-            var response = ctxRef.current.onChange(filterInfo);
+            var response = ctxRef.current.onChange(filterInfo, updateReasonRef.current);
             store_1.getFilterStore().saveFilter(namespace, filterInfo);
             if (!response) {
                 setIsLoading(false);
@@ -153,8 +154,10 @@ function useFilter(namespace, options) {
         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);
@@ -166,10 +169,12 @@ function useFilter(namespace, options) {
         }, []),
         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);
@@ -178,6 +183,7 @@ function useFilter(namespace, options) {
         }, []),
         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);
@@ -186,6 +192,7 @@ function useFilter(namespace, options) {
         }, []),
         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);
@@ -196,6 +203,7 @@ function useFilter(namespace, options) {
         }, []),
         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 });
@@ -204,12 +212,14 @@ function useFilter(namespace, options) {
         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 });

package/dist/useSimpleFilter.d.ts

@@ -1,3 +1,4 @@
+import { UseFilterUpdateReason } from './useFilter';
 export interface SimpleFilterInfo<TFilter> {
     filter: TFilter;
     sort?: string;
@@ -34,6 +35,7 @@ declare function useSimpleFilter<TFilter>(namespace: string, options: UseSimpleF
         lastRefreshAt: number;
         cursor?: string | null | undefined;
     };
+    updateReason: UseFilterUpdateReason;
     updateFilter: (filter: Partial<TFilter>, shouldRunImmediately?: any) => void;
     pagingInfo: (total: string | number | null | undefined) => {
         totalResults: number;

package/dist/useSimpleFilter.js

@@ -37,6 +37,7 @@ function useSimpleFilter(namespace, options) {
     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);
@@ -69,8 +70,10 @@ function useSimpleFilter(namespace, options) {
         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)) {
@@ -92,20 +95,24 @@ function useSimpleFilter(namespace, options) {
         }, [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);
@@ -115,14 +122,17 @@ function useSimpleFilter(namespace, options) {
         }, []),
         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 })); });
         }, []),
     };

package/package.json

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