Merge branch 'entity-methods-creator' into per-slice-creator

Author: EskiMojo14

packages/toolkit/src/asyncThunkCreator.ts

@@ -7,18 +7,14 @@ import type {
 } from './createAsyncThunk'
 import { createAsyncThunk } from './createAsyncThunk'
 import type { CaseReducer } from './createReducer'
-import type {
-  CreatorCaseReducers,
-  ReducerCreator,
-  ReducerDefinition,
-} from './createSlice'
+import type { ReducerCreator, ReducerDefinition } from './createSlice'
 import { ReducerType } from './createSlice'
 import type { Id } from './tsHelpers'
 
-export type AsyncThunkSliceReducerConfig<
+export type AsyncThunkSliceReducers<
   State,
-  ThunkArg extends any,
-  Returned = unknown,
+  ThunkArg,
+  Returned,
   ThunkApiConfig extends AsyncThunkConfig = {},
 > = {
   pending?: CaseReducer<
@@ -39,6 +35,14 @@ export type AsyncThunkSliceReducerConfig<
       AsyncThunk<Returned, ThunkArg, ThunkApiConfig>['rejected' | 'fulfilled']
     >
   >
+}
+
+export type AsyncThunkSliceReducerConfig<
+  State,
+  ThunkArg,
+  Returned,
+  ThunkApiConfig extends AsyncThunkConfig = {},
+> = AsyncThunkSliceReducers<State, ThunkArg, Returned, ThunkApiConfig> & {
   options?: AsyncThunkOptions<ThunkArg, ThunkApiConfig>
 }
 
@@ -116,41 +120,38 @@ export interface AsyncThunkCreator<
 
 export type AsyncThunkCreatorExposes<
   State,
-  CaseReducers extends CreatorCaseReducers<State>,
+  Definition extends ReducerDefinition,
 > = {
-  actions: {
-    [ReducerName in keyof CaseReducers]: CaseReducers[ReducerName] extends AsyncThunkSliceReducerDefinition<
-      State,
-      infer ThunkArg,
-      infer Returned,
-      infer ThunkApiConfig
-    >
-      ? AsyncThunk<Returned, ThunkArg, ThunkApiConfig>
-      : never
-  }
-  caseReducers: {
-    [ReducerName in keyof CaseReducers]: CaseReducers[ReducerName] extends AsyncThunkSliceReducerDefinition<
-      State,
-      any,
-      any,
-      any
-    >
-      ? Id<
-          Pick<
-            Required<CaseReducers[ReducerName]>,
-            'fulfilled' | 'rejected' | 'pending' | 'settled'
-          >
+  action: Definition extends AsyncThunkSliceReducerDefinition<
+    State,
+    infer ThunkArg,
+    infer Returned,
+    infer ThunkApiConfig
+  >
+    ? AsyncThunk<Returned, ThunkArg, ThunkApiConfig>
+    : never
+
+  caseReducer: Definition extends AsyncThunkSliceReducerDefinition<
+    State,
+    any,
+    any,
+    any
+  >
+    ? Id<
+        Pick<
+          Required<Definition>,
+          'fulfilled' | 'rejected' | 'pending' | 'settled'
         >
-      : never
-  }
+      >
+    : never
 }
 
 export const asyncThunkCreator: ReducerCreator<ReducerType.asyncThunk> = {
   type: ReducerType.asyncThunk,
   create: /* @__PURE__ */ (() => {
     function asyncThunk(
       payloadCreator: AsyncThunkPayloadCreator<any, any>,
-      config: AsyncThunkSliceReducerConfig<any, any>,
+      config: AsyncThunkSliceReducerConfig<any, any, any>,
     ): AsyncThunkSliceReducerDefinition<any, any> {
       return {
         _reducerDefinitionType: ReducerType.asyncThunk,

packages/toolkit/src/createSlice.ts

@@ -29,7 +29,6 @@ import type {
   IsAny,
   OverloadedReturnType,
   TypeGuard,
-  UnionToIntersection,
 } from './tsHelpers'
 import { getOrInsertComputed } from './utils'
 
@@ -40,115 +39,76 @@ export enum ReducerType {
   entityMethods = 'entityMethods',
 }
 
-export type RegisteredReducerType = keyof SliceReducerCreators<
-  any,
-  any,
-  any,
-  any
->
+export type RegisteredReducerType = keyof SliceReducerCreators<any, any, any>
 
 export type ReducerDefinition<
   T extends RegisteredReducerType = RegisteredReducerType,
 > = {
   _reducerDefinitionType: T
 }
 
-export type ReducerCreatorEntry<
-  Create,
-  Exposes extends {
-    actions?: Record<string, unknown>
-    caseReducers?: Record<string, unknown>
-  } = {},
-> = {
-  create: Create
-  actions: Exposes extends { actions: NonNullable<unknown> }
-    ? Exposes['actions']
-    : {}
-  caseReducers: Exposes extends { caseReducers: NonNullable<unknown> }
-    ? Exposes['caseReducers']
-    : {}
-}
-
 export type CreatorCaseReducers<State> =
   | Record<string, ReducerDefinition>
   | SliceCaseReducers<State>
 
 export interface SliceReducerCreators<
   State,
-  CaseReducers extends CreatorCaseReducers<State>,
-  Name extends string,
+  SliceName extends string,
   ReducerPath extends string,
 > {
-  [ReducerType.reducer]: ReducerCreatorEntry<
-    {
-      (
-        caseReducer: CaseReducer<State, PayloadAction>,
-      ): CaseReducerDefinition<State, PayloadAction>
-      <Payload = any>(
-        caseReducer: CaseReducer<State, PayloadAction<Payload>>,
-      ): CaseReducerDefinition<State, PayloadAction<Payload>>
-    },
-    {
-      actions: {
-        [ReducerName in keyof CaseReducers]: CaseReducers[ReducerName] extends CaseReducer<
-          State,
-          any
-        >
-          ? ActionCreatorForCaseReducer<
-              CaseReducers[ReducerName],
-              SliceActionType<Name, ReducerName>
-            >
-          : never
-      }
-      caseReducers: {
-        [ReducerName in keyof CaseReducers]: CaseReducers[ReducerName] extends CaseReducer<
-          State,
-          any
-        >
-          ? CaseReducers[ReducerName]
-          : never
-      }
-    }
-  >
-  [ReducerType.reducerWithPrepare]: ReducerCreatorEntry<
-    <Prepare extends PrepareAction<any>>(
-      prepare: Prepare,
-      reducer: CaseReducer<
-        State,
-        ReturnType<_ActionCreatorWithPreparedPayload<Prepare>>
-      >,
-    ) => PreparedCaseReducerDefinition<State, Prepare>,
-    {
-      actions: {
-        [ReducerName in keyof CaseReducers as ReducerName]: CaseReducers[ReducerName] extends CaseReducerWithPrepare<
-          State,
-          any
+  [ReducerType.reducer]: {
+    (
+      caseReducer: CaseReducer<State, PayloadAction>,
+    ): CaseReducerDefinition<State, PayloadAction>
+    <Payload = any>(
+      caseReducer: CaseReducer<State, PayloadAction<Payload>>,
+    ): CaseReducerDefinition<State, PayloadAction<Payload>>
+  }
+  [ReducerType.reducerWithPrepare]: <Prepare extends PrepareAction<any>>(
+    prepare: Prepare,
+    reducer: CaseReducer<
+      State,
+      ReturnType<_ActionCreatorWithPreparedPayload<Prepare>>
+    >,
+  ) => PreparedCaseReducerDefinition<State, Prepare>
+  [ReducerType.asyncThunk]: AsyncThunkCreator<State>
+  [ReducerType.entityMethods]: EntityMethodsCreator<State>
+}
+
+export interface SliceReducerCreatorsExposes<
+  State,
+  SliceName extends string,
+  ReducerPath extends string,
+  ReducerName extends PropertyKey,
+  Definition extends ReducerDefinition,
+> {
+  [creatorType: PropertyKey]: {
+    action?: NonNullable<unknown>
+    caseReducer?: NonNullable<unknown>
+  }
+  [ReducerType.reducer]: {
+    action: Definition extends CaseReducer<State, any>
+      ? ActionCreatorForCaseReducer<
+          Definition,
+          SliceActionType<SliceName, ReducerName>
         >
-          ? CaseReducers[ReducerName] extends { prepare: any }
-            ? ActionCreatorForCaseReducerWithPrepare<
-                CaseReducers[ReducerName],
-                SliceActionType<Name, ReducerName>
-              >
-            : never
-          : never
-      }
-      caseReducers: {
-        [ReducerName in keyof CaseReducers]: CaseReducers[ReducerName] extends CaseReducerWithPrepare<
-          State,
-          any
+      : never
+    caseReducer: Definition extends CaseReducer<State, any> ? Definition : never
+  }
+  [ReducerType.reducerWithPrepare]: {
+    action: Definition extends { prepare: any }
+      ? NonNullable<
+          ActionCreatorForCaseReducerWithPrepare<
+            Definition,
+            SliceActionType<SliceName, ReducerName>
+          >
         >
-          ? CaseReducers[ReducerName] extends { reducer: infer Reducer }
-            ? Reducer
-            : never
-          : never
-      }
-    }
-  >
-  [ReducerType.asyncThunk]: ReducerCreatorEntry<
-    AsyncThunkCreator<State>,
-    AsyncThunkCreatorExposes<State, CaseReducers>
-  >
-  [ReducerType.entityMethods]: ReducerCreatorEntry<EntityMethodsCreator<State>>
+      : never
+    caseReducer: Definition extends PreparedCaseReducerDefinition<State, any>
+      ? Definition['reducer']
+      : never
+  }
+  [ReducerType.asyncThunk]: AsyncThunkCreatorExposes<State, Definition>
 }
 
 export type ReducerCreators<
@@ -157,32 +117,24 @@ export type ReducerCreators<
   ReducerPath extends string = Name,
   CreatorMap extends Record<string, RegisteredReducerType> = {},
 > = {
-  reducer: SliceReducerCreators<
-    State,
-    any,
-    Name,
-    ReducerPath
-  >[ReducerType.reducer]['create']
+  reducer: SliceReducerCreators<State, Name, ReducerPath>[ReducerType.reducer]
   preparedReducer: SliceReducerCreators<
     State,
-    any,
     Name,
     ReducerPath
-  >[ReducerType.reducerWithPrepare]['create']
+  >[ReducerType.reducerWithPrepare]
 } & {
   [CreatorName in keyof CreatorMap as SliceReducerCreators<
     State,
-    never,
     Name,
     ReducerPath
-  >[CreatorMap[CreatorName]]['create'] extends never
+  >[CreatorMap[CreatorName]] extends never
     ? never
     : CreatorName]: SliceReducerCreators<
     State,
-    never,
     Name,
     ReducerPath
-  >[CreatorMap[CreatorName]]['create']
+  >[CreatorMap[CreatorName]]
 }
 
 interface InternalReducerHandlingContext<State> {
@@ -317,14 +269,14 @@ type DefinitionFromValue<
 
 type ReducerDefinitionsForType<Type extends RegisteredReducerType> = {
   [CreatorType in RegisteredReducerType]: DefinitionFromValue<
-    SliceReducerCreators<any, any, any, any>[CreatorType]['create'],
+    SliceReducerCreators<any, any, any>[CreatorType],
     Type
   >
 }[RegisteredReducerType]
 
 export type ReducerCreator<Type extends RegisteredReducerType> = {
   type: Type
-  create: SliceReducerCreators<any, any, any, any>[Type]['create']
+  create: SliceReducerCreators<any, any, any>[Type]
 } & (ReducerDefinitionsForType<Type> extends never
   ? {
       handle?<State>(
@@ -653,9 +605,15 @@ export type SliceActionType<
   ActionName extends keyof any,
 > = ActionName extends string | number ? `${SliceName}/${ActionName}` : string
 
-type ConvertNeverKeysToUnknown<T> = T extends any
-  ? { [K in keyof T]: T[K] extends never ? unknown : T[K] }
-  : never
+type TagAnonymousDefinition<
+  Definition extends CreatorCaseReducers<any>[string],
+> = Definition extends ReducerDefinition
+  ? Definition
+  : Definition extends CaseReducer<any, any>
+    ? Definition & ReducerDefinition<ReducerType.reducer>
+    : Definition extends CaseReducerWithPrepare<any, any>
+      ? Definition & ReducerDefinition<ReducerType.reducerWithPrepare>
+      : never
 
 /**
  * Derives the slice's `actions` property from the `reducers` options
@@ -667,18 +625,21 @@ export type CaseReducerActions<
   SliceName extends string,
   ReducerPath extends string = SliceName,
   State = any,
-> = Id<
-  UnionToIntersection<
-    ConvertNeverKeysToUnknown<
-      SliceReducerCreators<
+> = Id<{
+  [ReducerName in keyof CaseReducers]: TagAnonymousDefinition<
+    CaseReducers[ReducerName]
+  > extends ReducerDefinition<infer Type>
+    ? SliceReducerCreatorsExposes<
         State,
-        CaseReducers,
         SliceName,
-        ReducerPath
-      >[RegisteredReducerType]['actions']
-    >
-  >
->
+        ReducerPath,
+        ReducerName,
+        TagAnonymousDefinition<CaseReducers[ReducerName]>
+      > extends Record<Type, { action: infer Action extends {} }>
+      ? Action
+      : never
+    : never
+}>
 
 /**
  * Get a `PayloadActionCreator` type for a passed `CaseReducerWithPrepare`
@@ -715,18 +676,21 @@ type SliceDefinedCaseReducers<
   SliceName extends string = string,
   ReducerPath extends string = SliceName,
   State = any,
-> = Id<
-  UnionToIntersection<
-    ConvertNeverKeysToUnknown<
-      SliceReducerCreators<
+> = Id<{
+  [ReducerName in keyof CaseReducers]: TagAnonymousDefinition<
+    CaseReducers[ReducerName]
+  > extends ReducerDefinition<infer Type>
+    ? SliceReducerCreatorsExposes<
         State,
-        CaseReducers,
         SliceName,
-        ReducerPath
-      >[RegisteredReducerType]['caseReducers']
-    >
-  >
->
+        ReducerPath,
+        ReducerName,
+        TagAnonymousDefinition<CaseReducers[ReducerName]>
+      > extends Record<Type, { caseReducer: infer CaseReducer }>
+      ? CaseReducer
+      : never
+    : never
+}>
 
 type RemappedSelector<S extends Selector, NewState> =
   S extends Selector<any, infer R, infer P>

packages/toolkit/src/index.ts

@@ -83,16 +83,20 @@ export type {
   ReducerCreators,
   SliceSelectors,
   SliceReducerCreators,
+  SliceReducerCreatorsExposes,
   ReducerDefinition,
-  ReducerCreatorEntry,
   ReducerCreator,
   ReducerDetails,
   ReducerHandlingContext,
   SliceActionType,
   CaseReducerDefinition,
   PreparedCaseReducerDefinition,
 } from './createSlice'
-export type { AsyncThunkSliceReducerDefinition } from './asyncThunkCreator'
+export type {
+  AsyncThunkSliceReducers,
+  AsyncThunkSliceReducerConfig,
+  AsyncThunkSliceReducerDefinition,
+} from './asyncThunkCreator'
 export type { ActionCreatorInvariantMiddlewareOptions } from './actionCreatorInvariantMiddleware'
 export { createActionCreatorInvariantMiddleware } from './actionCreatorInvariantMiddleware'
 export {

packages/toolkit/src/tests/createSlice.test-d.ts

@@ -6,12 +6,10 @@ import type {
   ActionCreatorWithPreparedPayload,
   ActionCreatorWithoutPayload,
   ActionReducerMapBuilder,
-  CreatorCaseReducers,
   PayloadAction,
   PayloadActionCreator,
   Reducer,
   ReducerCreator,
-  ReducerCreatorEntry,
   ReducerCreators,
   ReducerDefinition,
   ReducerHandlingContext,
@@ -919,23 +917,24 @@ interface AddToastThunk<Name extends string, ReducerName extends PropertyKey> {
 declare module '@reduxjs/toolkit' {
   export interface SliceReducerCreators<
     State,
-    CaseReducers extends CreatorCaseReducers<State>,
-    Name extends string,
+    SliceName extends string,
     ReducerPath extends string,
   > {
-    [toasterCreatorType]: ReducerCreatorEntry<
-      State extends ToastState
-        ? () => ReducerDefinition<typeof toasterCreatorType>
-        : never,
-      {
-        actions: {
-          [ReducerName in keyof CaseReducers]: CaseReducers[ReducerName] extends ReducerDefinition<
-            typeof toasterCreatorType
-          >
-            ? AddToastThunk<Name, ReducerName>
-            : never
-        }
-      }
-    >
+    [toasterCreatorType]: State extends ToastState
+      ? () => ReducerDefinition<typeof toasterCreatorType>
+      : never
+  }
+  export interface SliceReducerCreatorsExposes<
+    State,
+    SliceName extends string,
+    ReducerPath extends string,
+    ReducerName extends PropertyKey,
+    Definition extends ReducerDefinition,
+  > {
+    [toasterCreatorType]: {
+      action: Definition extends ReducerDefinition<typeof toasterCreatorType>
+        ? AddToastThunk<SliceName, ReducerName>
+        : never
+    }
   }
 }

packages/toolkit/src/tests/createSlice.test.ts

@@ -5,11 +5,9 @@ import type {
   Action,
   CaseReducer,
   CaseReducerDefinition,
-  CreatorCaseReducers,
   PayloadAction,
   PayloadActionCreator,
   ReducerCreator,
-  ReducerCreatorEntry,
   ReducerCreators,
   ReducerDefinition,
   ReducerHandlingContext,
@@ -1237,101 +1235,80 @@ type PatchThunk<
 declare module '@reduxjs/toolkit' {
   export interface SliceReducerCreators<
     State,
-    CaseReducers extends CreatorCaseReducers<State>,
-    Name extends string,
+    SliceName extends string,
     ReducerPath extends string,
   > {
-    [loaderCreatorType]: ReducerCreatorEntry<
-      (
-        reducers: Pick<LoaderReducerDefinition<State>, 'ended' | 'started'>,
-      ) => LoaderReducerDefinition<State>,
-      {
-        actions: {
-          [ReducerName in keyof CaseReducers]: CaseReducers[ReducerName] extends ReducerDefinition<
-            typeof loaderCreatorType
-          >
-            ? LoaderThunk<Name, ReducerName>
-            : never
-        }
-        caseReducers: {
-          [ReducerName in keyof CaseReducers]: CaseReducers[ReducerName] extends ReducerDefinition<
-            typeof loaderCreatorType
-          >
-            ? Required<
-                Pick<LoaderReducerDefinition<State>, 'ended' | 'started'>
-              >
-            : never
-        }
-      }
-    >
-    [historyMethodsCreatorType]: ReducerCreatorEntry<
-      State extends HistoryState<unknown>
-        ? (this: ReducerCreators<State>) => {
-            undo: CaseReducerDefinition<State, PayloadAction>
-            redo: CaseReducerDefinition<State, PayloadAction>
-            reset: ReducerDefinition<typeof historyMethodsCreatorType> & {
-              type: 'reset'
-            }
+    [loaderCreatorType]: (
+      reducers: Pick<LoaderReducerDefinition<State>, 'ended' | 'started'>,
+    ) => LoaderReducerDefinition<State>
+    [historyMethodsCreatorType]: State extends HistoryState<unknown>
+      ? (this: ReducerCreators<State>) => {
+          undo: CaseReducerDefinition<State, PayloadAction>
+          redo: CaseReducerDefinition<State, PayloadAction>
+          reset: ReducerDefinition<typeof historyMethodsCreatorType> & {
+            type: 'reset'
           }
-        : never,
-      {
-        actions: {
-          [ReducerName in keyof CaseReducers]: CaseReducers[ReducerName] extends ReducerDefinition<
-            typeof historyMethodsCreatorType
-          > & { type: 'reset' }
-            ? PayloadActionCreator<void, SliceActionType<Name, ReducerName>>
-            : never
         }
-        caseReducers: {
-          [ReducerName in keyof CaseReducers]: CaseReducers[ReducerName] extends ReducerDefinition<
-            typeof historyMethodsCreatorType
-          > & { type: 'reset' }
-            ? CaseReducer<State, PayloadAction>
-            : never
-        }
-      }
-    >
-    [undoableCreatorType]: ReducerCreatorEntry<
-      State extends HistoryState<infer Data>
-        ? {
-            <A extends Action & { meta?: UndoableOptions }>(
-              this: ReducerCreators<State>,
-              reducer: CaseReducer<Data, NoInfer<A>>,
-            ): CaseReducer<State, A>
-            withoutPayload(): (options?: UndoableOptions) => {
-              payload: undefined
-              meta: UndoableOptions | undefined
-            }
-            withPayload<P>(): (
-              ...args: IfMaybeUndefined<
-                P,
-                [payload?: P, options?: UndoableOptions],
-                [payload: P, options?: UndoableOptions]
-              >
-            ) => { payload: P; meta: UndoableOptions | undefined }
+      : never
+    [undoableCreatorType]: State extends HistoryState<infer Data>
+      ? {
+          <A extends Action & { meta?: UndoableOptions }>(
+            this: ReducerCreators<State>,
+            reducer: CaseReducer<Data, NoInfer<A>>,
+          ): CaseReducer<State, A>
+          withoutPayload(): (options?: UndoableOptions) => {
+            payload: undefined
+            meta: UndoableOptions | undefined
           }
-        : never
-    >
-    [patchCreatorType]: ReducerCreatorEntry<
-      State extends Objectish
-        ? ReducerDefinition<typeof patchCreatorType>
-        : never,
-      {
-        actions: {
-          [ReducerName in keyof CaseReducers]: CaseReducers[ReducerName] extends ReducerDefinition<
-            typeof patchCreatorType
-          >
-            ? PatchThunk<Name, ReducerName, ReducerPath, State>
-            : never
-        }
-        caseReducers: {
-          [ReducerName in keyof CaseReducers]: CaseReducers[ReducerName] extends ReducerDefinition<
-            typeof patchCreatorType
-          >
-            ? CaseReducer<State, PayloadAction<Patch[]>>
-            : never
+          withPayload<P>(): (
+            ...args: IfMaybeUndefined<
+              P,
+              [payload?: P, options?: UndoableOptions],
+              [payload: P, options?: UndoableOptions]
+            >
+          ) => { payload: P; meta: UndoableOptions | undefined }
         }
-      }
-    >
+      : never
+    [patchCreatorType]: State extends Objectish
+      ? ReducerDefinition<typeof patchCreatorType>
+      : never
+  }
+  export interface SliceReducerCreatorsExposes<
+    State,
+    SliceName extends string,
+    ReducerPath extends string,
+    ReducerName extends PropertyKey,
+    Definition extends ReducerDefinition,
+  > {
+    [loaderCreatorType]: {
+      action: Definition extends ReducerDefinition<typeof loaderCreatorType>
+        ? LoaderThunk<SliceName, ReducerName>
+        : never
+      caseReducer: Definition extends ReducerDefinition<
+        typeof loaderCreatorType
+      >
+        ? Required<Pick<LoaderReducerDefinition<State>, 'ended' | 'started'>>
+        : never
+    }
+    [historyMethodsCreatorType]: {
+      action: Definition extends ReducerDefinition<
+        typeof historyMethodsCreatorType
+      > & { type: 'reset' }
+        ? PayloadActionCreator<void, SliceActionType<SliceName, ReducerName>>
+        : never
+      caseReducer: Definition extends ReducerDefinition<
+        typeof historyMethodsCreatorType
+      > & { type: 'reset' }
+        ? CaseReducer<State, PayloadAction>
+        : never
+    }
+    [patchCreatorType]: {
+      action: Definition extends ReducerDefinition<typeof patchCreatorType>
+        ? PatchThunk<SliceName, ReducerName, ReducerPath, State>
+        : never
+      caseReducer: Definition extends ReducerDefinition<typeof patchCreatorType>
+        ? CaseReducer<State, PayloadAction<Patch[]>>
+        : never
+    }
   }
 }