Method dispatchEvent

packages/core/src/events/EventManager.ts:56–92

(
    event: EventType,
    args: Partial<AnyEventArgs<T>>,
    meta?: EntityMetadata<T>,
  )

    meta?: EntityMetadata<T>,
  ): Promise<unknown>;
  dispatchEvent<T extends object>(
    event: EventType,
    args: Partial<AnyEventArgs<T>>,
    meta?: EntityMetadata<T>,
  ): Promise<unknown> | unknown {
    const listeners: AsyncFunction[] = [];
    const entity = (args as EventArgs<T>).entity;

    // execute lifecycle hooks first
    meta ??= (entity as AnyEntity)?.__meta;
    const hooks = (meta?.hooks[event] || []) as AsyncFunction[];
    listeners.push(
      ...hooks.map(hook => {
        const prototypeHook = meta?.prototype[hook as unknown as EntityKey<T>];
        const handler = typeof hook === 'function' ? hook : (entity[hook] ?? (prototypeHook as AsyncFunction));
        return handler.bind(entity);
      }),
    );

    for (const listener of this.#listeners[event] ?? new Set()) {
      const entities = this.#entities.get(listener)!;

      if (entities.size === 0 || !entity || entities.has(entity.constructor.name)) {
        listeners.push(listener[event]!.bind(listener) as AsyncFunction);
      }
    }

    if (event === EventType.onInit) {
      for (const listener of listeners) {
        void listener(args);
      }

      return;
    }

    return Utils.runSerial(listeners, listener => listener(args));
  }

  /** Checks whether there are any listeners (hooks or subscribers) for the given event type and entity. */
  hasListeners<T>(event: EventType, meta: EntityMetadata<T>): boolean {