tgui-core 5.4.2 → 5.5.0

package/dist/common/eventbus.d.ts

@@ -11,39 +11,48 @@
  * and update accordingly.
  *
  * @usage
+ *
+ * First, create an EventBus with the listeners you want to handle.
  * ```ts
  * const bus = new EventBus(listeners);
+ *```
  *
- * // These are the event types and their corresponding callbacks.
+ *  Next, define the listeners object. These are the event types and their
+ * corresponding callbacks.
+ * ```ts
  * const listeners = {
- *   'messageTypeA': (message) => { logger.log(message.payload); },
+ *   'messageTypeA': [handlerA, handlerB, handlerC],
  * } as const;
+ *```
  *
- * // You can further shorten this by linking a function to the event type:
- * function messageTypeA(payload: { text: string }) {
+ * Write a handler for the specific message type. They're handled serially.
+ * Anything you return will be passed to the next listener as the payload.
+ * ```ts
+ * function handlerA(payload: { text: string }) {
  *  logger.log(payload.text);
+ *  // The payload is discarded!
  * }
  *
- * const listeners = {
- *   messageTypeA,
- * } as const;
- *
- *
- * // Later, dispatch a message:
- * const message: ByondMessage = {
- *   type: 'messageTypeA',
- *   payload: { text: 'Hello, world!' },
- * };
+ * function handlerB(payload: { count: number }) {
+ *  // The next handler will receive this object as its payload.
+ *  return { count: payload.count + 1, otherData: 'foo' };
+ * }
  *
- * bus.dispatch(message);
- * ```
+ * function handlerC(payload: { count: number; otherData: string }) {
+ *  logger.log(`Count is ${payload.count} and otherData is ${payload.otherData}`);
+ * }
+ *```
  */
-export declare class EventBus<TListeners extends Readonly<Record<string, (payload: unknown) => void>>> {
+export declare class EventBus<TListeners extends Readonly<Record<string, Array<(payload: unknown) => void>>>> {
     private listeners;
     constructor(initialListeners: TListeners);
     /** Dispatch a message to the appropriate listener. */
     dispatch<TType extends keyof TListeners>(message: {
         type: TType;
-        payload?: Parameters<TListeners[TType]>[0];
+        /**
+         * This should match the first listener's payload type. It can be passed
+         * along and mutated by each listener in the chain by returning a new value.
+         */
+        payload?: Parameters<TListeners[TType][0]>[0];
     }): void;
 }

package/dist/common/eventbus.js

@@ -1 +1 @@
-class s{listeners={};constructor(s){this.listeners=s}dispatch(s){this.listeners[s.type]?.(s.payload)}}export{s as EventBus};
+class e{listeners={};constructor(e){this.listeners=e}dispatch(e){let t=this.listeners[e.type]?.length||0;if(0===t)return void console.warn(`EventBus: No listeners for message type "${String(e.type)}"`);let s=e.payload;for(let r=0;r<t;r++)s=this.listeners[e.type]?.[r](s)}}export{e as EventBus};

package/package.json

@@ -67,5 +67,5 @@
     "test": "bun test"
   },
   "type": "module",
-  "version": "5.4.2"
+  "version": "5.5.0"
 }