sokra

tapable

	MIT License http://www.opensource.org/licenses/mit-license.php

const deprecateContext = util.deprecate(() => {},

"Hook.context is deprecated and will be removed");

const CALL_DELEGATE = function(...args) {

const CALL_ASYNC_DELEGATE = function(...args) {

	this.callAsync = this._createCall("async");

const PROMISE_DELEGATE = function(...args) {

	this.promise = this._createCall("promise");

	constructor(args = [], name = undefined) {

		throw new Error("Abstract: should be overridden");

		} else if (typeof options !== "object" || options === null) {

			throw new Error("Invalid tap options");

		if (typeof options.name !== "string" || options.name === "") {

			throw new Error("Missing name for tap");

		if (typeof options.context !== "undefined") {

		options = Object.assign({ type, fn }, options);

		options = this._runRegisterInterceptors(options);

		for (const interceptor of this.interceptors) {

				const newOptions = interceptor.register(options);

			Object.assign({}, options, typeof opt === "string" ? { name: opt } : opt);

			tap: (opt, fn) => this.tap(mergeOptions(opt), fn),

			tapAsync: (opt, fn) => this.tapAsync(mergeOptions(opt), fn),

			tapPromise: (opt, fn) => this.tapPromise(mergeOptions(opt), fn),

			intercept: interceptor => this.intercept(interceptor),

			withOptions: opt => this.withOptions(mergeOptions(opt))

		return this.taps.length > 0 || this.interceptors.length > 0;

		this.interceptors.push(Object.assign({}, interceptor));

			for (let i = 0; i < this.taps.length; i++) {

				this.taps[i] = interceptor.register(this.taps[i]);

		} else if (Array.isArray(item.before)) {

  "description": "Just a little module for plugins.",

  "homepage": "https://github.com/webpack/tapable",

    "url": "http://github.com/webpack/tapable.git"

    "travis": "yarn pretty-lint && jest --coverage && codecov",

    "pretty-lint": "prettier --check lib/*.js lib/__tests__/*.js",

    "pretty": "prettier --loglevel warn --write lib/*.js lib/__tests__/*.js"

      "__tests__[\\\\/].+\\.js$": "babel-jest"

The tapable package expose many Hook classes, which can be used to create hooks for plugins.

All Hook constructors take one optional argument, which is a list of argument names as strings.

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

The best practice is to expose all hooks of a class in a `hooks` property:

			accelerate: new SyncHook(["newSpeed"]),

			calculateRoutes: new AsyncParallelHook(["source", "target", "routesList"])

myCar.hooks.brake.tap("WarningLampPlugin", () => warningLamp.on());

It's required to pass a name to identify the plugin/reason.

myCar.hooks.accelerate.tap("LoggerPlugin", newSpeed => console.log(`Accelerating to ${newSpeed}`));

For sync hooks, `tap` is the only valid method to add a plugin. Async hooks also support async plugins:

myCar.hooks.calculateRoutes.tapPromise("GoogleMapsPlugin", (source, target, routesList) => {

	return google.maps.findRoute(source, target).then(route => {

myCar.hooks.calculateRoutes.tapAsync("BingMapsPlugin", (source, target, routesList, callback) => {

	bing.findRoute(source, target, (err, route) => {

myCar.hooks.calculateRoutes.tap("CachedRoutesPlugin", (source, target, routesList) => {

	const cachedRoute = cache.get(source, target);

The class declaring these hooks need to call them:

	  * You won't get returned value from SyncHook or AsyncParallelHook,

	  * to do that, use SyncWaterfallHook and AsyncSeriesWaterfallHook respectively

* __Loop__. When a plugin in a loop hook returns a non-undefined value the hook will restart from the first plugin. It will loop until all plugins return undefined.

Additionally, hooks can be synchronous or asynchronous. To reflect this, there’re “Sync”, “AsyncSeries”, and “AsyncParallel” hook classes:

* __Sync__. A sync hook can only be tapped with synchronous functions (using `myHook.tap()`).

* __AsyncSeries__. An async-series hook can be tapped with synchronous, callback-based and promise-based functions (using `myHook.tap()`, `myHook.tapAsync()` and `myHook.tapPromise()`). They call each async method in a row.

* __AsyncParallel__. An async-parallel hook can also be tapped with synchronous, callback-based and promise-based functions (using `myHook.tap()`, `myHook.tapAsync()` and `myHook.tapPromise()`). However, they run each async method in parallel.

The hook type is reflected in its class name. E.g., `AsyncSeriesWaterfallHook` allows asynchronous functions and runs them in series, passing each function’s return value into the next function.

All Hooks offer an additional interception API:

		console.log("Starting to calculate routes");

		// tapInfo = { type: "promise", name: "GoogleMapsPlugin", fn: ... }

		console.log(`${tapInfo.name} is doing its job`);

		return tapInfo; // may return a new tapInfo object

**call**: `(...args) => void` Adding `call` to your interceptor will trigger when hooks are triggered. You have access to the hooks arguments.

**tap**: `(tap: Tap) => void` Adding `tap` to your interceptor will trigger when a plugin taps into a hook. Provided is the `Tap` object. `Tap` object can't be changed.

**loop**: `(...args) => void` Adding `loop` to your interceptor will trigger for each loop of a looping hook.

**register**: `(tap: Tap) => Tap | undefined` Adding `register` to your interceptor will trigger for each added `Tap` and allows to modify it.

Plugins and interceptors can opt-in to access an optional `context` object, which can be used to pass arbitrary values to subsequent plugins and interceptors.

		// tapInfo = { type: "sync", name: "NoisePlugin", fn: ... }

		console.log(`${tapInfo.name} is doing it's job`);

		// `context` starts as an empty object if at least one plugin uses `context: true`.

		// If no plugins use `context: true`, then `context` is undefined.

			// Arbitrary properties can be added to `context`, which plugins can then access.

A HookMap is a helper class for a Map with Hooks

const keyedHook = new HookMap(key => new SyncHook(["arg"]))

keyedHook.for("some-key").tap("MyPlugin", (arg) => { /* ... */ });

keyedHook.for("some-key").tapAsync("MyPlugin", (arg, callback) => { /* ... */ });

keyedHook.for("some-key").tapPromise("MyPlugin", (arg) => { /* ... */ });

	hook.callAsync("arg", err => { /* ... */ });

	tap: (name: string | Tap, fn: (context?, ...args) => Result) => void,

	tapAsync: (name: string | Tap, fn: (context?, ...args, callback: (err, result: Result) => void) => void) => void,

	tapPromise: (name: string | Tap, fn: (context?, ...args) => Promise<Result>) => void,

	intercept: (interceptor: HookInterceptor) => void

		@@ -61,3 +61,3 @@ /*
		options = {
		name: options
		name: options.trim()
		};
		@@ -64,0 +64,0 @@ } else if (typeof options !== "object" \|\| options === null) {

		{
		"name": "tapable",
		"version": "2.0.0-beta.11",
		"version": "2.0.0",
		"author": "Tobias Koppers @sokra",
		@@ -5,0 +5,0 @@ "description": "Just a little module for plugins.",

		@@ -142,3 +142,3 @@ # Tapable

		* __Loop__. TODO
		* __Loop__. When a plugin in a loop hook returns a non-undefined value the hook will restart from the first plugin. It will loop until all plugins return undefined.

		@@ -145,0 +145,0 @@ Additionally, hooks can be synchronous or asynchronous. To reflect this, there’re “Sync”, “AsyncSeries”, and “AsyncParallel” hook classes:

Fixed alerts

Improved metrics