@promoboxx/use-filter 1.2.0 → 1.4.0

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/localStorageStore.d.ts

@@ -0,0 +1,3 @@
+import { FilterStore } from '.';
+declare const localStorageStore: FilterStore;
+export default localStorageStore;

package/dist/store/localStorageStore.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var prefix = 'useFilter';
+var localStorageStore = {
+    getFilter: function (namespace) {
+        var item = localStorage.getItem(prefix + "/" + namespace + "/filter");
+        if (item) {
+            return JSON.parse(item);
+        }
+    },
+    saveFilter: function (namespace, filter) {
+        localStorage.setItem(prefix + "/" + namespace + "/filter", JSON.stringify(filter));
+    },
+    getData: function (namespace) {
+        var item = localStorage.getItem(prefix + "/" + namespace + "/data");
+        if (item) {
+            return JSON.parse(item);
+        }
+    },
+    saveData: function (namespace, data) {
+        localStorage.setItem(prefix + "/" + namespace + "/data", JSON.stringify(data));
+    },
+    clear: function () {
+        for (var key in localStorage) {
+            if (key.startsWith(prefix)) {
+                localStorage.removeItem(key);
+            }
+        }
+    },
+};
+exports.default = localStorageStore;

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/store/reduxHelpers/createActions.d.ts

@@ -0,0 +1,16 @@
+interface CreateActions {
+    <Namespace extends string, PayloadCreatorMap extends ReduxPayloadCreatorMap>(namespace: Namespace, actions: PayloadCreatorMap): ReduxActionCreatorMap<Namespace, PayloadCreatorMap>;
+}
+declare type ReduxPayloadCreatorMap = Record<string, (...args: any[]) => any>;
+export declare type ReduxActionCreatorMap<Namespace extends string, PayloadCreatorMap extends ReduxPayloadCreatorMap> = {
+    [Type in keyof PayloadCreatorMap]: Type extends string ? ReduxActionCreator<Namespace, Type, PayloadCreatorMap[Type]> : undefined;
+};
+export interface ReduxActionCreator<Namespace extends string = string, Type extends string = string, Fn extends (...args: any[]) => any = (...args: any[]) => any> {
+    (...args: Parameters<Fn>): {
+        type: `${Namespace}/${Type}`;
+        payload: ReturnType<Fn>;
+    };
+    actionType: `${Namespace}/${Type}`;
+}
+declare const createActions: CreateActions;
+export default createActions;

package/dist/store/reduxHelpers/createActions.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var createActions = function (namespace, payloadCreatorMap) {
+    var actionCreators = {};
+    var _loop_1 = function (key) {
+        actionCreators[key] = (function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return ({
+                type: namespace + "/" + key,
+                payload: payloadCreatorMap[key].apply(payloadCreatorMap, args),
+                // Need to cast here because there's no way to assign a function + extra
+                // attributes in one go.
+            });
+        });
+        actionCreators[key].actionType = namespace + "/" + key;
+    };
+    for (var key in payloadCreatorMap) {
+        _loop_1(key);
+    }
+    // TODO There's probably a better type to use here, but it's not super
+    // important since `CreateActions` already specifies one.
+    return actionCreators;
+};
+exports.default = createActions;

package/dist/store/reduxHelpers/createReducer.d.ts

@@ -0,0 +1,8 @@
+import { Action } from 'redux';
+import { ReduxActionCreator } from './createActions';
+interface ReduxReducerBuilder<State> {
+    addHandler: <ActionCreator extends ReduxActionCreator>(actionCreator: ActionCreator, handler: (state: State, action: ReturnType<ActionCreator>) => State) => ReduxReducerBuilder<State>;
+    addCase: <HandlerAction extends Action>(actionType: string, handler: (state: State, action: HandlerAction) => State) => ReduxReducerBuilder<State>;
+}
+declare function createReducer<State>(initialState: State, builderFn: (builder: ReduxReducerBuilder<State>) => void): (state: State | undefined, action: Action) => State;
+export default createReducer;

package/dist/store/reduxHelpers/createReducer.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function createReducer(initialState, builderFn) {
+    var handlers = {};
+    var builder = {
+        addHandler: function (actionCreator, handler) {
+            // TODO There's probably a better type to use here.
+            handlers[actionCreator.actionType] = handler;
+            return builder;
+        },
+        addCase: function (actionType, handler) {
+            // TODO There's probably a better type to use here.
+            handlers[actionType] = handler;
+            return builder;
+        },
+    };
+    builderFn(builder);
+    return function (state, action) {
+        if (state === void 0) { state = initialState; }
+        if (handlers[action.type]) {
+            return handlers[action.type](state, action);
+        }
+        return state;
+    };
+}
+exports.default = createReducer;

package/dist/store/reduxStore.d.ts

@@ -0,0 +1,15 @@
+import { Store } from 'redux';
+import { FilterInfo } from '../useFilter';
+import { FilterStore } from '.';
+interface CreateReduxStoreConfig {
+    store: Store<{
+        useFilter: UseFilterReduxState;
+    }>;
+}
+export declare function createReduxStore(config: CreateReduxStoreConfig): FilterStore;
+interface UseFilterReduxState {
+    data: Record<string, any>;
+    filters: Record<string, FilterInfo<any>>;
+}
+export declare const useFilterReduxReducer: (state: UseFilterReduxState | undefined, action: import("redux").Action<any>) => UseFilterReduxState;
+export {};

package/dist/store/reduxStore.js

@@ -0,0 +1,67 @@
+"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 });
+exports.useFilterReduxReducer = exports.createReduxStore = void 0;
+var createActions_1 = __importDefault(require("./reduxHelpers/createActions"));
+var createReducer_1 = __importDefault(require("./reduxHelpers/createReducer"));
+function createReduxStore(config) {
+    var reduxStoreStore = {
+        getFilter: function (namespace) {
+            return config.store.getState().useFilter.filters[namespace];
+        },
+        saveFilter: function (namespace, filter) {
+            config.store.dispatch(actions.saveFilter(namespace, filter));
+        },
+        getData: function (namespace) {
+            return config.store.getState().useFilter.data[namespace];
+        },
+        saveData: function (namespace, data) {
+            config.store.dispatch(actions.saveData(namespace, data));
+        },
+        clear: function () {
+            config.store.dispatch(actions.clear());
+        },
+    };
+    return reduxStoreStore;
+}
+exports.createReduxStore = createReduxStore;
+var actions = createActions_1.default('useFilter', {
+    saveData: function (namespace, data) { return ({
+        namespace: namespace,
+        data: data,
+    }); },
+    saveFilter: function (namespace, filter) { return ({
+        namespace: namespace,
+        filter: filter,
+    }); },
+    clear: function () { return undefined; },
+});
+var initialState = {
+    data: {},
+    filters: {},
+};
+exports.useFilterReduxReducer = createReducer_1.default(initialState, function (builder) {
+    builder
+        .addHandler(actions.saveFilter, function (state, action) {
+        var _a;
+        return (__assign(__assign({}, state), { filters: __assign(__assign({}, state.filters), (_a = {}, _a[action.payload.namespace] = action.payload.filter, _a)) }));
+    })
+        .addHandler(actions.saveData, function (state, action) {
+        var _a;
+        return (__assign(__assign({}, state), { data: __assign(__assign({}, state.data), (_a = {}, _a[action.payload.namespace] = action.payload.data, _a)) }));
+    })
+        .addHandler(actions.clear, function (state) { return (__assign(__assign({}, state), { filters: {}, data: {} })); });
+});

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/package.json

@@ -1,11 +1,8 @@
 {
   "name": "@promoboxx/use-filter",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "",
   "main": "dist/useFilter.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
   "keywords": [],
   "author": "",
   "license": "ISC",
@@ -14,6 +11,7 @@
     "@testing-library/react": "^12.0.0",
     "@types/jest": "^26.0.24",
     "@types/react": "^17.0.14",
+    "@types/redux": "^3.6.0",
     "eslint": "^7.30.0",
     "jest": "^27.0.6",
     "prettier": "^2.3.2",
@@ -24,10 +22,18 @@
   },
   "files": [
     "dist/useFilter.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/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",

package/CHANGELOG.md

@@ -1,49 +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.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)