reselect-kit 1.0.0

package/dist/cjs/reselectKit.development.cjs

@@ -0,0 +1,683 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _veksa_re_reselect = require("@veksa/re-reselect");
+let _veksa_reselect = require("@veksa/reselect");
+let _veksa_react_redux = require("@veksa/react-redux");
+let react = require("react");
+//#region src/createSegmentSelector.ts
+function createSegmentSelector(fn, initial) {
+	return (state) => fn(state) ?? initial;
+}
+//#endregion
+//#region src/_helpers/isObject.ts
+const isObject = (value) => {
+	return value !== null && typeof value === "object";
+};
+//#endregion
+//#region src/_helpers/defineDynamicSelectorName.ts
+const defineDynamicSelectorName = (selector, selectorNameGetter) => {
+	let overriddenSelectorName;
+	Object.defineProperty(selector, "selectorName", {
+		configurable: true,
+		get: () => overriddenSelectorName ?? selectorNameGetter(),
+		set: (value) => {
+			overriddenSelectorName = value;
+		}
+	});
+};
+//#endregion
+//#region src/debug/debug.ts
+let debugMode = false;
+const isDebugMode = () => debugMode;
+const setDebugMode = (value) => {
+	debugMode = value;
+};
+//#endregion
+//#region src/debug/withDebugName.ts
+/**
+* Runs `callback` only outside production and only while debug mode is enabled.
+* Centralizes the `NODE_ENV` / `isDebugMode` guard that the selector factories
+* would otherwise repeat around every debug-name assignment.
+*/
+const runInDebug = (callback) => {
+	/* istanbul ignore else  */
+	if (isDebugMode()) callback();
+};
+/**
+* Assigns a lazily-computed debug name to `selector`, guarded by
+* {@link runInDebug}. Covers the common single-name case; use `runInDebug`
+* directly when a block needs to name several selectors at once.
+*/
+const withDebugName = (selector, selectorNameGetter) => {
+	runInDebug(() => {
+		defineDynamicSelectorName(selector, selectorNameGetter);
+	});
+};
+//#endregion
+//#region src/_helpers/getSelectorName.ts
+const getSelectorName = (selector) => {
+	if ("selectorName" in selector && selector.selectorName) return selector.selectorName;
+	return selector.name;
+};
+//#endregion
+//#region src/createPathSelector.ts
+const defaultVoidFunction = () => {};
+/** @internal */
+const innerCreatePathSelector = (baseSelector, path = [], applyMeta = defaultVoidFunction) => {
+	const pathLength = path.length;
+	const proxyTarget = (defaultValue) => {
+		function resultSelector(state, props) {
+			let result;
+			if (arguments.length === 2) result = baseSelector(state, props);
+			else if (arguments.length === 1) result = baseSelector(state);
+			else result = baseSelector.apply(null, arguments);
+			for (let i = 0; i < pathLength && isObject(result); i += 1) result = result[path[i]];
+			return result === void 0 ? defaultValue : result;
+		}
+		Object.assign(resultSelector, baseSelector, { path });
+		resultSelector.dependencies = [baseSelector];
+		applyMeta(resultSelector);
+		withDebugName(resultSelector, () => {
+			return [getSelectorName(baseSelector), ...path].join(".");
+		});
+		return resultSelector;
+	};
+	return new Proxy(proxyTarget, { get: (_target, key) => {
+		return innerCreatePathSelector(baseSelector, [...path, String(key)], applyMeta);
+	} });
+};
+function createPathSelector(baseSelector) {
+	return innerCreatePathSelector(baseSelector);
+}
+//#endregion
+//#region src/createPropSelector.ts
+const propSelectorSymbol = Symbol.for("PropSelector");
+const isPropSelector = (selector) => {
+	return selector instanceof Object && propSelectorSymbol in selector;
+};
+function createPropSelector() {
+	const propsSelector = (_state, props) => props;
+	const applyMeta = (selector) => {
+		Object.defineProperty(selector, propSelectorSymbol, { value: true });
+	};
+	return innerCreatePathSelector(propsSelector, [], applyMeta);
+}
+//#endregion
+//#region src/keys/createKeySelectorComposer.ts
+const composedKeySelectorSymbol = Symbol.for("ComposedKeySelector");
+function isComposedKeySelector(keySelector) {
+	return "dependencies" in keySelector && composedKeySelectorSymbol in keySelector;
+}
+function createKeySelectorComposer(baseKeySelectorComposer) {
+	return ((...keySelectors) => {
+		const resultSelector = baseKeySelectorComposer(...keySelectors);
+		resultSelector.dependencies = keySelectors;
+		Object.defineProperty(resultSelector, composedKeySelectorSymbol, { value: true });
+		return resultSelector;
+	});
+}
+//#endregion
+//#region src/_helpers/arePathsEqual.ts
+const arePathsEqual = (path, anotherPath) => {
+	if (path.length !== anotherPath.length) return false;
+	for (let i = 0; i < path.length; i += 1) if (path[i] !== anotherPath[i]) return false;
+	return true;
+};
+//#endregion
+//#region src/keys/defaultKeySelector.ts
+const defaultKeySelector = () => "<DefaultKey>";
+//#endregion
+//#region src/_helpers/isCachedSelector.ts
+const isCachedSelector = (selector) => {
+	return selector instanceof Object && "keySelector" in selector && typeof selector.keySelector === "function";
+};
+//#endregion
+//#region src/keys/createKeySelectorCreator.ts
+const areSelectorsEqual = (selector, another) => {
+	if (selector === another) return true;
+	if (isPropSelector(selector) && isPropSelector(another)) return arePathsEqual(selector.path, another.path);
+	return false;
+};
+const flatKeySelectors = (keySelectors) => {
+	const result = [];
+	for (let i = 0; i < keySelectors.length; i += 1) {
+		const keySelector = keySelectors[i];
+		if (isComposedKeySelector(keySelector)) result.push(...flatKeySelectors(keySelector.dependencies));
+		else result.push(keySelector);
+	}
+	return result;
+};
+const uniqKeySelectors = (keySelectors) => {
+	const result = [];
+	for (let i = 0; i < keySelectors.length; i += 1) {
+		const keySelector = keySelectors[i];
+		if (!result.some((resultKeySelector) => areSelectorsEqual(keySelector, resultKeySelector))) result.push(keySelector);
+	}
+	return result;
+};
+const excludeDefaultSelectors = (keySelectors) => {
+	const result = [];
+	for (let i = 0; i < keySelectors.length; i += 1) {
+		const keySelector = keySelectors[i];
+		if (keySelector !== defaultKeySelector) result.push(keySelector);
+	}
+	return result;
+};
+function createKeySelectorCreator(keySelectorComposer) {
+	return ({ inputSelectors, keySelector }) => {
+		let keySelectors = [];
+		if (keySelector) keySelectors.push(keySelector);
+		inputSelectors.forEach((selector) => {
+			if (isCachedSelector(selector)) keySelectors.push(selector.keySelector);
+		});
+		keySelectors = flatKeySelectors(keySelectors);
+		keySelectors = uniqKeySelectors(keySelectors);
+		keySelectors = excludeDefaultSelectors(keySelectors);
+		if (keySelectors.length === 0) return defaultKeySelector;
+		if (keySelectors.length === 1) {
+			const [resultSelector] = keySelectors;
+			return resultSelector;
+		}
+		return keySelectorComposer(...keySelectors);
+	};
+}
+//#endregion
+//#region src/keys/stringComposeKeySelectors.ts
+const stringComposeKeySelectors = createKeySelectorComposer((...keySelectors) => (state, props) => {
+	let key = keySelectors[0](state, props);
+	for (let i = 1; i < keySelectors.length; i += 1) {
+		key += ":";
+		key += keySelectors[i](state, props);
+	}
+	return key;
+});
+//#endregion
+//#region src/_helpers/temporaryAssign.ts
+const noop = () => void 0;
+function temporaryAssign(target, source) {
+	if (typeof target !== "object" || target === null) return {
+		result: source,
+		rollback: noop
+	};
+	let temporary = null;
+	let deleteProps = null;
+	for (const prop in source) if (Object.prototype.hasOwnProperty.call(source, prop)) {
+		const targetProp = target[prop];
+		const sourceProp = source[prop];
+		if (targetProp !== sourceProp) {
+			if (Object.prototype.hasOwnProperty.call(target, prop)) {
+				if (temporary === null) temporary = {};
+				temporary[prop] = targetProp;
+			} else {
+				if (deleteProps === null) deleteProps = [];
+				deleteProps.push(prop);
+			}
+			target[prop] = sourceProp;
+		}
+	}
+	if (temporary === null && deleteProps === null) return {
+		result: target,
+		rollback: noop
+	};
+	const restore = temporary;
+	const remove = deleteProps;
+	const rollback = () => {
+		if (restore !== null) {
+			for (const prop in restore) if (Object.prototype.hasOwnProperty.call(restore, prop)) target[prop] = restore[prop];
+		}
+		if (remove !== null) {
+			for (const prop of remove) if (Object.prototype.hasOwnProperty.call(target, prop)) delete target[prop];
+		}
+	};
+	return {
+		result: target,
+		rollback
+	};
+}
+//#endregion
+//#region src/_helpers/getObjectPaths.ts
+const getObjectPaths = (value, parentPath = []) => {
+	if (!isObject(value)) return [parentPath];
+	return Object.keys(value).reduce((result, key) => {
+		const paths = getObjectPaths(value[key], parentPath.concat([key]));
+		return result.concat(paths);
+	}, []);
+};
+//#endregion
+//#region src/createBoundSelector.ts
+const generateBindingName = (binding) => {
+	const structure = Object.keys(binding).reduce((result, key) => ({
+		...result,
+		[key]: "[*]"
+	}), {});
+	return `${Object.keys(structure).join()} -> ${Object.values(structure).join()}`;
+};
+const innerCreateBoundSelector = (baseSelector, binding) => {
+	const boundSelector = (state, props) => baseSelector(state, {
+		...props,
+		...binding
+	});
+	return boundSelector;
+};
+const createBoundInnerSelector = (baseSelector, binding, options = {}) => {
+	const bindingStrategy = options.bindingStrategy ?? innerCreateBoundSelector;
+	const keySelectorComposer = options.keySelectorComposer ?? stringComposeKeySelectors;
+	const boundSelector = bindingStrategy(baseSelector, binding);
+	Object.assign(boundSelector, baseSelector);
+	boundSelector.dependencies = [baseSelector];
+	withDebugName(boundSelector, () => {
+		return `${getSelectorName(baseSelector)} (${generateBindingName(binding)})`;
+	});
+	if (isCachedSelector(baseSelector)) {
+		const cachedBoundSelector = boundSelector;
+		if (baseSelector.getMatchingSelector) cachedBoundSelector.getMatchingSelector = bindingStrategy(baseSelector.getMatchingSelector, binding);
+		if (baseSelector.removeMatchingSelector) cachedBoundSelector.removeMatchingSelector = bindingStrategy(baseSelector.removeMatchingSelector, binding);
+		const baseKeySelector = baseSelector.keySelector;
+		if (isObject(binding)) {
+			const paths = getObjectPaths(binding);
+			let keySelectors = isComposedKeySelector(baseKeySelector) ? baseKeySelector.dependencies : [baseKeySelector];
+			keySelectors = excludeDefaultSelectors(keySelectors);
+			keySelectors = keySelectors.filter((keySelector) => !isPropSelector(keySelector) || !paths.some((path) => arePathsEqual(keySelector.path, path))).map((keySelector) => isPropSelector(keySelector) ? keySelector : bindingStrategy(keySelector, binding));
+			if (keySelectors.length === 0) cachedBoundSelector.keySelector = defaultKeySelector;
+			else if (keySelectors.length === 1) {
+				const [keySelector] = keySelectors;
+				cachedBoundSelector.keySelector = keySelector;
+			} else cachedBoundSelector.keySelector = keySelectorComposer(...keySelectors);
+		} else cachedBoundSelector.keySelector = bindingStrategy(baseKeySelector, binding);
+	}
+	return boundSelector;
+};
+const createBoundSelector = (baseSelector, binding) => {
+	return createBoundInnerSelector(baseSelector, binding, { bindingStrategy: (selector, bindingProps) => {
+		const source = bindingProps;
+		const keys = Object.keys(source);
+		/**
+		* Almost every binding is a single key — `bound(selector, { positionId })` —
+		* and specialising it removes the two allocations the generic path costs per
+		* call: the `{ result, rollback }` object and the `rollback` closure. On a
+		* graph with a bound selector per row those are the calls that dominate.
+		*
+		* The `delete` in the restore stays deliberately. Leaving the key behind as
+		* `undefined` would be cheaper — it avoids putting the caller's props object
+		* into dictionary mode — but it also changes the object's shape, and
+		* `useSelector` memoizes props shallowly: a props object that has grown an
+		* extra key never again compares equal to a freshly built one, so the
+		* memoization the binding exists to protect would be defeated.
+		*/
+		if (keys.length === 1) {
+			const key = keys[0];
+			const value = source[key];
+			return (state, props) => {
+				const target = props;
+				if (typeof target !== "object" || target === null) return selector(state, source);
+				const previous = target[key];
+				if (previous === value) return selector(state, props);
+				const had = Object.prototype.hasOwnProperty.call(target, key);
+				target[key] = value;
+				try {
+					return selector(state, props);
+				} finally {
+					if (had) target[key] = previous;
+					else delete target[key];
+				}
+			};
+		}
+		return (state, props) => {
+			const { result: nextProps, rollback } = temporaryAssign(props, source);
+			const result = selector(state, nextProps);
+			rollback();
+			return result;
+		};
+	} });
+};
+//#endregion
+//#region src/createEmptySelector.ts
+/**
+* Creates a selector that always resolves to `undefined`. Used as the "no link"
+* branch of a chain (e.g. an optional relation that isn't present).
+*
+* When the base selector is cached, the empty selector is tagged with
+* {@link defaultKeySelector} so that it still passes {@link isCachedSelector}
+* and takes part in key-selector composition. The default key is deliberately
+* the only cache-related metadata copied: an empty selector has no result to
+* memoize, so it needs no `cache` / `getMatchingSelector` of its own, and the
+* default key is dropped by `excludeDefaultSelectors` during composition.
+*/
+const createEmptySelector = (baseSelector) => {
+	const emptySelector = () => void 0;
+	if (isCachedSelector(baseSelector)) emptySelector.keySelector = defaultKeySelector;
+	return emptySelector;
+};
+//#endregion
+//#region src/createAdaptedSelector.ts
+const generateMappingName = (mapping) => {
+	if (mapping.name) return mapping.name;
+	const structure = mapping(new Proxy({}, { get: (_target, key) => key }));
+	return `${Object.keys(structure).join()} -> ${Object.values(structure).join()}`;
+};
+const innerCreateAdaptedSelector = (baseSelector, mapping) => (state, props) => {
+	return baseSelector(state, mapping(props));
+};
+const createAdaptedSelector = (baseSelector, mapping) => {
+	const adaptedSelector = innerCreateAdaptedSelector(baseSelector, mapping);
+	Object.assign(adaptedSelector, baseSelector);
+	adaptedSelector.dependencies = [baseSelector];
+	withDebugName(adaptedSelector, () => {
+		return `${getSelectorName(baseSelector)} (${generateMappingName(mapping)})`;
+	});
+	if (isCachedSelector(baseSelector)) {
+		const cachedAdaptedSelector = adaptedSelector;
+		if (baseSelector.getMatchingSelector) cachedAdaptedSelector.getMatchingSelector = innerCreateAdaptedSelector(baseSelector.getMatchingSelector, mapping);
+		if (baseSelector.removeMatchingSelector) cachedAdaptedSelector.removeMatchingSelector = innerCreateAdaptedSelector(baseSelector.removeMatchingSelector, mapping);
+		cachedAdaptedSelector.keySelector = innerCreateAdaptedSelector(baseSelector.keySelector, mapping);
+	}
+	return adaptedSelector;
+};
+//#endregion
+//#region src/_helpers/stringifyFunction.ts
+const stringifyFunction = (source) => {
+	return String(source).replace(/\s+/g, " ").trim();
+};
+//#endregion
+//#region src/_helpers/generateSelectorKey.ts
+const generateSelectorKey = (selector) => {
+	const dependencies = selector.dependencies ?? [];
+	let result = stringifyFunction(selector);
+	for (let i = dependencies.length - 1; i >= 0; i -= 1) {
+		const dependency = dependencies[i];
+		result += stringifyFunction(dependency);
+	}
+	return result;
+};
+//#endregion
+//#region src/createChainSelector.ts
+function createChainSelector(selector, options, prevChain) {
+	const chain = (fn, chainOptions) => {
+		const combinedOptions = {
+			...options,
+			...chainOptions
+		};
+		const keySelector = isCachedSelector(selector) ? selector.keySelector : defaultKeySelector;
+		const { createSelectorOptions = () => ({}), keySelectorComposer = stringComposeKeySelectors } = combinedOptions;
+		const keySelectorCreator = createKeySelectorCreator(keySelectorComposer);
+		const higherOrderSelector = (0, _veksa_re_reselect.createCachedSelector)([selector], fn)({
+			...createSelectorOptions(),
+			keySelector
+		});
+		withDebugName(higherOrderSelector, () => {
+			return `higher order for ${getSelectorName(selector)} (${stringifyFunction(fn)})`;
+		});
+		const combinedSelector = (state, props) => {
+			const derivedSelector = higherOrderSelector(state, props);
+			runInDebug(() => {
+				combinedSelector.dependencies = [higherOrderSelector, derivedSelector];
+				if (!getSelectorName(derivedSelector)) defineDynamicSelectorName(derivedSelector, () => {
+					return `derived from ${getSelectorName(selector)} (${generateSelectorKey(derivedSelector)})`;
+				});
+				defineDynamicSelectorName(combinedSelector, () => {
+					return `${getSelectorName(selector)} (chained by ${getSelectorName(derivedSelector)})`;
+				});
+			});
+			return derivedSelector(state, props);
+		};
+		combinedSelector.dependencies = [higherOrderSelector];
+		combinedSelector.cache = higherOrderSelector.cache;
+		/**
+		* The derived selector's key selector, memoized on the derived selector itself.
+		*
+		* This used to be a second `createCachedSelector` over `[higherOrderSelector]`,
+		* which meant every key computation paid a whole extra cached-selector layer —
+		* its own key computation, its own cache lookup, and its own evaluation of
+		* `higherOrderSelector` — to produce a value that depends on nothing but the
+		* derived selector. A `WeakMap` keyed on that selector is the same mapping with
+		* none of the layer, and it shares across cache keys rather than per key.
+		*
+		* Note what is deliberately *not* memoized: the `(state, props)` pair. `props`
+		* is mutated in place by `createBoundSelector`, so two calls can pass the same
+		* object reference with different contents, and a reference-keyed cache would
+		* hand back a stale selector.
+		*/
+		const derivedKeySelectors = /* @__PURE__ */ new WeakMap();
+		combinedSelector.keySelector = (state, props) => {
+			const derivedSelector = higherOrderSelector(state, props);
+			let derivedKeySelector = derivedKeySelectors.get(derivedSelector);
+			if (derivedKeySelector === void 0) {
+				derivedKeySelector = keySelectorCreator({ inputSelectors: [higherOrderSelector, derivedSelector] });
+				derivedKeySelectors.set(derivedSelector, derivedKeySelector);
+			}
+			return derivedKeySelector(state, props);
+		};
+		withDebugName(combinedSelector, () => {
+			return `${getSelectorName(selector)} (will be chained ${stringifyFunction(fn)})`;
+		});
+		return createChainSelector(combinedSelector, combinedOptions, Object.assign(fn, { parentChain: prevChain }));
+	};
+	const map = (fn, mapOptions) => {
+		const mapSelector = (result) => {
+			const output = fn(result);
+			const mapSelector = () => output;
+			withDebugName(mapSelector, () => {
+				return `mapped from ${getSelectorName(selector)} (${stringifyFunction(fn)})`;
+			});
+			return mapSelector;
+		};
+		return chain(mapSelector, mapOptions);
+	};
+	const build = () => {
+		return Object.assign(selector, { chainHierarchy: prevChain });
+	};
+	return {
+		chain,
+		map,
+		build
+	};
+}
+//#endregion
+//#region src/createSequenceSelector.ts
+function createSequenceSelector(selectors, selectorCreator = _veksa_reselect.createSelector) {
+	return selectorCreator(selectors, (...results) => results);
+}
+//#endregion
+//#region src/createCachedSequenceSelector.ts
+function createCachedSequenceSelector(selectors) {
+	return createSequenceSelector(selectors, _veksa_re_reselect.createCachedSelector);
+}
+//#endregion
+//#region src/createStructuredSelector.ts
+const createStructuredSelector = _veksa_reselect.createStructuredSelector;
+//#endregion
+//#region src/createCachedStructuredSelector.ts
+function createCachedStructuredSelector(selectors) {
+	return createStructuredSelector(selectors, _veksa_re_reselect.createCachedSelector);
+}
+//#endregion
+//#region src/keys/arrayComposeKeySelectors.ts
+const arrayComposeKeySelectors = createKeySelectorComposer((...keySelectors) => (state, props) => {
+	let keyPath = [];
+	for (let i = 0; i < keySelectors.length; i += 1) {
+		const key = keySelectors[i](state, props);
+		if (Array.isArray(key)) keyPath = keyPath.concat(key);
+		else keyPath.push(key);
+	}
+	return keyPath;
+});
+//#endregion
+//#region src/cache/intervalMapCache.ts
+/**
+* Buckets used to live in a module-level `Record<string, …>` keyed by an
+* incrementing numeric id, which meant every `get` and `set` coerced that number to
+* a string and re-read the global record — four times per cache hit in `get`.
+* Holding the entries on the instance removes both, and a `Map` keeps non-string
+* keys as they are instead of stringifying them.
+*/
+const buckets = /* @__PURE__ */ new Set();
+const cacheLifetime = 1e4;
+let garbageCollectorStarted = false;
+const runGarbageCollector = () => {
+	const currentTime = Date.now();
+	buckets.forEach((bucket) => {
+		if (bucket.sweep(currentTime)) buckets.delete(bucket);
+	});
+	window.setTimeout(runGarbageCollector, cacheLifetime);
+};
+const initGarbageCollector = () => {
+	if (garbageCollectorStarted) return;
+	if (typeof window !== "undefined") {
+		garbageCollectorStarted = true;
+		window.setTimeout(runGarbageCollector, cacheLifetime);
+	}
+};
+var IntervalMapCache = class {
+	constructor() {
+		this.entries = /* @__PURE__ */ new Map();
+	}
+	set(key, data) {
+		const entry = this.entries.get(key);
+		if (entry === void 0) {
+			buckets.add(this);
+			this.entries.set(key, {
+				data,
+				time: Date.now()
+			});
+		} else {
+			entry.data = data;
+			entry.time = Date.now();
+		}
+	}
+	get(key) {
+		const entry = this.entries.get(key);
+		if (entry === void 0) return;
+		entry.time = Date.now();
+		return entry.data;
+	}
+	remove(key) {
+		this.entries.delete(key);
+	}
+	clear() {
+		this.entries.clear();
+		buckets.delete(this);
+	}
+	/**
+	* Drops entries untouched for longer than the lifetime. Returns whether the
+	* bucket is now empty, which is what lets the collector unregister it.
+	*/
+	sweep(currentTime) {
+		this.entries.forEach((entry, key) => {
+			if (currentTime - entry.time > cacheLifetime) this.entries.delete(key);
+		});
+		return this.entries.size === 0;
+	}
+};
+//#endregion
+//#region src/cache/TreeCache.ts
+const normalizeKey = (key) => Array.isArray(key) ? key : [key];
+var TreeCacheNode = class {};
+var TreeCache = class {
+	constructor(options) {
+		this.cacheObjectCreator = options.cacheObjectCreator ?? (() => new _veksa_re_reselect.FlatObjectCache());
+		const root = new TreeCacheNode();
+		root.cache = this.cacheObjectCreator();
+		this.root = root;
+	}
+	clear() {
+		const root = new TreeCacheNode();
+		root.cache = this.cacheObjectCreator();
+		this.root = root;
+	}
+	get(key) {
+		if (!Array.isArray(key)) {
+			const cacheResponse = this.root.cache?.get(key);
+			return cacheResponse instanceof TreeCacheNode ? cacheResponse.selectorFn : void 0;
+		}
+		let currentNode = this.root;
+		for (let i = 0; i < key.length; i += 1) {
+			const item = key[i];
+			const cacheResponse = currentNode.cache?.get(item);
+			if (cacheResponse instanceof TreeCacheNode) currentNode = cacheResponse;
+			else return;
+		}
+		return currentNode.selectorFn;
+	}
+	set(key, selectorFn) {
+		const keyPath = normalizeKey(key);
+		let currentNode = this.root;
+		for (let i = 0; i < keyPath.length; i += 1) {
+			const item = keyPath[i];
+			if (!currentNode.cache) currentNode.cache = this.cacheObjectCreator();
+			const cacheResponse = currentNode.cache.get(item);
+			if (cacheResponse instanceof TreeCacheNode) currentNode = cacheResponse;
+			else {
+				const node = new TreeCacheNode();
+				currentNode.cache.set(item, node);
+				currentNode = node;
+			}
+		}
+		currentNode.selectorFn = selectorFn;
+	}
+	remove(key) {
+		const keyPath = normalizeKey(key);
+		let currentNode = this.root;
+		for (let i = 0; i < keyPath.length; i += 1) {
+			const item = keyPath[i];
+			const cacheResponse = currentNode.cache?.get(item);
+			if (cacheResponse instanceof TreeCacheNode) currentNode = cacheResponse;
+			else return;
+		}
+		currentNode.selectorFn = void 0;
+	}
+	/**
+	* Called by re-reselect on every cache operation, so neither the wrapping array
+	* nor the `every` callback is allocated here.
+	*/
+	isValidCacheKey(key) {
+		const rootCache = this.root.cache;
+		if (rootCache?.isValidCacheKey === void 0) return true;
+		if (!Array.isArray(key)) return rootCache.isValidCacheKey(key);
+		for (let i = 0; i < key.length; i += 1) if (!rootCache.isValidCacheKey(key[i])) return false;
+		return true;
+	}
+};
+//#endregion
+//#region src/_hooks/useMemoWith.ts
+const useMemoWith = (value, comparator) => {
+	const ref = (0, react.useRef)(value);
+	if (!comparator(value, ref.current)) ref.current = value;
+	return ref.current;
+};
+//#endregion
+//#region src/_hooks/useSelector.ts
+function useSelector(selector, ...params) {
+	const props = params[0];
+	const memoizedProps = useMemoWith(props, _veksa_react_redux.shallowEqual);
+	const unfrozenProps = (0, react.useMemo)(() => {
+		return Object.isFrozen(memoizedProps) ? { ...memoizedProps } : memoizedProps;
+	}, [memoizedProps]);
+	return (0, _veksa_react_redux.useSelector)((0, react.useCallback)((state) => {
+		return selector(state, unfrozenProps);
+	}, [selector, unfrozenProps]), { devModeChecks: {
+		stabilityCheck: "never",
+		identityFunctionCheck: "never"
+	} });
+}
+//#endregion
+exports.IntervalMapCache = IntervalMapCache;
+exports.TreeCache = TreeCache;
+exports.arrayComposeKeySelectors = arrayComposeKeySelectors;
+exports.createAdaptedSelector = createAdaptedSelector;
+exports.createBoundSelector = createBoundSelector;
+exports.createCachedSequenceSelector = createCachedSequenceSelector;
+exports.createCachedStructuredSelector = createCachedStructuredSelector;
+exports.createChainSelector = createChainSelector;
+exports.createEmptySelector = createEmptySelector;
+exports.createKeySelectorComposer = createKeySelectorComposer;
+exports.createKeySelectorCreator = createKeySelectorCreator;
+exports.createPathSelector = createPathSelector;
+exports.createPropSelector = createPropSelector;
+exports.createSegmentSelector = createSegmentSelector;
+exports.defaultKeySelector = defaultKeySelector;
+exports.initGarbageCollector = initGarbageCollector;
+exports.isDebugMode = isDebugMode;
+exports.setDebugMode = setDebugMode;
+exports.stringComposeKeySelectors = stringComposeKeySelectors;
+exports.useSelector = useSelector;
+
+//# sourceMappingURL=reselectKit.development.cjs.map