@depup/reduxjs__toolkit 2.12.0-depup.28

package/src/listenerMiddleware/utils.ts

@@ -0,0 +1,30 @@
+export const assertFunction: (
+  func: unknown,
+  expected: string,
+) => asserts func is (...args: unknown[]) => unknown = (
+  func: unknown,
+  expected: string,
+) => {
+  if (typeof func !== 'function') {
+    throw new TypeError(`${expected} is not a function`)
+  }
+}
+
+export const noop = () => {}
+
+export const catchRejection = <T>(
+  promise: Promise<T>,
+  onError = noop,
+): Promise<T> => {
+  promise.catch(onError)
+
+  return promise
+}
+
+export const addAbortSignalListener = (
+  abortSignal: AbortSignal,
+  callback: (evt: Event) => void,
+) => {
+  abortSignal.addEventListener('abort', callback, { once: true })
+  return () => abortSignal.removeEventListener('abort', callback)
+}

package/src/mapBuilders.ts

@@ -0,0 +1,298 @@
+import type { Action } from 'redux'
+import type {
+  CaseReducer,
+  CaseReducers,
+  ActionMatcherDescriptionCollection,
+} from './createReducer'
+import type { TypeGuard } from './tsHelpers'
+import type { AsyncThunk, AsyncThunkConfig } from './createAsyncThunk'
+
+export type AsyncThunkReducers<
+  State,
+  ThunkArg extends any,
+  Returned = unknown,
+  ThunkApiConfig extends AsyncThunkConfig = {},
+> = {
+  pending?: CaseReducer<
+    State,
+    ReturnType<AsyncThunk<Returned, ThunkArg, ThunkApiConfig>['pending']>
+  >
+  rejected?: CaseReducer<
+    State,
+    ReturnType<AsyncThunk<Returned, ThunkArg, ThunkApiConfig>['rejected']>
+  >
+  fulfilled?: CaseReducer<
+    State,
+    ReturnType<AsyncThunk<Returned, ThunkArg, ThunkApiConfig>['fulfilled']>
+  >
+  settled?: CaseReducer<
+    State,
+    ReturnType<
+      AsyncThunk<Returned, ThunkArg, ThunkApiConfig>['rejected' | 'fulfilled']
+    >
+  >
+}
+
+export type TypedActionCreator<Type extends string> = {
+  (...args: any[]): Action<Type>
+  type: Type
+}
+
+/**
+ * A builder for an action <-> reducer map.
+ *
+ * @public
+ */
+export interface ActionReducerMapBuilder<State> {
+  /**
+   * Adds a case reducer to handle a single exact action type.
+   * @remarks
+   * All calls to `builder.addCase` must come before any calls to `builder.addMatcher` or `builder.addDefaultCase`.
+   * @param actionCreator - Either a plain action type string, or an action creator generated by [`createAction`](./createAction) that can be used to determine the action type.
+   * @param reducer - The actual case reducer function.
+   */
+  addCase<ActionCreator extends TypedActionCreator<string>>(
+    actionCreator: ActionCreator,
+    reducer: CaseReducer<State, ReturnType<ActionCreator>>,
+  ): ActionReducerMapBuilder<State>
+  /**
+   * Adds a case reducer to handle a single exact action type.
+   * @remarks
+   * All calls to `builder.addCase` must come before any calls to `builder.addAsyncThunk`, `builder.addMatcher` or `builder.addDefaultCase`.
+   * @param actionCreator - Either a plain action type string, or an action creator generated by [`createAction`](./createAction) that can be used to determine the action type.
+   * @param reducer - The actual case reducer function.
+   */
+  addCase<Type extends string, A extends Action<Type>>(
+    type: Type,
+    reducer: CaseReducer<State, A>,
+  ): ActionReducerMapBuilder<State>
+
+  /**
+   * Adds case reducers to handle actions based on a `AsyncThunk` action creator.
+   * @remarks
+   * All calls to `builder.addAsyncThunk` must come before after any calls to `builder.addCase` and before any calls to `builder.addMatcher` or `builder.addDefaultCase`.
+   * @param asyncThunk - The async thunk action creator itself.
+   * @param reducers - A mapping from each of the `AsyncThunk` action types to the case reducer that should handle those actions.
+   * @example
+   * ```ts no-transpile
+   * import { createAsyncThunk, createReducer } from '@reduxjs/toolkit';
+   *
+   * const fetchUserById = createAsyncThunk('users/fetchUser', async (id) => {
+   *   const response = await fetch(`https://reqres.in/api/users/${id}`);
+   *   return (await response.json()).data;
+   * });
+   *
+   * const reducer = createReducer(initialState, (builder) => {
+   *   builder.addAsyncThunk(fetchUserById, {
+   *     pending: (state, action) => {
+   *       state.fetchUserById.loading = 'pending';
+   *     },
+   *     fulfilled: (state, action) => {
+   *       state.fetchUserById.data = action.payload;
+   *     },
+   *     rejected: (state, action) => {
+   *       state.fetchUserById.error = action.error;
+   *     },
+   *     settled: (state, action) => {
+   *       state.fetchUserById.loading = action.meta.requestStatus;
+   *     },
+   *   });
+   * });
+   * ```
+   */
+  addAsyncThunk<
+    Returned,
+    ThunkArg,
+    ThunkApiConfig extends AsyncThunkConfig = {},
+  >(
+    asyncThunk: AsyncThunk<Returned, ThunkArg, ThunkApiConfig>,
+    reducers: AsyncThunkReducers<State, ThunkArg, Returned, ThunkApiConfig>,
+  ): Omit<ActionReducerMapBuilder<State>, 'addCase'>
+
+  /**
+   * Allows you to match your incoming actions against your own filter function instead of only the `action.type` property.
+   * @remarks
+   * If multiple matcher reducers match, all of them will be executed in the order
+   * they were defined in - even if a case reducer already matched.
+   * All calls to `builder.addMatcher` must come after any calls to `builder.addCase` and `builder.addAsyncThunk` and before any calls to `builder.addDefaultCase`.
+   * @param matcher - A matcher function. In TypeScript, this should be a [type predicate](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates)
+   *   function
+   * @param reducer - The actual case reducer function.
+   *
+   * @example
+   * ```ts
+   * import type { AsyncThunk, UnknownAction } from '@reduxjs/toolkit';
+   * import { createAction, createReducer } from '@reduxjs/toolkit';
+   *
+   * type GenericAsyncThunk = AsyncThunk<unknown, unknown, any>;
+   *
+   * type PendingAction = ReturnType<GenericAsyncThunk['pending']>;
+   * type RejectedAction = ReturnType<GenericAsyncThunk['rejected']>;
+   * type FulfilledAction = ReturnType<GenericAsyncThunk['fulfilled']>;
+   *
+   * const initialState: Record<string, string> = {};
+   * const resetAction = createAction('reset-tracked-loading-state');
+   *
+   * function isPendingAction(action: UnknownAction): action is PendingAction {
+   *   return typeof action.type === 'string' && action.type.endsWith('/pending');
+   * }
+   *
+   * const reducer = createReducer(initialState, (builder) => {
+   *   builder
+   *     .addCase(resetAction, () => initialState)
+   *     // matcher can be defined outside as a type predicate function
+   *     .addMatcher(isPendingAction, (state, action) => {
+   *       state[action.meta.requestId] = 'pending';
+   *     })
+   *     .addMatcher(
+   *       // matcher can be defined inline as a type predicate function
+   *       (action): action is RejectedAction => action.type.endsWith('/rejected'),
+   *       (state, action) => {
+   *         state[action.meta.requestId] = 'rejected';
+   *       },
+   *     )
+   *     // matcher can just return boolean and the matcher can receive a generic argument
+   *     .addMatcher<FulfilledAction>(
+   *       (action) => action.type.endsWith('/fulfilled'),
+   *       (state, action) => {
+   *         state[action.meta.requestId] = 'fulfilled';
+   *       },
+   *     );
+   * });
+   * ```
+   */
+  addMatcher<A>(
+    matcher: TypeGuard<A> | ((action: any) => boolean),
+    reducer: CaseReducer<State, A extends Action ? A : A & Action>,
+  ): Omit<ActionReducerMapBuilder<State>, 'addCase' | 'addAsyncThunk'>
+
+  /**
+   * Adds a "default case" reducer that is executed if no case reducer and no matcher
+   * reducer was executed for this action.
+   * @param reducer - The fallback "default case" reducer function.
+   *
+   * @example
+   * ```ts
+   * import { createReducer } from '@reduxjs/toolkit';
+   *
+   * const initialState = { otherActions: 0 };
+   *
+   * const reducer = createReducer(initialState, (builder) => {
+   *   builder
+   *     // .addCase(...)
+   *     // .addMatcher(...)
+   *     .addDefaultCase((state, action) => {
+   *       state.otherActions++;
+   *     });
+   * });
+   * ```
+   */
+  addDefaultCase(reducer: CaseReducer<State, Action>): {}
+}
+
+export function executeReducerBuilderCallback<S>(
+  builderCallback: (builder: ActionReducerMapBuilder<S>) => void,
+): [
+  CaseReducers<S, any>,
+  ActionMatcherDescriptionCollection<S>,
+  CaseReducer<S, Action> | undefined,
+] {
+  const actionsMap: CaseReducers<S, any> = {}
+  const actionMatchers: ActionMatcherDescriptionCollection<S> = []
+  let defaultCaseReducer: CaseReducer<S, Action> | undefined
+  const builder = {
+    addCase(
+      typeOrActionCreator: string | TypedActionCreator<any>,
+      reducer: CaseReducer<S>,
+    ) {
+      if (process.env.NODE_ENV !== 'production') {
+        /*
+         to keep the definition by the user in line with actual behavior,
+         we enforce `addCase` to always be called before calling `addMatcher`
+         as matching cases take precedence over matchers
+         */
+        if (actionMatchers.length > 0) {
+          throw new Error(
+            '`builder.addCase` should only be called before calling `builder.addMatcher`',
+          )
+        }
+        if (defaultCaseReducer) {
+          throw new Error(
+            '`builder.addCase` should only be called before calling `builder.addDefaultCase`',
+          )
+        }
+      }
+      const type =
+        typeof typeOrActionCreator === 'string'
+          ? typeOrActionCreator
+          : typeOrActionCreator.type
+      if (!type) {
+        throw new Error(
+          '`builder.addCase` cannot be called with an empty action type',
+        )
+      }
+      if (type in actionsMap) {
+        throw new Error(
+          '`builder.addCase` cannot be called with two reducers for the same action type ' +
+            `'${type}'`,
+        )
+      }
+      actionsMap[type] = reducer
+      return builder
+    },
+    addAsyncThunk<
+      Returned,
+      ThunkArg,
+      ThunkApiConfig extends AsyncThunkConfig = {},
+    >(
+      asyncThunk: AsyncThunk<Returned, ThunkArg, ThunkApiConfig>,
+      reducers: AsyncThunkReducers<S, ThunkArg, Returned, ThunkApiConfig>,
+    ) {
+      if (process.env.NODE_ENV !== 'production') {
+        // since this uses both action cases and matchers, we can't enforce the order in runtime other than checking for default case
+        if (defaultCaseReducer) {
+          throw new Error(
+            '`builder.addAsyncThunk` should only be called before calling `builder.addDefaultCase`',
+          )
+        }
+      }
+      if (reducers.pending)
+        actionsMap[asyncThunk.pending.type] = reducers.pending
+      if (reducers.rejected)
+        actionsMap[asyncThunk.rejected.type] = reducers.rejected
+      if (reducers.fulfilled)
+        actionsMap[asyncThunk.fulfilled.type] = reducers.fulfilled
+      if (reducers.settled)
+        actionMatchers.push({
+          matcher: asyncThunk.settled,
+          reducer: reducers.settled,
+        })
+      return builder
+    },
+    addMatcher<A>(
+      matcher: TypeGuard<A>,
+      reducer: CaseReducer<S, A extends Action ? A : A & Action>,
+    ) {
+      if (process.env.NODE_ENV !== 'production') {
+        if (defaultCaseReducer) {
+          throw new Error(
+            '`builder.addMatcher` should only be called before calling `builder.addDefaultCase`',
+          )
+        }
+      }
+      actionMatchers.push({ matcher, reducer })
+      return builder
+    },
+    addDefaultCase(reducer: CaseReducer<S, Action>) {
+      if (process.env.NODE_ENV !== 'production') {
+        if (defaultCaseReducer) {
+          throw new Error('`builder.addDefaultCase` can only be called once')
+        }
+      }
+      defaultCaseReducer = reducer
+      return builder
+    },
+  }
+  builderCallback(builder)
+  return [actionsMap, actionMatchers, defaultCaseReducer]
+}

package/src/matchers.ts

@@ -0,0 +1,365 @@
+import type {
+  ActionFromMatcher,
+  Matcher,
+  UnionToIntersection,
+} from './tsHelpers'
+import { hasMatchFunction } from './tsHelpers'
+import type {
+  AsyncThunk,
+  AsyncThunkFulfilledActionCreator,
+  AsyncThunkPendingActionCreator,
+  AsyncThunkRejectedActionCreator,
+} from './createAsyncThunk'
+
+/** @public */
+export type ActionMatchingAnyOf<Matchers extends Matcher<any>[]> =
+  ActionFromMatcher<Matchers[number]>
+
+/** @public */
+export type ActionMatchingAllOf<Matchers extends Matcher<any>[]> =
+  UnionToIntersection<ActionMatchingAnyOf<Matchers>>
+
+const matches = (matcher: Matcher<any>, action: any) => {
+  if (hasMatchFunction(matcher)) {
+    return matcher.match(action)
+  } else {
+    return matcher(action)
+  }
+}
+
+/**
+ * A higher-order function that returns a function that may be used to check
+ * whether an action matches any one of the supplied type guards or action
+ * creators.
+ *
+ * @param matchers The type guards or action creators to match against.
+ *
+ * @public
+ */
+export function isAnyOf<Matchers extends Matcher<any>[]>(
+  ...matchers: Matchers
+) {
+  return (action: any): action is ActionMatchingAnyOf<Matchers> => {
+    return matchers.some((matcher) => matches(matcher, action))
+  }
+}
+
+/**
+ * A higher-order function that returns a function that may be used to check
+ * whether an action matches all of the supplied type guards or action
+ * creators.
+ *
+ * @param matchers The type guards or action creators to match against.
+ *
+ * @public
+ */
+export function isAllOf<Matchers extends Matcher<any>[]>(
+  ...matchers: Matchers
+) {
+  return (action: any): action is ActionMatchingAllOf<Matchers> => {
+    return matchers.every((matcher) => matches(matcher, action))
+  }
+}
+
+/**
+ * @param action A redux action
+ * @param validStatus An array of valid meta.requestStatus values
+ *
+ * @internal
+ */
+export function hasExpectedRequestMetadata(
+  action: any,
+  validStatus: readonly string[],
+) {
+  if (!action || !action.meta) return false
+
+  const hasValidRequestId = typeof action.meta.requestId === 'string'
+  const hasValidRequestStatus =
+    validStatus.indexOf(action.meta.requestStatus) > -1
+
+  return hasValidRequestId && hasValidRequestStatus
+}
+
+function isAsyncThunkArray(a: [any] | AnyAsyncThunk[]): a is AnyAsyncThunk[] {
+  return (
+    typeof a[0] === 'function' &&
+    'pending' in a[0] &&
+    'fulfilled' in a[0] &&
+    'rejected' in a[0]
+  )
+}
+
+export type UnknownAsyncThunkPendingAction = ReturnType<
+  AsyncThunkPendingActionCreator<unknown>
+>
+
+export type PendingActionFromAsyncThunk<T extends AnyAsyncThunk> =
+  ActionFromMatcher<T['pending']>
+
+/**
+ * A higher-order function that returns a function that may be used to check
+ * whether an action was created by an async thunk action creator, and that
+ * the action is pending.
+ *
+ * @public
+ */
+export function isPending(): (
+  action: any,
+) => action is UnknownAsyncThunkPendingAction
+/**
+ * A higher-order function that returns a function that may be used to check
+ * whether an action belongs to one of the provided async thunk action creators,
+ * and that the action is pending.
+ *
+ * @param asyncThunks (optional) The async thunk action creators to match against.
+ *
+ * @public
+ */
+export function isPending<
+  AsyncThunks extends [AnyAsyncThunk, ...AnyAsyncThunk[]],
+>(
+  ...asyncThunks: AsyncThunks
+): (action: any) => action is PendingActionFromAsyncThunk<AsyncThunks[number]>
+/**
+ * Tests if `action` is a pending thunk action
+ * @public
+ */
+export function isPending(action: any): action is UnknownAsyncThunkPendingAction
+export function isPending<
+  AsyncThunks extends [AnyAsyncThunk, ...AnyAsyncThunk[]],
+>(...asyncThunks: AsyncThunks | [any]) {
+  if (asyncThunks.length === 0) {
+    return (action: any) => hasExpectedRequestMetadata(action, ['pending'])
+  }
+
+  if (!isAsyncThunkArray(asyncThunks)) {
+    return isPending()(asyncThunks[0])
+  }
+
+  return isAnyOf(...asyncThunks.map((asyncThunk) => asyncThunk.pending))
+}
+
+export type UnknownAsyncThunkRejectedAction = ReturnType<
+  AsyncThunkRejectedActionCreator<unknown, unknown>
+>
+
+export type RejectedActionFromAsyncThunk<T extends AnyAsyncThunk> =
+  ActionFromMatcher<T['rejected']>
+
+/**
+ * A higher-order function that returns a function that may be used to check
+ * whether an action was created by an async thunk action creator, and that
+ * the action is rejected.
+ *
+ * @public
+ */
+export function isRejected(): (
+  action: any,
+) => action is UnknownAsyncThunkRejectedAction
+/**
+ * A higher-order function that returns a function that may be used to check
+ * whether an action belongs to one of the provided async thunk action creators,
+ * and that the action is rejected.
+ *
+ * @param asyncThunks (optional) The async thunk action creators to match against.
+ *
+ * @public
+ */
+export function isRejected<
+  AsyncThunks extends [AnyAsyncThunk, ...AnyAsyncThunk[]],
+>(
+  ...asyncThunks: AsyncThunks
+): (action: any) => action is RejectedActionFromAsyncThunk<AsyncThunks[number]>
+/**
+ * Tests if `action` is a rejected thunk action
+ * @public
+ */
+export function isRejected(
+  action: any,
+): action is UnknownAsyncThunkRejectedAction
+export function isRejected<
+  AsyncThunks extends [AnyAsyncThunk, ...AnyAsyncThunk[]],
+>(...asyncThunks: AsyncThunks | [any]) {
+  if (asyncThunks.length === 0) {
+    return (action: any) => hasExpectedRequestMetadata(action, ['rejected'])
+  }
+
+  if (!isAsyncThunkArray(asyncThunks)) {
+    return isRejected()(asyncThunks[0])
+  }
+
+  return isAnyOf(...asyncThunks.map((asyncThunk) => asyncThunk.rejected))
+}
+
+export type UnknownAsyncThunkRejectedWithValueAction = ReturnType<
+  AsyncThunkRejectedActionCreator<unknown, unknown>
+>
+
+export type RejectedWithValueActionFromAsyncThunk<T extends AnyAsyncThunk> =
+  ActionFromMatcher<T['rejected']> &
+    (T extends AsyncThunk<any, any, { rejectValue: infer RejectedValue }>
+      ? { payload: RejectedValue }
+      : unknown)
+
+/**
+ * A higher-order function that returns a function that may be used to check
+ * whether an action was created by an async thunk action creator, and that
+ * the action is rejected with value.
+ *
+ * @public
+ */
+export function isRejectedWithValue(): (
+  action: any,
+) => action is UnknownAsyncThunkRejectedAction
+/**
+ * A higher-order function that returns a function that may be used to check
+ * whether an action belongs to one of the provided async thunk action creators,
+ * and that the action is rejected with value.
+ *
+ * @param asyncThunks (optional) The async thunk action creators to match against.
+ *
+ * @public
+ */
+export function isRejectedWithValue<
+  AsyncThunks extends [AnyAsyncThunk, ...AnyAsyncThunk[]],
+>(
+  ...asyncThunks: AsyncThunks
+): (
+  action: any,
+) => action is RejectedWithValueActionFromAsyncThunk<AsyncThunks[number]>
+/**
+ * Tests if `action` is a rejected thunk action with value
+ * @public
+ */
+export function isRejectedWithValue(
+  action: any,
+): action is UnknownAsyncThunkRejectedAction
+export function isRejectedWithValue<
+  AsyncThunks extends [AnyAsyncThunk, ...AnyAsyncThunk[]],
+>(...asyncThunks: AsyncThunks | [any]) {
+  const hasFlag = (action: any): action is any => {
+    return action && action.meta && action.meta.rejectedWithValue
+  }
+
+  if (asyncThunks.length === 0) {
+    return isAllOf(isRejected(...asyncThunks), hasFlag)
+  }
+
+  if (!isAsyncThunkArray(asyncThunks)) {
+    return isRejectedWithValue()(asyncThunks[0])
+  }
+
+  return isAllOf(isRejected(...asyncThunks), hasFlag)
+}
+
+export type UnknownAsyncThunkFulfilledAction = ReturnType<
+  AsyncThunkFulfilledActionCreator<unknown, unknown>
+>
+
+export type FulfilledActionFromAsyncThunk<T extends AnyAsyncThunk> =
+  ActionFromMatcher<T['fulfilled']>
+
+/**
+ * A higher-order function that returns a function that may be used to check
+ * whether an action was created by an async thunk action creator, and that
+ * the action is fulfilled.
+ *
+ * @public
+ */
+export function isFulfilled(): (
+  action: any,
+) => action is UnknownAsyncThunkFulfilledAction
+/**
+ * A higher-order function that returns a function that may be used to check
+ * whether an action belongs to one of the provided async thunk action creators,
+ * and that the action is fulfilled.
+ *
+ * @param asyncThunks (optional) The async thunk action creators to match against.
+ *
+ * @public
+ */
+export function isFulfilled<
+  AsyncThunks extends [AnyAsyncThunk, ...AnyAsyncThunk[]],
+>(
+  ...asyncThunks: AsyncThunks
+): (action: any) => action is FulfilledActionFromAsyncThunk<AsyncThunks[number]>
+/**
+ * Tests if `action` is a fulfilled thunk action
+ * @public
+ */
+export function isFulfilled(
+  action: any,
+): action is UnknownAsyncThunkFulfilledAction
+export function isFulfilled<
+  AsyncThunks extends [AnyAsyncThunk, ...AnyAsyncThunk[]],
+>(...asyncThunks: AsyncThunks | [any]) {
+  if (asyncThunks.length === 0) {
+    return (action: any) => hasExpectedRequestMetadata(action, ['fulfilled'])
+  }
+
+  if (!isAsyncThunkArray(asyncThunks)) {
+    return isFulfilled()(asyncThunks[0])
+  }
+
+  return isAnyOf(...asyncThunks.map((asyncThunk) => asyncThunk.fulfilled))
+}
+
+export type UnknownAsyncThunkAction =
+  | UnknownAsyncThunkPendingAction
+  | UnknownAsyncThunkRejectedAction
+  | UnknownAsyncThunkFulfilledAction
+
+export type AnyAsyncThunk = {
+  pending: { match: (action: any) => action is any }
+  fulfilled: { match: (action: any) => action is any }
+  rejected: { match: (action: any) => action is any }
+}
+
+export type ActionsFromAsyncThunk<T extends AnyAsyncThunk> =
+  | ActionFromMatcher<T['pending']>
+  | ActionFromMatcher<T['fulfilled']>
+  | ActionFromMatcher<T['rejected']>
+
+/**
+ * A higher-order function that returns a function that may be used to check
+ * whether an action was created by an async thunk action creator.
+ *
+ * @public
+ */
+export function isAsyncThunkAction(): (
+  action: any,
+) => action is UnknownAsyncThunkAction
+/**
+ * A higher-order function that returns a function that may be used to check
+ * whether an action belongs to one of the provided async thunk action creators.
+ *
+ * @param asyncThunks (optional) The async thunk action creators to match against.
+ *
+ * @public
+ */
+export function isAsyncThunkAction<
+  AsyncThunks extends [AnyAsyncThunk, ...AnyAsyncThunk[]],
+>(
+  ...asyncThunks: AsyncThunks
+): (action: any) => action is ActionsFromAsyncThunk<AsyncThunks[number]>
+/**
+ * Tests if `action` is a thunk action
+ * @public
+ */
+export function isAsyncThunkAction(
+  action: any,
+): action is UnknownAsyncThunkAction
+export function isAsyncThunkAction<
+  AsyncThunks extends [AnyAsyncThunk, ...AnyAsyncThunk[]],
+>(...asyncThunks: AsyncThunks | [any]) {
+  if (asyncThunks.length === 0) {
+    return (action: any) =>
+      hasExpectedRequestMetadata(action, ['pending', 'fulfilled', 'rejected'])
+  }
+
+  if (!isAsyncThunkArray(asyncThunks)) {
+    return isAsyncThunkAction()(asyncThunks[0])
+  }
+
+  return isAnyOf(...asyncThunks.flatMap(asyncThunk => [asyncThunk.pending, asyncThunk.rejected, asyncThunk.fulfilled]))
+}