@promoboxx/use-filter 1.3.0 → 1.5.1

package/dist/lib/buildDefaultFilterInfo.js

@@ -21,7 +21,7 @@ function buildDefaultFilterInfo(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(), totalResults: 1, totalPages: 1, offset: 0, page: 1 }, filterInfo);
+        filter: {}, sort: undefined, pageSize: 20, lastRefreshAt: new Date().getTime(), totalResults: 1, totalPages: 1, 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);

package/dist/store/index.d.ts

@@ -1,9 +1,9 @@
 import { FilterInfo } from '../useFilter';
 export interface FilterStore {
-    getFilter(namespace: string): FilterInfo<any> | null | undefined;
-    saveFilter(namespace: string, filter: FilterInfo<any>): void;
-    getData(namespace: string): any | null | undefined;
-    saveData(namespace: string, data: any): void;
+    getFilter<TFilter = any>(namespace: string): FilterInfo<TFilter> | null | undefined;
+    saveFilter<TFilter = any>(namespace: string, filter: FilterInfo<TFilter>): void;
+    getData<TResult = any>(namespace: string): TResult | null | undefined;
+    saveData<TResult = any>(namespace: string, data: TResult): void;
     clear(): void;
 }
 export declare function setFilterStore(newStore: FilterStore): void;

package/dist/store/memoryStore.js

@@ -1,23 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var filters = {};
-var data = {};
+var cachedFilters = {};
+var cachedData = {};
 var memoryStore = {
     getFilter: function (namespace) {
-        return filters[namespace];
+        return cachedFilters[namespace];
     },
     saveFilter: function (namespace, filter) {
-        filters[namespace] = filter;
+        cachedFilters[namespace] = filter;
     },
     getData: function (namespace) {
-        return data[namespace];
+        return cachedData[namespace];
     },
     saveData: function (namespace, data) {
-        filters[namespace] = data;
+        cachedData[namespace] = data;
     },
     clear: function () {
-        filters = {};
-        data = {};
+        cachedFilters = {};
+        cachedData = {};
     },
 };
 exports.default = memoryStore;

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>): 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?: any) => void;
+    resetFilter: () => void;
+    setOffset: (offset: number | string) => void;
+    setPage: (page: number | string) => void;
+    setSort: (sort: string | undefined) => void;
+    forceRefresh: () => void;
 };
 export default useFilter;
 export interface FilterInfo<TFilter> {
@@ -27,6 +27,7 @@ export interface FilterInfo<TFilter> {
     lastRefreshAt: number;
     totalResults: number;
     totalPages: number;
+    shouldRunImmediately: boolean;
 }
 declare type UseFilterOnChangeResult<TFilter, TResult> = void | {
     filterInfo?: Partial<Omit<FilterInfo<TFilter>, 'totalResults' | 'offset' | 'pageSize'> & {

package/dist/useFilter.js

@@ -32,31 +32,23 @@ var getPageFromOffset_1 = __importDefault(require("./lib/getPageFromOffset"));
 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); }), filterInfo = _a[0], setFilterInfoState = _a[1];
+    var _a = react_1.useState(function () {
+        return store_1.getFilterStore().getFilter(namespace);
+    }), filterInfo = _a[0], setFilterInfoState = _a[1];
     var _b = react_1.useState(function () {
         return store_1.getFilterStore().getData(namespace);
     }), data = _b[0], setData = _b[1];
-    var setFilterInfo = react_1.useCallback(function (filterInfo, skipFetch) {
-        if (skipFetch === void 0) { skipFetch = false; }
-        setFilterInfoState(function (previousFilterInfo) {
-            var lastRefreshAt;
-            if (skipFetch) {
-                lastRefreshAt = previousFilterInfo === null || previousFilterInfo === void 0 ? void 0 : previousFilterInfo.lastRefreshAt;
-            }
-            else {
-                lastRefreshAt = new Date().getTime();
-            }
-            if (!lastRefreshAt) {
-                throw new Error();
-            }
-            return __assign(__assign({}, filterInfo), { lastRefreshAt: lastRefreshAt });
-        });
-    }, []);
-    var ctxRef = react_1.useRef({
+    // 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,
+    };
+    var ctxRef = react_1.useRef(ctxRefValue);
+    react_1.useEffect(function () {
+        ctxRef.current = ctxRefValue;
     });
     var _c = react_1.useState(!filterInfo), isLoading = _c[0], setIsLoading = _c[1];
     var doesFilterExist = react_1.useRef(!!filterInfo);
@@ -75,7 +67,7 @@ function useFilter(namespace, options) {
         // If there is no existing filter info, set it to the defaults and return.
         // This same effect will trigger next go.
         if (!filterInfo) {
-            setFilterInfo(buildDefaultFilterInfo_1.default(ctxRef.current.defaultFilterInfo));
+            setFilterInfoState(__assign(__assign({}, buildDefaultFilterInfo_1.default(ctxRef.current.defaultFilterInfo)), { shouldRunImmediately: true }));
             return;
         }
         // If the lastRefreshAt hasn't changed, don't make a request.
@@ -83,7 +75,7 @@ function useFilter(namespace, options) {
             setIsLoading(false);
             return;
         }
-        var timeout = setTimeout(function () {
+        var makeRequest = function () {
             lastRefreshAtRef.current = filterInfo.lastRefreshAt;
             var response = ctxRef.current.onChange(filterInfo);
             store_1.getFilterStore().saveFilter(namespace, filterInfo);
@@ -92,31 +84,35 @@ function useFilter(namespace, options) {
                 return;
             }
             function handleResponse(response) {
-                if (!filterInfo) {
-                    return;
-                }
                 if (!response) {
                     return;
                 }
                 if (response.filterInfo) {
-                    var extra = {};
-                    var _a = response.filterInfo, page = _a.page, offset = _a.offset, totalResults = _a.totalResults, pageSize = _a.pageSize, filterInfoFromResponse = __rest(_a, ["page", "offset", "totalResults", "pageSize"]);
-                    var pageSizeNumber = Number(pageSize || filterInfo.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);
-                    }
-                    if (totalResults) {
-                        extra.totalResults = Number(totalResults);
-                        extra.totalPages = Math.ceil(extra.totalResults / pageSizeNumber);
-                    }
-                    setFilterInfo(__assign(__assign(__assign({}, filterInfo), filterInfoFromResponse), extra), true);
+                    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, filterInfoFromResponse = __rest(_a, ["page", "offset", "totalResults", "pageSize"]);
+                        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);
+                        }
+                        if (totalResults) {
+                            extra.totalResults = Number(totalResults);
+                            extra.totalPages = Math.ceil(extra.totalResults / pageSizeNumber);
+                        }
+                        return __assign(__assign(__assign({}, previous), filterInfoFromResponse), extra);
+                    });
                 }
                 if (response.data) {
                     setData(response.data);
@@ -130,62 +126,75 @@ function useFilter(namespace, options) {
                 handleResponse(response);
                 setIsLoading(false);
             }
-        }, ctxRef.current.debounceDuration != null
-            ? ctxRef.current.debounceDuration
-            : 500);
+        };
+        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, setFilterInfo, namespace]);
+    }, [filterInfo, namespace]);
     return {
         isLoading: isLoading,
         data: data,
         doesFilterExist: doesFilterExist.current,
         filterInfo: filterInfo || buildDefaultFilterInfo_1.default(options.defaultFilterInfo),
-        updateFilter: function (filter) {
-            if (!filterInfo) {
-                throw new Error();
-            }
-            var nextFilter = __assign(__assign({}, filterInfo.filter), filter);
-            if (shallowEqual_1.default(filterInfo.filter, nextFilter)) {
-                return;
-            }
-            setFilterInfo(__assign(__assign({}, filterInfo), { offset: 0, page: 1, totalResults: 1, totalPages: 1, filter: nextFilter }));
-        },
-        resetFilter: function () {
-            setFilterInfo(buildDefaultFilterInfo_1.default(options.defaultFilterInfo));
-        },
-        setOffset: function (offset) {
-            if (!filterInfo) {
-                throw new Error();
-            }
-            var offsetNumber = Number(offset);
-            setFilterInfo(__assign(__assign({}, filterInfo), { offset: offsetNumber, page: getPageFromOffset_1.default(offsetNumber, filterInfo.pageSize) }));
-        },
-        setPage: function (page) {
-            if (!filterInfo) {
-                throw new Error();
-            }
-            var pageNumber = Number(page);
-            setFilterInfo(__assign(__assign({}, filterInfo), { offset: getOffsetFromPage_1.default(pageNumber, filterInfo.pageSize), page: pageNumber }));
-        },
-        setSort: function (sort) {
-            if (!filterInfo) {
-                throw new Error();
-            }
-            setFilterInfo(__assign(__assign({}, filterInfo), { sort: sort }));
-        },
-        forceRefresh: function () {
-            if (!filterInfo) {
-                throw new Error();
-            }
-            setFilterInfo(__assign(__assign({}, filterInfo), { lastRefreshAt: new Date().getTime() }));
-        },
+        updateFilter: react_1.useCallback(function (filter, shouldRunImmediately) {
+            if (shouldRunImmediately === void 0) { shouldRunImmediately = false; }
+            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(), shouldRunImmediately: shouldRunImmediately });
+            });
+        }, []),
+        resetFilter: react_1.useCallback(function () {
+            setFilterInfoState(__assign(__assign({}, buildDefaultFilterInfo_1.default(ctxRef.current.defaultFilterInfo)), { shouldRunImmediately: true, lastRefreshAt: new Date().getTime() }));
+        }, []),
+        setOffset: react_1.useCallback(function (offset) {
+            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() });
+            });
+        }, []),
+        setPage: react_1.useCallback(function (page) {
+            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() });
+            });
+        }, []),
+        setSort: react_1.useCallback(function (sort) {
+            setFilterInfoState(function (previous) {
+                invariant(previous != null, 'setSort called without filterInfo');
+                return __assign(__assign({}, previous), { sort: sort, lastRefreshAt: new Date().getTime() });
+            });
+        }, []),
+        forceRefresh: react_1.useCallback(function () {
+            setFilterInfoState(function (previous) {
+                invariant(previous != null, 'forceRefresh called without filterInfo');
+                return __assign(__assign({}, previous), { lastRefreshAt: new Date().getTime() });
+            });
+        }, []),
     };
 }
 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

@@ -0,0 +1,29 @@
+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: SimpleFilterInfo<TFilter>;
+    debouncedFilterInfo: SimpleFilterInfo<TFilter>;
+    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;
+};
+export default useSimpleFilter;

package/dist/useSimpleFilter.js

@@ -0,0 +1,135 @@
+"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 store_1.getFilterStore().getFilter(namespace) ||
+            buildDefaultFilterInfo(options.defaultFilterInfo);
+    }), 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.3.0",
+  "version": "1.5.1",
   "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"
   ]
 }

package/CHANGELOG.md

@@ -1,63 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
-
-## 1.3.0 (2021-07-18)
-
-
-### Features
-
-* Redux store ([#5](https://github.com/promoboxx/use-filter/issues/5)) ([f92bee6](https://github.com/promoboxx/use-filter/commit/f92bee6417f78117ab9ca4936c23b24647aac008))
-
-### 1.2.1 (2021-07-17)
-
-
-### Bug Fixes
-
-* some git stuff is needed ([2bb0f21](https://github.com/promoboxx/use-filter/commit/2bb0f2117c79fd1ba0b6a309db4234caf162f57b))
-
-## 1.2.0 (2021-07-16)
-
-
-### Features
-
-* Add localStorageStore ([#4](https://github.com/promoboxx/use-filter/issues/4)) ([a6087e2](https://github.com/promoboxx/use-filter/commit/a6087e2f07a3640799b840e128b96838cd8ef150))
-
-## 1.1.0 (2021-07-16)
-
-
-### Features
-
-* Add concept of data to useFilter ([#2](https://github.com/promoboxx/use-filter/issues/2)) ([563c5a9](https://github.com/promoboxx/use-filter/commit/563c5a959cdc22a0f8eba9dbb3dde7802df02b46))
-
-### 1.0.6 (2021-07-16)
-
-
-### Bug Fixes
-
-* dont deploy test files ([500151c](https://github.com/promoboxx/use-filter/commit/500151c04f75139c71baf29b2ad2dccefcd57db7))
-
-### 1.0.5 (2021-07-16)
-
-
-### Bug Fixes
-
-* declaration files ([4ce29e4](https://github.com/promoboxx/use-filter/commit/4ce29e43469ad4ade2d222c3b09f38ad8f89ca4c))
-
-### 1.0.4 (2021-07-16)
-
-
-### Bug Fixes
-
-* more release prep ([daf06ac](https://github.com/promoboxx/use-filter/commit/daf06acc94668fdc7f0905c120f5541b4b2d16e9))
-
-### 1.0.3 (2021-07-16)
-
-### 1.0.2 (2021-07-16)
-
-
-### Bug Fixes
-
-* proper secrets syntax ([afc9fe9](https://github.com/promoboxx/use-filter/commit/afc9fe9b177dda2961d82858ef43cc481f762950))
-
-### 1.0.1 (2021-07-16)