strongly typed action handler and dispatcher

action.ts

import { Store } from 'src/store';

type TagWithKey<TagName extends string, T> = { [K in keyof T]: { [_ in TagName]: K } & { params: T[K] } };

type Unionize<T> = T[keyof T];

type ActionHandlers<TParams, TParamsKey extends keyof TParams> = {
    [Key in TParamsKey]: (params: TParams[Key]) => void
};

type ActionHandlersTable<TActionParams> = ActionHandlers<TActionParams, keyof TActionParams>;

interface IActionHandler<TActionParams extends {}> {
    readonly handlers: ActionHandlersTable<TActionParams>;
}

type ActionParamsA = {
    Increase: {
        amount: number;
    };
    Foo: {
        bar: { x: boolean };
    };
};

class ActionHandlerA implements IActionHandler<ActionParamsA> {
    public readonly handlers: ActionHandlersTable<ActionParamsA> = null;

    constructor(store: Store) {
        this.handlers = {
            Increase: ({ amount }) => {
                store.count += amount;
            },
            Foo: _ => {}
        };
    }
}

type ActionParamsB = {
    Decrease: {
        amount: number;
    };
    Bar: null;
};

export class ActionHandlerB implements IActionHandler<ActionParamsB> {
    public readonly handlers: ActionHandlersTable<ActionParamsB>;

    constructor(store: Store) {
        this.handlers = {
            Decrease: params => {
                store.count -= params.amount;
            },
            Bar: _ => {}
        };
    }
}

type ActionType<T> = T extends IActionHandler<infer U> ? Unionize<TagWithKey<'type', U>> : never;

const createDispatcher = <T extends IActionHandler<any>>(actionHandlers: T[]) => {
    return (actionType: ActionType<T>): void => {
        for (let i = 0; i < actionHandlers.length; i++) {
            const handler = actionHandlers[i].handlers[actionType.type];
            if (handler) {
                return handler.call(null, actionType.params);
            }
        }
    };
};

export const createActionDispatcher = (store: Store) =>
    createDispatcher([new ActionHandlerA(store), new ActionHandlerB(store)]);

export type Dispatch = ReturnType<typeof createActionDispatcher>;