reselect-kit 1.0.1 → 1.1.1

package/dist/reselectKit.mjs

@@ -1,7 +1,7 @@
-import { FlatObjectCache, createCachedSelector } from "@veksa/re-reselect";
 import { createSelector, createStructuredSelector } from "@veksa/reselect";
+import { FlatObjectCache, createCachedSelector } from "@veksa/re-reselect";
 import { shallowEqual, useSelector as useSelector$1 } from "@veksa/react-redux";
-import { useCallback, useMemo, useRef } from "react";
+import { useRef } from "react";
 //#region src/createSegmentSelector.ts
 function createSegmentSelector(fn, initial) {
 	return (state) => {
@@ -93,6 +93,15 @@ const innerCreatePathSelector = (baseSelector, path = [], applyMeta = defaultVoi
 		return innerCreatePathSelector(baseSelector, [...path, String(key)], applyMeta);
 	} });
 };
+/**
+* Builds a proxy that turns property access into a selector reading that path.
+*
+* `Params` is inferred straight from the base selector, so the plain and the
+* parametric case share one signature — and one set of builder types — instead
+* of being told apart by a conditional in the parameter position. It defaults
+* to empty so that `createPathSelector<State, Result>(selector)` keeps working
+* for callers that spell the type arguments out.
+*/
 function createPathSelector(baseSelector) {
 	return innerCreatePathSelector(baseSelector);
 }
@@ -259,16 +268,55 @@ const generateBindingName = (binding) => {
 	}), {});
 	return `${Object.keys(structure).join()} -> ${Object.values(structure).join()}`;
 };
-const innerCreateBoundSelector = (baseSelector, binding) => {
-	const boundSelector = (state, props) => baseSelector(state, {
-		...props,
-		...binding
-	});
-	return boundSelector;
+/**
+* The default binding strategy: applies the binding to the props the caller
+* passed, hands them to the base selector, and puts them back as they were.
+*
+* 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.
+*/
+const applyBinding = (baseSelector, binding) => {
+	const source = binding;
+	const keys = Object.keys(source);
+	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 baseSelector(state, source);
+			const previous = target[key];
+			if (previous === value) return baseSelector(state, props);
+			const had = Object.prototype.hasOwnProperty.call(target, key);
+			target[key] = value;
+			try {
+				return baseSelector(state, props);
+			} finally {
+				if (had) target[key] = previous;
+				else delete target[key];
+			}
+		};
+	}
+	return (state, props) => {
+		const { result: nextProps, rollback } = temporaryAssign(props, source);
+		try {
+			return baseSelector(state, nextProps);
+		} finally {
+			rollback();
+		}
+	};
 };
-const createBoundInnerSelector = (baseSelector, binding, options = {}) => {
+const createBoundSelector = (baseSelector, binding, options = {}) => {
 	var _ref, _options$keySelectorC;
-	const bindingStrategy = (_ref = options.bindingStrategy) !== null && _ref !== void 0 ? _ref : innerCreateBoundSelector;
+	const bindingStrategy = (_ref = options.bindingStrategy) !== null && _ref !== void 0 ? _ref : applyBinding;
 	const keySelectorComposer = (_options$keySelectorC = options.keySelectorComposer) !== null && _options$keySelectorC !== void 0 ? _options$keySelectorC : stringComposeKeySelectors;
 	const boundSelector = bindingStrategy(baseSelector, binding);
 	Object.assign(boundSelector, baseSelector);
@@ -295,49 +343,6 @@ const createBoundInnerSelector = (baseSelector, binding, options = {}) => {
 	}
 	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
 /**
@@ -366,6 +371,11 @@ const generateMappingName = (mapping) => {
 const innerCreateAdaptedSelector = (baseSelector, mapping) => (state, props) => {
 	return baseSelector(state, mapping(props));
 };
+/**
+* Rewrites the props a selector reads. Only the props argument changes: the
+* adapted selector takes `[P2]` where the base took `[P1]`, which is the same
+* argument tuple every other creator in the library carries.
+*/
 const createAdaptedSelector = (baseSelector, mapping) => {
 	const adaptedSelector = innerCreateAdaptedSelector(baseSelector, mapping);
 	Object.assign(adaptedSelector, baseSelector);
@@ -401,7 +411,8 @@ const generateSelectorKey = (selector) => {
 //#endregion
 //#region src/createChainSelector.ts
 function createChainSelector(selector, options, prevChain) {
-	const chain = (fn, chainOptions) => {
+	const createLevel = (fn, chainOptions, isDerivedKeyless) => {
+		var _selectorOptions$sele;
 		const combinedOptions = {
 			...options,
 			...chainOptions
@@ -409,8 +420,17 @@ function createChainSelector(selector, options, prevChain) {
 		const keySelector = isCachedSelector(selector) ? selector.keySelector : defaultKeySelector;
 		const { createSelectorOptions = () => ({}), keySelectorComposer = stringComposeKeySelectors } = combinedOptions;
 		const keySelectorCreator = createKeySelectorCreator(keySelectorComposer);
-		const higherOrderSelector = createCachedSelector([selector], fn)({
-			...createSelectorOptions(),
+		/**
+		* Nothing below this level is keyed, so the cache would hold a single entry
+		* for the lifetime of the chain and every call would still pay for the key
+		* computation and the lookup that guard it. A plain memoized selector is the
+		* same mapping — re-reselect under a constant key is one `createSelector`
+		* instance — without the layer.
+		*/
+		const isKeyless = keySelector === defaultKeySelector;
+		const selectorOptions = createSelectorOptions();
+		const higherOrderSelector = isKeyless ? ((_selectorOptions$sele = selectorOptions.selectorCreator) !== null && _selectorOptions$sele !== void 0 ? _selectorOptions$sele : createSelector)([selector], fn) : createCachedSelector([selector], fn)({
+			...selectorOptions,
 			keySelector
 		});
 		withDebugName(higherOrderSelector, () => {
@@ -430,37 +450,65 @@ function createChainSelector(selector, options, prevChain) {
 			return derivedSelector(state, props);
 		};
 		combinedSelector.dependencies = [higherOrderSelector];
-		combinedSelector.cache = higherOrderSelector.cache;
+		if (!isKeyless) 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.
+		* Assigned through a local and written to the selector once. Assigning the
+		* property in both branches instead reads as two expando declarations of
+		* `keySelector` to TypeScript before 7, which rejects it as a duplicate
+		* identifier.
 		*/
-		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);
-		};
+		let levelKeySelector;
+		if (isDerivedKeyless)
+ /**
+		* A `map` level derives a plain `() => output`, never a cached selector, so
+		* it contributes nothing to the composed key and the whole composition is
+		* known at build time. It is the same call the wrapper below makes, minus
+		* the derived selector — so the key is composed exactly as before, once,
+		* instead of on every key computation of every level above.
+		*/
+		levelKeySelector = keySelectorCreator({ inputSelectors: [higherOrderSelector] });
+		else {
+			/**
+			* 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();
+			levelKeySelector = (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);
+			};
+		}
+		/**
+		* When nothing keyed is left the composition yields the default key, and
+		* leaving the property off is what lets the next level skip its cache too.
+		* The wrapper above is a fresh closure, so only a `map` level can land here
+		* with the default.
+		*/
+		if (levelKeySelector !== defaultKeySelector) combinedSelector.keySelector = levelKeySelector;
 		withDebugName(combinedSelector, () => {
 			return `${getSelectorName(selector)} (will be chained ${stringifyFunction(fn)})`;
 		});
 		return createChainSelector(combinedSelector, combinedOptions, Object.assign(fn, { parentChain: prevChain }));
 	};
+	const chain = (fn, chainOptions) => {
+		return createLevel(fn, chainOptions, false);
+	};
 	const map = (fn, mapOptions) => {
 		const mapSelector = (result) => {
 			const output = fn(result);
@@ -470,7 +518,7 @@ function createChainSelector(selector, options, prevChain) {
 			});
 			return mapSelector;
 		};
-		return chain(mapSelector, mapOptions);
+		return createLevel(mapSelector, mapOptions, true);
 	};
 	const build = () => {
 		return Object.assign(selector, { chainHierarchy: prevChain });
@@ -651,28 +699,140 @@ var TreeCache = class {
 	}
 };
 //#endregion
-//#region src/_hooks/useMemoWith.ts
-const useMemoWith = (value, comparator) => {
-	const ref = useRef(value);
-	if (!comparator(value, ref.current)) ref.current = value;
-	return ref.current;
+//#region src/_helpers/unfreezeProps.ts
+/**
+* Bound selectors write the binding into the props object in place and roll it
+* back afterwards (see temporaryAssign.ts), which throws on a frozen target in
+* strict mode. React freezes element props in development, and immer-based
+* stores hand out frozen objects in production too, so the copy stays in both
+* builds — the hooks only ever call this when props actually change.
+*/
+const unfreezeProps = (props) => {
+	if (typeof props !== "object" || props === null || !Object.isFrozen(props)) return props;
+	return Array.isArray(props) ? props.slice() : { ...props };
 };
 //#endregion
+//#region src/_hooks/selectorOptions.ts
+/**
+* Hoisted: react-redux reads the options object on every render, so there is no
+* reason to allocate a fresh one per call site per render. The dev-mode checks
+* re-run the selector to compare results, which these hooks control themselves.
+*/
+const selectorOptions = { devModeChecks: {
+	stabilityCheck: "never",
+	identityFunctionCheck: "never"
+} };
+//#endregion
 //#region src/_hooks/useSelector.ts
 function useSelector(selector, ...params) {
 	const props = params[0];
-	const memoizedProps = useMemoWith(props, shallowEqual);
-	const unfrozenProps = useMemo(() => {
-		return Object.isFrozen(memoizedProps) ? { ...memoizedProps } : memoizedProps;
-	}, [memoizedProps]);
-	return useSelector$1(useCallback((state) => {
-		return selector(state, unfrozenProps);
-	}, [selector, unfrozenProps]), { devModeChecks: {
-		stabilityCheck: "never",
-		identityFunctionCheck: "never"
-	} });
+	const cacheRef = useRef(null);
+	let cache = cacheRef.current;
+	if (cache === null) {
+		const unfrozenProps = unfreezeProps(props);
+		cache = cacheRef.current = {
+			props,
+			unfrozenProps,
+			selector,
+			boundSelector: (state) => selector(state, unfrozenProps)
+		};
+	} else {
+		const propsChanged = !shallowEqual(props, cache.props);
+		if (propsChanged) {
+			cache.props = props;
+			cache.unfrozenProps = unfreezeProps(props);
+		}
+		if (propsChanged || cache.selector !== selector) {
+			const { unfrozenProps } = cache;
+			cache.selector = selector;
+			cache.boundSelector = (state) => selector(state, unfrozenProps);
+		}
+	}
+	return useSelector$1(cache.boundSelector, selectorOptions);
+}
+//#endregion
+//#region src/_hooks/useSelectors.ts
+const readSelectors = (cache, selectors) => {
+	const keys = [];
+	const fns = [];
+	for (const key in selectors) if (Object.prototype.hasOwnProperty.call(selectors, key)) {
+		keys.push(key);
+		fns.push(selectors[key]);
+	}
+	cache.keys = keys;
+	cache.selectors = fns;
+	cache.results = [];
+	cache.value = null;
+};
+/**
+* One pass over the incoming object instead of `shallowEqual`, which would
+* allocate a key array for each side on every render of every call site. Key
+* order is part of the comparison, so a renamed key is caught as well.
+*/
+const hasSameSelectors = (cache, selectors) => {
+	const { keys, selectors: fns } = cache;
+	let index = 0;
+	for (const key in selectors) if (Object.prototype.hasOwnProperty.call(selectors, key)) {
+		if (index === keys.length || keys[index] !== key || fns[index] !== selectors[key]) return false;
+		index++;
+	}
+	return index === keys.length;
+};
+/**
+* The structured part: every selector runs, but the result object is rebuilt
+* only when some field actually changed. An unchanged batch keeps its previous
+* reference, so react-redux's default reference equality already bails out —
+* no result allocation and no comparison pass on the steady path.
+*/
+const select = (cache, state) => {
+	const { keys, selectors, unfrozenProps, results } = cache;
+	const count = keys.length;
+	let changed = cache.value === null;
+	for (let index = 0; index < count; index++) {
+		const result = selectors[index](state, unfrozenProps);
+		if (!Object.is(result, results[index])) {
+			results[index] = result;
+			changed = true;
+		}
+	}
+	if (!changed) return cache.value;
+	const value = {};
+	for (let index = 0; index < count; index++) value[keys[index]] = results[index];
+	cache.value = value;
+	return value;
+};
+function useSelectors(selectors, ...params) {
+	const props = params[0];
+	const cacheRef = useRef(null);
+	let cache = cacheRef.current;
+	if (cache === null) {
+		const created = {
+			keys: [],
+			selectors: [],
+			props,
+			unfrozenProps: unfreezeProps(props),
+			results: [],
+			value: null,
+			boundSelector: (state) => select(created, state)
+		};
+		readSelectors(created, selectors);
+		cache = cacheRef.current = created;
+	} else {
+		const selectorsChanged = !hasSameSelectors(cache, selectors);
+		const propsChanged = !shallowEqual(props, cache.props);
+		if (selectorsChanged) readSelectors(cache, selectors);
+		if (propsChanged) {
+			cache.props = props;
+			cache.unfrozenProps = unfreezeProps(props);
+		}
+		if (selectorsChanged || propsChanged) {
+			const current = cache;
+			cache.boundSelector = (state) => select(current, state);
+		}
+	}
+	return useSelector$1(cache.boundSelector, selectorOptions);
 }
 //#endregion
-export { IntervalMapCache, TreeCache, arrayComposeKeySelectors, createAdaptedSelector, createBoundSelector, createCachedSequenceSelector, createCachedStructuredSelector, createChainSelector, createEmptySelector, createKeySelectorComposer, createKeySelectorCreator, createPathSelector, createPropSelector, createSegmentSelector, defaultKeySelector, initGarbageCollector, isDebugMode, setDebugMode, stringComposeKeySelectors, useSelector };
+export { IntervalMapCache, TreeCache, arrayComposeKeySelectors, createAdaptedSelector, createBoundSelector, createCachedSequenceSelector, createCachedStructuredSelector, createChainSelector, createEmptySelector, createKeySelectorComposer, createKeySelectorCreator, createPathSelector, createPropSelector, createSegmentSelector, createSequenceSelector, defaultKeySelector, initGarbageCollector, isDebugMode, setDebugMode, stringComposeKeySelectors, useSelector, useSelectors };
 
 //# sourceMappingURL=reselectKit.mjs.map