reselect-kit 1.0.1 → 1.1.0

package/dist/reselectKit.d.ts

@@ -1,9 +1,14 @@
+import { GetParamsFromSelectors, GetStateFromSelectors, Selector, SelectorResultArray, SelectorResultsMap, SelectorsObject, createSelector, createSelectorCreator } from "@veksa/reselect";
 import { ICacheObject, KeySelector, PolymorphicCachedOptions } from "@veksa/re-reselect";
-import { Selector, SelectorResultsMap, SelectorsObject, createSelectorCreator } from "@veksa/reselect";
 //#region src/createSegmentSelector.d.ts
 declare function createSegmentSelector<State, SelectedSegment extends State | State[keyof State]>(fn: (state: State) => SelectedSegment, initial: SelectedSegment): (state: State) => SelectedSegment;
 //#endregion
 //#region src/types.d.ts
+/**
+ * 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.
+ */
+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,
@@ -16,11 +21,6 @@ type NamedSelector<S, R, Params extends readonly any[] = [], D = unknown[]> = Se
   selectorName?: string;
   dependencies?: D;
 };
-/**
- * Back-compat alias: a parametric selector is a {@link NamedSelector} whose
- * single extra argument is `Props`.
- */
-type NamedParametricSelector<S, P, R, D = unknown[]> = NamedSelector<S, R, [P], D>;
 type Path = string[];
 /**
  * Turns a union `A | B | C` into the intersection `A & B & C`. Not exported by
@@ -28,54 +28,108 @@ type Path = string[];
  * intersect the `state`/`props` of several selectors.
  */
 type UnionToIntersection<Union> = (Union extends unknown ? (distributed: Union) => void : never) 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.
+ */
+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.
+ */
+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.
+ */
+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;
 //#endregion
 //#region src/createPathSelector.d.ts
 type Defined<T> = Exclude<T, undefined>;
 type IsOptional<T> = undefined extends T ? true : null extends T ? true : false;
 type IsObject<T> = T extends object ? true : false;
-type PathSelector<S, R, D> = NamedSelector<S, R, [], D> & {
-  path: Path;
-};
-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.
+ */
+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>; };
-type RequiredSelectorBuilder<S, R, D> = R extends object ? { [K in keyof R]: () => PathSelector<S, NonNullable<R[K]>, D>; } : {};
-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>; } : {});
-type RequiredParametricSelectorBuilder<S, P, R, D> = R extends object ? { [K in keyof R]: () => PathParametricSelector<S, P, NonNullable<R[K]>, D>; } : {};
-type OptionalParametricSelectorBuilder<S, P, R, D> = ((defaultValue?: R) => PathParametricSelector<S, P, R extends undefined ? Defined<R> : R, D>) & (R extends object ? { [K in keyof Required<R>]: () => PathParametricSelector<S, P, NonNullable<R[K]>, D>; } : {});
-type RequiredObjectSelectorWrapper<S, R, D> = { [K in keyof R]-?: IsOptional<R[K]> extends true ? OptionalPathSelectorType<S, R[K], D> : RequiredPathSelectorType<S, R[K], D>; };
-type OptionalObjectSelectorWrapper<S, R, D> = { [K in keyof R]-?: OptionalPathSelectorType<S, R[K], D>; };
-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>; };
-type OptionalObjectParametricSelectorWrapper<S, P, R, D> = { [K in keyof R]-?: OptionalPathParametricSelectorType<S, P, R[K], D>; };
-type RequiredArraySelectorWrapper<S, R, D> = {
-  length: RequiredPathSelectorType<S, number, D>;
-  [K: number]: IsOptional<R> extends true ? OptionalPathSelectorType<S, R, D> : RequiredPathSelectorType<S, R, D>;
-};
-type OptionalArraySelectorWrapper<S, R, D> = {
-  length: RequiredPathSelectorType<S, number, D>;
-  [K: number]: OptionalPathSelectorType<S, R, D>;
-};
-type RequiredArrayParametricSelectorWrapper<S, P, R, D> = {
-  length: RequiredPathParametricSelectorType<S, P, number, D>;
-  [K: number]: IsOptional<R> extends true ? OptionalPathParametricSelectorType<S, P, R, D> : RequiredPathParametricSelectorType<S, P, R, D>;
+type RequiredSelectorBuilder<S, R, Params extends readonly any[], D> = R extends object ? { [K in keyof R]: () => PathSelector<S, NonNullable<R[K]>, Params, D>; } : {};
+type OptionalSelectorBuilder<S, R, Params extends readonly any[], D> = ((defaultValue?: R) => PathSelector<S, R extends undefined ? Defined<R> : R, Params, D>) & (R extends object ? { [K in keyof Required<R>]: () => PathSelector<S, NonNullable<R[K]>, Params, D>; } : {});
+type RequiredObjectSelectorWrapper<S, R, Params extends readonly any[], D> = { [K in keyof R]-?: IsOptional<R[K]> extends true ? OptionalPathSelectorType<S, R[K], Params, D> : RequiredPathSelectorType<S, R[K], Params, D>; };
+type OptionalObjectSelectorWrapper<S, R, Params extends readonly any[], D> = { [K in keyof R]-?: OptionalPathSelectorType<S, R[K], Params, D>; };
+type RequiredArraySelectorWrapper<S, R, Params extends readonly any[], D> = {
+  length: RequiredPathSelectorType<S, number, Params, D>;
+  [K: number]: IsOptional<R> extends true ? OptionalPathSelectorType<S, R, Params, D> : RequiredPathSelectorType<S, R, Params, D>;
 };
-type OptionalArrayParametricSelectorWrapper<S, P, R, D> = {
-  length: RequiredPathParametricSelectorType<S, P, number, D>;
-  [K: number]: OptionalPathParametricSelectorType<S, P, R, D>;
+type OptionalArraySelectorWrapper<S, R, Params extends readonly any[], D> = {
+  length: RequiredPathSelectorType<S, number, Params, D>;
+  [K: number]: OptionalPathSelectorType<S, R, Params, D>;
 };
-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>;
-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>;
-type RequiredDataParametricSelectorWrapper<S, P, R, D> = R extends unknown[] ? RequiredArrayParametricSelectorWrapper<S, P, R[number], D> : IsObject<R> extends true ? RequiredObjectParametricSelectorWrapper<S, P, R, D> : RequiredParametricSelectorBuilder<S, P, R, D>;
-type OptionalDataParametricSelectorWrapper<S, P, R, D> = R extends unknown[] ? OptionalArrayParametricSelectorWrapper<S, P, R[number], D> : IsObject<R> extends true ? OptionalObjectParametricSelectorWrapper<S, P, R, D> : OptionalParametricSelectorBuilder<S, P, R, D>;
-type RequiredPathSelectorType<S, R, D> = RequiredSelectorBuilder<S, R, D> & RequiredDataSelectorWrapper<S, NonNullable<R>, D>;
-type OptionalPathSelectorType<S, R, D> = OptionalSelectorBuilder<S, R, D> & OptionalDataSelectorWrapper<S, NonNullable<R>, D>;
-type RequiredPathParametricSelectorType<S, P, R, D> = RequiredParametricSelectorBuilder<S, P, R, D> & RequiredDataParametricSelectorWrapper<S, P, NonNullable<R>, D>;
-type OptionalPathParametricSelectorType<S, P, R, D> = OptionalParametricSelectorBuilder<S, P, R, D> & OptionalDataParametricSelectorWrapper<S, P, NonNullable<R>, D>;
-declare 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]>]>;
+type RequiredDataSelectorWrapper<S, R, Params extends readonly any[], D> = R extends unknown[] ? RequiredArraySelectorWrapper<S, R[number], Params, D> : IsObject<R> extends true ? RequiredObjectSelectorWrapper<S, R, Params, D> : RequiredSelectorBuilder<S, R, Params, D>;
+type OptionalDataSelectorWrapper<S, R, Params extends readonly any[], D> = R extends unknown[] ? OptionalArraySelectorWrapper<S, R[number], Params, D> : IsObject<R> extends true ? OptionalObjectSelectorWrapper<S, R, Params, D> : OptionalSelectorBuilder<S, R, Params, D>;
+type RequiredPathSelectorType<S, R, Params extends readonly any[], D> = RequiredSelectorBuilder<S, R, Params, D> & RequiredDataSelectorWrapper<S, NonNullable<R>, Params, D>;
+type OptionalPathSelectorType<S, R, Params extends readonly any[], D> = OptionalSelectorBuilder<S, R, Params, D> & OptionalDataSelectorWrapper<S, NonNullable<R>, Params, D>;
+/**
+ * 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.
+ */
+declare 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]>;
 //#endregion
 //#region src/createPropSelector.d.ts
-declare function createPropSelector<P>(): RequiredPathParametricSelectorType<unknown, P, P, [Selector<unknown, P, [P]>]>;
+declare function createPropSelector<P>(): RequiredPathSelectorType<unknown, P, [P], [Selector<unknown, P, [P]>]>;
 //#endregion
 //#region src/keys/createKeySelectorComposer.d.ts
 /**
@@ -83,38 +137,38 @@ declare function createPropSelector<P>(): RequiredPathParametricSelectorType<unk
  * number of extra arguments (props, ...). Used for variadic tuple inference.
  */
 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`.
  */
-type OutputKeySelector<S, P, D extends readonly AnyKeySelector[]> = ([P] extends [never] ? (state: S) => unknown : (state: S, props: P) => unknown) & {
+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.
  */
-type KeySelectorComposer = <Ks extends readonly AnyKeySelector[]>(...keySelectors: Ks) => OutputKeySelector<ComposedState<Ks>, ComposedProps<Ks>, Ks>;
+type KeySelectorComposer = <Ks extends readonly AnyKeySelector[]>(...keySelectors: Ks) => OutputKeySelector<MergedState<Ks>, MergedParams<Ks>, Ks>;
 declare function createKeySelectorComposer(baseKeySelectorComposer: (...keySelectors: AnyKeySelector[]) => AnyKeySelector): KeySelectorComposer;
 //#endregion
 //#region src/createBoundSelector.d.ts
 /**
- * The special type to prevent binding of non optional props on optional values
+ * The bound selector: what the binding did not supply is what is left to pass.
+ * A binding covering every prop leaves an empty argument tuple, which is what a
+ * plain selector is in the unified model — so one type covers both cases.
+ *
+ * The outer condition is the guard against binding a prop the base selector
+ * declares as optional with a value that is not.
  */
-type BoundSelector<S, P2, P1 extends Partial<P2>, R> = P2 extends Pick<P1, keyof P2> ? Exclude<keyof P1, keyof P2> extends never ? NamedSelector<S, R> : NamedParametricSelector<S, Omit<P1, keyof P2>, R> : never;
+type BoundSelector<S, P2, P1 extends Partial<P2>, R> = P2 extends Pick<P1, keyof P2> ? NamedSelector<S, R, Exclude<keyof P1, keyof P2> extends never ? [] : [Omit<P1, keyof P2>]> : never;
 type BoundSelectorOptions<S, P2, P1 extends Partial<P2>, R> = {
-  bindingStrategy?: (baseSelector: Selector<S, R, [P1]>, binding: P2) => Selector<S, R, [Omit<P1, keyof P2>]>;
+  bindingStrategy?: (baseSelector: (state: S, props: P1) => R, binding: P2) => (state: S, props: Omit<P1, keyof P2>) => R;
   keySelectorComposer?: KeySelectorComposer;
 };
-declare const createBoundInnerSelector: <S, P2 extends object, P1 extends Partial<P2>, R, OR extends R>(baseSelector: Selector<S, R, [P1]>, binding: P2, options?: BoundSelectorOptions<S, P2, P1, OR>) => BoundSelector<S, P2, P1, R>;
-declare const createBoundSelector: typeof createBoundInnerSelector;
+declare const createBoundSelector: <S, P2 extends object, P1 extends Partial<P2>, R, OR extends R>(baseSelector: (state: S, props: P1) => R, binding: P2, options?: BoundSelectorOptions<S, P2, P1, OR>) => BoundSelector<S, P2, P1, R>;
 //#endregion
 //#region src/createEmptySelector.d.ts
 /**
@@ -131,15 +185,21 @@ declare const createBoundSelector: typeof createBoundInnerSelector;
 declare const createEmptySelector: <S, R>(baseSelector: Selector<S, R, any[]>) => Selector<S, R | undefined>;
 //#endregion
 //#region src/createAdaptedSelector.d.ts
-declare const createAdaptedSelector: <S, P1 extends object, P2, R>(baseSelector: Selector<S, R, [P1]>, mapping: (props: P2) => P1) => NamedParametricSelector<S, P2, R>;
+/**
+ * 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.
+ */
+declare const createAdaptedSelector: <S, P1 extends object, P2, R>(baseSelector: (state: S, props: P1) => R, mapping: (props: P2) => P1) => NamedSelector<S, R, [P2]>;
 //#endregion
 //#region src/createChainSelector.d.ts
-type SelectorChain<R1, S1, R2> = (result: R1) => Selector<S1, R2>;
-type ParametricSelectorChain<R1, S1, P1, R2> = (result: R1) => Selector<S1, R2, [P1]>;
-type SelectorChainHierarchy<C extends SelectorChain<any, any, any>, H extends SelectorChainHierarchy<any, any>> = C & {
-  parentChain?: H;
-};
-type ParametricSelectorChainHierarchy<C extends ParametricSelectorChain<any, any, any, any>, H extends ParametricSelectorChainHierarchy<any, any>> = C & {
+/**
+ * A chain step: given the previous level's result, it returns the selector the
+ * next level reads. `Params` is empty for a step that only needs `state`, so a
+ * single type covers what used to be a plain and a parametric variant.
+ */
+type SelectorChain<R1, S1, R2, Params extends readonly any[] = []> = (result: R1) => Selector<S1, R2, Params>;
+type SelectorChainHierarchy<C extends SelectorChain<any, any, any, any>, H extends SelectorChainHierarchy<any, any>> = C & {
   parentChain?: H;
 };
 type CreateSelectorOptions<SelectorCreator extends typeof createSelectorCreator> = {
@@ -150,42 +210,60 @@ type ChainSelectorOptions<SelectorCreator extends typeof createSelectorCreator =
   createSelectorOptions?: () => CreateSelectorOptions<SelectorCreator>;
   keySelectorComposer?: KeySelectorComposer;
 };
-interface ChainSelectorResult<S1, R1> {
-  chain: <S2, R2 = any>(fn: SelectorChain<R1, S2, R2>, chainOptions?: ChainSelectorOptions) => ChainSelectorResult<S1 & S2, R2>;
-  map: <R2>(fn: (result: R1) => R2, mapOptions?: ChainSelectorOptions) => ChainSelectorResult<S1, R2>;
-  build: () => Selector<S1, R1, []> & {
+/**
+ * Every level of the chain carries the arguments its selector needs. A level
+ * that only reads `state` leaves `Params` empty, and one that reads props adds
+ * them — so a step introducing props makes them required for the whole built
+ * selector, whether or not the base selector had any.
+ *
+ * `Params` defaults to empty on the entry point, so that
+ * `createChainSelector<State, Result>(selector)` keeps working for callers that
+ * spell the type arguments out.
+ */
+interface ChainSelectorResult<S1, R1, Params extends readonly any[]> {
+  chain: <S2, R2, Params2 extends readonly any[]>(fn: (result: R1) => (state: S2, ...params: Params2) => R2, chainOptions?: ChainSelectorOptions) => ChainSelectorResult<S1 & S2, R2, MergeParams<Params, Params2>>;
+  map: <R2>(fn: (result: R1) => R2, mapOptions?: ChainSelectorOptions) => ChainSelectorResult<S1, R2, Params>;
+  build: () => Selector<S1, R1, Params> & {
     chainHierarchy: SelectorChainHierarchy<any, any> | undefined;
   };
 }
-interface ParametricChainSelectorResult<S1, P1, R1> {
-  chain: <S2, P2 = unknown, R2 = any>(fn: ParametricSelectorChain<R1, S2, P2, R2>, chainOptions?: ChainSelectorOptions) => ParametricChainSelectorResult<S1 & S2, P1 & P2, R2>;
-  map: <R2>(fn: (result: R1) => R2, mapOptions?: ChainSelectorOptions) => ParametricChainSelectorResult<S1, P1, R2>;
-  build: () => Selector<S1, R1, [P1]> & {
-    chainHierarchy: ParametricSelectorChainHierarchy<any, any> | undefined;
-  };
-}
-declare function createChainSelector<S1, R1>(selector: Selector<S1, R1>, options?: ChainSelectorOptions, prevChain?: SelectorChainHierarchy<any, any>): ChainSelectorResult<S1, R1>;
-declare function createChainSelector<S1, P1, R1>(selector: Selector<S1, R1, [P1]>, options?: ChainSelectorOptions, prevChain?: ParametricSelectorChainHierarchy<any, any>): ParametricChainSelectorResult<S1, P1, R1>;
+declare function createChainSelector<S1, R1, Params extends readonly any[] = []>(selector: (state: S1, ...params: Params) => R1, options?: ChainSelectorOptions, prevChain?: SelectorChainHierarchy<any, any>): ChainSelectorResult<S1, R1, Params>;
+//#endregion
+//#region src/createSequenceSelector.d.ts
+/**
+ * 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.
+ */
+declare function createSequenceSelector<Selectors extends readonly AnySelector[]>(selectors: [...Selectors], selectorCreator?: typeof createSelector): Selector<MergedState<Selectors>, SelectorResultArray<Selectors>, MergedParams<Selectors>>;
 //#endregion
 //#region src/createCachedSequenceSelector.d.ts
-declare function createCachedSequenceSelector<S, R>(selectors: Selector<S, R>[]): (options: PolymorphicCachedOptions<Selector<S, R>[], R[]>) => Selector<S, R[]>;
-declare function createCachedSequenceSelector<S, P, R>(selectors: Selector<S, R, [P]>[]): (options: PolymorphicCachedOptions<Selector<S, R, [P]>[], R[]>) => Selector<S, R[], [P]>;
+/**
+ * The cached counterpart of {@link createSequenceSelector}. The inferred tuple
+ * reaches `PolymorphicCachedOptions` as-is, so re-reselect types the caller's
+ * `keySelector` with the exact arguments of the group.
+ */
+declare function createCachedSequenceSelector<Selectors extends readonly AnySelector[]>(selectors: [...Selectors]): (options: PolymorphicCachedOptions<Selectors, SelectorResultArray<Selectors>>) => Selector<MergedState<Selectors>, SelectorResultArray<Selectors>, MergedParams<Selectors>>;
 //#endregion
 //#region src/createCachedStructuredSelector.d.ts
-/** Intersection of the `state` argument of every selector in the object. */
-type StructuredState<M extends SelectorsObject> = UnionToIntersection<{ [K in keyof M]: Parameters<M[K]>[0]; }[keyof M]>;
-/** Union of the `props` argument (position 1) of every parametric selector. */
-type StructuredPropsUnion<M extends SelectorsObject> = { [K in keyof M]: Parameters<M[K]> extends [any, infer Props, ...any[]] ? Props : never; }[keyof M];
-/** The extra-arguments tuple: `[Props]` when any selector is parametric, else `[]`. */
-type StructuredParams<M extends SelectorsObject> = [StructuredPropsUnion<M>] extends [never] ? [] : [UnionToIntersection<StructuredPropsUnion<M>>];
-/** The input selectors as reselect sees them, used to type the cached options. */
-type StructuredInputs<M extends SelectorsObject> = Selector<StructuredState<M>, unknown, StructuredParams<M>>[];
+/**
+ * The input selectors as re-reselect reads them when typing the caller's
+ * `keySelector`: it takes `state` and the extra arguments off the group, and
+ * both are already merged here. Putting the selectors back in key order would
+ * type the arguments no more precisely and would cost a type instantiation per
+ * key, capping the batch at roughly fifty fields.
+ */
+type StructuredInputs<M extends SelectorsObject> = Selector<MergedState<M>, unknown, MergedParams<M>>[];
 /**
  * A single variadic signature replaces the former `Selector` / `ParametricSelector`
  * conditional: `state` and `props` are derived from the selectors object, so a
  * parametric input keeps its props type without a separate overload.
  */
-declare function createCachedStructuredSelector<M extends SelectorsObject>(selectors: M): (options: PolymorphicCachedOptions<StructuredInputs<M>, SelectorResultsMap<M>>) => Selector<StructuredState<M>, SelectorResultsMap<M>, StructuredParams<M>>;
+declare function createCachedStructuredSelector<M extends SelectorsObject>(selectors: M): (options: PolymorphicCachedOptions<StructuredInputs<M>, SelectorResultsMap<M>>) => Selector<MergedState<M>, SelectorResultsMap<M>, MergedParams<M>>;
 //#endregion
 //#region src/keys/defaultKeySelector.d.ts
 declare const defaultKeySelector: () => string;
@@ -241,8 +319,39 @@ declare class TreeCache implements ICacheObject {
 }
 //#endregion
 //#region src/_hooks/useSelector.d.ts
-declare function useSelector<S extends object, R>(selector: (state: S) => R): R;
-declare function useSelector<S extends object, P, R>(selector: (state: S, props: P) => R, props: P): R;
+/**
+ * Reads one selector from the store. Props are compared shallowly, so an inline
+ * object literal does not invalidate the selector on every render.
+ *
+ * A single variadic signature covers both the plain and the parametric case:
+ * `Params` is inferred from the selector itself and is empty when the selector
+ * takes nothing but `state`, so the props argument is required exactly when the
+ * selector declares one. `NoInfer` keeps the props argument out of that
+ * inference -- otherwise an inline object literal would widen `Params` instead
+ * of being checked against what the selector declares. It defaults to empty so
+ * that `useSelector<State, Result>(selector)` -- the call site of the former
+ * plain overload -- keeps compiling without spelling the tuple out.
+ *
+ * Use {@link useSelectors} to read several selectors through a single store
+ * subscription.
+ */
+declare function useSelector<S extends object, R, Params extends readonly any[] = []>(selector: (state: S, ...params: Params) => R, ...params: NoInfer<Params>): R;
+//#endregion
+//#region src/_hooks/useSelectors.d.ts
+/**
+ * Reads a batch of selectors through a single store subscription and returns
+ * their results as one object.
+ *
+ * Seven `useSelector` calls in a row component mean seven store listeners,
+ * seven `useSyncExternalStore` instances and seven snapshot comparisons per
+ * dispatch. This collapses them into one of each; the trade-off is that any
+ * tracked state segment changing re-runs the whole batch, which for memoized
+ * selectors is a cache hit per field.
+ *
+ * The memoization lives in the component instance, so rows do not compete for
+ * a shared cache the way a module-level structured selector would.
+ */
+declare function useSelectors<M extends SelectorsObject>(selectors: M, ...params: MergedParams<M>): SelectorResultsMap<M>;
 //#endregion
-export { type ChainSelectorOptions, IntervalMapCache, TreeCache, arrayComposeKeySelectors, createAdaptedSelector, createBoundSelector, createCachedSequenceSelector, createCachedStructuredSelector, createChainSelector, createEmptySelector, createKeySelectorComposer, createKeySelectorCreator, createPathSelector, createPropSelector, createSegmentSelector, defaultKeySelector, initGarbageCollector, isDebugMode, setDebugMode, stringComposeKeySelectors, useSelector };
+export { type ChainSelectorOptions, IntervalMapCache, TreeCache, arrayComposeKeySelectors, createAdaptedSelector, createBoundSelector, createCachedSequenceSelector, createCachedStructuredSelector, createChainSelector, createEmptySelector, createKeySelectorComposer, createKeySelectorCreator, createPathSelector, createPropSelector, createSegmentSelector, createSequenceSelector, defaultKeySelector, initGarbageCollector, isDebugMode, setDebugMode, stringComposeKeySelectors, useSelector, useSelectors };
 //# sourceMappingURL=reselectKit.d.ts.map