hookable 0.0.1 → 1.0.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+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
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,271 @@
+# Hookable
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![packagephobia][packagephobia-src]][packagephobia-href]
+[![Github Actions CI][github-actions-ci-src]][github-actions-ci-href]
+[![Codecov][codecov-src]][codecov-href]
+
+> Awaitable hook system
+
+## Install
+
+Using yarn:
+
+```bash
+yarn add hookable
+```
+
+Using npm:
+
+```bash
+npm install hookable
+```
+
+## Usage
+
+**Method A: Create a hookable instance:**
+
+```js
+import { createHooks } from 'hookable'
+
+// Create a hookable instance
+const hooks = createHooks()
+
+// Hook on 'hello'
+hooks.hook('hello', () => { console.log('Hello World' )})
+
+// Call 'hello' hook
+hooks.callHook('hello')
+```
+
+**Method B: Extend your base class from Hookable:**
+
+```js
+import { Hookable } from 'hookable'
+
+export default class FooLib extends Hookable {
+  constructor() {
+    // Call to parent to initialize
+    super()
+    // Initialize Hookable with custom logger
+    // super(consola)
+  }
+
+  async someFunction() {
+    // Call and wait for `hook1` hooks (if any) sequential
+    await this.callHook('hook1')
+  }
+}
+```
+
+**Inside plugins, register for any hook:**
+
+```js
+const lib = new FooLib()
+
+// Register a handler for `hook2`
+lib.hook('hook2', async () => { /* ... */ })
+
+// Register multiply handlers at once
+lib.addHooks({
+  hook1: async () => { /* ... */ },
+  hook2: [ /* can be also an array */ ]
+})
+```
+
+**Unregistering hooks:**
+
+```js
+const lib = new FooLib()
+
+const hook0 = async () => { /* ... */ }
+const hook1 = async () => { /* ... */ }
+const hook2 = async () => { /* ... */ }
+
+// The hook() method returns an "unregister" function
+const unregisterHook0 = lib.hook('hook0', hook0)
+const unregisterHooks1and2 = lib.addHooks({ hook1, hook2 })
+
+/* ... */
+
+unregisterHook0()
+unregisterHooks1and2()
+
+// or
+
+lib.removeHooks({ hook0, hook1 })
+lib.removeHook('hook2', hook2)
+```
+
+**Triggering a hook handler once:**
+
+```js
+const lib = new FooLib()
+
+const unregister = lib.hook('hook0', async () => {
+  // Unregister as soon as the hook is executed
+  unregister()
+
+  /* ... */
+})
+```
+
+
+## Hookable class
+
+### `constructor()`
+
+### `hook (name, fn)`
+
+Register a handler for a specific hook. `fn` must be a function.
+
+Returns an `unregister` function that, when called, will remove the registered handler.
+
+### `hookOnce (name, fn)`
+
+Similar to `hook` but unregisters hook once called.
+
+Returns an `unregister` function that, when called, will remove the registered handler before first call.
+
+### `addHooks(configHooks)`
+
+Flatten and register hooks object.
+
+Example:
+
+```js
+hookable.addHooks({
+  test: {
+    before: () => {},
+    after: () => {}
+  }
+})
+
+```
+
+This registers `test:before` and `test:after` hooks at bulk.
+
+Returns an `unregister` function that, when called, will remove all the registered handlers.
+
+### `async callHook (name, ...args)`
+
+Used by class itself to **sequentially** call handlers of a specific hook.
+
+### `callHookWith (name, callerFn)`
+
+If you need custom control over how hooks are called, you can provide a custom function that will receive an array of handlers of a specific hook.
+
+`callerFn` if a callback function that accepts two arguments, `hooks` and `args`:
+- `hooks`: Array of user hooks to be called
+- `args`: Array of arguments that should be passed each time calling a hook
+
+### `deprecateHook (old, name)`
+
+Deprecate hook called `old` in favor of `name` hook.
+
+### `deprecateHooks (deprecatedHooks)`
+
+Deprecate all hooks from an object (keys are old and values or newer ones).
+
+### `removeHook (name, fn)`
+
+Remove a particular hook handler, if the `fn` handler is present.
+
+### `removeHooks (configHooks)`
+
+Remove multiple hook handlers.
+
+Example:
+
+```js
+const handler = async () => { /* ... */ }
+
+hookable.hook('test:before', handler)
+hookable.addHooks({ test: { after: handler } })
+
+// ...
+
+hookable.removeHooks({
+  test: {
+    before: handler,
+    after: handler
+  }
+})
+```
+
+### `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')
+```
+
+### `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`
+
+- Type checking improved. You can use `Hookable<T>` or `createHooks<T>()` to provide types interface **([c2e1e22](https://github.com/unjs/hookable/commit/c2e1e223d16e7bf87117cd8d72ad3ba211a333d8))**
+- We no longer provide an IE11 compatible umd build. Instead, you should use an ESM-aware bundler such as webpack or rollup to transpile if needed.
+- Logger param is dropped. We use `console.warn` by default for deprecated hooks.
+- Package now uses named exports. You should import `{ Hookable }` instead of  `Hookable` or use new `createHooks` util
+- `mergeHooks` util is exported standalone. You should replace `Hookable.mergeHooks` and `this.mergeHooks` with new `{ mergeHooks }` export
+- In versions < 5.0.0 when using `callHook` if an error happened by one of the hook callbacks, we was handling errors globally and call global `error` hook + `console.error` instead and resolve `callHook` promise!  This sometimes makes confusing behavior when we think code worked but it didn't. v5 introduced a breaking change that when a hook throws an error, `callHook` also rejects instead of a global `error` event. This means you should be careful to handle all errors when using `callHook` now.
+
+## Credits
+
+Extracted from [Nuxt](https://github.com/nuxt/nuxt.js) hooks system originally introduced by [Sébastien Chopin](https://github.com/Atinux)
+
+Thanks to [Joe Paice](https://github.com/RGBboy) for donating [hookable](https://www.npmjs.com/package/hookable) package name.
+
+## License
+
+MIT - Made with 💖
+
+<!-- Badges -->
+[npm-version-src]: https://flat.badgen.net/npm/dt/hookable
+[npm-version-href]: https://npmjs.com/package/hookable
+
+[npm-downloads-src]: https://flat.badgen.net/npm/v/hookable
+[npm-downloads-href]: https://npmjs.com/package/hookable
+
+[github-actions-ci-src]: https://flat.badgen.net/github/checks/unjs/hookable/main
+[github-actions-ci-href]: https://github.com/unjs/hookable/actions
+
+[codecov-src]: https://flat.badgen.net/codecov/c/github/unjs/hookable
+[codecov-href]: https://codecov.io/gh/unjs/hookable
+
+[packagephobia-src]: https://flat.badgen.net/packagephobia/install/hookable
+[packagephobia-href]: https://packagephobia.now.sh/result?p=hookable

package/dist/index.cjs

@@ -0,0 +1,251 @@
+'use strict';
+
+function flatHooks(configHooks, hooks = {}, parentName) {
+  for (const key in configHooks) {
+    const subHook = configHooks[key];
+    const name = parentName ? `${parentName}:${key}` : key;
+    if (typeof subHook === "object" && subHook !== null) {
+      flatHooks(subHook, hooks, name);
+    } else if (typeof subHook === "function") {
+      hooks[name] = subHook;
+    }
+  }
+  return hooks;
+}
+function mergeHooks(...hooks) {
+  const finalHooks = {};
+  for (const hook of hooks) {
+    const flatenHook = flatHooks(hook);
+    for (const key in flatenHook) {
+      if (finalHooks[key]) {
+        finalHooks[key].push(flatenHook[key]);
+      } else {
+        finalHooks[key] = [flatenHook[key]];
+      }
+    }
+  }
+  for (const key in finalHooks) {
+    if (finalHooks[key].length > 1) {
+      const array = finalHooks[key];
+      finalHooks[key] = (...arguments_) => serial(array, (function_) => function_(...arguments_));
+    } else {
+      finalHooks[key] = finalHooks[key][0];
+    }
+  }
+  return finalHooks;
+}
+function serial(tasks, function_) {
+  return tasks.reduce((promise, task) => promise.then(() => function_(task)), Promise.resolve());
+}
+function serialCaller(hooks, arguments_) {
+  return hooks.reduce((promise, hookFunction) => promise.then(() => hookFunction.apply(void 0, arguments_)), Promise.resolve());
+}
+function parallelCaller(hooks, arguments_) {
+  return Promise.all(hooks.map((hook) => hook.apply(void 0, arguments_)));
+}
+function callEachWith(callbacks, argument0) {
+  for (const callback of callbacks) {
+    callback(argument0);
+  }
+}
+
+class Hookable {
+  constructor() {
+    this._hooks = {};
+    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, function_, options = {}) {
+    if (!name || typeof function_ !== "function") {
+      return () => {
+      };
+    }
+    const originalName = name;
+    let dep;
+    while (this._deprecatedHooks[name]) {
+      dep = this._deprecatedHooks[name];
+      name = dep.to;
+    }
+    if (dep && !options.allowDeprecated) {
+      let message = dep.message;
+      if (!message) {
+        message = `${originalName} hook has been deprecated` + (dep.to ? `, please use ${dep.to}` : "");
+      }
+      if (!this._deprecatedMessages) {
+        this._deprecatedMessages = /* @__PURE__ */ new Set();
+      }
+      if (!this._deprecatedMessages.has(message)) {
+        console.warn(message);
+        this._deprecatedMessages.add(message);
+      }
+    }
+    this._hooks[name] = this._hooks[name] || [];
+    this._hooks[name].push(function_);
+    return () => {
+      if (function_) {
+        this.removeHook(name, function_);
+        function_ = void 0;
+      }
+    };
+  }
+  hookOnce(name, function_) {
+    let _unreg;
+    let _function = (...arguments_) => {
+      if (typeof _unreg === "function") {
+        _unreg();
+      }
+      _unreg = void 0;
+      _function = void 0;
+      return function_(...arguments_);
+    };
+    _unreg = this.hook(name, _function);
+    return _unreg;
+  }
+  removeHook(name, function_) {
+    if (this._hooks[name]) {
+      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];
+      }
+    }
+  }
+  deprecateHook(name, deprecated) {
+    this._deprecatedHooks[name] = typeof deprecated === "string" ? { to: deprecated } : 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);
+    const removeFns = Object.keys(hooks).map((key) => this.hook(key, hooks[key]));
+    return () => {
+      for (const unreg of removeFns.splice(0, removeFns.length)) {
+        unreg();
+      }
+    };
+  }
+  removeHooks(configHooks) {
+    const hooks = flatHooks(configHooks);
+    for (const key in hooks) {
+      this.removeHook(key, hooks[key]);
+    }
+  }
+  callHook(name, ...arguments_) {
+    return this.callHookWith(serialCaller, name, ...arguments_);
+  }
+  callHookParallel(name, ...arguments_) {
+    return this.callHookWith(parallelCaller, name, ...arguments_);
+  }
+  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] || [], arguments_);
+    if (result instanceof Promise) {
+      return result.finally(() => {
+        if (this._after && event) {
+          callEachWith(this._after, event);
+        }
+      });
+    }
+    if (this._after && event) {
+      callEachWith(this._after, event);
+    }
+    return result;
+  }
+  beforeEach(function_) {
+    this._before = this._before || [];
+    this._before.push(function_);
+    return () => {
+      const index = this._before.indexOf(function_);
+      if (index !== -1) {
+        this._before.splice(index, 1);
+      }
+    };
+  }
+  afterEach(function_) {
+    this._after = this._after || [];
+    this._after.push(function_);
+    return () => {
+      const index = this._after.indexOf(function_);
+      if (index !== -1) {
+        this._after.splice(index, 1);
+      }
+    };
+  }
+}
+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;
+exports.flatHooks = flatHooks;
+exports.mergeHooks = mergeHooks;
+exports.parallelCaller = parallelCaller;
+exports.serial = serial;
+exports.serialCaller = serialCaller;

package/dist/index.d.ts

@@ -0,0 +1,100 @@
+declare type HookCallback = (...arguments_: any) => Promise<void> | void;
+interface Hooks {
+    [key: string]: HookCallback;
+}
+declare type HookKeys<T> = keyof T & string;
+declare type DeprecatedHook<T> = {
+    message?: string;
+    to: HookKeys<T>;
+};
+declare type DeprecatedHooks<T> = {
+    [name in HookKeys<T>]: DeprecatedHook<T>;
+};
+declare type ValueOf<C> = C extends Record<any, any> ? C[keyof C] : never;
+declare type Strings<T> = Exclude<keyof T, number | symbol>;
+declare type KnownKeys<T> = keyof {
+    [K in keyof T as string extends K ? never : number extends K ? never : K]: never;
+};
+declare type StripGeneric<T> = Pick<T, KnownKeys<T> extends keyof T ? KnownKeys<T> : never>;
+declare type OnlyGeneric<T> = Omit<T, KnownKeys<T> extends keyof T ? KnownKeys<T> : never>;
+declare type Namespaces<T> = ValueOf<{
+    [key in Strings<T>]: key extends `${infer Namespace}:${string}` ? Namespace : never;
+}>;
+declare type BareHooks<T> = ValueOf<{
+    [key in Strings<T>]: key extends `${string}:${string}` ? never : key;
+}>;
+declare type HooksInNamespace<T, Namespace extends string> = ValueOf<{
+    [key in Strings<T>]: key extends `${Namespace}:${infer HookName}` ? HookName : never;
+}>;
+declare type WithoutNamespace<T, Namespace extends string> = {
+    [key in HooksInNamespace<T, Namespace>]: `${Namespace}:${key}` extends keyof T ? T[`${Namespace}:${key}`] : never;
+};
+declare type NestedHooks<T> = (Partial<StripGeneric<T>> | Partial<OnlyGeneric<T>>) & Partial<{
+    [key in Namespaces<StripGeneric<T>>]: NestedHooks<WithoutNamespace<T, key>>;
+}> & Partial<{
+    [key in BareHooks<StripGeneric<T>>]: T[key];
+}>;
+
+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;
+    private _deprecatedMessages;
+    constructor();
+    hook<NameT extends HookNameT>(name: NameT, function_: InferCallback<HooksT, NameT>, options?: {
+        allowDeprecated?: boolean;
+    }): () => 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, ...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[], 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<any>, _options?: CreateDebuggerOptions): {
+    /** Stop debugging and remove listeners */
+    close: () => void;
+};
+
+export { CreateDebuggerOptions, DeprecatedHook, DeprecatedHooks, HookCallback, HookKeys, Hookable, Hooks, NestedHooks, createDebugger, createHooks, flatHooks, mergeHooks, parallelCaller, serial, serialCaller };

package/dist/index.mjs

@@ -0,0 +1,242 @@
+function flatHooks(configHooks, hooks = {}, parentName) {
+  for (const key in configHooks) {
+    const subHook = configHooks[key];
+    const name = parentName ? `${parentName}:${key}` : key;
+    if (typeof subHook === "object" && subHook !== null) {
+      flatHooks(subHook, hooks, name);
+    } else if (typeof subHook === "function") {
+      hooks[name] = subHook;
+    }
+  }
+  return hooks;
+}
+function mergeHooks(...hooks) {
+  const finalHooks = {};
+  for (const hook of hooks) {
+    const flatenHook = flatHooks(hook);
+    for (const key in flatenHook) {
+      if (finalHooks[key]) {
+        finalHooks[key].push(flatenHook[key]);
+      } else {
+        finalHooks[key] = [flatenHook[key]];
+      }
+    }
+  }
+  for (const key in finalHooks) {
+    if (finalHooks[key].length > 1) {
+      const array = finalHooks[key];
+      finalHooks[key] = (...arguments_) => serial(array, (function_) => function_(...arguments_));
+    } else {
+      finalHooks[key] = finalHooks[key][0];
+    }
+  }
+  return finalHooks;
+}
+function serial(tasks, function_) {
+  return tasks.reduce((promise, task) => promise.then(() => function_(task)), Promise.resolve());
+}
+function serialCaller(hooks, arguments_) {
+  return hooks.reduce((promise, hookFunction) => promise.then(() => hookFunction.apply(void 0, arguments_)), Promise.resolve());
+}
+function parallelCaller(hooks, arguments_) {
+  return Promise.all(hooks.map((hook) => hook.apply(void 0, arguments_)));
+}
+function callEachWith(callbacks, argument0) {
+  for (const callback of callbacks) {
+    callback(argument0);
+  }
+}
+
+class Hookable {
+  constructor() {
+    this._hooks = {};
+    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, function_, options = {}) {
+    if (!name || typeof function_ !== "function") {
+      return () => {
+      };
+    }
+    const originalName = name;
+    let dep;
+    while (this._deprecatedHooks[name]) {
+      dep = this._deprecatedHooks[name];
+      name = dep.to;
+    }
+    if (dep && !options.allowDeprecated) {
+      let message = dep.message;
+      if (!message) {
+        message = `${originalName} hook has been deprecated` + (dep.to ? `, please use ${dep.to}` : "");
+      }
+      if (!this._deprecatedMessages) {
+        this._deprecatedMessages = /* @__PURE__ */ new Set();
+      }
+      if (!this._deprecatedMessages.has(message)) {
+        console.warn(message);
+        this._deprecatedMessages.add(message);
+      }
+    }
+    this._hooks[name] = this._hooks[name] || [];
+    this._hooks[name].push(function_);
+    return () => {
+      if (function_) {
+        this.removeHook(name, function_);
+        function_ = void 0;
+      }
+    };
+  }
+  hookOnce(name, function_) {
+    let _unreg;
+    let _function = (...arguments_) => {
+      if (typeof _unreg === "function") {
+        _unreg();
+      }
+      _unreg = void 0;
+      _function = void 0;
+      return function_(...arguments_);
+    };
+    _unreg = this.hook(name, _function);
+    return _unreg;
+  }
+  removeHook(name, function_) {
+    if (this._hooks[name]) {
+      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];
+      }
+    }
+  }
+  deprecateHook(name, deprecated) {
+    this._deprecatedHooks[name] = typeof deprecated === "string" ? { to: deprecated } : 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);
+    const removeFns = Object.keys(hooks).map((key) => this.hook(key, hooks[key]));
+    return () => {
+      for (const unreg of removeFns.splice(0, removeFns.length)) {
+        unreg();
+      }
+    };
+  }
+  removeHooks(configHooks) {
+    const hooks = flatHooks(configHooks);
+    for (const key in hooks) {
+      this.removeHook(key, hooks[key]);
+    }
+  }
+  callHook(name, ...arguments_) {
+    return this.callHookWith(serialCaller, name, ...arguments_);
+  }
+  callHookParallel(name, ...arguments_) {
+    return this.callHookWith(parallelCaller, name, ...arguments_);
+  }
+  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] || [], arguments_);
+    if (result instanceof Promise) {
+      return result.finally(() => {
+        if (this._after && event) {
+          callEachWith(this._after, event);
+        }
+      });
+    }
+    if (this._after && event) {
+      callEachWith(this._after, event);
+    }
+    return result;
+  }
+  beforeEach(function_) {
+    this._before = this._before || [];
+    this._before.push(function_);
+    return () => {
+      const index = this._before.indexOf(function_);
+      if (index !== -1) {
+        this._before.splice(index, 1);
+      }
+    };
+  }
+  afterEach(function_) {
+    this._after = this._after || [];
+    this._after.push(function_);
+    return () => {
+      const index = this._after.indexOf(function_);
+      if (index !== -1) {
+        this._after.splice(index, 1);
+      }
+    };
+  }
+}
+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,22 +1,45 @@
 {
   "name": "hookable",
-  "version": "0.0.1",
-  "description": "Enable hookable functions on an object.",
-  "keywords": ["hook", "plugin"],
-  "author": "RGBboy <me@rgbboy.com>",
-  "main": "index.js",
-  "engines": {
-    "node": "0.8.x"
+  "version": "1.0.0",
+  "description": "Awaitable hook system",
+  "keywords": [
+    "hook",
+    "hookable",
+    "plugin",
+    "tapable",
+    "tappable"
+  ],
+  "repository": "unjs/hookable",
+  "license": "MIT",
+  "exports": {
+    "import": "./dist/index.mjs",
+    "types": "./dist/index.d.ts",
+    "require": "./dist/index.cjs"
   },
-  "dependencies": {
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "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"
   },
   "devDependencies": {
-    "mocha": "1.5.x",
-    "should": "1.2.x"
+    "@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"
   },
-  "scripts" : {
-    "test" : "make test",
-    "unit" : "make unit",
-    "spec" : "make spec"
-  }
-}
+  "packageManager": "pnpm@7.16.0"
+}

package/.npmignore

@@ -1,7 +0,0 @@
-.git*
-.travis*
-Makefile
-test/
-example/
-.DS_Store
-*.tmproj

package/index.js

@@ -1,2 +0,0 @@
-
-exports = module.exports = require('./lib/hookable');

package/lib/hookable.js

@@ -1,29 +0,0 @@
-/*!
- * hookable
- * Copyright(c) 2012 RGBboy <me@rgbboy.com>
- * MIT Licensed
- */
-
-/**
-* Module Dependencies
-*/
-
-
-
-/**
- * Add hookable functionality to component instance.
- *
- * @param {Object} that
- * @api public
- */
-exports = module.exports = function (that) {
-
-  return that;
-
-};
-
-/**
-* Library version.
-*/
-
-exports.version = '0.0.1';

package/readme.md

@@ -1,19 +0,0 @@
-# Hookable
-
-  Enable hookable functions on an object.
-
-  [![Build Status](https://secure.travis-ci.org/RGBboy/hookable.png)](http://travis-ci.org/RGBboy/hookable)
-
-## Installation
-
-  Works with Express 3.0.x
-
-    $ npm install git://github.com/RGBboy/hookable.git
-
-## Usage
-
-  **Write this**
-
-## To Do
-
-  * Write tests