This repository has been archived on 2024-07-27. You can view files and clone it, but cannot push or open issues or pull requests.
keksAccountGUI/node_modulesOLD/enhanced-resolve/lib/CachedInputFileSystem.js
2019-08-11 20:48:02 +02:00

277 lines
7.4 KiB
JavaScript

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