create a defineImmutableHelpers identity function, and use for immer

packages/toolkit/src/createDraftSafeSelector.ts

@@ -1,6 +1,6 @@
-import { current, isDraft } from 'immer'
 import { createSelector } from 'reselect'
 import type { ImmutableHelpers } from './tsHelpers'
+import { immutableHelpers } from './immer'
 
 export type BuildCreateDraftSafeSelectorConfiguration = Pick<
  ImmutableHelpers,
@@ -28,7 +28,5 @@ export function buildCreateDraftSafeSelector({
  }
 }
 
-export const createDraftSafeSelector = buildCreateDraftSafeSelector({
- isDraft,
- current,
-})
+export const createDraftSafeSelector =
+ buildCreateDraftSafeSelector(immutableHelpers)

packages/toolkit/src/createReducer.ts

@@ -1,9 +1,9 @@
 import type { Draft } from 'immer'
-import { produce as createNextState, isDraft, freeze, isDraftable } from 'immer'
 import type { AnyAction, Action, Reducer } from 'redux'
 import type { ActionReducerMapBuilder } from './mapBuilders'
 import { executeReducerBuilderCallback } from './mapBuilders'
 import type { ImmutableHelpers, NoInfer } from './tsHelpers'
+import { immutableHelpers } from './immer'
 
 /**
  * Defines a mapping from action types to corresponding action object shapes.
@@ -247,9 +247,4 @@ export function buildCreateReducer({
  }
 }
 
-export const createReducer = buildCreateReducer({
- createNextState,
- isDraft,
- isDraftable,
- freeze,
-})
+export const createReducer = buildCreateReducer(immutableHelpers)

packages/toolkit/src/createSlice.ts

@@ -1,5 +1,4 @@
 import type { Reducer } from 'redux'
-import { produce as createNextState, freeze, isDraft, isDraftable } from 'immer'
 import type {
  ActionCreatorWithoutPayload,
  PayloadAction,
@@ -18,6 +17,7 @@ import { buildCreateReducer } from './createReducer'
 import type { ActionReducerMapBuilder } from './mapBuilders'
 import { executeReducerBuilderCallback } from './mapBuilders'
 import type { NoInfer } from './tsHelpers'
+import { immutableHelpers } from './immer'
 
 let hasWarnedAboutObjectNotation = false
 
@@ -393,9 +393,4 @@ export function buildCreateSlice(
  }
 }
 
-export const createSlice = buildCreateSlice({
- createNextState,
- isDraft,
- isDraftable,
- freeze,
-})
+export const createSlice = buildCreateSlice(immutableHelpers)

packages/toolkit/src/entities/create_adapter.ts

@@ -1,4 +1,3 @@
-import { isDraft, current, produce as createNextState } from 'immer'
 import type {
  EntityDefinition,
  Comparer,
@@ -11,6 +10,7 @@ import { buildCreateSortedStateAdapter } from './sorted_state_adapter'
 import { buildCreateUnsortedStateAdapter } from './unsorted_state_adapter'
 import type { BuildCreateDraftSafeSelectorConfiguration } from '..'
 import type { BuildStateOperatorConfiguration } from './state_adapter'
+import { immutableHelpers } from '@internal/immer'
 
 export interface BuildCreateEntityAdapterConfiguration
  extends BuildCreateDraftSafeSelectorConfiguration,
@@ -57,8 +57,4 @@ export function buildCreateEntityAdapter(
  }
 }
 
-export const createEntityAdapter = buildCreateEntityAdapter({
- isDraft,
- current,
- createNextState,
-})
+export const createEntityAdapter = buildCreateEntityAdapter(immutableHelpers)

packages/toolkit/src/immer.ts

@@ -0,0 +1,22 @@
+import {
+ applyPatches,
+ current,
+ freeze,
+ isDraft,
+ isDraftable,
+ original,
+ produce,
+ produceWithPatches,
+} from 'immer'
+import { defineImmutableHelpers } from './tsHelpers'
+
+export const immutableHelpers = defineImmutableHelpers({
+ createNextState: produce,
+ createWithPatches: produceWithPatches,
+ applyPatches,
+ isDraft,
+ isDraftable,
+ original,
+ current,
+ freeze,
+})

packages/toolkit/src/index.ts

@@ -199,3 +199,5 @@ export {
 export type { AutoBatchOptions } from './autoBatchEnhancer'
 
 export type { ImmutableHelpers } from './tsHelpers'
+export { defineImmutableHelpers } from './tsHelpers'
+export { immutableHelpers as immerImmutableHelpers } from './immer'

packages/toolkit/src/query/core/module.ts

@@ -16,6 +16,7 @@ import type {
  ThunkAction,
  ThunkDispatch,
 } from '@reduxjs/toolkit'
+import { immerImmutableHelpers } from '@reduxjs/toolkit'
 import type {
  EndpointDefinitions,
  QueryArgFrom,
@@ -50,15 +51,7 @@ import type { BaseQueryFn } from '../baseQueryTypes'
 import type { ReferenceCacheLifecycle } from './buildMiddleware/cacheLifecycle'
 import type { ReferenceQueryLifecycle } from './buildMiddleware/queryLifecycle'
 import type { ReferenceCacheCollection } from './buildMiddleware/cacheCollection'
-import {
- produce,
- applyPatches,
- enablePatches,
- isDraft,
- isDraftable,
- produceWithPatches,
- freeze,
-} from 'immer'
+import { enablePatches } from 'immer'
 
 /**
  * `ifOlderThan` - (default: `false` | `number`) - _number is value in seconds_
@@ -478,14 +471,7 @@ interface CoreModuleOptions {
  * ```
  */
 export const coreModule = ({
- immutableHelpers = {
- createNextState: produce,
- createWithPatches: produceWithPatches,
- applyPatches,
- isDraft,
- isDraftable,
- freeze,
- },
+ immutableHelpers = immerImmutableHelpers,
 }: CoreModuleOptions = {}): Module<CoreModule> => ({
  name: coreModuleName,
  init(

packages/toolkit/src/tsHelpers.ts

@@ -3,23 +3,56 @@ import type { Draft, Patch, applyPatches } from 'immer'
 import type { MiddlewareArray } from './utils'
 
 export interface ImmutableHelpers {
+ /**
+ * Function that receives a base object, and a recipe which is called with a draft that the recipe is allowed to mutate.
+ * The recipe can return a new state which will replace the existing state, or it can not return (in which case the existing draft is used)
+ * Returns an immutably modified version of the input object.
+ */
  createNextState: <Base>(
  base: Base,
  recipe: (draft: Draft<Base>) => void | Base | Draft<Base>
  ) => Base
+ /**
+ * Function that receives a base object, and a recipe which is called with a draft that the recipe is allowed to mutate.
+ * The recipe can return a new state which will replace the existing state, or it can not return (in which case the existing draft is used)
+ * Returns a tuple of an immutably modified version of the input object, an array of patches describing the changes made, and an array of inverse patches.
+ */
  createWithPatches: <Base>(
  base: Base,
  recipe: (draft: Draft<Base>) => void | Base | Draft<Base>
  ) => readonly [Base, Patch[], Patch[]]
- // depends on an Objectish type that immer doesn't export
+ /**
+ * Receives a base object and an array of patches describing changes to apply.
+ * Returns an immutably modified version of the base object with changes applied.
+ */
  applyPatches: typeof applyPatches
+ /**
+ * Indicates whether the value passed is a draft, meaning it's safe to mutate.
+ */
  isDraft(value: any): boolean
+ /**
+ * Indicates whether the value passed is possible to turn into a mutable draft.
+ */
  isDraftable(value: any): boolean
+ /**
+ * Receives a draft and returns its base object.
+ */
  original<T>(value: T): T | undefined
+ /**
+ * Receives a draft and returns an object with any changes to date immutably applied.
+ */
  current<T>(value: T): T
+ /**
+ * Receives an object and freezes it, causing runtime errors if mutation is attempted after.
+ */
  freeze<T>(obj: T, deep?: boolean): T
 }
 
+/**
+ * Define a config object indicating utilities for RTK packages to use for immutable operations.
+ */
+export const defineImmutableHelpers = (helpers: ImmutableHelpers) => helpers
+
 /**
  * return True if T is `any`, otherwise return False
  * taken from https://github.com/joonhocho/tsdef