Reducer.ts

import Event from './Event';

export type ReducerHandler<E extends Event, State> = (state: State, event: E) => State;

type EventType<E> = E extends Event ? E['type'] : never;
type ExtractEvent<E extends Event, Type> = E extends { type: Type } ? E : never;

export default interface Reducer<E extends Event, State> {
  initialState?: State;
  ensureFirstEventTypeToBe?: EventType<E>;
  handlers: {
    [T in EventType<E>]?: ReducerHandler<ExtractEvent<E, T>, State>;
  };
}

export type ReducerFn<State> = (events: Event[], state?: State) => State;

export function makeReducerFn<E extends Event, State>(reducer: Reducer<E, State>): ReducerFn<State> {
  const {
    initialState,
    ensureFirstEventTypeToBe,
    handlers,
  } = reducer;

  return (events: E[], state: State = initialState): State => {
    if (ensureFirstEventTypeToBe !== undefined) {
      if (state === undefined && events[0].type !== ensureFirstEventTypeToBe) {
        throw new Error();
      }
    }

    return events.reduce<State>((previousState, event) => {
      const handler = handlers[event.type];

      if (handler === undefined) {
        return previousState;
      }

      return handler(previousState, event);
    }, state);
  };
}