@promoboxx/use-filter 1.11.2 → 2.0.1

package/dist/cjs/useFilter.js

@@ -0,0 +1,251 @@
+const require_lib_getOffsetFromPage = require('./lib/getOffsetFromPage.js');
+const require_lib_getPageFromOffset = require('./lib/getPageFromOffset.js');
+const require_lib_buildDefaultFilterInfo = require('./lib/buildDefaultFilterInfo.js');
+const require_lib_shallowEqual = require('./lib/shallowEqual.js');
+const require_store_index = require('./store/index.js');
+let react = require("react");
+
+//#region src/useFilter.ts
+function useFilter(namespace, options) {
+	const ctxRefValue = {
+		namespace,
+		onChange: options.onChange,
+		debounceDuration: options.debounceDuration,
+		defaultFilterInfo: options.defaultFilterInfo,
+		onBeforeSaveFilter: options.onBeforeSaveFilter,
+		store: options.store
+	};
+	const ctxRef = (0, react.useRef)(ctxRefValue);
+	(0, react.useEffect)(() => {
+		ctxRef.current = ctxRefValue;
+	});
+	const [filterInfo, setFilterInfoState] = (0, react.useState)(() => {
+		const fromStore = require_store_index.getFilterStore(ctxRef.current.store).getFilter(namespace);
+		if (fromStore) {
+			const filterInfo = require_lib_buildDefaultFilterInfo({
+				...fromStore,
+				shouldRunImmediately: true,
+				filter: {
+					...options.defaultFilterInfo?.filter,
+					...fromStore.filter
+				}
+			});
+			return filterInfo;
+		}
+	});
+	const [data, setData] = (0, react.useState)(() => require_store_index.getFilterStore(ctxRef.current.store).getData(namespace));
+	const [isLoading, setIsLoading] = (0, react.useState)(!filterInfo);
+	const doesFilterExist = (0, react.useRef)(!!filterInfo);
+	const lastRefreshAtRef = (0, react.useRef)(options.shouldForceRunOnMount ? -1 : filterInfo ? filterInfo.lastRefreshAt : -1);
+	const updateReasonRef = (0, react.useRef)("initial");
+	(0, react.useEffect)(() => {
+		setIsLoading(true);
+		if (!filterInfo) {
+			setFilterInfoState({
+				...require_lib_buildDefaultFilterInfo(ctxRef.current.defaultFilterInfo),
+				shouldRunImmediately: true
+			});
+			return;
+		}
+		if (lastRefreshAtRef.current === filterInfo.lastRefreshAt) {
+			setIsLoading(false);
+			return;
+		}
+		const makeRequest = () => {
+			lastRefreshAtRef.current = filterInfo.lastRefreshAt;
+			const response = ctxRef.current.onChange(filterInfo, updateReasonRef.current);
+			require_store_index.getFilterStore(ctxRef.current.store).saveFilter(namespace, ctxRef.current.onBeforeSaveFilter ? ctxRef.current.onBeforeSaveFilter(filterInfo) : filterInfo);
+			if (!response) {
+				setIsLoading(false);
+				return;
+			}
+			function handleResponse(response) {
+				if (!response) {
+					return;
+				}
+				if (response.filterInfo) {
+					setFilterInfoState((previous) => {
+						invariant(!!response.filterInfo, "");
+						invariant(previous != null, "handleResponse called without filterInfo");
+						const extra = {};
+						const { page, offset, totalResults, pageSize, nextCursor, ...filterInfoFromResponse } = response.filterInfo;
+						const pageSizeNumber = Number(pageSize || previous.pageSize);
+						if (page != null && offset == null) {
+							extra.offset = require_lib_getOffsetFromPage(page, pageSizeNumber);
+							extra.page = page;
+						} else if (page == null && offset != null) {
+							const offsetNumber = Number(offset);
+							extra.offset = offsetNumber;
+							extra.page = require_lib_getPageFromOffset(offsetNumber, pageSizeNumber);
+						}
+						if ("totalResults" in response.filterInfo) {
+							extra.totalResults = Number(totalResults || 0);
+							extra.totalPages = Math.ceil(extra.totalResults / pageSizeNumber);
+						}
+						if ("nextCursor" in response.filterInfo) {
+							extra.nextCursor = nextCursor;
+						}
+						return {
+							...previous,
+							...filterInfoFromResponse,
+							...extra
+						};
+					});
+				}
+				if (response.data) {
+					setData(response.data);
+					require_store_index.getFilterStore(ctxRef.current.store).saveData(namespace, response.data);
+				}
+			}
+			if (isPromise(response)) {
+				response.then(handleResponse).finally(() => setIsLoading(false));
+			} else {
+				handleResponse(response);
+				setIsLoading(false);
+			}
+		};
+		let timeout = undefined;
+		if (filterInfo.shouldRunImmediately) {
+			makeRequest();
+		} else {
+			timeout = setTimeout(makeRequest, ctxRef.current.debounceDuration != null ? ctxRef.current.debounceDuration : 500);
+		}
+		return () => {
+			if (timeout) {
+				clearTimeout(timeout);
+			}
+		};
+	}, [filterInfo, namespace]);
+	const api = {
+		isLoading,
+		data,
+		doesFilterExist: doesFilterExist.current,
+		filterInfo: filterInfo || require_lib_buildDefaultFilterInfo(options.defaultFilterInfo),
+		updateReason: updateReasonRef.current,
+		updateFilter: (0, react.useCallback)((filter, shouldRunImmediately = false) => {
+			updateReasonRef.current = "filter";
+			setFilterInfoState((previous) => {
+				invariant(previous != null, "updateFilter called without filterInfo");
+				const nextFilter = {
+					...previous.filter,
+					...filter
+				};
+				if (require_lib_shallowEqual(previous.filter, nextFilter)) {
+					return previous;
+				}
+				return {
+					...previous,
+					offset: 0,
+					page: 1,
+					totalResults: 1,
+					totalPages: 1,
+					filter: nextFilter,
+					lastRefreshAt: new Date().getTime(),
+					cursor: undefined,
+					nextCursor: undefined,
+					shouldRunImmediately
+				};
+			});
+		}, []),
+		resetFilter: (0, react.useCallback)((shouldRunImmediately = false) => {
+			updateReasonRef.current = "filter";
+			setFilterInfoState({
+				...require_lib_buildDefaultFilterInfo(ctxRef.current.defaultFilterInfo),
+				lastRefreshAt: new Date().getTime(),
+				shouldRunImmediately
+			});
+		}, []),
+		setOffset: (0, react.useCallback)((offset, shouldRunImmediately = false) => {
+			updateReasonRef.current = "pagination";
+			setFilterInfoState((previous) => {
+				invariant(previous != null, "setOffset called without filterInfo");
+				const offsetNumber = Number(offset);
+				return {
+					...previous,
+					offset: offsetNumber,
+					page: require_lib_getPageFromOffset(offsetNumber, previous.pageSize),
+					lastRefreshAt: new Date().getTime(),
+					shouldRunImmediately
+				};
+			});
+		}, []),
+		setPage: (0, react.useCallback)((page, shouldRunImmediately = false) => {
+			updateReasonRef.current = "pagination";
+			setFilterInfoState((previous) => {
+				invariant(previous != null, "setPage called without filterInfo");
+				const pageNumber = Number(page);
+				return {
+					...previous,
+					offset: require_lib_getOffsetFromPage(pageNumber, previous.pageSize),
+					page: pageNumber,
+					lastRefreshAt: new Date().getTime(),
+					shouldRunImmediately
+				};
+			});
+		}, []),
+		setPageSize: (0, react.useCallback)((pageSize, shouldRunImmediately = false) => {
+			updateReasonRef.current = "pagination";
+			setFilterInfoState((previous) => {
+				invariant(previous != null, "setPageSize called without filterInfo");
+				const pageSizeNumber = Number(pageSize);
+				const page = require_lib_getPageFromOffset(previous.offset, pageSizeNumber);
+				const offset = require_lib_getOffsetFromPage(page, pageSizeNumber);
+				return {
+					...previous,
+					pageSize: pageSizeNumber,
+					offset,
+					page,
+					lastRefreshAt: new Date().getTime(),
+					shouldRunImmediately
+				};
+			});
+		}, []),
+		setSort: (0, react.useCallback)((sort, shouldRunImmediately = false) => {
+			updateReasonRef.current = "filter";
+			setFilterInfoState((previous) => {
+				invariant(previous != null, "setSort called without filterInfo");
+				return {
+					...previous,
+					sort,
+					lastRefreshAt: new Date().getTime(),
+					shouldRunImmediately
+				};
+			});
+		}, []),
+		setCursor: (0, react.useCallback)((cursor, shouldRunImmediately = false) => {
+			setFilterInfoState((previous) => {
+				updateReasonRef.current = "pagination";
+				invariant(previous != null, "setCursor called without filterInfo");
+				return {
+					...previous,
+					cursor,
+					lastRefreshAt: new Date().getTime(),
+					shouldRunImmediately
+				};
+			});
+		}, []),
+		forceRefresh: (0, react.useCallback)((shouldRunImmediately = false) => {
+			updateReasonRef.current = "filter";
+			setFilterInfoState((previous) => {
+				invariant(previous != null, "forceRefresh called without filterInfo");
+				return {
+					...previous,
+					lastRefreshAt: new Date().getTime(),
+					shouldRunImmediately
+				};
+			});
+		}, [])
+	};
+	return api;
+}
+function invariant(input, message) {
+	if (!input) {
+		throw new Error(`Invariant error: ${message}`);
+	}
+}
+function isPromise(t) {
+	return !!t?.then;
+}
+
+//#endregion
+module.exports = useFilter;

package/dist/cjs/useSimpleFilter.d.ts

@@ -0,0 +1,89 @@
+import { FilterStore } from "./store/index.js";
+import { UseFilterUpdateReason } from "./useFilter.js";
+
+//#region src/useSimpleFilter.d.ts
+interface UseSimpleFilterOptions<TFilter> {
+  /**
+   * 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<SimpleFilterInfo<TFilter>>;
+  /**
+   * In case you want to change the default debounce duration.
+   */
+  debounceDuration?: number;
+  onBeforeSaveFilter?: (filterInfo: SimpleFilterInfo<TFilter>) => SimpleFilterInfo<TFilter>;
+  store?: FilterStore;
+}
+interface SimpleFilterApi<TFilter> {
+  /**
+   * Really more "is debouncing", since simple mode doesn't know when your code
+   * is doing anything.
+   */
+  isLoading: boolean;
+  /**
+   * Access to the filter and its metadata.
+   */
+  filterInfo: SimpleFilterInfo<TFilter>;
+  /**
+   * Same as the regular `filterInfo`, but updates in a debounced fashion.
+   */
+  debouncedFilterInfo: SimpleFilterInfo<TFilter>;
+  /**
+   * Why the last update happened.
+   */
+  updateReason: UseFilterUpdateReason;
+  /**
+   * Update one or more values in your filter.
+   */
+  updateFilter: (filter: Partial<TFilter>, shouldRunImmediately?: boolean) => void;
+  /**
+   * Does the boring math for you based on your `pageSize` and `totalResults`.
+   */
+  pagingInfo: (total: string | number | null | undefined) => {
+    totalResults: number;
+    totalPages: number;
+  };
+  /**
+   * 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, shouldRunImmediately?: boolean) => void;
+  /**
+   * Changes the cursor.
+   */
+  setCursor: (cursor: string | null | undefined, shouldRunImmediately?: boolean) => void;
+  /**
+   * Forces a refresh of the filter.
+   */
+  forceRefresh: (shouldRunImmediately?: boolean) => void;
+}
+interface SimpleFilterInfo<TFilter> {
+  filter: TFilter;
+  sort?: string;
+  offset: number;
+  page: number;
+  pageSize: number;
+  lastRefreshAt: number;
+  cursor?: string | null;
+  shouldRunImmediately: boolean;
+}
+declare function useSimpleFilter<TFilter extends Record<string, unknown>>(namespace: string, options: UseSimpleFilterOptions<TFilter>): SimpleFilterApi<TFilter>;
+//#endregion
+export { SimpleFilterApi, SimpleFilterInfo, useSimpleFilter as default };

package/dist/cjs/useSimpleFilter.js

@@ -0,0 +1,198 @@
+const require_lib_getOffsetFromPage = require('./lib/getOffsetFromPage.js');
+const require_lib_getPageFromOffset = require('./lib/getPageFromOffset.js');
+const require_lib_shallowEqual = require('./lib/shallowEqual.js');
+const require_store_index = require('./store/index.js');
+let react = require("react");
+
+//#region src/useSimpleFilter.ts
+function useSimpleFilter(namespace, options) {
+	const ctxRefValue = {
+		namespace,
+		debounceDuration: options.debounceDuration,
+		defaultFilterInfo: options.defaultFilterInfo,
+		onBeforeSaveFilter: options.onBeforeSaveFilter,
+		store: options.store
+	};
+	const ctxRef = (0, react.useRef)(ctxRefValue);
+	(0, react.useEffect)(() => {
+		ctxRef.current = ctxRefValue;
+	});
+	const [isLoading, setIsLoading] = (0, react.useState)(false);
+	const [filterInfo, setFilterInfoState] = (0, react.useState)(() => {
+		const fromStore = require_store_index.getFilterStore(ctxRef.current.store).getFilter(namespace);
+		if (fromStore) {
+			const filterInfo = buildDefaultFilterInfo({
+				...fromStore,
+				shouldRunImmediately: true,
+				filter: {
+					...options.defaultFilterInfo?.filter,
+					...fromStore.filter
+				}
+			});
+			return filterInfo;
+		} else {
+			return buildDefaultFilterInfo({
+				...options.defaultFilterInfo,
+				shouldRunImmediately: true
+			});
+		}
+	});
+	const [debouncedFilterInfo, setDebouncedFilterInfo] = (0, react.useState)(filterInfo);
+	const lastRefreshAtRef = (0, react.useRef)(-1);
+	const updateReasonRef = (0, react.useRef)("initial");
+	(0, react.useEffect)(() => {
+		setIsLoading(true);
+		if (lastRefreshAtRef.current === filterInfo.lastRefreshAt) {
+			setIsLoading(false);
+			return;
+		}
+		let timeout = undefined;
+		function makeRequest() {
+			lastRefreshAtRef.current = filterInfo.lastRefreshAt;
+			require_store_index.getFilterStore(ctxRef.current.store).saveFilter(ctxRef.current.namespace, ctxRef.current.onBeforeSaveFilter ? ctxRef.current.onBeforeSaveFilter(filterInfo) : filterInfo);
+			setDebouncedFilterInfo(filterInfo);
+			setIsLoading(false);
+		}
+		if (filterInfo.shouldRunImmediately) {
+			makeRequest();
+		} else {
+			timeout = setTimeout(makeRequest, ctxRef.current.debounceDuration ?? 500);
+		}
+		return () => {
+			if (timeout) {
+				clearTimeout(timeout);
+			}
+		};
+	}, [filterInfo]);
+	const previousTotalRef = (0, react.useRef)(0);
+	const api = {
+		isLoading,
+		filterInfo,
+		debouncedFilterInfo,
+		updateReason: updateReasonRef.current,
+		updateFilter: (0, react.useCallback)((filter, shouldRunImmediately = false) => {
+			updateReasonRef.current = "filter";
+			setFilterInfoState((previous) => {
+				const nextFilter = {
+					...previous.filter,
+					...filter
+				};
+				if (require_lib_shallowEqual(previous.filter, nextFilter)) {
+					return previous;
+				}
+				return {
+					...previous,
+					shouldRunImmediately,
+					offset: 0,
+					page: 1,
+					totalResults: 1,
+					totalPages: 1,
+					filter: nextFilter,
+					cursor: undefined,
+					lastRefreshAt: new Date().getTime()
+				};
+			});
+		}, []),
+		pagingInfo: (0, react.useCallback)((total) => {
+			const normalized = Number(total == null ? previousTotalRef.current : total);
+			previousTotalRef.current = normalized;
+			return {
+				totalResults: normalized,
+				totalPages: Math.ceil(normalized / filterInfo.pageSize)
+			};
+		}, [filterInfo.pageSize]),
+		resetFilter: (0, react.useCallback)((shouldRunImmediately = false) => {
+			updateReasonRef.current = "filter";
+			setFilterInfoState({
+				...buildDefaultFilterInfo(ctxRef.current.defaultFilterInfo),
+				shouldRunImmediately
+			});
+		}, []),
+		setOffset: (0, react.useCallback)((offset, shouldRunImmediately = false) => {
+			updateReasonRef.current = "pagination";
+			const offsetNumber = Number(offset);
+			setFilterInfoState((previous) => ({
+				...previous,
+				offset: offsetNumber,
+				page: require_lib_getPageFromOffset(offsetNumber, previous.pageSize),
+				lastRefreshAt: new Date().getTime(),
+				shouldRunImmediately
+			}));
+		}, []),
+		setPage: (0, react.useCallback)((page, shouldRunImmediately = false) => {
+			updateReasonRef.current = "pagination";
+			const pageNumber = Number(page);
+			setFilterInfoState((previous) => ({
+				...previous,
+				offset: require_lib_getOffsetFromPage(pageNumber, previous.pageSize),
+				page: pageNumber,
+				lastRefreshAt: new Date().getTime(),
+				shouldRunImmediately
+			}));
+		}, []),
+		setPageSize: (0, react.useCallback)((pageSize, shouldRunImmediately = false) => {
+			updateReasonRef.current = "pagination";
+			setFilterInfoState((previous) => {
+				const pageSizeNumber = Number(pageSize);
+				const page = require_lib_getPageFromOffset(previous.offset, pageSizeNumber);
+				const offset = require_lib_getOffsetFromPage(page, pageSizeNumber);
+				return {
+					...previous,
+					pageSize: pageSizeNumber,
+					offset,
+					page,
+					lastRefreshAt: new Date().getTime(),
+					shouldRunImmediately
+				};
+			});
+		}, []),
+		setSort: (0, react.useCallback)((sort, shouldRunImmediately = false) => {
+			updateReasonRef.current = "filter";
+			setFilterInfoState((previous) => ({
+				...previous,
+				sort,
+				lastRefreshAt: new Date().getTime(),
+				shouldRunImmediately
+			}));
+		}, []),
+		setCursor: (0, react.useCallback)((cursor, shouldRunImmediately = false) => {
+			updateReasonRef.current = "pagination";
+			setFilterInfoState((previous) => ({
+				...previous,
+				cursor,
+				lastRefreshAt: new Date().getTime(),
+				shouldRunImmediately
+			}));
+		}, []),
+		forceRefresh: (0, react.useCallback)((shouldRunImmediately = false) => {
+			updateReasonRef.current = "filter";
+			setFilterInfoState((previous) => ({
+				...previous,
+				lastRefreshAt: new Date().getTime(),
+				shouldRunImmediately
+			}));
+		}, [])
+	};
+	return api;
+}
+function buildDefaultFilterInfo(filterInfo = {}) {
+	const merged = {
+		filter: {},
+		sort: undefined,
+		pageSize: 20,
+		lastRefreshAt: new Date().getTime(),
+		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 = useSimpleFilter;

package/dist/esm/lib/buildDefaultFilterInfo.d.mts

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

package/dist/esm/lib/buildDefaultFilterInfo.mjs

@@ -0,0 +1,27 @@
+import getOffsetFromPage from "./getOffsetFromPage.mjs";
+import getPageFromOffset from "./getPageFromOffset.mjs";
+
+//#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 = getOffsetFromPage(filterInfo.page, merged.pageSize);
+	} else if (filterInfo.page == null && filterInfo.offset != null) {
+		merged.page = getPageFromOffset(filterInfo.offset, merged.pageSize);
+	}
+	return merged;
+}
+
+//#endregion
+export { buildDefaultFilterInfo as default };

package/dist/esm/lib/getOffsetFromPage.d.mts

@@ -0,0 +1,4 @@
+//#region src/lib/getOffsetFromPage.d.ts
+declare function getOffsetFromPage(page: number, pageSize: number): number;
+//#endregion
+export { getOffsetFromPage as default };

package/dist/esm/lib/getOffsetFromPage.mjs

@@ -0,0 +1,7 @@
+//#region src/lib/getOffsetFromPage.ts
+function getOffsetFromPage(page, pageSize) {
+	return pageSize * (page - 1);
+}
+
+//#endregion
+export { getOffsetFromPage as default };

package/dist/esm/lib/getPageFromOffset.d.mts

@@ -0,0 +1,4 @@
+//#region src/lib/getPageFromOffset.d.ts
+declare function getPageFromOffset(offset: number, pageSize: number): number;
+//#endregion
+export { getPageFromOffset as default };

package/dist/esm/lib/getPageFromOffset.mjs

@@ -0,0 +1,7 @@
+//#region src/lib/getPageFromOffset.ts
+function getPageFromOffset(offset, pageSize) {
+	return Math.floor(offset / pageSize) + 1;
+}
+
+//#endregion
+export { getPageFromOffset as default };

package/dist/esm/lib/shallowEqual.d.mts

@@ -0,0 +1,4 @@
+//#region src/lib/shallowEqual.d.ts
+declare const shallowEqual: (objA: any, objB: any) => boolean;
+//#endregion
+export { shallowEqual as default };

package/dist/esm/lib/shallowEqual.mjs

@@ -0,0 +1,23 @@
+//#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
+export { shallowEqual as default };

package/dist/esm/store/index.d.mts

@@ -0,0 +1,14 @@
+import { FilterInfo } from "../useFilter.mjs";
+
+//#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/esm/store/index.mjs

@@ -0,0 +1,15 @@
+//#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
+export { getFilterStore, setFilterStore };

package/dist/esm/store/localStorageStore.d.mts

@@ -0,0 +1,6 @@
+import { FilterStore } from "./index.mjs";
+
+//#region src/store/localStorageStore.d.ts
+declare const localStorageStore: FilterStore;
+//#endregion
+export { localStorageStore as default };