State

action.ts

import {Callback} from './callback'

export class Action<T> {
  constructor(public type: string, public value: T) {}
}

export const createAction = <T>(type: string) => {
  return class extends Action<T> {
    constructor(value: T) {
      super(type, value)
    }
  }
}

const actions = new Map<string, Set<Callback<any>>>()

export const setAction = <T>(type: string, callback: Callback<T>) => {
  const callbacks = getAction<T>(type)
  actions.set(type, callbacks.add(callback))
}

export const getAction = <T>(type: string) => {
  return actions.get(type) ?? new Set<Callback<T>>()
}

callback.ts

export interface Callback<T> {
  (value: T): void
}

dispatch.ts

import {Action, getAction} from './action'

export const dispatch = <T>(action: Action<T>) => {
  for (const callback of getAction(action.type)) {
    callback(action.value)
  }
}

select.ts

import {Callback} from './callback'
import {setAction} from './action'

export const select = <T>(type: string) => {
  return (callback: Callback<T>) => {
    setAction(type, callback)
  }
}