@xylabs/events 4.9.17

package/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

package/README.md

@@ -0,0 +1,69 @@
+[![logo][]](https://xylabs.com)
+
+# @xylabs/events
+
+[![npm-badge][]][npm-link]
+[![npm-downloads-badge][]][npm-link]
+[![jsdelivr-badge][]][jsdelivr-link]
+[![npm-license-badge][]](LICENSE)
+[![socket-badge][]][socket-link]
+
+> XY Labs generalized Javascript library 
+
+## Table of Contents
+
+-   [Description](#description)
+-   [Install](#install)
+-   [Maintainers](#maintainers)
+-   [License](#license)
+-   [Credits](#credits)
+
+## Description
+
+Common Javascript code that is used throughout XYO projects that use React.
+
+## Install
+
+Using npm:
+
+```sh
+npm i --save @xylabs/events
+```
+
+Using yarn:
+
+```sh
+yarn add @xylabs/events
+```
+
+## Documentation
+[Developer Reference](https://xylabs.github.io/sdk-js)
+
+## Maintainers
+
+-   [Arie Trouw](https://github.com/arietrouw) ([arietrouw.com](https://arietrouw.com))
+-   [Joel Carter](https://github.com/JoelBCarter)
+-   [Matt Jones](https://github.com/jonesmac)
+-   [Jordan Trouw](https://github.com/jordantrouw)
+
+## License
+
+See the [LICENSE](LICENSE) file for license details
+
+## Credits
+
+[Made with 🔥and ❄️ by XY Labs](https://xylabs.com)
+
+[logo]: https://cdn.xy.company/img/brand/XYPersistentCompany_Logo_Icon_Colored.svg
+
+[npm-badge]: https://img.shields.io/npm/v/@xylabs/events.svg
+[npm-link]: https://www.npmjs.com/package/@xylabs/events
+
+[npm-downloads-badge]: https://img.shields.io/npm/dw/@xylabs/events
+[npm-license-badge]: https://img.shields.io/npm/l/@xylabs/events
+
+[jsdelivr-badge]: https://data.jsdelivr.com/v1/package/npm/@xylabs/events/badge
+[jsdelivr-link]: https://www.jsdelivr.com/package/npm/@xylabs/events
+
+[socket-badge]: https://socket.dev/api/badge/npm/package/@xylabs/events
+[socket-link]: https://socket.dev/npm/package/@xylabs/events

package/dist/neutral/index.mjs

@@ -0,0 +1,258 @@
+// src/Events/Events.ts
+import { assertEx } from "@xylabs/assert";
+import { Base } from "@xylabs/base";
+import { handleError } from "@xylabs/error";
+import { forget } from "@xylabs/forget";
+import { isDefined } from "@xylabs/typeof";
+var NO_META_EVENT_ERROR_MESSAGE = "`eventName` cannot be meta event `listenerAdded` or `listenerRemoved`";
+var resolvedPromise = Promise.resolve();
+var isMetaEvent = (eventName) => eventName === "listenerAdded" || eventName === "listenerRemoved";
+var Events = class _Events extends Base {
+  static anyMap = /* @__PURE__ */ new WeakMap();
+  static eventsMap = /* @__PURE__ */ new WeakMap();
+  static canEmitMetaEvents = false;
+  static isGlobalDebugEnabled = false;
+  // this is here to be able to query the type, not use
+  eventData = {};
+  constructor(params = {}) {
+    const mutatedParams = { ...params };
+    if (mutatedParams.debug) {
+      mutatedParams.debug.logger = mutatedParams.debug.logger ?? ((type, debugName, eventName, eventData) => {
+        let eventDataString;
+        try {
+          eventDataString = JSON.stringify(eventData);
+        } catch {
+          eventDataString = `Object with the following keys failed to stringify: ${Object.keys(eventData ?? {}).join(",")}`;
+        }
+        const eventNameString = typeof eventName === "symbol" || typeof eventName === "number" ? eventName.toString() : eventName;
+        const currentTime = /* @__PURE__ */ new Date();
+        const logTime = `${currentTime.getHours()}:${currentTime.getMinutes()}:${currentTime.getSeconds()}.${currentTime.getMilliseconds()}`;
+        this.logger?.log(`[${logTime}][events:${type}][${debugName}] Event Name: ${eventNameString}
+	data: ${eventDataString}`);
+      });
+    }
+    super(mutatedParams);
+    _Events.anyMap.set(this, /* @__PURE__ */ new Set());
+    _Events.eventsMap.set(this, /* @__PURE__ */ new Map());
+  }
+  static get isDebugEnabled() {
+    if (typeof globalThis.process?.env !== "object") {
+      return _Events.isGlobalDebugEnabled;
+    }
+    const { env } = globalThis.process ?? { env: {} };
+    return env.DEBUG === "events" || env.DEBUG === "*" || _Events.isGlobalDebugEnabled;
+  }
+  static set isDebugEnabled(newValue) {
+    _Events.isGlobalDebugEnabled = newValue;
+  }
+  get debug() {
+    return this.params.debug;
+  }
+  clearListeners(eventNames) {
+    const eventNamesArray = Array.isArray(eventNames) ? eventNames : [eventNames];
+    for (const eventName of eventNamesArray) {
+      this.logIfDebugEnabled("clear", eventName);
+      if (typeof eventName === "string" || typeof eventName === "symbol" || typeof eventName === "number") {
+        const set = this.getListeners(eventName);
+        if (set) {
+          set.clear();
+        }
+      } else {
+        _Events.anyMap.get(this)?.clear();
+        for (const [eventName2, listeners] of assertEx(_Events.eventsMap.get(this)).entries()) {
+          listeners.clear();
+          _Events.eventsMap.get(this)?.delete(eventName2);
+        }
+      }
+    }
+  }
+  async emit(eventName, eventArgs) {
+    await this.emitInternal(eventName, eventArgs);
+  }
+  async emitMetaEvent(eventName, eventArgs) {
+    if (isMetaEvent(eventName)) {
+      try {
+        _Events.canEmitMetaEvents = true;
+        await this.emitMetaEventInternal(eventName, eventArgs);
+      } finally {
+        _Events.canEmitMetaEvents = false;
+      }
+    }
+  }
+  async emitSerial(eventName, eventArgs) {
+    if (isMetaEvent(eventName) && !_Events.canEmitMetaEvents) {
+      throw new TypeError(NO_META_EVENT_ERROR_MESSAGE);
+    }
+    const filterMatch = (args, filter) => {
+      switch (typeof filter) {
+        case "object": {
+          return Object.entries(args).reduce((prev, [key, value]) => filter[key] === value ? true : prev, false);
+        }
+        default: {
+          return args === filter;
+        }
+      }
+    };
+    this.logIfDebugEnabled("emitSerial", eventName, eventArgs);
+    const listeners = this.getListeners(eventName) ?? /* @__PURE__ */ new Set();
+    const filteredListeners = [...listeners.values()].filter((value) => isDefined(value.filter) ? filterMatch(eventArgs, value.filter) : true).map((info) => info.listener);
+    const anyListeners = assertEx(_Events.anyMap.get(this));
+    const staticListeners = [...filteredListeners];
+    const staticAnyListeners = [...anyListeners];
+    await resolvedPromise;
+    for (const listener of staticListeners) {
+      await this.safeCallListener(eventName, eventArgs, listener);
+    }
+    for (const listener of staticAnyListeners) {
+      await this.safeCallAnyListener(eventName, eventArgs, listener);
+    }
+  }
+  // TODO: Make test for this
+  listenerCount(eventNames) {
+    const eventNamesArray = Array.isArray(eventNames) ? eventNames : [eventNames];
+    let count = 0;
+    for (const eventName of eventNamesArray) {
+      if (typeof eventName === "string") {
+        count += assertEx(_Events.anyMap.get(this)).size + (this.getListeners(eventName)?.size ?? 0);
+        continue;
+      }
+      count += assertEx(_Events.anyMap.get(this)).size;
+      for (const value of assertEx(_Events.eventsMap.get(this)).values()) {
+        count += value.size;
+      }
+    }
+    return count;
+  }
+  logIfDebugEnabled(type, eventName, eventArgs) {
+    if (_Events.isDebugEnabled || this.debug?.enabled) {
+      this.debug?.logger?.(type, this.debug.name, eventName, eventArgs);
+    }
+  }
+  off(eventNames, listener) {
+    const eventNamesArray = Array.isArray(eventNames) ? eventNames : [eventNames];
+    for (const eventName of eventNamesArray) {
+      const set = this.getListeners(eventName);
+      if (set) {
+        set.delete(listener);
+        if (set.size === 0) {
+          const events = _Events.eventsMap.get(this);
+          events?.delete(eventName);
+        }
+      }
+      this.logIfDebugEnabled("unsubscribe", eventName);
+      if (!isMetaEvent(eventName)) {
+        forget(this.emitMetaEvent("listenerRemoved", { eventName, listener }));
+      }
+    }
+  }
+  offAny(listener) {
+    this.logIfDebugEnabled("unsubscribeAny");
+    const typedMap = _Events.anyMap.get(this);
+    typedMap?.delete(listener);
+    forget(this.emitMetaEvent("listenerRemoved", { listener }));
+  }
+  on(eventNames, listener, filter) {
+    const eventNamesArray = Array.isArray(eventNames) ? eventNames : [eventNames];
+    for (const eventName of eventNamesArray) {
+      let set = this.getListeners(eventName);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        const events = _Events.eventsMap.get(this);
+        events?.set(eventName, set);
+      }
+      set.add({ filter, listener });
+      this.logIfDebugEnabled("subscribe", eventName);
+      if (!isMetaEvent(eventName)) {
+        forget(this.emitMetaEvent("listenerAdded", { eventName, listener }));
+      }
+    }
+    return this.off.bind(this, eventNames, listener);
+  }
+  onAny(listener) {
+    this.logIfDebugEnabled("subscribeAny");
+    _Events.anyMap.get(this)?.add(listener);
+    forget(this.emitMetaEvent("listenerAdded", { listener }));
+    return this.offAny.bind(this, listener);
+  }
+  once(eventName, listener) {
+    const subListener = async (args) => {
+      this.off(eventName, subListener);
+      await this.safeCallListener(eventName, args, listener);
+    };
+    this.on(eventName, subListener);
+    return this.off.bind(this, eventName, subListener);
+  }
+  async emitInternal(eventName, eventArgs, filter) {
+    if (isMetaEvent(eventName) && !_Events.canEmitMetaEvents) {
+      throw new TypeError(NO_META_EVENT_ERROR_MESSAGE);
+    }
+    this.logIfDebugEnabled("emit", eventName, eventArgs);
+    const listeners = this.getListeners(eventName) ?? /* @__PURE__ */ new Set();
+    const filteredListeners = [...listeners.values()].filter((value) => isDefined(filter) ? isDefined(value.listener) : true).map((info) => info.listener);
+    const anyListeners = assertEx(_Events.anyMap.get(this));
+    const staticListeners = [...filteredListeners];
+    const staticAnyListeners = isMetaEvent(eventName) ? [] : [...anyListeners];
+    await resolvedPromise;
+    await Promise.all([
+      ...staticListeners.map(async (listener) => {
+        await this.safeCallListener(eventName, eventArgs, listener);
+      }),
+      ...staticAnyListeners.map(async (listener) => {
+        if (anyListeners.has(listener)) {
+          await this.safeCallAnyListener(eventName, eventArgs, listener);
+        }
+      })
+    ]);
+  }
+  async emitMetaEventInternal(eventName, eventArgs) {
+    if (isMetaEvent(eventName) && !_Events.canEmitMetaEvents) {
+      throw new TypeError("`eventName` cannot be meta event `listenerAdded` or `listenerRemoved`");
+    }
+    this.logIfDebugEnabled("emit", eventName, eventArgs);
+    const listeners = this.getListeners(eventName) ?? /* @__PURE__ */ new Set();
+    const filteredListeners = [...listeners.values()].map((info) => info.listener);
+    const anyListeners = assertEx(_Events.anyMap.get(this));
+    const staticListeners = [...filteredListeners];
+    const staticAnyListeners = isMetaEvent(eventName) ? [] : [...anyListeners];
+    await resolvedPromise;
+    await Promise.all([
+      ...staticListeners.map(async (listener) => {
+        await this.safeCallListener(eventName, eventArgs, listener);
+      }),
+      ...staticAnyListeners.map(async (listener) => {
+        if (anyListeners.has(listener)) {
+          await this.safeCallAnyListener(eventName, eventArgs, listener);
+        }
+      })
+    ]);
+  }
+  getListeners(eventName) {
+    const events = assertEx(_Events.eventsMap.get(this));
+    if (!events.has(eventName)) {
+      return;
+    }
+    return events.get(eventName);
+  }
+  async safeCallAnyListener(eventName, eventArgs, listener) {
+    try {
+      return await listener(eventName, eventArgs);
+    } catch (ex) {
+      handleError(ex, (error) => {
+        this.logger?.error(`Listener[${String(eventName)}] Excepted: ${error.message}`);
+      });
+    }
+  }
+  async safeCallListener(eventName, eventArgs, listener) {
+    try {
+      return await listener(eventArgs);
+    } catch (ex) {
+      handleError(ex, (error) => {
+        this.logger?.error(`Listener[${String(eventName)}] Excepted: ${error.message}`);
+      });
+    }
+  }
+};
+export {
+  Events
+};
+//# sourceMappingURL=index.mjs.map

package/dist/neutral/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/Events/Events.ts"],"sourcesContent":["import { assertEx } from '@xylabs/assert'\nimport type { BaseParams } from '@xylabs/base'\nimport { Base } from '@xylabs/base'\nimport { handleError } from '@xylabs/error'\nimport { forget } from '@xylabs/forget'\nimport { isDefined } from '@xylabs/typeof'\n\nimport type {\n  EventAnyListener, EventArgs, EventData, EventFunctions, EventListener, EventName,\n} from '../model/index.ts'\n\n/**\nEmittery can collect and log debug information.\n\nTo enable this feature set the `DEBUG` environment variable to `emittery` or `*`. Additionally, you can set the static `isDebugEnabled` variable to true\non the Emittery class, or `myEmitter.debug.enabled` on an instance of it for debugging a single instance.\n\nSee API for more information on how debugging works.\n*/\nexport type DebugLogger = (type: string, debugName: string, eventName?: EventName, eventData?: EventArgs) => void\n\nexport type EventListenerInfo<TEventArgs extends EventArgs = EventArgs> = {\n  filter?: TEventArgs\n  listener: EventListener<TEventArgs>\n}\n\nconst NO_META_EVENT_ERROR_MESSAGE = '`eventName` cannot be meta event `listenerAdded` or `listenerRemoved`'\n\n/**\nConfigure debug options of an instance.\n*/\nexport type DebugOptions = {\n  enabled?: boolean\n  logger?: DebugLogger\n  readonly name: string\n}\n\nconst resolvedPromise = Promise.resolve()\n\nexport type MetaEventData<TEventData extends EventData> = {\n  listenerAdded: {\n    eventName?: keyof TEventData\n    listener: EventListener<TEventData[keyof TEventData]> | EventAnyListener<TEventData[keyof TEventData]>\n  }\n  listenerRemoved: {\n    eventName?: keyof TEventData\n    listener: EventListener<TEventData[keyof TEventData]> | EventAnyListener<TEventData[keyof TEventData]>\n  }\n}\n\nconst isMetaEvent = (eventName: EventName) => eventName === 'listenerAdded' || eventName === 'listenerRemoved'\n\nexport type EventsParams = BaseParams<{ readonly debug?: DebugOptions }>\n\nexport class Events<TEventData extends EventData = EventData> extends Base<EventsParams> implements EventFunctions<TEventData> {\n  protected static anyMap = new WeakMap<object, Set<EventAnyListener>>()\n  protected static eventsMap = new WeakMap<object, Map<EventName, Set<EventListenerInfo>>>()\n\n  private static canEmitMetaEvents = false\n  private static isGlobalDebugEnabled = false\n\n  // this is here to be able to query the type, not use\n  eventData = {} as TEventData\n\n  constructor(params: EventsParams = {}) {\n    const mutatedParams = { ...params }\n    if (mutatedParams.debug) {\n      mutatedParams.debug.logger\n        = mutatedParams.debug.logger\n          ?? ((type: string, debugName: string, eventName?: EventName, eventData?: EventArgs) => {\n            let eventDataString: string\n            try {\n              eventDataString = JSON.stringify(eventData)\n            } catch {\n              eventDataString = `Object with the following keys failed to stringify: ${Object.keys(eventData ?? {}).join(',')}`\n            }\n\n            const eventNameString = typeof eventName === 'symbol' || typeof eventName === 'number' ? eventName.toString() : eventName\n\n            const currentTime = new Date()\n            const logTime = `${currentTime.getHours()}:${currentTime.getMinutes()}:${currentTime.getSeconds()}.${currentTime.getMilliseconds()}`\n            this.logger?.log(`[${logTime}][events:${type}][${debugName}] Event Name: ${eventNameString}\\n\\tdata: ${eventDataString}`)\n          })\n    }\n    super(mutatedParams)\n    Events.anyMap.set(this, new Set<EventAnyListener>())\n    Events.eventsMap.set(this, new Map<keyof TEventData, Set<EventListenerInfo>>())\n  }\n\n  static get isDebugEnabled() {\n    // In a browser environment, `globalThis.process` can potentially reference a DOM Element with a `#process` ID,\n    // so instead of just type checking `globalThis.process`, we need to make sure that `globalThis.process.env` exists.\n\n    if (typeof globalThis.process?.env !== 'object') {\n      return Events.isGlobalDebugEnabled\n    }\n\n    const { env } = globalThis.process ?? { env: {} }\n    return env.DEBUG === 'events' || env.DEBUG === '*' || Events.isGlobalDebugEnabled\n  }\n\n  static set isDebugEnabled(newValue) {\n    Events.isGlobalDebugEnabled = newValue\n  }\n\n  get debug() {\n    return this.params.debug\n  }\n\n  clearListeners(eventNames: keyof TEventData | (keyof TEventData)[]) {\n    const eventNamesArray = Array.isArray(eventNames) ? eventNames : [eventNames]\n\n    for (const eventName of eventNamesArray) {\n      this.logIfDebugEnabled('clear', eventName)\n\n      if (typeof eventName === 'string' || typeof eventName === 'symbol' || typeof eventName === 'number') {\n        const set = this.getListeners(eventName)\n        if (set) {\n          set.clear()\n        }\n      } else {\n        Events.anyMap.get(this)?.clear()\n\n        for (const [eventName, listeners] of assertEx(Events.eventsMap.get(this)).entries()) {\n          listeners.clear()\n          Events.eventsMap.get(this)?.delete(eventName)\n        }\n      }\n    }\n  }\n\n  async emit<TEventName extends keyof TEventData>(eventName: TEventName, eventArgs: TEventData[TEventName]) {\n    await this.emitInternal(eventName, eventArgs)\n  }\n\n  async emitMetaEvent<TEventName extends keyof MetaEventData<TEventData>>(eventName: TEventName, eventArgs: MetaEventData<TEventData>[TEventName]) {\n    if (isMetaEvent(eventName)) {\n      try {\n        Events.canEmitMetaEvents = true\n        await this.emitMetaEventInternal(eventName, eventArgs)\n      } finally {\n        Events.canEmitMetaEvents = false\n      }\n    }\n  }\n\n  async emitSerial<TEventName extends keyof TEventData>(eventName: TEventName, eventArgs: TEventData[TEventName]) {\n    if (isMetaEvent(eventName) && !Events.canEmitMetaEvents) {\n      throw new TypeError(NO_META_EVENT_ERROR_MESSAGE)\n    }\n\n    const filterMatch = (args: TEventData[TEventName], filter: TEventData[TEventName]) => {\n      switch (typeof filter) {\n        case 'object': {\n          // eslint-disable-next-line unicorn/no-array-reduce\n          return Object.entries(args).reduce((prev, [key, value]) => ((filter as Record<PropertyKey, unknown>)[key] === value ? true : prev), false)\n        }\n        default: {\n          return args === filter\n        }\n      }\n    }\n\n    this.logIfDebugEnabled('emitSerial', eventName, eventArgs)\n\n    const listeners = this.getListeners(eventName) ?? new Set()\n    const filteredListeners = [...listeners.values()]\n      .filter(value => (isDefined(value.filter) ? filterMatch(eventArgs, value.filter as TEventData[TEventName]) : true))\n      .map(info => info.listener)\n    const anyListeners = assertEx(Events.anyMap.get(this))\n    const staticListeners = [...filteredListeners]\n    const staticAnyListeners = [...anyListeners]\n\n    await resolvedPromise\n\n    for (const listener of staticListeners) {\n      await this.safeCallListener(eventName, eventArgs, listener)\n    }\n\n    for (const listener of staticAnyListeners) {\n      await this.safeCallAnyListener(eventName, eventArgs, listener)\n    }\n  }\n\n  // TODO: Make test for this\n  listenerCount(eventNames?: keyof TEventData | (keyof TEventData)[]) {\n    const eventNamesArray = Array.isArray(eventNames) ? eventNames : [eventNames]\n    let count = 0\n\n    for (const eventName of eventNamesArray) {\n      if (typeof eventName === 'string') {\n        count += assertEx(Events.anyMap.get(this)).size + (this.getListeners(eventName)?.size ?? 0)\n\n        continue\n      }\n\n      count += assertEx(Events.anyMap.get(this)).size\n\n      for (const value of assertEx(Events.eventsMap.get(this)).values()) {\n        count += value.size\n      }\n    }\n\n    return count\n  }\n\n  logIfDebugEnabled<TEventName extends EventName>(type: string, eventName?: TEventName, eventArgs?: EventArgs) {\n    if (Events.isDebugEnabled || this.debug?.enabled) {\n      this.debug?.logger?.(type, this.debug.name, eventName, eventArgs)\n    }\n  }\n\n  off<TEventName extends keyof TEventData, TEventListener = EventListener<TEventData[TEventName]>>(\n    eventNames: TEventName | TEventName[],\n    listener: TEventListener,\n  ) {\n    const eventNamesArray = Array.isArray(eventNames) ? eventNames : [eventNames]\n    for (const eventName of eventNamesArray) {\n      const set = this.getListeners(eventName) as Set<TEventListener> | undefined\n      if (set) {\n        set.delete(listener)\n        if (set.size === 0) {\n          const events = Events.eventsMap.get(this)\n          events?.delete(eventName)\n        }\n      }\n\n      this.logIfDebugEnabled('unsubscribe', eventName)\n\n      if (!isMetaEvent(eventName)) {\n        forget(this.emitMetaEvent('listenerRemoved', { eventName, listener: listener as EventListener }))\n      }\n    }\n  }\n\n  offAny(listener: EventAnyListener) {\n    this.logIfDebugEnabled('unsubscribeAny')\n\n    const typedMap = Events.anyMap.get(this) as Set<EventAnyListener<TEventData[keyof TEventData]>>\n    typedMap?.delete(listener)\n    forget(this.emitMetaEvent('listenerRemoved', { listener: listener as EventAnyListener }))\n  }\n\n  on<TEventName extends keyof TEventData = keyof TEventData>(\n    eventNames: TEventName | TEventName[],\n    listener: EventListener<TEventData[TEventName]>,\n    filter?: TEventData[TEventName],\n  ) {\n    const eventNamesArray = Array.isArray(eventNames) ? eventNames : [eventNames]\n    for (const eventName of eventNamesArray) {\n      let set = this.getListeners(eventName)\n      if (!set) {\n        set = new Set()\n        const events = Events.eventsMap.get(this)\n        events?.set(eventName, set)\n      }\n\n      set.add({ filter, listener: listener as EventListener })\n\n      this.logIfDebugEnabled('subscribe', eventName)\n\n      if (!isMetaEvent(eventName)) {\n        forget(this.emitMetaEvent('listenerAdded', { eventName, listener: listener as EventListener }))\n      }\n    }\n\n    return this.off.bind(this, eventNames, listener as EventListener)\n  }\n\n  onAny(listener: EventAnyListener) {\n    this.logIfDebugEnabled('subscribeAny')\n\n    Events.anyMap.get(this)?.add(listener as EventAnyListener)\n    forget(this.emitMetaEvent('listenerAdded', { listener: listener as EventAnyListener }))\n    return this.offAny.bind(this, listener as EventAnyListener)\n  }\n\n  once<TEventName extends keyof TEventData>(eventName: TEventName, listener: EventListener<TEventData[TEventName]>) {\n    const subListener = async (args: TEventData[TEventName]) => {\n      this.off(eventName, subListener)\n      await this.safeCallListener(eventName, args, listener)\n    }\n    this.on(eventName, subListener)\n    return this.off.bind(this, eventName, subListener as EventListener)\n  }\n\n  private async emitInternal<TEventName extends keyof TEventData, TEventArgs extends TEventData[TEventName]>(\n    eventName: TEventName,\n    eventArgs: TEventArgs,\n    filter?: TEventArgs,\n  ) {\n    if (isMetaEvent(eventName) && !Events.canEmitMetaEvents) {\n      throw new TypeError(NO_META_EVENT_ERROR_MESSAGE)\n    }\n\n    this.logIfDebugEnabled('emit', eventName, eventArgs)\n\n    const listeners = this.getListeners(eventName) ?? new Set()\n    const filteredListeners = [...listeners.values()].filter(value => (isDefined(filter) ? isDefined(value.listener) : true)).map(info => info.listener)\n    const anyListeners = assertEx(Events.anyMap.get(this))\n    const staticListeners = [...filteredListeners]\n    const staticAnyListeners = isMetaEvent(eventName) ? [] : [...anyListeners]\n\n    await resolvedPromise\n    await Promise.all([\n      ...staticListeners.map(async (listener) => {\n        await this.safeCallListener(eventName, eventArgs, listener)\n      }),\n      ...staticAnyListeners.map(async (listener) => {\n        if (anyListeners.has(listener)) {\n          await this.safeCallAnyListener(eventName, eventArgs, listener)\n        }\n      }),\n    ])\n  }\n\n  private async emitMetaEventInternal<TEventName extends keyof MetaEventData<TEventData>>(\n    eventName: TEventName,\n    eventArgs: MetaEventData<TEventData>[TEventName],\n  ) {\n    if (isMetaEvent(eventName) && !Events.canEmitMetaEvents) {\n      throw new TypeError('`eventName` cannot be meta event `listenerAdded` or `listenerRemoved`')\n    }\n\n    this.logIfDebugEnabled('emit', eventName, eventArgs)\n\n    const listeners = this.getListeners(eventName) ?? new Set()\n    const filteredListeners = [...listeners.values()].map(info => info.listener)\n    const anyListeners = assertEx(Events.anyMap.get(this))\n    const staticListeners = [...filteredListeners]\n    const staticAnyListeners = isMetaEvent(eventName) ? [] : [...anyListeners]\n\n    await resolvedPromise\n    await Promise.all([\n      ...staticListeners.map(async (listener) => {\n        await this.safeCallListener(eventName, eventArgs, listener)\n      }),\n      ...staticAnyListeners.map(async (listener) => {\n        if (anyListeners.has(listener)) {\n          await this.safeCallAnyListener(eventName, eventArgs, listener)\n        }\n      }),\n    ])\n  }\n\n  private getListeners<TEventName extends keyof TEventData>(eventName: TEventName) {\n    const events = assertEx(Events.eventsMap.get(this))\n    if (!events.has(eventName)) {\n      return\n    }\n\n    return events.get(eventName)\n  }\n\n  private async safeCallAnyListener<TEventData extends EventData, TEventName extends keyof EventData>(\n    eventName: TEventName,\n    eventArgs: TEventData[TEventName],\n    listener: EventAnyListener<TEventData[TEventName]>,\n  ) {\n    try {\n      return await listener(eventName, eventArgs)\n    } catch (ex) {\n      handleError(ex, (error) => {\n        this.logger?.error(`Listener[${String(eventName)}] Excepted: ${error.message}`)\n      })\n    }\n  }\n\n  private async safeCallListener<TEventData extends EventData, TEventName extends keyof EventData>(\n    eventName: TEventName,\n    eventArgs: TEventData[TEventName],\n    listener: EventListener<TEventData[TEventName]>,\n  ) {\n    try {\n      return await listener(eventArgs)\n    } catch (ex) {\n      handleError(ex, (error) => {\n        this.logger?.error(`Listener[${String(eventName)}] Excepted: ${error.message}`)\n      })\n    }\n  }\n}\n"],"mappings":"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","names":["eventName"]}

package/dist/types/Events/Events.d.ts

@@ -0,0 +1,65 @@
+import type { BaseParams } from '@xylabs/base';
+import { Base } from '@xylabs/base';
+import type { EventAnyListener, EventArgs, EventData, EventFunctions, EventListener, EventName } from '../model/index.ts';
+/**
+Emittery can collect and log debug information.
+
+To enable this feature set the `DEBUG` environment variable to `emittery` or `*`. Additionally, you can set the static `isDebugEnabled` variable to true
+on the Emittery class, or `myEmitter.debug.enabled` on an instance of it for debugging a single instance.
+
+See API for more information on how debugging works.
+*/
+export type DebugLogger = (type: string, debugName: string, eventName?: EventName, eventData?: EventArgs) => void;
+export type EventListenerInfo<TEventArgs extends EventArgs = EventArgs> = {
+    filter?: TEventArgs;
+    listener: EventListener<TEventArgs>;
+};
+/**
+Configure debug options of an instance.
+*/
+export type DebugOptions = {
+    enabled?: boolean;
+    logger?: DebugLogger;
+    readonly name: string;
+};
+export type MetaEventData<TEventData extends EventData> = {
+    listenerAdded: {
+        eventName?: keyof TEventData;
+        listener: EventListener<TEventData[keyof TEventData]> | EventAnyListener<TEventData[keyof TEventData]>;
+    };
+    listenerRemoved: {
+        eventName?: keyof TEventData;
+        listener: EventListener<TEventData[keyof TEventData]> | EventAnyListener<TEventData[keyof TEventData]>;
+    };
+};
+export type EventsParams = BaseParams<{
+    readonly debug?: DebugOptions;
+}>;
+export declare class Events<TEventData extends EventData = EventData> extends Base<EventsParams> implements EventFunctions<TEventData> {
+    protected static anyMap: WeakMap<object, Set<EventAnyListener>>;
+    protected static eventsMap: WeakMap<object, Map<PropertyKey, Set<EventListenerInfo<EventArgs>>>>;
+    private static canEmitMetaEvents;
+    private static isGlobalDebugEnabled;
+    eventData: TEventData;
+    constructor(params?: EventsParams);
+    static get isDebugEnabled(): boolean;
+    static set isDebugEnabled(newValue: boolean);
+    get debug(): DebugOptions | undefined;
+    clearListeners(eventNames: keyof TEventData | (keyof TEventData)[]): void;
+    emit<TEventName extends keyof TEventData>(eventName: TEventName, eventArgs: TEventData[TEventName]): Promise<void>;
+    emitMetaEvent<TEventName extends keyof MetaEventData<TEventData>>(eventName: TEventName, eventArgs: MetaEventData<TEventData>[TEventName]): Promise<void>;
+    emitSerial<TEventName extends keyof TEventData>(eventName: TEventName, eventArgs: TEventData[TEventName]): Promise<void>;
+    listenerCount(eventNames?: keyof TEventData | (keyof TEventData)[]): number;
+    logIfDebugEnabled<TEventName extends EventName>(type: string, eventName?: TEventName, eventArgs?: EventArgs): void;
+    off<TEventName extends keyof TEventData, TEventListener = EventListener<TEventData[TEventName]>>(eventNames: TEventName | TEventName[], listener: TEventListener): void;
+    offAny(listener: EventAnyListener): void;
+    on<TEventName extends keyof TEventData = keyof TEventData>(eventNames: TEventName | TEventName[], listener: EventListener<TEventData[TEventName]>, filter?: TEventData[TEventName]): () => void;
+    onAny(listener: EventAnyListener): () => void;
+    once<TEventName extends keyof TEventData>(eventName: TEventName, listener: EventListener<TEventData[TEventName]>): () => void;
+    private emitInternal;
+    private emitMetaEventInternal;
+    private getListeners;
+    private safeCallAnyListener;
+    private safeCallListener;
+}
+//# sourceMappingURL=Events.d.ts.map

package/dist/types/Events/Events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Events.d.ts","sourceRoot":"","sources":["../../../src/Events/Events.ts"],"names":[],"mappings":"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"}

package/dist/types/Events/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Events.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/Events/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/Events/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA"}

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Events/index.ts';
+export * from './model/index.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,kBAAkB,CAAA"}

package/dist/types/model/Event.d.ts

@@ -0,0 +1,22 @@
+import type { Promisable } from '@xylabs/promise';
+export type EventName = PropertyKey;
+export type EventArgs = string | number | object;
+export type EventData = {
+    [key: EventName]: EventArgs;
+};
+export type EventUnsubscribeFunction = () => void;
+export type EventAnyListener<TEventArgs extends EventArgs = EventArgs> = (eventName: EventName, eventData: TEventArgs) => Promisable<void>;
+export type EventListener<TEventArgs extends EventArgs = EventArgs> = (eventData: TEventArgs) => Promisable<void>;
+export interface EventFunctions<TEventData extends EventData> {
+    eventData: TEventData;
+    clearListeners(eventNames: keyof TEventData | (keyof TEventData)[]): void;
+    emit<TEventName extends keyof TEventData>(eventName: TEventName, eventArgs: TEventData[TEventName]): Promise<void>;
+    emitSerial<TEventName extends keyof TEventData>(eventName: TEventName, eventArgs: TEventData[TEventName]): Promise<void>;
+    listenerCount(eventNames: keyof TEventData | (keyof TEventData)[]): number;
+    off<TEventName extends keyof TEventData>(eventNames: TEventName | TEventName[], listener: EventListener<TEventData[TEventName]>): void;
+    offAny(listener: EventAnyListener | Promise<void>): void;
+    on<TEventName extends keyof TEventData>(eventNames: TEventName | TEventName[], listener: EventListener<TEventData[TEventName]>): EventUnsubscribeFunction;
+    onAny(listener: EventAnyListener): EventUnsubscribeFunction;
+    once<TEventName extends keyof TEventData>(eventName: TEventName, listener: EventListener<TEventData[TEventName]>): EventUnsubscribeFunction;
+}
+//# sourceMappingURL=Event.d.ts.map

package/dist/types/model/Event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Event.d.ts","sourceRoot":"","sources":["../../../src/model/Event.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD,MAAM,MAAM,SAAS,GAAG,WAAW,CAAA;AACnC,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAA;AAChD,MAAM,MAAM,SAAS,GAAG;IAAE,CAAC,GAAG,EAAE,SAAS,GAAG,SAAS,CAAA;CAAE,CAAA;AACvD,MAAM,MAAM,wBAAwB,GAAG,MAAM,IAAI,CAAA;AACjD,MAAM,MAAM,gBAAgB,CAAC,UAAU,SAAS,SAAS,GAAG,SAAS,IAAI,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,UAAU,KAAK,UAAU,CAAC,IAAI,CAAC,CAAA;AAC1I,MAAM,MAAM,aAAa,CAAC,UAAU,SAAS,SAAS,GAAG,SAAS,IAAI,CAAC,SAAS,EAAE,UAAU,KAAK,UAAU,CAAC,IAAI,CAAC,CAAA;AAEjH,MAAM,WAAW,cAAc,CAAC,UAAU,SAAS,SAAS;IAC1D,SAAS,EAAE,UAAU,CAAA;IACrB,cAAc,CAAC,UAAU,EAAE,MAAM,UAAU,GAAG,CAAC,MAAM,UAAU,CAAC,EAAE,GAAG,IAAI,CAAA;IACzE,IAAI,CAAC,UAAU,SAAS,MAAM,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAClH,UAAU,CAAC,UAAU,SAAS,MAAM,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACxH,aAAa,CAAC,UAAU,EAAE,MAAM,UAAU,GAAG,CAAC,MAAM,UAAU,CAAC,EAAE,GAAG,MAAM,CAAA;IAC1E,GAAG,CAAC,UAAU,SAAS,MAAM,UAAU,EAAE,UAAU,EAAE,UAAU,GAAG,UAAU,EAAE,EAAE,QAAQ,EAAE,aAAa,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,GAAG,IAAI,CAAA;IACtI,MAAM,CAAC,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IACxD,EAAE,CAAC,UAAU,SAAS,MAAM,UAAU,EACpC,UAAU,EAAE,UAAU,GAAG,UAAU,EAAE,EACrC,QAAQ,EAAE,aAAa,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,GAC9C,wBAAwB,CAAA;IAC3B,KAAK,CAAC,QAAQ,EAAE,gBAAgB,GAAG,wBAAwB,CAAA;IAC3D,IAAI,CAAC,UAAU,SAAS,MAAM,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,QAAQ,EAAE,aAAa,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,GAAG,wBAAwB,CAAA;CAC5I"}

package/dist/types/model/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Event.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/model/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/model/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA"}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@xylabs/events",
+  "version": "4.9.17",
+  "description": "Primary SDK for using XYO Protocol 2.0",
+  "homepage": "https://xyo.network",
+  "bugs": {
+    "url": "git+https://github.com/XYOracleNetwork/sdk-xyo-client-js/issues",
+    "email": "support@xyo.network"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/XYOracleNetwork/sdk-xyo-client-js.git"
+  },
+  "license": "LGPL-3.0-only",
+  "author": {
+    "name": "XYO Development Team",
+    "email": "support@xyo.network",
+    "url": "https://xyo.network"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "default": "./dist/neutral/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "module": "dist/neutral/index.mjs",
+  "types": "dist/types/index.d.ts",
+  "dependencies": {
+    "@xylabs/assert": "^4.9.17",
+    "@xylabs/base": "^4.9.17",
+    "@xylabs/error": "^4.9.17",
+    "@xylabs/forget": "^4.9.17",
+    "@xylabs/promise": "^4.9.17",
+    "@xylabs/typeof": "^4.9.17"
+  },
+  "devDependencies": {
+    "@xylabs/delay": "^4.9.17",
+    "@xylabs/ts-scripts-yarn3": "^6.5.5",
+    "@xylabs/tsconfig": "^6.5.5",
+    "@xylabs/vitest-extended": "^4.9.17",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/Events/Events.ts

@@ -0,0 +1,382 @@
+import { assertEx } from '@xylabs/assert'
+import type { BaseParams } from '@xylabs/base'
+import { Base } from '@xylabs/base'
+import { handleError } from '@xylabs/error'
+import { forget } from '@xylabs/forget'
+import { isDefined } from '@xylabs/typeof'
+
+import type {
+  EventAnyListener, EventArgs, EventData, EventFunctions, EventListener, EventName,
+} from '../model/index.ts'
+
+/**
+Emittery can collect and log debug information.
+
+To enable this feature set the `DEBUG` environment variable to `emittery` or `*`. Additionally, you can set the static `isDebugEnabled` variable to true
+on the Emittery class, or `myEmitter.debug.enabled` on an instance of it for debugging a single instance.
+
+See API for more information on how debugging works.
+*/
+export type DebugLogger = (type: string, debugName: string, eventName?: EventName, eventData?: EventArgs) => void
+
+export type EventListenerInfo<TEventArgs extends EventArgs = EventArgs> = {
+  filter?: TEventArgs
+  listener: EventListener<TEventArgs>
+}
+
+const NO_META_EVENT_ERROR_MESSAGE = '`eventName` cannot be meta event `listenerAdded` or `listenerRemoved`'
+
+/**
+Configure debug options of an instance.
+*/
+export type DebugOptions = {
+  enabled?: boolean
+  logger?: DebugLogger
+  readonly name: string
+}
+
+const resolvedPromise = Promise.resolve()
+
+export type MetaEventData<TEventData extends EventData> = {
+  listenerAdded: {
+    eventName?: keyof TEventData
+    listener: EventListener<TEventData[keyof TEventData]> | EventAnyListener<TEventData[keyof TEventData]>
+  }
+  listenerRemoved: {
+    eventName?: keyof TEventData
+    listener: EventListener<TEventData[keyof TEventData]> | EventAnyListener<TEventData[keyof TEventData]>
+  }
+}
+
+const isMetaEvent = (eventName: EventName) => eventName === 'listenerAdded' || eventName === 'listenerRemoved'
+
+export type EventsParams = BaseParams<{ readonly debug?: DebugOptions }>
+
+export class Events<TEventData extends EventData = EventData> extends Base<EventsParams> implements EventFunctions<TEventData> {
+  protected static anyMap = new WeakMap<object, Set<EventAnyListener>>()
+  protected static eventsMap = new WeakMap<object, Map<EventName, Set<EventListenerInfo>>>()
+
+  private static canEmitMetaEvents = false
+  private static isGlobalDebugEnabled = false
+
+  // this is here to be able to query the type, not use
+  eventData = {} as TEventData
+
+  constructor(params: EventsParams = {}) {
+    const mutatedParams = { ...params }
+    if (mutatedParams.debug) {
+      mutatedParams.debug.logger
+        = mutatedParams.debug.logger
+          ?? ((type: string, debugName: string, eventName?: EventName, eventData?: EventArgs) => {
+            let eventDataString: string
+            try {
+              eventDataString = JSON.stringify(eventData)
+            } catch {
+              eventDataString = `Object with the following keys failed to stringify: ${Object.keys(eventData ?? {}).join(',')}`
+            }
+
+            const eventNameString = typeof eventName === 'symbol' || typeof eventName === 'number' ? eventName.toString() : eventName
+
+            const currentTime = new Date()
+            const logTime = `${currentTime.getHours()}:${currentTime.getMinutes()}:${currentTime.getSeconds()}.${currentTime.getMilliseconds()}`
+            this.logger?.log(`[${logTime}][events:${type}][${debugName}] Event Name: ${eventNameString}\n\tdata: ${eventDataString}`)
+          })
+    }
+    super(mutatedParams)
+    Events.anyMap.set(this, new Set<EventAnyListener>())
+    Events.eventsMap.set(this, new Map<keyof TEventData, Set<EventListenerInfo>>())
+  }
+
+  static get isDebugEnabled() {
+    // In a browser environment, `globalThis.process` can potentially reference a DOM Element with a `#process` ID,
+    // so instead of just type checking `globalThis.process`, we need to make sure that `globalThis.process.env` exists.
+
+    if (typeof globalThis.process?.env !== 'object') {
+      return Events.isGlobalDebugEnabled
+    }
+
+    const { env } = globalThis.process ?? { env: {} }
+    return env.DEBUG === 'events' || env.DEBUG === '*' || Events.isGlobalDebugEnabled
+  }
+
+  static set isDebugEnabled(newValue) {
+    Events.isGlobalDebugEnabled = newValue
+  }
+
+  get debug() {
+    return this.params.debug
+  }
+
+  clearListeners(eventNames: keyof TEventData | (keyof TEventData)[]) {
+    const eventNamesArray = Array.isArray(eventNames) ? eventNames : [eventNames]
+
+    for (const eventName of eventNamesArray) {
+      this.logIfDebugEnabled('clear', eventName)
+
+      if (typeof eventName === 'string' || typeof eventName === 'symbol' || typeof eventName === 'number') {
+        const set = this.getListeners(eventName)
+        if (set) {
+          set.clear()
+        }
+      } else {
+        Events.anyMap.get(this)?.clear()
+
+        for (const [eventName, listeners] of assertEx(Events.eventsMap.get(this)).entries()) {
+          listeners.clear()
+          Events.eventsMap.get(this)?.delete(eventName)
+        }
+      }
+    }
+  }
+
+  async emit<TEventName extends keyof TEventData>(eventName: TEventName, eventArgs: TEventData[TEventName]) {
+    await this.emitInternal(eventName, eventArgs)
+  }
+
+  async emitMetaEvent<TEventName extends keyof MetaEventData<TEventData>>(eventName: TEventName, eventArgs: MetaEventData<TEventData>[TEventName]) {
+    if (isMetaEvent(eventName)) {
+      try {
+        Events.canEmitMetaEvents = true
+        await this.emitMetaEventInternal(eventName, eventArgs)
+      } finally {
+        Events.canEmitMetaEvents = false
+      }
+    }
+  }
+
+  async emitSerial<TEventName extends keyof TEventData>(eventName: TEventName, eventArgs: TEventData[TEventName]) {
+    if (isMetaEvent(eventName) && !Events.canEmitMetaEvents) {
+      throw new TypeError(NO_META_EVENT_ERROR_MESSAGE)
+    }
+
+    const filterMatch = (args: TEventData[TEventName], filter: TEventData[TEventName]) => {
+      switch (typeof filter) {
+        case 'object': {
+          // eslint-disable-next-line unicorn/no-array-reduce
+          return Object.entries(args).reduce((prev, [key, value]) => ((filter as Record<PropertyKey, unknown>)[key] === value ? true : prev), false)
+        }
+        default: {
+          return args === filter
+        }
+      }
+    }
+
+    this.logIfDebugEnabled('emitSerial', eventName, eventArgs)
+
+    const listeners = this.getListeners(eventName) ?? new Set()
+    const filteredListeners = [...listeners.values()]
+      .filter(value => (isDefined(value.filter) ? filterMatch(eventArgs, value.filter as TEventData[TEventName]) : true))
+      .map(info => info.listener)
+    const anyListeners = assertEx(Events.anyMap.get(this))
+    const staticListeners = [...filteredListeners]
+    const staticAnyListeners = [...anyListeners]
+
+    await resolvedPromise
+
+    for (const listener of staticListeners) {
+      await this.safeCallListener(eventName, eventArgs, listener)
+    }
+
+    for (const listener of staticAnyListeners) {
+      await this.safeCallAnyListener(eventName, eventArgs, listener)
+    }
+  }
+
+  // TODO: Make test for this
+  listenerCount(eventNames?: keyof TEventData | (keyof TEventData)[]) {
+    const eventNamesArray = Array.isArray(eventNames) ? eventNames : [eventNames]
+    let count = 0
+
+    for (const eventName of eventNamesArray) {
+      if (typeof eventName === 'string') {
+        count += assertEx(Events.anyMap.get(this)).size + (this.getListeners(eventName)?.size ?? 0)
+
+        continue
+      }
+
+      count += assertEx(Events.anyMap.get(this)).size
+
+      for (const value of assertEx(Events.eventsMap.get(this)).values()) {
+        count += value.size
+      }
+    }
+
+    return count
+  }
+
+  logIfDebugEnabled<TEventName extends EventName>(type: string, eventName?: TEventName, eventArgs?: EventArgs) {
+    if (Events.isDebugEnabled || this.debug?.enabled) {
+      this.debug?.logger?.(type, this.debug.name, eventName, eventArgs)
+    }
+  }
+
+  off<TEventName extends keyof TEventData, TEventListener = EventListener<TEventData[TEventName]>>(
+    eventNames: TEventName | TEventName[],
+    listener: TEventListener,
+  ) {
+    const eventNamesArray = Array.isArray(eventNames) ? eventNames : [eventNames]
+    for (const eventName of eventNamesArray) {
+      const set = this.getListeners(eventName) as Set<TEventListener> | undefined
+      if (set) {
+        set.delete(listener)
+        if (set.size === 0) {
+          const events = Events.eventsMap.get(this)
+          events?.delete(eventName)
+        }
+      }
+
+      this.logIfDebugEnabled('unsubscribe', eventName)
+
+      if (!isMetaEvent(eventName)) {
+        forget(this.emitMetaEvent('listenerRemoved', { eventName, listener: listener as EventListener }))
+      }
+    }
+  }
+
+  offAny(listener: EventAnyListener) {
+    this.logIfDebugEnabled('unsubscribeAny')
+
+    const typedMap = Events.anyMap.get(this) as Set<EventAnyListener<TEventData[keyof TEventData]>>
+    typedMap?.delete(listener)
+    forget(this.emitMetaEvent('listenerRemoved', { listener: listener as EventAnyListener }))
+  }
+
+  on<TEventName extends keyof TEventData = keyof TEventData>(
+    eventNames: TEventName | TEventName[],
+    listener: EventListener<TEventData[TEventName]>,
+    filter?: TEventData[TEventName],
+  ) {
+    const eventNamesArray = Array.isArray(eventNames) ? eventNames : [eventNames]
+    for (const eventName of eventNamesArray) {
+      let set = this.getListeners(eventName)
+      if (!set) {
+        set = new Set()
+        const events = Events.eventsMap.get(this)
+        events?.set(eventName, set)
+      }
+
+      set.add({ filter, listener: listener as EventListener })
+
+      this.logIfDebugEnabled('subscribe', eventName)
+
+      if (!isMetaEvent(eventName)) {
+        forget(this.emitMetaEvent('listenerAdded', { eventName, listener: listener as EventListener }))
+      }
+    }
+
+    return this.off.bind(this, eventNames, listener as EventListener)
+  }
+
+  onAny(listener: EventAnyListener) {
+    this.logIfDebugEnabled('subscribeAny')
+
+    Events.anyMap.get(this)?.add(listener as EventAnyListener)
+    forget(this.emitMetaEvent('listenerAdded', { listener: listener as EventAnyListener }))
+    return this.offAny.bind(this, listener as EventAnyListener)
+  }
+
+  once<TEventName extends keyof TEventData>(eventName: TEventName, listener: EventListener<TEventData[TEventName]>) {
+    const subListener = async (args: TEventData[TEventName]) => {
+      this.off(eventName, subListener)
+      await this.safeCallListener(eventName, args, listener)
+    }
+    this.on(eventName, subListener)
+    return this.off.bind(this, eventName, subListener as EventListener)
+  }
+
+  private async emitInternal<TEventName extends keyof TEventData, TEventArgs extends TEventData[TEventName]>(
+    eventName: TEventName,
+    eventArgs: TEventArgs,
+    filter?: TEventArgs,
+  ) {
+    if (isMetaEvent(eventName) && !Events.canEmitMetaEvents) {
+      throw new TypeError(NO_META_EVENT_ERROR_MESSAGE)
+    }
+
+    this.logIfDebugEnabled('emit', eventName, eventArgs)
+
+    const listeners = this.getListeners(eventName) ?? new Set()
+    const filteredListeners = [...listeners.values()].filter(value => (isDefined(filter) ? isDefined(value.listener) : true)).map(info => info.listener)
+    const anyListeners = assertEx(Events.anyMap.get(this))
+    const staticListeners = [...filteredListeners]
+    const staticAnyListeners = isMetaEvent(eventName) ? [] : [...anyListeners]
+
+    await resolvedPromise
+    await Promise.all([
+      ...staticListeners.map(async (listener) => {
+        await this.safeCallListener(eventName, eventArgs, listener)
+      }),
+      ...staticAnyListeners.map(async (listener) => {
+        if (anyListeners.has(listener)) {
+          await this.safeCallAnyListener(eventName, eventArgs, listener)
+        }
+      }),
+    ])
+  }
+
+  private async emitMetaEventInternal<TEventName extends keyof MetaEventData<TEventData>>(
+    eventName: TEventName,
+    eventArgs: MetaEventData<TEventData>[TEventName],
+  ) {
+    if (isMetaEvent(eventName) && !Events.canEmitMetaEvents) {
+      throw new TypeError('`eventName` cannot be meta event `listenerAdded` or `listenerRemoved`')
+    }
+
+    this.logIfDebugEnabled('emit', eventName, eventArgs)
+
+    const listeners = this.getListeners(eventName) ?? new Set()
+    const filteredListeners = [...listeners.values()].map(info => info.listener)
+    const anyListeners = assertEx(Events.anyMap.get(this))
+    const staticListeners = [...filteredListeners]
+    const staticAnyListeners = isMetaEvent(eventName) ? [] : [...anyListeners]
+
+    await resolvedPromise
+    await Promise.all([
+      ...staticListeners.map(async (listener) => {
+        await this.safeCallListener(eventName, eventArgs, listener)
+      }),
+      ...staticAnyListeners.map(async (listener) => {
+        if (anyListeners.has(listener)) {
+          await this.safeCallAnyListener(eventName, eventArgs, listener)
+        }
+      }),
+    ])
+  }
+
+  private getListeners<TEventName extends keyof TEventData>(eventName: TEventName) {
+    const events = assertEx(Events.eventsMap.get(this))
+    if (!events.has(eventName)) {
+      return
+    }
+
+    return events.get(eventName)
+  }
+
+  private async safeCallAnyListener<TEventData extends EventData, TEventName extends keyof EventData>(
+    eventName: TEventName,
+    eventArgs: TEventData[TEventName],
+    listener: EventAnyListener<TEventData[TEventName]>,
+  ) {
+    try {
+      return await listener(eventName, eventArgs)
+    } catch (ex) {
+      handleError(ex, (error) => {
+        this.logger?.error(`Listener[${String(eventName)}] Excepted: ${error.message}`)
+      })
+    }
+  }
+
+  private async safeCallListener<TEventData extends EventData, TEventName extends keyof EventData>(
+    eventName: TEventName,
+    eventArgs: TEventData[TEventName],
+    listener: EventListener<TEventData[TEventName]>,
+  ) {
+    try {
+      return await listener(eventArgs)
+    } catch (ex) {
+      handleError(ex, (error) => {
+        this.logger?.error(`Listener[${String(eventName)}] Excepted: ${error.message}`)
+      })
+    }
+  }
+}

package/src/Events/index.ts

@@ -0,0 +1 @@
+export * from './Events.ts'

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './Events/index.ts'
+export * from './model/index.ts'

package/src/model/Event.ts

@@ -0,0 +1,24 @@
+import type { Promisable } from '@xylabs/promise'
+
+export type EventName = PropertyKey
+export type EventArgs = string | number | object
+export type EventData = { [key: EventName]: EventArgs }
+export type EventUnsubscribeFunction = () => void
+export type EventAnyListener<TEventArgs extends EventArgs = EventArgs> = (eventName: EventName, eventData: TEventArgs) => Promisable<void>
+export type EventListener<TEventArgs extends EventArgs = EventArgs> = (eventData: TEventArgs) => Promisable<void>
+
+export interface EventFunctions<TEventData extends EventData> {
+  eventData: TEventData
+  clearListeners(eventNames: keyof TEventData | (keyof TEventData)[]): void
+  emit<TEventName extends keyof TEventData>(eventName: TEventName, eventArgs: TEventData[TEventName]): Promise<void>
+  emitSerial<TEventName extends keyof TEventData>(eventName: TEventName, eventArgs: TEventData[TEventName]): Promise<void>
+  listenerCount(eventNames: keyof TEventData | (keyof TEventData)[]): number
+  off<TEventName extends keyof TEventData>(eventNames: TEventName | TEventName[], listener: EventListener<TEventData[TEventName]>): void
+  offAny(listener: EventAnyListener | Promise<void>): void
+  on<TEventName extends keyof TEventData>(
+    eventNames: TEventName | TEventName[],
+    listener: EventListener<TEventData[TEventName]>,
+  ): EventUnsubscribeFunction
+  onAny(listener: EventAnyListener): EventUnsubscribeFunction
+  once<TEventName extends keyof TEventData>(eventName: TEventName, listener: EventListener<TEventData[TEventName]>): EventUnsubscribeFunction
+}

package/src/model/index.ts

@@ -0,0 +1 @@
+export * from './Event.ts'

package/xy.config.ts

@@ -0,0 +1,10 @@
+import type { XyTsupConfig } from '@xylabs/ts-scripts-yarn3'
+const config: XyTsupConfig = {
+  compile: {
+    browser: {},
+    neutral: { src: true },
+    node: {},
+  },
+}
+
+export default config