Hook.js

/*
	MIT License http://www.opensource.org/licenses/mit-license.php
	Author Tobias Koppers @sokra
*/
"use strict";

const util = require("util");

const deprecateContext = util.deprecate(
	() => {},
	"Hook.context is deprecated and will be removed"
);

function CALL_DELEGATE(...args) {
	this.call = this._createCall("sync");
	return this.call(...args);
}

function CALL_ASYNC_DELEGATE(...args) {
	this.callAsync = this._createCall("async");
	return this.callAsync(...args);
}

function PROMISE_DELEGATE(...args) {
	this.promise = this._createCall("promise");
	return this.promise(...args);
}

class Hook {
	constructor(args = [], name = undefined) {
		this._args = args;
		this.name = name;
		this.taps = [];
		this.interceptors = [];
		this._call = CALL_DELEGATE;
		this.call = CALL_DELEGATE;
		this._callAsync = CALL_ASYNC_DELEGATE;
		this.callAsync = CALL_ASYNC_DELEGATE;
		this._promise = PROMISE_DELEGATE;
		this.promise = PROMISE_DELEGATE;
		this._x = undefined;

		// eslint-disable-next-line no-self-assign
		this.compile = this.compile;
		// eslint-disable-next-line no-self-assign
		this.tap = this.tap;
		// eslint-disable-next-line no-self-assign
		this.tapAsync = this.tapAsync;
		// eslint-disable-next-line no-self-assign
		this.tapPromise = this.tapPromise;
	}

	compile(_options) {
		throw new Error("Abstract: should be overridden");
	}

	_createCall(type) {
		return this.compile({
			taps: this.taps,
			interceptors: this.interceptors,
			args: this._args,
			type
		});
	}

	_tap(type, options, fn) {
		if (typeof options === "string") {
			// Fast path: a string options ("name") is by far the most common
			// case. Build the final descriptor in a single allocation instead
			// of creating `{ name }` and then `Object.assign`ing it.
			const name = options.trim();
			if (name === "") {
				throw new Error("Missing name for tap");
			}
			options = { type, fn, name };
		} else {
			if (typeof options !== "object" || options === null) {
				throw new Error("Invalid tap options");
			}
			let { name } = options;
			if (typeof name === "string") {
				name = name.trim();
			}
			if (typeof name !== "string" || name === "") {
				throw new Error("Missing name for tap");
			}
			if (typeof options.context !== "undefined") {
				deprecateContext();
			}
			// Fast path: only `name` is set. Build the descriptor as a literal
			// so `_insert` and downstream consumers see the same hidden class
			// as the string-options path, avoiding a polymorphic call site.
			if (
				options.before === undefined &&
				options.stage === undefined &&
				options.context === undefined &&
				options.type === undefined &&
				options.fn === undefined
			) {
				options = { type, fn, name };
			} else {
				options.name = name;
				// Preserve previous precedence: user-provided keys win over the internal `type`/`fn`.
				options = Object.assign({ type, fn }, options);
			}
		}
		options = this._runRegisterInterceptors(options);
		this._insert(options);
	}

	tap(options, fn) {
		this._tap("sync", options, fn);
	}

	tapAsync(options, fn) {
		this._tap("async", options, fn);
	}

	tapPromise(options, fn) {
		this._tap("promise", options, fn);
	}

	_runRegisterInterceptors(options) {
		const { interceptors } = this;
		const { length } = interceptors;
		// Common case: no interceptors.
		if (length === 0) return options;
		for (let i = 0; i < length; i++) {
			const interceptor = interceptors[i];
			if (interceptor.register) {
				const newOptions = interceptor.register(options);
				if (newOptions !== undefined) {
					options = newOptions;
				}
			}
		}
		return options;
	}

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

		return {
			name: this.name,
			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),
			isUsed: () => this.isUsed(),
			withOptions: (opt) => this.withOptions(mergeOptions(opt))
		};
	}

	isUsed() {
		return this.taps.length > 0 || this.interceptors.length > 0;
	}

	intercept(interceptor) {
		this._resetCompilation();
		this.interceptors.push(Object.assign({}, interceptor));
		if (interceptor.register) {
			for (let i = 0; i < this.taps.length; i++) {
				this.taps[i] = interceptor.register(this.taps[i]);
			}
		}
	}

	_resetCompilation() {
		this.call = this._call;
		this.callAsync = this._callAsync;
		this.promise = this._promise;
	}

	_insert(item) {
		this._resetCompilation();
		const { taps } = this;
		const stage = typeof item.stage === "number" ? item.stage : 0;

		// Fast path: the overwhelmingly common `hook.tap("name", fn)` case
		// has no `before` and default stage 0. If the list is empty or the
		// last tap's stage is <= the new item's stage the item belongs at
		// the end - append in O(1), skipping the Set allocation and the
		// shift loop.
		if (!(typeof item.before === "string" || Array.isArray(item.before))) {
			const n = taps.length;
			if (n === 0 || (taps[n - 1].stage || 0) <= stage) {
				taps[n] = item;
				return;
			}
		}

		let before;

		if (typeof item.before === "string") {
			before = new Set([item.before]);
		} else if (Array.isArray(item.before)) {
			before = new Set(item.before);
		}

		let i = taps.length;

		while (i > 0) {
			i--;
			const tap = taps[i];
			taps[i + 1] = tap;
			const xStage = tap.stage || 0;
			if (before) {
				if (before.has(tap.name)) {
					before.delete(tap.name);
					continue;
				}
				if (before.size > 0) {
					continue;
				}
			}
			if (xStage > stage) {
				continue;
			}
			i++;
			break;
		}
		taps[i] = item;
	}
}

Object.setPrototypeOf(Hook.prototype, null);

module.exports = Hook;