hookified 1.4.0 → 1.5.0

package/dist/node/index.cjs

@@ -33,6 +33,12 @@ var Eventified = class {
     this._eventListeners = /* @__PURE__ */ new Map();
     this._maxListeners = 100;
   }
+  /**
+   * 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);
@@ -41,6 +47,11 @@ var Eventified = class {
     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;
@@ -48,21 +59,42 @@ var Eventified = class {
     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());
   }
-  rawListeners(eventName) {
-    if (!eventName) {
+  /**
+   * 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(eventName) ?? [];
+    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);
@@ -71,14 +103,29 @@ var Eventified = class {
     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;
   }
-  // Add an event listener
+  /**
+   * 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, []);
@@ -92,11 +139,22 @@ var Eventified = class {
     }
     return this;
   }
-  // Remove an event listener
+  /**
+   * 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);
@@ -108,21 +166,36 @@ var Eventified = class {
     }
     return this;
   }
-  // Emit an event
+  /**
+   * 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 true;
+    return result;
   }
-  // Get all listeners for a specific event
+  /**
+   * 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) ?? [];
   }
-  // Remove all listeners for a specific 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);
@@ -131,7 +204,11 @@ var Eventified = class {
     }
     return this;
   }
-  // Set the maximum number of listeners for a single event
+  /**
+   * 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()) {
@@ -140,6 +217,10 @@ var Eventified = class {
       }
     }
   }
+  /**
+   * Gets all listeners
+   * @returns {EventListener[]} An array of listeners
+   */
   getAllListeners() {
     let result = new Array();
     for (const listeners of this._eventListeners.values()) {
@@ -156,7 +237,12 @@ var Hookified = class extends Eventified {
     super();
     this._hooks = /* @__PURE__ */ new Map();
   }
-  // Adds a handler function for a specific event
+  /**
+   * 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) {
@@ -165,7 +251,24 @@ var Hookified = class extends Eventified {
       this._hooks.set(event, [handler]);
     }
   }
-  // Removes a specific handler function for a specific event
+  /**
+   * 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) {
@@ -175,7 +278,12 @@ var Hookified = class extends Eventified {
       }
     }
   }
-  // Triggers all handlers for a specific event with provided data
+  /**
+   * 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) {
@@ -188,13 +296,25 @@ var Hookified = class extends Eventified {
       }
     }
   }
-  // Provides read-only access to the current handlers
+  /**
+   * Gets all hooks
+   * @returns {Map<string, Hook[]>}
+   */
   get hooks() {
     return this._hooks;
   }
+  /**
+   * 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();
   }

package/dist/node/index.d.cts

@@ -148,21 +148,106 @@ declare class Eventified implements IEventEmitter {
     _eventListeners: Map<string | symbol, EventListener[]>;
     _maxListeners: number;
     constructor();
+    /**
+     * 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: string | symbol, listener: EventListener): IEventEmitter;
+    /**
+     * 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?: string | symbol): number;
+    /**
+     * Gets an array of event names
+     * @returns {Array<string | symbol>} An array of event names
+     */
     eventNames(): Array<string | symbol>;
-    rawListeners(eventName?: string | symbol): EventListener[];
+    /**
+     * 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?: string | symbol): EventListener[];
+    /**
+     * 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: string | symbol, listener: EventListener): IEventEmitter;
+    /**
+     * 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: string | symbol, listener: EventListener): IEventEmitter;
+    /**
+     * Gets the maximum number of listeners that can be added for a single event
+     * @returns {number} The maximum number of listeners
+     */
     maxListeners(): number;
+    /**
+     * 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: string | symbol, listener: EventListener): IEventEmitter;
+    /**
+     * 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: string | symbol, listener: EventListener): IEventEmitter;
+    /**
+     * 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: string, listener: EventListener): IEventEmitter;
-    off(event: string, listener: EventListener): IEventEmitter;
-    emit(event: string, ...arguments_: any[]): boolean;
+    /**
+     * 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: string | symbol, listener: EventListener): IEventEmitter;
+    /**
+     * 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: string | symbol, ...arguments_: any[]): boolean;
+    /**
+     * 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: string): EventListener[];
+    /**
+     * 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?: string): IEventEmitter;
+    /**
+     * 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: number): void;
+    /**
+     * Gets all listeners
+     * @returns {EventListener[]} An array of listeners
+     */
     getAllListeners(): EventListener[];
 }
 
@@ -170,11 +255,48 @@ type Hook = (...arguments_: any[]) => Promise<void> | void;
 declare class Hookified extends Eventified {
     _hooks: Map<string, Hook[]>;
     constructor();
+    /**
+     * Adds a handler function for a specific event
+     * @param {string} event
+     * @param {Hook} handler - this can be async or sync
+     * @returns {void}
+     */
     onHook(event: string, handler: Hook): void;
+    /**
+     * Adds a handler that only executes once for a specific event
+     * @param event
+     * @param handler
+     */
+    onceHook(event: string, handler: Hook): void;
+    /**
+     * Removes a handler function for a specific event
+     * @param {string} event
+     * @param {Hook} handler
+     * @returns {void}
+     */
     removeHook(event: string, handler: Hook): void;
+    /**
+     * Calls all handlers for a specific event
+     * @param {string} event
+     * @param {T[]} arguments_
+     * @returns {Promise<void>}
+     */
     hook<T>(event: string, ...arguments_: T[]): Promise<void>;
+    /**
+     * Gets all hooks
+     * @returns {Map<string, Hook[]>}
+     */
     get hooks(): Map<string, Hook[]>;
+    /**
+     * Gets all hooks for a specific event
+     * @param {string} event
+     * @returns {Hook[]}
+     */
     getHooks(event: string): Hook[] | undefined;
+    /**
+     * Removes all hooks
+     * @returns {void}
+     */
     clearHooks(): void;
 }
 

package/dist/node/index.d.ts

@@ -148,21 +148,106 @@ declare class Eventified implements IEventEmitter {
     _eventListeners: Map<string | symbol, EventListener[]>;
     _maxListeners: number;
     constructor();
+    /**
+     * 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: string | symbol, listener: EventListener): IEventEmitter;
+    /**
+     * 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?: string | symbol): number;
+    /**
+     * Gets an array of event names
+     * @returns {Array<string | symbol>} An array of event names
+     */
     eventNames(): Array<string | symbol>;
-    rawListeners(eventName?: string | symbol): EventListener[];
+    /**
+     * 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?: string | symbol): EventListener[];
+    /**
+     * 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: string | symbol, listener: EventListener): IEventEmitter;
+    /**
+     * 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: string | symbol, listener: EventListener): IEventEmitter;
+    /**
+     * Gets the maximum number of listeners that can be added for a single event
+     * @returns {number} The maximum number of listeners
+     */
     maxListeners(): number;
+    /**
+     * 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: string | symbol, listener: EventListener): IEventEmitter;
+    /**
+     * 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: string | symbol, listener: EventListener): IEventEmitter;
+    /**
+     * 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: string, listener: EventListener): IEventEmitter;
-    off(event: string, listener: EventListener): IEventEmitter;
-    emit(event: string, ...arguments_: any[]): boolean;
+    /**
+     * 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: string | symbol, listener: EventListener): IEventEmitter;
+    /**
+     * 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: string | symbol, ...arguments_: any[]): boolean;
+    /**
+     * 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: string): EventListener[];
+    /**
+     * 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?: string): IEventEmitter;
+    /**
+     * 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: number): void;
+    /**
+     * Gets all listeners
+     * @returns {EventListener[]} An array of listeners
+     */
     getAllListeners(): EventListener[];
 }
 
@@ -170,11 +255,48 @@ type Hook = (...arguments_: any[]) => Promise<void> | void;
 declare class Hookified extends Eventified {
     _hooks: Map<string, Hook[]>;
     constructor();
+    /**
+     * Adds a handler function for a specific event
+     * @param {string} event
+     * @param {Hook} handler - this can be async or sync
+     * @returns {void}
+     */
     onHook(event: string, handler: Hook): void;
+    /**
+     * Adds a handler that only executes once for a specific event
+     * @param event
+     * @param handler
+     */
+    onceHook(event: string, handler: Hook): void;
+    /**
+     * Removes a handler function for a specific event
+     * @param {string} event
+     * @param {Hook} handler
+     * @returns {void}
+     */
     removeHook(event: string, handler: Hook): void;
+    /**
+     * Calls all handlers for a specific event
+     * @param {string} event
+     * @param {T[]} arguments_
+     * @returns {Promise<void>}
+     */
     hook<T>(event: string, ...arguments_: T[]): Promise<void>;
+    /**
+     * Gets all hooks
+     * @returns {Map<string, Hook[]>}
+     */
     get hooks(): Map<string, Hook[]>;
+    /**
+     * Gets all hooks for a specific event
+     * @param {string} event
+     * @returns {Hook[]}
+     */
     getHooks(event: string): Hook[] | undefined;
+    /**
+     * Removes all hooks
+     * @returns {void}
+     */
     clearHooks(): void;
 }