From e06ec920f7a5d784e674c4c4b4e6d1da3dc7391d Mon Sep 17 00:00:00 2001
From: Piotr Russ <mail@pruss.it>
Date: Mon, 16 Nov 2020 00:10:28 +0100
Subject: api, login, auth

---
 node_modules/tapable/lib/Hook.js | 176 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 176 insertions(+)
 create mode 100644 node_modules/tapable/lib/Hook.js

(limited to 'node_modules/tapable/lib/Hook.js')

diff --git a/node_modules/tapable/lib/Hook.js b/node_modules/tapable/lib/Hook.js
new file mode 100644
index 0000000..6a976e9
--- /dev/null
+++ b/node_modules/tapable/lib/Hook.js
@@ -0,0 +1,176 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+class Hook {
+	constructor(args) {
+		if (!Array.isArray(args)) args = [];
+		this._args = args;
+		this.taps = [];
+		this.interceptors = [];
+		this.call = this._call;
+		this.promise = this._promise;
+		this.callAsync = this._callAsync;
+		this._x = undefined;
+	}
+
+	compile(options) {
+		throw new Error("Abstract: should be overriden");
+	}
+
+	_createCall(type) {
+		return this.compile({
+			taps: this.taps,
+			interceptors: this.interceptors,
+			args: this._args,
+			type: type
+		});
+	}
+
+	tap(options, fn) {
+		if (typeof options === "string") options = { name: options };
+		if (typeof options !== "object" || options === null)
+			throw new Error(
+				"Invalid arguments to tap(options: Object, fn: function)"
+			);
+		options = Object.assign({ type: "sync", fn: fn }, options);
+		if (typeof options.name !== "string" || options.name === "")
+			throw new Error("Missing name for tap");
+		options = this._runRegisterInterceptors(options);
+		this._insert(options);
+	}
+
+	tapAsync(options, fn) {
+		if (typeof options === "string") options = { name: options };
+		if (typeof options !== "object" || options === null)
+			throw new Error(
+				"Invalid arguments to tapAsync(options: Object, fn: function)"
+			);
+		options = Object.assign({ type: "async", fn: fn }, options);
+		if (typeof options.name !== "string" || options.name === "")
+			throw new Error("Missing name for tapAsync");
+		options = this._runRegisterInterceptors(options);
+		this._insert(options);
+	}
+
+	tapPromise(options, fn) {
+		if (typeof options === "string") options = { name: options };
+		if (typeof options !== "object" || options === null)
+			throw new Error(
+				"Invalid arguments to tapPromise(options: Object, fn: function)"
+			);
+		options = Object.assign({ type: "promise", fn: fn }, options);
+		if (typeof options.name !== "string" || options.name === "")
+			throw new Error("Missing name for tapPromise");
+		options = this._runRegisterInterceptors(options);
+		this._insert(options);
+	}
+
+	_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);
+
+		// Prevent creating endless prototype chains
+		options = Object.assign({}, options, this._withOptions);
+		const base = this._withOptionsBase || this;
+		const newHook = Object.create(base);
+
+		(newHook.tapAsync = (opt, fn) => base.tapAsync(mergeOptions(opt), fn)),
+			(newHook.tap = (opt, fn) => base.tap(mergeOptions(opt), fn));
+		newHook.tapPromise = (opt, fn) => base.tapPromise(mergeOptions(opt), fn);
+		newHook._withOptions = options;
+		newHook._withOptionsBase = base;
+		return newHook;
+	}
+
+	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;
+	}
+}
+
+function createCompileDelegate(name, type) {
+	return function lazyCompileHook(...args) {
+		this[name] = this._createCall(type);
+		return this[name](...args);
+	};
+}
+
+Object.defineProperties(Hook.prototype, {
+	_call: {
+		value: createCompileDelegate("call", "sync"),
+		configurable: true,
+		writable: true
+	},
+	_promise: {
+		value: createCompileDelegate("promise", "promise"),
+		configurable: true,
+		writable: true
+	},
+	_callAsync: {
+		value: createCompileDelegate("callAsync", "async"),
+		configurable: true,
+		writable: true
+	}
+});
+
+module.exports = Hook;
-- 
cgit v1.2.3