@promoboxx/use-filter 1.0.2 → 1.0.5

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 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.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)
 
 

package/dist/lib/buildDefaultFilterInfo.d.ts

@@ -0,0 +1,3 @@
+import { FilterInfo } from '../useFilter';
+declare function buildDefaultFilterInfo<T>(filterInfo?: Partial<FilterInfo<T>>): FilterInfo<T>;
+export default buildDefaultFilterInfo;

package/dist/lib/buildDefaultFilterInfo.js

@@ -0,0 +1,35 @@
+"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 getOffsetFromPage_1 = __importDefault(require("./getOffsetFromPage"));
+var getPageFromOffset_1 = __importDefault(require("./getPageFromOffset"));
+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(), totalResults: 1, totalPages: 1, offset: 0, page: 1 }, 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 = buildDefaultFilterInfo;

package/dist/lib/getOffsetFromPage.d.ts

@@ -0,0 +1,2 @@
+declare function getOffsetFromPage(page: number, pageSize: number): number;
+export default getOffsetFromPage;

package/dist/lib/getOffsetFromPage.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getOffsetFromPage(page, pageSize) {
+    return pageSize * (page - 1);
+}
+exports.default = getOffsetFromPage;

package/dist/lib/getPageFromOffset.d.ts

@@ -0,0 +1,2 @@
+declare function getPageFromOffset(offset: number, pageSize: number): number;
+export default getPageFromOffset;

package/dist/lib/getPageFromOffset.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getPageFromOffset(offset, pageSize) {
+    return Math.floor(offset / pageSize) + 1;
+}
+exports.default = getPageFromOffset;

package/dist/lib/shallowEqual.d.ts

@@ -0,0 +1,2 @@
+declare const shallowEqual: (objA: any, objB: any) => boolean;
+export default shallowEqual;

package/dist/lib/shallowEqual.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var shallowEqual = function (objA, objB) {
+    if (Object.is(objA, objB)) {
+        return true;
+    }
+    if (typeof objA !== 'object' || !objA || typeof objB !== 'object' || !objB) {
+        return false;
+    }
+    var keysA = Object.keys(objA);
+    var keysB = Object.keys(objB);
+    if (keysA.length !== keysB.length) {
+        return false;
+    }
+    for (var _i = 0, keysA_1 = keysA; _i < keysA_1.length; _i++) {
+        var key = keysA_1[_i];
+        if (!Object.is(objA[key], objB[key])) {
+            return false;
+        }
+    }
+    return true;
+};
+exports.default = shallowEqual;

package/dist/lib/shallowEqual.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/shallowEqual.test.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var shallowEqual_1 = __importDefault(require("./shallowEqual"));
+describe('shallowEqual', function () {
+    it('should return true if arguments fields are equal', function () {
+        expect(shallowEqual_1.default({ a: 1, b: 2, c: undefined }, { a: 1, b: 2, c: undefined })).toBe(true);
+        expect(shallowEqual_1.default({ a: 1, b: 2, c: 3 }, { a: 1, b: 2, c: 3 })).toBe(true);
+        var o = {};
+        expect(shallowEqual_1.default({ a: 1, b: 2, c: o }, { a: 1, b: 2, c: o })).toBe(true);
+        var d = function () {
+            return 1;
+        };
+        expect(shallowEqual_1.default({ a: 1, b: 2, c: o, d: d }, { a: 1, b: 2, c: o, d: d })).toBe(true);
+    });
+    it('should return false if arguments fields are different function identities', function () {
+        expect(shallowEqual_1.default({
+            a: 1,
+            b: 2,
+            d: function () {
+                return 1;
+            },
+        }, {
+            a: 1,
+            b: 2,
+            d: function () {
+                return 1;
+            },
+        })).toBe(false);
+    });
+    it('should return false if first argument has too many keys', function () {
+        expect(shallowEqual_1.default({ a: 1, b: 2, c: 3 }, { a: 1, b: 2 })).toBe(false);
+    });
+    it('should return false if second argument has too many keys', function () {
+        expect(shallowEqual_1.default({ a: 1, b: 2 }, { a: 1, b: 2, c: 3 })).toBe(false);
+    });
+    it('should return false if arguments have different keys', function () {
+        expect(shallowEqual_1.default({ a: 1, b: 2, c: undefined }, { a: 1, bb: 2, c: undefined })).toBe(false);
+    });
+    it('should compare two NaN values', function () {
+        expect(shallowEqual_1.default(NaN, NaN)).toBe(true);
+    });
+    it('should compare empty objects, with false', function () {
+        expect(shallowEqual_1.default({}, false)).toBe(false);
+        expect(shallowEqual_1.default(false, {})).toBe(false);
+        expect(shallowEqual_1.default([], false)).toBe(false);
+        expect(shallowEqual_1.default(false, [])).toBe(false);
+    });
+    it('should compare two zero values', function () {
+        expect(shallowEqual_1.default(0, 0)).toBe(true);
+    });
+});

package/dist/store/index.d.ts

@@ -0,0 +1,8 @@
+import { FilterInfo } from '../useFilter';
+export interface FilterStore {
+    getFilter(namespace: string): FilterInfo<any> | null | undefined;
+    saveFilter(namespace: string, filter: FilterInfo<any>): void;
+    clear(): void;
+}
+export declare function setFilterStore(newStore: FilterStore): void;
+export declare function getFilterStore(): FilterStore;

package/dist/store/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFilterStore = exports.setFilterStore = void 0;
+var store;
+function setFilterStore(newStore) {
+    store = newStore;
+}
+exports.setFilterStore = setFilterStore;
+function getFilterStore() {
+    if (!store) {
+        throw new Error('A store must be set with setFilterStore');
+    }
+    return store;
+}
+exports.getFilterStore = getFilterStore;

package/dist/store/memoryStore.d.ts

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

package/dist/store/memoryStore.js

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

package/dist/useFilter.d.ts

@@ -0,0 +1,37 @@
+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>>;
+    debounceDuration?: number;
+}
+declare function useFilter<T>(namespace: string, options: UseFilterOptions<T, any>): {
+    isLoading: boolean;
+    doesFilterExist: boolean;
+    filterInfo: FilterInfo<T>;
+    updateFilter(filter: T): 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> {
+    filter: TFilter;
+    offset: number;
+    page: number;
+    sort?: string;
+    pageSize: number;
+    lastRefreshAt: number;
+    totalResults: number;
+    totalPages: number;
+}
+declare type UseFilterOnChangeResult<TFilter, TResult> = void | {
+    filterInfo?: Partial<Omit<FilterInfo<TFilter>, 'totalResults' | 'offset' | 'pageSize'> & {
+        totalResults: string | number;
+        offset: string | number;
+        pageSize: string | number;
+    }>;
+    data?: TResult;
+};

package/dist/useFilter.js

@@ -0,0 +1,184 @@
+"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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+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 buildDefaultFilterInfo_1 = __importDefault(require("./lib/buildDefaultFilterInfo"));
+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 useFilter(namespace, options) {
+    var _a = react_1.useState(function () { return store_1.getFilterStore().getFilter(namespace); }), filterInfo = _a[0], setFilterInfoState = _a[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({
+        namespace: namespace,
+        onChange: options.onChange,
+        debounceDuration: options.debounceDuration,
+        defaultFilterInfo: options.defaultFilterInfo,
+    });
+    var _b = react_1.useState(!filterInfo), isLoading = _b[0], setIsLoading = _b[1];
+    var doesFilterExist = react_1.useRef(!!filterInfo);
+    var lastRefreshAtRef = react_1.useRef(
+    // if shouldForceRunOnMount is set, always use -1
+    // otherwise, try grabbing lastRefreshAt
+    // then, just use -1 cause there's no other option
+    options.shouldForceRunOnMount
+        ? -1
+        : filterInfo
+            ? filterInfo.lastRefreshAt
+            : -1);
+    // Call onChange when data changes.
+    react_1.useEffect(function () {
+        setIsLoading(true);
+        // 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));
+            return;
+        }
+        // If the lastRefreshAt hasn't changed, don't make a request.
+        if (lastRefreshAtRef.current === filterInfo.lastRefreshAt) {
+            setIsLoading(false);
+            return;
+        }
+        var timeout = setTimeout(function () {
+            lastRefreshAtRef.current = filterInfo.lastRefreshAt;
+            var response = ctxRef.current.onChange(filterInfo);
+            store_1.getFilterStore().saveFilter(namespace, filterInfo);
+            if (!response) {
+                setIsLoading(false);
+                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);
+                    }
+                    // TODO Don't do anther request here????
+                    setFilterInfo(__assign(__assign(__assign({}, filterInfo), filterInfoFromResponse), extra), true);
+                }
+            }
+            if (isPromise(response)) {
+                response.then(handleResponse).finally(function () { return setIsLoading(false); });
+            }
+            else {
+                handleResponse(response);
+                setIsLoading(false);
+            }
+        }, ctxRef.current.debounceDuration != null
+            ? ctxRef.current.debounceDuration
+            : 500);
+        return function () {
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+        };
+    }, [filterInfo, setFilterInfo, namespace]);
+    return {
+        isLoading: isLoading,
+        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() }));
+        },
+    };
+}
+exports.default = useFilter;
+function isPromise(t) {
+    return !!(t === null || t === void 0 ? void 0 : t.then);
+}

package/dist/useFilter.test.d.ts

@@ -0,0 +1 @@
+export {};