Feature/immutable invariant

docs/api/getDefaultMiddleware.md

@@ -55,12 +55,12 @@ One of the goals of Redux Toolkit is to provide opinionated defaults and prevent
 `getDefaultMiddleware` includes some middleware that are added **in development builds of your app only** to
 provide runtime checks for two common issues:
 
-- [`redux-immutable-state-invariant`](https://github.com/leoasis/redux-immutable-state-invariant): deeply compares
+- [`immutable-state-invariant`](./otherExports.md#createimmutablestateinvariantmiddleware): - deeply compares
   state values for mutations. It can detect mutations in reducers during a dispatch, and also mutations that occur between
   dispatches (such as in a component or a selector). When a mutation is detected, it will throw an error and indicate the key
   path for where the mutated value was detected in the state tree.
 - [`serializable-state-invariant-middleware`](./otherExports.md#createserializablestateinvariantmiddleware): a custom middleware created specifically for use in Redux Toolkit. Similar in
-  concept to `redux-immutable-state-invariant`, but deeply checks your state tree and your actions for non-serializable values
+  concept to `immutable-state-invariant`, but deeply checks your state tree and your actions for non-serializable values
   such as functions, Promises, Symbols, and other non-plain-JS-data values. When a non-serializable value is detected, a
   console error will be printed with the key path for where the non-serializable value was detected.
 

docs/api/otherExports.md

@@ -11,6 +11,56 @@ Redux Toolkit exports some of its internal utilities, and re-exports additional
 
 ## Internal Exports
 
+### `createImmutalStateInvariantMiddleware`
+
+Creates an instance of the `immutable-state-invariant` middleware described in [`getDefaultMiddleware`](./getDefaultMiddleware.md).
+
+Accepts a single configuration object parameter, with the following options:
+
+```ts
+function createImmutableStateInvariantMiddleware({
+  // The function to check if a value is considered to be immutable.
+  // This function is applied recursively to every value contained in the state.
+  // The default implementation will return true for primitive types (like numbers, strings, booleans, null and undefined).
+  isImmutable?: (value: any) => boolean
+  // An array of dot-separated path strings that match named nodes from the root state to ignore when checking for immutability.
+  // Defaults to undefined
+  ignoredPaths?: string[]
+})
+```
+
+Example:
+
+```js
+import {
+  createSlice,
+  configureStore,
+  createImmutableStateInvariantMiddleware
+} from '@reduxjs/toolkit'
+
+const exampleSlice = createSlice({
+  name: 'example',
+  initialState: {
+    user: 'will track changes',
+    ignoredPath: 'single level',
+    ignoredNested: {
+      one: 'one',
+      two: 'two'
+    }
+  },
+  reducers: {}
+})
+
+const immutableInvariantMiddleware = createImmutableStateInvariantMiddleware({
+  ignoredPaths: ['ignoredPath', 'ignoredNested.one', 'ignoredNested.two']
+})
+
+const store = configureStore({
+  reducer: exampleSlice.reducer,
+  middleware: [immutableInvariantMiddleware]
+})
+```
+
 ### `createSerializableStateInvariantMiddleware`
 
 Creates an instance of the `serializable-state-invariant` middleware described in [`getDefaultMiddleware`](./getDefaultMiddleware.md).