### Install Hookable

Source: https://github.com/unjs/hookable/blob/main/README.md

Install the hookable package using npx and nypm.

```bash
npx nypm i hookable
```

--------------------------------

### Create Hookable Instance

Source: https://github.com/unjs/hookable/blob/main/README.md

Demonstrates creating a basic hookable instance, registering a hook, and calling it.

```javascript
import { Hookable } from "hookable";

// Create a hookable instance
const hooks = new Hookable();

// Hook on 'hello'
hooks.hook("hello", () => {
  console.log("Hello World");
});

// Call 'hello' hook
hooks.callHook("hello");
```

--------------------------------

### Register Hooks in Plugins

Source: https://github.com/unjs/hookable/blob/main/README.md

Illustrates registering single and multiple hooks, including an array of handlers for a single hook name.

```javascript
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 */
  ],
});
```

--------------------------------

### Extend Class with Hookable

Source: https://github.com/unjs/hookable/blob/main/README.md

Shows how to extend a base class with Hookable to add hook functionality.

```javascript
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");
  }
}
```

--------------------------------

### Create and Use a Hook Debugger

Source: https://github.com/unjs/hookable/blob/main/README.md

Automatically logs each hook that is called and its execution time. Use this to monitor hook activity. Remember to close the debugger when it's no longer needed.

```javascript
const debug = hookable.createDebugger(hooks, { tag: "something" });

hooks.callHook("some-hook", "some-arg");
// [something] some-hook: 0.21ms

debug.close();
```

--------------------------------

### Before Each Hook Callback

Source: https://github.com/unjs/hookable/blob/main/README.md

Registers a synchronous callback that executes before any hook is called, providing event details.

```javascript
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");
```

--------------------------------

### After Each Hook Callback

Source: https://github.com/unjs/hookable/blob/main/README.md

Registers a synchronous callback that executes after any hook has been called, providing event details.

```javascript
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");
```

--------------------------------

### Hookable Class Methods

Source: https://github.com/unjs/hookable/blob/main/README.md

This section details the core methods of the Hookable class for managing hooks.

```APIDOC
## Hookable Class

### `constructor()`

Initializes a new Hookable instance.

### `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 3 arguments, `hooks`, `args` and `name`:

- `hooks`: Array of user hooks to be called
- `args`: Array of arguments that should be passed each time calling a hook
- `name`: Name of the 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,
  },
});
```

### `removeAllHooks`

Remove all hook handlers.

### `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");
```
```

--------------------------------

### Exported Classes and Utilities

Source: https://github.com/unjs/hookable/blob/main/AGENTS.md

Shows the main classes and utility functions exported by the Hookable library for use in your projects.

```typescript
export { Hookable, HookableCore, createHooks }

// Utilities
export { flatHooks, mergeHooks, parallelCaller, serial, serialCaller }

// Debugger
export { createDebugger }
```

--------------------------------

### Add Hooks with Nested Structure

Source: https://github.com/unjs/hookable/blob/main/README.md

Demonstrates registering multiple hooks at once using a nested object structure, which flattens into specific hook names.

```javascript
hookable.addHooks({
  test: {
    before: () => {},
    after: () => {},
  },
});
```

--------------------------------

### Unregister Hooks

Source: https://github.com/unjs/hookable/blob/main/README.md

Demonstrates how to unregister single and multiple hooks using the returned unregister functions or removeHooks method.

```javascript
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);
```

--------------------------------

### Trigger Hook Once

Source: https://github.com/unjs/hookable/blob/main/README.md

Shows how to register a hook that will automatically unregister itself after its first execution.

```javascript
const lib = new FooLib();

const unregister = lib.hook("hook0", async () => {
  // Unregister as soon as the hook is executed
  unregister();

  /* ... */
});
```

--------------------------------

### Remove Multiple Hooks by Structure

Source: https://github.com/unjs/hookable/blob/main/README.md

Illustrates removing multiple hook handlers efficiently by providing a nested object structure similar to addHooks.

```javascript
const handler = async () => {
  /* ... */
};

hookable.hook("test:before", handler);
hookable.addHooks({ test: { after: handler } });

// ...

hookable.removeHooks({
  test: {
    before: handler,
    after: handler,
  },
});
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.