reselect-kit 1.0.1 → 1.1.1

package/src/createPathSelector.ts

@@ -1,5 +1,4 @@
-import { Selector } from '@veksa/reselect';
-import { NamedParametricSelector, NamedSelector, Path } from './types';
+import { NamedSelector, Path } from './types';
 import { isObject } from './_helpers/isObject';
 import { withDebugName } from './debug/withDebugName';
 import { getSelectorName } from './_helpers/getSelectorName';
@@ -10,131 +9,94 @@ export type IsOptional<T> = undefined extends T ? true : null extends T ? true :
 
 export type IsObject<T> = T extends object ? true : false;
 
-export type PathSelector<S, R, D> = NamedSelector<S, R, [], D> & {
-  path: Path;
-};
-
-export type PathParametricSelector<S, P, R, D> = NamedParametricSelector<S, P, R, D> & {
+/**
+ * The selector a path builder produces. `Params` is carried through untouched
+ * from the base selector: walking a path changes the result, never the
+ * arguments, so the plain and the parametric case are the same type.
+ */
+export type PathSelector<S, R, Params extends readonly any[], D> = NamedSelector<
+  S,
+  R,
+  Params,
+  D
+> & {
   path: Path;
 };
 
 type Required<T> = { [P in keyof T]-?: Exclude<T[P], undefined | null> };
 
-export type RequiredSelectorBuilder<S, R, D> = R extends object
-  ? { [K in keyof R]: () => PathSelector<S, NonNullable<R[K]>, D> }
-  : {};
-
-export type OptionalSelectorBuilder<S, R, D> = ((
-  defaultValue?: R,
-) => PathSelector<S, R extends undefined ? Defined<R> : R, D>) &
-  (R extends object
-    ? { [K in keyof Required<R>]: () => PathSelector<S, NonNullable<R[K]>, D> }
-    : {});
-
-export type RequiredParametricSelectorBuilder<S, P, R, D> = R extends object
-  ? { [K in keyof R]: () => PathParametricSelector<S, P, NonNullable<R[K]>, D> }
+export type RequiredSelectorBuilder<S, R, Params extends readonly any[], D> = R extends object
+  ? { [K in keyof R]: () => PathSelector<S, NonNullable<R[K]>, Params, D> }
   : {};
 
-export type OptionalParametricSelectorBuilder<S, P, R, D> = ((
+export type OptionalSelectorBuilder<S, R, Params extends readonly any[], D> = ((
   defaultValue?: R,
-) => PathParametricSelector<S, P, R extends undefined ? Defined<R> : R, D>) &
+) => PathSelector<S, R extends undefined ? Defined<R> : R, Params, D>) &
   (R extends object
-    ? { [K in keyof Required<R>]: () => PathParametricSelector<S, P, NonNullable<R[K]>, D> }
+    ? { [K in keyof Required<R>]: () => PathSelector<S, NonNullable<R[K]>, Params, D> }
     : {});
 
-export type RequiredObjectSelectorWrapper<S, R, D> = {
+export type RequiredObjectSelectorWrapper<S, R, Params extends readonly any[], D> = {
   [K in keyof R]-?: IsOptional<R[K]> extends true
-    ? OptionalPathSelectorType<S, R[K], D>
-    : RequiredPathSelectorType<S, R[K], D>;
-};
-
-export type OptionalObjectSelectorWrapper<S, R, D> = {
-  [K in keyof R]-?: OptionalPathSelectorType<S, R[K], D>;
-};
-
-export type RequiredObjectParametricSelectorWrapper<S, P, R, D> = {
-  [K in keyof R]-?: IsOptional<R[K]> extends true
-    ? OptionalPathParametricSelectorType<S, P, R[K], D>
-    : RequiredPathParametricSelectorType<S, P, R[K], D>;
-};
-
-export type OptionalObjectParametricSelectorWrapper<S, P, R, D> = {
-  [K in keyof R]-?: OptionalPathParametricSelectorType<S, P, R[K], D>;
+    ? OptionalPathSelectorType<S, R[K], Params, D>
+    : RequiredPathSelectorType<S, R[K], Params, D>;
 };
 
-export type RequiredArraySelectorWrapper<S, R, D> = {
-  length: RequiredPathSelectorType<S, number, D>;
-
-  [K: number]: IsOptional<R> extends true
-    ? OptionalPathSelectorType<S, R, D>
-    : RequiredPathSelectorType<S, R, D>;
+export type OptionalObjectSelectorWrapper<S, R, Params extends readonly any[], D> = {
+  [K in keyof R]-?: OptionalPathSelectorType<S, R[K], Params, D>;
 };
 
-export type OptionalArraySelectorWrapper<S, R, D> = {
-  length: RequiredPathSelectorType<S, number, D>;
-
-  [K: number]: OptionalPathSelectorType<S, R, D>;
-};
-
-export type RequiredArrayParametricSelectorWrapper<S, P, R, D> = {
-  length: RequiredPathParametricSelectorType<S, P, number, D>;
+export type RequiredArraySelectorWrapper<S, R, Params extends readonly any[], D> = {
+  length: RequiredPathSelectorType<S, number, Params, D>;
 
   [K: number]: IsOptional<R> extends true
-    ? OptionalPathParametricSelectorType<S, P, R, D>
-    : RequiredPathParametricSelectorType<S, P, R, D>;
+    ? OptionalPathSelectorType<S, R, Params, D>
+    : RequiredPathSelectorType<S, R, Params, D>;
 };
 
-export type OptionalArrayParametricSelectorWrapper<S, P, R, D> = {
-  length: RequiredPathParametricSelectorType<S, P, number, D>;
+export type OptionalArraySelectorWrapper<S, R, Params extends readonly any[], D> = {
+  length: RequiredPathSelectorType<S, number, Params, D>;
 
-  [K: number]: OptionalPathParametricSelectorType<S, P, R, D>;
+  [K: number]: OptionalPathSelectorType<S, R, Params, D>;
 };
 
-export type RequiredDataSelectorWrapper<S, R, D> = R extends unknown[]
-  ? RequiredArraySelectorWrapper<S, R[number], D>
-  : IsObject<R> extends true
-    ? RequiredObjectSelectorWrapper<S, R, D>
-    : RequiredSelectorBuilder<S, R, D>;
-
-export type OptionalDataSelectorWrapper<S, R, D> = R extends unknown[]
-  ? OptionalArraySelectorWrapper<S, R[number], D>
-  : IsObject<R> extends true
-    ? OptionalObjectSelectorWrapper<S, R, D>
-    : OptionalSelectorBuilder<S, R, D>;
-
-export type RequiredDataParametricSelectorWrapper<S, P, R, D> = R extends unknown[]
-  ? RequiredArrayParametricSelectorWrapper<S, P, R[number], D>
+export type RequiredDataSelectorWrapper<
+  S,
+  R,
+  Params extends readonly any[],
+  D,
+> = R extends unknown[]
+  ? RequiredArraySelectorWrapper<S, R[number], Params, D>
   : IsObject<R> extends true
-    ? RequiredObjectParametricSelectorWrapper<S, P, R, D>
-    : RequiredParametricSelectorBuilder<S, P, R, D>;
+    ? RequiredObjectSelectorWrapper<S, R, Params, D>
+    : RequiredSelectorBuilder<S, R, Params, D>;
 
-export type OptionalDataParametricSelectorWrapper<S, P, R, D> = R extends unknown[]
-  ? OptionalArrayParametricSelectorWrapper<S, P, R[number], D>
+export type OptionalDataSelectorWrapper<
+  S,
+  R,
+  Params extends readonly any[],
+  D,
+> = R extends unknown[]
+  ? OptionalArraySelectorWrapper<S, R[number], Params, D>
   : IsObject<R> extends true
-    ? OptionalObjectParametricSelectorWrapper<S, P, R, D>
-    : OptionalParametricSelectorBuilder<S, P, R, D>;
+    ? OptionalObjectSelectorWrapper<S, R, Params, D>
+    : OptionalSelectorBuilder<S, R, Params, D>;
 
-export type RequiredPathSelectorType<S, R, D> = RequiredSelectorBuilder<S, R, D> &
-  RequiredDataSelectorWrapper<S, NonNullable<R>, D>;
-
-export type OptionalPathSelectorType<S, R, D> = OptionalSelectorBuilder<S, R, D> &
-  OptionalDataSelectorWrapper<S, NonNullable<R>, D>;
-
-export type RequiredPathParametricSelectorType<S, P, R, D> = RequiredParametricSelectorBuilder<
+export type RequiredPathSelectorType<
   S,
-  P,
   R,
-  D
-> &
-  RequiredDataParametricSelectorWrapper<S, P, NonNullable<R>, D>;
+  Params extends readonly any[],
+  D,
+> = RequiredSelectorBuilder<S, R, Params, D> &
+  RequiredDataSelectorWrapper<S, NonNullable<R>, Params, D>;
 
-export type OptionalPathParametricSelectorType<S, P, R, D> = OptionalParametricSelectorBuilder<
+export type OptionalPathSelectorType<
   S,
-  P,
   R,
-  D
-> &
-  OptionalDataParametricSelectorWrapper<S, P, NonNullable<R>, D>;
+  Params extends readonly any[],
+  D,
+> = OptionalSelectorBuilder<S, R, Params, D> &
+  OptionalDataSelectorWrapper<S, NonNullable<R>, Params, D>;
 
 const defaultVoidFunction = () => {
   return;
@@ -195,14 +157,19 @@ export const innerCreatePathSelector = (
   });
 };
 
-export function createPathSelector<S, R, P = void>(
-  baseSelector: P extends void ? Selector<S, R> : Selector<S, R, [P]>,
-): P extends void
-  ? IsOptional<R> extends true
-    ? OptionalPathSelectorType<S, R, [Selector<S, R>]>
-    : RequiredPathSelectorType<S, R, [Selector<S, R>]>
-  : IsOptional<R> extends true
-    ? OptionalPathParametricSelectorType<S, P, R, [Selector<S, R, [P]>]>
-    : RequiredPathParametricSelectorType<S, P, R, [Selector<S, R, [P]>]> {
+/**
+ * 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.
+ */
+export function createPathSelector<S, R, Params extends readonly any[] = []>(
+  baseSelector: (state: S, ...params: Params) => R,
+): IsOptional<R> extends true
+  ? OptionalPathSelectorType<S, R, Params, [typeof baseSelector]>
+  : RequiredPathSelectorType<S, R, Params, [typeof baseSelector]> {
   return innerCreatePathSelector(baseSelector as (...args: unknown[]) => unknown) as any;
 }

package/src/createPropSelector.ts

@@ -1,5 +1,5 @@
 import { Selector } from '@veksa/reselect';
-import { innerCreatePathSelector, RequiredPathParametricSelectorType } from './createPathSelector';
+import { innerCreatePathSelector, RequiredPathSelectorType } from './createPathSelector';
 import { Path } from './types';
 
 const propSelectorSymbol = Symbol.for('PropSelector');
@@ -8,10 +8,10 @@ export const isPropSelector = (selector: unknown): selector is { path: Path } =>
   return selector instanceof Object && propSelectorSymbol in selector;
 };
 
-export function createPropSelector<P>(): RequiredPathParametricSelectorType<
+export function createPropSelector<P>(): RequiredPathSelectorType<
   unknown,
   P,
-  P,
+  [P],
   [Selector<unknown, P, [P]>]
 > {
   const propsSelector = (_state: unknown, props: unknown) => props;
@@ -20,9 +20,10 @@ export function createPropSelector<P>(): RequiredPathParametricSelectorType<
     Object.defineProperty(selector, propSelectorSymbol, { value: true });
   };
 
-  return innerCreatePathSelector(
-    propsSelector,
-    [],
-    applyMeta,
-  ) as RequiredPathParametricSelectorType<unknown, P, P, [Selector<unknown, P, [P]>]>;
+  return innerCreatePathSelector(propsSelector, [], applyMeta) as RequiredPathSelectorType<
+    unknown,
+    P,
+    [P],
+    [Selector<unknown, P, [P]>]
+  >;
 }

package/src/createSequenceSelector.ts

@@ -1,14 +1,19 @@
-import { createSelector, Selector } from '@veksa/reselect';
+import { createSelector, Selector, SelectorResultArray } from '@veksa/reselect';
+import { AnySelector, MergedParams, MergedState } from './types';
 
-export function createSequenceSelector<S, R>(
-  selectors: Selector<S, R>[],
+/**
+ * Runs a group of selectors and collects their results positionally.
+ *
+ * The selectors are inferred as a tuple rather than an array, which is what
+ * makes the result a tuple of the individual result types and lets `state` and
+ * the extra arguments be merged per position. An array would collapse them into
+ * a union and resolve everything past `state` to `never`, which is why the
+ * plain and the parametric case used to need an overload each.
+ */
+export function createSequenceSelector<Selectors extends readonly AnySelector[]>(
+  selectors: [...Selectors],
   selectorCreator?: typeof createSelector,
-): Selector<S, R[]>;
-
-export function createSequenceSelector<S, P, R>(
-  selectors: Selector<S, R, [P]>[],
-  selectorCreator?: typeof createSelector,
-): Selector<S, R[], [P]>;
+): Selector<MergedState<Selectors>, SelectorResultArray<Selectors>, MergedParams<Selectors>>;
 
 export function createSequenceSelector(selectors: any, selectorCreator = createSelector) {
   return selectorCreator(selectors, (...results: unknown[]) => results);

package/src/index.ts

@@ -7,6 +7,7 @@ export { createBoundSelector } from './createBoundSelector';
 export { createEmptySelector } from './createEmptySelector';
 export { createAdaptedSelector } from './createAdaptedSelector';
 export { createChainSelector, type ChainSelectorOptions } from './createChainSelector';
+export { createSequenceSelector } from './createSequenceSelector';
 export { createCachedSequenceSelector } from './createCachedSequenceSelector';
 export { createCachedStructuredSelector } from './createCachedStructuredSelector';
 
@@ -24,3 +25,4 @@ export { initGarbageCollector, IntervalMapCache } from './cache/intervalMapCache
 export { TreeCache } from './cache/TreeCache';
 
 export { useSelector } from './_hooks/useSelector';
+export { useSelectors } from './_hooks/useSelectors';

package/src/keys/createKeySelectorComposer.ts

@@ -1,5 +1,5 @@
 import { KeySelector } from '@veksa/re-reselect';
-import { UnionToIntersection } from '../types';
+import { MergedParams, MergedState } from '../types';
 
 export const composedKeySelectorSymbol = Symbol.for('ComposedKeySelector');
 
@@ -9,39 +9,28 @@ export const composedKeySelectorSymbol = Symbol.for('ComposedKeySelector');
  */
 type AnyKeySelector = KeySelector<any>;
 
-/** Intersection of every input key selector's `state` argument. */
-type ComposedState<Ks extends readonly AnyKeySelector[]> = UnionToIntersection<
-  { [Index in keyof Ks]: Parameters<Ks[Index]>[0] }[number]
->;
-
-/** Union of every input key selector's `props` argument (position 1), if any. */
-type PropsUnion<Ks extends readonly AnyKeySelector[]> = {
-  [Index in keyof Ks]: Parameters<Ks[Index]> extends [any, infer Props, ...any[]] ? Props : never;
-}[number];
-
-/** Intersection of every input key selector's `props`, or `never` if none are parametric. */
-type ComposedProps<Ks extends readonly AnyKeySelector[]> = [PropsUnion<Ks>] extends [never]
-  ? never
-  : UnionToIntersection<PropsUnion<Ks>>;
-
 /**
  * The key selector produced by a {@link KeySelectorComposer}: a function that
- * intersects the `state` (and `props`, when any input is parametric) of every
- * composed key selector, tagged with the original inputs as `dependencies`.
+ * intersects the `state` and the extra arguments of every composed key
+ * selector, tagged with the original inputs as `dependencies`.
  */
-export type OutputKeySelector<S, P, D extends readonly AnyKeySelector[]> = ([P] extends [never]
-  ? (state: S) => unknown
-  : (state: S, props: P) => unknown) & {
+export type OutputKeySelector<
+  S,
+  Params extends readonly any[],
+  D extends readonly AnyKeySelector[],
+> = ((state: S, ...params: Params) => unknown) & {
   dependencies: D;
 };
 
 /**
  * Composes N key selectors into a single one. A single variadic signature with
- * tuple inference replaces the former per-arity overload set.
+ * tuple inference replaces the former per-arity overload set; `state` and the
+ * extra arguments are merged by the same helpers every other multi-selector
+ * creator in the library uses.
  */
 export type KeySelectorComposer = <Ks extends readonly AnyKeySelector[]>(
   ...keySelectors: Ks
-) => OutputKeySelector<ComposedState<Ks>, ComposedProps<Ks>, Ks>;
+) => OutputKeySelector<MergedState<Ks>, MergedParams<Ks>, Ks>;
 
 export function isComposedKeySelector(
   keySelector: AnyKeySelector,

package/src/types.ts

@@ -1,6 +1,17 @@
-import { Selector, SelectorArray } from '@veksa/reselect';
+import {
+  GetParamsFromSelectors,
+  GetStateFromSelectors,
+  Selector,
+  SelectorArray,
+} from '@veksa/reselect';
 import { OutputCachedSelector } from '@veksa/re-reselect';
 
+/**
+ * The loosest shape a selector can take: a function of `state` plus any number
+ * of extra arguments. Used as the constraint for variadic tuple inference.
+ */
+export type AnySelector = (state: any, ...params: any[]) => any;
+
 /**
  * A selector carrying optional debug metadata. In the unified model a
  * "parametric" selector is simply a selector whose `Params` tuple is non-empty,
@@ -18,12 +29,6 @@ export type NamedSelector<S, R, Params extends readonly any[] = [], D = unknown[
   dependencies?: D;
 };
 
-/**
- * Back-compat alias: a parametric selector is a {@link NamedSelector} whose
- * single extra argument is `Props`.
- */
-export type NamedParametricSelector<S, P, R, D = unknown[]> = NamedSelector<S, R, [P], D>;
-
 export type ReReselectSelector = OutputCachedSelector<SelectorArray, unknown>;
 
 export type CachedSelector = Pick<ReReselectSelector, 'cache' | 'keySelector'> &
@@ -41,3 +46,106 @@ export type UnionToIntersection<Union> = (
 ) extends (merged: infer Intersection) => void
   ? Intersection
   : never;
+
+/** The values of a group of selectors, whether it is an object or a tuple. */
+type SelectorsUnion<Selectors> = Selectors extends readonly AnySelector[]
+  ? Selectors[number]
+  : Selectors[keyof Selectors];
+
+/**
+ * The `state` argument of each selector in a union of them. Distributed over
+ * the union rather than matched against it, so each member is read on its own.
+ */
+type StateOf<S> = S extends AnySelector ? Parameters<S>[0] : never;
+
+/**
+ * The `props` argument of the selectors in a union that require one, or `never`
+ * for the ones that take none. The argument tuple is matched rather than the
+ * signature: a selector of `state` alone is assignable to one that also takes
+ * `props`, and would otherwise contribute `unknown`.
+ */
+type RequiredPropsOf<S> = S extends AnySelector
+  ? Parameters<S> extends [any, infer Props, ...any[]]
+    ? Props
+    : never
+  : never;
+
+/**
+ * The `props` argument of the selectors in a union that accept one without
+ * requiring it. An optional argument does not match the tuple pattern above,
+ * which is why it needs a pattern of its own; `undefined` is what the optional
+ * marker contributes and is dropped, so that intersecting the props of the
+ * group does not collapse to `never`.
+ *
+ * A selector that leaves its arguments open — `Selector<State, Result>` is
+ * `(state, ...args: any[]) => Result` — declares no props at all and must
+ * contribute nothing, or its `any` would swallow the props of every other
+ * selector in the group. It is told apart by the length of what follows
+ * `state`: an optional argument gives a finite `0 | 1`, a rest gives `number`.
+ */
+type OptionalPropsOf<S> = S extends AnySelector
+  ? Parameters<S> extends [any, any, ...any[]]
+    ? never
+    : Parameters<S> extends [any, ...infer Rest]
+      ? number extends Rest['length']
+        ? never
+        : Rest extends readonly []
+          ? never
+          : Exclude<Rest[0], undefined>
+      : never
+  : never;
+
+/**
+ * The `state` every selector in the group accepts: the intersection of their
+ * first arguments. An empty group constrains nothing, so it reads `unknown`
+ * rather than the `never` an intersection of no members would otherwise give.
+ */
+export type MergedState<Selectors> = Selectors extends readonly []
+  ? unknown
+  : Selectors extends readonly AnySelector[]
+    ? GetStateFromSelectors<Selectors>
+    : UnionToIntersection<StateOf<SelectorsUnion<Selectors>>>;
+
+/**
+ * The props of a union of selectors, as the argument tuple that reads all of
+ * them: empty when none takes props, optional when every selector that takes
+ * them declares them optional, required as soon as one selector requires them.
+ * The props themselves are intersected, so the argument satisfies each member.
+ */
+type UnionProps<Union, Required = RequiredPropsOf<Union>, Optional = OptionalPropsOf<Union>> = [
+  Required,
+] extends [never]
+  ? [Optional] extends [never]
+    ? []
+    : [props?: UnionToIntersection<Optional>]
+  : [props: UnionToIntersection<Required | Optional>];
+
+/**
+ * The extra arguments the group takes beyond `state`: `[]` when no selector is
+ * parametric, `[Props]` when some are — with the `Props` of every parametric
+ * selector intersected.
+ *
+ * A tuple of selectors is merged position by position, so a selector taking
+ * more than `props` keeps its later arguments. An object is merged through the
+ * union of its values instead, which stops at `props` but costs nothing per
+ * key: the keys carry no order worth recovering, and a batch of selectors has
+ * no reason to be capped at a size a component could plausibly reach.
+ */
+export type MergedParams<Selectors> = Selectors extends readonly AnySelector[]
+  ? GetParamsFromSelectors<Selectors>
+  : UnionProps<SelectorsUnion<Selectors>>;
+
+/**
+ * The same element-wise merge as {@link MergedParams}, for two argument tuples
+ * that are already known — the case of a step-by-step composition, where each
+ * step adds its own arguments to what the previous steps require.
+ */
+export type MergeParams<A extends readonly any[], B extends readonly any[]> = A extends readonly []
+  ? B
+  : B extends readonly []
+    ? A
+    : A extends readonly [infer AHead, ...infer ATail]
+      ? B extends readonly [infer BHead, ...infer BTail]
+        ? [AHead & BHead, ...MergeParams<ATail, BTail>]
+        : A
+      : B;