Flesh out configureStore docs, and tweak other pages

Author: markerikson

docs/api/configureStore.md

@@ -7,28 +7,78 @@ hide_title: true
 
 # `configureStore`
 
-A friendlier abstraction over the standard Redux `createStore` function. Takes a single configuration object parameter, with the following options:
+A friendlier abstraction over the standard Redux `createStore` function. 
+
+
+## Parameters
+
+`configureStore` accepts a single configuration object parameter, with the following options:
 
 ```ts
 function configureStore({
     // A single reducer function that will be used as the root reducer,
     // or an object of slice reducers that will be passed to combineReducers()
-    reducer: Object<string, Function> | Function,
-    // An array of Redux middlewares.  If not supplied, adds the middleware returned by getDefaultMiddleware()
-    middleware: Array<MiddlewareFunction>,
-    // Built-in support for devtools. Defaults to true.
-    devTools: boolean,
-    // Same as current createStore.
-    preloadedState : State,
+    reducer: Object<string, ReducerFunction> | ReducerFunction,
+    // An array of Redux middlewares.  If not supplied, uses getDefaultMiddleware()
+    middleware?: MiddlewareFunction[],
+    // Enable support for the Redux DevTools Extension. Defaults to true.
+    devTools?: boolean,
     // Same as current createStore.
-    enhancer : ReduxStoreEnhancer,
+    preloadedState?: State,
+    // An optional array of Redux store enhancers
+    enhancers?: ReduxStoreEnhancer[],
 })
 ```
 
-For details on how the `middleware` parameter works and the list of middleware that are added by default, see the
-[`getDefaultMiddleware` docs page](./getDefaultMiddleware.md)
+### `reducer`
+
+If this is a single function, it will be directly used as the root reducer for the store.
+
+If it is an object of slice reducers, like `{users : usersReducer, posts : postsReducer}`, 
+`configureStore` will automatically create the root reducer by passing this object to the
+[Redux `combineReducers` utility](https://redux.js.org/api/combinereducers).
+
+
+### `middleware`
+
+An optional array of Redux middleware functions.
+
+If this option is provided, it should contain all the middleware functions you
+want added to the store.  `configureStore` will automatically pass those to `applyMiddleware`.
+
+If not provided, `configureStore` will call `getDefaultMiddleware` and use the
+array of middleware functions it returns.
+
+For more details on how the `middleware` parameter works and the list of middleware that are added by default, see the
+[`getDefaultMiddleware` docs page](./getDefaultMiddleware.md).
+
+
+### `devTools`
+
+A boolean indicating whether  `configureStore` should automatically enable support for [the Redux DevTools browser extension](https://github.com/zalmoxisus/redux-devtools-extension).
+
+Defaults to true.
+
+The Redux DevTools Extension recently added [support for showing action stack traces](https://github.com/zalmoxisus/redux-devtools-extension/blob/d4ef75691ad294646f74bca38b973b19850a37cf/docs/Features/Trace.md) that show exactly where each action was dispatched.  Capturing the traces can add a bit of overhead, so the DevTools Extension allows users to configure whether action stack traces are captured.
+
+If this parameter is true, then `configureStore` will enable capturing action stack traces in development mode only.
+
+
+### `preloadedState`
+
+An optional initial state value to be passed to the Redux `createStore` function.
+
+### `enhancers`
+
+An optional array of Redux store enhancers.  If included, these will be passed to [the Redux `compose` function](https://redux.js.org/api/compose), and the combined enhancer will be passed to `createStore`.
+
+This should _not_ include `applyMiddleware()` or
+the Redux DevTools Extension `composeWithDevTools`, as those are already handled by `configureStore`.
+
+
+## Usage
 
-Basic usage:
+### Basic Example
 
 ```js
 import { configureStore } from 'redux-starter-kit'
@@ -39,7 +89,7 @@ const store = configureStore({ reducer: rootReducer })
 // The store now has redux-thunk added and the Redux DevTools Extension is turned on
 ```
 
-Full example:
+###  Full Example
 
 ```js
 import { configureStore, getDefaultMiddleware } from 'redux-starter-kit'
@@ -77,7 +127,7 @@ const preloadedState = {
 const store = configureStore({
   reducer,
   middleware,
-  devTools: NODE_ENV !== 'production',
+  devTools: process.env.NODE_ENV !== 'production',
   preloadedState,
   enhancers: [reduxBatch]
 })

docs/api/createAction.md

@@ -27,8 +27,8 @@ import { increment } from './actions'
 
 function counterReducer(state = 0, action) {
   switch (action.type) {
-    // action creator can be used directly as the type for comparisons
-    case increment: {
+    // action creator's `toString()` can be used as the type for comparisons
+    case increment.toString(): {
       return state + action.payload
     }
     default:

docs/api/otherExports.md

@@ -7,17 +7,67 @@ hide_title: true
 
 # Other Exports
 
-`redux-starter-kit` re-exports additional functions from other dependencies as well.
+`redux-starter-kit` exports some of its internal utilities, and re-exports additional functions from other dependencies as well.
 
-## `createNextState`
+
+## Internal Exports
+
+
+### `createSerializableStateInvariantMiddleware`
+
+Creates an instance of the `serializable-state-invariant` middleware described in [`getDefaultMiddleware`](./getDefaultMiddleware.md).
+
+Accepts an options object with an `isSerializable` parameter, which will be used
+to determine if a value is considered serializable or not.  If not provided, this
+defaults to `isPlain`.
+
+Example:
+
+```js
+import {configureStore, createSerializableStateInvariantMiddleware} from "redux-starter-kit";
+
+const serializableMiddleware = createSerializableStateInvariantMiddleware({
+    isSerializable: () => true // all values will be accepted
+});
+
+const store = configureStore({
+    reducer,
+    middleware : [serializableMiddleware],
+});
+```
+
+### `isPlain`
+
+The default function used to determine if a value is considered serializable.
+
+Current definition:
+
+```js
+function isPlain(val) {
+  return (
+    typeof val === 'undefined' ||
+    val === null ||
+    typeof val === 'string' ||
+    typeof val === 'boolean' ||
+    typeof val === 'number' ||
+    Array.isArray(val) ||
+    isPlainObject(val)
+  )
+}
+```
+
+
+## Exports from Other Libraries
+
+### `createNextState`
 
 The default immutable update function from the [`immer` library](https://github.com/mweststrate/immer#api), re-exported here as `createNextState` (also commonly referred to as `produce`)
 
-## `combineReducers`
+### `combineReducers`
 
 Redux's `combineReducers`, re-exported for convenience. While `configureStore` calls this internally, you may wish to call it yourself to compose multiple levels of slice reducers.
 
-## `compose`
+### `compose`
 
 Redux's `compose`. It composes functions from right to left.
 This is a functional programming utility. You might want to use it to apply several store custom enhancers/ functions in a row.

docs/introduction/quick-start.md

@@ -27,11 +27,11 @@ you make your Redux code better.
 
 `redux-starter-kit` includes:
 
-- A `configureStore()` function with simplified configuration options. It can automatically combine your slice reducers, adds whatever Redux middleware you supply, includes `redux-thunk` by default, and enables use of the Redux DevTools Extension.
-- A `createReducer()` utility that lets you supply a lookup table of action types to case reducer functions, rather than writing switch statements. In addition, it automatically uses the [`immer` library](https://github.com/mweststrate/immer) to let you write simpler immutable updates with normal mutative code, like `state.todos[3].completed = true`.
-- A `createAction()` utility that returns an action creator function for the given action type string. The function itself has `toString()` defined, so that it can be used in place of the type constant.
-- A `createSlice()` function that accepts a set of reducer functions, a slice name, and an initial state value, and automatically generates corresponding action creators, types, and simple selector functions.
-- An improved version of the widely used `createSelector` utility for creating memoized selector functions, which can accept string keypaths as "input selectors" (re-exported from the [`selectorator` library](https://github.com/planttheidea/selectorator)).
+- A [`configureStore()` function](./configureStore.md) with simplified configuration options. It can automatically combine your slice reducers, adds whatever Redux middleware you supply, includes `redux-thunk` by default, and enables use of the Redux DevTools Extension.
+- A [`createReducer()` utility](./createReducer.md) that lets you supply a lookup table of action types to case reducer functions, rather than writing switch statements. In addition, it automatically uses the [`immer` library](https://github.com/mweststrate/immer) to let you write simpler immutable updates with normal mutative code, like `state.todos[3].completed = true`.
+- A [`createAction()` utility](./createAction.md) that returns an action creator function for the given action type string. The function itself has `toString()` defined, so that it can be used in place of the type constant.
+- A [`createSlice()` function](./createSlice.md) that accepts a set of reducer functions, a slice name, and an initial state value, and automatically generates corresponding action creators, types, and simple selector functions.
+- An improved version of the widely used [`createSelector` utility](./createSelector.md) for creating memoized selector functions, which can accept string keypaths as "input selectors" (re-exported from the [`selectorator` library](https://github.com/planttheidea/selectorator)).
 
 ## Installation