hookable 5.4.0 → 5.4.2

package/LICENSE.md

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2018 Pooya Parsa <pooya@pi0.ir>
+Copyright (c) Pooya Parsa <pooya@pi0.io>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/index.cjs

@@ -1,7 +1,5 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 function flatHooks(configHooks, hooks = {}, parentName) {
   for (const key in configHooks) {
     const subHook = configHooks[key];
@@ -28,82 +26,42 @@ function mergeHooks(...hooks) {
   }
   for (const key in finalHooks) {
     if (finalHooks[key].length > 1) {
-      const arr = finalHooks[key];
-      finalHooks[key] = (...args) => serial(arr, (fn) => fn(...args));
+      const array = finalHooks[key];
+      finalHooks[key] = (...arguments_) => serial(array, (function_) => function_(...arguments_));
     } else {
       finalHooks[key] = finalHooks[key][0];
     }
   }
   return finalHooks;
 }
-function serial(tasks, fn) {
-  return tasks.reduce((promise, task) => promise.then(() => fn(task)), Promise.resolve(null));
+function serial(tasks, function_) {
+  return tasks.reduce((promise, task) => promise.then(() => function_(task)), Promise.resolve());
 }
-function serialCaller(hooks, args) {
-  return hooks.reduce((promise, hookFn) => promise.then(() => hookFn.apply(void 0, args)), Promise.resolve(null));
+function serialCaller(hooks, arguments_) {
+  return hooks.reduce((promise, hookFunction) => promise.then(() => hookFunction.apply(void 0, arguments_)), Promise.resolve());
 }
-function parallelCaller(hooks, args) {
-  return Promise.all(hooks.map((hook) => hook.apply(void 0, args)));
+function parallelCaller(hooks, arguments_) {
+  return Promise.all(hooks.map((hook) => hook.apply(void 0, arguments_)));
 }
-function callEachWith(callbacks, arg0) {
-  for (const cb of callbacks) {
-    cb(arg0);
+function callEachWith(callbacks, argument0) {
+  for (const callback of callbacks) {
+    callback(argument0);
   }
 }
-const isBrowser = typeof window !== "undefined";
-function createDebugger(hooks, _options = {}) {
-  const options = {
-    inspect: isBrowser,
-    group: isBrowser,
-    filter: () => true,
-    ..._options
-  };
-  const _filter = options.filter;
-  const filter = typeof _filter === "string" ? (name) => name.startsWith(_filter) : _filter;
-  const logPrefix = options.tag ? `[${options.tag}] ` : "";
-  const unsubscribeBefore = hooks.beforeEach(({ name }) => {
-    if (!filter(name)) {
-      return;
-    }
-    console.time(logPrefix + name);
-  });
-  const unsubscribeAfter = hooks.afterEach(({ name, args }) => {
-    if (!filter(name)) {
-      return;
-    }
-    if (options.group) {
-      console.groupCollapsed(name);
-    }
-    if (options.inspect) {
-      console.timeLog(logPrefix + name, args);
-    } else {
-      console.timeEnd(logPrefix + name);
-    }
-    if (options.group) {
-      console.groupEnd();
-    }
-  });
-  return {
-    close: () => {
-      unsubscribeBefore();
-      unsubscribeAfter();
-    }
-  };
-}
 
 class Hookable {
   constructor() {
     this._hooks = {};
-    this._before = null;
-    this._after = null;
-    this._deprecatedMessages = null;
+    this._before = void 0;
+    this._after = void 0;
+    this._deprecatedMessages = void 0;
     this._deprecatedHooks = {};
     this.hook = this.hook.bind(this);
     this.callHook = this.callHook.bind(this);
     this.callHookWith = this.callHookWith.bind(this);
   }
-  hook(name, fn, opts = {}) {
-    if (!name || typeof fn !== "function") {
+  hook(name, function_, options = {}) {
+    if (!name || typeof function_ !== "function") {
       return () => {
       };
     }
@@ -113,7 +71,7 @@ class Hookable {
       dep = this._deprecatedHooks[name];
       name = dep.to;
     }
-    if (dep && !opts.allowDeprecated) {
+    if (dep && !options.allowDeprecated) {
       let message = dep.message;
       if (!message) {
         message = `${originalName} hook has been deprecated` + (dep.to ? `, please use ${dep.to}` : "");
@@ -127,30 +85,32 @@ class Hookable {
       }
     }
     this._hooks[name] = this._hooks[name] || [];
-    this._hooks[name].push(fn);
+    this._hooks[name].push(function_);
     return () => {
-      if (fn) {
-        this.removeHook(name, fn);
-        fn = null;
+      if (function_) {
+        this.removeHook(name, function_);
+        function_ = void 0;
       }
     };
   }
-  hookOnce(name, fn) {
+  hookOnce(name, function_) {
     let _unreg;
-    let _fn = (...args) => {
-      _unreg();
-      _unreg = null;
-      _fn = null;
-      return fn(...args);
+    let _function = (...arguments_) => {
+      if (typeof _unreg === "function") {
+        _unreg();
+      }
+      _unreg = void 0;
+      _function = void 0;
+      return function_(...arguments_);
     };
-    _unreg = this.hook(name, _fn);
+    _unreg = this.hook(name, _function);
     return _unreg;
   }
-  removeHook(name, fn) {
+  removeHook(name, function_) {
     if (this._hooks[name]) {
-      const idx = this._hooks[name].indexOf(fn);
-      if (idx !== -1) {
-        this._hooks[name].splice(idx, 1);
+      const index = this._hooks[name].indexOf(function_);
+      if (index !== -1) {
+        this._hooks[name].splice(index, 1);
       }
       if (this._hooks[name].length === 0) {
         delete this._hooks[name];
@@ -175,7 +135,9 @@ class Hookable {
     const hooks = flatHooks(configHooks);
     const removeFns = Object.keys(hooks).map((key) => this.hook(key, hooks[key]));
     return () => {
-      removeFns.splice(0, removeFns.length).forEach((unreg) => unreg());
+      for (const unreg of removeFns.splice(0, removeFns.length)) {
+        unreg();
+      }
     };
   }
   removeHooks(configHooks) {
@@ -184,45 +146,45 @@ class Hookable {
       this.removeHook(key, hooks[key]);
     }
   }
-  callHook(name, ...args) {
-    return this.callHookWith(serialCaller, name, ...args);
+  callHook(name, ...arguments_) {
+    return this.callHookWith(serialCaller, name, ...arguments_);
   }
-  callHookParallel(name, ...args) {
-    return this.callHookWith(parallelCaller, name, ...args);
+  callHookParallel(name, ...arguments_) {
+    return this.callHookWith(parallelCaller, name, ...arguments_);
   }
-  callHookWith(caller, name, ...args) {
-    const event = this._before || this._after ? { name, args, context: {} } : void 0;
+  callHookWith(caller, name, ...arguments_) {
+    const event = this._before || this._after ? { name, args: arguments_, context: {} } : void 0;
     if (this._before) {
       callEachWith(this._before, event);
     }
-    const result = caller(this._hooks[name] || [], args);
+    const result = caller(this._hooks[name] || [], arguments_);
     if (result instanceof Promise) {
       return result.finally(() => {
-        if (this._after) {
+        if (this._after && event) {
           callEachWith(this._after, event);
         }
       });
     }
-    if (this._after) {
+    if (this._after && event) {
       callEachWith(this._after, event);
     }
     return result;
   }
-  beforeEach(fn) {
+  beforeEach(function_) {
     this._before = this._before || [];
-    this._before.push(fn);
+    this._before.push(function_);
     return () => {
-      const index = this._before.indexOf(fn);
+      const index = this._before.indexOf(function_);
       if (index !== -1) {
         this._before.splice(index, 1);
       }
     };
   }
-  afterEach(fn) {
+  afterEach(function_) {
     this._after = this._after || [];
-    this._after.push(fn);
+    this._after.push(function_);
     return () => {
-      const index = this._after.indexOf(fn);
+      const index = this._after.indexOf(function_);
       if (index !== -1) {
         this._after.splice(index, 1);
       }
@@ -233,6 +195,52 @@ function createHooks() {
   return new Hookable();
 }
 
+const isBrowser = typeof window !== "undefined";
+function createDebugger(hooks, _options = {}) {
+  const options = {
+    inspect: isBrowser,
+    group: isBrowser,
+    filter: () => true,
+    ..._options
+  };
+  const _filter = options.filter;
+  const filter = typeof _filter === "string" ? (name) => name.startsWith(_filter) : _filter;
+  const _tag = options.tag ? `[${options.tag}] ` : "";
+  const logPrefix = (event) => _tag + event.name + "".padEnd(event._id, "\0");
+  const _idCtr = {};
+  const unsubscribeBefore = hooks.beforeEach((event) => {
+    if (!filter(event.name)) {
+      return;
+    }
+    _idCtr[event.name] = _idCtr[event.name] || 0;
+    event._id = _idCtr[event.name]++;
+    console.time(logPrefix(event));
+  });
+  const unsubscribeAfter = hooks.afterEach((event) => {
+    if (!filter(event.name)) {
+      return;
+    }
+    if (options.group) {
+      console.groupCollapsed(event.name);
+    }
+    if (options.inspect) {
+      console.timeLog(logPrefix(event), event.args);
+    } else {
+      console.timeEnd(logPrefix(event));
+    }
+    if (options.group) {
+      console.groupEnd();
+    }
+    _idCtr[event.name]--;
+  });
+  return {
+    close: () => {
+      unsubscribeBefore();
+      unsubscribeAfter();
+    }
+  };
+}
+
 exports.Hookable = Hookable;
 exports.createDebugger = createDebugger;
 exports.createHooks = createHooks;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-declare type HookCallback = (...args: any) => Promise<void> | void;
+declare type HookCallback = (...arguments_: any) => Promise<void> | void;
 interface Hooks {
     [key: string]: HookCallback;
 }
@@ -34,24 +34,6 @@ declare type NestedHooks<T> = (Partial<StripGeneric<T>> | Partial<OnlyGeneric<T>
 }> & Partial<{
     [key in BareHooks<StripGeneric<T>>]: T[key];
 }>;
-interface CreateDebuggerOptions {
-    /** An optional tag to prefix console logs with */
-    tag?: string;
-    /**
-     * Show hook params to the console output
-     *
-     * Enabled for browsers by default
-     */
-    inspect?: boolean;
-    /**
-     * Use group/groupEnd wrapper around logs happening during a specific hook
-     *
-     * Enabled for browsers by default
-     */
-    group?: boolean;
-    /** Filter which hooks to enable debugger for. Can be a string prefix or fn. */
-    filter?: string | ((event: string) => boolean);
-}
 
 declare type InferCallback<HT, HN extends keyof HT> = HT[HN] extends HookCallback ? HT[HN] : never;
 declare type InferSpyEvent<HT extends Record<string, any>> = {
@@ -68,30 +50,49 @@ declare class Hookable<HooksT = Record<string, HookCallback>, HookNameT extends
     private _deprecatedHooks;
     private _deprecatedMessages;
     constructor();
-    hook<NameT extends HookNameT>(name: NameT, fn: InferCallback<HooksT, NameT>, opts?: {
+    hook<NameT extends HookNameT>(name: NameT, function_: InferCallback<HooksT, NameT>, options?: {
         allowDeprecated?: boolean;
     }): () => void;
-    hookOnce<NameT extends HookNameT>(name: NameT, fn: InferCallback<HooksT, NameT>): () => void;
-    removeHook<NameT extends HookNameT>(name: NameT, fn: InferCallback<HooksT, NameT>): void;
+    hookOnce<NameT extends HookNameT>(name: NameT, function_: InferCallback<HooksT, NameT>): () => void;
+    removeHook<NameT extends HookNameT>(name: NameT, function_: InferCallback<HooksT, NameT>): void;
     deprecateHook<NameT extends HookNameT>(name: NameT, deprecated: HookKeys<HooksT> | DeprecatedHook<HooksT>): void;
     deprecateHooks(deprecatedHooks: Partial<Record<HookNameT, DeprecatedHook<HooksT>>>): void;
     addHooks(configHooks: NestedHooks<HooksT>): () => void;
     removeHooks(configHooks: NestedHooks<HooksT>): void;
-    callHook<NameT extends HookNameT>(name: NameT, ...args: Parameters<InferCallback<HooksT, NameT>>): Promise<any>;
-    callHookParallel<NameT extends HookNameT>(name: NameT, ...args: Parameters<InferCallback<HooksT, NameT>>): Promise<any[]>;
-    callHookWith<NameT extends HookNameT, CallFunction extends (hooks: HookCallback[], args: Parameters<InferCallback<HooksT, NameT>>) => any>(caller: CallFunction, name: NameT, ...args: Parameters<InferCallback<HooksT, NameT>>): ReturnType<CallFunction>;
-    beforeEach(fn: (event: InferSpyEvent<HooksT>) => void): () => void;
-    afterEach(fn: (event: InferSpyEvent<HooksT>) => void): () => void;
+    callHook<NameT extends HookNameT>(name: NameT, ...arguments_: Parameters<InferCallback<HooksT, NameT>>): Promise<any>;
+    callHookParallel<NameT extends HookNameT>(name: NameT, ...arguments_: Parameters<InferCallback<HooksT, NameT>>): Promise<any[]>;
+    callHookWith<NameT extends HookNameT, CallFunction extends (hooks: HookCallback[], arguments_: Parameters<InferCallback<HooksT, NameT>>) => any>(caller: CallFunction, name: NameT, ...arguments_: Parameters<InferCallback<HooksT, NameT>>): ReturnType<CallFunction>;
+    beforeEach(function_: (event: InferSpyEvent<HooksT>) => void): () => void;
+    afterEach(function_: (event: InferSpyEvent<HooksT>) => void): () => void;
 }
 declare function createHooks<T>(): Hookable<T>;
 
 declare function flatHooks<T>(configHooks: NestedHooks<T>, hooks?: T, parentName?: string): T;
 declare function mergeHooks<T>(...hooks: NestedHooks<T>[]): T;
-declare function serial<T>(tasks: T[], fn: (task: T) => Promise<any> | any): Promise<any>;
-declare function serialCaller(hooks: HookCallback[], args?: any[]): Promise<any>;
-declare function parallelCaller(hooks: HookCallback[], args?: any[]): Promise<any[]>;
+declare function serial<T>(tasks: T[], function_: (task: T) => Promise<any> | any): Promise<any>;
+declare function serialCaller(hooks: HookCallback[], arguments_?: any[]): Promise<any>;
+declare function parallelCaller(hooks: HookCallback[], arguments_?: any[]): Promise<any[]>;
+
+interface CreateDebuggerOptions {
+    /** An optional tag to prefix console logs with */
+    tag?: string;
+    /**
+     * Show hook params to the console output
+     *
+     * Enabled for browsers by default
+     */
+    inspect?: boolean;
+    /**
+     * Use group/groupEnd wrapper around logs happening during a specific hook
+     *
+     * Enabled for browsers by default
+     */
+    group?: boolean;
+    /** Filter which hooks to enable debugger for. Can be a string prefix or fn. */
+    filter?: string | ((event: string) => boolean);
+}
 /** Start debugging hook names and timing in console */
-declare function createDebugger(hooks: Hookable, _options?: CreateDebuggerOptions): {
+declare function createDebugger(hooks: Hookable<any>, _options?: CreateDebuggerOptions): {
     /** Stop debugging and remove listeners */
     close: () => void;
 };

package/dist/index.mjs

@@ -24,82 +24,42 @@ function mergeHooks(...hooks) {
   }
   for (const key in finalHooks) {
     if (finalHooks[key].length > 1) {
-      const arr = finalHooks[key];
-      finalHooks[key] = (...args) => serial(arr, (fn) => fn(...args));
+      const array = finalHooks[key];
+      finalHooks[key] = (...arguments_) => serial(array, (function_) => function_(...arguments_));
     } else {
       finalHooks[key] = finalHooks[key][0];
     }
   }
   return finalHooks;
 }
-function serial(tasks, fn) {
-  return tasks.reduce((promise, task) => promise.then(() => fn(task)), Promise.resolve(null));
+function serial(tasks, function_) {
+  return tasks.reduce((promise, task) => promise.then(() => function_(task)), Promise.resolve());
 }
-function serialCaller(hooks, args) {
-  return hooks.reduce((promise, hookFn) => promise.then(() => hookFn.apply(void 0, args)), Promise.resolve(null));
+function serialCaller(hooks, arguments_) {
+  return hooks.reduce((promise, hookFunction) => promise.then(() => hookFunction.apply(void 0, arguments_)), Promise.resolve());
 }
-function parallelCaller(hooks, args) {
-  return Promise.all(hooks.map((hook) => hook.apply(void 0, args)));
+function parallelCaller(hooks, arguments_) {
+  return Promise.all(hooks.map((hook) => hook.apply(void 0, arguments_)));
 }
-function callEachWith(callbacks, arg0) {
-  for (const cb of callbacks) {
-    cb(arg0);
+function callEachWith(callbacks, argument0) {
+  for (const callback of callbacks) {
+    callback(argument0);
   }
 }
-const isBrowser = typeof window !== "undefined";
-function createDebugger(hooks, _options = {}) {
-  const options = {
-    inspect: isBrowser,
-    group: isBrowser,
-    filter: () => true,
-    ..._options
-  };
-  const _filter = options.filter;
-  const filter = typeof _filter === "string" ? (name) => name.startsWith(_filter) : _filter;
-  const logPrefix = options.tag ? `[${options.tag}] ` : "";
-  const unsubscribeBefore = hooks.beforeEach(({ name }) => {
-    if (!filter(name)) {
-      return;
-    }
-    console.time(logPrefix + name);
-  });
-  const unsubscribeAfter = hooks.afterEach(({ name, args }) => {
-    if (!filter(name)) {
-      return;
-    }
-    if (options.group) {
-      console.groupCollapsed(name);
-    }
-    if (options.inspect) {
-      console.timeLog(logPrefix + name, args);
-    } else {
-      console.timeEnd(logPrefix + name);
-    }
-    if (options.group) {
-      console.groupEnd();
-    }
-  });
-  return {
-    close: () => {
-      unsubscribeBefore();
-      unsubscribeAfter();
-    }
-  };
-}
 
 class Hookable {
   constructor() {
     this._hooks = {};
-    this._before = null;
-    this._after = null;
-    this._deprecatedMessages = null;
+    this._before = void 0;
+    this._after = void 0;
+    this._deprecatedMessages = void 0;
     this._deprecatedHooks = {};
     this.hook = this.hook.bind(this);
     this.callHook = this.callHook.bind(this);
     this.callHookWith = this.callHookWith.bind(this);
   }
-  hook(name, fn, opts = {}) {
-    if (!name || typeof fn !== "function") {
+  hook(name, function_, options = {}) {
+    if (!name || typeof function_ !== "function") {
       return () => {
       };
     }
@@ -109,7 +69,7 @@ class Hookable {
       dep = this._deprecatedHooks[name];
       name = dep.to;
     }
-    if (dep && !opts.allowDeprecated) {
+    if (dep && !options.allowDeprecated) {
       let message = dep.message;
       if (!message) {
         message = `${originalName} hook has been deprecated` + (dep.to ? `, please use ${dep.to}` : "");
@@ -123,30 +83,32 @@ class Hookable {
       }
     }
     this._hooks[name] = this._hooks[name] || [];
-    this._hooks[name].push(fn);
+    this._hooks[name].push(function_);
     return () => {
-      if (fn) {
-        this.removeHook(name, fn);
-        fn = null;
+      if (function_) {
+        this.removeHook(name, function_);
+        function_ = void 0;
       }
     };
   }
-  hookOnce(name, fn) {
+  hookOnce(name, function_) {
     let _unreg;
-    let _fn = (...args) => {
-      _unreg();
-      _unreg = null;
-      _fn = null;
-      return fn(...args);
+    let _function = (...arguments_) => {
+      if (typeof _unreg === "function") {
+        _unreg();
+      }
+      _unreg = void 0;
+      _function = void 0;
+      return function_(...arguments_);
     };
-    _unreg = this.hook(name, _fn);
+    _unreg = this.hook(name, _function);
     return _unreg;
   }
-  removeHook(name, fn) {
+  removeHook(name, function_) {
     if (this._hooks[name]) {
-      const idx = this._hooks[name].indexOf(fn);
-      if (idx !== -1) {
-        this._hooks[name].splice(idx, 1);
+      const index = this._hooks[name].indexOf(function_);
+      if (index !== -1) {
+        this._hooks[name].splice(index, 1);
       }
       if (this._hooks[name].length === 0) {
         delete this._hooks[name];
@@ -171,7 +133,9 @@ class Hookable {
     const hooks = flatHooks(configHooks);
     const removeFns = Object.keys(hooks).map((key) => this.hook(key, hooks[key]));
     return () => {
-      removeFns.splice(0, removeFns.length).forEach((unreg) => unreg());
+      for (const unreg of removeFns.splice(0, removeFns.length)) {
+        unreg();
+      }
     };
   }
   removeHooks(configHooks) {
@@ -180,45 +144,45 @@ class Hookable {
       this.removeHook(key, hooks[key]);
     }
   }
-  callHook(name, ...args) {
-    return this.callHookWith(serialCaller, name, ...args);
+  callHook(name, ...arguments_) {
+    return this.callHookWith(serialCaller, name, ...arguments_);
   }
-  callHookParallel(name, ...args) {
-    return this.callHookWith(parallelCaller, name, ...args);
+  callHookParallel(name, ...arguments_) {
+    return this.callHookWith(parallelCaller, name, ...arguments_);
   }
-  callHookWith(caller, name, ...args) {
-    const event = this._before || this._after ? { name, args, context: {} } : void 0;
+  callHookWith(caller, name, ...arguments_) {
+    const event = this._before || this._after ? { name, args: arguments_, context: {} } : void 0;
     if (this._before) {
       callEachWith(this._before, event);
     }
-    const result = caller(this._hooks[name] || [], args);
+    const result = caller(this._hooks[name] || [], arguments_);
     if (result instanceof Promise) {
       return result.finally(() => {
-        if (this._after) {
+        if (this._after && event) {
           callEachWith(this._after, event);
         }
       });
     }
-    if (this._after) {
+    if (this._after && event) {
       callEachWith(this._after, event);
     }
     return result;
   }
-  beforeEach(fn) {
+  beforeEach(function_) {
     this._before = this._before || [];
-    this._before.push(fn);
+    this._before.push(function_);
     return () => {
-      const index = this._before.indexOf(fn);
+      const index = this._before.indexOf(function_);
       if (index !== -1) {
         this._before.splice(index, 1);
       }
     };
   }
-  afterEach(fn) {
+  afterEach(function_) {
     this._after = this._after || [];
-    this._after.push(fn);
+    this._after.push(function_);
     return () => {
-      const index = this._after.indexOf(fn);
+      const index = this._after.indexOf(function_);
       if (index !== -1) {
         this._after.splice(index, 1);
       }
@@ -229,4 +193,50 @@ function createHooks() {
   return new Hookable();
 }
 
+const isBrowser = typeof window !== "undefined";
+function createDebugger(hooks, _options = {}) {
+  const options = {
+    inspect: isBrowser,
+    group: isBrowser,
+    filter: () => true,
+    ..._options
+  };
+  const _filter = options.filter;
+  const filter = typeof _filter === "string" ? (name) => name.startsWith(_filter) : _filter;
+  const _tag = options.tag ? `[${options.tag}] ` : "";
+  const logPrefix = (event) => _tag + event.name + "".padEnd(event._id, "\0");
+  const _idCtr = {};
+  const unsubscribeBefore = hooks.beforeEach((event) => {
+    if (!filter(event.name)) {
+      return;
+    }
+    _idCtr[event.name] = _idCtr[event.name] || 0;
+    event._id = _idCtr[event.name]++;
+    console.time(logPrefix(event));
+  });
+  const unsubscribeAfter = hooks.afterEach((event) => {
+    if (!filter(event.name)) {
+      return;
+    }
+    if (options.group) {
+      console.groupCollapsed(event.name);
+    }
+    if (options.inspect) {
+      console.timeLog(logPrefix(event), event.args);
+    } else {
+      console.timeEnd(logPrefix(event));
+    }
+    if (options.group) {
+      console.groupEnd();
+    }
+    _idCtr[event.name]--;
+  });
+  return {
+    close: () => {
+      unsubscribeBefore();
+      unsubscribeAfter();
+    }
+  };
+}
+
 export { Hookable, createDebugger, createHooks, flatHooks, mergeHooks, parallelCaller, serial, serialCaller };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hookable",
-  "version": "5.4.0",
+  "version": "5.4.2",
   "description": "Awaitable hook system",
   "keywords": [
     "hook",
@@ -13,6 +13,7 @@
   "license": "MIT",
   "exports": {
     "import": "./dist/index.mjs",
+    "types": "./dist/index.d.ts",
     "require": "./dist/index.cjs"
   },
   "main": "./dist/index.cjs",
@@ -22,16 +23,16 @@
     "dist"
   ],
   "devDependencies": {
-    "@nuxtjs/eslint-config-typescript": "latest",
-    "@vitest/coverage-c8": "^0.24.1",
-    "eslint": "latest",
-    "expect-type": "^0.14.2",
-    "standard-version": "latest",
-    "typescript": "latest",
-    "unbuild": "latest",
-    "vitest": "latest"
+    "@vitest/coverage-c8": "^0.25.2",
+    "eslint": "^8.27.0",
+    "eslint-config-unjs": "^0.0.2",
+    "expect-type": "^0.15.0",
+    "standard-version": "^9.5.0",
+    "typescript": "^4.8.4",
+    "unbuild": "^0.9.4",
+    "vitest": "^0.25.2"
   },
-  "packageManager": "pnpm@7.13.4",
+  "packageManager": "pnpm@7.16.0",
   "scripts": {
     "build": "unbuild",
     "dev": "vitest",