SxsnPC/node_modules/enhanced-resolve/lib/CachedInputFileSystem.js

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

class Storage {
	constructor(duration) {
		this.duration = duration;
		this.running = new Map();
		this.data = new Map();
		this.levels = [];
		if (duration > 0) {
			this.levels.push(
				new Set(),
				new Set(),
				new Set(),
				new Set(),
				new Set(),
				new Set(),
				new Set(),
				new Set(),
				new Set()
			);
			for (let i = 8000; i < duration; i += 500) this.levels.push(new Set());
		}
		this.count = 0;
		this.interval = null;
		this.needTickCheck = false;
		this.nextTick = null;
		this.passive = true;
		this.tick = this.tick.bind(this);
	}

	ensureTick() {
		if (!this.interval && this.duration > 0 && !this.nextTick)
			this.interval = setInterval(
				this.tick,
				Math.floor(this.duration / this.levels.length)
			);
	}

	finished(name, err, result) {
		const callbacks = this.running.get(name);
		this.running.delete(name);
		if (this.duration > 0) {
			this.data.set(name, [err, result]);
			const levelData = this.levels[0];
			this.count -= levelData.size;
			levelData.add(name);
			this.count += levelData.size;
			this.ensureTick();
		}
		for (let i = 0; i < callbacks.length; i++) {
			callbacks[i](err, result);
		}
	}

	finishedSync(name, err, result) {
		if (this.duration > 0) {
			this.data.set(name, [err, result]);
			const levelData = this.levels[0];
			this.count -= levelData.size;
			levelData.add(name);
			this.count += levelData.size;
			this.ensureTick();
		}
	}

	provide(name, provider, callback) {
		if (typeof name !== "string") {
			callback(new TypeError("path must be a string"));
			return;
		}
		let running = this.running.get(name);
		if (running) {
			running.push(callback);
			return;
		}
		if (this.duration > 0) {
			this.checkTicks();
			const data = this.data.get(name);
			if (data) {
				return process.nextTick(() => {
					callback.apply(null, data);
				});
			}
		}
		this.running.set(name, (running = [callback]));
		provider(name, (err, result) => {
			this.finished(name, err, result);
		});
	}

	provideSync(name, provider) {
		if (typeof name !== "string") {
			throw new TypeError("path must be a string");
		}
		if (this.duration > 0) {
			this.checkTicks();
			const data = this.data.get(name);
			if (data) {
				if (data[0]) throw data[0];
				return data[1];
			}
		}
		let result;
		try {
			result = provider(name);
		} catch (e) {
			this.finishedSync(name, e);
			throw e;
		}
		this.finishedSync(name, null, result);
		return result;
	}

	tick() {
		const decay = this.levels.pop();
		for (let item of decay) {
			this.data.delete(item);
		}
		this.count -= decay.size;
		decay.clear();
		this.levels.unshift(decay);
		if (this.count === 0) {
			clearInterval(this.interval);
			this.interval = null;
			this.nextTick = null;
			return true;
		} else if (this.nextTick) {
			this.nextTick += Math.floor(this.duration / this.levels.length);
			const time = new Date().getTime();
			if (this.nextTick > time) {
				this.nextTick = null;
				this.interval = setInterval(
					this.tick,
					Math.floor(this.duration / this.levels.length)
				);
				return true;
			}
		} else if (this.passive) {
			clearInterval(this.interval);
			this.interval = null;
			this.nextTick =
				new Date().getTime() + Math.floor(this.duration / this.levels.length);
		} else {
			this.passive = true;
		}
	}

	checkTicks() {
		this.passive = false;
		if (this.nextTick) {
			while (!this.tick());
		}
	}

	purge(what) {
		if (!what) {
			this.count = 0;
			clearInterval(this.interval);
			this.nextTick = null;
			this.data.clear();
			this.levels.forEach(level => {
				level.clear();
			});
		} else if (typeof what === "string") {
			for (let key of this.data.keys()) {
				if (key.startsWith(what)) this.data.delete(key);
			}
		} else {
			for (let i = what.length - 1; i >= 0; i--) {
				this.purge(what[i]);
			}
		}
	}
}

module.exports = class CachedInputFileSystem {
	constructor(fileSystem, duration) {
		this.fileSystem = fileSystem;
		this._statStorage = new Storage(duration);
		this._readdirStorage = new Storage(duration);
		this._readFileStorage = new Storage(duration);
		this._readJsonStorage = new Storage(duration);
		this._readlinkStorage = new Storage(duration);

		this._stat = this.fileSystem.stat
			? this.fileSystem.stat.bind(this.fileSystem)
			: null;
		if (!this._stat) this.stat = null;

		this._statSync = this.fileSystem.statSync
			? this.fileSystem.statSync.bind(this.fileSystem)
			: null;
		if (!this._statSync) this.statSync = null;

		this._readdir = this.fileSystem.readdir
			? this.fileSystem.readdir.bind(this.fileSystem)
			: null;
		if (!this._readdir) this.readdir = null;

		this._readdirSync = this.fileSystem.readdirSync
			? this.fileSystem.readdirSync.bind(this.fileSystem)
			: null;
		if (!this._readdirSync) this.readdirSync = null;

		this._readFile = this.fileSystem.readFile
			? this.fileSystem.readFile.bind(this.fileSystem)
			: null;
		if (!this._readFile) this.readFile = null;

		this._readFileSync = this.fileSystem.readFileSync
			? this.fileSystem.readFileSync.bind(this.fileSystem)
			: null;
		if (!this._readFileSync) this.readFileSync = null;

		if (this.fileSystem.readJson) {
			this._readJson = this.fileSystem.readJson.bind(this.fileSystem);
		} else if (this.readFile) {
			this._readJson = (path, callback) => {
				this.readFile(path, (err, buffer) => {
					if (err) return callback(err);
					let data;
					try {
						data = JSON.parse(buffer.toString("utf-8"));
					} catch (e) {
						return callback(e);
					}
					callback(null, data);
				});
			};
		} else {
			this.readJson = null;
		}
		if (this.fileSystem.readJsonSync) {
			this._readJsonSync = this.fileSystem.readJsonSync.bind(this.fileSystem);
		} else if (this.readFileSync) {
			this._readJsonSync = path => {
				const buffer = this.readFileSync(path);
				const data = JSON.parse(buffer.toString("utf-8"));
				return data;
			};
		} else {
			this.readJsonSync = null;
		}

		this._readlink = this.fileSystem.readlink
			? this.fileSystem.readlink.bind(this.fileSystem)
			: null;
		if (!this._readlink) this.readlink = null;

		this._readlinkSync = this.fileSystem.readlinkSync
			? this.fileSystem.readlinkSync.bind(this.fileSystem)
			: null;
		if (!this._readlinkSync) this.readlinkSync = null;
	}

	stat(path, callback) {
		this._statStorage.provide(path, this._stat, callback);
	}

	readdir(path, callback) {
		this._readdirStorage.provide(path, this._readdir, callback);
	}

	readFile(path, callback) {
		this._readFileStorage.provide(path, this._readFile, callback);
	}

	readJson(path, callback) {
		this._readJsonStorage.provide(path, this._readJson, callback);
	}

	readlink(path, callback) {
		this._readlinkStorage.provide(path, this._readlink, callback);
	}

	statSync(path) {
		return this._statStorage.provideSync(path, this._statSync);
	}

	readdirSync(path) {
		return this._readdirStorage.provideSync(path, this._readdirSync);
	}

	readFileSync(path) {
		return this._readFileStorage.provideSync(path, this._readFileSync);
	}

	readJsonSync(path) {
		return this._readJsonStorage.provideSync(path, this._readJsonSync);
	}

	readlinkSync(path) {
		return this._readlinkStorage.provideSync(path, this._readlinkSync);
	}

	purge(what) {
		this._statStorage.purge(what);
		this._readdirStorage.purge(what);
		this._readFileStorage.purge(what);
		this._readlinkStorage.purge(what);
		this._readJsonStorage.purge(what);
	}
};