hookable 5.1.0 → 5.2.0

package/README.md

@@ -44,7 +44,7 @@ hooks.callHook('hello')
 ```js
 import { Hookable } from 'hookable'
 
-export default class Foo extends Hookable {
+export default class FooLib extends Hookable {
   constructor() {
     // Call to parent to initialize
     super()
@@ -62,7 +62,7 @@ export default class Foo extends Hookable {
 **Inside plugins, register for any hook:**
 
 ```js
-const lib = newFooLib()
+const lib = new FooLib()
 
 // Register a handler for `hook2`
 lib.hook('hook2', async () => { /* ... */ })
@@ -77,7 +77,7 @@ lib.addHooks({
 **Unregistering hooks:**
 
 ```js
-const lib = newFooLib()
+const lib = new FooLib()
 
 const hook0 = async () => { /* ... */ }
 const hook1 = async () => { /* ... */ }
@@ -101,7 +101,7 @@ lib.removeHook('hook2', hook2)
 **Triggering a hook handler once:**
 
 ```js
-const lib = newFooLib()
+const lib = new FooLib()
 
 const unregister = lib.hook('hook0', async () => {
   // Unregister as soon as the hook is executed
@@ -194,6 +194,32 @@ hookable.removeHooks({
 })
 ```
 
+### `beforeEach (syncCallback)`
+
+Registers a (sync) callback to be called before each hook is being called.
+
+```js
+hookable.beforeEach((event) => { console.log(`${event.name} hook is being called with ${event.args}`)})
+hookable.hook('test', () => { console.log('running test hook') })
+
+// test hook is being called with []
+// running test hook
+await hookable.callHook('test')
+```
+
+### `afterEach (syncCallback)`
+
+Registers a (sync) callback to be called after each hook is being called.
+
+```js
+hookable.afterEach((event) => { console.log(`${event.name} hook called with ${event.args}`)})
+hookable.hook('test', () => { console.log('running test hook') })
+
+// running test hook
+// test hook called with []
+await hookable.callHook('test')
+```
+
 ## Migration
 
 ### From `4.x` to `5.x`

package/dist/index.cjs

@@ -45,10 +45,17 @@ function serialCaller(hooks, args) {
 function parallelCaller(hooks, args) {
   return Promise.all(hooks.map((hook) => hook.apply(void 0, args)));
 }
+function callEachWith(callbacks, arg0) {
+  for (const cb of callbacks) {
+    cb(arg0);
+  }
+}
 
 class Hookable {
   constructor() {
     this._hooks = {};
+    this._before = null;
+    this._after = null;
     this._deprecatedHooks = {};
     this.hook = this.hook.bind(this);
     this.callHook = this.callHook.bind(this);
@@ -72,7 +79,9 @@ class Hookable {
     }
     if (deprecatedHookObj) {
       if (!deprecatedHookObj.message) {
-        console.warn(`${originalName} hook has been deprecated` + (deprecatedHookObj.to ? `, please use ${deprecatedHookObj.to}` : ""));
+        console.warn(
+          `${originalName} hook has been deprecated` + (deprecatedHookObj.to ? `, please use ${deprecatedHookObj.to}` : "")
+        );
       } else {
         console.warn(deprecatedHookObj.message);
       }
@@ -110,9 +119,17 @@ class Hookable {
   }
   deprecateHook(name, deprecated) {
     this._deprecatedHooks[name] = deprecated;
+    const _hooks = this._hooks[name] || [];
+    this._hooks[name] = void 0;
+    for (const hook of _hooks) {
+      this.hook(name, hook);
+    }
   }
   deprecateHooks(deprecatedHooks) {
     Object.assign(this._deprecatedHooks, deprecatedHooks);
+    for (const name in deprecatedHooks) {
+      this.deprecateHook(name, deprecatedHooks[name]);
+    }
   }
   addHooks(configHooks) {
     const hooks = flatHooks(configHooks);
@@ -128,19 +145,36 @@ class Hookable {
     }
   }
   callHook(name, ...args) {
-    if (this._hooks[name]) {
-      return serialCaller(this._hooks[name], args);
-    }
+    return this.callHookWith(serialCaller, name, ...args);
   }
   callHookParallel(name, ...args) {
-    if (this._hooks[name]) {
-      return parallelCaller(this._hooks[name], args);
-    }
+    return this.callHookWith(parallelCaller, name, ...args);
   }
   callHookWith(caller, name, ...args) {
-    if (this._hooks[name]) {
-      return caller(this._hooks[name], args);
+    const event = this._before || this._after ? { name, args, context: {} } : void 0;
+    if (this._before) {
+      callEachWith(this._before, event);
+    }
+    const result = caller(this._hooks[name] || [], args);
+    if (result instanceof Promise) {
+      return result.finally(() => {
+        if (this._after) {
+          callEachWith(this._after, event);
+        }
+      });
     }
+    if (this._after) {
+      callEachWith(this._after, event);
+    }
+    return result;
+  }
+  beforeEach(fn) {
+    this._before = this._before || [];
+    this._before.push(fn);
+  }
+  afterEach(fn) {
+    this._after = this._after || [];
+    this._after.push(fn);
   }
 }
 function createHooks() {

package/dist/index.d.ts

@@ -36,20 +36,31 @@ declare type NestedHooks<T> = (Partial<StripGeneric<T>> | Partial<OnlyGeneric<T>
 }>;
 
 declare type InferCallback<HT, HN extends keyof HT> = HT[HN] extends HookCallback ? HT[HN] : never;
+declare type InferSpyEvent<HT extends Record<string, any>> = {
+    [key in keyof HT]: {
+        name: key;
+        args: Parameters<HT[key]>;
+        context: Record<string, any>;
+    };
+}[keyof HT];
 declare class Hookable<HooksT = Record<string, HookCallback>, HookNameT extends HookKeys<HooksT> = HookKeys<HooksT>> {
     private _hooks;
+    private _before;
+    private _after;
     private _deprecatedHooks;
     constructor();
     hook<NameT extends HookNameT>(name: NameT, fn: InferCallback<HooksT, NameT>): () => void;
     hookOnce<NameT extends HookNameT>(name: NameT, fn: InferCallback<HooksT, NameT>): () => void;
     removeHook<NameT extends HookNameT>(name: NameT, fn: InferCallback<HooksT, NameT>): void;
     deprecateHook<NameT extends HookNameT>(name: NameT, deprecated: DeprecatedHook<HooksT>): void;
-    deprecateHooks(deprecatedHooks: Record<HookNameT, 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[]>;
+    callHook<NameT extends HookNameT>(name: NameT, ...args: Parameters<InferCallback<HooksT, NameT>>): void | Promise<any>;
+    callHookParallel<NameT extends HookNameT>(name: NameT, ...args: Parameters<InferCallback<HooksT, NameT>>): void | 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>>): void | ReturnType<CallFunction>;
+    beforeEach(fn: (event: InferSpyEvent<HooksT>) => void): void;
+    afterEach(fn: (event: InferSpyEvent<HooksT>) => void): void;
 }
 declare function createHooks<T>(): Hookable<T>;
 

package/dist/index.mjs

@@ -41,10 +41,17 @@ function serialCaller(hooks, args) {
 function parallelCaller(hooks, args) {
   return Promise.all(hooks.map((hook) => hook.apply(void 0, args)));
 }
+function callEachWith(callbacks, arg0) {
+  for (const cb of callbacks) {
+    cb(arg0);
+  }
+}
 
 class Hookable {
   constructor() {
     this._hooks = {};
+    this._before = null;
+    this._after = null;
     this._deprecatedHooks = {};
     this.hook = this.hook.bind(this);
     this.callHook = this.callHook.bind(this);
@@ -68,7 +75,9 @@ class Hookable {
     }
     if (deprecatedHookObj) {
       if (!deprecatedHookObj.message) {
-        console.warn(`${originalName} hook has been deprecated` + (deprecatedHookObj.to ? `, please use ${deprecatedHookObj.to}` : ""));
+        console.warn(
+          `${originalName} hook has been deprecated` + (deprecatedHookObj.to ? `, please use ${deprecatedHookObj.to}` : "")
+        );
       } else {
         console.warn(deprecatedHookObj.message);
       }
@@ -106,9 +115,17 @@ class Hookable {
   }
   deprecateHook(name, deprecated) {
     this._deprecatedHooks[name] = deprecated;
+    const _hooks = this._hooks[name] || [];
+    this._hooks[name] = void 0;
+    for (const hook of _hooks) {
+      this.hook(name, hook);
+    }
   }
   deprecateHooks(deprecatedHooks) {
     Object.assign(this._deprecatedHooks, deprecatedHooks);
+    for (const name in deprecatedHooks) {
+      this.deprecateHook(name, deprecatedHooks[name]);
+    }
   }
   addHooks(configHooks) {
     const hooks = flatHooks(configHooks);
@@ -124,19 +141,36 @@ class Hookable {
     }
   }
   callHook(name, ...args) {
-    if (this._hooks[name]) {
-      return serialCaller(this._hooks[name], args);
-    }
+    return this.callHookWith(serialCaller, name, ...args);
   }
   callHookParallel(name, ...args) {
-    if (this._hooks[name]) {
-      return parallelCaller(this._hooks[name], args);
-    }
+    return this.callHookWith(parallelCaller, name, ...args);
   }
   callHookWith(caller, name, ...args) {
-    if (this._hooks[name]) {
-      return caller(this._hooks[name], args);
+    const event = this._before || this._after ? { name, args, context: {} } : void 0;
+    if (this._before) {
+      callEachWith(this._before, event);
+    }
+    const result = caller(this._hooks[name] || [], args);
+    if (result instanceof Promise) {
+      return result.finally(() => {
+        if (this._after) {
+          callEachWith(this._after, event);
+        }
+      });
     }
+    if (this._after) {
+      callEachWith(this._after, event);
+    }
+    return result;
+  }
+  beforeEach(fn) {
+    this._before = this._before || [];
+    this._before.push(fn);
+  }
+  afterEach(fn) {
+    this._after = this._after || [];
+    this._after.push(fn);
   }
 }
 function createHooks() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hookable",
-  "version": "5.1.0",
+  "version": "5.2.0",
   "description": "Awaitable hook system",
   "keywords": [
     "hook",
@@ -21,24 +21,24 @@
   "files": [
     "dist"
   ],
-  "scripts": {
-    "build": "unbuild",
-    "lint": "eslint --ext .ts src",
-    "prepublish": "yarn build",
-    "release": "yarn test && yarn build && standard-version && git push --follow-tags && npm publish",
-    "test": "yarn lint && yarn jest"
-  },
   "devDependencies": {
     "@nuxtjs/eslint-config-typescript": "latest",
-    "@types/jest": "latest",
-    "babel-jest": "latest",
-    "codecov": "latest",
+    "@vitest/coverage-c8": "^0.22.1",
     "eslint": "latest",
-    "expect-type": "^0.12.0",
-    "jest": "latest",
+    "expect-type": "^0.13.0",
     "standard-version": "latest",
-    "ts-jest": "latest",
     "typescript": "latest",
-    "unbuild": "latest"
+    "unbuild": "latest",
+    "vitest": "latest"
+  },
+  "packageManager": "pnpm@7.9.4",
+  "scripts": {
+    "build": "unbuild",
+    "dev": "vitest",
+    "lint": "eslint --ext .ts src",
+    "prepublish": "pnpm build",
+    "release": "pnpm test && pnpm build && standard-version && git push --follow-tags && pnpm publish",
+    "test": "pnpm lint && vitest run --coverage",
+    "test:types": "tsc --noEmit"
   }
-}
+}