hookable 5.3.0 → 5.4.0

package/README.md

@@ -220,6 +220,19 @@ hookable.hook('test', () => { console.log('running test hook') })
 await hookable.callHook('test')
 ```
 
+### `createDebugger`
+
+Automatically logs each hook that is called and how long it takes to run.
+
+```js
+const debug = hookable.createDebugger(hooks, { tag: 'something' })
+
+hooks.callHook('some-hook', 'some-arg')
+// [something] some-hook: 0.21ms
+
+debug.close()
+```
+
 ## Migration
 
 ### From `4.x` to `5.x`

package/dist/index.cjs

@@ -50,6 +50,46 @@ function callEachWith(callbacks, arg0) {
     cb(arg0);
   }
 }
+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() {
@@ -171,10 +211,22 @@ class Hookable {
   beforeEach(fn) {
     this._before = this._before || [];
     this._before.push(fn);
+    return () => {
+      const index = this._before.indexOf(fn);
+      if (index !== -1) {
+        this._before.splice(index, 1);
+      }
+    };
   }
   afterEach(fn) {
     this._after = this._after || [];
     this._after.push(fn);
+    return () => {
+      const index = this._after.indexOf(fn);
+      if (index !== -1) {
+        this._after.splice(index, 1);
+      }
+    };
   }
 }
 function createHooks() {
@@ -182,6 +234,7 @@ function createHooks() {
 }
 
 exports.Hookable = Hookable;
+exports.createDebugger = createDebugger;
 exports.createHooks = createHooks;
 exports.flatHooks = flatHooks;
 exports.mergeHooks = mergeHooks;

package/dist/index.d.ts

@@ -34,6 +34,24 @@ 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>> = {
@@ -62,8 +80,8 @@ declare class Hookable<HooksT = Record<string, HookCallback>, HookNameT extends
     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;
+    beforeEach(fn: (event: InferSpyEvent<HooksT>) => void): () => void;
+    afterEach(fn: (event: InferSpyEvent<HooksT>) => void): () => void;
 }
 declare function createHooks<T>(): Hookable<T>;
 
@@ -72,5 +90,10 @@ 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[]>;
+/** Start debugging hook names and timing in console */
+declare function createDebugger(hooks: Hookable, _options?: CreateDebuggerOptions): {
+    /** Stop debugging and remove listeners */
+    close: () => void;
+};
 
-export { DeprecatedHook, DeprecatedHooks, HookCallback, HookKeys, Hookable, Hooks, NestedHooks, createHooks, flatHooks, mergeHooks, parallelCaller, serial, serialCaller };
+export { CreateDebuggerOptions, DeprecatedHook, DeprecatedHooks, HookCallback, HookKeys, Hookable, Hooks, NestedHooks, createDebugger, createHooks, flatHooks, mergeHooks, parallelCaller, serial, serialCaller };

package/dist/index.mjs

@@ -46,6 +46,46 @@ function callEachWith(callbacks, arg0) {
     cb(arg0);
   }
 }
+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() {
@@ -167,14 +207,26 @@ class Hookable {
   beforeEach(fn) {
     this._before = this._before || [];
     this._before.push(fn);
+    return () => {
+      const index = this._before.indexOf(fn);
+      if (index !== -1) {
+        this._before.splice(index, 1);
+      }
+    };
   }
   afterEach(fn) {
     this._after = this._after || [];
     this._after.push(fn);
+    return () => {
+      const index = this._after.indexOf(fn);
+      if (index !== -1) {
+        this._after.splice(index, 1);
+      }
+    };
   }
 }
 function createHooks() {
   return new Hookable();
 }
 
-export { Hookable, createHooks, flatHooks, mergeHooks, parallelCaller, serial, serialCaller };
+export { Hookable, createDebugger, createHooks, flatHooks, mergeHooks, parallelCaller, serial, serialCaller };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hookable",
-  "version": "5.3.0",
+  "version": "5.4.0",
   "description": "Awaitable hook system",
   "keywords": [
     "hook",
@@ -23,15 +23,15 @@
   ],
   "devDependencies": {
     "@nuxtjs/eslint-config-typescript": "latest",
-    "@vitest/coverage-c8": "^0.22.1",
+    "@vitest/coverage-c8": "^0.24.1",
     "eslint": "latest",
-    "expect-type": "^0.13.0",
+    "expect-type": "^0.14.2",
     "standard-version": "latest",
     "typescript": "latest",
     "unbuild": "latest",
     "vitest": "latest"
   },
-  "packageManager": "pnpm@7.9.4",
+  "packageManager": "pnpm@7.13.4",
   "scripts": {
     "build": "unbuild",
     "dev": "vitest",