tgui-core 5.5.0 → 5.5.2

package/dist/common/eventbus.d.ts

@@ -3,56 +3,66 @@
  *
  * Handles different event messages from byond and TGUI.
  *
- * Don't fret! This is a simple class under the hood. Using some typescript-fu,
- * it's able to provide type safety for the event types and their payloads.
- *
  * The philosophy: This interacts directly with state managers in vanilla JS,
  * offering a way to handle browser events. UIs then subscribe to these states
  * and update accordingly.
  *
  * @usage
  *
- * First, create an EventBus with the listeners you want to handle.
+ * ### First step
+ *
+ * Create an EventBus with the listeners you want to handle.
+ *
  * ```ts
  * const bus = new EventBus(listeners);
  *```
  *
- *  Next, define the listeners object. These are the event types and their
+ * ### Second step
+ *
+ * Next, define the listeners object. These are the event types and their
  * corresponding callbacks.
+ *
  * ```ts
  * const listeners = {
- *   'messageTypeA': [handlerA, handlerB, handlerC],
+ *   'messageTypeA': handlerA,
  * } as const;
  *```
  *
- * 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.
+ * ### Third step
+ *
+ * Write a handler for the specific message type.
+ *
  * ```ts
- * function handlerA(payload: { text: string }) {
- *  logger.log(payload.text);
- *  // The payload is discarded!
- * }
+ * type ExpectedPayloadA = {
+ *   text: string;
+ * };
  *
- * function handlerB(payload: { count: number }) {
- *  // The next handler will receive this object as its payload.
- *  return { count: payload.count + 1, otherData: 'foo' };
+ * function handlerA(payload: ExpectedPayloadA) {
+ *   logger.log(payload.text);
  * }
+ *```
+
+ * You can now dispatch the messageTypeA event! If you want to shorten the
+ * syntax, you can name the handler function after the incoming event type.
  *
- * function handlerC(payload: { count: number; otherData: string }) {
- *  logger.log(`Count is ${payload.count} and otherData is ${payload.otherData}`);
+ * ````ts
+ * function messageTypeA(payload: ExpectedPayloadA) {
+ *   logger.log(payload.text);
  * }
- *```
+ *
+ * const listeners = {
+ *  messageTypeA,
+ * } as const;
+ *
  */
-export declare class EventBus<TListeners extends Readonly<Record<string, Array<(payload: unknown) => void>>>> {
+export declare class EventBus<TListeners extends ListenerMap> {
     private listeners;
     constructor(initialListeners: TListeners);
     /** Dispatch a message to the appropriate listener. */
-    dispatch<TType extends keyof TListeners>(message: {
-        type: TType;
-        /**
-         * 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;
+    dispatch(message: Message): void;
 }
+export type ListenerMap = Record<string, (payload?: unknown) => void>;
+export type Message = {
+    type: string;
+    payload?: unknown;
+};

package/dist/common/eventbus.js

@@ -1 +1 @@
-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};
+class s{listeners;constructor(s){this.listeners=s}dispatch(s){let t=this.listeners[s.type];"payload"in s?t(s.payload):t()}}export{s as EventBus};

package/package.json

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