Infer correct state when input selectors are a mix of explicit and rest syntax in createSelector

src/types.ts

@@ -1,4 +1,4 @@
-import type { MergeParameters, ExtractParams } from './versionedTypes'
+import type { MergeParameters } from './versionedTypes'
 export type { MergeParameters } from './versionedTypes'
 
 /*
@@ -71,7 +71,8 @@ export type OutputParametricSelector<
   Result,
   Combiner extends UnknownFunction,
   Keys = {}
-> = ParametricSelector<State, Props, Result> & OutputSelectorFields<Combiner, Keys>
+> = ParametricSelector<State, Props, Result> &
+  OutputSelectorFields<Combiner, Keys>
 
 /** An array of input selectors */
 export type SelectorArray = ReadonlyArray<Selector>
@@ -89,13 +90,9 @@ export type EqualityFn = (a: any, b: any) => boolean
 export type SelectorResultArray<Selectors extends SelectorArray> =
   ExtractReturnType<Selectors>
 
-/** Finds union of the first parameter from an array of functions and turns it into an intersection */
-type GetIntersectedFirstParam<T extends readonly UnknownFunction[]> =
-  UnionToIntersection<ExtractParams<T>[number][0]>
-
 /** Determines the combined single "State" type (first arg) from all input selectors */
 export type GetStateFromSelectors<S extends SelectorArray> =
-  GetIntersectedFirstParam<S>
+  MergeParameters<S>[0]
 
 /** Determines the combined  "Params" type (all remaining args) from all input selectors */
 export type GetParamsFromSelectors<
@@ -122,6 +119,27 @@ export type Head<T> = T extends [any, ...any[]] ? T[0] : never
 /** All other items in an array */
 export type Tail<A> = A extends [any, ...infer Rest] ? Rest : never
 
+/** Last item in an array. Recursion also enables this to work with rest syntax - where the type of rest is extracted */
+export type ReverseHead<S extends readonly unknown[][]> = Tail<S> extends [
+  unknown
+]
+  ? S
+  : Tail<S> extends readonly unknown[][]
+  ? ReverseHead<Tail<S>>
+  : never
+
+/** All elements in array except last
+ *
+ * Recursion makes this work also when rest syntax has been used
+ * Runs _ReverseTail twice, because first pass turns last element into "never", and second pass removes it.
+ **/
+export type ReverseTail<S> = _ReverseTail<_ReverseTail<S>>
+type _ReverseTail<S> = Tail<S> extends [unknown]
+  ? [Head<S>]
+  : Tail<S> extends unknown[]
+  ? [Head<S>, ..._ReverseTail<Tail<S>>]
+  : never
+
 /** Extract only numeric keys from an array type */
 export type AllArrayKeys<A extends readonly any[]> = A extends any
   ? {

src/versionedTypes/index.ts

@@ -1 +1 @@
-export { MergeParameters, ExtractParams } from './ts47-mergeParameters'
+export { MergeParameters } from './ts47-mergeParameters'

src/versionedTypes/ts47-mergeParameters.ts

@@ -1,23 +1,21 @@
 // This entire implementation courtesy of Anders Hjelsberg:
 // https://github.com/microsoft/TypeScript/pull/50831#issuecomment-1253830522
 
+import { ReverseHead, ReverseTail } from '../types'
+
 type UnknownFunction = (...args: any[]) => any
 
-type LongestTuple<T extends readonly unknown[][]> = T extends [
-  infer U extends unknown[]
-]
+type LongestTuple<T> = T extends [infer U extends unknown[]]
   ? U
   : T extends [infer U, ...infer R extends unknown[][]]
   ? MostProperties<U, LongestTuple<R>>
   : never
 
 type MostProperties<T, U> = keyof U extends keyof T ? T : U
 
-type ElementAt<T extends unknown[], N extends keyof any> = N extends keyof T
-  ? T[N]
-  : unknown
+type ElementAt<T, N extends keyof any> = N extends keyof T ? T[N] : unknown
 
-type ElementsAt<T extends readonly unknown[][], N extends keyof any> = {
+type ElementsAt<T, N extends keyof any> = {
   [K in keyof T]: ElementAt<T[K], N>
 }
 
@@ -27,16 +25,42 @@ type Intersect<T extends readonly unknown[]> = T extends []
   ? H & Intersect<T>
   : T[number]
 
-type MergeTuples<
-  T extends readonly unknown[][],
-  L extends unknown[] = LongestTuple<T>
-> = {
-  [K in keyof L]: Intersect<ElementsAt<T, K>>
+type MergeTuples<T, L extends unknown[] = LongestTuple<T>> = {
+  [K in keyof L]: Intersect<
+    ElementsAt<T, K> extends readonly unknown[] ? ElementsAt<T, K> : never
+  >
 }
 
-export type ExtractParams<T extends readonly UnknownFunction[]> = {
+type ExtractParameters<T extends readonly UnknownFunction[]> = {
   [K in keyof T]: Parameters<T[K]>
 }
 
 export type MergeParameters<T extends readonly UnknownFunction[]> =
-  '0' extends keyof T ? MergeTuples<ExtractParams<T>> : Parameters<T[number]>
+  '0' extends keyof T
+    ? MergeTuples<MakeRestExplicit<ExtractParameters<T>>>
+    : Parameters<T[number]>
+
+type HasRest<S extends readonly unknown[]> = number extends S['length']
+  ? true
+  : false
+
+type HasExplicit<S extends readonly unknown[]> = '0' extends keyof S
+  ? true
+  : false
+
+type HasCombined<S extends readonly unknown[]> = true extends HasExplicit<S> &
+  HasRest<S>
+  ? true
+  : false
+
+type MakeRestExplicit<T extends readonly unknown[][]> =
+  true extends HasCombined<T>
+    ? [
+        ...ReverseTail<T>,
+        ReverseHead<T> extends readonly unknown[]
+          ? ReverseHead<T>[number]
+          : never
+      ]
+    : true extends HasRest<T>
+    ? [...T]
+    : T