Socket
Socket
Sign inDemoInstall

enhanced-resolve

Package Overview
Dependencies
Maintainers
4
Versions
130
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

enhanced-resolve - npm Package Compare versions

Comparing version 3.4.1 to 4.0.0-beta.1

lib/createInnerContext.js

83

lib/AliasFieldPlugin.js

@@ -5,48 +5,49 @@ /*

*/
"use strict";
var DescriptionFileUtils = require("./DescriptionFileUtils");
var createInnerCallback = require("./createInnerCallback");
var getInnerRequest = require("./getInnerRequest");
const DescriptionFileUtils = require("./DescriptionFileUtils");
const getInnerRequest = require("./getInnerRequest");
function AliasFieldPlugin(source, field, target) {
this.source = source;
this.field = field;
this.target = target;
}
module.exports = AliasFieldPlugin;
module.exports = class AliasFieldPlugin {
constructor(source, field, target) {
this.source = source;
this.field = field;
this.target = target;
}
AliasFieldPlugin.prototype.apply = function(resolver) {
var target = this.target;
var field = this.field;
resolver.plugin(this.source, function(request, callback) {
if(!request.descriptionFileData) return callback();
var innerRequest = getInnerRequest(resolver, request);
if(!innerRequest) return callback();
var fieldData = DescriptionFileUtils.getField(request.descriptionFileData, field);
if(typeof fieldData !== "object") {
if(callback.log) callback.log("Field '" + field + "' doesn't contain a valid alias configuration");
return callback();
}
var data1 = fieldData[innerRequest];
var data2 = fieldData[innerRequest.replace(/^\.\//, "")];
var data = typeof data1 !== "undefined" ? data1 : data2;
if(data === innerRequest) return callback();
if(data === undefined) return callback();
if(data === false) {
var ignoreObj = Object.assign({}, request, {
path: false
apply(resolver) {
const target = resolver.ensureHook(this.target);
resolver.getHook(this.source).tapAsync("AliasFieldPlugin", (request, resolveContext, callback) => {
if(!request.descriptionFileData) return callback();
const innerRequest = getInnerRequest(resolver, request);
if(!innerRequest) return callback();
const fieldData = DescriptionFileUtils.getField(request.descriptionFileData, this.field);
if(typeof fieldData !== "object") {
if(resolveContext.log) resolveContext.log("Field '" + this.field + "' doesn't contain a valid alias configuration");
return callback();
}
const data1 = fieldData[innerRequest];
const data2 = fieldData[innerRequest.replace(/^\.\//, "")];
const data = typeof data1 !== "undefined" ? data1 : data2;
if(data === innerRequest) return callback();
if(data === undefined) return callback();
if(data === false) {
const ignoreObj = Object.assign({}, request, {
path: false
});
return callback(null, ignoreObj);
}
const obj = Object.assign({}, request, {
path: request.descriptionFileRoot,
request: data
});
return callback(null, ignoreObj);
}
var obj = Object.assign({}, request, {
path: request.descriptionFileRoot,
request: data
resolver.doResolve(target, obj, "aliased from description file " + request.descriptionFilePath + " with mapping '" + innerRequest + "' to '" + data + "'", resolveContext, (err, result) => {
if(err) return callback(err);
// Don't allow other aliasing or raw request
if(result === undefined) return callback(null, null);
callback(null, result);
});
});
resolver.doResolve(target, obj, "aliased from description file " + request.descriptionFilePath + " with mapping '" + innerRequest + "' to '" + data + "'", createInnerCallback(function(err, result) {
if(arguments.length > 0) return callback(err, result);
// Don't allow other aliasing or raw request
callback(null, null);
}, callback));
});
}
};

67

lib/AliasPlugin.js

@@ -5,7 +5,7 @@ /*

*/
var createInnerCallback = require("./createInnerCallback");
"use strict";
function startsWith(string, searchString) {
var stringLength = string.length;
var searchLength = searchString.length;
const stringLength = string.length;
const searchLength = searchString.length;

@@ -16,3 +16,3 @@ // early out if the search length is greater than the search string

}
var index = -1;
let index = -1;
while(++index < searchLength) {

@@ -26,35 +26,34 @@ if(string.charCodeAt(index) !== searchString.charCodeAt(index)) {

function AliasPlugin(source, options, target) {
this.source = source;
this.name = options.name;
this.alias = options.alias;
this.onlyModule = options.onlyModule;
this.target = target;
}
module.exports = AliasPlugin;
module.exports = class AliasPlugin {
constructor(source, options, target) {
this.source = source;
this.name = options.name;
this.alias = options.alias;
this.onlyModule = options.onlyModule;
this.target = target;
}
AliasPlugin.prototype.apply = function(resolver) {
var target = this.target;
var name = this.name;
var alias = this.alias;
var onlyModule = this.onlyModule;
resolver.plugin(this.source, function(request, callback) {
var innerRequest = request.request;
if(!innerRequest) return callback();
if(innerRequest === name || (!onlyModule && startsWith(innerRequest, name + "/"))) {
if(innerRequest !== alias && !startsWith(innerRequest, alias + "/")) {
var newRequestStr = alias + innerRequest.substr(name.length);
var obj = Object.assign({}, request, {
request: newRequestStr
});
return resolver.doResolve(target, obj, "aliased with mapping '" + name + "': '" + alias + "' to '" + newRequestStr + "'", createInnerCallback(function(err, result) {
if(arguments.length > 0) return callback(err, result);
apply(resolver) {
const target = resolver.ensureHook(this.target);
resolver.getHook(this.source).tapAsync("AliasPlugin", (request, resolveContext, callback) => {
const innerRequest = request.request;
if(!innerRequest) return callback();
if(innerRequest === this.name || (!this.onlyModule && startsWith(innerRequest, this.name + "/"))) {
if(innerRequest !== this.alias && !startsWith(innerRequest, this.alias + "/")) {
const newRequestStr = this.alias + innerRequest.substr(this.name.length);
const obj = Object.assign({}, request, {
request: newRequestStr
});
return resolver.doResolve(target, obj, "aliased with mapping '" + this.name + "': '" + this.alias + "' to '" + newRequestStr + "'", resolveContext, (err, result) => {
if(err) return callback(err);
// don't allow other aliasing or raw request
callback(null, null);
}, callback));
// Don't allow other aliasing or raw request
if(result === undefined) return callback(null, null);
callback(null, result);
});
}
}
}
return callback();
});
return callback();
});
}
};

32

lib/AppendPlugin.js

@@ -5,19 +5,21 @@ /*

*/
function AppendPlugin(source, appending, target) {
this.source = source;
this.appending = appending;
this.target = target;
}
module.exports = AppendPlugin;
"use strict";
AppendPlugin.prototype.apply = function(resolver) {
var target = this.target;
var appending = this.appending;
resolver.plugin(this.source, function(request, callback) {
var obj = Object.assign({}, request, {
path: request.path + appending,
relativePath: request.relativePath && (request.relativePath + appending)
module.exports = class AppendPlugin {
constructor(source, appending, target) {
this.source = source;
this.appending = appending;
this.target = target;
}
apply(resolver) {
const target = resolver.ensureHook(this.target);
resolver.getHook(this.source).tapAsync("AppendPlugin", (request, resolveContext, callback) => {
const obj = Object.assign({}, request, {
path: request.path + this.appending,
relativePath: request.relativePath && (request.relativePath + this.appending)
});
resolver.doResolve(target, obj, this.appending, resolveContext, callback);
});
resolver.doResolve(target, obj, appending, callback);
});
}
};

452

lib/CachedInputFileSystem.js

@@ -5,268 +5,274 @@ /*

*/
function Storage(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(var i = 8000; i < duration; i += 500)
this.levels.push(new Set());
"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);
}
this.count = 0;
this.interval = null;
this.needTickCheck = false;
this.nextTick = null;
this.passive = true;
this.tick = this.tick.bind(this);
}
Storage.prototype.ensureTick = function() {
if(!this.interval && this.duration > 0 && !this.nextTick)
this.interval = setInterval(this.tick, Math.floor(this.duration / this.levels.length));
};
ensureTick() {
if(!this.interval && this.duration > 0 && !this.nextTick)
this.interval = setInterval(this.tick, Math.floor(this.duration / this.levels.length));
}
Storage.prototype.finished = function(name, err, result) {
var callbacks = this.running.get(name);
this.running.delete(name);
if(this.duration > 0) {
this.data.set(name, [err, result]);
var levelData = this.levels[0];
this.count -= levelData.size;
levelData.add(name);
this.count += levelData.size;
this.ensureTick();
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);
}
}
for(var i = 0; i < callbacks.length; i++) {
callbacks[i](err, result);
}
};
Storage.prototype.finishedSync = function(name, err, result) {
if(this.duration > 0) {
this.data.set(name, [err, result]);
var levelData = this.levels[0];
this.count -= levelData.size;
levelData.add(name);
this.count += levelData.size;
this.ensureTick();
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();
}
}
};
Storage.prototype.provide = function(name, provider, callback) {
if(typeof name !== "string") {
callback(new TypeError("path must be a string"));
return;
}
var running = this.running.get(name);
if(running) {
running.push(callback);
return;
}
if(this.duration > 0) {
this.checkTicks();
var data = this.data.get(name);
if(data) {
return process.nextTick(function() {
callback.apply(null, data);
});
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);
});
}
this.running.set(name, running = [callback]);
var _this = this;
provider(name, function(err, result) {
_this.finished(name, err, result);
});
};
Storage.prototype.provideSync = function(name, provider) {
if(typeof name !== "string") {
throw new TypeError("path must be a string");
}
if(this.duration > 0) {
this.checkTicks();
var data = this.data.get(name);
if(data) {
if(data[0])
throw data[0];
return data[1];
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;
}
try {
var result = provider(name);
} catch(e) {
this.finishedSync(name, e);
throw e;
}
this.finishedSync(name, null, result);
return result;
};
Storage.prototype.tick = function() {
var decay = this.levels.pop();
for(var 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);
var time = new Date().getTime();
if(this.nextTick > time) {
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;
this.interval = setInterval(this.tick, Math.floor(this.duration / this.levels.length));
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;
}
} 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;
}
};
Storage.prototype.checkTicks = function() {
this.passive = false;
if(this.nextTick) {
while(!this.tick());
checkTicks() {
this.passive = false;
if(this.nextTick) {
while(!this.tick());
}
}
};
Storage.prototype.purge = function(what) {
if(!what) {
this.count = 0;
clearInterval(this.interval);
this.nextTick = null;
this.data.clear();
this.levels.forEach(function(level) {
level.clear();
});
} else if(typeof what === "string") {
for(var key of this.data.keys()) {
if(key.startsWith(what))
this.data.delete(key);
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]);
}
}
} else {
for(var i = what.length - 1; i >= 0; i--) {
this.purge(what[i]);
}
}
};
}
function CachedInputFileSystem(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);
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._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._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._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._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._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;
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 = function(path, callback) {
this.readFile(path, function(err, buffer) {
if(err) return callback(err);
try {
var data = JSON.parse(buffer.toString("utf-8"));
} catch(e) {
return callback(e);
}
callback(null, data);
});
}.bind(this);
} else {
this.readJson = null;
}
if(this.fileSystem.readJsonSync) {
this._readJsonSync = this.fileSystem.readJsonSync.bind(this.fileSystem);
} else if(this.readFileSync) {
this._readJsonSync = function(path) {
var buffer = this.readFileSync(path);
var data = JSON.parse(buffer.toString("utf-8"));
return data;
}.bind(this);
} else {
this.readJsonSync = 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._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;
}
module.exports = CachedInputFileSystem;
this._readlinkSync = this.fileSystem.readlinkSync ? this.fileSystem.readlinkSync.bind(this.fileSystem) : null;
if(!this._readlinkSync) this.readlinkSync = null;
}
CachedInputFileSystem.prototype.stat = function(path, callback) {
this._statStorage.provide(path, this._stat, callback);
};
stat(path, callback) {
this._statStorage.provide(path, this._stat, callback);
}
CachedInputFileSystem.prototype.readdir = function(path, callback) {
this._readdirStorage.provide(path, this._readdir, callback);
};
readdir(path, callback) {
this._readdirStorage.provide(path, this._readdir, callback);
}
CachedInputFileSystem.prototype.readFile = function(path, callback) {
this._readFileStorage.provide(path, this._readFile, callback);
};
readFile(path, callback) {
this._readFileStorage.provide(path, this._readFile, callback);
}
CachedInputFileSystem.prototype.readJson = function(path, callback) {
this._readJsonStorage.provide(path, this._readJson, callback);
};
readJson(path, callback) {
this._readJsonStorage.provide(path, this._readJson, callback);
}
CachedInputFileSystem.prototype.readlink = function(path, callback) {
this._readlinkStorage.provide(path, this._readlink, callback);
};
readlink(path, callback) {
this._readlinkStorage.provide(path, this._readlink, callback);
}
CachedInputFileSystem.prototype.statSync = function(path) {
return this._statStorage.provideSync(path, this._statSync);
};
statSync(path) {
return this._statStorage.provideSync(path, this._statSync);
}
CachedInputFileSystem.prototype.readdirSync = function(path) {
return this._readdirStorage.provideSync(path, this._readdirSync);
};
readdirSync(path) {
return this._readdirStorage.provideSync(path, this._readdirSync);
}
CachedInputFileSystem.prototype.readFileSync = function(path) {
return this._readFileStorage.provideSync(path, this._readFileSync);
};
readFileSync(path) {
return this._readFileStorage.provideSync(path, this._readFileSync);
}
CachedInputFileSystem.prototype.readJsonSync = function(path) {
return this._readJsonStorage.provideSync(path, this._readJsonSync);
};
readJsonSync(path) {
return this._readJsonStorage.provideSync(path, this._readJsonSync);
}
CachedInputFileSystem.prototype.readlinkSync = function(path) {
return this._readlinkStorage.provideSync(path, this._readlinkSync);
};
readlinkSync(path) {
return this._readlinkStorage.provideSync(path, this._readlinkSync);
}
CachedInputFileSystem.prototype.purge = function(what) {
this._statStorage.purge(what);
this._readdirStorage.purge(what);
this._readFileStorage.purge(what);
this._readlinkStorage.purge(what);
this._readJsonStorage.purge(what);
purge(what) {
this._statStorage.purge(what);
this._readdirStorage.purge(what);
this._readFileStorage.purge(what);
this._readlinkStorage.purge(what);
this._readJsonStorage.purge(what);
}
};

35

lib/CloneBasenamePlugin.js

@@ -5,21 +5,24 @@ /*

*/
var basename = require("./getPaths").basename;
"use strict";
function CloneBasenamePlugin(source, target) {
this.source = source;
this.target = target;
}
module.exports = CloneBasenamePlugin;
const basename = require("./getPaths").basename;
CloneBasenamePlugin.prototype.apply = function(resolver) {
var target = this.target;
resolver.plugin(this.source, function(request, callback) {
var filename = basename(request.path);
var filePath = resolver.join(request.path, filename);
var obj = Object.assign({}, request, {
path: filePath,
relativePath: request.relativePath && resolver.join(request.relativePath, filename)
module.exports = class CloneBasenamePlugin {
constructor(source, target) {
this.source = source;
this.target = target;
}
apply(resolver) {
const target = resolver.ensureHook(this.target);
resolver.getHook(this.source).tapAsync("CloneBasenamePlugin", (request, resolveContext, callback) => {
const filename = basename(request.path);
const filePath = resolver.join(request.path, filename);
const obj = Object.assign({}, request, {
path: filePath,
relativePath: request.relativePath && resolver.join(request.relativePath, filename)
});
resolver.doResolve(target, obj, "using path: " + filePath, resolveContext, callback);
});
resolver.doResolve(target, obj, "using path: " + filePath, callback);
});
}
};

80

lib/concord.js

@@ -5,7 +5,9 @@ /*

*/
var globToRegExp = require("./globToRegExp").globToRegExp;
"use strict";
const globToRegExp = require("./globToRegExp").globToRegExp;
function parseType(type) {
var items = type.split("+");
var t = items.shift();
const items = type.split("+");
const t = items.shift();
return {

@@ -21,3 +23,3 @@ type: t === "*" ? null : t,

if(testedType.type && testedType.type !== baseType.type) return false;
return testedType.features.every(function(requiredFeature) {
return testedType.features.every(requiredFeature => {
return baseType.features.indexOf(requiredFeature) >= 0;

@@ -31,3 +33,3 @@ });

if(baseType.length !== testedType.length) return false;
for(var i = 0; i < baseType.length; i++) {
for(let i = 0; i < baseType.length; i++) {
if(!isTypeMatched(baseType[i], testedType[i]))

@@ -40,3 +42,3 @@ return false;

function isResourceTypeSupported(context, type) {
return context.supportedResourceTypes && context.supportedResourceTypes.some(function(supportedType) {
return context.supportedResourceTypes && context.supportedResourceTypes.some(supportedType => {
return isResourceTypeMatched(supportedType, type);

@@ -47,3 +49,3 @@ });

function isEnvironment(context, env) {
return context.environments && context.environments.every(function(environment) {
return context.environments && context.environments.every(environment => {
return isTypeMatched(environment, env);

@@ -53,6 +55,6 @@ });

var globCache = {};
const globCache = {};
function getGlobRegExp(glob) {
var regExp = globCache[glob] || (globCache[glob] = globToRegExp(glob));
const regExp = globCache[glob] || (globCache[glob] = globToRegExp(glob));
return regExp;

@@ -62,3 +64,3 @@ }

function matchGlob(glob, relativePath) {
var regExp = getGlobRegExp(glob);
const regExp = getGlobRegExp(glob);
return regExp.exec(relativePath);

@@ -72,12 +74,12 @@ }

function isConditionMatched(context, condition) {
var items = condition.split("|");
const items = condition.split("|");
return items.some(function testFn(item) {
item = item.trim();
var inverted = /^!/.test(item);
const inverted = /^!/.test(item);
if(inverted) return !testFn(item.substr(1));
if(/^[a-z]+:/.test(item)) {
// match named condition
var match = /^([a-z]+):\s*/.exec(item);
var value = item.substr(match[0].length);
var name = match[1];
const match = /^([a-z]+):\s*/.exec(item);
const value = item.substr(match[0].length);
const name = match[1];
switch(name) {

@@ -101,6 +103,6 @@ case "referrer":

while(true) { //eslint-disable-line
var match = /^\[([^\]]+)\]\s*/.exec(key);
const match = /^\[([^\]]+)\]\s*/.exec(key);
if(!match) return key;
key = key.substr(match[0].length);
var condition = match[1];
const condition = match[1];
if(!isConditionMatched(context, condition)) {

@@ -113,5 +115,5 @@ return false;

function getField(context, configuration, field) {
var value;
Object.keys(configuration).forEach(function(key) {
var pureKey = isKeyMatched(context, key);
let value;
Object.keys(configuration).forEach(key => {
const pureKey = isKeyMatched(context, key);
if(pureKey === field) {

@@ -133,13 +135,15 @@ value = configuration[key];

function matchModule(context, configuration, request) {
var modulesField = getField(context, configuration, "modules");
const modulesField = getField(context, configuration, "modules");
if(!modulesField) return request;
var newRequest = request;
var keys = Object.keys(modulesField);
var iteration = 0;
for(var i = 0; i < keys.length; i++) {
var key = keys[i];
var pureKey = isKeyMatched(context, key);
var match = matchGlob(pureKey, newRequest);
let newRequest = request;
const keys = Object.keys(modulesField);
let iteration = 0;
let match;
let index;
for(let i = 0; i < keys.length; i++) {
const key = keys[i];
const pureKey = isKeyMatched(context, key);
match = matchGlob(pureKey, newRequest);
if(match) {
var value = modulesField[key];
const value = modulesField[key];
if(typeof value !== "string") {

@@ -150,3 +154,3 @@ return value;

} else {
var index = 1;
index = 1;
newRequest = value.replace(/(\/?\*)?\*/g, replaceMatcher);

@@ -165,4 +169,6 @@ }

case "/**":
var m = match[index++];
return m ? "/" + m : "";
{
const m = match[index++];
return m ? "/" + m : "";
}
case "**":

@@ -176,9 +182,9 @@ case "*":

function matchType(context, configuration, relativePath) {
var typesField = getField(context, configuration, "types");
const typesField = getField(context, configuration, "types");
if(!typesField) return undefined;
var type;
Object.keys(typesField).forEach(function(key) {
var pureKey = isKeyMatched(context, key);
let type;
Object.keys(typesField).forEach(key => {
const pureKey = isKeyMatched(context, key);
if(isGlobMatched(pureKey, relativePath)) {
var value = typesField[key];
const value = typesField[key];
if(!type && /\/\*$/.test(value))

@@ -185,0 +191,0 @@ throw new Error("value ('" + value + "') of key '" + key + "' contains '*', but there is no previous value defined");

59

lib/ConcordExtensionsPlugin.js

@@ -5,34 +5,37 @@ /*

*/
var concord = require("./concord");
var DescriptionFileUtils = require("./DescriptionFileUtils");
var forEachBail = require("./forEachBail");
var createInnerCallback = require("./createInnerCallback");
"use strict";
function ConcordExtensionsPlugin(source, options, target) {
this.source = source;
this.options = options;
this.target = target;
}
module.exports = ConcordExtensionsPlugin;
const concord = require("./concord");
const DescriptionFileUtils = require("./DescriptionFileUtils");
const forEachBail = require("./forEachBail");
ConcordExtensionsPlugin.prototype.apply = function(resolver) {
var target = this.target;
resolver.plugin(this.source, function(request, callback) {
var concordField = DescriptionFileUtils.getField(request.descriptionFileData, "concord");
if(!concordField) return callback();
var extensions = concord.getExtensions(request.context, concordField);
if(!extensions) return callback();
var topLevelCallback = callback;
forEachBail(extensions, function(appending, callback) {
var obj = Object.assign({}, request, {
path: request.path + appending,
relativePath: request.relativePath && (request.relativePath + appending)
module.exports = class ConcordExtensionsPlugin {
constructor(source, options, target) {
this.source = source;
this.options = options;
this.target = target;
}
apply(resolver) {
const target = resolver.ensureHook(this.target);
resolver.getHook(this.source).tapAsync("ConcordExtensionsPlugin", (request, resolveContext, callback) => {
const concordField = DescriptionFileUtils.getField(request.descriptionFileData, "concord");
if(!concordField) return callback();
const extensions = concord.getExtensions(request.context, concordField);
if(!extensions) return callback();
forEachBail(extensions, (appending, callback) => {
const obj = Object.assign({}, request, {
path: request.path + appending,
relativePath: request.relativePath && (request.relativePath + appending)
});
resolver.doResolve(target, obj, "concord extension: " + appending, resolveContext, callback);
}, (err, result) => {
if(err) return callback(err);
// Don't allow other processing
if(result === undefined) return callback(null, null);
callback(null, result);
});
resolver.doResolve(target, obj, "concord extension: " + appending, createInnerCallback(callback, topLevelCallback));
}, function(err, result) {
if(arguments.length > 0) return callback(err, result);
callback(null, null);
});
});
}
};

47

lib/ConcordMainPlugin.js

@@ -5,27 +5,30 @@ /*

*/
var path = require("path");
var concord = require("./concord");
var DescriptionFileUtils = require("./DescriptionFileUtils");
"use strict";
function ConcordMainPlugin(source, options, target) {
this.source = source;
this.options = options;
this.target = target;
}
module.exports = ConcordMainPlugin;
const path = require("path");
const concord = require("./concord");
const DescriptionFileUtils = require("./DescriptionFileUtils");
ConcordMainPlugin.prototype.apply = function(resolver) {
var target = this.target;
resolver.plugin(this.source, function(request, callback) {
if(request.path !== request.descriptionFileRoot) return callback();
var concordField = DescriptionFileUtils.getField(request.descriptionFileData, "concord");
if(!concordField) return callback();
var mainModule = concord.getMain(request.context, concordField);
if(!mainModule) return callback();
var obj = Object.assign({}, request, {
request: mainModule
module.exports = class ConcordMainPlugin {
constructor(source, options, target) {
this.source = source;
this.options = options;
this.target = target;
}
apply(resolver) {
const target = resolver.ensureHook(this.target);
resolver.getHook(this.source).tapAsync("ConcordMainPlugin", (request, resolveContext, callback) => {
if(request.path !== request.descriptionFileRoot) return callback();
const concordField = DescriptionFileUtils.getField(request.descriptionFileData, "concord");
if(!concordField) return callback();
const mainModule = concord.getMain(request.context, concordField);
if(!mainModule) return callback();
const obj = Object.assign({}, request, {
request: mainModule
});
const filename = path.basename(request.descriptionFilePath);
return resolver.doResolve(target, obj, "use " + mainModule + " from " + filename, resolveContext, callback);
});
var filename = path.basename(request.descriptionFilePath);
return resolver.doResolve(target, obj, "use " + mainModule + " from " + filename, callback);
});
}
};

73

lib/ConcordModulesPlugin.js

@@ -5,41 +5,44 @@ /*

*/
var concord = require("./concord");
var DescriptionFileUtils = require("./DescriptionFileUtils");
var createInnerCallback = require("./createInnerCallback");
var getInnerRequest = require("./getInnerRequest");
"use strict";
function ConcordModulesPlugin(source, options, target) {
this.source = source;
this.options = options;
this.target = target;
}
module.exports = ConcordModulesPlugin;
const concord = require("./concord");
const DescriptionFileUtils = require("./DescriptionFileUtils");
const getInnerRequest = require("./getInnerRequest");
ConcordModulesPlugin.prototype.apply = function(resolver) {
var target = this.target;
resolver.plugin(this.source, function(request, callback) {
var innerRequest = getInnerRequest(resolver, request);
if(!innerRequest) return callback();
var concordField = DescriptionFileUtils.getField(request.descriptionFileData, "concord");
if(!concordField) return callback();
var data = concord.matchModule(request.context, concordField, innerRequest);
if(data === innerRequest) return callback();
if(data === undefined) return callback();
if(data === false) {
var ignoreObj = Object.assign({}, request, {
path: false
module.exports = class ConcordModulesPlugin {
constructor(source, options, target) {
this.source = source;
this.options = options;
this.target = target;
}
apply(resolver) {
const target = resolver.ensureHook(this.target);
resolver.getHook(this.source).tapAsync("ConcordModulesPlugin", (request, resolveContext, callback) => {
const innerRequest = getInnerRequest(resolver, request);
if(!innerRequest) return callback();
const concordField = DescriptionFileUtils.getField(request.descriptionFileData, "concord");
if(!concordField) return callback();
const data = concord.matchModule(request.context, concordField, innerRequest);
if(data === innerRequest) return callback();
if(data === undefined) return callback();
if(data === false) {
const ignoreObj = Object.assign({}, request, {
path: false
});
return callback(null, ignoreObj);
}
const obj = Object.assign({}, request, {
path: request.descriptionFileRoot,
request: data
});
return callback(null, ignoreObj);
}
var obj = Object.assign({}, request, {
path: request.descriptionFileRoot,
request: data
resolver.doResolve(target, obj, "aliased from description file " + request.descriptionFilePath + " with mapping '" + innerRequest + "' to '" + data + "'", resolveContext, (err, result) => {
if(err) return callback(err);
// Don't allow other aliasing or raw request
if(result === undefined) return callback(null, null);
callback(null, result);
});
});
resolver.doResolve(target, obj, "aliased from description file " + request.descriptionFilePath + " with mapping '" + innerRequest + "' to '" + data + "'", createInnerCallback(function(err, result) {
if(arguments.length > 0) return callback(err, result);
// Don't allow other aliasing or raw request
callback(null, null);
}, callback));
});
}
};

43

lib/createInnerCallback.js

@@ -5,7 +5,11 @@ /*

*/
module.exports = function createInnerCallback(callback, options, message, messageOptional) {
var log = options.log;
"use strict";
const util = require("util");
module.exports = util.deprecate(function createInnerCallback(callback, options, message, messageOptional) {
const log = options.log;
if(!log) {
if(options.stack !== callback.stack) {
var callbackWrapper = function callbackWrapper() {
const callbackWrapper = function callbackWrapper() {
return callback.apply(this, arguments);

@@ -21,23 +25,24 @@ };

function loggingCallbackWrapper() {
var i;
if(message) {
if(!messageOptional || theLog.length > 0) {
log(message);
for(i = 0; i < theLog.length; i++)
log(" " + theLog[i]);
}
} else {
for(i = 0; i < theLog.length; i++)
log(theLog[i]);
}
return callback.apply(this, arguments);
}
var theLog = [];
loggingCallbackWrapper.log = function writeLog(msg) {
theLog.push(msg);
};
if(message) {
if(!messageOptional) {
log(message);
}
loggingCallbackWrapper.log = function writeLog(msg) {
if(messageOptional) {
log(message);
messageOptional = false;
}
log(" " + msg);
};
} else {
loggingCallbackWrapper.log = function writeLog(msg) {
log(msg);
};
}
loggingCallbackWrapper.stack = options.stack;
loggingCallbackWrapper.missing = options.missing;
return loggingCallbackWrapper;
};
}, "Pass resolveContext instead and use createInnerContext");

41

lib/DescriptionFilePlugin.js

@@ -1,10 +0,10 @@

"use strict";
/*
MIT License http://www.opensource.org/licenses/mit-license.php
Author Tobias Koppers @sokra
MIT License http://www.opensource.org/licenses/mit-license.php
Author Tobias Koppers @sokra
*/
const createInnerCallback = require("./createInnerCallback");
"use strict";
const DescriptionFileUtils = require("./DescriptionFileUtils");
class DescriptionFilePlugin {
module.exports = class DescriptionFilePlugin {
constructor(source, filenames, target) {

@@ -17,15 +17,14 @@ this.source = source;

apply(resolver) {
const filenames = this.filenames;
const target = this.target;
resolver.plugin(this.source, (request, callback) => {
const target = resolver.ensureHook(this.target);
resolver.getHook(this.source).tapAsync("DescriptionFilePlugin", (request, resolveContext, callback) => {
const directory = request.path;
DescriptionFileUtils.loadDescriptionFile(resolver, directory, filenames, ((err, result) => {
DescriptionFileUtils.loadDescriptionFile(resolver, directory, this.filenames, resolveContext, (err, result) => {
if(err) return callback(err);
if(!result) {
if(callback.missing) {
filenames.forEach((filename) => {
callback.missing.push(resolver.join(directory, filename));
if(resolveContext.missing) {
this.filenames.forEach((filename) => {
resolveContext.missing.add(resolver.join(directory, filename));
});
}
if(callback.log) callback.log("No description file found");
if(resolveContext.log) resolveContext.log("No description file found");
return callback();

@@ -40,14 +39,12 @@ }

});
resolver.doResolve(target, obj, "using description file: " + result.path + " (relative path: " + relativePath + ")", createInnerCallback((err, result) => {
resolver.doResolve(target, obj, "using description file: " + result.path + " (relative path: " + relativePath + ")", resolveContext, (err, result) => {
if(err) return callback(err);
if(result) return callback(null, result);
// Don't allow other description files or none at all
callback(null, null);
}, callback));
}));
// Don't allow other processing
if(result === undefined) return callback(null, null);
callback(null, result);
});
});
});
}
}
module.exports = DescriptionFilePlugin;
};

31

lib/DescriptionFileUtils.js

@@ -5,10 +5,12 @@ /*

*/
var forEachBail = require("./forEachBail");
"use strict";
function loadDescriptionFile(resolver, directory, filenames, callback) {
const forEachBail = require("./forEachBail");
function loadDescriptionFile(resolver, directory, filenames, resolveContext, callback) {
(function findDescriptionFile() {
forEachBail(filenames, function(filename, callback) {
var descriptionFilePath = resolver.join(directory, filename);
forEachBail(filenames, (filename, callback) => {
const descriptionFilePath = resolver.join(directory, filename);
if(resolver.fileSystem.readJson) {
resolver.fileSystem.readJson(descriptionFilePath, function(err, content) {
resolver.fileSystem.readJson(descriptionFilePath, (err, content) => {
if(err) {

@@ -21,6 +23,7 @@ if(typeof err.code !== "undefined") return callback();

} else {
resolver.fileSystem.readFile(descriptionFilePath, function(err, content) {
resolver.fileSystem.readFile(descriptionFilePath, (err, content) => {
if(err) return callback();
let json;
try {
var json = JSON.parse(content);
json = JSON.parse(content);
} catch(e) {

@@ -35,4 +38,4 @@ onJson(e);

if(err) {
if(callback.log)
callback.log(descriptionFilePath + " (directory description file): " + err);
if(resolveContext.log)
resolveContext.log(descriptionFilePath + " (directory description file): " + err);
else

@@ -48,3 +51,3 @@ err.message = descriptionFilePath + " (directory description file): " + err;

}
}, function(err, result) {
}, (err, result) => {
if(err) return callback(err);

@@ -68,4 +71,4 @@ if(result) {

if(Array.isArray(field)) {
var current = content;
for(var j = 0; j < field.length; j++) {
let current = content;
for(let j = 0; j < field.length; j++) {
if(current === null || typeof current !== "object") {

@@ -89,5 +92,5 @@ current = null;

if(directory === "/") return null;
var i = directory.lastIndexOf("/"),
const i = directory.lastIndexOf("/"),
j = directory.lastIndexOf("\\");
var p = i < 0 ? j : j < 0 ? i : i < j ? j : i;
const p = i < 0 ? j : j < 0 ? i : i < j ? j : i;
if(p < 0) return null;

@@ -94,0 +97,0 @@ return directory.substr(0, p || 1);

51

lib/DirectoryExistsPlugin.js

@@ -5,27 +5,30 @@ /*

*/
function DirectoryExistsPlugin(source, target) {
this.source = source;
this.target = target;
}
module.exports = DirectoryExistsPlugin;
"use strict";
DirectoryExistsPlugin.prototype.apply = function(resolver) {
var target = this.target;
resolver.plugin(this.source, function(request, callback) {
var fs = this.fileSystem;
var directory = request.path;
fs.stat(directory, function(err, stat) {
if(err || !stat) {
if(callback.missing) callback.missing.push(directory);
if(callback.log) callback.log(directory + " doesn't exist");
return callback();
}
if(!stat.isDirectory()) {
if(callback.missing) callback.missing.push(directory);
if(callback.log) callback.log(directory + " is not a directory");
return callback();
}
this.doResolve(target, request, "existing directory", callback);
}.bind(this));
});
module.exports = class DirectoryExistsPlugin {
constructor(source, target) {
this.source = source;
this.target = target;
}
apply(resolver) {
const target = resolver.ensureHook(this.target);
resolver.getHook(this.source).tapAsync("DirectoryExistsPlugin", (request, resolveContext, callback) => {
const fs = resolver.fileSystem;
const directory = request.path;
fs.stat(directory, (err, stat) => {
if(err || !stat) {
if(resolveContext.missing) resolveContext.missing.add(directory);
if(resolveContext.log) resolveContext.log(directory + " doesn't exist");
return callback();
}
if(!stat.isDirectory()) {
if(resolveContext.missing) resolveContext.missing.add(directory);
if(resolveContext.log) resolveContext.log(directory + " is not a directory");
return callback();
}
resolver.doResolve(target, request, "existing directory", resolveContext, callback);
});
});
}
};

51

lib/FileExistsPlugin.js

@@ -5,27 +5,30 @@ /*

*/
function FileExistsPlugin(source, target) {
this.source = source;
this.target = target;
}
module.exports = FileExistsPlugin;
"use strict";
FileExistsPlugin.prototype.apply = function(resolver) {
var target = this.target;
resolver.plugin(this.source, function(request, callback) {
var fs = this.fileSystem;
var file = request.path;
fs.stat(file, function(err, stat) {
if(err || !stat) {
if(callback.missing) callback.missing.push(file);
if(callback.log) callback.log(file + " doesn't exist");
return callback();
}
if(!stat.isFile()) {
if(callback.missing) callback.missing.push(file);
if(callback.log) callback.log(file + " is not a file");
return callback();
}
this.doResolve(target, request, "existing file: " + file, callback, true);
}.bind(this));
});
module.exports = class FileExistsPlugin {
constructor(source, target) {
this.source = source;
this.target = target;
}
apply(resolver) {
const target = resolver.ensureHook(this.target);
const fs = resolver.fileSystem;
resolver.getHook(this.source).tapAsync("FileExistsPlugin", (request, resolveContext, callback) => {
const file = request.path;
fs.stat(file, (err, stat) => {
if(err || !stat) {
if(resolveContext.missing) resolveContext.missing.add(file);
if(resolveContext.log) resolveContext.log(file + " doesn't exist");
return callback();
}
if(!stat.isFile()) {
if(resolveContext.missing) resolveContext.missing.add(file);
if(resolveContext.log) resolveContext.log(file + " is not a file");
return callback();
}
resolver.doResolve(target, request, "existing file: " + file, resolveContext, callback);
});
});
}
};

29

lib/FileKindPlugin.js

@@ -5,16 +5,19 @@ /*

*/
function FileKindPlugin(source, target) {
this.source = source;
this.target = target;
}
module.exports = FileKindPlugin;
"use strict";
FileKindPlugin.prototype.apply = function(resolver) {
var target = this.target;
resolver.plugin(this.source, function(request, callback) {
if(request.directory) return callback();
var obj = Object.assign({}, request);
delete obj.directory;
resolver.doResolve(target, obj, null, callback);
});
module.exports = class FileKindPlugin {
constructor(source, target) {
this.source = source;
this.target = target;
}
apply(resolver) {
const target = resolver.ensureHook(this.target);
resolver.getHook(this.source).tapAsync("FileKindPlugin", (request, resolveContext, callback) => {
if(request.directory) return callback();
const obj = Object.assign({}, request);
delete obj.directory;
resolver.doResolve(target, obj, null, resolveContext, callback);
});
}
};

30

lib/forEachBail.js

@@ -5,9 +5,11 @@ /*

*/
"use strict";
module.exports = function forEachBail(array, iterator, callback) {
if(array.length === 0) return callback();
var currentPos = array.length;
var currentResult;
var done = [];
for(var i = 0; i < array.length; i++) {
var itCb = createIteratorCallback(i);
let currentPos = array.length;
let currentResult;
let done = [];
for(let i = 0; i < array.length; i++) {
const itCb = createIteratorCallback(i);
iterator(array[i], itCb);

@@ -20,7 +22,7 @@ if(currentPos === 0) break;

if(i >= currentPos) return; // ignore
var args = Array.prototype.slice.call(arguments);
const args = Array.prototype.slice.call(arguments);
done.push(i);
if(args.length > 0) {
currentPos = i + 1;
done = done.filter(function(item) {
done = done.filter(item => {
return item <= i;

@@ -40,7 +42,7 @@ });

if(array.length === 0) return callback();
var currentPos = array.length;
var currentResult;
var done = [];
for(var i = 0; i < array.length; i++) {
var itCb = createIteratorCallback(i);
let currentPos = array.length;
let currentResult;
let done = [];
for(let i = 0; i < array.length; i++) {
const itCb = createIteratorCallback(i);
iterator(array[i], i, itCb);

@@ -53,7 +55,7 @@ if(currentPos === 0) break;

if(i >= currentPos) return; // ignore
var args = Array.prototype.slice.call(arguments);
const args = Array.prototype.slice.call(arguments);
done.push(i);
if(args.length > 0) {
currentPos = i + 1;
done = done.filter(function(item) {
done = done.filter(item => {
return item <= i;

@@ -60,0 +62,0 @@ });

4

lib/getInnerRequest.js

@@ -5,2 +5,4 @@ /*

*/
"use strict";
module.exports = function getInnerRequest(resolver, request) {

@@ -11,3 +13,3 @@ if(typeof request.__innerRequest === "string" &&

return request.__innerRequest;
var innerRequest;
let innerRequest;
if(request.request) {

@@ -14,0 +16,0 @@ innerRequest = request.request;

18

lib/getPaths.js

@@ -5,10 +5,12 @@ /*

*/
"use strict";
module.exports = function getPaths(path) {
var parts = path.split(/(.*?[\\\/]+)/);
var paths = [path];
var seqments = [parts[parts.length - 1]];
var part = parts[parts.length - 1];
const parts = path.split(/(.*?[\\\/]+)/);
const paths = [path];
const seqments = [parts[parts.length - 1]];
let part = parts[parts.length - 1];
path = path.substr(0, path.length - part.length - 1);
paths.push(path);
for(var i = parts.length - 2; i > 2; i -= 2) {
for(let i = parts.length - 2; i > 2; i -= 2) {
part = parts[i];

@@ -28,8 +30,8 @@ path = path.substr(0, path.length - part.length) || "/";

module.exports.basename = function basename(path) {
var i = path.lastIndexOf("/"),
const i = path.lastIndexOf("/"),
j = path.lastIndexOf("\\");
var p = i < 0 ? j : j < 0 ? i : i < j ? j : i;
const p = i < 0 ? j : j < 0 ? i : i < j ? j : i;
if(p < 0) return null;
var s = path.substr(p + 1);
const s = path.substr(p + 1);
return s;
};

56

lib/globToRegExp.js

@@ -5,2 +5,4 @@ /*

*/
"use strict";
function globToRegExp(glob) {

@@ -23,9 +25,9 @@ // * [^\\\/]*

}
var tokens = tokenize(glob);
var process = createRoot();
var regExpStr = tokens.map(process).join("");
const tokens = tokenize(glob);
const process = createRoot();
const regExpStr = tokens.map(process).join("");
return new RegExp("^" + regExpStr + "$");
}
var SIMPLE_TOKENS = {
const SIMPLE_TOKENS = {
"@(": "one",

@@ -48,6 +50,6 @@ "?(": "zero-one",

function tokenize(glob) {
return glob.split(/([@?+*]\(|\/\*\*\/|\*\*|[?*]|\[[\!\^]?(?:[^\]\\]|\\.)+\]|\{|,|\/|[|)}])/g).map(function(item) {
return glob.split(/([@?+*]\(|\/\*\*\/|\*\*|[?*]|\[[\!\^]?(?:[^\]\\]|\\.)+\]|\{|,|\/|[|)}])/g).map(item => {
if(!item)
return null;
var t = SIMPLE_TOKENS[item];
const t = SIMPLE_TOKENS[item];
if(t) {

@@ -81,5 +83,5 @@ return {

function createRoot() {
var inOr = [];
var process = createSeqment();
var initial = true;
const inOr = [];
const process = createSeqment();
let initial = true;
return function(token) {

@@ -110,5 +112,7 @@ switch(token.type) {

default:
var result = process(token, initial);
initial = false;
return result;
{
const result = process(token, initial);
initial = false;
return result;
}
}

@@ -119,4 +123,4 @@ };

function createSeqment() {
var inSeqment = [];
var process = createSimple();
const inSeqment = [];
const process = createSimple();
return function(token, initial) {

@@ -140,14 +144,16 @@ switch(token.type) {

case "closing-segment":
var segment = inSeqment.pop();
switch(segment) {
case "one":
return ")";
case "one-many":
return ")+";
case "zero-many":
return ")*";
case "zero-one":
return ")?";
{
const segment = inSeqment.pop();
switch(segment) {
case "one":
return ")";
case "one-many":
return ")+";
case "zero-many":
return ")*";
case "zero-one":
return ")?";
}
throw new Error("Unexcepted segment " + segment);
}
throw new Error("Unexcepted segment " + segment);
case "end":

@@ -154,0 +160,0 @@ if(inSeqment.length > 0) {

31

lib/JoinRequestPlugin.js

@@ -5,18 +5,21 @@ /*

*/
function JoinRequestPlugin(source, target) {
this.source = source;
this.target = target;
}
module.exports = JoinRequestPlugin;
"use strict";
JoinRequestPlugin.prototype.apply = function(resolver) {
var target = this.target;
resolver.plugin(this.source, function(request, callback) {
var obj = Object.assign({}, request, {
path: resolver.join(request.path, request.request),
relativePath: request.relativePath && resolver.join(request.relativePath, request.request),
request: undefined
module.exports = class JoinRequestPlugin {
constructor(source, target) {
this.source = source;
this.target = target;
}
apply(resolver) {
const target = resolver.ensureHook(this.target);
resolver.getHook(this.source).tapAsync("JoinRequestPlugin", (request, resolveContext, callback) => {
const obj = Object.assign({}, request, {
path: resolver.join(request.path, request.request),
relativePath: request.relativePath && resolver.join(request.relativePath, request.request),
request: undefined
});
resolver.doResolve(target, obj, null, resolveContext, callback);
});
resolver.doResolve(target, obj, null, callback);
});
}
};

41

lib/LogInfoPlugin.js

@@ -5,22 +5,25 @@ /*

*/
function LogInfoPlugin(source) {
this.source = source;
}
module.exports = LogInfoPlugin;
"use strict";
LogInfoPlugin.prototype.apply = function(resolver) {
var source = this.source;
resolver.plugin(this.source, function(request, callback) {
if(!callback.log) return callback();
var log = callback.log;
var prefix = "[" + source + "] ";
if(request.path) log(prefix + "Resolving in directory: " + request.path);
if(request.request) log(prefix + "Resolving request: " + request.request);
if(request.module) log(prefix + "Request is an module request.");
if(request.directory) log(prefix + "Request is a directory request.");
if(request.query) log(prefix + "Resolving request query: " + request.query);
if(request.descriptionFilePath) log(prefix + "Has description data from " + request.descriptionFilePath);
if(request.relativePath) log(prefix + "Relative path from description file is: " + request.relativePath);
callback();
});
module.exports = class LogInfoPlugin {
constructor(source) {
this.source = source;
}
apply(resolver) {
const source = this.source;
resolver.getHook(this.source).tapAsync("LogInfoPlugin", (request, resolveContext, callback) => {
if(!resolveContext.log) return callback();
const log = resolveContext.log;
const prefix = "[" + source + "] ";
if(request.path) log(prefix + "Resolving in directory: " + request.path);
if(request.request) log(prefix + "Resolving request: " + request.request);
if(request.module) log(prefix + "Request is an module request.");
if(request.directory) log(prefix + "Request is a directory request.");
if(request.query) log(prefix + "Resolving request query: " + request.query);
if(request.descriptionFilePath) log(prefix + "Has description data from " + request.descriptionFilePath);
if(request.relativePath) log(prefix + "Relative path from description file is: " + request.relativePath);
callback();
});
}
};

78

lib/MainFieldPlugin.js

@@ -5,45 +5,47 @@ /*

*/
var path = require("path");
"use strict";
function MainFieldPlugin(source, options, target) {
this.source = source;
this.options = options;
this.target = target;
}
module.exports = MainFieldPlugin;
const path = require("path");
MainFieldPlugin.prototype.apply = function(resolver) {
var target = this.target;
var options = this.options;
resolver.plugin(this.source, function mainField(request, callback) {
if(request.path !== request.descriptionFileRoot) return callback();
var content = request.descriptionFileData;
var filename = path.basename(request.descriptionFilePath);
var mainModule;
var field = options.name;
if(Array.isArray(field)) {
var current = content;
for(var j = 0; j < field.length; j++) {
if(current === null || typeof current !== "object") {
current = null;
break;
module.exports = class MainFieldPlugin {
constructor(source, options, target) {
this.source = source;
this.options = options;
this.target = target;
}
apply(resolver) {
const target = resolver.ensureHook(this.target);
resolver.getHook(this.source).tapAsync("MainFieldPlugin", (request, resolveContext, callback) => {
if(request.path !== request.descriptionFileRoot) return callback();
const content = request.descriptionFileData;
const filename = path.basename(request.descriptionFilePath);
let mainModule;
const field = this.options.name;
if(Array.isArray(field)) {
let current = content;
for(let j = 0; j < field.length; j++) {
if(current === null || typeof current !== "object") {
current = null;
break;
}
current = current[field[j]];
}
current = current[field[j]];
if(typeof current === "string") {
mainModule = current;
}
} else {
if(typeof content[field] === "string") {
mainModule = content[field];
}
}
if(typeof current === "string") {
mainModule = current;
}
} else {
if(typeof content[field] === "string") {
mainModule = content[field];
}
}
if(!mainModule) return callback();
if(options.forceRelative && !/^\.\.?\//.test(mainModule))
mainModule = "./" + mainModule;
var obj = Object.assign({}, request, {
request: mainModule
if(!mainModule) return callback();
if(this.options.forceRelative && !/^\.\.?\//.test(mainModule))
mainModule = "./" + mainModule;
const obj = Object.assign({}, request, {
request: mainModule
});
return resolver.doResolve(target, obj, "use " + mainModule + " from " + this.options.name + " in " + filename, resolveContext, callback);
});
return resolver.doResolve(target, obj, "use " + mainModule + " from " + options.name + " in " + filename, callback);
});
}
};

58

lib/ModuleAppendPlugin.js

@@ -5,32 +5,34 @@ /*

*/
function ModuleAppendPlugin(source, appending, target) {
this.source = source;
this.appending = appending;
this.target = target;
}
module.exports = ModuleAppendPlugin;
"use strict";
ModuleAppendPlugin.prototype.apply = function(resolver) {
var appending = this.appending;
var target = this.target;
resolver.plugin(this.source, function(request, callback) {
var i = request.request.indexOf("/"),
j = request.request.indexOf("\\");
var p = i < 0 ? j : j < 0 ? i : i < j ? i : j;
var moduleName, remainingRequest;
if(p < 0) {
moduleName = request.request;
remainingRequest = "";
} else {
moduleName = request.request.substr(0, p);
remainingRequest = request.request.substr(p);
}
if(moduleName === "." || moduleName === "..")
return callback();
var moduleFinalName = moduleName + appending;
var obj = Object.assign({}, request, {
request: moduleFinalName + remainingRequest
module.exports = class ModuleAppendPlugin {
constructor(source, appending, target) {
this.source = source;
this.appending = appending;
this.target = target;
}
apply(resolver) {
const target = resolver.ensureHook(this.target);
resolver.getHook(this.source).tapAsync("ModuleAppendPlugin", (request, resolveContext, callback) => {
const i = request.request.indexOf("/"),
j = request.request.indexOf("\\");
const p = i < 0 ? j : j < 0 ? i : i < j ? i : j;
let moduleName, remainingRequest;
if(p < 0) {
moduleName = request.request;
remainingRequest = "";
} else {
moduleName = request.request.substr(0, p);
remainingRequest = request.request.substr(p);
}
if(moduleName === "." || moduleName === "..")
return callback();
const moduleFinalName = moduleName + this.appending;
const obj = Object.assign({}, request, {
request: moduleFinalName + remainingRequest
});
resolver.doResolve(target, obj, "module variation " + moduleFinalName, resolveContext, callback);
});
resolver.doResolve(target, obj, "module variation " + moduleFinalName, callback);
});
}
};

38

lib/ModuleKindPlugin.js

@@ -5,23 +5,25 @@ /*

*/
var createInnerCallback = require("./createInnerCallback");
"use strict";
function ModuleKindPlugin(source, target) {
this.source = source;
this.target = target;
}
module.exports = ModuleKindPlugin;
module.exports = class ModuleKindPlugin {
constructor(source, target) {
this.source = source;
this.target = target;
}
ModuleKindPlugin.prototype.apply = function(resolver) {
var target = this.target;
resolver.plugin(this.source, function(request, callback) {
if(!request.module) return callback();
var obj = Object.assign({}, request);
delete obj.module;
resolver.doResolve(target, obj, "resolve as module", createInnerCallback(function(err, result) {
if(arguments.length > 0) return callback(err, result);
apply(resolver) {
const target = resolver.ensureHook(this.target);
resolver.getHook(this.source).tapAsync("ModuleKindPlugin", (request, resolveContext, callback) => {
if(!request.module) return callback();
const obj = Object.assign({}, request);
delete obj.module;
resolver.doResolve(target, obj, "resolve as module", resolveContext, (err, result) => {
if(err) return callback(err);
// Don't allow other alternatives
callback(null, null);
}, callback));
});
// Don't allow other alternatives
if(result === undefined) return callback(null, null);
callback(null, result);
});
});
}
};

76

lib/ModulesInHierachicDirectoriesPlugin.js

@@ -5,43 +5,41 @@ /*

*/
var createInnerCallback = require("./createInnerCallback");
var forEachBail = require("./forEachBail");
var getPaths = require("./getPaths");
"use strict";
function ModulesInHierachicDirectoriesPlugin(source, directories, target) {
this.source = source;
this.directories = [].concat(directories);
this.target = target;
}
module.exports = ModulesInHierachicDirectoriesPlugin;
const forEachBail = require("./forEachBail");
const getPaths = require("./getPaths");
ModulesInHierachicDirectoriesPlugin.prototype.apply = function(resolver) {
var directories = this.directories;
var target = this.target;
resolver.plugin(this.source, function(request, callback) {
var fs = this.fileSystem;
var topLevelCallback = callback;
var addrs = getPaths(request.path).paths.map(function(p) {
return directories.map(function(d) {
return this.join(p, d);
}, this);
}, this).reduce(function(array, p) {
array.push.apply(array, p);
return array;
}, []);
forEachBail(addrs, function(addr, callback) {
fs.stat(addr, function(err, stat) {
if(!err && stat && stat.isDirectory()) {
var obj = Object.assign({}, request, {
path: addr,
request: "./" + request.request
});
var message = "looking for modules in " + addr;
return resolver.doResolve(target, obj, message, createInnerCallback(callback, topLevelCallback));
}
if(topLevelCallback.log) topLevelCallback.log(addr + " doesn't exist or is not a directory");
if(topLevelCallback.missing) topLevelCallback.missing.push(addr);
return callback();
});
}, callback);
});
module.exports = class ModulesInHierachicDirectoriesPlugin {
constructor(source, directories, target) {
this.source = source;
this.directories = [].concat(directories);
this.target = target;
}
apply(resolver) {
const target = resolver.ensureHook(this.target);
resolver.getHook(this.source).tapAsync("ModulesInHierachicDirectoriesPlugin", (request, resolveContext, callback) => {
const fs = resolver.fileSystem;
const addrs = getPaths(request.path).paths.map(p => {
return this.directories.map(d => resolver.join(p, d));
}).reduce((array, p) => {
array.push.apply(array, p);
return array;
}, []);
forEachBail(addrs, (addr, callback) => {
fs.stat(addr, (err, stat) => {
if(!err && stat && stat.isDirectory()) {
const obj = Object.assign({}, request, {
path: addr,
request: "./" + request.request
});
const message = "looking for modules in " + addr;
return resolver.doResolve(target, obj, message, resolveContext, callback);
}
if(resolveContext.log) resolveContext.log(addr + " doesn't exist or is not a directory");
if(resolveContext.missing) resolveContext.missing.add(addr);
return callback();
});
}, callback);
});
}
};

32

lib/ModulesInRootPlugin.js

@@ -5,19 +5,21 @@ /*

*/
function ModulesInRootPlugin(source, path, target) {
this.source = source;
this.path = path;
this.target = target;
}
module.exports = ModulesInRootPlugin;
"use strict";
ModulesInRootPlugin.prototype.apply = function(resolver) {
var target = this.target;
var path = this.path;
resolver.plugin(this.source, function(request, callback) {
var obj = Object.assign({}, request, {
path: path,
request: "./" + request.request
module.exports = class ModulesInRootPlugin {
constructor(source, path, target) {
this.source = source;
this.path = path;
this.target = target;
}
apply(resolver) {
const target = resolver.ensureHook(this.target);
resolver.getHook(this.source).tapAsync("ModulesInRootPlugin", (request, resolveContext, callback) => {
const obj = Object.assign({}, request, {
path: this.path,
request: "./" + request.request
});
resolver.doResolve(target, obj, "looking for modules in " + this.path, resolveContext, callback);
});
resolver.doResolve(target, obj, "looking for modules in " + path, callback, true);
});
}
};

23

lib/NextPlugin.js

@@ -5,13 +5,16 @@ /*

*/
function NextPlugin(source, target) {
this.source = source;
this.target = target;
}
module.exports = NextPlugin;
"use strict";
NextPlugin.prototype.apply = function(resolver) {
var target = this.target;
resolver.plugin(this.source, function(request, callback) {
resolver.doResolve(target, request, null, callback);
});
module.exports = class NextPlugin {
constructor(source, target) {
this.source = source;
this.target = target;
}
apply(resolver) {
const target = resolver.ensureHook(this.target);
resolver.getHook(this.source).tapAsync("NextPlugin", (request, resolveContext, callback) => {
resolver.doResolve(target, request, null, resolveContext, callback);
});
}
};

68

lib/node.js

@@ -5,10 +5,12 @@ /*

*/
var ResolverFactory = require("./ResolverFactory");
"use strict";
var NodeJsInputFileSystem = require("./NodeJsInputFileSystem");
var CachedInputFileSystem = require("./CachedInputFileSystem");
const ResolverFactory = require("./ResolverFactory");
var nodeFileSystem = new CachedInputFileSystem(new NodeJsInputFileSystem(), 4000);
const NodeJsInputFileSystem = require("./NodeJsInputFileSystem");
const CachedInputFileSystem = require("./CachedInputFileSystem");
var nodeContext = {
const nodeFileSystem = new CachedInputFileSystem(new NodeJsInputFileSystem(), 4000);
const nodeContext = {
environments: [

@@ -19,9 +21,10 @@ "node+es3+es5+process+native"

var asyncResolver = ResolverFactory.createResolver({
const asyncResolver = ResolverFactory.createResolver({
extensions: [".js", ".json", ".node"],
fileSystem: nodeFileSystem
});
module.exports = function resolve(context, path, request, callback) {
module.exports = function resolve(context, path, request, resolveContext, callback) {
if(typeof context === "string") {
callback = request;
callback = resolveContext;
resolveContext = request;
request = path;

@@ -31,6 +34,9 @@ path = context;

}
asyncResolver.resolve(context, path, request, callback);
if(typeof callback !== "function") {
callback = resolveContext;
}
asyncResolver.resolve(context, path, request, resolveContext, callback);
};
var syncResolver = ResolverFactory.createResolver({
const syncResolver = ResolverFactory.createResolver({
extensions: [".js", ".json", ".node"],

@@ -49,3 +55,3 @@ useSyncFileSystemCalls: true,

var asyncContextResolver = ResolverFactory.createResolver({
const asyncContextResolver = ResolverFactory.createResolver({
extensions: [".js", ".json", ".node"],

@@ -55,5 +61,6 @@ resolveToContext: true,

});
module.exports.context = function resolveContext(context, path, request, callback) {
module.exports.context = function resolveContext(context, path, request, resolveContext, callback) {
if(typeof context === "string") {
callback = request;
callback = resolveContext;
resolveContext = request;
request = path;

@@ -63,6 +70,9 @@ path = context;

}
asyncContextResolver.resolve(context, path, request, callback);
if(typeof callback !== "function") {
callback = resolveContext;
}
asyncContextResolver.resolve(context, path, request, resolveContext, callback);
};
var syncContextResolver = ResolverFactory.createResolver({
const syncContextResolver = ResolverFactory.createResolver({
extensions: [".js", ".json", ".node"],

@@ -82,3 +92,3 @@ resolveToContext: true,

var asyncLoaderResolver = ResolverFactory.createResolver({
const asyncLoaderResolver = ResolverFactory.createResolver({
extensions: [".js", ".json", ".node"],

@@ -89,5 +99,6 @@ moduleExtensions: ["-loader"],

});
module.exports.loader = function resolveLoader(context, path, request, callback) {
module.exports.loader = function resolveLoader(context, path, request, resolveContext, callback) {
if(typeof context === "string") {
callback = request;
callback = resolveContext;
resolveContext = request;
request = path;

@@ -97,6 +108,9 @@ path = context;

}
asyncLoaderResolver.resolve(context, path, request, callback);
if(typeof callback !== "function") {
callback = resolveContext;
}
asyncLoaderResolver.resolve(context, path, request, resolveContext, callback);
};
var syncLoaderResolver = ResolverFactory.createResolver({
const syncLoaderResolver = ResolverFactory.createResolver({
extensions: [".js", ".json", ".node"],

@@ -121,6 +135,7 @@ moduleExtensions: ["-loader"],

}, options);
var resolver = ResolverFactory.createResolver(options);
return function(context, path, request, callback) {
const resolver = ResolverFactory.createResolver(options);
return function(context, path, request, resolveContext, callback) {
if(typeof context === "string") {
callback = request;
callback = resolveContext;
resolveContext = request;
request = path;

@@ -130,3 +145,6 @@ path = context;

}
resolver.resolve(context, path, request, callback);
if(typeof callback !== "function") {
callback = resolveContext;
}
resolver.resolve(context, path, request, resolveContext, callback);
};

@@ -140,3 +158,3 @@ };

}, options);
var resolver = ResolverFactory.createResolver(options);
const resolver = ResolverFactory.createResolver(options);
return function(context, path, request) {

@@ -143,0 +161,0 @@ if(typeof context === "string") {

12

lib/NodeJsInputFileSystem.js

@@ -5,4 +5,6 @@ /*

*/
var fs = require("graceful-fs");
"use strict";
const fs = require("graceful-fs");
function NodeJsInputFileSystem() {}

@@ -13,4 +15,4 @@ module.exports = NodeJsInputFileSystem;

NodeJsInputFileSystem.prototype.readdir = function readdir(path, callback) {
fs.readdir(path, function(err, files) {
callback(err, files && files.map(function(file) {
fs.readdir(path, (err, files) => {
callback(err, files && files.map(file => {
return file.normalize ? file.normalize("NFC") : file;

@@ -25,4 +27,4 @@ }));

NodeJsInputFileSystem.prototype.readdirSync = function readdirSync(path) {
var files = fs.readdirSync(path);
return files && files.map(function(file) {
const files = fs.readdirSync(path);
return files && files.map(file => {
return file.normalize ? file.normalize("NFC") : file;

@@ -29,0 +31,0 @@ });

45

lib/ParsePlugin.js

@@ -5,24 +5,27 @@ /*

*/
function ParsePlugin(source, target) {
this.source = source;
this.target = target;
}
module.exports = ParsePlugin;
"use strict";
ParsePlugin.prototype.apply = function(resolver) {
var target = this.target;
resolver.plugin(this.source, function(request, callback) {
var parsed = resolver.parse(request.request);
var obj = Object.assign({}, request, parsed);
if(request.query && !parsed.query) {
obj.query = request.query;
}
if(parsed && callback.log) {
if(parsed.module)
callback.log("Parsed request is a module");
if(parsed.directory)
callback.log("Parsed request is a directory");
}
resolver.doResolve(target, obj, null, callback);
});
module.exports = class ParsePlugin {
constructor(source, target) {
this.source = source;
this.target = target;
}
apply(resolver) {
const target = resolver.ensureHook(this.target);
resolver.getHook(this.source).tapAsync("ParsePlugin", (request, resolveContext, callback) => {
const parsed = resolver.parse(request.request);
const obj = Object.assign({}, request, parsed);
if(request.query && !parsed.query) {
obj.query = request.query;
}
if(parsed && resolveContext.log) {
if(parsed.module)
resolveContext.log("Parsed request is a module");
if(parsed.directory)
resolveContext.log("Parsed request is a directory");
}
resolver.doResolve(target, obj, null, resolveContext, callback);
});
}
};

428

lib/Resolver.js

@@ -5,224 +5,292 @@ /*

*/
var Tapable = require("tapable");
var createInnerCallback = require("./createInnerCallback");
"use strict";
function Resolver(fileSystem) {
Tapable.call(this);
this.fileSystem = fileSystem;
const util = require("util");
const Tapable = require("tapable/lib/Tapable");
const SyncHook = require("tapable/lib/SyncHook");
const AsyncSeriesBailHook = require("tapable/lib/AsyncSeriesBailHook");
const AsyncSeriesHook = require("tapable/lib/AsyncSeriesHook");
const createInnerContext = require("./createInnerContext");
const REGEXP_NOT_MODULE = /^\.$|^\.[\\\/]|^\.\.$|^\.\.[\/\\]|^\/|^[A-Z]:[\\\/]/i;
const REGEXP_DIRECTORY = /[\/\\]$/i;
const memoryFsJoin = require("memory-fs/lib/join");
const memoizedJoin = new Map();
const memoryFsNormalize = require("memory-fs/lib/normalize");
function withName(name, hook) {
hook.name = name;
return hook;
}
module.exports = Resolver;
Resolver.prototype = Object.create(Tapable.prototype);
function toCamelCase(str) {
return str.replace(/-([a-z])/g, str => str.substr(1).toUpperCase());
}
Resolver.prototype.constructor = Resolver;
const deprecatedPushToMissing = util.deprecate((set, item) => {
set.add(item);
}, "The missing array is now a Set. Use add instead of push.");
Resolver.prototype.resolveSync = function resolveSync(context, path, request) {
var err, result, sync = false;
this.resolve(context, path, request, function(e, r) {
err = e;
result = r;
sync = true;
});
if(!sync) throw new Error("Cannot 'resolveSync' because the fileSystem is not sync. Use 'resolve'!");
if(err) throw err;
return result;
};
const deprecatedResolveContextInCallback = util.deprecate((x) => {
return x;
}, "The callback argument was splitted into resolveContext and callback.");
Resolver.prototype.resolve = function resolve(context, path, request, callback) {
if(arguments.length === 3) {
throw new Error("Signature changed: context parameter added");
}
var resolver = this;
var obj = {
context: context,
path: path,
request: request
};
const deprecatedHookAsString = util.deprecate((x) => {
return x;
}, "The type arguments (string) is now a hook argument (Hook). Pass a reference to the hook instead.");
var localMissing;
var log;
var message = "resolve '" + request + "' in '" + path + "'";
function writeLog(msg) {
log.push(msg);
class Resolver extends Tapable {
constructor(fileSystem) {
super();
this.fileSystem = fileSystem;
this.hooks = {
resolveStep: withName("resolveStep", new SyncHook(["hook", "request"])),
noResolve: withName("noResolve", new SyncHook(["request", "error"])),
resolve: withName("resolve", new AsyncSeriesBailHook(["request", "resolveContext"])),
result: new AsyncSeriesHook(["result", "resolveContext"])
};
this._pluginCompat.tap("Resolver: before/after", options => {
if(/^before-/.test(options.name)) {
options.name = options.name.substr(7);
options.stage = -10;
} else if(/^after-/.test(options.name)) {
options.name = options.name.substr(6);
options.stage = 10;
}
});
this._pluginCompat.tap("Resolver: step hooks", options => {
const name = options.name;
const stepHook = !/^resolve(-s|S)tep$|^no(-r|R)esolve$/.test(name);
if(stepHook) {
options.async = true;
this.ensureHook(name);
const fn = options.fn;
options.fn = (request, resolverContext, callback) => {
const innerCallback = (err, result) => {
if(err) return callback(err);
if(result !== undefined) return callback(null, result);
callback();
};
for(const key in resolverContext) {
innerCallback[key] = resolverContext[key];
}
fn.call(this, request, innerCallback);
};
}
});
}
function logAsString() {
return log.join("\n");
ensureHook(name) {
if(typeof name !== "string") return name;
name = toCamelCase(name);
if(/^before/.test(name)) {
return this.ensureHook(name[6].toLowerCase() + name.substr(7)).withOptions({
stage: -10
});
}
if(/^after/.test(name)) {
return this.ensureHook(name[5].toLowerCase() + name.substr(6)).withOptions({
stage: 10
});
}
const hook = this.hooks[name];
if(!hook) {
return this.hooks[name] = withName(name, new AsyncSeriesBailHook(["request", "resolveContext"]));
}
return hook;
}
function onError(err, result) {
if(callback.log) {
for(var i = 0; i < log.length; i++)
callback.log(log[i]);
getHook(name) {
if(typeof name !== "string") return name;
name = toCamelCase(name);
if(/^before/.test(name)) {
return this.getHook(name[6].toLowerCase() + name.substr(7)).withOptions({
stage: -10
});
}
if(/^after/.test(name)) {
return this.getHook(name[5].toLowerCase() + name.substr(6)).withOptions({
stage: 10
});
}
const hook = this.hooks[name];
if(!hook) {
throw new Error(`Hook ${name} doesn't exist`);
}
return hook;
}
if(err) return callback(err);
var error = new Error("Can't " + message);
error.details = logAsString();
error.missing = localMissing;
resolver.applyPlugins("no-resolve", obj, error);
return callback(error);
resolveSync(context, path, request) {
let err, result, sync = false;
this.resolve(context, path, request, {}, (e, r) => {
err = e;
result = r;
sync = true;
});
if(!sync) throw new Error("Cannot 'resolveSync' because the fileSystem is not sync. Use 'resolve'!");
if(err) throw err;
return result;
}
function onResolve(err, result) {
if(!err && result) {
return callback(null, result.path === false ? false : result.path + (result.query || ""), result);
resolve(context, path, request, resolveContext, callback) {
// For backward compatiblity START
if(typeof callback !== "function") {
callback = deprecatedResolveContextInCallback(resolveContext);
}
// END
const obj = {
context: context,
path: path,
request: request
};
localMissing = [];
log = [];
const message = "resolve '" + request + "' in '" + path + "'";
return resolver.doResolve("resolve", obj, message, createInnerCallback(onError, {
log: writeLog,
missing: localMissing,
stack: callback.stack
}));
}
// Try to resolve assuming there is no error
// We don't log stuff in this case
return this.doResolve(this.hooks.resolve, obj, message, {
missing: resolveContext.missing,
stack: resolveContext.stack
}, (err, result) => {
if(!err && result) {
return callback(null, result.path === false ? false : result.path + (result.query || ""), result);
}
onResolve.missing = callback.missing;
onResolve.stack = callback.stack;
const localMissing = new Set();
// TODO remove in enhanced-resolve 5
localMissing.push = item => deprecatedPushToMissing(localMissing, item);
const log = [];
return this.doResolve("resolve", obj, message, onResolve);
};
return this.doResolve(this.hooks.resolve, obj, message, {
log: msg => {
if(resolveContext.log) {
resolveContext.log(msg);
}
log.push(msg);
},
missing: localMissing,
stack: resolveContext.stack
}, (err, result) => {
if(err) return callback(err);
Resolver.prototype.doResolve = function doResolve(type, request, message, callback) {
var resolver = this;
var stackLine = type + ": (" + request.path + ") " +
(request.request || "") + (request.query || "") +
(request.directory ? " directory" : "") +
(request.module ? " module" : "");
var newStack = [stackLine];
if(callback.stack) {
newStack = callback.stack.concat(newStack);
if(callback.stack.indexOf(stackLine) >= 0) {
// Prevent recursion
var recursionError = new Error("Recursion in resolving\nStack:\n " + newStack.join("\n "));
recursionError.recursion = true;
if(callback.log) callback.log("abort resolving because of recursion");
return callback(recursionError);
}
const error = new Error("Can't " + message + "\n" + log.join("\n"));
error.details = log.join("\n");
error.missing = Array.from(localMissing);
this.hooks.noResolve.call(obj, error);
return callback(error);
});
});
}
resolver.applyPlugins("resolve-step", type, request);
var beforePluginName = "before-" + type;
if(resolver.hasPlugins(beforePluginName)) {
resolver.applyPluginsAsyncSeriesBailResult1(beforePluginName, request, createInnerCallback(beforeInnerCallback, {
log: callback.log,
missing: callback.missing,
stack: newStack
}, message && ("before " + message), true));
} else {
runNormal();
}
doResolve(hook, request, message, resolveContext, callback) {
// For backward compatiblity START
if(typeof callback !== "function") {
callback = deprecatedResolveContextInCallback(resolveContext);
}
if(typeof hook === "string") {
const name = toCamelCase(hook);
hook = deprecatedHookAsString(this.hooks[name]);
if(!hook) {
throw new Error(`Hook "${name}" doesn't exist`);
}
}
// END
if(typeof callback !== "function") throw new Error("callback is not a function " + Array.from(arguments));
if(!resolveContext) throw new Error("resolveContext is not an object " + Array.from(arguments));
function beforeInnerCallback(err, result) {
if(arguments.length > 0) {
if(err) return callback(err);
if(result) return callback(null, result);
return callback();
const stackLine = hook.name + ": (" + request.path + ") " +
(request.request || "") + (request.query || "") +
(request.directory ? " directory" : "") +
(request.module ? " module" : "");
let newStack;
if(resolveContext.stack) {
newStack = new Set(resolveContext.stack);
if(resolveContext.stack.has(stackLine)) {
// Prevent recursion
const recursionError = new Error("Recursion in resolving\nStack:\n " + Array.from(newStack).join("\n "));
recursionError.recursion = true;
if(resolveContext.log) resolveContext.log("abort resolving because of recursion");
return callback(recursionError);
}
newStack.add(stackLine);
} else {
newStack = new Set([stackLine]);
}
runNormal();
}
this.hooks.resolveStep.call(hook, request);
function runNormal() {
if(resolver.hasPlugins(type)) {
return resolver.applyPluginsAsyncSeriesBailResult1(type, request, createInnerCallback(innerCallback, {
log: callback.log,
missing: callback.missing,
if(hook.isUsed()) {
const innerContext = createInnerContext({
log: resolveContext.log,
missing: resolveContext.missing,
stack: newStack
}, message));
}, message);
return hook.callAsync(request, innerContext, (err, result) => {
if(err) return callback(err);
if(result) return callback(null, result);
callback();
});
} else {
runAfter();
callback();
}
}
function innerCallback(err, result) {
if(arguments.length > 0) {
if(err) return callback(err);
if(result) return callback(null, result);
return callback();
parse(identifier) {
if(identifier === "") return null;
const part = {
request: "",
query: "",
module: false,
directory: false,
file: false
};
const idxQuery = identifier.indexOf("?");
if(idxQuery === 0) {
part.query = identifier;
} else if(idxQuery > 0) {
part.request = identifier.slice(0, idxQuery);
part.query = identifier.slice(idxQuery);
} else {
part.request = identifier;
}
runAfter();
if(part.request) {
part.module = this.isModule(part.request);
part.directory = this.isDirectory(part.request);
if(part.directory) {
part.request = part.request.substr(0, part.request.length - 1);
}
}
return part;
}
function runAfter() {
var afterPluginName = "after-" + type;
if(resolver.hasPlugins(afterPluginName)) {
return resolver.applyPluginsAsyncSeriesBailResult1(afterPluginName, request, createInnerCallback(afterInnerCallback, {
log: callback.log,
missing: callback.missing,
stack: newStack
}, message && ("after " + message), true));
} else {
callback();
}
isModule(path) {
return !REGEXP_NOT_MODULE.test(path);
}
function afterInnerCallback(err, result) {
if(arguments.length > 0) {
if(err) return callback(err);
if(result) return callback(null, result);
return callback();
}
return callback();
isDirectory(path) {
return REGEXP_DIRECTORY.test(path);
}
};
Resolver.prototype.parse = function parse(identifier) {
if(identifier === "") return null;
var part = {
request: "",
query: "",
module: false,
directory: false,
file: false
};
var idxQuery = identifier.indexOf("?");
if(idxQuery === 0) {
part.query = identifier;
} else if(idxQuery > 0) {
part.request = identifier.slice(0, idxQuery);
part.query = identifier.slice(idxQuery);
} else {
part.request = identifier;
}
if(part.request) {
part.module = this.isModule(part.request);
part.directory = this.isDirectory(part.request);
if(part.directory) {
part.request = part.request.substr(0, part.request.length - 1);
join(path, request) {
let cacheEntry;
let pathCache = memoizedJoin.get(path);
if(typeof pathCache === "undefined") {
memoizedJoin.set(path, pathCache = new Map());
} else {
cacheEntry = pathCache.get(request);
if(typeof cacheEntry !== "undefined")
return cacheEntry;
}
cacheEntry = memoryFsJoin(path, request);
pathCache.set(request, cacheEntry);
return cacheEntry;
}
return part;
};
var notModuleRegExp = /^\.$|^\.[\\\/]|^\.\.$|^\.\.[\/\\]|^\/|^[A-Z]:[\\\/]/i;
Resolver.prototype.isModule = function isModule(path) {
return !notModuleRegExp.test(path);
};
var directoryRegExp = /[\/\\]$/i;
Resolver.prototype.isDirectory = function isDirectory(path) {
return directoryRegExp.test(path);
};
var memoryFsJoin = require("memory-fs/lib/join");
var memoizedJoin = new Map();
Resolver.prototype.join = function(path, request) {
var cacheEntry;
var pathCache = memoizedJoin.get(path);
if(typeof pathCache === "undefined") {
memoizedJoin.set(path, pathCache = new Map());
} else {
cacheEntry = pathCache.get(request);
if(typeof cacheEntry !== "undefined")
return cacheEntry;
normalize(path) {
return memoryFsNormalize(path);
}
cacheEntry = memoryFsJoin(path, request);
pathCache.set(request, cacheEntry);
return cacheEntry;
};
}
Resolver.prototype.normalize = require("memory-fs/lib/normalize");
module.exports = Resolver;

168

lib/ResolverFactory.js

@@ -5,30 +5,32 @@ /*

*/
var Resolver = require("./Resolver");
"use strict";
var SyncAsyncFileSystemDecorator = require("./SyncAsyncFileSystemDecorator");
const Resolver = require("./Resolver");
var ParsePlugin = require("./ParsePlugin");
var DescriptionFilePlugin = require("./DescriptionFilePlugin");
var NextPlugin = require("./NextPlugin");
var TryNextPlugin = require("./TryNextPlugin");
var ModuleKindPlugin = require("./ModuleKindPlugin");
var FileKindPlugin = require("./FileKindPlugin");
var JoinRequestPlugin = require("./JoinRequestPlugin");
var ModulesInHierachicDirectoriesPlugin = require("./ModulesInHierachicDirectoriesPlugin");
var ModulesInRootPlugin = require("./ModulesInRootPlugin");
var AliasPlugin = require("./AliasPlugin");
var AliasFieldPlugin = require("./AliasFieldPlugin");
var ConcordExtensionsPlugin = require("./ConcordExtensionsPlugin");
var ConcordMainPlugin = require("./ConcordMainPlugin");
var ConcordModulesPlugin = require("./ConcordModulesPlugin");
var DirectoryExistsPlugin = require("./DirectoryExistsPlugin");
var FileExistsPlugin = require("./FileExistsPlugin");
var SymlinkPlugin = require("./SymlinkPlugin");
var MainFieldPlugin = require("./MainFieldPlugin");
var UseFilePlugin = require("./UseFilePlugin");
var AppendPlugin = require("./AppendPlugin");
var ResultPlugin = require("./ResultPlugin");
var ModuleAppendPlugin = require("./ModuleAppendPlugin");
var UnsafeCachePlugin = require("./UnsafeCachePlugin");
const SyncAsyncFileSystemDecorator = require("./SyncAsyncFileSystemDecorator");
const ParsePlugin = require("./ParsePlugin");
const DescriptionFilePlugin = require("./DescriptionFilePlugin");
const NextPlugin = require("./NextPlugin");
const TryNextPlugin = require("./TryNextPlugin");
const ModuleKindPlugin = require("./ModuleKindPlugin");
const FileKindPlugin = require("./FileKindPlugin");
const JoinRequestPlugin = require("./JoinRequestPlugin");
const ModulesInHierachicDirectoriesPlugin = require("./ModulesInHierachicDirectoriesPlugin");
const ModulesInRootPlugin = require("./ModulesInRootPlugin");
const AliasPlugin = require("./AliasPlugin");
const AliasFieldPlugin = require("./AliasFieldPlugin");
const ConcordExtensionsPlugin = require("./ConcordExtensionsPlugin");
const ConcordMainPlugin = require("./ConcordMainPlugin");
const ConcordModulesPlugin = require("./ConcordModulesPlugin");
const DirectoryExistsPlugin = require("./DirectoryExistsPlugin");
const FileExistsPlugin = require("./FileExistsPlugin");
const SymlinkPlugin = require("./SymlinkPlugin");
const MainFieldPlugin = require("./MainFieldPlugin");
const UseFilePlugin = require("./UseFilePlugin");
const AppendPlugin = require("./AppendPlugin");
const ResultPlugin = require("./ResultPlugin");
const ModuleAppendPlugin = require("./ModuleAppendPlugin");
const UnsafeCachePlugin = require("./UnsafeCachePlugin");
exports.createResolver = function(options) {

@@ -39,6 +41,6 @@

// A list of directories to resolve modules from, can be absolute path or folder name
var modules = options.modules || ["node_modules"];
let modules = options.modules || ["node_modules"];
// A list of description files to read from
var descriptionFiles = options.descriptionFiles || ["package.json"];
const descriptionFiles = options.descriptionFiles || ["package.json"];

@@ -48,43 +50,46 @@ // A list of additional resolve plugins which should be applied

// changes the original options.plugins array, causing duplicate plugins
var plugins = (options.plugins && options.plugins.slice()) || [];
const plugins = (options.plugins && options.plugins.slice()) || [];
// A list of main fields in description files
var mainFields = options.mainFields || ["main"];
let mainFields = options.mainFields || ["main"];
// A list of alias fields in description files
var aliasFields = options.aliasFields || [];
const aliasFields = options.aliasFields || [];
// A list of main files in directories
var mainFiles = options.mainFiles || ["index"];
const mainFiles = options.mainFiles || ["index"];
// A list of extensions which should be tried for files
var extensions = options.extensions || [".js", ".json", ".node"];
let extensions = options.extensions || [".js", ".json", ".node"];
// Enforce that a extension from extensions must be used
var enforceExtension = options.enforceExtension || false;
const enforceExtension = options.enforceExtension || false;
// A list of module extensions which should be tried for modules
var moduleExtensions = options.moduleExtensions || [];
let moduleExtensions = options.moduleExtensions || [];
// Enforce that a extension from moduleExtensions must be used
var enforceModuleExtension = options.enforceModuleExtension || false;
const enforceModuleExtension = options.enforceModuleExtension || false;
// A list of module alias configurations or an object which maps key to value
var alias = options.alias || [];
let alias = options.alias || [];
// Resolve symlinks to their symlinked location
var symlinks = typeof options.symlinks !== "undefined" ? options.symlinks : true;
const symlinks = typeof options.symlinks !== "undefined" ? options.symlinks : true;
// Resolve to a context instead of a file
var resolveToContext = options.resolveToContext || false;
const resolveToContext = options.resolveToContext || false;
// Use this cache object to unsafely cache the successful requests
var unsafeCache = options.unsafeCache || false;
let unsafeCache = options.unsafeCache || false;
// Whether or not the unsafeCache should include request context as part of the cache key.
var cacheWithContext = typeof options.cacheWithContext !== "undefined" ? options.cacheWithContext : true;
const cacheWithContext = typeof options.cacheWithContext !== "undefined" ? options.cacheWithContext : true;
// Enable concord description file instructions
const enableConcord = options.concord || false;
// A function which decides whether a request should be cached or not.
// an object is passed with `path` and `request` properties.
var cachePredicate = options.cachePredicate || function() {
const cachePredicate = options.cachePredicate || function() {
return true;

@@ -94,9 +99,9 @@ };

// The file system which should be used
var fileSystem = options.fileSystem;
const fileSystem = options.fileSystem;
// Use only the sync variants of the file system calls
var useSyncFileSystemCalls = options.useSyncFileSystemCalls;
// Use only the sync constiants of the file system calls
const useSyncFileSystemCalls = options.useSyncFileSystemCalls;
// A prepared Resolver to which the plugins are attached
var resolver = options.resolver;
let resolver = options.resolver;

@@ -112,7 +117,7 @@ //// options processing ////

modules = mergeFilteredToArray([].concat(modules), function(item) {
modules = mergeFilteredToArray([].concat(modules), item => {
return !isAbsolutePath(item);
});
mainFields = mainFields.map(function(item) {
mainFields = mainFields.map(item => {
if(typeof item === "string") {

@@ -128,5 +133,5 @@ item = {

if(typeof alias === "object" && !Array.isArray(alias)) {
alias = Object.keys(alias).map(function(key) {
var onlyModule = false;
var obj = alias[key];
alias = Object.keys(alias).map(key => {
let onlyModule = false;
let obj = alias[key];
if(/\$$/.test(key)) {

@@ -155,2 +160,17 @@ onlyModule = true;

resolver.ensureHook("resolve");
resolver.ensureHook("parsedResolve");
resolver.ensureHook("describedResolve");
resolver.ensureHook("rawModule");
resolver.ensureHook("module");
resolver.ensureHook("relative");
resolver.ensureHook("describedRelative");
resolver.ensureHook("directory");
resolver.ensureHook("existingDirectory");
resolver.ensureHook("undescribedRawFile");
resolver.ensureHook("rawFile");
resolver.ensureHook("file");
resolver.ensureHook("existingFile");
resolver.ensureHook("resolved");
// resolve

@@ -169,7 +189,9 @@ if(unsafeCache) {

// described-resolve
alias.forEach(function(item) {
alias.forEach(item => {
plugins.push(new AliasPlugin("described-resolve", item, "resolve"));
});
plugins.push(new ConcordModulesPlugin("described-resolve", {}, "resolve"));
aliasFields.forEach(function(item) {
if(enableConcord) {
plugins.push(new ConcordModulesPlugin("described-resolve", {}, "resolve"));
}
aliasFields.forEach(item => {
plugins.push(new AliasFieldPlugin("described-resolve", item, "resolve"));

@@ -181,3 +203,3 @@ });

// raw-module
moduleExtensions.forEach(function(item) {
moduleExtensions.forEach(item => {
plugins.push(new ModuleAppendPlugin("raw-module", item, "module"));

@@ -189,3 +211,3 @@ });

// module
modules.forEach(function(item) {
modules.forEach(item => {
if(Array.isArray(item))

@@ -216,7 +238,9 @@ plugins.push(new ModulesInHierachicDirectoriesPlugin("module", item, "resolve"));

// existing-directory
plugins.push(new ConcordMainPlugin("existing-directory", {}, "resolve"));
mainFields.forEach(function(item) {
if(enableConcord) {
plugins.push(new ConcordMainPlugin("existing-directory", {}, "resolve"));
}
mainFields.forEach(item => {
plugins.push(new MainFieldPlugin("existing-directory", item, "resolve"));
});
mainFiles.forEach(function(item) {
mainFiles.forEach(item => {
plugins.push(new UseFilePlugin("existing-directory", item, "undescribed-raw-file"));

@@ -230,6 +254,9 @@ });

// raw-file
if(!enforceExtension)
if(!enforceExtension) {
plugins.push(new TryNextPlugin("raw-file", "no extension", "file"));
plugins.push(new ConcordExtensionsPlugin("raw-file", {}, "file"));
extensions.forEach(function(item) {
}
if(enableConcord) {
plugins.push(new ConcordExtensionsPlugin("raw-file", {}, "file"));
}
extensions.forEach(item => {
plugins.push(new AppendPlugin("raw-file", item, "file"));

@@ -239,7 +266,9 @@ });

// file
alias.forEach(function(item) {
alias.forEach(item => {
plugins.push(new AliasPlugin("file", item, "resolve"));
});
plugins.push(new ConcordModulesPlugin("file", {}, "resolve"));
aliasFields.forEach(function(item) {
if(enableConcord) {
plugins.push(new ConcordModulesPlugin("file", {}, "resolve"));
}
aliasFields.forEach(item => {
plugins.push(new AliasFieldPlugin("file", item, "resolve"));

@@ -257,9 +286,10 @@ });

// resolved
plugins.push(new ResultPlugin("resolved"));
plugins.push(new ResultPlugin(resolver.hooks.resolved));
//// RESOLVER ////
plugins.forEach(function(plugin) {
resolver.apply(plugin);
plugins.forEach(plugin => {
plugin.apply(resolver);
});
return resolver;

@@ -269,5 +299,5 @@ };

function mergeFilteredToArray(array, filter) {
return array.reduce(function(array, item) {
return array.reduce((array, item) => {
if(filter(item)) {
var lastElement = array[array.length - 1];
const lastElement = array[array.length - 1];
if(Array.isArray(lastElement)) {

@@ -274,0 +304,0 @@ lastElement.push(item);

26

lib/ResultPlugin.js

@@ -5,15 +5,19 @@ /*

*/
function ResultPlugin(source) {
this.source = source;
}
module.exports = ResultPlugin;
"use strict";
ResultPlugin.prototype.apply = function(resolver) {
resolver.plugin(this.source, function(request, callback) {
var obj = Object.assign({}, request);
resolver.applyPluginsAsyncSeries1("result", obj, function(err) {
if(err) return callback(err);
callback(null, obj);
module.exports = class ResultPlugin {
constructor(source) {
this.source = source;
}
apply(resolver) {
this.source.tapAsync("ResultPlugin", (request, resolverContext, callback) => {
const obj = Object.assign({}, request);
if(resolverContext.log) resolverContext.log("reporting result " + obj.path);
resolver.hooks.result.callAsync(obj, resolverContext, err => {
if(err) return callback(err);
callback(null, obj);
});
});
});
}
};

76

lib/SymlinkPlugin.js

@@ -5,44 +5,46 @@ /*

*/
var getPaths = require("./getPaths");
var forEachBail = require("./forEachBail");
"use strict";
function SymlinkPlugin(source, target) {
this.source = source;
this.target = target;
}
module.exports = SymlinkPlugin;
const getPaths = require("./getPaths");
const forEachBail = require("./forEachBail");
SymlinkPlugin.prototype.apply = function(resolver) {
var target = this.target;
resolver.plugin(this.source, function(request, callback) {
var _this = this;
var fs = _this.fileSystem;
var pathsResult = getPaths(request.path);
var pathSeqments = pathsResult.seqments;
var paths = pathsResult.paths;
module.exports = class SymlinkPlugin {
constructor(source, target) {
this.source = source;
this.target = target;
}
var containsSymlink = false;
forEachBail.withIndex(paths, function(path, idx, callback) {
fs.readlink(path, function(err, result) {
if(!err && result) {
pathSeqments[idx] = result;
containsSymlink = true;
// Shortcut when absolute symlink found
if(/^(\/|[a-zA-z]:($|\\))/.test(result))
return callback(null, idx);
}
callback();
apply(resolver) {
const target = resolver.ensureHook(this.target);
const fs = resolver.fileSystem;
resolver.getHook(this.source).tapAsync("SymlinkPlugin", (request, resolveContext, callback) => {
const pathsResult = getPaths(request.path);
const pathSeqments = pathsResult.seqments;
const paths = pathsResult.paths;
let containsSymlink = false;
forEachBail.withIndex(paths, (path, idx, callback) => {
fs.readlink(path, (err, result) => {
if(!err && result) {
pathSeqments[idx] = result;
containsSymlink = true;
// Shortcut when absolute symlink found
if(/^(\/|[a-zA-z]:($|\\))/.test(result))
return callback(null, idx);
}
callback();
});
}, (err, idx) => {
if(!containsSymlink) return callback();
const resultSeqments = typeof idx === "number" ? pathSeqments.slice(0, idx + 1) : pathSeqments.slice();
const result = resultSeqments.reverse().reduce((a, b) => {
return resolver.join(a, b);
});
const obj = Object.assign({}, request, {
path: result
});
resolver.doResolve(target, obj, "resolved symlink to " + result, resolveContext, callback);
});
}, function(err, idx) {
if(!containsSymlink) return callback();
var resultSeqments = typeof idx === "number" ? pathSeqments.slice(0, idx + 1) : pathSeqments.slice();
var result = resultSeqments.reverse().reduce(function(a, b) {
return _this.join(a, b);
});
var obj = Object.assign({}, request, {
path: result
});
resolver.doResolve(target, obj, "resolved symlink to " + result, callback);
});
});
}
};

17

lib/SyncAsyncFileSystemDecorator.js

@@ -5,2 +5,4 @@ /*

*/
"use strict";
function SyncAsyncFileSystemDecorator(fs) {

@@ -10,4 +12,5 @@ this.fs = fs;

this.stat = function(arg, callback) {
let result;
try {
var result = fs.statSync(arg);
result = fs.statSync(arg);
} catch(e) {

@@ -21,4 +24,5 @@ return callback(e);

this.readdir = function(arg, callback) {
let result;
try {
var result = fs.readdirSync(arg);
result = fs.readdirSync(arg);
} catch(e) {

@@ -32,4 +36,5 @@ return callback(e);

this.readFile = function(arg, callback) {
let result;
try {
var result = fs.readFileSync(arg);
result = fs.readFileSync(arg);
} catch(e) {

@@ -43,4 +48,5 @@ return callback(e);

this.readlink = function(arg, callback) {
let result;
try {
var result = fs.readlinkSync(arg);
result = fs.readlinkSync(arg);
} catch(e) {

@@ -54,4 +60,5 @@ return callback(e);

this.readJson = function(arg, callback) {
let result;
try {
var result = fs.readJsonSync(arg);
result = fs.readJsonSync(arg);
} catch(e) {

@@ -58,0 +65,0 @@ return callback(e);

26

lib/TryNextPlugin.js

@@ -5,15 +5,17 @@ /*

*/
function TryNextPlugin(source, message, target) {
this.source = source;
this.message = message;
this.target = target;
}
module.exports = TryNextPlugin;
"use strict";
TryNextPlugin.prototype.apply = function(resolver) {
var target = this.target;
var message = this.message;
resolver.plugin(this.source, function(request, callback) {
resolver.doResolve(target, request, message, callback);
});
module.exports = class TryNextPlugin {
constructor(source, message, target) {
this.source = source;
this.message = message;
this.target = target;
}
apply(resolver) {
const target = resolver.ensureHook(this.target);
resolver.getHook(this.source).tapAsync("TryNextPlugin", (request, resolveContext, callback) => {
resolver.doResolve(target, request, this.message, resolveContext, callback);
});
}
};

54

lib/UnsafeCachePlugin.js

@@ -5,13 +5,4 @@ /*

*/
var createInnerCallback = require("./createInnerCallback");
"use strict";
function UnsafeCachePlugin(source, filterPredicate, cache, withContext, target) {
this.source = source;
this.filterPredicate = filterPredicate;
this.withContext = withContext;
this.cache = cache || {};
this.target = target;
}
module.exports = UnsafeCachePlugin;
function getCacheId(request, withContext) {

@@ -26,20 +17,27 @@ return JSON.stringify({

UnsafeCachePlugin.prototype.apply = function(resolver) {
var filterPredicate = this.filterPredicate;
var cache = this.cache;
var target = this.target;
var withContext = this.withContext;
resolver.plugin(this.source, function(request, callback) {
if(!filterPredicate(request)) return callback();
var cacheId = getCacheId(request, withContext);
var cacheEntry = cache[cacheId];
if(cacheEntry) {
return callback(null, cacheEntry);
}
resolver.doResolve(target, request, null, createInnerCallback(function(err, result) {
if(err) return callback(err);
if(result) return callback(null, cache[cacheId] = result);
callback();
}, callback));
});
module.exports = class UnsafeCachePlugin {
constructor(source, filterPredicate, cache, withContext, target) {
this.source = source;
this.filterPredicate = filterPredicate;
this.withContext = withContext;
this.cache = cache || {};
this.target = target;
}
apply(resolver) {
const target = resolver.ensureHook(this.target);
resolver.getHook(this.source).tapAsync("UnsafeCachePlugin", (request, resolveContext, callback) => {
if(!this.filterPredicate(request)) return callback();
const cacheId = getCacheId(request, this.withContext);
const cacheEntry = this.cache[cacheId];
if(cacheEntry) {
return callback(null, cacheEntry);
}
resolver.doResolve(target, request, null, resolveContext, (err, result) => {
if(err) return callback(err);
if(result) return callback(null, this.cache[cacheId] = result);
callback();
});
});
}
};

34

lib/UseFilePlugin.js

@@ -5,20 +5,22 @@ /*

*/
function UseFilePlugin(source, filename, target) {
this.source = source;
this.filename = filename;
this.target = target;
}
module.exports = UseFilePlugin;
"use strict";
UseFilePlugin.prototype.apply = function(resolver) {
var filename = this.filename;
var target = this.target;
resolver.plugin(this.source, function(request, callback) {
var filePath = resolver.join(request.path, filename);
var obj = Object.assign({}, request, {
path: filePath,
relativePath: request.relativePath && resolver.join(request.relativePath, filename)
module.exports = class UseFilePlugin {
constructor(source, filename, target) {
this.source = source;
this.filename = filename;
this.target = target;
}
apply(resolver) {
const target = resolver.ensureHook(this.target);
resolver.getHook(this.source).tapAsync("UseFilePlugin", (request, resolveContext, callback) => {
const filePath = resolver.join(request.path, this.filename);
const obj = Object.assign({}, request, {
path: filePath,
relativePath: request.relativePath && resolver.join(request.relativePath, this.filename)
});
resolver.doResolve(target, obj, "using path: " + filePath, resolveContext, callback);
});
resolver.doResolve(target, obj, "using path: " + filePath, callback);
});
}
};

5

package.json
{
"name": "enhanced-resolve",
"version": "3.4.1",
"version": "4.0.0-beta.1",
"author": "Tobias Koppers @sokra",

@@ -12,4 +12,3 @@ "description": "Offers a async require.resolve function. It's highly configurable.",

"memory-fs": "^0.4.0",
"object-assign": "^4.0.1",
"tapable": "^0.2.7"
"tapable": "^1.0.0-beta.4"
},

@@ -16,0 +15,0 @@ "licenses": [

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc