hookified 1.8.0 → 1.8.1

package/README.md

@@ -16,7 +16,8 @@
 - Browser Support and Delivered via CDN
 - Ability to throw errors in hooks
 - Ability to pass in a logger (such as Pino) for errors
-- No package dependencies
+- No package dependencies and only 100KB in size
+- Fast and Efficient with [Benchmarks](#benchmarks)
 - Maintained on a regular basis!
 
 # Table of Contents
@@ -48,6 +49,7 @@
   - [.listenerCount(eventName?)](#listenercounteventname)
   - [.rawListeners(eventName?)](#rawlistenerseventname)
 - [Development and Testing](#development-and-testing)
+- [Benchmarks](#benchmarks)
 - [License](#license)
 
 # Installation
@@ -809,6 +811,29 @@ npm i && npm test
 
 To contribute follow the [Contributing Guidelines](CONTRIBUTING.md) and [Code of Conduct](CODE_OF_CONDUCT.md).
 
+# Benchmarks
+
+We are doing very simple benchmarking to see how this compares to other libraries using `tinybench`. This is not a full benchmark but just a simple way to see how it performs. Our goal is to be as close or better than the other libraries including native (EventEmitter).
+
+## Hooks
+|       name        |  summary  |  ops/sec  |  time/op  |  margin  |  samples  |
+|-------------------|:---------:|----------:|----------:|:--------:|----------:|
+|  Hookified 1.8.0  |    🥇     |       4M  |    306ns  |  ±2.46%  |       3M  |
+|  Hookable ^5.5.3  |   -71%    |       1M  |      1µs  |  ±2.93%  |     826K  |
+
+## Emits
+
+This shows how close the native `EventEmitter` is to `hookified` and `eventemitter3`. We are using the same test as above but just emitting events. It is not a fair comparison but it is interesting to see how close they are.
+
+|          name           |  summary  |  ops/sec  |  time/op  |  margin  |  samples  |
+|-------------------------|:---------:|----------:|----------:|:--------:|----------:|
+|  Hookified 1.8.0        |    🥇     |      10M  |    112ns  |  ±1.13%  |       9M  |
+|  EventEmitter3 5.0.1    |   -1.3%   |      10M  |    114ns  |  ±1.84%  |       9M  |
+|  EventEmitter v22.12.0  |   -1.5%   |       9M  |    114ns  |  ±1.18%  |       9M  |
+|  Emittery 1.1.0         |   -92%    |     785K  |      1µs  |  ±0.45%  |     761K  |
+
+_Note: the `EventEmitter` version is Nodejs versioning._
+
 # License
 
 [MIT & © Jared Wray](LICENSE)

package/dist/node/index.cjs

@@ -1,393 +1 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  Eventified: () => Eventified,
-  Hookified: () => Hookified
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/eventified.ts
-var Eventified = class {
-  _eventListeners;
-  _maxListeners;
-  _logger;
-  constructor(options) {
-    this._eventListeners = /* @__PURE__ */ new Map();
-    this._maxListeners = 100;
-    this._logger = options?.logger;
-  }
-  /**
-   * Adds a handler function for a specific event that will run only once
-   * @param {string | symbol} eventName
-   * @param {EventListener} listener
-   * @returns {IEventEmitter} returns the instance of the class for chaining
-   */
-  once(eventName, listener) {
-    const onceListener = (...arguments_) => {
-      this.off(eventName, onceListener);
-      listener(...arguments_);
-    };
-    this.on(eventName, onceListener);
-    return this;
-  }
-  /**
-   * Gets the number of listeners for a specific event. If no event is provided, it returns the total number of listeners
-   * @param {string} eventName The event name. Not required
-   * @returns {number} The number of listeners
-   */
-  listenerCount(eventName) {
-    if (!eventName) {
-      return this.getAllListeners().length;
-    }
-    const listeners = this._eventListeners.get(eventName);
-    return listeners ? listeners.length : 0;
-  }
-  /**
-   * Gets an array of event names
-   * @returns {Array<string | symbol>} An array of event names
-   */
-  eventNames() {
-    return Array.from(this._eventListeners.keys());
-  }
-  /**
-   * Gets an array of listeners for a specific event. If no event is provided, it returns all listeners
-   * @param {string} [event] (Optional) The event name
-   * @returns {EventListener[]} An array of listeners
-   */
-  rawListeners(event) {
-    if (!event) {
-      return this.getAllListeners();
-    }
-    return this._eventListeners.get(event) ?? [];
-  }
-  /**
-   * Prepends a listener to the beginning of the listeners array for the specified event
-   * @param {string | symbol} eventName
-   * @param {EventListener} listener
-   * @returns {IEventEmitter} returns the instance of the class for chaining
-   */
-  prependListener(eventName, listener) {
-    const listeners = this._eventListeners.get(eventName) ?? [];
-    listeners.unshift(listener);
-    this._eventListeners.set(eventName, listeners);
-    return this;
-  }
-  /**
-   * Prepends a one-time listener to the beginning of the listeners array for the specified event
-   * @param {string | symbol} eventName
-   * @param {EventListener} listener
-   * @returns {IEventEmitter} returns the instance of the class for chaining
-   */
-  prependOnceListener(eventName, listener) {
-    const onceListener = (...arguments_) => {
-      this.off(eventName, onceListener);
-      listener(...arguments_);
-    };
-    this.prependListener(eventName, onceListener);
-    return this;
-  }
-  /**
-   * Gets the maximum number of listeners that can be added for a single event
-   * @returns {number} The maximum number of listeners
-   */
-  maxListeners() {
-    return this._maxListeners;
-  }
-  /**
-   * Adds a listener for a specific event. It is an alias for the on() method
-   * @param {string | symbol} event
-   * @param {EventListener} listener
-   * @returns {IEventEmitter} returns the instance of the class for chaining
-   */
-  addListener(event, listener) {
-    this.on(event, listener);
-    return this;
-  }
-  /**
-   * Adds a listener for a specific event
-   * @param {string | symbol} event
-   * @param {EventListener} listener
-   * @returns {IEventEmitter} returns the instance of the class for chaining
-   */
-  on(event, listener) {
-    if (!this._eventListeners.has(event)) {
-      this._eventListeners.set(event, []);
-    }
-    const listeners = this._eventListeners.get(event);
-    if (listeners) {
-      if (listeners.length >= this._maxListeners) {
-        console.warn(`MaxListenersExceededWarning: Possible event memory leak detected. ${listeners.length + 1} ${event} listeners added. Use setMaxListeners() to increase limit.`);
-      }
-      listeners.push(listener);
-    }
-    return this;
-  }
-  /**
-   * Removes a listener for a specific event. It is an alias for the off() method
-   * @param {string | symbol} event
-   * @param {EventListener} listener
-   * @returns {IEventEmitter} returns the instance of the class for chaining
-   */
-  removeListener(event, listener) {
-    this.off(event, listener);
-    return this;
-  }
-  /**
-   * Removes a listener for a specific event
-   * @param {string | symbol} event
-   * @param {EventListener} listener
-   * @returns {IEventEmitter} returns the instance of the class for chaining
-   */
-  off(event, listener) {
-    const listeners = this._eventListeners.get(event) ?? [];
-    const index = listeners.indexOf(listener);
-    if (index !== -1) {
-      listeners.splice(index, 1);
-    }
-    if (listeners.length === 0) {
-      this._eventListeners.delete(event);
-    }
-    return this;
-  }
-  /**
-   * Calls all listeners for a specific event
-   * @param {string | symbol} event
-   * @param arguments_ The arguments to pass to the listeners
-   * @returns {boolean} Returns true if the event had listeners, false otherwise
-   */
-  emit(event, ...arguments_) {
-    let result = false;
-    const listeners = this._eventListeners.get(event);
-    if (listeners && listeners.length > 0) {
-      for (const listener of listeners) {
-        listener(...arguments_);
-        result = true;
-      }
-    }
-    return result;
-  }
-  /**
-   * Gets all listeners for a specific event. If no event is provided, it returns all listeners
-   * @param {string} [event] (Optional) The event name
-   * @returns {EventListener[]} An array of listeners
-   */
-  listeners(event) {
-    return this._eventListeners.get(event) ?? [];
-  }
-  /**
-   * Removes all listeners for a specific event. If no event is provided, it removes all listeners
-   * @param {string} [event] (Optional) The event name
-   * @returns {IEventEmitter} returns the instance of the class for chaining
-   */
-  removeAllListeners(event) {
-    if (event) {
-      this._eventListeners.delete(event);
-    } else {
-      this._eventListeners.clear();
-    }
-    return this;
-  }
-  /**
-   * Sets the maximum number of listeners that can be added for a single event
-   * @param {number} n The maximum number of listeners
-   * @returns {void}
-   */
-  setMaxListeners(n) {
-    this._maxListeners = n;
-    for (const listeners of this._eventListeners.values()) {
-      if (listeners.length > n) {
-        listeners.splice(n);
-      }
-    }
-  }
-  /**
-   * Gets all listeners
-   * @returns {EventListener[]} An array of listeners
-   */
-  getAllListeners() {
-    let result = new Array();
-    for (const listeners of this._eventListeners.values()) {
-      result = result.concat(listeners);
-    }
-    return result;
-  }
-};
-
-// src/index.ts
-var Hookified = class extends Eventified {
-  _hooks;
-  _throwHookErrors = false;
-  constructor(options) {
-    super({ logger: options?.logger });
-    this._hooks = /* @__PURE__ */ new Map();
-    if (options?.throwHookErrors !== void 0) {
-      this._throwHookErrors = options.throwHookErrors;
-    }
-  }
-  /**
-   * Gets all hooks
-   * @returns {Map<string, Hook[]>}
-   */
-  get hooks() {
-    return this._hooks;
-  }
-  /**
-   * Gets whether an error should be thrown when a hook throws an error. Default is false and only emits an error event.
-   * @returns {boolean}
-   */
-  get throwHookErrors() {
-    return this._throwHookErrors;
-  }
-  /**
-   * Sets whether an error should be thrown when a hook throws an error. Default is false and only emits an error event.
-   * @param {boolean} value
-   */
-  set throwHookErrors(value) {
-    this._throwHookErrors = value;
-  }
-  /**
-   * Gets the logger
-   * @returns {Logger}
-   */
-  get logger() {
-    return this._logger;
-  }
-  /**
-   * Sets the logger
-   * @param {Logger} logger
-   */
-  set logger(logger) {
-    this._logger = logger;
-  }
-  /**
-   * Adds a handler function for a specific event
-   * @param {string} event
-   * @param {Hook} handler - this can be async or sync
-   * @returns {void}
-   */
-  onHook(event, handler) {
-    const eventHandlers = this._hooks.get(event);
-    if (eventHandlers) {
-      eventHandlers.push(handler);
-    } else {
-      this._hooks.set(event, [handler]);
-    }
-  }
-  /**
-   * Adds a handler function for a specific event that runs before all other handlers
-   * @param {string} event
-   * @param {Hook} handler - this can be async or sync
-   * @returns {void}
-   */
-  prependHook(event, handler) {
-    const eventHandlers = this._hooks.get(event);
-    if (eventHandlers) {
-      eventHandlers.unshift(handler);
-    } else {
-      this._hooks.set(event, [handler]);
-    }
-  }
-  /**
-   * Adds a handler that only executes once for a specific event before all other handlers
-   * @param event
-   * @param handler
-   */
-  prependOnceHook(event, handler) {
-    const hook = async (...arguments_) => {
-      this.removeHook(event, hook);
-      return handler(...arguments_);
-    };
-    this.prependHook(event, hook);
-  }
-  /**
-   * Adds a handler that only executes once for a specific event
-   * @param event
-   * @param handler
-   */
-  onceHook(event, handler) {
-    const hook = async (...arguments_) => {
-      this.removeHook(event, hook);
-      return handler(...arguments_);
-    };
-    this.onHook(event, hook);
-  }
-  /**
-   * Removes a handler function for a specific event
-   * @param {string} event
-   * @param {Hook} handler
-   * @returns {void}
-   */
-  removeHook(event, handler) {
-    const eventHandlers = this._hooks.get(event);
-    if (eventHandlers) {
-      const index = eventHandlers.indexOf(handler);
-      if (index !== -1) {
-        eventHandlers.splice(index, 1);
-      }
-    }
-  }
-  /**
-   * Calls all handlers for a specific event
-   * @param {string} event
-   * @param {T[]} arguments_
-   * @returns {Promise<void>}
-   */
-  async hook(event, ...arguments_) {
-    const eventHandlers = this._hooks.get(event);
-    if (eventHandlers) {
-      for (const handler of eventHandlers) {
-        try {
-          await handler(...arguments_);
-        } catch (error) {
-          const message = `${event}: ${error.message}`;
-          this.emit("error", new Error(message));
-          if (this._logger) {
-            this._logger.error(message);
-          }
-          if (this._throwHookErrors) {
-            throw new Error(message);
-          }
-        }
-      }
-    }
-  }
-  /**
-   * Gets all hooks for a specific event
-   * @param {string} event
-   * @returns {Hook[]}
-   */
-  getHooks(event) {
-    return this._hooks.get(event);
-  }
-  /**
-   * Removes all hooks
-   * @returns {void}
-   */
-  clearHooks() {
-    this._hooks.clear();
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Eventified,
-  Hookified
-});
+"use strict";var g=Object.defineProperty;var a=Object.getOwnPropertyDescriptor;var h=Object.getOwnPropertyNames;var u=Object.prototype.hasOwnProperty;var v=(n,e)=>{for(var t in e)g(n,t,{get:e[t],enumerable:!0})},c=(n,e,t,s)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of h(e))!u.call(n,r)&&r!==t&&g(n,r,{get:()=>e[r],enumerable:!(s=a(e,r))||s.enumerable});return n};var p=n=>c(g({},"__esModule",{value:!0}),n);var E={};v(E,{Eventified:()=>i,Hookified:()=>m});module.exports=p(E);var i=class{_eventListeners;_maxListeners;_logger;constructor(e){this._eventListeners=new Map,this._maxListeners=100,this._logger=e?.logger}once(e,t){let s=(...r)=>{this.off(e,s),t(...r)};return this.on(e,s),this}listenerCount(e){if(!e)return this.getAllListeners().length;let t=this._eventListeners.get(e);return t?t.length:0}eventNames(){return Array.from(this._eventListeners.keys())}rawListeners(e){return e?this._eventListeners.get(e)??[]:this.getAllListeners()}prependListener(e,t){let s=this._eventListeners.get(e)??[];return s.unshift(t),this._eventListeners.set(e,s),this}prependOnceListener(e,t){let s=(...r)=>{this.off(e,s),t(...r)};return this.prependListener(e,s),this}maxListeners(){return this._maxListeners}addListener(e,t){return this.on(e,t),this}on(e,t){this._eventListeners.has(e)||this._eventListeners.set(e,[]);let s=this._eventListeners.get(e);return s&&(s.length>=this._maxListeners&&console.warn(`MaxListenersExceededWarning: Possible event memory leak detected. ${s.length+1} ${e} listeners added. Use setMaxListeners() to increase limit.`),s.push(t)),this}removeListener(e,t){return this.off(e,t),this}off(e,t){let s=this._eventListeners.get(e)??[],r=s.indexOf(t);return r!==-1&&s.splice(r,1),s.length===0&&this._eventListeners.delete(e),this}emit(e,...t){let s=!1,r=this._eventListeners.get(e);if(r&&r.length>0)for(let o of r)o(...t),s=!0;return s}listeners(e){return this._eventListeners.get(e)??[]}removeAllListeners(e){return e?this._eventListeners.delete(e):this._eventListeners.clear(),this}setMaxListeners(e){this._maxListeners=e;for(let t of this._eventListeners.values())t.length>e&&t.splice(e)}getAllListeners(){let e=new Array;for(let t of this._eventListeners.values())e=e.concat(t);return e}};var m=class extends i{_hooks;_throwHookErrors=!1;constructor(e){super({logger:e?.logger}),this._hooks=new Map,e?.throwHookErrors!==void 0&&(this._throwHookErrors=e.throwHookErrors)}get hooks(){return this._hooks}get throwHookErrors(){return this._throwHookErrors}set throwHookErrors(e){this._throwHookErrors=e}get logger(){return this._logger}set logger(e){this._logger=e}onHook(e,t){let s=this._hooks.get(e);s?s.push(t):this._hooks.set(e,[t])}prependHook(e,t){let s=this._hooks.get(e);s?s.unshift(t):this._hooks.set(e,[t])}prependOnceHook(e,t){let s=async(...r)=>(this.removeHook(e,s),t(...r));this.prependHook(e,s)}onceHook(e,t){let s=async(...r)=>(this.removeHook(e,s),t(...r));this.onHook(e,s)}removeHook(e,t){let s=this._hooks.get(e);if(s){let r=s.indexOf(t);r!==-1&&s.splice(r,1)}}async hook(e,...t){let s=this._hooks.get(e);if(s)for(let r of s)try{await r(...t)}catch(o){let l=`${e}: ${o.message}`;if(this.emit("error",new Error(l)),this._logger&&this._logger.error(l),this._throwHookErrors)throw new Error(l)}}getHooks(e){return this._hooks.get(e)}clearHooks(){this._hooks.clear()}};0&&(module.exports={Eventified,Hookified});

package/dist/node/index.js

@@ -1,365 +1 @@
-// src/eventified.ts
-var Eventified = class {
-  _eventListeners;
-  _maxListeners;
-  _logger;
-  constructor(options) {
-    this._eventListeners = /* @__PURE__ */ new Map();
-    this._maxListeners = 100;
-    this._logger = options?.logger;
-  }
-  /**
-   * Adds a handler function for a specific event that will run only once
-   * @param {string | symbol} eventName
-   * @param {EventListener} listener
-   * @returns {IEventEmitter} returns the instance of the class for chaining
-   */
-  once(eventName, listener) {
-    const onceListener = (...arguments_) => {
-      this.off(eventName, onceListener);
-      listener(...arguments_);
-    };
-    this.on(eventName, onceListener);
-    return this;
-  }
-  /**
-   * Gets the number of listeners for a specific event. If no event is provided, it returns the total number of listeners
-   * @param {string} eventName The event name. Not required
-   * @returns {number} The number of listeners
-   */
-  listenerCount(eventName) {
-    if (!eventName) {
-      return this.getAllListeners().length;
-    }
-    const listeners = this._eventListeners.get(eventName);
-    return listeners ? listeners.length : 0;
-  }
-  /**
-   * Gets an array of event names
-   * @returns {Array<string | symbol>} An array of event names
-   */
-  eventNames() {
-    return Array.from(this._eventListeners.keys());
-  }
-  /**
-   * Gets an array of listeners for a specific event. If no event is provided, it returns all listeners
-   * @param {string} [event] (Optional) The event name
-   * @returns {EventListener[]} An array of listeners
-   */
-  rawListeners(event) {
-    if (!event) {
-      return this.getAllListeners();
-    }
-    return this._eventListeners.get(event) ?? [];
-  }
-  /**
-   * Prepends a listener to the beginning of the listeners array for the specified event
-   * @param {string | symbol} eventName
-   * @param {EventListener} listener
-   * @returns {IEventEmitter} returns the instance of the class for chaining
-   */
-  prependListener(eventName, listener) {
-    const listeners = this._eventListeners.get(eventName) ?? [];
-    listeners.unshift(listener);
-    this._eventListeners.set(eventName, listeners);
-    return this;
-  }
-  /**
-   * Prepends a one-time listener to the beginning of the listeners array for the specified event
-   * @param {string | symbol} eventName
-   * @param {EventListener} listener
-   * @returns {IEventEmitter} returns the instance of the class for chaining
-   */
-  prependOnceListener(eventName, listener) {
-    const onceListener = (...arguments_) => {
-      this.off(eventName, onceListener);
-      listener(...arguments_);
-    };
-    this.prependListener(eventName, onceListener);
-    return this;
-  }
-  /**
-   * Gets the maximum number of listeners that can be added for a single event
-   * @returns {number} The maximum number of listeners
-   */
-  maxListeners() {
-    return this._maxListeners;
-  }
-  /**
-   * Adds a listener for a specific event. It is an alias for the on() method
-   * @param {string | symbol} event
-   * @param {EventListener} listener
-   * @returns {IEventEmitter} returns the instance of the class for chaining
-   */
-  addListener(event, listener) {
-    this.on(event, listener);
-    return this;
-  }
-  /**
-   * Adds a listener for a specific event
-   * @param {string | symbol} event
-   * @param {EventListener} listener
-   * @returns {IEventEmitter} returns the instance of the class for chaining
-   */
-  on(event, listener) {
-    if (!this._eventListeners.has(event)) {
-      this._eventListeners.set(event, []);
-    }
-    const listeners = this._eventListeners.get(event);
-    if (listeners) {
-      if (listeners.length >= this._maxListeners) {
-        console.warn(`MaxListenersExceededWarning: Possible event memory leak detected. ${listeners.length + 1} ${event} listeners added. Use setMaxListeners() to increase limit.`);
-      }
-      listeners.push(listener);
-    }
-    return this;
-  }
-  /**
-   * Removes a listener for a specific event. It is an alias for the off() method
-   * @param {string | symbol} event
-   * @param {EventListener} listener
-   * @returns {IEventEmitter} returns the instance of the class for chaining
-   */
-  removeListener(event, listener) {
-    this.off(event, listener);
-    return this;
-  }
-  /**
-   * Removes a listener for a specific event
-   * @param {string | symbol} event
-   * @param {EventListener} listener
-   * @returns {IEventEmitter} returns the instance of the class for chaining
-   */
-  off(event, listener) {
-    const listeners = this._eventListeners.get(event) ?? [];
-    const index = listeners.indexOf(listener);
-    if (index !== -1) {
-      listeners.splice(index, 1);
-    }
-    if (listeners.length === 0) {
-      this._eventListeners.delete(event);
-    }
-    return this;
-  }
-  /**
-   * Calls all listeners for a specific event
-   * @param {string | symbol} event
-   * @param arguments_ The arguments to pass to the listeners
-   * @returns {boolean} Returns true if the event had listeners, false otherwise
-   */
-  emit(event, ...arguments_) {
-    let result = false;
-    const listeners = this._eventListeners.get(event);
-    if (listeners && listeners.length > 0) {
-      for (const listener of listeners) {
-        listener(...arguments_);
-        result = true;
-      }
-    }
-    return result;
-  }
-  /**
-   * Gets all listeners for a specific event. If no event is provided, it returns all listeners
-   * @param {string} [event] (Optional) The event name
-   * @returns {EventListener[]} An array of listeners
-   */
-  listeners(event) {
-    return this._eventListeners.get(event) ?? [];
-  }
-  /**
-   * Removes all listeners for a specific event. If no event is provided, it removes all listeners
-   * @param {string} [event] (Optional) The event name
-   * @returns {IEventEmitter} returns the instance of the class for chaining
-   */
-  removeAllListeners(event) {
-    if (event) {
-      this._eventListeners.delete(event);
-    } else {
-      this._eventListeners.clear();
-    }
-    return this;
-  }
-  /**
-   * Sets the maximum number of listeners that can be added for a single event
-   * @param {number} n The maximum number of listeners
-   * @returns {void}
-   */
-  setMaxListeners(n) {
-    this._maxListeners = n;
-    for (const listeners of this._eventListeners.values()) {
-      if (listeners.length > n) {
-        listeners.splice(n);
-      }
-    }
-  }
-  /**
-   * Gets all listeners
-   * @returns {EventListener[]} An array of listeners
-   */
-  getAllListeners() {
-    let result = new Array();
-    for (const listeners of this._eventListeners.values()) {
-      result = result.concat(listeners);
-    }
-    return result;
-  }
-};
-
-// src/index.ts
-var Hookified = class extends Eventified {
-  _hooks;
-  _throwHookErrors = false;
-  constructor(options) {
-    super({ logger: options?.logger });
-    this._hooks = /* @__PURE__ */ new Map();
-    if (options?.throwHookErrors !== void 0) {
-      this._throwHookErrors = options.throwHookErrors;
-    }
-  }
-  /**
-   * Gets all hooks
-   * @returns {Map<string, Hook[]>}
-   */
-  get hooks() {
-    return this._hooks;
-  }
-  /**
-   * Gets whether an error should be thrown when a hook throws an error. Default is false and only emits an error event.
-   * @returns {boolean}
-   */
-  get throwHookErrors() {
-    return this._throwHookErrors;
-  }
-  /**
-   * Sets whether an error should be thrown when a hook throws an error. Default is false and only emits an error event.
-   * @param {boolean} value
-   */
-  set throwHookErrors(value) {
-    this._throwHookErrors = value;
-  }
-  /**
-   * Gets the logger
-   * @returns {Logger}
-   */
-  get logger() {
-    return this._logger;
-  }
-  /**
-   * Sets the logger
-   * @param {Logger} logger
-   */
-  set logger(logger) {
-    this._logger = logger;
-  }
-  /**
-   * Adds a handler function for a specific event
-   * @param {string} event
-   * @param {Hook} handler - this can be async or sync
-   * @returns {void}
-   */
-  onHook(event, handler) {
-    const eventHandlers = this._hooks.get(event);
-    if (eventHandlers) {
-      eventHandlers.push(handler);
-    } else {
-      this._hooks.set(event, [handler]);
-    }
-  }
-  /**
-   * Adds a handler function for a specific event that runs before all other handlers
-   * @param {string} event
-   * @param {Hook} handler - this can be async or sync
-   * @returns {void}
-   */
-  prependHook(event, handler) {
-    const eventHandlers = this._hooks.get(event);
-    if (eventHandlers) {
-      eventHandlers.unshift(handler);
-    } else {
-      this._hooks.set(event, [handler]);
-    }
-  }
-  /**
-   * Adds a handler that only executes once for a specific event before all other handlers
-   * @param event
-   * @param handler
-   */
-  prependOnceHook(event, handler) {
-    const hook = async (...arguments_) => {
-      this.removeHook(event, hook);
-      return handler(...arguments_);
-    };
-    this.prependHook(event, hook);
-  }
-  /**
-   * Adds a handler that only executes once for a specific event
-   * @param event
-   * @param handler
-   */
-  onceHook(event, handler) {
-    const hook = async (...arguments_) => {
-      this.removeHook(event, hook);
-      return handler(...arguments_);
-    };
-    this.onHook(event, hook);
-  }
-  /**
-   * Removes a handler function for a specific event
-   * @param {string} event
-   * @param {Hook} handler
-   * @returns {void}
-   */
-  removeHook(event, handler) {
-    const eventHandlers = this._hooks.get(event);
-    if (eventHandlers) {
-      const index = eventHandlers.indexOf(handler);
-      if (index !== -1) {
-        eventHandlers.splice(index, 1);
-      }
-    }
-  }
-  /**
-   * Calls all handlers for a specific event
-   * @param {string} event
-   * @param {T[]} arguments_
-   * @returns {Promise<void>}
-   */
-  async hook(event, ...arguments_) {
-    const eventHandlers = this._hooks.get(event);
-    if (eventHandlers) {
-      for (const handler of eventHandlers) {
-        try {
-          await handler(...arguments_);
-        } catch (error) {
-          const message = `${event}: ${error.message}`;
-          this.emit("error", new Error(message));
-          if (this._logger) {
-            this._logger.error(message);
-          }
-          if (this._throwHookErrors) {
-            throw new Error(message);
-          }
-        }
-      }
-    }
-  }
-  /**
-   * Gets all hooks for a specific event
-   * @param {string} event
-   * @returns {Hook[]}
-   */
-  getHooks(event) {
-    return this._hooks.get(event);
-  }
-  /**
-   * Removes all hooks
-   * @returns {void}
-   */
-  clearHooks() {
-    this._hooks.clear();
-  }
-};
-export {
-  Eventified,
-  Hookified
-};
+var n=class{_eventListeners;_maxListeners;_logger;constructor(e){this._eventListeners=new Map,this._maxListeners=100,this._logger=e?.logger}once(e,s){let t=(...r)=>{this.off(e,t),s(...r)};return this.on(e,t),this}listenerCount(e){if(!e)return this.getAllListeners().length;let s=this._eventListeners.get(e);return s?s.length:0}eventNames(){return Array.from(this._eventListeners.keys())}rawListeners(e){return e?this._eventListeners.get(e)??[]:this.getAllListeners()}prependListener(e,s){let t=this._eventListeners.get(e)??[];return t.unshift(s),this._eventListeners.set(e,t),this}prependOnceListener(e,s){let t=(...r)=>{this.off(e,t),s(...r)};return this.prependListener(e,t),this}maxListeners(){return this._maxListeners}addListener(e,s){return this.on(e,s),this}on(e,s){this._eventListeners.has(e)||this._eventListeners.set(e,[]);let t=this._eventListeners.get(e);return t&&(t.length>=this._maxListeners&&console.warn(`MaxListenersExceededWarning: Possible event memory leak detected. ${t.length+1} ${e} listeners added. Use setMaxListeners() to increase limit.`),t.push(s)),this}removeListener(e,s){return this.off(e,s),this}off(e,s){let t=this._eventListeners.get(e)??[],r=t.indexOf(s);return r!==-1&&t.splice(r,1),t.length===0&&this._eventListeners.delete(e),this}emit(e,...s){let t=!1,r=this._eventListeners.get(e);if(r&&r.length>0)for(let i of r)i(...s),t=!0;return t}listeners(e){return this._eventListeners.get(e)??[]}removeAllListeners(e){return e?this._eventListeners.delete(e):this._eventListeners.clear(),this}setMaxListeners(e){this._maxListeners=e;for(let s of this._eventListeners.values())s.length>e&&s.splice(e)}getAllListeners(){let e=new Array;for(let s of this._eventListeners.values())e=e.concat(s);return e}};var l=class extends n{_hooks;_throwHookErrors=!1;constructor(e){super({logger:e?.logger}),this._hooks=new Map,e?.throwHookErrors!==void 0&&(this._throwHookErrors=e.throwHookErrors)}get hooks(){return this._hooks}get throwHookErrors(){return this._throwHookErrors}set throwHookErrors(e){this._throwHookErrors=e}get logger(){return this._logger}set logger(e){this._logger=e}onHook(e,s){let t=this._hooks.get(e);t?t.push(s):this._hooks.set(e,[s])}prependHook(e,s){let t=this._hooks.get(e);t?t.unshift(s):this._hooks.set(e,[s])}prependOnceHook(e,s){let t=async(...r)=>(this.removeHook(e,t),s(...r));this.prependHook(e,t)}onceHook(e,s){let t=async(...r)=>(this.removeHook(e,t),s(...r));this.onHook(e,t)}removeHook(e,s){let t=this._hooks.get(e);if(t){let r=t.indexOf(s);r!==-1&&t.splice(r,1)}}async hook(e,...s){let t=this._hooks.get(e);if(t)for(let r of t)try{await r(...s)}catch(i){let o=`${e}: ${i.message}`;if(this.emit("error",new Error(o)),this._logger&&this._logger.error(o),this._throwHookErrors)throw new Error(o)}}getHooks(e){return this._hooks.get(e)}clearHooks(){this._hooks.clear()}};export{n as Eventified,l as Hookified};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hookified",
-  "version": "1.8.0",
+  "version": "1.8.1",
   "description": "Event Emitting and Middleware Hooks",
   "type": "module",
   "main": "dist/node/index.cjs",
@@ -21,6 +21,9 @@
     "test:ci": "xo && vitest run --coverage",
     "clean": "rimraf ./dist ./coverage ./site/dist",
     "build": "rimraf ./dist && tsup",
+    "benchmark": "pnpm benchmark:hooks && pnpm benchmark:emit",
+    "benchmark:hooks": "pnpm tsx benchmark/hook.ts",
+    "benchmark:emit": "pnpm tsx benchmark/emit.ts",
     "website:build": "docula build",
     "website:serve": "docula serve",
     "prepare": "npm run build"
@@ -57,11 +60,17 @@
   },
   "homepage": "https://github.com/jaredwray/hookified#readme",
   "devDependencies": {
+    "@monstermann/tinybench-pretty-printer": "^0.0.0",
     "@vitest/coverage-v8": "^3.0.8",
     "docula": "^0.10.1",
+    "emittery": "^1.1.0",
+    "eventemitter3": "^5.0.1",
+    "hookable": "^5.5.3",
     "pino": "^9.6.0",
     "rimraf": "^6.0.1",
+    "tinybench": "^3.1.1",
     "tsup": "^8.4.0",
+    "tsx": "^4.19.3",
     "typescript": "^5.8.2",
     "vitest": "^3.0.8",
     "xo": "^0.60.0"