reduxjs#2808 Preloaded state is now selectively partial (instead of d…

…eeply partial). (reduxjs#3485)

* Preloaded state is now selectively partial (instead of deeply partial).

* Improved CombinedState, PreloadedState, and removed UnCombinedState.

Found a better way to type check CombinedState which allows the
$CombinedState symbol property marker to be optional. Since it's
optional, it's no longer necessary to strip it off in the Reducer state
parameter type and return type. This leaves the type definition for
Reducer unmodified, reduces the number of types required by one, and
makes the resolved types and stack traces clearer.

* Small change to the description of CombinedState.

* Removed DeepPartial import from tests.

Leaving the definition in place as removing it would be a breaking change.

* Made prettier happy.

* Made prettier happy with UsingObjectSpreadOperator.md


Former-commit-id: 41c0612

docs/recipes/UsingObjectSpreadOperator.md

@@ -64,6 +64,7 @@ While the object spread syntax is a [Stage 4](https://github.com/tc39/proposal-o
  "plugins": ["@babel/plugin-proposal-object-rest-spread"]
 }
 ```
+
 > ##### Note on Object Spread Operator
 
-> Like the Array Spread Operator, the Object Spread Operator creates a [shallow clone](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax#Spread_in_object_literals) of the original object. In other words, for multidimensional source objects, elements in the copied object at a depth greater than one are mere references to the source object (with the exception of [primitives](https://developer.mozilla.org/en-US/docs/Glossary/Primitive), which are copied). Thus, you cannot reliably use the  Object Spread Operator (`...`) for deep cloning objects.
+> Like the Array Spread Operator, the Object Spread Operator creates a [shallow clone](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax#Spread_in_object_literals) of the original object. In other words, for multidimensional source objects, elements in the copied object at a depth greater than one are mere references to the source object (with the exception of [primitives](https://developer.mozilla.org/en-US/docs/Glossary/Primitive), which are copied). Thus, you cannot reliably use the Object Spread Operator (`...`) for deep cloning objects.

index.d.ts.REMOVED.git-id

@@ -1 +1 @@
-c9c5a57d757e5b58e699c9b8ec15a14e5843521f
+50e8d018faee8887ed82337fcd1993ad07df0968

test/typescript/enhancers.ts

@@ -1,11 +1,5 @@
-import {
- StoreEnhancer,
- Action,
- AnyAction,
- Reducer,
- createStore,
- DeepPartial
-} from 'redux'
+import { PreloadedState } from '../../index'
+import { StoreEnhancer, Action, AnyAction, Reducer, createStore } from 'redux'
 
 interface State {
  someField: 'string'
@@ -43,10 +37,10 @@ function stateExtension() {
  A extends Action = AnyAction
  >(
  reducer: Reducer<S, A>,
- preloadedState?: DeepPartial<S>
+ preloadedState?: PreloadedState<S>
  ) => {
  const wrappedReducer: Reducer<S & ExtraState, A> = null as any
- const wrappedPreloadedState: S & ExtraState = null as any
+ const wrappedPreloadedState: PreloadedState<S & ExtraState> = null as any
  return createStore(wrappedReducer, wrappedPreloadedState)
  }
 

test/typescript/store.ts

@@ -57,21 +57,45 @@ const funcWithStore = (store: Store<State, DerivedAction>) => {}
 const store: Store<State> = createStore(reducer)
 
 const storeWithPreloadedState: Store<State> = createStore(reducer, {
+ a: 'a',
+ b: { c: 'c', d: 'd' }
+})
+// typings:expect-error
+const storeWithBadPreloadedState: Store<State> = createStore(reducer, {
  b: { c: 'c' }
 })
 
 const storeWithActionReducer = createStore(reducerWithAction)
 const storeWithActionReducerAndPreloadedState = createStore(reducerWithAction, {
- b: { c: 'c' }
+ a: 'a',
+ b: { c: 'c', d: 'd' }
 })
 funcWithStore(storeWithActionReducer)
 funcWithStore(storeWithActionReducerAndPreloadedState)
 
+// typings:expect-error
+const storeWithActionReducerAndBadPreloadedState = createStore(
+ reducerWithAction,
+ {
+ b: { c: 'c' }
+ }
+)
+
 const enhancer: StoreEnhancer = next => next
 
 const storeWithSpecificEnhancer: Store<State> = createStore(reducer, enhancer)
 
 const storeWithPreloadedStateAndEnhancer: Store<State> = createStore(
+ reducer,
+ {
+ a: 'a',
+ b: { c: 'c', d: 'd' }
+ },
+ enhancer
+)
+
+// typings:expect-error
+const storeWithBadPreloadedStateAndEnhancer: Store<State> = createStore(
  reducer,
  {
  b: { c: 'c' }