hookified 1.13.0 → 1.15.0

package/dist/node/index.d.cts

@@ -6,7 +6,21 @@ type Logger = {
     error: (message: string, ...arguments_: unknown[]) => void;
     fatal: (message: string, ...arguments_: unknown[]) => void;
 };
-
+type EventEmitterOptions = {
+    /**
+     * Logger instance for logging errors.
+     */
+    logger?: Logger;
+    /**
+     * Whether to throw an error when emit 'error' and there are no listeners. Default is false and only emits an error event.
+     */
+    throwOnEmitError?: boolean;
+    /**
+     * Whether to throw on 'error' when there are no listeners. This is the standard functionality in EventEmitter
+     * @default false - in v2 this will be set to true by default
+     */
+    throwOnEmptyListeners?: boolean;
+};
 type IEventEmitter = {
     /**
      * Registers a listener for the specified event.
@@ -152,21 +166,47 @@ type IEventEmitter = {
     prependOnceListener(eventName: string | symbol, listener: (...arguments_: any[]) => void): IEventEmitter;
 };
 type EventListener = (...arguments_: any[]) => void;
-type EventEmitterOptions = {
+type Hook = (...arguments_: any[]) => Promise<void> | void;
+type HookEntry = {
     /**
-     * Logger instance for logging errors.
+     * The event name for the hook
      */
-    logger?: Logger;
+    event: string;
     /**
-     * Whether to throw an error when emit 'error' and there are no listeners. Default is false and only emits an error event.
+     * The handler function for the hook
      */
-    throwOnEmitError?: boolean;
+    handler: Hook;
+};
+type HookifiedOptions = {
     /**
-     * Whether to throw on 'error' when there are no listeners. This is the standard functionality in EventEmitter
-     * @default false - in v2 this will be set to true by default
+     * Whether an error should be thrown when a hook throws an error. Default is false and only emits an error event.
+     * @deprecated - this will be deprecated in version 2. Please use throwOnHookError.
      */
-    throwOnEmptyListeners?: boolean;
-};
+    throwHookErrors?: boolean;
+    /**
+     * Whether an error should be thrown when a hook throws an error. Default is false and only emits an error event.
+     */
+    throwOnHookError?: boolean;
+    /**
+     * Whether to enforce that all hook names start with 'before' or 'after'. Default is false.
+     * @type {boolean}
+     * @default false
+     */
+    enforceBeforeAfter?: boolean;
+    /**
+     * Map of deprecated hook names to deprecation messages. When a deprecated hook is used, a warning will be emitted.
+     * @type {Map<string, string>}
+     * @default new Map()
+     */
+    deprecatedHooks?: Map<string, string>;
+    /**
+     * Whether to allow deprecated hooks to be registered and executed. Default is true.
+     * @type {boolean}
+     * @default true
+     */
+    allowDeprecated?: boolean;
+} & EventEmitterOptions;
+
 declare class Eventified implements IEventEmitter {
     private readonly _eventListeners;
     private _maxListeners;
@@ -306,48 +346,14 @@ declare class Eventified implements IEventEmitter {
      * @returns {EventListener[]} An array of listeners
      */
     getAllListeners(): EventListener[];
-}
-
-type Hook = (...arguments_: any[]) => Promise<void> | void;
-type HookEntry = {
-    /**
-     * The event name for the hook
-     */
-    event: string;
-    /**
-     * The handler function for the hook
-     */
-    handler: Hook;
-};
-type HookifiedOptions = {
-    /**
-     * Whether an error should be thrown when a hook throws an error. Default is false and only emits an error event.
-     * @deprecated - this will be deprecated in version 2. Please use throwOnHookError.
-     */
-    throwHookErrors?: boolean;
     /**
-     * Whether an error should be thrown when a hook throws an error. Default is false and only emits an error event.
+     * Sends a log message using the configured logger based on the event name
+     * @param {string | symbol} eventName - The event name that determines the log level
+     * @param {unknown} data - The data to log
      */
-    throwOnHookError?: boolean;
-    /**
-     * Whether to enforce that all hook names start with 'before' or 'after'. Default is false.
-     * @type {boolean}
-     * @default false
-     */
-    enforceBeforeAfter?: boolean;
-    /**
-     * Map of deprecated hook names to deprecation messages. When a deprecated hook is used, a warning will be emitted.
-     * @type {Map<string, string>}
-     * @default new Map()
-     */
-    deprecatedHooks?: Map<string, string>;
-    /**
-     * Whether to allow deprecated hooks to be registered and executed. Default is true.
-     * @type {boolean}
-     * @default true
-     */
-    allowDeprecated?: boolean;
-} & EventEmitterOptions;
+    private sendLog;
+}
+
 declare class Hookified extends Eventified {
     private readonly _hooks;
     private _throwOnHookError;
@@ -433,7 +439,7 @@ declare class Hookified extends Eventified {
      */
     onHook(event: string, handler: Hook): void;
     /**
-     * Adds a handler function for a specific event that runs before all other handlers
+     * Adds a handler function for a specific event
      * @param {HookEntry} hookEntry
      * @returns {void}
      */
@@ -490,6 +496,17 @@ declare class Hookified extends Eventified {
      * @returns {Promise<void>}
      */
     hook<T>(event: string, ...arguments_: T[]): Promise<void>;
+    /**
+     * Calls all synchronous handlers for a specific event.
+     * Async handlers (declared with `async` keyword) are silently skipped.
+     *
+     * Note: The `hook` method is preferred as it executes both sync and async functions.
+     * Use `hookSync` only when you specifically need synchronous execution.
+     * @param {string} event
+     * @param {T[]} arguments_
+     * @returns {void}
+     */
+    hookSync<T>(event: string, ...arguments_: T[]): void;
     /**
      * Prepends the word `before` to your hook. Example is event is `test`, the before hook is `before:test`.
      * @param {string} event - The event name
@@ -523,4 +540,4 @@ declare class Hookified extends Eventified {
     clearHooks(): void;
 }
 
-export { type EventListener, Eventified, type Hook, type HookEntry, Hookified, type HookifiedOptions, type Logger };
+export { type EventEmitterOptions, type EventListener, Eventified, type Hook, type HookEntry, Hookified, type HookifiedOptions, type IEventEmitter, type Logger };

package/dist/node/index.d.ts

@@ -6,7 +6,21 @@ type Logger = {
     error: (message: string, ...arguments_: unknown[]) => void;
     fatal: (message: string, ...arguments_: unknown[]) => void;
 };
-
+type EventEmitterOptions = {
+    /**
+     * Logger instance for logging errors.
+     */
+    logger?: Logger;
+    /**
+     * Whether to throw an error when emit 'error' and there are no listeners. Default is false and only emits an error event.
+     */
+    throwOnEmitError?: boolean;
+    /**
+     * Whether to throw on 'error' when there are no listeners. This is the standard functionality in EventEmitter
+     * @default false - in v2 this will be set to true by default
+     */
+    throwOnEmptyListeners?: boolean;
+};
 type IEventEmitter = {
     /**
      * Registers a listener for the specified event.
@@ -152,21 +166,47 @@ type IEventEmitter = {
     prependOnceListener(eventName: string | symbol, listener: (...arguments_: any[]) => void): IEventEmitter;
 };
 type EventListener = (...arguments_: any[]) => void;
-type EventEmitterOptions = {
+type Hook = (...arguments_: any[]) => Promise<void> | void;
+type HookEntry = {
     /**
-     * Logger instance for logging errors.
+     * The event name for the hook
      */
-    logger?: Logger;
+    event: string;
     /**
-     * Whether to throw an error when emit 'error' and there are no listeners. Default is false and only emits an error event.
+     * The handler function for the hook
      */
-    throwOnEmitError?: boolean;
+    handler: Hook;
+};
+type HookifiedOptions = {
     /**
-     * Whether to throw on 'error' when there are no listeners. This is the standard functionality in EventEmitter
-     * @default false - in v2 this will be set to true by default
+     * Whether an error should be thrown when a hook throws an error. Default is false and only emits an error event.
+     * @deprecated - this will be deprecated in version 2. Please use throwOnHookError.
      */
-    throwOnEmptyListeners?: boolean;
-};
+    throwHookErrors?: boolean;
+    /**
+     * Whether an error should be thrown when a hook throws an error. Default is false and only emits an error event.
+     */
+    throwOnHookError?: boolean;
+    /**
+     * Whether to enforce that all hook names start with 'before' or 'after'. Default is false.
+     * @type {boolean}
+     * @default false
+     */
+    enforceBeforeAfter?: boolean;
+    /**
+     * Map of deprecated hook names to deprecation messages. When a deprecated hook is used, a warning will be emitted.
+     * @type {Map<string, string>}
+     * @default new Map()
+     */
+    deprecatedHooks?: Map<string, string>;
+    /**
+     * Whether to allow deprecated hooks to be registered and executed. Default is true.
+     * @type {boolean}
+     * @default true
+     */
+    allowDeprecated?: boolean;
+} & EventEmitterOptions;
+
 declare class Eventified implements IEventEmitter {
     private readonly _eventListeners;
     private _maxListeners;
@@ -306,48 +346,14 @@ declare class Eventified implements IEventEmitter {
      * @returns {EventListener[]} An array of listeners
      */
     getAllListeners(): EventListener[];
-}
-
-type Hook = (...arguments_: any[]) => Promise<void> | void;
-type HookEntry = {
-    /**
-     * The event name for the hook
-     */
-    event: string;
-    /**
-     * The handler function for the hook
-     */
-    handler: Hook;
-};
-type HookifiedOptions = {
-    /**
-     * Whether an error should be thrown when a hook throws an error. Default is false and only emits an error event.
-     * @deprecated - this will be deprecated in version 2. Please use throwOnHookError.
-     */
-    throwHookErrors?: boolean;
     /**
-     * Whether an error should be thrown when a hook throws an error. Default is false and only emits an error event.
+     * Sends a log message using the configured logger based on the event name
+     * @param {string | symbol} eventName - The event name that determines the log level
+     * @param {unknown} data - The data to log
      */
-    throwOnHookError?: boolean;
-    /**
-     * Whether to enforce that all hook names start with 'before' or 'after'. Default is false.
-     * @type {boolean}
-     * @default false
-     */
-    enforceBeforeAfter?: boolean;
-    /**
-     * Map of deprecated hook names to deprecation messages. When a deprecated hook is used, a warning will be emitted.
-     * @type {Map<string, string>}
-     * @default new Map()
-     */
-    deprecatedHooks?: Map<string, string>;
-    /**
-     * Whether to allow deprecated hooks to be registered and executed. Default is true.
-     * @type {boolean}
-     * @default true
-     */
-    allowDeprecated?: boolean;
-} & EventEmitterOptions;
+    private sendLog;
+}
+
 declare class Hookified extends Eventified {
     private readonly _hooks;
     private _throwOnHookError;
@@ -433,7 +439,7 @@ declare class Hookified extends Eventified {
      */
     onHook(event: string, handler: Hook): void;
     /**
-     * Adds a handler function for a specific event that runs before all other handlers
+     * Adds a handler function for a specific event
      * @param {HookEntry} hookEntry
      * @returns {void}
      */
@@ -490,6 +496,17 @@ declare class Hookified extends Eventified {
      * @returns {Promise<void>}
      */
     hook<T>(event: string, ...arguments_: T[]): Promise<void>;
+    /**
+     * Calls all synchronous handlers for a specific event.
+     * Async handlers (declared with `async` keyword) are silently skipped.
+     *
+     * Note: The `hook` method is preferred as it executes both sync and async functions.
+     * Use `hookSync` only when you specifically need synchronous execution.
+     * @param {string} event
+     * @param {T[]} arguments_
+     * @returns {void}
+     */
+    hookSync<T>(event: string, ...arguments_: T[]): void;
     /**
      * Prepends the word `before` to your hook. Example is event is `test`, the before hook is `before:test`.
      * @param {string} event - The event name
@@ -523,4 +540,4 @@ declare class Hookified extends Eventified {
     clearHooks(): void;
 }
 
-export { type EventListener, Eventified, type Hook, type HookEntry, Hookified, type HookifiedOptions, type Logger };
+export { type EventEmitterOptions, type EventListener, Eventified, type Hook, type HookEntry, Hookified, type HookifiedOptions, type IEventEmitter, type Logger };

package/dist/node/index.js

@@ -219,6 +219,7 @@ var Eventified = class {
         }
       }
     }
+    this.sendLog(event, arguments_);
     return result;
   }
   /**
@@ -266,6 +267,54 @@ var Eventified = class {
     }
     return result;
   }
+  /**
+   * Sends a log message using the configured logger based on the event name
+   * @param {string | symbol} eventName - The event name that determines the log level
+   * @param {unknown} data - The data to log
+   */
+  sendLog(eventName, data) {
+    if (!this._logger) {
+      return;
+    }
+    let message;
+    if (typeof data === "string") {
+      message = data;
+    } else if (Array.isArray(data) && data.length > 0 && data[0] instanceof Error) {
+      message = data[0].message;
+    } else if (data instanceof Error) {
+      message = data.message;
+    } else if (Array.isArray(data) && data.length > 0 && typeof data[0]?.message === "string") {
+      message = data[0].message;
+    } else {
+      message = JSON.stringify(data);
+    }
+    switch (eventName) {
+      case "error": {
+        this._logger.error?.(message, { event: eventName, data });
+        break;
+      }
+      case "warn": {
+        this._logger.warn?.(message, { event: eventName, data });
+        break;
+      }
+      case "trace": {
+        this._logger.trace?.(message, { event: eventName, data });
+        break;
+      }
+      case "debug": {
+        this._logger.debug?.(message, { event: eventName, data });
+        break;
+      }
+      case "fatal": {
+        this._logger.fatal?.(message, { event: eventName, data });
+        break;
+      }
+      default: {
+        this._logger.info?.(message, { event: eventName, data });
+        break;
+      }
+    }
+  }
 };
 
 // src/index.ts
@@ -400,9 +449,6 @@ var Hookified = class extends Eventified {
       const message = this._deprecatedHooks.get(event);
       const warningMessage = `Hook "${event}" is deprecated${message ? `: ${message}` : ""}`;
       this.emit("warn", { hook: event, message: warningMessage });
-      if (this.logger?.warn) {
-        this.logger.warn(warningMessage);
-      }
       return this._allowDeprecated;
     }
     return true;
@@ -414,24 +460,24 @@ var Hookified = class extends Eventified {
    * @returns {void}
    */
   onHook(event, handler) {
-    this.validateHookName(event);
-    if (!this.checkDeprecatedHook(event)) {
-      return;
-    }
-    const eventHandlers = this._hooks.get(event);
-    if (eventHandlers) {
-      eventHandlers.push(handler);
-    } else {
-      this._hooks.set(event, [handler]);
-    }
+    this.onHookEntry({ event, handler });
   }
   /**
-   * Adds a handler function for a specific event that runs before all other handlers
+   * Adds a handler function for a specific event
    * @param {HookEntry} hookEntry
    * @returns {void}
    */
   onHookEntry(hookEntry) {
-    this.onHook(hookEntry.event, hookEntry.handler);
+    this.validateHookName(hookEntry.event);
+    if (!this.checkDeprecatedHook(hookEntry.event)) {
+      return;
+    }
+    const eventHandlers = this._hooks.get(hookEntry.event);
+    if (eventHandlers) {
+      eventHandlers.push(hookEntry.handler);
+    } else {
+      this._hooks.set(hookEntry.event, [hookEntry.handler]);
+    }
   }
   /**
    * Alias for onHook. This is provided for compatibility with other libraries that use the `addHook` method.
@@ -440,7 +486,7 @@ var Hookified = class extends Eventified {
    * @returns {void}
    */
   addHook(event, handler) {
-    this.onHook(event, handler);
+    this.onHookEntry({ event, handler });
   }
   /**
    * Adds a handler function for a specific event
@@ -550,9 +596,39 @@ var Hookified = class extends Eventified {
         } catch (error) {
           const message = `${event}: ${error.message}`;
           this.emit("error", new Error(message));
-          if (this.logger) {
-            this.logger.error(message);
+          if (this._throwOnHookError) {
+            throw new Error(message);
           }
+        }
+      }
+    }
+  }
+  /**
+   * Calls all synchronous handlers for a specific event.
+   * Async handlers (declared with `async` keyword) are silently skipped.
+   *
+   * Note: The `hook` method is preferred as it executes both sync and async functions.
+   * Use `hookSync` only when you specifically need synchronous execution.
+   * @param {string} event
+   * @param {T[]} arguments_
+   * @returns {void}
+   */
+  hookSync(event, ...arguments_) {
+    this.validateHookName(event);
+    if (!this.checkDeprecatedHook(event)) {
+      return;
+    }
+    const eventHandlers = this._hooks.get(event);
+    if (eventHandlers) {
+      for (const handler of eventHandlers) {
+        if (handler.constructor.name === "AsyncFunction") {
+          continue;
+        }
+        try {
+          handler(...arguments_);
+        } catch (error) {
+          const message = `${event}: ${error.message}`;
+          this.emit("error", new Error(message));
           if (this._throwOnHookError) {
             throw new Error(message);
           }
@@ -610,3 +686,4 @@ export {
   Eventified,
   Hookified
 };
+/* v8 ignore next -- @preserve */

package/package.json

@@ -1,21 +1,28 @@
 {
   "name": "hookified",
-  "version": "1.13.0",
+  "version": "1.15.0",
   "description": "Event Emitting and Middleware Hooks",
   "type": "module",
-  "main": "dist/node/index.cjs",
-  "module": "dist/node/index.js",
+  "main": "./dist/node/index.js",
+  "module": "./dist/node/index.js",
+  "types": "./dist/node/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/node/index.js",
-      "require": "./dist/node/index.cjs"
+      "import": {
+        "types": "./dist/node/index.d.ts",
+        "default": "./dist/node/index.js"
+      },
+      "require": {
+        "types": "./dist/node/index.d.cts",
+        "default": "./dist/node/index.cjs"
+      },
+      "default": "./dist/node/index.js"
     },
     "./browser": {
       "import": "./dist/browser/index.js",
       "default": "./dist/browser/index.global.js"
     }
   },
-  "types": "dist/node/index.d.ts",
   "scripts": {
     "lint": "biome check --write --error-on-warnings",
     "test": "pnpm lint && vitest run --coverage",
@@ -61,29 +68,24 @@
   },
   "homepage": "https://github.com/jaredwray/hookified#readme",
   "devDependencies": {
-    "@biomejs/biome": "^2.3.5",
-    "@monstermann/tinybench-pretty-printer": "^0.2.0",
-    "@types/node": "^24.10.0",
-    "@vitest/coverage-v8": "^4.0.8",
-    "docula": "^0.31.0",
+    "@biomejs/biome": "^2.3.8",
+    "@monstermann/tinybench-pretty-printer": "^0.3.0",
+    "@types/node": "^25.0.3",
+    "@vitest/coverage-v8": "^4.0.15",
+    "docula": "^0.31.1",
     "emittery": "^1.2.0",
     "eventemitter3": "^5.0.1",
-    "hookable": "^5.5.3",
+    "hookable": "^6.0.1",
     "pino": "^10.1.0",
-    "rimraf": "^6.1.0",
-    "tinybench": "^5.1.0",
-    "tsup": "^8.5.0",
-    "tsx": "^4.20.6",
+    "rimraf": "^6.1.2",
+    "tinybench": "^6.0.0",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.8"
+    "vitest": "^4.0.15"
   },
   "files": [
     "dist",
     "LICENSE"
-  ],
-  "pnpm": {
-    "onlyBuiltDependencies": [
-      "unrs-resolver"
-    ]
-  }
+  ]
 }