Revert unnecessary changes

Author: Methuselah96

src/applyMiddleware.ts

@@ -54,7 +54,7 @@ export default function applyMiddleware<Ext, S = any>(
 ): StoreEnhancer<{ dispatch: Ext }>
 export default function applyMiddleware(
   ...middlewares: Middleware[]
-): StoreEnhancer {
+): StoreEnhancer<any> {
   return (createStore: StoreCreator) => <S, A extends AnyAction>(
     reducer: Reducer<S, A>,
     ...args: any[]

src/createStore.ts

@@ -5,7 +5,8 @@ import {
   PreloadedState,
   StoreEnhancer,
   Dispatch,
-  Observer
+  Observer,
+  ExtendState
 } from './types/store'
 import { Action } from './types/actions'
 import { Reducer } from './types/reducers'
@@ -37,20 +38,31 @@ import isPlainObject from './utils/isPlainObject'
  * @returns A Redux store that lets you read the state, dispatch actions
  * and subscribe to changes.
  */
-export default function createStore<S, A extends Action>(
+export default function createStore<
+  S,
+  A extends Action,
+  Ext = {},
+  StateExt = never
+>(
   reducer: Reducer<S, A>,
-  preloadedState?: PreloadedState<S>
-): Store<S, A>
-export default function createStore<S, A extends Action, Ext, StateExt>(
-  reducer: Reducer<S, A>,
-  enhancer: StoreEnhancer<Ext, StateExt>
+  enhancer?: StoreEnhancer<Ext, StateExt>
 ): Store<S, A, StateExt> & Ext
-export default function createStore<S, A extends Action, Ext, StateExt>(
+export default function createStore<
+  S,
+  A extends Action,
+  Ext = {},
+  StateExt = never
+>(
   reducer: Reducer<S, A>,
-  preloadedState: PreloadedState<S>,
-  enhancer: StoreEnhancer<Ext, StateExt>
+  preloadedState?: PreloadedState<S>,
+  enhancer?: StoreEnhancer<Ext, StateExt>
 ): Store<S, A, StateExt> & Ext
-export default function createStore<S, A extends Action, Ext, StateExt>(
+export default function createStore<
+  S,
+  A extends Action,
+  Ext = {},
+  StateExt = never
+>(
   reducer: Reducer<S, A>,
   preloadedState?: PreloadedState<S> | StoreEnhancer<Ext, StateExt>,
   enhancer?: StoreEnhancer<Ext, StateExt>
@@ -110,7 +122,7 @@ export default function createStore<S, A extends Action, Ext, StateExt>(
    *
    * @returns The current state tree of your application.
    */
-  function getState(): S & StateExt {
+  function getState(): ExtendState<S, StateExt> {
     if (isDispatching) {
       throw new Error(
         'You may not call store.getState() while the reducer is executing. ' +
@@ -119,7 +131,7 @@ export default function createStore<S, A extends Action, Ext, StateExt>(
       )
     }
 
-    return currentState as S & StateExt
+    return currentState as ExtendState<S, StateExt>
   }
 
   /**
@@ -291,7 +303,9 @@ export default function createStore<S, A extends Action, Ext, StateExt>(
         }
 
         function observeState() {
-          const observerAsObserver = observer as Observer<S>
+          const observerAsObserver = observer as Observer<
+            ExtendState<S, StateExt>
+          >
           if (observerAsObserver.next) {
             observerAsObserver.next(getState())
           }
@@ -313,11 +327,12 @@ export default function createStore<S, A extends Action, Ext, StateExt>(
   // the initial state tree.
   dispatch({ type: ActionTypes.INIT } as A)
 
-  return ({
+  const store = ({
     dispatch: dispatch as Dispatch<A>,
     subscribe,
     getState,
     replaceReducer,
     [$$observable]: observable
   } as unknown) as Store<S, A, StateExt> & Ext
+  return store
 }

src/index.ts

@@ -19,7 +19,8 @@ export {
   Store,
   StoreCreator,
   StoreEnhancer,
-  StoreEnhancerStoreCreator
+  StoreEnhancerStoreCreator,
+  ExtendState
 } from './types/store'
 // reducers
 export {

src/types/store.ts

@@ -2,6 +2,20 @@ import { Action, AnyAction } from './actions'
 import { Reducer } from './reducers'
 import '../utils/symbol-observable'
 
+/**
+ * Extend the state
+ *
+ * This is used by store enhancers and store creators to extend state.
+ * If there is no state extension, it just returns the state, as is, otherwise
+ * it returns the state joined with its extension.
+ *
+ * Reference for future devs:
+ * https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
+ */
+export type ExtendState<State, Extension> = [Extension] extends [never]
+  ? State
+  : State & Extension
+
 /**
  * Internal "virtual" symbol used to make the `CombinedState` type unique.
  */
@@ -108,8 +122,13 @@ export type Observer<T> = {
  * @template S The type of state held by this store.
  * @template A the type of actions which may be dispatched by this store.
  * @template StateExt any extension to state from store enhancers
+ * @template Ext any extensions to the store from store enhancers
  */
-export interface Store<S = any, A extends Action = AnyAction, StateExt = {}> {
+export interface Store<
+  S = any,
+  A extends Action = AnyAction,
+  StateExt = never
+> {
   /**
    * Dispatches an action. It is the only way to trigger a state change.
    *
@@ -143,7 +162,7 @@ export interface Store<S = any, A extends Action = AnyAction, StateExt = {}> {
    *
    * @returns The current state tree of your application.
    */
-  getState(): S & StateExt
+  getState(): ExtendState<S, StateExt>
 
   /**
    * Adds a change listener. It will be called any time an action is
@@ -188,7 +207,7 @@ export interface Store<S = any, A extends Action = AnyAction, StateExt = {}> {
    * For more information, see the observable proposal:
    * https://github.com/tc39/proposal-observable
    */
-  [Symbol.observable](): Observable<S & StateExt>
+  [Symbol.observable](): Observable<ExtendState<S, StateExt>>
 }
 
 /**
@@ -203,18 +222,14 @@ export interface Store<S = any, A extends Action = AnyAction, StateExt = {}> {
  * @template StateExt State extension that is mixed into the state type.
  */
 export interface StoreCreator {
-  <S, A extends Action>(
-    reducer: Reducer<S, A>,
-    preloadedState?: PreloadedState<S>
-  ): Store<S, A>
-  <S, A extends Action, Ext, StateExt>(
+  <S, A extends Action, Ext = {}, StateExt = never>(
     reducer: Reducer<S, A>,
-    enhancer: StoreEnhancer<Ext, StateExt>
+    enhancer?: StoreEnhancer<Ext, StateExt>
   ): Store<S, A, StateExt> & Ext
-  <S, A extends Action, Ext, StateExt>(
+  <S, A extends Action, Ext = {}, StateExt = never>(
     reducer: Reducer<S, A>,
-    preloadedState: PreloadedState<S>,
-    enhancer: StoreEnhancer<Ext, StateExt>
+    preloadedState?: PreloadedState<S>,
+    enhancer?: StoreEnhancer<Ext>
   ): Store<S, A, StateExt> & Ext
 }
 
@@ -239,10 +254,10 @@ export interface StoreCreator {
  * @template Ext Store extension that is mixed into the Store type.
  * @template StateExt State extension that is mixed into the state type.
  */
-export type StoreEnhancer<Ext = {}, StateExt = {}> = (
-  next: StoreEnhancerStoreCreator
+export type StoreEnhancer<Ext = {}, StateExt = never> = (
+  next: StoreEnhancerStoreCreator<Ext, StateExt>
 ) => StoreEnhancerStoreCreator<Ext, StateExt>
-export type StoreEnhancerStoreCreator<Ext = {}, StateExt = {}> = <
+export type StoreEnhancerStoreCreator<Ext = {}, StateExt = never> = <
   S = any,
   A extends Action = AnyAction
 >(

test/typescript/enhancers.ts

@@ -63,9 +63,7 @@ function stateExtension() {
     reducer: Reducer<S, A>,
     preloadedState?: any
   ) => {
-    const wrapReducer = (
-      reducer: Reducer<S, A>
-    ): Reducer<S & ExtraState, A> => (state, action) => {
+    const wrappedReducer: Reducer<S & ExtraState, A> = (state, action) => {
       const newState = reducer(state, action)
       return {
         ...newState,
@@ -78,13 +76,7 @@ function stateExtension() {
           extraField: 'extra'
         }
       : undefined
-    const store = createStore(wrapReducer(reducer), wrappedPreloadedState)
-    return {
-      ...store,
-      replaceReducer(nextReducer: Reducer<S, A>) {
-        store.replaceReducer(wrapReducer(nextReducer))
-      }
-    }
+    return createStore(wrappedReducer, wrappedPreloadedState)
   }
 
   const store = createStore(reducer, enhancer)
@@ -103,10 +95,8 @@ function extraMethods() {
     ...args
   ) => {
     const store = createStore(...args)
-    return {
-      ...store,
-      method: () => 'foo'
-    }
+    store.method = () => 'foo'
+    return store
   }
 
   const store = createStore(reducer, enhancer)
@@ -145,10 +135,7 @@ function replaceReducerExtender() {
           extraField: 'extra'
         }
       : undefined
-    return {
-      ...createStore(wrappedReducer, wrappedPreloadedState),
-      method: () => 'foo'
-    }
+    return createStore(wrappedReducer, wrappedPreloadedState)
   }
 
   const store = createStore(reducer, enhancer)

test/typescript/store.ts

@@ -5,7 +5,8 @@ import {
   Action,
   StoreEnhancer,
   Unsubscribe,
-  Observer
+  Observer,
+  ExtendState
 } from '../..'
 import 'symbol-observable'
 
@@ -17,6 +18,41 @@ type State = {
   }
 }
 
+/* extended state */
+const noExtend: ExtendState<State, never> = {
+  a: 'a',
+  b: {
+    c: 'c',
+    d: 'd'
+  }
+}
+// typings:expect-error
+const noExtendError: ExtendState<State, never> = {
+  a: 'a',
+  b: {
+    c: 'c',
+    d: 'd'
+  },
+  e: 'oops'
+}
+
+const yesExtend: ExtendState<State, { yes: 'we can' }> = {
+  a: 'a',
+  b: {
+    c: 'c',
+    d: 'd'
+  },
+  yes: 'we can'
+}
+// typings:expect-error
+const yesExtendError: ExtendState<State, { yes: 'we can' }> = {
+  a: 'a',
+  b: {
+    c: 'c',
+    d: 'd'
+  }
+}
+
 interface DerivedAction extends Action {
   type: 'a'
   b: 'b'
@@ -84,9 +120,9 @@ const storeWithActionReducerAndBadPreloadedState = createStore(
 
 const enhancer: StoreEnhancer = next => next
 
-const storeWithSpecificEnhancer = createStore(reducer, enhancer)
+const storeWithSpecificEnhancer: Store<State> = createStore(reducer, enhancer)
 
-const storeWithPreloadedStateAndEnhancer = createStore(
+const storeWithPreloadedStateAndEnhancer: Store<State> = createStore(
   reducer,
   {
     a: 'a',