Add configuration for createDraftSafeSelector, createEntityAdapter, and RTKQ's core module

packages/toolkit/src/createDraftSafeSelector.ts

@@ -1,5 +1,23 @@
-import { current, isDraft } from 'immer'
 import { createSelector } from 'reselect'
+import type { ImmutableHelpers } from './tsHelpers'
+import { immutableHelpers } from './immer'
+
+export type BuildCreateDraftSafeSelectorConfiguration = Pick<
+  ImmutableHelpers,
+  'isDraft' | 'current'
+>
+
+export function buildCreateDraftSafeSelector({
+  isDraft,
+  current,
+}: BuildCreateDraftSafeSelectorConfiguration): typeof createSelector {
+  return function createDraftSafeSelector(...args: unknown[]) {
+    const selector = (createSelector as any)(...args)
+    const wrappedSelector = (value: unknown, ...rest: unknown[]) =>
+      selector(isDraft(value) ? current(value) : value, ...rest)
+    return wrappedSelector as any
+  }
+}
 
 /**
  * "Draft-Safe" version of `reselect`'s `createSelector`:
@@ -8,11 +26,5 @@ import { createSelector } from 'reselect'
  * that might be possibly outdated if the draft has been modified since.
  * @public
  */
-export const createDraftSafeSelector: typeof createSelector = (
-  ...args: unknown[]
-) => {
-  const selector = (createSelector as any)(...args)
-  const wrappedSelector = (value: unknown, ...rest: unknown[]) =>
-    selector(isDraft(value) ? current(value) : value, ...rest)
-  return wrappedSelector as any
-}
+export const createDraftSafeSelector: typeof createSelector =
+  buildCreateDraftSafeSelector(immutableHelpers)

packages/toolkit/src/createReducer.ts

@@ -1,10 +1,9 @@
 import type { Draft } from 'immer'
-import { produce as createNextState, isDraft, isDraftable } from 'immer'
 import type { AnyAction, Action, Reducer } from 'redux'
 import type { ActionReducerMapBuilder } from './mapBuilders'
 import { executeReducerBuilderCallback } from './mapBuilders'
-import type { NoInfer } from './tsHelpers'
-import { makeFreezeDraftable } from './utils'
+import type { ImmutableHelpers, NoInfer } from './tsHelpers'
+import { immutableHelpers } from './immer'
 
 /**
  * Defines a mapping from action types to corresponding action object shapes.
@@ -153,25 +152,17 @@ const reducer = createReducer(
   ): ReducerWithInitialState<S>
 }
 
-export interface BuildCreateReducerConfiguration {
-  createNextState: <Base>(
-    base: Base,
-    recipe: (draft: Draft<Base>) => void | Base | Draft<Base>
-  ) => Base
-  isDraft(value: any): boolean
-  isDraftable(value: any): boolean
-}
+export type BuildCreateReducerConfiguration = Pick<
+  ImmutableHelpers,
+  'createNextState' | 'isDraft' | 'isDraftable' | 'freeze'
+>
 
 export function buildCreateReducer({
   createNextState,
   isDraft,
   isDraftable,
+  freeze,
 }: BuildCreateReducerConfiguration): CreateReducer {
-  const freezeDraftable = makeFreezeDraftable({
-    createNextState,
-    isDraft,
-    isDraftable,
-  })
   return function createReducer<S extends NotFunction<any>>(
     initialState: S | (() => S),
     mapOrBuilderCallback: (builder: ActionReducerMapBuilder<S>) => void
@@ -190,9 +181,9 @@ export function buildCreateReducer({
     // Ensure the initial state gets frozen either way (if draftable)
     let getInitialState: () => S
     if (isStateFunction(initialState)) {
-      getInitialState = () => freezeDraftable(initialState())
+      getInitialState = () => freeze(initialState(), true)
     } else {
-      const frozenInitialState = freezeDraftable(initialState)
+      const frozenInitialState = freeze(initialState, true)
       getInitialState = () => frozenInitialState
     }
 
@@ -256,8 +247,4 @@ export function buildCreateReducer({
   }
 }
 
-export const createReducer = buildCreateReducer({
-  createNextState,
-  isDraft,
-  isDraftable,
-})
+export const createReducer = buildCreateReducer(immutableHelpers)

packages/toolkit/src/createSlice.ts

@@ -1,5 +1,4 @@
 import type { Reducer } from 'redux'
-import { produce as createNextState, isDraft, isDraftable } from 'immer'
 import type {
   ActionCreatorWithoutPayload,
   PayloadAction,
@@ -18,7 +17,7 @@ import { buildCreateReducer } from './createReducer'
 import type { ActionReducerMapBuilder } from './mapBuilders'
 import { executeReducerBuilderCallback } from './mapBuilders'
 import type { NoInfer } from './tsHelpers'
-import { makeFreezeDraftable } from './utils'
+import { immutableHelpers } from './immer'
 
 let hasWarnedAboutObjectNotation = false
 
@@ -283,7 +282,7 @@ export function buildCreateSlice(
   configuration: BuildCreateSliceConfiguration
 ): CreateSlice {
   const createReducer = buildCreateReducer(configuration)
-  const freezeDraftable = makeFreezeDraftable(configuration)
+  const { freeze } = configuration
 
   return function createSlice<
     State,
@@ -311,7 +310,7 @@ export function buildCreateSlice(
     const initialState =
       typeof options.initialState == 'function'
         ? options.initialState
-        : freezeDraftable(options.initialState)
+        : freeze(options.initialState)
 
     const reducers = options.reducers || {}
 
@@ -394,8 +393,4 @@ export function buildCreateSlice(
   }
 }
 
-export const createSlice = buildCreateSlice({
-  createNextState,
-  isDraft,
-  isDraftable,
-})
+export const createSlice = buildCreateSlice(immutableHelpers)

packages/toolkit/src/entities/create_adapter.ts

@@ -5,39 +5,56 @@ import type {
   EntityAdapter,
 } from './models'
 import { createInitialStateFactory } from './entity_state'
-import { createSelectorsFactory } from './state_selectors'
-import { createSortedStateAdapter } from './sorted_state_adapter'
-import { createUnsortedStateAdapter } from './unsorted_state_adapter'
+import { buildCreateSelectorsFactory } from './state_selectors'
+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 '../immer'
 
-/**
- *
- * @param options
- *
- * @public
- */
-export function createEntityAdapter<T>(
-  options: {
+export interface BuildCreateEntityAdapterConfiguration
+  extends BuildCreateDraftSafeSelectorConfiguration,
+    BuildStateOperatorConfiguration {}
+
+export type CreateEntityAdapter = {
+  <T>(options?: {
     selectId?: IdSelector<T>
     sortComparer?: false | Comparer<T>
-  } = {}
-): EntityAdapter<T> {
-  const { selectId, sortComparer }: EntityDefinition<T> = {
-    sortComparer: false,
-    selectId: (instance: any) => instance.id,
-    ...options,
-  }
+  }): EntityAdapter<T>
+}
 
-  const stateFactory = createInitialStateFactory<T>()
-  const selectorsFactory = createSelectorsFactory<T>()
-  const stateAdapter = sortComparer
-    ? createSortedStateAdapter(selectId, sortComparer)
-    : createUnsortedStateAdapter(selectId)
+export function buildCreateEntityAdapter(
+  config: BuildCreateEntityAdapterConfiguration
+): CreateEntityAdapter {
+  const createSelectorsFactory = buildCreateSelectorsFactory(config)
+  const createUnsortedStateAdapter = buildCreateUnsortedStateAdapter(config)
+  const createSortedStateAdapter = buildCreateSortedStateAdapter(config)
+  return function createEntityAdapter<T>(
+    options: {
+      selectId?: IdSelector<T>
+      sortComparer?: false | Comparer<T>
+    } = {}
+  ): EntityAdapter<T> {
+    const { selectId, sortComparer }: EntityDefinition<T> = {
+      sortComparer: false,
+      selectId: (instance: any) => instance.id,
+      ...options,
+    }
 
-  return {
-    selectId,
-    sortComparer,
-    ...stateFactory,
-    ...selectorsFactory,
-    ...stateAdapter,
+    const stateFactory = createInitialStateFactory<T>()
+    const selectorsFactory = createSelectorsFactory<T>()
+    const stateAdapter = sortComparer
+      ? createSortedStateAdapter(selectId, sortComparer)
+      : createUnsortedStateAdapter(selectId)
+
+    return {
+      selectId,
+      sortComparer,
+      ...stateFactory,
+      ...selectorsFactory,
+      ...stateAdapter,
+    }
   }
 }
+
+export const createEntityAdapter = buildCreateEntityAdapter(immutableHelpers)