The tapable package provides a collection of classes that can be used to add hooks into a plugin system. These hooks can be used to intercept and modify the behavior of certain functions or events, allowing for a highly customizable and extensible architecture. It is commonly used in webpack's plugin system but can be used in any JavaScript project to add similar plugin capabilities.

What are tapable's main functionalities?

SyncHook

SyncHook allows for synchronous execution of multiple functions. It is useful when you need to ensure that hooks are executed in the order they were added.

const { SyncHook } = require('tapable');

const hook = new SyncHook(['arg1', 'arg2']);

hook.tap('MyPlugin', (arg1, arg2) => {
  console.log(`Values received: ${arg1}, ${arg2}`);
});

hook.call('Hello', 'World');

AsyncParallelHook

AsyncParallelHook allows for asynchronous execution of hooks in parallel. It is useful when you have multiple asynchronous tasks that can run at the same time without waiting for each other.

const { AsyncParallelHook } = require('tapable');

const asyncHook = new AsyncParallelHook(['arg1']);

asyncHook.tapPromise('AsyncPlugin', (arg1) => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      console.log(`Async value: ${arg1}`);
      resolve();
    }, 1000);
  });
});

asyncHook.promise('Hello').then(() => {
  console.log('All async plugins have finished.');
});

AsyncSeriesHook

AsyncSeriesHook allows for asynchronous execution of hooks one after another. It is useful when tasks need to be done in a specific sequence, with each task starting only after the previous one has completed.

const { AsyncSeriesHook } = require('tapable');

const asyncSeriesHook = new AsyncSeriesHook(['arg1']);

asyncSeriesHook.tapPromise('AsyncSeriesPlugin', (arg1) => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      console.log(`Async series value: ${arg1}`);
      resolve();
    }, 1000);
  });
});

asyncSeriesHook.promise('World').then(() => {
  console.log('All async series plugins have finished.');
});

Other packages similar to tapable

Readme

Source

Tapable

var Tapable = require("tapable");

Tapable is a class for plugin binding and applying.

Just extend it.

function MyClass() {
	Tapable.call(this);
}

MyClass.prototype = Object.create(Tapable.prototype);

MyClass.prototype.method = function() {};

Or mix it in.

function MyClass2() {
	EventEmitter.call(this);
	Tapable.call(this);
}

MyClass2.prototype = Object.create(EventEmitter.prototype);
Tapable.mixin(MyClass2.prototype);

MyClass2.prototype.method = function() {};

Public functions

void plugin(name: string, handler: Function)

name is the name of the plugin interface the class provides.

handler is a callback function. The signature depends on the class. this is the instance of the class.

void restartApplyPlugins()

Should only be called from a handler function.

It restarts the process of applying handers.

Protected functions

void applyPlugins(name: string, args: any...)

Synchronous applies all registered handers for name. The handler functions are called with all args.

void applyPluginsAsync(
	name: string,
	args: any...,
	callback: (err?: Error) -> void
)

Asynchronously applies all registered handers for name. The handler functions are called with all args and a callback function with the signature (err?: Error) -> void. The hander functions are called in order of registration.

callback is called after all handlers are called.

any applyPluginsBailResult(name: string, args: any...)

Synchronous applies all registered handers for name. The handler function are called with all args. If a handler function returns something !== undefined, the value is returned and no more handers are applied.

applyPluginsAsyncWaterfall(
	name: string,
	init: any,
	callback: (err: Error, result: any) -> void
)

Asynchronously applies all registered handers for name. The hander functions are called with the current value and a callback function with the signature (err: Error, nextValue: any) -> void. When called nextValue is the current value for the next handler. The current value for the first handler is init. After all handlers are applied, callback is called with the last value. If any handler passes a value for err, the callback is called with this error and no more handlers are called.

applyPluginsParallel(
	name: string,
	args: any...,
	callback: (err?: Error) -> void
)

Applies all registered handlers for name parallel. The handler functions are called with all args and a callback function with the signature (err?: Error) -> void. The callback function is called when all handlers called the callback without err. If any handler calls the callback with err, callback is invoked with this error and the other handlers are ignored.

restartApplyPlugins cannot be used.

applyPluginsParallelBailResult(
	name: string,
	args: any...,
	callback: (err: Error, result: any) -> void
)

Applies all registered handlers for name parallel. The handler functions are called with all args and a callback function with the signature (err?: Error) -> void. Handler functions must call the callback. They can either pass an error, or pass undefined, or pass an value. The first result (either error or value) with is not undefined is passed to the callback. The order is defined by registeration not by speed of the handler function. This function compentate this.

restartApplyPlugins cannot be used.

FAQs

What is tapable?

Is tapable well maintained?

Last updated on 21 Jan 2013

Did you know?

Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.

Install