FM / lib

/var/www/cobraambalaj/node_modules/tapable/lib/

/var/www/cobraambalaj/node_modules/tapable/lib

Name	Size	Mode	Actions
AsyncParallelBailHook.js	2353	0644	edit dl rm
AsyncParallelHook.js	877	0644	edit dl rm
AsyncSeriesBailHook.js	1057	0644	edit dl rm
AsyncSeriesHook.js	863	0644	edit dl rm
AsyncSeriesLoopHook.js	888	0644	edit dl rm
AsyncSeriesWaterfallHook.js	1261	0644	edit dl rm
Hook.js	4061	0644	edit dl rm
HookCodeFactory.js	11950	0644	edit dl rm
HookMap.js	1517	0644	edit dl rm
index.js	814	0644	edit dl rm
MultiHook.js	898	0644	edit dl rm
SyncBailHook.js	1227	0644	edit dl rm
SyncHook.js	1024	0644	edit dl rm
SyncLoopHook.js	1057	0644	edit dl rm
SyncWaterfallHook.js	1478	0644	edit dl rm
util-browser.js	314	0644	edit dl rm

Edit: /var/www/cobraambalaj/node_modules/tapable/lib/Hook.js (4061B)

/*
	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");

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;

this.compile = this.compile;
		this.tap = this.tap;
		this.tapAsync = this.tapAsync;
		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: type
		});
	}

_tap(type, options, fn) {
		if (typeof options === "string") {
			options = {
				name: options.trim()
			};
		} 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") {
			deprecateContext();
		}
		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) {
		for (const interceptor of this.interceptors) {
			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();
		let before;
		if (typeof item.before === "string") {
			before = new Set([item.before]);
		} else if (Array.isArray(item.before)) {
			before = new Set(item.before);
		}
		let stage = 0;
		if (typeof item.stage === "number") {
			stage = item.stage;
		}
		let i = this.taps.length;
		while (i > 0) {
			i--;
			const x = this.taps[i];
			this.taps[i + 1] = x;
			const xStage = x.stage || 0;
			if (before) {
				if (before.has(x.name)) {
					before.delete(x.name);
					continue;
				}
				if (before.size > 0) {
					continue;
				}
			}
			if (xStage > stage) {
				continue;
			}
			i++;
			break;
		}
		this.taps[i] = item;
	}
}

Object.setPrototypeOf(Hook.prototype, null);

module.exports = Hook;

cmd: