202407 #

type Fn = (data?: any) => void

interface Event {
  key: number
  callback: Fn
}

interface PublishedEvents {
  name: string
  data?: any
}

export class EventManager {
  _events: { [key: string]: Event[] } = {}

  _publishedEvents: PublishedEvents[] = []

  _uniqueId = 0 // use self increasing number to guarantee global uniqueness

  subscribe(name: string, callback: Fn): number {
    if (!this._events[name]) {
      this._events[name] = []
    }
    const event = { key: this._uniqueId++, callback }
    this._events[name].push(event)
    return event.key
  }

  publish(name: string, data?: any): void {
    this._publishedEvents.push({ name, data })
    if (this._events[name]) {
      this._events[name].forEach(({ callback }): void => {
        callback(data)
      })
    }
  }

  unSubscribe(name: string, key: number): void {
    if (this._events[name]) {
      for (let i = 0; i < this._events[name].length; i++) {
        if (key === this._events[name][i].key) {
          this._events[name].splice(i, 1)
          break
        }
      }
    }
  }

  // Make sure published events can be triggered when subscribed
  ensureTriggeredAndSubscribe(name: string, callback: Fn): number {
    const event = this._publishedEvents
      .slice()
      .reverse()
      .find((item) => item.name === name)
    if (event) {
      callback(event.data)
    }
    return this.subscribe(name, callback)
  }
}

import { EventManager } from "micro-event-manager"

// first create a manager instance
const eventManager = new EventManager()

// then subscribe to an event, it will return an unique key
const key = eventManager.subscribe("log", () => {
  console.log("executed")
})

// trigger the event, the second argument is optional
eventManager.publish("log", "data")

// you can use the generated key to unsubscribe the event
eventManager.unSubscribe("log", key)

// when you are not sure if the subscription happens before the publishment
// and you want to make sure any published events should be triggered, you can use this function to subscribe
eventManager.ensureTriggeredAndSubscribe("log", () => {
  console.log("executed")
})