React-redux batch actions middleware typed using variadic tuples

batchActionsMiddleware.ts

import { batch } from 'react-redux';
import {
  Action,
  AnyAction,
  Middleware,
  ThunkAction,
  ThunkDispatch,
} from '@reduxjs/toolkit';

type MaybeThunkAction<T> = T extends Action
  ? T
  : T extends ThunkAction<infer R, infer S, infer E, infer A>
  ? ThunkAction<R, S, E, A>
  : never;

type MaybeThunkReturn<T> = T extends Action
  ? T
  : T extends (...args: never[]) => infer R
  ? R
  : never;

interface BatchDispatch<S, E, A extends Action> extends ThunkDispatch<S, E, A> {
  <T extends MaybeThunkAction<T[number]>[]>(batchActions: readonly [...T]): {
    [P in keyof T]: MaybeThunkReturn<T[P]>;
  };
}

type BatchMiddleware<
  S = {},
  A extends Action = AnyAction,
  E = undefined
> = Middleware<BatchDispatch<S, E, A>, S, BatchDispatch<S, E, A>>;

/** Should be the first middleware */
export const batchActionsMiddleware: BatchMiddleware = store => next => action => {
  if (Array.isArray(action)) {
    let batchedActions;
    batch(() => {
      batchedActions = action.map(a => store.dispatch(a));
    });
    return batchedActions;
  }
  return next(action);
};
    
export default batchActionsMiddleware;