@omujs/chat 0.9.48 → 0.9.49

package/dist/esm/event/event-types.js

@@ -0,0 +1,76 @@
+// @bun
+// src/event/event.ts
+class ListenerEvent {
+  getListener;
+  constructor(getListener) {
+    this.getListener = getListener;
+  }
+  subscribe(handler, chat) {
+    const listener = this.getListener(chat);
+    return listener.listen(handler);
+  }
+}
+
+class TableEvent extends ListenerEvent {
+  getTable;
+  AddBatch;
+  UpdateBatch;
+  RemoveBatch;
+  Add;
+  Update;
+  Remove;
+  Clear;
+  wrappers;
+  constructor(getTable) {
+    super((chat) => getTable(chat).event.cacheUpdate);
+    this.getTable = getTable;
+    this.AddBatch = new ListenerEvent((chat) => getTable(chat).event.add);
+    this.UpdateBatch = new ListenerEvent((chat) => getTable(chat).event.update);
+    this.RemoveBatch = new ListenerEvent((chat) => getTable(chat).event.remove);
+    this.Add = this.createBatchSubscriber((table) => table.event.add);
+    this.Update = this.createBatchSubscriber((table) => table.event.update);
+    this.Remove = this.createBatchSubscriber((table) => table.event.remove);
+    this.Clear = new ListenerEvent((client) => getTable(client).event.clear);
+    this.wrappers = {};
+  }
+  static createBatchWrapper(emit) {
+    return async (items) => {
+      for (const item of items.values()) {
+        await emit(item);
+      }
+    };
+  }
+  createBatchSubscriber(getListener) {
+    let batchWrapper = null;
+    const subscribe = (emit, chat) => {
+      const table = this.getTable(chat);
+      const listener = getListener(table);
+      batchWrapper = TableEvent.createBatchWrapper((item) => emit(item));
+      const stopListen = table.listen();
+      const clearEvent = listener.listen(batchWrapper);
+      return () => {
+        stopListen();
+        clearEvent();
+      };
+    };
+    return {
+      subscribe
+    };
+  }
+}
+
+// src/event/event-types.ts
+var events = {
+  Message: new TableEvent((chat) => chat.messages),
+  Author: new TableEvent((chat) => chat.authors),
+  Channel: new TableEvent((chat) => chat.channels),
+  Provider: new TableEvent((chat) => chat.providers),
+  Room: new TableEvent((chat) => chat.rooms),
+  Vote: new TableEvent((chat) => chat.votes)
+};
+export {
+  events
+};
+
+//# debugId=8A75DAF050E0121664756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/event/event.ts", "../../src/event/event-types.ts"],
  "sourcesContent": [
    "import type { Table } from '@omujs/omu/api/table';\nimport type { Unlisten } from '@omujs/omu/event';\nimport { EventEmitter } from '@omujs/omu/event';\n\nimport type { Chat } from '../chat.js';\n\nexport type EventHandler<P extends Array<any>> = (...args: P) => Promise<void> | void;\n\nexport interface EventSource<P extends Array<any>> {\n    subscribe(handler: EventHandler<P>, chat: Chat): Unlisten;\n}\n\nexport class ListenerEvent<P extends Array<any>> implements EventSource<P> {\n    constructor(private readonly getListener: (chat: Chat) => EventEmitter<P>) {}\n\n    public subscribe(handler: EventHandler<P>, chat: Chat): Unlisten {\n        const listener = this.getListener(chat);\n        return listener.listen(handler);\n    }\n}\n\nexport class TableEvent<T> extends ListenerEvent<[Map<string, T>]> {\n    public readonly AddBatch: ListenerEvent<[Map<string, T>]>;\n    public readonly UpdateBatch: ListenerEvent<[Map<string, T>]>;\n    public readonly RemoveBatch: ListenerEvent<[Map<string, T>]>;\n    public readonly Add: EventSource<[T]>;\n    public readonly Update: EventSource<[T]>;\n    public readonly Remove: EventSource<[T]>;\n    public readonly Clear: EventSource<[]>;\n    public readonly wrappers: Record<string, Unlisten>;\n\n    constructor(private readonly getTable: (chat: Chat) => Table<T>) {\n        super((chat) => getTable(chat).event.cacheUpdate);\n        this.AddBatch = new ListenerEvent((chat) => getTable(chat).event.add);\n        this.UpdateBatch = new ListenerEvent((chat) => getTable(chat).event.update);\n        this.RemoveBatch = new ListenerEvent((chat) => getTable(chat).event.remove);\n        this.Add = this.createBatchSubscriber((table) => table.event.add);\n        this.Update = this.createBatchSubscriber((table) => table.event.update);\n        this.Remove = this.createBatchSubscriber((table) => table.event.remove);\n        this.Clear = new ListenerEvent((client) => getTable(client).event.clear);\n        this.wrappers = {};\n    }\n\n    private static createBatchWrapper<T>(emit: EventHandler<[T]>): EventHandler<[Map<string, T>]> {\n        return async (items) => {\n            for (const item of items.values()) {\n                await emit(item);\n            }\n        };\n    }\n\n    private createBatchSubscriber(\n        getListener: (table: Table<T>) => EventEmitter<[Map<string, T>]>,\n    ): EventSource<[T]> {\n        let batchWrapper: EventHandler<[Map<string, T>]> | null = null;\n\n        const subscribe = (emit: EventHandler<[T]>, chat: Chat): Unlisten => {\n            const table = this.getTable(chat);\n            const listener = getListener(table);\n            batchWrapper = TableEvent.createBatchWrapper((item) => emit(item));\n            const stopListen = table.listen();\n            const clearEvent = listener.listen(batchWrapper);\n            return () => {\n                stopListen();\n                clearEvent();\n            };\n        };\n\n        return {\n            subscribe,\n        };\n    }\n}\n\ntype Entry<P extends Array<any>> = {\n    source: EventSource<P>;\n    listeners: EventEmitter<P>;\n};\n\nexport class EventRegistry {\n    private readonly chat: Chat;\n    private readonly events: Map<EventSource<any>, Entry<any>>;\n\n    constructor(chat: Chat) {\n        this.chat = chat;\n        this.events = new Map();\n    }\n\n    public register<P extends Array<any>>(event: EventSource<P>, handler: EventHandler<P>): void {\n        let entry = this.events.get(event) as Entry<P> | null;\n        if (!entry) {\n            const newEntry: Entry<P> = {\n                source: event,\n                listeners: new EventEmitter(),\n            };\n            entry = newEntry;\n            this.events.set(event, newEntry);\n            event.subscribe((...args) => newEntry.listeners.emit(...args), this.chat);\n        }\n        entry.listeners.listen((...args) => handler(...args));\n    }\n}\n",
    "import { Author } from '../models/author.js';\nimport { Channel } from '../models/channel.js';\nimport { Message } from '../models/message.js';\nimport { Provider } from '../models/provider.js';\nimport { Room } from '../models/room.js';\nimport { Vote } from '../models/vote.js';\nimport { TableEvent } from './event.js';\n\nexport const events: { Message: TableEvent<Message>; Author: TableEvent<Author>; Channel: TableEvent<Channel>; Provider: TableEvent<Provider>; Room: TableEvent<Room>; Vote: TableEvent<Vote> } = {\n    Message: new TableEvent((chat) => chat.messages),\n    Author: new TableEvent((chat) => chat.authors),\n    Channel: new TableEvent((chat) => chat.channels),\n    Provider: new TableEvent((chat) => chat.providers),\n    Room: new TableEvent((chat) => chat.rooms),\n    Vote: new TableEvent((chat) => chat.votes),\n};\n"
  ],
  "mappings": ";;AAYO,MAAM,cAA8D;AAAA,EAC1C;AAAA,EAA7B,WAAW,CAAkB,aAA8C;AAAA,IAA9C;AAAA;AAAA,EAEtB,SAAS,CAAC,SAA0B,MAAsB;AAAA,IAC7D,MAAM,WAAW,KAAK,YAAY,IAAI;AAAA,IACtC,OAAO,SAAS,OAAO,OAAO;AAAA;AAEtC;AAAA;AAEO,MAAM,mBAAsB,cAAgC;AAAA,EAUlC;AAAA,EATb;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAEhB,WAAW,CAAkB,UAAoC;AAAA,IAC7D,MAAM,CAAC,SAAS,SAAS,IAAI,EAAE,MAAM,WAAW;AAAA,IADvB;AAAA,IAEzB,KAAK,WAAW,IAAI,cAAc,CAAC,SAAS,SAAS,IAAI,EAAE,MAAM,GAAG;AAAA,IACpE,KAAK,cAAc,IAAI,cAAc,CAAC,SAAS,SAAS,IAAI,EAAE,MAAM,MAAM;AAAA,IAC1E,KAAK,cAAc,IAAI,cAAc,CAAC,SAAS,SAAS,IAAI,EAAE,MAAM,MAAM;AAAA,IAC1E,KAAK,MAAM,KAAK,sBAAsB,CAAC,UAAU,MAAM,MAAM,GAAG;AAAA,IAChE,KAAK,SAAS,KAAK,sBAAsB,CAAC,UAAU,MAAM,MAAM,MAAM;AAAA,IACtE,KAAK,SAAS,KAAK,sBAAsB,CAAC,UAAU,MAAM,MAAM,MAAM;AAAA,IACtE,KAAK,QAAQ,IAAI,cAAc,CAAC,WAAW,SAAS,MAAM,EAAE,MAAM,KAAK;AAAA,IACvE,KAAK,WAAW,CAAC;AAAA;AAAA,SAGN,kBAAqB,CAAC,MAAyD;AAAA,IAC1F,OAAO,OAAO,UAAU;AAAA,MACpB,WAAW,QAAQ,MAAM,OAAO,GAAG;AAAA,QAC/B,MAAM,KAAK,IAAI;AAAA,MACnB;AAAA;AAAA;AAAA,EAIA,qBAAqB,CACzB,aACgB;AAAA,IAChB,IAAI,eAAsD;AAAA,IAE1D,MAAM,YAAY,CAAC,MAAyB,SAAyB;AAAA,MACjE,MAAM,QAAQ,KAAK,SAAS,IAAI;AAAA,MAChC,MAAM,WAAW,YAAY,KAAK;AAAA,MAClC,eAAe,WAAW,mBAAmB,CAAC,SAAS,KAAK,IAAI,CAAC;AAAA,MACjE,MAAM,aAAa,MAAM,OAAO;AAAA,MAChC,MAAM,aAAa,SAAS,OAAO,YAAY;AAAA,MAC/C,OAAO,MAAM;AAAA,QACT,WAAW;AAAA,QACX,WAAW;AAAA;AAAA;AAAA,IAInB,OAAO;AAAA,MACH;AAAA,IACJ;AAAA;AAER;;;AChEO,IAAM,SAAqL;AAAA,EAC9L,SAAS,IAAI,WAAW,CAAC,SAAS,KAAK,QAAQ;AAAA,EAC/C,QAAQ,IAAI,WAAW,CAAC,SAAS,KAAK,OAAO;AAAA,EAC7C,SAAS,IAAI,WAAW,CAAC,SAAS,KAAK,QAAQ;AAAA,EAC/C,UAAU,IAAI,WAAW,CAAC,SAAS,KAAK,SAAS;AAAA,EACjD,MAAM,IAAI,WAAW,CAAC,SAAS,KAAK,KAAK;AAAA,EACzC,MAAM,IAAI,WAAW,CAAC,SAAS,KAAK,KAAK;AAC7C;",
  "debugId": "8A75DAF050E0121664756E2164756E21",
  "names": []
}

package/dist/esm/event/event.js

@@ -0,0 +1,106 @@
+// @bun
+// ../omu/dist/esm/event/index.js
+class EventEmitter {
+  listeners = [];
+  listen(listener) {
+    this.listeners.push(listener);
+    return () => {
+      this.listeners.splice(this.listeners.indexOf(listener), 1);
+    };
+  }
+  async emit(...args) {
+    for (const listener of [...this.listeners]) {
+      await listener(...args);
+    }
+  }
+}
+
+// src/event/event.ts
+class ListenerEvent {
+  getListener;
+  constructor(getListener) {
+    this.getListener = getListener;
+  }
+  subscribe(handler, chat) {
+    const listener = this.getListener(chat);
+    return listener.listen(handler);
+  }
+}
+
+class TableEvent extends ListenerEvent {
+  getTable;
+  AddBatch;
+  UpdateBatch;
+  RemoveBatch;
+  Add;
+  Update;
+  Remove;
+  Clear;
+  wrappers;
+  constructor(getTable) {
+    super((chat) => getTable(chat).event.cacheUpdate);
+    this.getTable = getTable;
+    this.AddBatch = new ListenerEvent((chat) => getTable(chat).event.add);
+    this.UpdateBatch = new ListenerEvent((chat) => getTable(chat).event.update);
+    this.RemoveBatch = new ListenerEvent((chat) => getTable(chat).event.remove);
+    this.Add = this.createBatchSubscriber((table) => table.event.add);
+    this.Update = this.createBatchSubscriber((table) => table.event.update);
+    this.Remove = this.createBatchSubscriber((table) => table.event.remove);
+    this.Clear = new ListenerEvent((client) => getTable(client).event.clear);
+    this.wrappers = {};
+  }
+  static createBatchWrapper(emit) {
+    return async (items) => {
+      for (const item of items.values()) {
+        await emit(item);
+      }
+    };
+  }
+  createBatchSubscriber(getListener) {
+    let batchWrapper = null;
+    const subscribe = (emit, chat) => {
+      const table = this.getTable(chat);
+      const listener = getListener(table);
+      batchWrapper = TableEvent.createBatchWrapper((item) => emit(item));
+      const stopListen = table.listen();
+      const clearEvent = listener.listen(batchWrapper);
+      return () => {
+        stopListen();
+        clearEvent();
+      };
+    };
+    return {
+      subscribe
+    };
+  }
+}
+
+class EventRegistry {
+  chat;
+  events;
+  constructor(chat) {
+    this.chat = chat;
+    this.events = new Map;
+  }
+  register(event, handler) {
+    let entry = this.events.get(event);
+    if (!entry) {
+      const newEntry = {
+        source: event,
+        listeners: new EventEmitter
+      };
+      entry = newEntry;
+      this.events.set(event, newEntry);
+      event.subscribe((...args) => newEntry.listeners.emit(...args), this.chat);
+    }
+    entry.listeners.listen((...args) => handler(...args));
+  }
+}
+export {
+  TableEvent,
+  ListenerEvent,
+  EventRegistry
+};
+
+//# debugId=32DECB28BCA2C08764756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../omu/dist/esm/event/index.js", "../../src/event/event.ts"],
  "sourcesContent": [
    "// @bun\n// src/event/index.ts\nclass EventEmitter {\n  listeners = [];\n  listen(listener) {\n    this.listeners.push(listener);\n    return () => {\n      this.listeners.splice(this.listeners.indexOf(listener), 1);\n    };\n  }\n  async emit(...args) {\n    for (const listener of [...this.listeners]) {\n      await listener(...args);\n    }\n  }\n}\nexport {\n  EventEmitter\n};\n\n//# debugId=7F555088E4509AF464756E2164756E21\n//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2V2ZW50L2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWwogICAgImV4cG9ydCB0eXBlIFVubGlzdGVuID0gKCkgPT4gdm9pZDtcblxuZXhwb3J0IGNsYXNzIEV2ZW50RW1pdHRlcjxQIGV4dGVuZHMgQXJyYXk8YW55Pj4ge1xuICAgIHByaXZhdGUgcmVhZG9ubHkgbGlzdGVuZXJzOiBBcnJheTwoLi4uYXJnczogUCkgPT4gUHJvbWlzZTx2b2lkPiB8IHZvaWQ+ID0gW107XG5cbiAgICBwdWJsaWMgbGlzdGVuKGxpc3RlbmVyOiAoLi4uYXJnczogUCkgPT4gYW55KTogVW5saXN0ZW4ge1xuICAgICAgICB0aGlzLmxpc3RlbmVycy5wdXNoKGxpc3RlbmVyKTtcbiAgICAgICAgcmV0dXJuICgpID0+IHtcbiAgICAgICAgICAgIHRoaXMubGlzdGVuZXJzLnNwbGljZSh0aGlzLmxpc3RlbmVycy5pbmRleE9mKGxpc3RlbmVyKSwgMSk7XG4gICAgICAgIH07XG4gICAgfVxuXG4gICAgcHVibGljIGFzeW5jIGVtaXQoLi4uYXJnczogUCk6IFByb21pc2U8dm9pZD4ge1xuICAgICAgICBmb3IgKGNvbnN0IGxpc3RlbmVyIG9mIFsuLi50aGlzLmxpc3RlbmVyc10pIHtcbiAgICAgICAgICAgIGF3YWl0IGxpc3RlbmVyKC4uLmFyZ3MpO1xuICAgICAgICB9XG4gICAgfVxufVxuIgogIF0sCiAgIm1hcHBpbmdzIjogIjs7QUFFTyxNQUFNLGFBQW1DO0FBQUEsRUFDM0IsWUFBeUQsQ0FBQztBQUFBLEVBRXBFLE1BQU0sQ0FBQyxVQUF5QztBQUFBLElBQ25ELEtBQUssVUFBVSxLQUFLLFFBQVE7QUFBQSxJQUM1QixPQUFPLE1BQU07QUFBQSxNQUNULEtBQUssVUFBVSxPQUFPLEtBQUssVUFBVSxRQUFRLFFBQVEsR0FBRyxDQUFDO0FBQUE7QUFBQTtBQUFBLE9BSXBELEtBQUksSUFBSSxNQUF3QjtBQUFBLElBQ3pDLFdBQVcsWUFBWSxDQUFDLEdBQUcsS0FBSyxTQUFTLEdBQUc7QUFBQSxNQUN4QyxNQUFNLFNBQVMsR0FBRyxJQUFJO0FBQUEsSUFDMUI7QUFBQTtBQUVSOyIsCiAgImRlYnVnSWQiOiAiN0Y1NTUwODhFNDUwOUFGNDY0NzU2RTIxNjQ3NTZFMjEiLAogICJuYW1lcyI6IFtdCn0=\n",
    "import type { Table } from '@omujs/omu/api/table';\nimport type { Unlisten } from '@omujs/omu/event';\nimport { EventEmitter } from '@omujs/omu/event';\n\nimport type { Chat } from '../chat.js';\n\nexport type EventHandler<P extends Array<any>> = (...args: P) => Promise<void> | void;\n\nexport interface EventSource<P extends Array<any>> {\n    subscribe(handler: EventHandler<P>, chat: Chat): Unlisten;\n}\n\nexport class ListenerEvent<P extends Array<any>> implements EventSource<P> {\n    constructor(private readonly getListener: (chat: Chat) => EventEmitter<P>) {}\n\n    public subscribe(handler: EventHandler<P>, chat: Chat): Unlisten {\n        const listener = this.getListener(chat);\n        return listener.listen(handler);\n    }\n}\n\nexport class TableEvent<T> extends ListenerEvent<[Map<string, T>]> {\n    public readonly AddBatch: ListenerEvent<[Map<string, T>]>;\n    public readonly UpdateBatch: ListenerEvent<[Map<string, T>]>;\n    public readonly RemoveBatch: ListenerEvent<[Map<string, T>]>;\n    public readonly Add: EventSource<[T]>;\n    public readonly Update: EventSource<[T]>;\n    public readonly Remove: EventSource<[T]>;\n    public readonly Clear: EventSource<[]>;\n    public readonly wrappers: Record<string, Unlisten>;\n\n    constructor(private readonly getTable: (chat: Chat) => Table<T>) {\n        super((chat) => getTable(chat).event.cacheUpdate);\n        this.AddBatch = new ListenerEvent((chat) => getTable(chat).event.add);\n        this.UpdateBatch = new ListenerEvent((chat) => getTable(chat).event.update);\n        this.RemoveBatch = new ListenerEvent((chat) => getTable(chat).event.remove);\n        this.Add = this.createBatchSubscriber((table) => table.event.add);\n        this.Update = this.createBatchSubscriber((table) => table.event.update);\n        this.Remove = this.createBatchSubscriber((table) => table.event.remove);\n        this.Clear = new ListenerEvent((client) => getTable(client).event.clear);\n        this.wrappers = {};\n    }\n\n    private static createBatchWrapper<T>(emit: EventHandler<[T]>): EventHandler<[Map<string, T>]> {\n        return async (items) => {\n            for (const item of items.values()) {\n                await emit(item);\n            }\n        };\n    }\n\n    private createBatchSubscriber(\n        getListener: (table: Table<T>) => EventEmitter<[Map<string, T>]>,\n    ): EventSource<[T]> {\n        let batchWrapper: EventHandler<[Map<string, T>]> | null = null;\n\n        const subscribe = (emit: EventHandler<[T]>, chat: Chat): Unlisten => {\n            const table = this.getTable(chat);\n            const listener = getListener(table);\n            batchWrapper = TableEvent.createBatchWrapper((item) => emit(item));\n            const stopListen = table.listen();\n            const clearEvent = listener.listen(batchWrapper);\n            return () => {\n                stopListen();\n                clearEvent();\n            };\n        };\n\n        return {\n            subscribe,\n        };\n    }\n}\n\ntype Entry<P extends Array<any>> = {\n    source: EventSource<P>;\n    listeners: EventEmitter<P>;\n};\n\nexport class EventRegistry {\n    private readonly chat: Chat;\n    private readonly events: Map<EventSource<any>, Entry<any>>;\n\n    constructor(chat: Chat) {\n        this.chat = chat;\n        this.events = new Map();\n    }\n\n    public register<P extends Array<any>>(event: EventSource<P>, handler: EventHandler<P>): void {\n        let entry = this.events.get(event) as Entry<P> | null;\n        if (!entry) {\n            const newEntry: Entry<P> = {\n                source: event,\n                listeners: new EventEmitter(),\n            };\n            entry = newEntry;\n            this.events.set(event, newEntry);\n            event.subscribe((...args) => newEntry.listeners.emit(...args), this.chat);\n        }\n        entry.listeners.listen((...args) => handler(...args));\n    }\n}\n"
  ],
  "mappings": "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",
  "debugId": "32DECB28BCA2C08764756E2164756E21",
  "names": []
}

package/dist/esm/event/index.js

@@ -0,0 +1,115 @@
+// @bun
+// ../omu/dist/esm/event/index.js
+class EventEmitter {
+  listeners = [];
+  listen(listener) {
+    this.listeners.push(listener);
+    return () => {
+      this.listeners.splice(this.listeners.indexOf(listener), 1);
+    };
+  }
+  async emit(...args) {
+    for (const listener of [...this.listeners]) {
+      await listener(...args);
+    }
+  }
+}
+
+// src/event/event.ts
+class ListenerEvent {
+  getListener;
+  constructor(getListener) {
+    this.getListener = getListener;
+  }
+  subscribe(handler, chat) {
+    const listener = this.getListener(chat);
+    return listener.listen(handler);
+  }
+}
+
+class TableEvent extends ListenerEvent {
+  getTable;
+  AddBatch;
+  UpdateBatch;
+  RemoveBatch;
+  Add;
+  Update;
+  Remove;
+  Clear;
+  wrappers;
+  constructor(getTable) {
+    super((chat) => getTable(chat).event.cacheUpdate);
+    this.getTable = getTable;
+    this.AddBatch = new ListenerEvent((chat) => getTable(chat).event.add);
+    this.UpdateBatch = new ListenerEvent((chat) => getTable(chat).event.update);
+    this.RemoveBatch = new ListenerEvent((chat) => getTable(chat).event.remove);
+    this.Add = this.createBatchSubscriber((table) => table.event.add);
+    this.Update = this.createBatchSubscriber((table) => table.event.update);
+    this.Remove = this.createBatchSubscriber((table) => table.event.remove);
+    this.Clear = new ListenerEvent((client) => getTable(client).event.clear);
+    this.wrappers = {};
+  }
+  static createBatchWrapper(emit) {
+    return async (items) => {
+      for (const item of items.values()) {
+        await emit(item);
+      }
+    };
+  }
+  createBatchSubscriber(getListener) {
+    let batchWrapper = null;
+    const subscribe = (emit, chat) => {
+      const table = this.getTable(chat);
+      const listener = getListener(table);
+      batchWrapper = TableEvent.createBatchWrapper((item) => emit(item));
+      const stopListen = table.listen();
+      const clearEvent = listener.listen(batchWrapper);
+      return () => {
+        stopListen();
+        clearEvent();
+      };
+    };
+    return {
+      subscribe
+    };
+  }
+}
+
+class EventRegistry {
+  chat;
+  events;
+  constructor(chat) {
+    this.chat = chat;
+    this.events = new Map;
+  }
+  register(event, handler) {
+    let entry = this.events.get(event);
+    if (!entry) {
+      const newEntry = {
+        source: event,
+        listeners: new EventEmitter
+      };
+      entry = newEntry;
+      this.events.set(event, newEntry);
+      event.subscribe((...args) => newEntry.listeners.emit(...args), this.chat);
+    }
+    entry.listeners.listen((...args) => handler(...args));
+  }
+}
+
+// src/event/event-types.ts
+var events = {
+  Message: new TableEvent((chat) => chat.messages),
+  Author: new TableEvent((chat) => chat.authors),
+  Channel: new TableEvent((chat) => chat.channels),
+  Provider: new TableEvent((chat) => chat.providers),
+  Room: new TableEvent((chat) => chat.rooms),
+  Vote: new TableEvent((chat) => chat.votes)
+};
+export {
+  events as Events,
+  EventRegistry
+};
+
+//# debugId=F2B3B443165F1CA764756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../omu/dist/esm/event/index.js", "../../src/event/event.ts", "../../src/event/event-types.ts"],
  "sourcesContent": [
    "// @bun\n// src/event/index.ts\nclass EventEmitter {\n  listeners = [];\n  listen(listener) {\n    this.listeners.push(listener);\n    return () => {\n      this.listeners.splice(this.listeners.indexOf(listener), 1);\n    };\n  }\n  async emit(...args) {\n    for (const listener of [...this.listeners]) {\n      await listener(...args);\n    }\n  }\n}\nexport {\n  EventEmitter\n};\n\n//# debugId=7F555088E4509AF464756E2164756E21\n//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2V2ZW50L2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWwogICAgImV4cG9ydCB0eXBlIFVubGlzdGVuID0gKCkgPT4gdm9pZDtcblxuZXhwb3J0IGNsYXNzIEV2ZW50RW1pdHRlcjxQIGV4dGVuZHMgQXJyYXk8YW55Pj4ge1xuICAgIHByaXZhdGUgcmVhZG9ubHkgbGlzdGVuZXJzOiBBcnJheTwoLi4uYXJnczogUCkgPT4gUHJvbWlzZTx2b2lkPiB8IHZvaWQ+ID0gW107XG5cbiAgICBwdWJsaWMgbGlzdGVuKGxpc3RlbmVyOiAoLi4uYXJnczogUCkgPT4gYW55KTogVW5saXN0ZW4ge1xuICAgICAgICB0aGlzLmxpc3RlbmVycy5wdXNoKGxpc3RlbmVyKTtcbiAgICAgICAgcmV0dXJuICgpID0+IHtcbiAgICAgICAgICAgIHRoaXMubGlzdGVuZXJzLnNwbGljZSh0aGlzLmxpc3RlbmVycy5pbmRleE9mKGxpc3RlbmVyKSwgMSk7XG4gICAgICAgIH07XG4gICAgfVxuXG4gICAgcHVibGljIGFzeW5jIGVtaXQoLi4uYXJnczogUCk6IFByb21pc2U8dm9pZD4ge1xuICAgICAgICBmb3IgKGNvbnN0IGxpc3RlbmVyIG9mIFsuLi50aGlzLmxpc3RlbmVyc10pIHtcbiAgICAgICAgICAgIGF3YWl0IGxpc3RlbmVyKC4uLmFyZ3MpO1xuICAgICAgICB9XG4gICAgfVxufVxuIgogIF0sCiAgIm1hcHBpbmdzIjogIjs7QUFFTyxNQUFNLGFBQW1DO0FBQUEsRUFDM0IsWUFBeUQsQ0FBQztBQUFBLEVBRXBFLE1BQU0sQ0FBQyxVQUF5QztBQUFBLElBQ25ELEtBQUssVUFBVSxLQUFLLFFBQVE7QUFBQSxJQUM1QixPQUFPLE1BQU07QUFBQSxNQUNULEtBQUssVUFBVSxPQUFPLEtBQUssVUFBVSxRQUFRLFFBQVEsR0FBRyxDQUFDO0FBQUE7QUFBQTtBQUFBLE9BSXBELEtBQUksSUFBSSxNQUF3QjtBQUFBLElBQ3pDLFdBQVcsWUFBWSxDQUFDLEdBQUcsS0FBSyxTQUFTLEdBQUc7QUFBQSxNQUN4QyxNQUFNLFNBQVMsR0FBRyxJQUFJO0FBQUEsSUFDMUI7QUFBQTtBQUVSOyIsCiAgImRlYnVnSWQiOiAiN0Y1NTUwODhFNDUwOUFGNDY0NzU2RTIxNjQ3NTZFMjEiLAogICJuYW1lcyI6IFtdCn0=\n",
    "import type { Table } from '@omujs/omu/api/table';\nimport type { Unlisten } from '@omujs/omu/event';\nimport { EventEmitter } from '@omujs/omu/event';\n\nimport type { Chat } from '../chat.js';\n\nexport type EventHandler<P extends Array<any>> = (...args: P) => Promise<void> | void;\n\nexport interface EventSource<P extends Array<any>> {\n    subscribe(handler: EventHandler<P>, chat: Chat): Unlisten;\n}\n\nexport class ListenerEvent<P extends Array<any>> implements EventSource<P> {\n    constructor(private readonly getListener: (chat: Chat) => EventEmitter<P>) {}\n\n    public subscribe(handler: EventHandler<P>, chat: Chat): Unlisten {\n        const listener = this.getListener(chat);\n        return listener.listen(handler);\n    }\n}\n\nexport class TableEvent<T> extends ListenerEvent<[Map<string, T>]> {\n    public readonly AddBatch: ListenerEvent<[Map<string, T>]>;\n    public readonly UpdateBatch: ListenerEvent<[Map<string, T>]>;\n    public readonly RemoveBatch: ListenerEvent<[Map<string, T>]>;\n    public readonly Add: EventSource<[T]>;\n    public readonly Update: EventSource<[T]>;\n    public readonly Remove: EventSource<[T]>;\n    public readonly Clear: EventSource<[]>;\n    public readonly wrappers: Record<string, Unlisten>;\n\n    constructor(private readonly getTable: (chat: Chat) => Table<T>) {\n        super((chat) => getTable(chat).event.cacheUpdate);\n        this.AddBatch = new ListenerEvent((chat) => getTable(chat).event.add);\n        this.UpdateBatch = new ListenerEvent((chat) => getTable(chat).event.update);\n        this.RemoveBatch = new ListenerEvent((chat) => getTable(chat).event.remove);\n        this.Add = this.createBatchSubscriber((table) => table.event.add);\n        this.Update = this.createBatchSubscriber((table) => table.event.update);\n        this.Remove = this.createBatchSubscriber((table) => table.event.remove);\n        this.Clear = new ListenerEvent((client) => getTable(client).event.clear);\n        this.wrappers = {};\n    }\n\n    private static createBatchWrapper<T>(emit: EventHandler<[T]>): EventHandler<[Map<string, T>]> {\n        return async (items) => {\n            for (const item of items.values()) {\n                await emit(item);\n            }\n        };\n    }\n\n    private createBatchSubscriber(\n        getListener: (table: Table<T>) => EventEmitter<[Map<string, T>]>,\n    ): EventSource<[T]> {\n        let batchWrapper: EventHandler<[Map<string, T>]> | null = null;\n\n        const subscribe = (emit: EventHandler<[T]>, chat: Chat): Unlisten => {\n            const table = this.getTable(chat);\n            const listener = getListener(table);\n            batchWrapper = TableEvent.createBatchWrapper((item) => emit(item));\n            const stopListen = table.listen();\n            const clearEvent = listener.listen(batchWrapper);\n            return () => {\n                stopListen();\n                clearEvent();\n            };\n        };\n\n        return {\n            subscribe,\n        };\n    }\n}\n\ntype Entry<P extends Array<any>> = {\n    source: EventSource<P>;\n    listeners: EventEmitter<P>;\n};\n\nexport class EventRegistry {\n    private readonly chat: Chat;\n    private readonly events: Map<EventSource<any>, Entry<any>>;\n\n    constructor(chat: Chat) {\n        this.chat = chat;\n        this.events = new Map();\n    }\n\n    public register<P extends Array<any>>(event: EventSource<P>, handler: EventHandler<P>): void {\n        let entry = this.events.get(event) as Entry<P> | null;\n        if (!entry) {\n            const newEntry: Entry<P> = {\n                source: event,\n                listeners: new EventEmitter(),\n            };\n            entry = newEntry;\n            this.events.set(event, newEntry);\n            event.subscribe((...args) => newEntry.listeners.emit(...args), this.chat);\n        }\n        entry.listeners.listen((...args) => handler(...args));\n    }\n}\n",
    "import { Author } from '../models/author.js';\nimport { Channel } from '../models/channel.js';\nimport { Message } from '../models/message.js';\nimport { Provider } from '../models/provider.js';\nimport { Room } from '../models/room.js';\nimport { Vote } from '../models/vote.js';\nimport { TableEvent } from './event.js';\n\nexport const events: { Message: TableEvent<Message>; Author: TableEvent<Author>; Channel: TableEvent<Channel>; Provider: TableEvent<Provider>; Room: TableEvent<Room>; Vote: TableEvent<Vote> } = {\n    Message: new TableEvent((chat) => chat.messages),\n    Author: new TableEvent((chat) => chat.authors),\n    Channel: new TableEvent((chat) => chat.channels),\n    Provider: new TableEvent((chat) => chat.providers),\n    Room: new TableEvent((chat) => chat.rooms),\n    Vote: new TableEvent((chat) => chat.votes),\n};\n"
  ],
  "mappings": "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",
  "debugId": "F2B3B443165F1CA764756E2164756E21",
  "names": []
}