redux - npm Package Compare versions

Comparing version 5.0.0-alpha.4 to 5.0.0-alpha.5

dist/redux.d.ts

@@ -80,12 +80,15 @@ /**
  * @template A The type of actions the reducer can potentially respond to.
+ * @template PreloadedState The type of state consumed by this reducer the first time it's called.
  */
-type Reducer<S = any, A extends Action = AnyAction> = (state: S | undefined, action: A) => S;
+type Reducer<S = any, A extends Action = AnyAction, PreloadedState = S> = (state: S | PreloadedState | undefined, action: A) => S;
 /**
  * Object whose values correspond to different reducer functions.
  *
+ * @template S The combined state of the reducers.
  * @template A The type of actions the reducers can potentially respond to.
+ * @template PreloadedState The combined preloaded state of the reducers.
  */
-type ReducersMapObject<S = any, A extends Action = AnyAction> = {
-    [K in keyof S]: Reducer<S[K], A>;
-};
+type ReducersMapObject<S = any, A extends Action = AnyAction, PreloadedState = S> = keyof PreloadedState extends keyof S ? {
+    [K in keyof S]: Reducer<S[K], A, K extends keyof PreloadedState ? PreloadedState[K] : never>;
+} : never;
 /**
@@ -96,4 +99,4 @@ * Infer a combined state shape from a `ReducersMapObject`.
  */
-type StateFromReducersMapObject<M> = M extends ReducersMapObject ? {
-    [P in keyof M]: M[P] extends Reducer<infer S, any> ? S : never;
+type StateFromReducersMapObject<M> = M[keyof M] extends Reducer<any, any, any> | undefined ? {
+    [P in keyof M]: M[P] extends Reducer<infer S> ? S : never;
 } : never;
@@ -105,5 +108,3 @@ /**
  */
-type ReducerFromReducersMapObject<M> = M extends {
-    [P in keyof M]: infer R;
-} ? R extends Reducer<any, any> ? R : never : never;
+type ReducerFromReducersMapObject<M> = M[keyof M] extends Reducer<any, any, any> | undefined ? M[keyof M] : never;
 /**
@@ -114,3 +115,3 @@ * Infer action type from a reducer function.
  */
-type ActionFromReducer<R> = R extends Reducer<any, infer A> ? A : never;
+type ActionFromReducer<R> = R extends Reducer<any, infer A, any> | undefined ? A : never;
 /**
@@ -121,39 +122,13 @@ * Infer action union type from a `ReducersMapObject`.
  */
-type ActionFromReducersMapObject<M> = M extends ReducersMapObject ? ActionFromReducer<ReducerFromReducersMapObject<M>> : never;
-
+type ActionFromReducersMapObject<M> = ActionFromReducer<ReducerFromReducersMapObject<M>>;
 /**
- * Internal "virtual" symbol used to make the `CombinedState` type unique.
- */
-declare const $CombinedState: unique symbol;
-/**
- * State base type for reducers created with `combineReducers()`.
+ * Infer a combined preloaded state shape from a `ReducersMapObject`.
  *
- * This type allows the `createStore()` method to infer which levels of the
- * preloaded state can be partial.
- *
- * Because Typescript is really duck-typed, a type needs to have some
- * identifying property to differentiate it from other types with matching
- * prototypes for type checking purposes. That's why this type has the
- * `$CombinedState` symbol property. Without the property, this type would
- * match any object. The symbol doesn't really exist because it's an internal
- * (i.e. not exported), and internally we never check its value. Since it's a
- * symbol property, it's not expected to be unumerable, and the value is
- * typed as always undefined, so its never expected to have a meaningful
- * value anyway. It just makes this type distinguishable from plain `{}`.
+ * @template M Object map of reducers as provided to `combineReducers(map: M)`.
  */
-interface EmptyObject {
-    readonly [$CombinedState]?: undefined;
-}
-type CombinedState<S> = EmptyObject & S;
+type PreloadedStateShapeFromReducersMapObject<M> = M[keyof M] extends Reducer<any, any, any> | undefined ? {
+    [P in keyof M]: M[P] extends (inputState: infer InputState, action: AnyAction) => any ? InputState : never;
+} : never;
+
 /**
- * Recursively makes combined state objects partial. Only combined state _root
- * objects_ (i.e. the generated higher level object with keys mapping to
- * individual reducers) are partial.
- */
-type PreloadedState<S> = Required<S> extends EmptyObject ? S extends CombinedState<infer S1> ? {
-    [K in keyof S1]?: S1[K] extends object ? PreloadedState<S1[K]> : S1[K];
-} : S : {
-    [K in keyof S]: S[K] extends string | number | boolean | symbol ? S[K] : PreloadedState<S[K]>;
-};
-/**
  * A *dispatching function* (or simply *dispatch function*) is a function that
@@ -314,2 +289,3 @@ * accepts an action or an async action; it then may or may not dispatch one
  * @template A The type of actions which may be dispatched.
+ * @template PreloadedState The initial state that is passed into the reducer.
  * @template Ext Store extension that is mixed in to the Store type.
@@ -320,3 +296,3 @@ * @template StateExt State extension that is mixed into the state type.
     <S, A extends Action, Ext extends {} = {}, StateExt extends {} = {}>(reducer: Reducer<S, A>, enhancer?: StoreEnhancer<Ext, StateExt>): Store<S, A, StateExt> & Ext;
-    <S, A extends Action, Ext extends {} = {}, StateExt extends {} = {}>(reducer: Reducer<S, A>, preloadedState?: PreloadedState<S>, enhancer?: StoreEnhancer<Ext>): Store<S, A, StateExt> & Ext;
+    <S, A extends Action, Ext extends {} = {}, StateExt extends {} = {}, PreloadedState = S>(reducer: Reducer<S, A, PreloadedState>, preloadedState?: PreloadedState | undefined, enhancer?: StoreEnhancer<Ext>): Store<S, A, StateExt> & Ext;
 }
@@ -345,3 +321,3 @@ /**
 type StoreEnhancer<Ext extends {} = {}, StateExt extends {} = {}> = <NextExt extends {}, NextStateExt extends {}>(next: StoreEnhancerStoreCreator<NextExt, NextStateExt>) => StoreEnhancerStoreCreator<NextExt & Ext, NextStateExt & StateExt>;
-type StoreEnhancerStoreCreator<Ext extends {} = {}, StateExt extends {} = {}> = <S = any, A extends Action = AnyAction>(reducer: Reducer<S, A>, preloadedState?: PreloadedState<S>) => Store<S, A, StateExt> & Ext;
+type StoreEnhancerStoreCreator<Ext extends {} = {}, StateExt extends {} = {}> = <S, A extends Action, PreloadedState>(reducer: Reducer<S, A, PreloadedState>, preloadedState?: PreloadedState | undefined) => Store<S, A, StateExt> & Ext;
 
@@ -399,3 +375,3 @@ /**
  */
-declare function createStore<S, A extends Action, Ext extends {} = {}, StateExt extends {} = {}>(reducer: Reducer<S, A>, preloadedState?: PreloadedState<S>, enhancer?: StoreEnhancer<Ext, StateExt>): Store<S, A, StateExt> & Ext;
+declare function createStore<S, A extends Action, Ext extends {} = {}, StateExt extends {} = {}, PreloadedState = S>(reducer: Reducer<S, A, PreloadedState>, preloadedState?: PreloadedState | undefined, enhancer?: StoreEnhancer<Ext, StateExt>): Store<S, A, StateExt> & Ext;
 /**
@@ -462,3 +438,3 @@ * Creates a Redux store that holds the state tree.
  */
-declare function legacy_createStore<S, A extends Action, Ext extends {} = {}, StateExt extends {} = {}>(reducer: Reducer<S, A>, preloadedState?: PreloadedState<S>, enhancer?: StoreEnhancer<Ext, StateExt>): Store<S, A, StateExt> & Ext;
+declare function legacy_createStore<S, A extends Action, Ext extends {} = {}, StateExt extends {} = {}, PreloadedState = S>(reducer: Reducer<S, A, PreloadedState>, preloadedState?: PreloadedState | undefined, enhancer?: StoreEnhancer<Ext, StateExt>): Store<S, A, StateExt> & Ext;
 
@@ -483,5 +459,3 @@ /**
  */
-declare function combineReducers<S>(reducers: ReducersMapObject<S, any>): Reducer<CombinedState<S>>;
-declare function combineReducers<S, A extends Action = AnyAction>(reducers: ReducersMapObject<S, A>): Reducer<CombinedState<S>, A>;
-declare function combineReducers<M extends ReducersMapObject>(reducers: M): Reducer<CombinedState<StateFromReducersMapObject<M>>, ActionFromReducersMapObject<M>>;
+declare function combineReducers<M>(reducers: M): M[keyof M] extends Reducer<any, any, any> | undefined ? Reducer<StateFromReducersMapObject<M>, ActionFromReducersMapObject<M>, Partial<PreloadedStateShapeFromReducersMapObject<M>>> : never;
 
@@ -532,5 +506,5 @@ /**
  */
-interface Middleware<_DispatchExt = {}, // TODO: remove unused component (breaking change)
+interface Middleware<_DispatchExt = {}, // TODO: see if this can be used in type definition somehow (can't be removed, as is used to get final dispatch type)
 S = any, D extends Dispatch = Dispatch> {
-    (api: MiddlewareAPI<D, S>): (next: D) => (action: D extends Dispatch<infer A> ? A : never) => any;
+    (api: MiddlewareAPI<D, S>): (next: (action: unknown) => unknown) => (action: unknown) => unknown;
 }
@@ -608,2 +582,2 @@
 
-export { Action, ActionCreator, ActionCreatorsMapObject, ActionFromReducer, ActionFromReducersMapObject, AnyAction, CombinedState, Dispatch, Middleware, MiddlewareAPI, Observable, Observer, PreloadedState, Reducer, ReducerFromReducersMapObject, ReducersMapObject, StateFromReducersMapObject, Store, StoreCreator, StoreEnhancer, StoreEnhancerStoreCreator, Unsubscribe, ActionTypes as __DO_NOT_USE__ActionTypes, applyMiddleware, bindActionCreators, combineReducers, compose, createStore, legacy_createStore };
+export { Action, ActionCreator, ActionCreatorsMapObject, ActionFromReducer, ActionFromReducersMapObject, AnyAction, Dispatch, Middleware, MiddlewareAPI, Observable, Observer, PreloadedStateShapeFromReducersMapObject, Reducer, ReducerFromReducersMapObject, ReducersMapObject, StateFromReducersMapObject, Store, StoreCreator, StoreEnhancer, StoreEnhancerStoreCreator, Unsubscribe, ActionTypes as __DO_NOT_USE__ActionTypes, applyMiddleware, bindActionCreators, combineReducers, compose, createStore, legacy_createStore };

package.json

 {
   "name": "redux",
-  "version": "5.0.0-alpha.4",
+  "version": "5.0.0-alpha.5",
   "description": "Predictable state container for JavaScript apps",
@@ -51,2 +51,3 @@ "license": "MIT",
     "test:cov": "vitest --coverage",
+    "test:typecheck": "tsc -p test && echo \"Types passed\"",
     "build": "tsup",
@@ -53,0 +54,0 @@ "prepublishOnly": "yarn clean && yarn check-types && yarn format:check && yarn lint && yarn test",

README.md

@@ -11,3 +11,3 @@ # <a href='https://redux.js.org'><img src='https://camo.githubusercontent.com/f28b5bc7822f1b7bb28a96d8d09e7d79169248fc/687474703a2f2f692e696d6775722e636f6d2f4a65567164514d2e706e67' height='60' alt='Redux Logo' aria-label='redux.js.org' /></a>
 
-![GitHub Workflow Status](https://img.shields.io/github/workflow/status/reduxjs/redux/Tests/master?style=flat-square)
+![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/reduxjs/redux/test.yaml?branch=master&event=push&style=flat-square)
 [![npm version](https://img.shields.io/npm/v/redux.svg?style=flat-square)](https://www.npmjs.com/package/redux)
@@ -14,0 +14,0 @@ [![npm downloads](https://img.shields.io/npm/dm/redux.svg?style=flat-square)](https://www.npmjs.com/package/redux)

src/applyMiddleware.ts

 import compose from './compose'
 import { Middleware, MiddlewareAPI } from './types/middleware'
-import { AnyAction } from './types/actions'
-import { StoreEnhancer, Dispatch, PreloadedState } from './types/store'
-import { Reducer } from './types/reducers'
+import { StoreEnhancer, Dispatch } from './types/store'
 
@@ -58,27 +56,23 @@ /**
 ): StoreEnhancer<any> {
-  return createStore =>
-    <S, A extends AnyAction>(
-      reducer: Reducer<S, A>,
-      preloadedState?: PreloadedState<S>
-    ) => {
-      const store = createStore(reducer, preloadedState)
-      let dispatch: Dispatch = () => {
-        throw new Error(
-          'Dispatching while constructing your middleware is not allowed. ' +
-            'Other middleware would not be applied to this dispatch.'
-        )
-      }
+  return createStore => (reducer, preloadedState) => {
+    const store = createStore(reducer, preloadedState)
+    let dispatch: Dispatch = () => {
+      throw new Error(
+        'Dispatching while constructing your middleware is not allowed. ' +
+          'Other middleware would not be applied to this dispatch.'
+      )
+    }
 
-      const middlewareAPI: MiddlewareAPI = {
-        getState: store.getState,
-        dispatch: (action, ...args) => dispatch(action, ...args)
-      }
-      const chain = middlewares.map(middleware => middleware(middlewareAPI))
-      dispatch = compose<typeof dispatch>(...chain)(store.dispatch)
+    const middlewareAPI: MiddlewareAPI = {
+      getState: store.getState,
+      dispatch: (action, ...args) => dispatch(action, ...args)
+    }
+    const chain = middlewares.map(middleware => middleware(middlewareAPI))
+    dispatch = compose<typeof dispatch>(...chain)(store.dispatch)
 
-      return {
-        ...store,
-        dispatch
-      }
+    return {
+      ...store,
+      dispatch
     }
+  }
 }

src/combineReducers.ts

 import { AnyAction, Action } from './types/actions'
 import {
   ActionFromReducersMapObject,
+  PreloadedStateShapeFromReducersMapObject,
   Reducer,
-  ReducersMapObject,
   StateFromReducersMapObject
 } from './types/reducers'
-import { CombinedState } from './types/store'
 
@@ -17,3 +16,3 @@ import ActionTypes from './utils/actionTypes'
   inputState: object,
-  reducers: ReducersMapObject,
+  reducers: { [key: string]: Reducer<any, any, any> },
   action: Action,
@@ -64,3 +63,5 @@ unexpectedKeyCache: { [key: string]: true }
 
-function assertReducerShape(reducers: ReducersMapObject) {
+function assertReducerShape(reducers: {
+  [key: string]: Reducer<any, any, any>
+}) {
   Object.keys(reducers).forEach(key => {
@@ -115,17 +116,16 @@ const reducer = reducers[key]
  */
-export default function combineReducers<S>(
-  reducers: ReducersMapObject<S, any>
-): Reducer<CombinedState<S>>
-export default function combineReducers<S, A extends Action = AnyAction>(
-  reducers: ReducersMapObject<S, A>
-): Reducer<CombinedState<S>, A>
-export default function combineReducers<M extends ReducersMapObject>(
+export default function combineReducers<M>(
   reducers: M
-): Reducer<
-  CombinedState<StateFromReducersMapObject<M>>,
-  ActionFromReducersMapObject<M>
->
-export default function combineReducers(reducers: ReducersMapObject) {
+): M[keyof M] extends Reducer<any, any, any> | undefined
+  ? Reducer<
+      StateFromReducersMapObject<M>,
+      ActionFromReducersMapObject<M>,
+      Partial<PreloadedStateShapeFromReducersMapObject<M>>
+    >
+  : never
+export default function combineReducers(reducers: {
+  [key: string]: Reducer<any, any, any>
+}) {
   const reducerKeys = Object.keys(reducers)
-  const finalReducers: ReducersMapObject = {}
+  const finalReducers: { [key: string]: Reducer<any, any, any> } = {}
   for (let i = 0; i < reducerKeys.length; i++) {
@@ -132,0 +132,0 @@ const key = reducerKeys[i]

src/createStore.ts

@@ -5,3 +5,2 @@ import $$observable from './utils/symbol-observable'
   Store,
-  PreloadedState,
   StoreEnhancer,
@@ -81,6 +80,7 @@ Dispatch,
   Ext extends {} = {},
-  StateExt extends {} = {}
+  StateExt extends {} = {},
+  PreloadedState = S
 >(
-  reducer: Reducer<S, A>,
-  preloadedState?: PreloadedState<S>,
+  reducer: Reducer<S, A, PreloadedState>,
+  preloadedState?: PreloadedState | undefined,
   enhancer?: StoreEnhancer<Ext, StateExt>
@@ -92,6 +92,7 @@ ): Store<S, A, StateExt> & Ext
   Ext extends {} = {},
-  StateExt extends {} = {}
+  StateExt extends {} = {},
+  PreloadedState = S
 >(
-  reducer: Reducer<S, A>,
-  preloadedState?: PreloadedState<S> | StoreEnhancer<Ext, StateExt>,
+  reducer: Reducer<S, A, PreloadedState>,
+  preloadedState?: PreloadedState | StoreEnhancer<Ext, StateExt> | undefined,
   enhancer?: StoreEnhancer<Ext, StateExt>
@@ -134,8 +135,10 @@ ): Store<S, A, StateExt> & Ext {
       reducer,
-      preloadedState as PreloadedState<S>
-    ) as Store<S, A, StateExt> & Ext
+      preloadedState as PreloadedState | undefined
+    )
   }
 
   let currentReducer = reducer
-  let currentState = preloadedState as S
+  let currentState: S | PreloadedState | undefined = preloadedState as
+    | PreloadedState
+    | undefined
   let currentListeners: Map<number, ListenerCallback> | null = new Map()
@@ -322,3 +325,3 @@ let nextListeners = currentListeners
 
-    currentReducer = nextReducer
+    currentReducer = nextReducer as unknown as Reducer<S, A, PreloadedState>
 
@@ -464,6 +467,7 @@ // This action has a similar effect to ActionTypes.INIT.
   Ext extends {} = {},
-  StateExt extends {} = {}
+  StateExt extends {} = {},
+  PreloadedState = S
 >(
-  reducer: Reducer<S, A>,
-  preloadedState?: PreloadedState<S>,
+  reducer: Reducer<S, A, PreloadedState>,
+  preloadedState?: PreloadedState | undefined,
   enhancer?: StoreEnhancer<Ext, StateExt>
@@ -475,6 +479,7 @@ ): Store<S, A, StateExt> & Ext
   Ext extends {} = {},
-  StateExt extends {} = {}
+  StateExt extends {} = {},
+  PreloadedState = S
 >(
   reducer: Reducer<S, A>,
-  preloadedState?: PreloadedState<S> | StoreEnhancer<Ext, StateExt>,
+  preloadedState?: PreloadedState | StoreEnhancer<Ext, StateExt> | undefined,
   enhancer?: StoreEnhancer<Ext, StateExt>
@@ -481,0 +486,0 @@ ): Store<S, A, StateExt> & Ext {

src/index.ts

@@ -12,4 +12,2 @@ // functions
 export {
-  CombinedState,
-  PreloadedState,
   Dispatch,
@@ -27,7 +25,8 @@ Unsubscribe,
   Reducer,
-  ReducerFromReducersMapObject,
   ReducersMapObject,
   StateFromReducersMapObject,
+  ReducerFromReducersMapObject,
   ActionFromReducer,
-  ActionFromReducersMapObject
+  ActionFromReducersMapObject,
+  PreloadedStateShapeFromReducersMapObject
 } from './types/reducers'
@@ -34,0 +33,0 @@ // action creators

src/types/middleware.ts

@@ -23,3 +23,3 @@ import { Dispatch } from './store'
 export interface Middleware<
-  _DispatchExt = {}, // TODO: remove unused component (breaking change)
+  _DispatchExt = {}, // TODO: see if this can be used in type definition somehow (can't be removed, as is used to get final dispatch type)
   S = any,
@@ -29,4 +29,4 @@ D extends Dispatch = Dispatch
   (api: MiddlewareAPI<D, S>): (
-    next: D
-  ) => (action: D extends Dispatch<infer A> ? A : never) => any
+    next: (action: unknown) => unknown
+  ) => (action: unknown) => unknown
 }

src/types/reducers.ts

@@ -28,7 +28,9 @@ import { Action, AnyAction } from './actions'
  * @template A The type of actions the reducer can potentially respond to.
+ * @template PreloadedState The type of state consumed by this reducer the first time it's called.
  */
-export type Reducer<S = any, A extends Action = AnyAction> = (
-  state: S | undefined,
-  action: A
-) => S
+export type Reducer<
+  S = any,
+  A extends Action = AnyAction,
+  PreloadedState = S
+> = (state: S | PreloadedState | undefined, action: A) => S
 
@@ -38,7 +40,19 @@ /**
  *
+ * @template S The combined state of the reducers.
  * @template A The type of actions the reducers can potentially respond to.
+ * @template PreloadedState The combined preloaded state of the reducers.
  */
-export type ReducersMapObject<S = any, A extends Action = AnyAction> = {
-  [K in keyof S]: Reducer<S[K], A>
-}
+export type ReducersMapObject<
+  S = any,
+  A extends Action = AnyAction,
+  PreloadedState = S
+> = keyof PreloadedState extends keyof S
+  ? {
+      [K in keyof S]: Reducer<
+        S[K],
+        A,
+        K extends keyof PreloadedState ? PreloadedState[K] : never
+      >
+    }
+  : never
 
@@ -50,4 +64,8 @@ /**
  */
-export type StateFromReducersMapObject<M> = M extends ReducersMapObject
-  ? { [P in keyof M]: M[P] extends Reducer<infer S, any> ? S : never }
+export type StateFromReducersMapObject<M> = M[keyof M] extends
+  | Reducer<any, any, any>
+  | undefined
+  ? {
+      [P in keyof M]: M[P] extends Reducer<infer S> ? S : never
+    }
   : never
@@ -60,8 +78,6 @@
  */
-export type ReducerFromReducersMapObject<M> = M extends {
-  [P in keyof M]: infer R
-}
-  ? R extends Reducer<any, any>
-    ? R
-    : never
+export type ReducerFromReducersMapObject<M> = M[keyof M] extends
+  | Reducer<any, any, any>
+  | undefined
+  ? M[keyof M]
   : never
@@ -74,3 +90,7 @@
  */
-export type ActionFromReducer<R> = R extends Reducer<any, infer A> ? A : never
+export type ActionFromReducer<R> = R extends
+  | Reducer<any, infer A, any>
+  | undefined
+  ? A
+  : never
 
@@ -82,4 +102,22 @@ /**
  */
-export type ActionFromReducersMapObject<M> = M extends ReducersMapObject
-  ? ActionFromReducer<ReducerFromReducersMapObject<M>>
+export type ActionFromReducersMapObject<M> = ActionFromReducer<
+  ReducerFromReducersMapObject<M>
+>
+
+/**
+ * Infer a combined preloaded state shape from a `ReducersMapObject`.
+ *
+ * @template M Object map of reducers as provided to `combineReducers(map: M)`.
+ */
+export type PreloadedStateShapeFromReducersMapObject<M> = M[keyof M] extends
+  | Reducer<any, any, any>
+  | undefined
+  ? {
+      [P in keyof M]: M[P] extends (
+        inputState: infer InputState,
+        action: AnyAction
+      ) => any
+        ? InputState
+        : never
+    }
   : never

src/types/store.ts

@@ -7,45 +7,2 @@ import { Action, AnyAction } from './actions'
 /**
- * Internal "virtual" symbol used to make the `CombinedState` type unique.
- */
-declare const $CombinedState: unique symbol
-
-/**
- * State base type for reducers created with `combineReducers()`.
- *
- * This type allows the `createStore()` method to infer which levels of the
- * preloaded state can be partial.
- *
- * Because Typescript is really duck-typed, a type needs to have some
- * identifying property to differentiate it from other types with matching
- * prototypes for type checking purposes. That's why this type has the
- * `$CombinedState` symbol property. Without the property, this type would
- * match any object. The symbol doesn't really exist because it's an internal
- * (i.e. not exported), and internally we never check its value. Since it's a
- * symbol property, it's not expected to be unumerable, and the value is
- * typed as always undefined, so its never expected to have a meaningful
- * value anyway. It just makes this type distinguishable from plain `{}`.
- */
-interface EmptyObject {
-  readonly [$CombinedState]?: undefined
-}
-export type CombinedState<S> = EmptyObject & S
-
-/**
- * Recursively makes combined state objects partial. Only combined state _root
- * objects_ (i.e. the generated higher level object with keys mapping to
- * individual reducers) are partial.
- */
-export type PreloadedState<S> = Required<S> extends EmptyObject
-  ? S extends CombinedState<infer S1>
-    ? {
-        [K in keyof S1]?: S1[K] extends object ? PreloadedState<S1[K]> : S1[K]
-      }
-    : S
-  : {
-      [K in keyof S]: S[K] extends string | number | boolean | symbol
-        ? S[K]
-        : PreloadedState<S[K]>
-    }
-
-/**
  * A *dispatching function* (or simply *dispatch function*) is a function that
@@ -219,2 +176,3 @@ * accepts an action or an async action; it then may or may not dispatch one
  * @template A The type of actions which may be dispatched.
+ * @template PreloadedState The initial state that is passed into the reducer.
  * @template Ext Store extension that is mixed in to the Store type.
@@ -228,5 +186,11 @@ * @template StateExt State extension that is mixed into the state type.
   ): Store<S, A, StateExt> & Ext
-  <S, A extends Action, Ext extends {} = {}, StateExt extends {} = {}>(
-    reducer: Reducer<S, A>,
-    preloadedState?: PreloadedState<S>,
+  <
+    S,
+    A extends Action,
+    Ext extends {} = {},
+    StateExt extends {} = {},
+    PreloadedState = S
+  >(
+    reducer: Reducer<S, A, PreloadedState>,
+    preloadedState?: PreloadedState | undefined,
     enhancer?: StoreEnhancer<Ext>
@@ -266,5 +230,5 @@ ): Store<S, A, StateExt> & Ext
   StateExt extends {} = {}
-> = <S = any, A extends Action = AnyAction>(
-  reducer: Reducer<S, A>,
-  preloadedState?: PreloadedState<S>
+> = <S, A extends Action, PreloadedState>(
+  reducer: Reducer<S, A, PreloadedState>,
+  preloadedState?: PreloadedState | undefined
 ) => Store<S, A, StateExt> & Ext

No alert changes

Worsened metrics

Total package byte prevSize

291912

decreased by-0.4%

Lines of code

3162

decreased by-0.75%

No dependency changes