@promoboxx/use-filter 1.11.2 → 2.0.1

package/dist/cjs/_virtual/_rolldown/runtime.js

@@ -0,0 +1,29 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;

package/dist/cjs/lib/buildDefaultFilterInfo.d.ts

@@ -0,0 +1,5 @@
+import { FilterInfo } from "../useFilter.js";
+
+//#region src/lib/buildDefaultFilterInfo.d.ts
+declare function buildDefaultFilterInfo<T extends Record<string, unknown>>(filterInfo?: Partial<FilterInfo<T>>): FilterInfo<T>;
+export = buildDefaultFilterInfo;

package/dist/cjs/lib/buildDefaultFilterInfo.js

@@ -0,0 +1,27 @@
+const require_lib_getOffsetFromPage = require('./getOffsetFromPage.js');
+const require_lib_getPageFromOffset = require('./getPageFromOffset.js');
+
+//#region src/lib/buildDefaultFilterInfo.ts
+function buildDefaultFilterInfo(filterInfo = {}) {
+	const merged = {
+		filter: {},
+		sort: undefined,
+		pageSize: 20,
+		lastRefreshAt: new Date().getTime(),
+		totalResults: 1,
+		totalPages: 1,
+		offset: 0,
+		page: 1,
+		shouldRunImmediately: false,
+		...filterInfo
+	};
+	if (filterInfo.page != null && filterInfo.offset == null) {
+		merged.offset = require_lib_getOffsetFromPage(filterInfo.page, merged.pageSize);
+	} else if (filterInfo.page == null && filterInfo.offset != null) {
+		merged.page = require_lib_getPageFromOffset(filterInfo.offset, merged.pageSize);
+	}
+	return merged;
+}
+
+//#endregion
+module.exports = buildDefaultFilterInfo;

package/dist/{lib → cjs/lib}/getOffsetFromPage.d.ts

@@ -1,2 +1,3 @@
+//#region src/lib/getOffsetFromPage.d.ts
 declare function getOffsetFromPage(page: number, pageSize: number): number;
-export default getOffsetFromPage;
+export = getOffsetFromPage;

package/dist/cjs/lib/getOffsetFromPage.js

@@ -0,0 +1,8 @@
+
+//#region src/lib/getOffsetFromPage.ts
+function getOffsetFromPage(page, pageSize) {
+	return pageSize * (page - 1);
+}
+
+//#endregion
+module.exports = getOffsetFromPage;

package/dist/{lib → cjs/lib}/getPageFromOffset.d.ts

@@ -1,2 +1,3 @@
+//#region src/lib/getPageFromOffset.d.ts
 declare function getPageFromOffset(offset: number, pageSize: number): number;
-export default getPageFromOffset;
+export = getPageFromOffset;

package/dist/cjs/lib/getPageFromOffset.js

@@ -0,0 +1,8 @@
+
+//#region src/lib/getPageFromOffset.ts
+function getPageFromOffset(offset, pageSize) {
+	return Math.floor(offset / pageSize) + 1;
+}
+
+//#endregion
+module.exports = getPageFromOffset;

package/dist/{lib → cjs/lib}/shallowEqual.d.ts

@@ -1,2 +1,3 @@
+//#region src/lib/shallowEqual.d.ts
 declare const shallowEqual: (objA: any, objB: any) => boolean;
-export default shallowEqual;
+export = shallowEqual;

package/dist/cjs/lib/shallowEqual.js

@@ -0,0 +1,24 @@
+
+//#region src/lib/shallowEqual.ts
+const shallowEqual = (objA, objB) => {
+	if (Object.is(objA, objB)) {
+		return true;
+	}
+	if (typeof objA !== "object" || !objA || typeof objB !== "object" || !objB) {
+		return false;
+	}
+	const keysA = Object.keys(objA);
+	const keysB = Object.keys(objB);
+	if (keysA.length !== keysB.length) {
+		return false;
+	}
+	for (const key of keysA) {
+		if (!Object.is(objA[key], objB[key])) {
+			return false;
+		}
+	}
+	return true;
+};
+
+//#endregion
+module.exports = shallowEqual;

package/dist/cjs/store/index.d.ts

@@ -0,0 +1,14 @@
+import { FilterInfo } from "../useFilter.js";
+
+//#region src/store/index.d.ts
+interface FilterStore {
+  getFilter<TFilter extends Record<string, unknown>>(namespace: string): FilterInfo<TFilter> | null | undefined;
+  saveFilter<TFilter extends Record<string, unknown>>(namespace: string, filter: FilterInfo<TFilter>): void;
+  getData<TResult = any>(namespace: string): TResult | null | undefined;
+  saveData<TResult = any>(namespace: string, data: TResult): void;
+  clear(): void;
+}
+declare function setFilterStore(newStore: FilterStore): void;
+declare function getFilterStore(optionalStore?: FilterStore): FilterStore;
+//#endregion
+export { FilterStore, getFilterStore, setFilterStore };

package/dist/cjs/store/index.js

@@ -0,0 +1,18 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/store/index.ts
+let globalStore;
+function setFilterStore(newStore) {
+	globalStore = newStore;
+}
+function getFilterStore(optionalStore) {
+	const resolvedStore = optionalStore || globalStore;
+	if (!resolvedStore) {
+		throw new Error("A store must be set with setFilterStore");
+	}
+	return resolvedStore;
+}
+
+//#endregion
+exports.getFilterStore = getFilterStore;
+exports.setFilterStore = setFilterStore;

package/dist/cjs/store/localStorageStore.d.ts

@@ -0,0 +1,5 @@
+import { FilterStore } from "./index.js";
+
+//#region src/store/localStorageStore.d.ts
+declare const localStorageStore: FilterStore;
+export = localStorageStore;

package/dist/cjs/store/localStorageStore.js

@@ -0,0 +1,33 @@
+
+//#region src/store/localStorageStore.ts
+const prefix = "useFilter";
+const localStorageStore = {
+	getFilter(namespace) {
+		const item = localStorage.getItem(`${prefix}/${namespace}/filter`);
+		if (item) {
+			return JSON.parse(item);
+		}
+	},
+	saveFilter(namespace, filter) {
+		localStorage.setItem(`${prefix}/${namespace}/filter`, JSON.stringify(filter));
+	},
+	getData(namespace) {
+		const item = localStorage.getItem(`${prefix}/${namespace}/data`);
+		if (item) {
+			return JSON.parse(item);
+		}
+	},
+	saveData(namespace, data) {
+		localStorage.setItem(`${prefix}/${namespace}/data`, JSON.stringify(data));
+	},
+	clear() {
+		for (const key in localStorage) {
+			if (key.startsWith(prefix)) {
+				localStorage.removeItem(key);
+			}
+		}
+	}
+};
+
+//#endregion
+module.exports = localStorageStore;

package/dist/cjs/store/memoryStore.d.ts

@@ -0,0 +1,5 @@
+import { FilterStore } from "./index.js";
+
+//#region src/store/memoryStore.d.ts
+declare const memoryStore: FilterStore;
+export = memoryStore;

package/dist/cjs/store/memoryStore.js

@@ -0,0 +1,25 @@
+
+//#region src/store/memoryStore.ts
+let cachedFilters = {};
+let cachedData = {};
+const memoryStore = {
+	getFilter(namespace) {
+		return cachedFilters[namespace];
+	},
+	saveFilter(namespace, filter) {
+		cachedFilters[namespace] = filter;
+	},
+	getData(namespace) {
+		return cachedData[namespace];
+	},
+	saveData(namespace, data) {
+		cachedData[namespace] = data;
+	},
+	clear() {
+		cachedFilters = {};
+		cachedData = {};
+	}
+};
+
+//#endregion
+module.exports = memoryStore;

package/dist/cjs/store/reduxHelpers/createActions.d.ts

@@ -0,0 +1,16 @@
+//#region src/store/reduxHelpers/createActions.d.ts
+interface CreateActions {
+  <Namespace extends string, PayloadCreatorMap extends ReduxPayloadCreatorMap>(namespace: Namespace, actions: PayloadCreatorMap): ReduxActionCreatorMap<Namespace, PayloadCreatorMap>;
+}
+type ReduxPayloadCreatorMap = Record<string, (...args: any[]) => any>;
+type ReduxActionCreatorMap<Namespace extends string, PayloadCreatorMap extends ReduxPayloadCreatorMap> = { [Type in keyof PayloadCreatorMap]: Type extends string ? ReduxActionCreator<Namespace, Type, PayloadCreatorMap[Type]> : undefined };
+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;
+//#endregion
+export { ReduxActionCreator, ReduxActionCreatorMap, createActions as default };

package/dist/cjs/store/reduxHelpers/createActions.js

@@ -0,0 +1,16 @@
+
+//#region src/store/reduxHelpers/createActions.ts
+const createActions = (namespace, payloadCreatorMap) => {
+	const actionCreators = {};
+	for (const key in payloadCreatorMap) {
+		actionCreators[key] = ((...args) => ({
+			type: `${namespace}/${key}`,
+			payload: payloadCreatorMap[key](...args)
+		}));
+		actionCreators[key].actionType = `${namespace}/${key}`;
+	}
+	return actionCreators;
+};
+
+//#endregion
+module.exports = createActions;

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

@@ -0,0 +1,10 @@
+import { ReduxActionCreator } from "./createActions.js";
+import { Action } from "redux";
+
+//#region src/store/reduxHelpers/createReducer.d.ts
+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 = createReducer;

package/dist/cjs/store/reduxHelpers/createReducer.js

@@ -0,0 +1,25 @@
+
+//#region src/store/reduxHelpers/createReducer.ts
+function createReducer(initialState, builderFn) {
+	const handlers = {};
+	const builder = {
+		addHandler: (actionCreator, handler) => {
+			handlers[actionCreator.actionType] = handler;
+			return builder;
+		},
+		addCase: (actionType, handler) => {
+			handlers[actionType] = handler;
+			return builder;
+		}
+	};
+	builderFn(builder);
+	return (state = initialState, action) => {
+		if (handlers[action.type]) {
+			return handlers[action.type](state, action);
+		}
+		return state;
+	};
+}
+
+//#endregion
+module.exports = createReducer;

package/dist/cjs/store/reduxStore.d.ts

@@ -0,0 +1,18 @@
+import { FilterStore } from "./index.js";
+import { FilterInfo } from "../useFilter.js";
+import { Store } from "redux";
+
+//#region src/store/reduxStore.d.ts
+interface CreateReduxStoreConfig {
+  store: Store<{
+    useFilter: UseFilterReduxState;
+  }>;
+}
+declare function createReduxStore(config: CreateReduxStoreConfig): FilterStore;
+interface UseFilterReduxState {
+  data: Record<string, any>;
+  filters: Record<string, FilterInfo<any>>;
+}
+declare const useFilterReduxReducer: (state: UseFilterReduxState | undefined, action: import("redux").Action) => UseFilterReduxState;
+//#endregion
+export { createReduxStore, useFilterReduxReducer };

package/dist/cjs/store/reduxStore.js

@@ -0,0 +1,63 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_store_reduxHelpers_createActions = require('./reduxHelpers/createActions.js');
+const require_store_reduxHelpers_createReducer = require('./reduxHelpers/createReducer.js');
+
+//#region src/store/reduxStore.ts
+function createReduxStore(config) {
+	const reduxStoreStore = {
+		getFilter: (namespace) => {
+			return config.store.getState().useFilter.filters[namespace];
+		},
+		saveFilter: (namespace, filter) => {
+			config.store.dispatch(actions.saveFilter(namespace, filter));
+		},
+		getData: (namespace) => {
+			return config.store.getState().useFilter.data[namespace];
+		},
+		saveData: (namespace, data) => {
+			config.store.dispatch(actions.saveData(namespace, data));
+		},
+		clear: () => {
+			config.store.dispatch(actions.clear());
+		}
+	};
+	return reduxStoreStore;
+}
+const actions = require_store_reduxHelpers_createActions("useFilter", {
+	saveData: (namespace, data) => ({
+		namespace,
+		data
+	}),
+	saveFilter: (namespace, filter) => ({
+		namespace,
+		filter
+	}),
+	clear: () => undefined
+});
+const initialState = {
+	data: {},
+	filters: {}
+};
+const useFilterReduxReducer = require_store_reduxHelpers_createReducer(initialState, (builder) => {
+	builder.addHandler(actions.saveFilter, (state, action) => ({
+		...state,
+		filters: {
+			...state.filters,
+			[action.payload.namespace]: action.payload.filter
+		}
+	})).addHandler(actions.saveData, (state, action) => ({
+		...state,
+		data: {
+			...state.data,
+			[action.payload.namespace]: action.payload.data
+		}
+	})).addHandler(actions.clear, (state) => ({
+		...state,
+		filters: {},
+		data: {}
+	}));
+});
+
+//#endregion
+exports.createReduxStore = createReduxStore;
+exports.useFilterReduxReducer = useFilterReduxReducer;

package/dist/cjs/store/urlParamStore.d.ts

@@ -0,0 +1,8 @@
+import { FilterStore } from "./index.js";
+
+//#region src/store/urlParamStore.d.ts
+declare const createUrlParamStore: () => FilterStore;
+declare function replaceQueryParams(newParams: string): void;
+declare function naivelyParseExistingParams(): any;
+//#endregion
+export { createUrlParamStore, naivelyParseExistingParams, replaceQueryParams };

package/dist/cjs/store/urlParamStore.js

@@ -0,0 +1,68 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+let qs = require("qs");
+qs = require_runtime.__toESM(qs);
+
+//#region src/store/urlParamStore.ts
+const createUrlParamStore = () => {
+	const urlParamStore = {
+		getFilter(namespace) {
+			const parsed = naivelyParseExistingParams();
+			const parsedInfo = parsed[`info.${namespace}`];
+			const parsedFilter = parsed[`filter.${namespace}`];
+			if (parsedInfo || parsedFilter) {
+				const { page, offset, pageSize, ...rest } = parsedInfo || {};
+				return {
+					...{
+						page: 1 / page ? +page : undefined,
+						pageSize: 1 / pageSize ? +pageSize : undefined,
+						offset: 1 / offset ? +offset : undefined,
+						...rest
+					},
+					filter: parsedFilter
+				};
+			}
+		},
+		saveFilter(namespace, filterInfo) {
+			const parsed = naivelyParseExistingParams();
+			const clonedInfo = { ...filterInfo };
+			const clonedFilter = filterInfo.filter;
+			delete clonedInfo.filter;
+			delete clonedInfo.lastRefreshAt;
+			delete clonedInfo.shouldRunImmediately;
+			delete clonedInfo.totalResults;
+			delete clonedInfo.totalPages;
+			delete clonedInfo.nextCursor;
+			parsed[`filter.${namespace}`] = clonedFilter;
+			parsed[`info.${namespace}`] = clonedInfo;
+			replaceQueryParams(qs.default.stringify(parsed));
+		},
+		clear() {
+			const parsed = naivelyParseExistingParams();
+			for (const key in parsed) {
+				if (key.startsWith("filter.") || key.startsWith("info.")) {
+					delete parsed[key];
+				}
+			}
+			replaceQueryParams(qs.default.stringify(parsed));
+		},
+		getData() {
+			return undefined;
+		},
+		saveData() {}
+	};
+	return urlParamStore;
+};
+function replaceQueryParams(newParams) {
+	const nextUrl = new URL(window.location.toString());
+	nextUrl.search = newParams;
+	window.history.replaceState(undefined, "", nextUrl.toString());
+}
+function naivelyParseExistingParams() {
+	return qs.default.parse(window.location.search.substring(1));
+}
+
+//#endregion
+exports.createUrlParamStore = createUrlParamStore;
+exports.naivelyParseExistingParams = naivelyParseExistingParams;
+exports.replaceQueryParams = replaceQueryParams;

package/dist/cjs/useFilter.d.ts

@@ -0,0 +1,106 @@
+import { FilterStore } from "./store/index.js";
+
+//#region src/useFilter.d.ts
+type MaybePromise<T> = T | Promise<T>;
+interface UseFilterOptions<TFilter extends Record<string, unknown>, TResult> {
+  /**
+   * Default values for your filter. When calling `.reset` your filter will be
+   * set to this.
+   * Changing these values does not cause a call to happen.
+   */
+  defaultFilterInfo?: Partial<FilterInfo<TFilter>>;
+  /**
+   * Enable this if you are not using the data caching of this hook.
+   */
+  shouldForceRunOnMount?: boolean;
+  /**
+   * Called whenever the filter changes.
+   */
+  onChange: (filterInfo: FilterInfo<TFilter>, reason: UseFilterUpdateReason) => MaybePromise<UseFilterOnChangeResult<TFilter, TResult>>;
+  /**
+   * In case you want to change the default debounce duration.
+   */
+  debounceDuration?: number;
+  onBeforeSaveFilter?: (filterInfo: FilterInfo<TFilter>) => FilterInfo<TFilter>;
+  store?: FilterStore;
+}
+interface FilterApi<TFilter extends Record<string, unknown>, TResult> {
+  /**
+   * Whether the system is debouncing or waiting for your `onChange` to finish.
+   */
+  isLoading: boolean;
+  /**
+   * Any cached data for this filter.
+   */
+  data: TResult | null | undefined;
+  /**
+   * Access to the filter and its metadata.
+   */
+  filterInfo: FilterInfo<TFilter>;
+  /**
+   * Whether the filter existed in the system when the component mounted.
+   * @deprecated
+   */
+  doesFilterExist: boolean;
+  /**
+   * Why the last update happened.
+   */
+  updateReason: UseFilterUpdateReason;
+  /**
+   * Update one or more values in your filter.
+   */
+  updateFilter: (filter: Partial<TFilter>, shouldRunImmediately?: boolean) => void;
+  /**
+   * Resets the filter back to `defaultFilterInfo`.
+   */
+  resetFilter: (shouldRunImmediately?: boolean) => void;
+  /**
+   * Changes the offset. Will update `page`.
+   */
+  setOffset: (offset: number | string, shouldRunImmediately?: boolean) => void;
+  /**
+   * Changes the page. Will update `offset`.
+   */
+  setPage: (page: number | string, shouldRunImmediately?: boolean) => void;
+  /**
+   * Changes the page size.
+   */
+  setPageSize: (pageSize: number | string, shouldRunImmediately?: boolean) => void;
+  /**
+   * Change the sort method.
+   */
+  setSort: (sort: string | undefined, shouldRunImmediately?: boolean) => void;
+  /**
+   * Changes the cursor.
+   */
+  setCursor: (cursor: string | null | undefined, shouldRunImmediately?: boolean) => void;
+  /**
+   * Forces a refresh of the filter.
+   */
+  forceRefresh: (shouldRunImmediately?: boolean) => void;
+}
+type UseFilterUpdateReason = 'initial' | 'filter' | 'pagination';
+declare function useFilter<TFilter extends Record<string, unknown>, TResult>(namespace: string, options: UseFilterOptions<TFilter, TResult>): FilterApi<TFilter, TResult>;
+interface FilterInfo<TFilter extends Record<string, unknown>> {
+  filter: TFilter;
+  offset: number;
+  page: number;
+  sort?: string;
+  pageSize: number;
+  lastRefreshAt: number;
+  totalResults: number;
+  totalPages: number;
+  shouldRunImmediately: boolean;
+  cursor?: string | null;
+  nextCursor?: string | null;
+}
+type UseFilterOnChangeResult<TFilter extends Record<string, unknown>, TResult> = void | {
+  filterInfo?: Partial<Omit<FilterInfo<TFilter>, 'totalResults' | 'offset' | 'pageSize'> & {
+    totalResults: string | number;
+    offset: string | number;
+    pageSize: string | number;
+  }>;
+  data?: TResult;
+};
+//#endregion
+export { FilterApi, FilterInfo, UseFilterUpdateReason, useFilter as default };