hookable 5.1.2 → 5.2.0

package/README.md

@@ -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);
@@ -138,13 +145,36 @@ class Hookable {
     }
   }
   callHook(name, ...args) {
-    return serialCaller(this._hooks[name] || [], args);
+    return this.callHookWith(serialCaller, name, ...args);
   }
   callHookParallel(name, ...args) {
-    return parallelCaller(this._hooks[name] || [], args);
+    return this.callHookWith(parallelCaller, name, ...args);
   }
   callHookWith(caller, name, ...args) {
-    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);
@@ -134,13 +141,36 @@ class Hookable {
     }
   }
   callHook(name, ...args) {
-    return serialCaller(this._hooks[name] || [], args);
+    return this.callHookWith(serialCaller, name, ...args);
   }
   callHookParallel(name, ...args) {
-    return parallelCaller(this._hooks[name] || [], args);
+    return this.callHookWith(parallelCaller, name, ...args);
   }
   callHookWith(caller, name, ...args) {
-    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.2",
+  "version": "5.2.0",
   "description": "Awaitable hook system",
   "keywords": [
     "hook",
@@ -23,22 +23,22 @@
   ],
   "devDependencies": {
     "@nuxtjs/eslint-config-typescript": "latest",
-    "c8": "latest",
-    "codecov": "latest",
+    "@vitest/coverage-c8": "^0.22.1",
     "eslint": "latest",
     "expect-type": "^0.13.0",
-    "vitest": "latest",
     "standard-version": "latest",
     "typescript": "latest",
-    "unbuild": "latest"
+    "unbuild": "latest",
+    "vitest": "latest"
   },
-  "packageManager": "pnpm@7.9.0",
+  "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",
+    "test": "pnpm lint && vitest run --coverage",
     "test:types": "tsc --noEmit"
   }
 }