From de98e0b232509d5f40c135d540a70e415272ff85 Mon Sep 17 00:00:00 2001 From: Florian Dold Date: Wed, 3 May 2017 15:35:00 +0200 Subject: node_modules --- .../enhanced-resolve/lib/AliasFieldPlugin.js | 51 ++++ node_modules/enhanced-resolve/lib/AliasPlugin.js | 57 +++++ node_modules/enhanced-resolve/lib/AppendPlugin.js | 22 ++ .../enhanced-resolve/lib/CachedInputFileSystem.js | 260 ++++++++++++++++++++ .../enhanced-resolve/lib/CloneBasenamePlugin.js | 24 ++ .../lib/ConcordExtensionsPlugin.js | 37 +++ .../enhanced-resolve/lib/ConcordMainPlugin.js | 30 +++ .../enhanced-resolve/lib/ConcordModulesPlugin.js | 44 ++++ .../enhanced-resolve/lib/DescriptionFilePlugin.js | 51 ++++ .../enhanced-resolve/lib/DescriptionFileUtils.js | 93 +++++++ .../enhanced-resolve/lib/DirectoryExistsPlugin.js | 30 +++ .../enhanced-resolve/lib/FileExistsPlugin.js | 30 +++ .../enhanced-resolve/lib/FileKindPlugin.js | 19 ++ .../enhanced-resolve/lib/JoinRequestPlugin.js | 21 ++ node_modules/enhanced-resolve/lib/LogInfoPlugin.js | 25 ++ .../enhanced-resolve/lib/MainFieldPlugin.js | 48 ++++ .../enhanced-resolve/lib/ModuleAppendPlugin.js | 35 +++ .../enhanced-resolve/lib/ModuleKindPlugin.js | 26 ++ .../lib/ModulesInHierachicDirectoriesPlugin.js | 46 ++++ .../enhanced-resolve/lib/ModulesInRootPlugin.js | 22 ++ node_modules/enhanced-resolve/lib/NextPlugin.js | 16 ++ .../enhanced-resolve/lib/NodeJsInputFileSystem.js | 29 +++ node_modules/enhanced-resolve/lib/ParsePlugin.js | 27 +++ node_modules/enhanced-resolve/lib/Resolver.js | 190 +++++++++++++++ .../enhanced-resolve/lib/ResolverFactory.js | 270 +++++++++++++++++++++ node_modules/enhanced-resolve/lib/ResultPlugin.js | 18 ++ node_modules/enhanced-resolve/lib/SymlinkPlugin.js | 49 ++++ .../lib/SyncAsyncFileSystemDecorator.js | 58 +++++ node_modules/enhanced-resolve/lib/TryNextPlugin.js | 18 ++ .../enhanced-resolve/lib/UnsafeCachePlugin.js | 41 ++++ node_modules/enhanced-resolve/lib/UseFilePlugin.js | 23 ++ node_modules/enhanced-resolve/lib/concord.js | 189 +++++++++++++++ .../enhanced-resolve/lib/createInnerCallback.js | 41 ++++ node_modules/enhanced-resolve/lib/forEachBail.js | 34 +++ .../enhanced-resolve/lib/getInnerRequest.js | 22 ++ node_modules/enhanced-resolve/lib/getPaths.js | 33 +++ node_modules/enhanced-resolve/lib/globToRegExp.js | 188 ++++++++++++++ node_modules/enhanced-resolve/lib/node.js | 144 +++++++++++ 38 files changed, 2361 insertions(+) create mode 100644 node_modules/enhanced-resolve/lib/AliasFieldPlugin.js create mode 100644 node_modules/enhanced-resolve/lib/AliasPlugin.js create mode 100644 node_modules/enhanced-resolve/lib/AppendPlugin.js create mode 100644 node_modules/enhanced-resolve/lib/CachedInputFileSystem.js create mode 100644 node_modules/enhanced-resolve/lib/CloneBasenamePlugin.js create mode 100644 node_modules/enhanced-resolve/lib/ConcordExtensionsPlugin.js create mode 100644 node_modules/enhanced-resolve/lib/ConcordMainPlugin.js create mode 100644 node_modules/enhanced-resolve/lib/ConcordModulesPlugin.js create mode 100644 node_modules/enhanced-resolve/lib/DescriptionFilePlugin.js create mode 100644 node_modules/enhanced-resolve/lib/DescriptionFileUtils.js create mode 100644 node_modules/enhanced-resolve/lib/DirectoryExistsPlugin.js create mode 100644 node_modules/enhanced-resolve/lib/FileExistsPlugin.js create mode 100644 node_modules/enhanced-resolve/lib/FileKindPlugin.js create mode 100644 node_modules/enhanced-resolve/lib/JoinRequestPlugin.js create mode 100644 node_modules/enhanced-resolve/lib/LogInfoPlugin.js create mode 100644 node_modules/enhanced-resolve/lib/MainFieldPlugin.js create mode 100644 node_modules/enhanced-resolve/lib/ModuleAppendPlugin.js create mode 100644 node_modules/enhanced-resolve/lib/ModuleKindPlugin.js create mode 100644 node_modules/enhanced-resolve/lib/ModulesInHierachicDirectoriesPlugin.js create mode 100644 node_modules/enhanced-resolve/lib/ModulesInRootPlugin.js create mode 100644 node_modules/enhanced-resolve/lib/NextPlugin.js create mode 100644 node_modules/enhanced-resolve/lib/NodeJsInputFileSystem.js create mode 100644 node_modules/enhanced-resolve/lib/ParsePlugin.js create mode 100644 node_modules/enhanced-resolve/lib/Resolver.js create mode 100644 node_modules/enhanced-resolve/lib/ResolverFactory.js create mode 100644 node_modules/enhanced-resolve/lib/ResultPlugin.js create mode 100644 node_modules/enhanced-resolve/lib/SymlinkPlugin.js create mode 100644 node_modules/enhanced-resolve/lib/SyncAsyncFileSystemDecorator.js create mode 100644 node_modules/enhanced-resolve/lib/TryNextPlugin.js create mode 100644 node_modules/enhanced-resolve/lib/UnsafeCachePlugin.js create mode 100644 node_modules/enhanced-resolve/lib/UseFilePlugin.js create mode 100644 node_modules/enhanced-resolve/lib/concord.js create mode 100644 node_modules/enhanced-resolve/lib/createInnerCallback.js create mode 100644 node_modules/enhanced-resolve/lib/forEachBail.js create mode 100644 node_modules/enhanced-resolve/lib/getInnerRequest.js create mode 100644 node_modules/enhanced-resolve/lib/getPaths.js create mode 100644 node_modules/enhanced-resolve/lib/globToRegExp.js create mode 100644 node_modules/enhanced-resolve/lib/node.js (limited to 'node_modules/enhanced-resolve/lib') diff --git a/node_modules/enhanced-resolve/lib/AliasFieldPlugin.js b/node_modules/enhanced-resolve/lib/AliasFieldPlugin.js new file mode 100644 index 000000000..70b6b97d6 --- /dev/null +++ b/node_modules/enhanced-resolve/lib/AliasFieldPlugin.js @@ -0,0 +1,51 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ + +var DescriptionFileUtils = require("./DescriptionFileUtils"); +var createInnerCallback = require("./createInnerCallback"); +var getInnerRequest = require("./getInnerRequest"); + +function AliasFieldPlugin(source, field, target) { + this.source = source; + this.field = field; + this.target = target; +} +module.exports = AliasFieldPlugin; + +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 + }); + 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 + "'", createInnerCallback(function(err, result) { + if(arguments.length > 0) return callback(err, result); + + // Don't allow other aliasing or raw request + callback(null, null); + }, callback)); + }); +}; diff --git a/node_modules/enhanced-resolve/lib/AliasPlugin.js b/node_modules/enhanced-resolve/lib/AliasPlugin.js new file mode 100644 index 000000000..86f2a6fba --- /dev/null +++ b/node_modules/enhanced-resolve/lib/AliasPlugin.js @@ -0,0 +1,57 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +var createInnerCallback = require("./createInnerCallback"); + +function startsWith(string, searchString) { + var stringLength = string.length; + var searchLength = searchString.length; + + // early out if the search length is greater than the search string + if(searchLength > stringLength) { + return false; + } + var index = -1; + while(++index < searchLength) { + if(string.charCodeAt(index) !== searchString.charCodeAt(index)) { + return false; + } + } + return true; +} + +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; + +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); + + // don't allow other aliasing or raw request + callback(null, null); + }, callback)); + } + } + return callback(); + }); +}; diff --git a/node_modules/enhanced-resolve/lib/AppendPlugin.js b/node_modules/enhanced-resolve/lib/AppendPlugin.js new file mode 100644 index 000000000..a42ff3679 --- /dev/null +++ b/node_modules/enhanced-resolve/lib/AppendPlugin.js @@ -0,0 +1,22 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +function AppendPlugin(source, appending, target) { + this.source = source; + this.appending = appending; + this.target = target; +} +module.exports = AppendPlugin; + +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) + }); + resolver.doResolve(target, obj, appending, callback); + }); +}; diff --git a/node_modules/enhanced-resolve/lib/CachedInputFileSystem.js b/node_modules/enhanced-resolve/lib/CachedInputFileSystem.js new file mode 100644 index 000000000..2ea7858a0 --- /dev/null +++ b/node_modules/enhanced-resolve/lib/CachedInputFileSystem.js @@ -0,0 +1,260 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +function Storage(duration) { + this.duration = duration; + this.running = {}; + this.data = {}; + this.levels = []; + if(duration > 0) { + this.levels.push([], [], [], [], [], [], [], [], []); + for(var i = 8000; i < duration; i += 500) + this.levels.push([]); + } + 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)); +}; + +Storage.prototype.finished = function(name, err, result) { + var callbacks = this.running[name]; + delete this.running[name]; + if(this.duration > 0) { + this.count++; + this.data[name] = [err, result]; + this.levels[0].push(name); + this.ensureTick(); + } + for(var i = 0; i < callbacks.length; i++) { + callbacks[i](err, result); + } +}; + +Storage.prototype.finishedSync = function(name, err, result) { + if(this.duration > 0) { + this.count++; + this.data[name] = [err, result]; + this.levels[0].push(name); + this.ensureTick(); + } +}; + +Storage.prototype.provide = function(name, provider, callback) { + var running = this.running[name]; + if(running) { + running.push(callback); + return; + } + if(this.duration > 0) { + this.checkTicks(); + var data = this.data[name]; + if(data) { + return process.nextTick(function() { + callback.apply(null, data); + }); + } + } + this.running[name] = running = [callback]; + var _this = this; + provider(name, function(err, result) { + _this.finished(name, err, result); + }); +}; + +Storage.prototype.provideSync = function(name, provider) { + if(this.duration > 0) { + this.checkTicks(); + var data = this.data[name]; + if(data) { + if(data[0]) + throw data[0]; + return data[1]; + } + } + 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 i = decay.length - 1; i >= 0; i--) { + delete this.data[decay[i]]; + } + this.count -= decay.length; + decay.length = 0; + 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) { + 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; + } +}; + +Storage.prototype.checkTicks = function() { + 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 = {}; + this.levels.forEach(function(level) { + level.length = 0; + }); + } else if(typeof what === "string") { + Object.keys(this.data).forEach(function(key) { + if(key.indexOf(what) === 0) + delete this.data[key]; + }, this); + } 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); + + this._stat = this.fileSystem.stat ? this.fileSystem.stat.bind(this.fileSystem) : null; + if(!this._stat) this.stat = null; + + this._statSync = this.fileSystem.statSync ? this.fileSystem.statSync.bind(this.fileSystem) : null; + if(!this._statSync) this.statSync = null; + + this._readdir = this.fileSystem.readdir ? this.fileSystem.readdir.bind(this.fileSystem) : null; + if(!this._readdir) this.readdir = null; + + this._readdirSync = this.fileSystem.readdirSync ? this.fileSystem.readdirSync.bind(this.fileSystem) : null; + if(!this._readdirSync) this.readdirSync = null; + + this._readFile = this.fileSystem.readFile ? this.fileSystem.readFile.bind(this.fileSystem) : null; + if(!this._readFile) this.readFile = null; + + this._readFileSync = this.fileSystem.readFileSync ? this.fileSystem.readFileSync.bind(this.fileSystem) : null; + if(!this._readFileSync) this.readFileSync = null; + + if(this.fileSystem.readJson) { + this._readJson = this.fileSystem.readJson.bind(this.fileSystem); + } else if(this.readFile) { + this._readJson = 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; + } + + 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; + +CachedInputFileSystem.prototype.stat = function(path, callback) { + this._statStorage.provide(path, this._stat, callback); +}; + +CachedInputFileSystem.prototype.readdir = function(path, callback) { + this._readdirStorage.provide(path, this._readdir, callback); +}; + +CachedInputFileSystem.prototype.readFile = function(path, callback) { + this._readFileStorage.provide(path, this._readFile, callback); +}; + +CachedInputFileSystem.prototype.readJson = function(path, callback) { + this._readJsonStorage.provide(path, this._readJson, callback); +}; + +CachedInputFileSystem.prototype.readlink = function(path, callback) { + this._readlinkStorage.provide(path, this._readlink, callback); +}; + +CachedInputFileSystem.prototype.statSync = function(path) { + return this._statStorage.provideSync(path, this._statSync); +}; + +CachedInputFileSystem.prototype.readdirSync = function(path) { + return this._readdirStorage.provideSync(path, this._readdirSync); +}; + +CachedInputFileSystem.prototype.readFileSync = function(path) { + return this._readFileStorage.provideSync(path, this._readFileSync); +}; + +CachedInputFileSystem.prototype.readJsonSync = function(path) { + return this._readJsonStorage.provideSync(path, this._readJsonSync); +}; + +CachedInputFileSystem.prototype.readlinkSync = function(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); +}; diff --git a/node_modules/enhanced-resolve/lib/CloneBasenamePlugin.js b/node_modules/enhanced-resolve/lib/CloneBasenamePlugin.js new file mode 100644 index 000000000..d6ad4bc06 --- /dev/null +++ b/node_modules/enhanced-resolve/lib/CloneBasenamePlugin.js @@ -0,0 +1,24 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +var basename = require("./getPaths").basename; + +function CloneBasenamePlugin(source, target) { + this.source = source; + this.target = target; +} +module.exports = CloneBasenamePlugin; + +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) + }); + resolver.doResolve(target, obj, "using path: " + filePath, callback); + }); +}; diff --git a/node_modules/enhanced-resolve/lib/ConcordExtensionsPlugin.js b/node_modules/enhanced-resolve/lib/ConcordExtensionsPlugin.js new file mode 100644 index 000000000..2a3c41a94 --- /dev/null +++ b/node_modules/enhanced-resolve/lib/ConcordExtensionsPlugin.js @@ -0,0 +1,37 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +var concord = require("./concord"); +var DescriptionFileUtils = require("./DescriptionFileUtils"); +var forEachBail = require("./forEachBail"); +var createInnerCallback = require("./createInnerCallback"); + +function ConcordExtensionsPlugin(source, options, target) { + this.source = source; + this.options = options; + this.target = target; +} +module.exports = ConcordExtensionsPlugin; + +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) + }); + resolver.doResolve(target, obj, "concord extension: " + appending, createInnerCallback(callback, topLevelCallback)); + }, function(err, result) { + if(arguments.length > 0) return callback(err, result); + + callback(null, null); + }); + }); +}; diff --git a/node_modules/enhanced-resolve/lib/ConcordMainPlugin.js b/node_modules/enhanced-resolve/lib/ConcordMainPlugin.js new file mode 100644 index 000000000..b3b672d8a --- /dev/null +++ b/node_modules/enhanced-resolve/lib/ConcordMainPlugin.js @@ -0,0 +1,30 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +var path = require("path"); +var concord = require("./concord"); +var DescriptionFileUtils = require("./DescriptionFileUtils"); + +function ConcordMainPlugin(source, options, target) { + this.source = source; + this.options = options; + this.target = target; +} +module.exports = ConcordMainPlugin; + +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 + }); + var filename = path.basename(request.descriptionFilePath); + return resolver.doResolve(target, obj, "use " + mainModule + " from " + filename, callback); + }); +}; diff --git a/node_modules/enhanced-resolve/lib/ConcordModulesPlugin.js b/node_modules/enhanced-resolve/lib/ConcordModulesPlugin.js new file mode 100644 index 000000000..2aa35ab87 --- /dev/null +++ b/node_modules/enhanced-resolve/lib/ConcordModulesPlugin.js @@ -0,0 +1,44 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +var concord = require("./concord"); +var DescriptionFileUtils = require("./DescriptionFileUtils"); +var createInnerCallback = require("./createInnerCallback"); +var getInnerRequest = require("./getInnerRequest"); + +function ConcordModulesPlugin(source, options, target) { + this.source = source; + this.options = options; + this.target = target; +} +module.exports = ConcordModulesPlugin; + +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 + }); + 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 + "'", createInnerCallback(function(err, result) { + if(arguments.length > 0) return callback(err, result); + + // Don't allow other aliasing or raw request + callback(null, null); + }, callback)); + }); +}; diff --git a/node_modules/enhanced-resolve/lib/DescriptionFilePlugin.js b/node_modules/enhanced-resolve/lib/DescriptionFilePlugin.js new file mode 100644 index 000000000..ad4a9a3c6 --- /dev/null +++ b/node_modules/enhanced-resolve/lib/DescriptionFilePlugin.js @@ -0,0 +1,51 @@ +"use strict"; +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +const createInnerCallback = require("./createInnerCallback"); +const DescriptionFileUtils = require("./DescriptionFileUtils"); + +class DescriptionFilePlugin { + constructor(source, filenames, target) { + this.source = source; + this.filenames = [].concat(filenames); + this.target = target; + } + + apply(resolver) { + const filenames = this.filenames; + const target = this.target; + resolver.plugin(this.source, (request, callback) => { + const directory = request.path; + DescriptionFileUtils.loadDescriptionFile(resolver, directory, filenames, ((err, result) => { + if(err) return callback(err); + if(!result) { + if(callback.missing) { + filenames.forEach((filename) => { + callback.missing.push(resolver.join(directory, filename)); + }); + } + if(callback.log) callback.log("No description file found"); + return callback(); + } + const relativePath = "." + request.path.substr(result.directory.length).replace(/\\/g, "/"); + const obj = Object.assign({}, request, { + descriptionFilePath: result.path, + descriptionFileData: result.content, + descriptionFileRoot: result.directory, + relativePath: relativePath + }); + resolver.doResolve(target, obj, "using description file: " + result.path + " (relative path: " + relativePath + ")", createInnerCallback((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)); + })); + }); + } +} + +module.exports = DescriptionFilePlugin; diff --git a/node_modules/enhanced-resolve/lib/DescriptionFileUtils.js b/node_modules/enhanced-resolve/lib/DescriptionFileUtils.js new file mode 100644 index 000000000..084d29ec9 --- /dev/null +++ b/node_modules/enhanced-resolve/lib/DescriptionFileUtils.js @@ -0,0 +1,93 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +var forEachBail = require("./forEachBail"); + +function loadDescriptionFile(resolver, directory, filenames, callback) { + (function findDescriptionFile() { + forEachBail(filenames, function(filename, callback) { + var descriptionFilePath = resolver.join(directory, filename); + if(resolver.fileSystem.readJson) { + resolver.fileSystem.readJson(descriptionFilePath, function(err, content) { + if(err) { + if(typeof err.code !== "undefined") return callback(); + return onJson(err); + } + onJson(null, content); + }); + } else { + resolver.fileSystem.readFile(descriptionFilePath, function(err, content) { + if(err) return callback(); + try { + var json = JSON.parse(content); + } catch(e) { + onJson(e); + } + onJson(null, json); + }); + } + + function onJson(err, content) { + if(err) { + if(callback.log) + callback.log(descriptionFilePath + " (directory description file): " + err); + else + err.message = descriptionFilePath + " (directory description file): " + err; + return callback(err); + } + callback(null, { + content: content, + directory: directory, + path: descriptionFilePath + }); + } + }, function(err, result) { + if(err) return callback(err); + if(result) { + return callback(null, result); + } else { + directory = cdUp(directory); + if(!directory) { + return callback(); + } else { + return findDescriptionFile(); + } + } + }); + }()); +} + +function getField(content, field) { + if(!content) return undefined; + if(Array.isArray(field)) { + var current = content; + for(var j = 0; j < field.length; j++) { + if(current === null || typeof current !== "object") { + current = null; + break; + } + current = current[field[j]]; + } + if(typeof current === "object") { + return current; + } + } else { + if(typeof content[field] === "object") { + return content[field]; + } + } +} + +function cdUp(directory) { + if(directory === "/") return null; + var i = directory.lastIndexOf("/"), + j = directory.lastIndexOf("\\"); + var p = i < 0 ? j : j < 0 ? i : i < j ? j : i; + if(p < 0) return null; + return directory.substr(0, p || 1); +} + +exports.loadDescriptionFile = loadDescriptionFile; +exports.getField = getField; +exports.cdUp = cdUp; diff --git a/node_modules/enhanced-resolve/lib/DirectoryExistsPlugin.js b/node_modules/enhanced-resolve/lib/DirectoryExistsPlugin.js new file mode 100644 index 000000000..7e88d68d0 --- /dev/null +++ b/node_modules/enhanced-resolve/lib/DirectoryExistsPlugin.js @@ -0,0 +1,30 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +function DirectoryExistsPlugin(source, target) { + this.source = source; + this.target = target; +} +module.exports = DirectoryExistsPlugin; + +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)); + }); +}; diff --git a/node_modules/enhanced-resolve/lib/FileExistsPlugin.js b/node_modules/enhanced-resolve/lib/FileExistsPlugin.js new file mode 100644 index 000000000..59fc6a5f1 --- /dev/null +++ b/node_modules/enhanced-resolve/lib/FileExistsPlugin.js @@ -0,0 +1,30 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +function FileExistsPlugin(source, target) { + this.source = source; + this.target = target; +} +module.exports = FileExistsPlugin; + +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)); + }); +}; diff --git a/node_modules/enhanced-resolve/lib/FileKindPlugin.js b/node_modules/enhanced-resolve/lib/FileKindPlugin.js new file mode 100644 index 000000000..d42bc22f3 --- /dev/null +++ b/node_modules/enhanced-resolve/lib/FileKindPlugin.js @@ -0,0 +1,19 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +function FileKindPlugin(source, target) { + this.source = source; + this.target = target; +} +module.exports = FileKindPlugin; + +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); + }); +}; diff --git a/node_modules/enhanced-resolve/lib/JoinRequestPlugin.js b/node_modules/enhanced-resolve/lib/JoinRequestPlugin.js new file mode 100644 index 000000000..ac828eb31 --- /dev/null +++ b/node_modules/enhanced-resolve/lib/JoinRequestPlugin.js @@ -0,0 +1,21 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +function JoinRequestPlugin(source, target) { + this.source = source; + this.target = target; +} +module.exports = JoinRequestPlugin; + +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 + }); + resolver.doResolve(target, obj, null, callback); + }); +}; diff --git a/node_modules/enhanced-resolve/lib/LogInfoPlugin.js b/node_modules/enhanced-resolve/lib/LogInfoPlugin.js new file mode 100644 index 000000000..1ebc837ce --- /dev/null +++ b/node_modules/enhanced-resolve/lib/LogInfoPlugin.js @@ -0,0 +1,25 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +function LogInfoPlugin(source) { + this.source = source; +} +module.exports = LogInfoPlugin; + +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(); + }); +}; diff --git a/node_modules/enhanced-resolve/lib/MainFieldPlugin.js b/node_modules/enhanced-resolve/lib/MainFieldPlugin.js new file mode 100644 index 000000000..45ecd4b23 --- /dev/null +++ b/node_modules/enhanced-resolve/lib/MainFieldPlugin.js @@ -0,0 +1,48 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +var path = require("path"); + +function MainFieldPlugin(source, options, target) { + this.source = source; + this.options = options; + this.target = target; +} +module.exports = MainFieldPlugin; + +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; + } + current = current[field[j]]; + } + 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 + }); + return resolver.doResolve(target, obj, "use " + mainModule + " from " + options.name + " in " + filename, callback); + }); +}; diff --git a/node_modules/enhanced-resolve/lib/ModuleAppendPlugin.js b/node_modules/enhanced-resolve/lib/ModuleAppendPlugin.js new file mode 100644 index 000000000..55ebcb937 --- /dev/null +++ b/node_modules/enhanced-resolve/lib/ModuleAppendPlugin.js @@ -0,0 +1,35 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +function ModuleAppendPlugin(source, appending, target) { + this.source = source; + this.appending = appending; + this.target = target; +} +module.exports = ModuleAppendPlugin; + +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 + }); + resolver.doResolve(target, obj, "module variation " + moduleFinalName, callback); + }); +}; diff --git a/node_modules/enhanced-resolve/lib/ModuleKindPlugin.js b/node_modules/enhanced-resolve/lib/ModuleKindPlugin.js new file mode 100644 index 000000000..e6d920108 --- /dev/null +++ b/node_modules/enhanced-resolve/lib/ModuleKindPlugin.js @@ -0,0 +1,26 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +var createInnerCallback = require("./createInnerCallback"); + +function ModuleKindPlugin(source, target) { + this.source = source; + this.target = target; +} +module.exports = ModuleKindPlugin; + +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); + + // Don't allow other alternatives + callback(null, null); + }, callback)); + }); +}; diff --git a/node_modules/enhanced-resolve/lib/ModulesInHierachicDirectoriesPlugin.js b/node_modules/enhanced-resolve/lib/ModulesInHierachicDirectoriesPlugin.js new file mode 100644 index 000000000..cb942ce94 --- /dev/null +++ b/node_modules/enhanced-resolve/lib/ModulesInHierachicDirectoriesPlugin.js @@ -0,0 +1,46 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +var createInnerCallback = require("./createInnerCallback"); +var forEachBail = require("./forEachBail"); +var getPaths = require("./getPaths"); + +function ModulesInHierachicDirectoriesPlugin(source, directories, target) { + this.source = source; + this.directories = [].concat(directories); + this.target = target; +} +module.exports = ModulesInHierachicDirectoriesPlugin; + +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); + }); +}; diff --git a/node_modules/enhanced-resolve/lib/ModulesInRootPlugin.js b/node_modules/enhanced-resolve/lib/ModulesInRootPlugin.js new file mode 100644 index 000000000..1d7de20fb --- /dev/null +++ b/node_modules/enhanced-resolve/lib/ModulesInRootPlugin.js @@ -0,0 +1,22 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +function ModulesInRootPlugin(source, path, target) { + this.source = source; + this.path = path; + this.target = target; +} +module.exports = ModulesInRootPlugin; + +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 + }); + resolver.doResolve(target, obj, "looking for modules in " + path, callback, true); + }); +}; diff --git a/node_modules/enhanced-resolve/lib/NextPlugin.js b/node_modules/enhanced-resolve/lib/NextPlugin.js new file mode 100644 index 000000000..0db218c81 --- /dev/null +++ b/node_modules/enhanced-resolve/lib/NextPlugin.js @@ -0,0 +1,16 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +function NextPlugin(source, target) { + this.source = source; + this.target = target; +} +module.exports = NextPlugin; + +NextPlugin.prototype.apply = function(resolver) { + var target = this.target; + resolver.plugin(this.source, function(request, callback) { + resolver.doResolve(target, request, null, callback); + }); +}; diff --git a/node_modules/enhanced-resolve/lib/NodeJsInputFileSystem.js b/node_modules/enhanced-resolve/lib/NodeJsInputFileSystem.js new file mode 100644 index 000000000..28c78ca8a --- /dev/null +++ b/node_modules/enhanced-resolve/lib/NodeJsInputFileSystem.js @@ -0,0 +1,29 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +var fs = require("graceful-fs"); + +function NodeJsInputFileSystem() {} +module.exports = NodeJsInputFileSystem; + +NodeJsInputFileSystem.prototype.stat = fs.stat.bind(fs); +NodeJsInputFileSystem.prototype.readdir = function readdir(path, callback) { + fs.readdir(path, function(err, files) { + callback(err, files && files.map(function(file) { + return file.normalize ? file.normalize("NFC") : file; + })); + }); +}; +NodeJsInputFileSystem.prototype.readFile = fs.readFile.bind(fs); +NodeJsInputFileSystem.prototype.readlink = fs.readlink.bind(fs); + +NodeJsInputFileSystem.prototype.statSync = fs.statSync.bind(fs); +NodeJsInputFileSystem.prototype.readdirSync = function readdirSync(path) { + var files = fs.readdirSync(path); + return files && files.map(function(file) { + return file.normalize ? file.normalize("NFC") : file; + }); +}; +NodeJsInputFileSystem.prototype.readFileSync = fs.readFileSync.bind(fs); +NodeJsInputFileSystem.prototype.readlinkSync = fs.readlinkSync.bind(fs); diff --git a/node_modules/enhanced-resolve/lib/ParsePlugin.js b/node_modules/enhanced-resolve/lib/ParsePlugin.js new file mode 100644 index 000000000..f4117fac9 --- /dev/null +++ b/node_modules/enhanced-resolve/lib/ParsePlugin.js @@ -0,0 +1,27 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +function ParsePlugin(source, target) { + this.source = source; + this.target = target; +} +module.exports = ParsePlugin; + +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); + }); +}; diff --git a/node_modules/enhanced-resolve/lib/Resolver.js b/node_modules/enhanced-resolve/lib/Resolver.js new file mode 100644 index 000000000..6b8074569 --- /dev/null +++ b/node_modules/enhanced-resolve/lib/Resolver.js @@ -0,0 +1,190 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +var Tapable = require("tapable"); +var createInnerCallback = require("./createInnerCallback"); + +function Resolver(fileSystem) { + Tapable.call(this); + this.fileSystem = fileSystem; +} +module.exports = Resolver; + +Resolver.prototype = Object.create(Tapable.prototype); + +Resolver.prototype.constructor = Resolver; + +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; +}; + +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 + }; + + var localMissing = []; + var missing = callback.missing ? { + push: function(item) { + callback.missing.push(item); + localMissing.push(item); + } + } : localMissing; + var log = []; + var message = "resolve '" + request + "' in '" + path + "'"; + + function writeLog(msg) { + log.push(msg); + } + + function logAsString() { + return log.join("\n"); + } + + function onResolved(err, result) { + if(callback.log) { + for(var i = 0; i < log.length; i++) + callback.log(log[i]); + } + if(err) return callback(err); + if(!result) { + var error = new Error("Can't " + message); + error.details = logAsString(); + error.missing = localMissing; + resolver.applyPlugins("no-resolve", obj, error); + return callback(error); + } + return callback(null, result.path === false ? false : result.path + (result.query || ""), result); + } + return this.doResolve("resolve", obj, message, createInnerCallback(onResolved, { + log: writeLog, + missing: missing, + stack: callback.stack + }, null)); +}; + +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); + } + } + resolver.applyPlugins("resolve-step", type, request); + + resolver.applyPluginsAsyncSeriesBailResult1("before-" + type, request, createInnerCallback(beforeInnerCallback, { + log: callback.log, + missing: callback.missing, + stack: newStack + }, message && ("before " + message), true)); + + function beforeInnerCallback(err, result) { + if(arguments.length > 0) { + if(err) return callback(err); + if(result) return callback(null, result); + return callback(); + } + return resolver.applyPluginsParallelBailResult1(type, request, createInnerCallback(innerCallback, { + log: callback.log, + missing: callback.missing, + stack: newStack + }, message)); + } + + function innerCallback(err, result) { + if(arguments.length > 0) { + if(err) return callback(err); + if(result) return callback(null, result); + return callback(); + } + return resolver.applyPluginsAsyncSeriesBailResult1("after-" + type, request, createInnerCallback(afterInnerCallback, { + log: callback.log, + missing: callback.missing, + stack: newStack + }, message && ("after " + message), true)); + } + + function afterInnerCallback(err, result) { + if(arguments.length > 0) { + if(err) return callback(err); + if(result) return callback(null, result); + return callback(); + } + return callback(); + } +}; + +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); + } + } + 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 = {}; +Resolver.prototype.join = function(path, request) { + var memoizeKey = path + "|$" + request; + if(!memoizedJoin[memoizeKey]) { + memoizedJoin[memoizeKey] = memoryFsJoin(path, request); + } + return memoizedJoin[memoizeKey]; +}; + +Resolver.prototype.normalize = require("memory-fs/lib/normalize"); diff --git a/node_modules/enhanced-resolve/lib/ResolverFactory.js b/node_modules/enhanced-resolve/lib/ResolverFactory.js new file mode 100644 index 000000000..682ef4640 --- /dev/null +++ b/node_modules/enhanced-resolve/lib/ResolverFactory.js @@ -0,0 +1,270 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +var Resolver = require("./Resolver"); + +var SyncAsyncFileSystemDecorator = require("./SyncAsyncFileSystemDecorator"); + +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"); + +exports.createResolver = function(options) { + + //// OPTIONS //// + + // A list of directories to resolve modules from, can be absolute path or folder name + var modules = options.modules || ["node_modules"]; + + // A list of description files to read from + var descriptionFiles = options.descriptionFiles || ["package.json"]; + + // A list of additional resolve plugins which should be applied + // The slice is there to create a copy, because otherwise pushing into plugins + // changes the original options.plugins array, causing duplicate plugins + var plugins = (options.plugins && options.plugins.slice()) || []; + + // A list of main fields in description files + var mainFields = options.mainFields || ["main"]; + + // A list of alias fields in description files + var aliasFields = options.aliasFields || []; + + // A list of main files in directories + var mainFiles = options.mainFiles || ["index"]; + + // A list of extensions which should be tried for files + var extensions = options.extensions || [".js", ".json", ".node"]; + + // Enforce that a extension from extensions must be used + var enforceExtension = options.enforceExtension || false; + + // A list of module extensions which should be tried for modules + var moduleExtensions = options.moduleExtensions || []; + + // Enforce that a extension from moduleExtensions must be used + var enforceModuleExtension = options.enforceModuleExtension || false; + + // A list of module alias configurations or an object which maps key to value + var alias = options.alias || []; + + // Resolve symlinks to their symlinked location + var symlinks = typeof options.symlinks !== "undefined" ? options.symlinks : true; + + // Resolve to a context instead of a file + var resolveToContext = options.resolveToContext || false; + + // Use this cache object to unsafely cache the successful requests + var unsafeCache = options.unsafeCache || 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() { + return true; + }; + + // The file system which should be used + var fileSystem = options.fileSystem; + + // Use only the sync variants of the file system calls + var useSyncFileSystemCalls = options.useSyncFileSystemCalls; + + // A prepared Resolver to which the plugins are attached + var resolver = options.resolver; + + //// options processing //// + + if(!resolver) { + resolver = new Resolver(useSyncFileSystemCalls ? new SyncAsyncFileSystemDecorator(fileSystem) : fileSystem); + } + + extensions = [].concat(extensions); + moduleExtensions = [].concat(moduleExtensions); + + modules = mergeFilteredToArray([].concat(modules), function(item) { + return !isAbsolutePath(item); + }); + + mainFields = mainFields.map(function(item) { + if(typeof item === "string") { + item = { + name: item, + forceRelative: true + }; + } + return item; + }); + + if(typeof alias === "object" && !Array.isArray(alias)) { + alias = Object.keys(alias).map(function(key) { + var onlyModule = false; + var obj = alias[key]; + if(/\$$/.test(key)) { + onlyModule = true; + key = key.substr(0, key.length - 1); + } + if(typeof obj === "string") { + obj = { + alias: obj + }; + } + obj = Object.assign({ + name: key, + onlyModule: onlyModule + }, obj); + return obj; + }); + } + + if(unsafeCache && typeof unsafeCache !== "object") { + unsafeCache = {}; + } + + //// pipeline //// + + // resolve + if(unsafeCache) { + plugins.push(new UnsafeCachePlugin("resolve", cachePredicate, unsafeCache, "new-resolve")); + plugins.push(new ParsePlugin("new-resolve", "parsed-resolve")); + } else { + plugins.push(new ParsePlugin("resolve", "parsed-resolve")); + } + + // parsed-resolve + plugins.push(new DescriptionFilePlugin("parsed-resolve", descriptionFiles, "described-resolve")); + plugins.push(new NextPlugin("after-parsed-resolve", "described-resolve")); + + // described-resolve + alias.forEach(function(item) { + plugins.push(new AliasPlugin("described-resolve", item, "resolve")); + }); + plugins.push(new ConcordModulesPlugin("described-resolve", {}, "resolve")); + aliasFields.forEach(function(item) { + plugins.push(new AliasFieldPlugin("described-resolve", item, "resolve")); + }); + plugins.push(new ModuleKindPlugin("after-described-resolve", "raw-module")); + plugins.push(new JoinRequestPlugin("after-described-resolve", "relative")); + + // raw-module + moduleExtensions.forEach(function(item) { + plugins.push(new ModuleAppendPlugin("raw-module", item, "module")); + }); + if(!enforceModuleExtension) + plugins.push(new TryNextPlugin("raw-module", null, "module")); + + // module + modules.forEach(function(item) { + if(Array.isArray(item)) + plugins.push(new ModulesInHierachicDirectoriesPlugin("module", item, "resolve")); + else + plugins.push(new ModulesInRootPlugin("module", item, "resolve")); + }); + + // relative + plugins.push(new DescriptionFilePlugin("relative", descriptionFiles, "described-relative")); + plugins.push(new NextPlugin("after-relative", "described-relative")); + + // described-relative + plugins.push(new FileKindPlugin("described-relative", "raw-file")); + plugins.push(new TryNextPlugin("described-relative", "as directory", "directory")); + + // directory + plugins.push(new DirectoryExistsPlugin("directory", "existing-directory")); + + if(resolveToContext) { + + // existing-directory + plugins.push(new NextPlugin("existing-directory", "resolved")); + + } else { + + // existing-directory + plugins.push(new ConcordMainPlugin("existing-directory", {}, "resolve")); + mainFields.forEach(function(item) { + plugins.push(new MainFieldPlugin("existing-directory", item, "resolve")); + }); + mainFiles.forEach(function(item) { + plugins.push(new UseFilePlugin("existing-directory", item, "undescribed-raw-file")); + }); + + // undescribed-raw-file + plugins.push(new DescriptionFilePlugin("undescribed-raw-file", descriptionFiles, "raw-file")); + plugins.push(new NextPlugin("after-undescribed-raw-file", "raw-file")); + + // raw-file + if(!enforceExtension) + plugins.push(new TryNextPlugin("raw-file", "no extension", "file")); + plugins.push(new ConcordExtensionsPlugin("raw-file", {}, "file")); + extensions.forEach(function(item) { + plugins.push(new AppendPlugin("raw-file", item, "file")); + }); + + // file + alias.forEach(function(item) { + plugins.push(new AliasPlugin("file", item, "resolve")); + }); + plugins.push(new ConcordModulesPlugin("file", {}, "resolve")); + aliasFields.forEach(function(item) { + plugins.push(new AliasFieldPlugin("file", item, "resolve")); + }); + if(symlinks) + plugins.push(new SymlinkPlugin("file", "relative")); + plugins.push(new FileExistsPlugin("file", "existing-file")); + + // existing-file + plugins.push(new NextPlugin("existing-file", "resolved")); + + } + + // resolved + plugins.push(new ResultPlugin("resolved")); + + //// RESOLVER //// + + plugins.forEach(function(plugin) { + resolver.apply(plugin); + }); + return resolver; +}; + +function mergeFilteredToArray(array, filter) { + return array.reduce(function(array, item) { + if(filter(item)) { + var lastElement = array[array.length - 1]; + if(Array.isArray(lastElement)) { + lastElement.push(item); + } else { + array.push([item]); + } + return array; + } else { + array.push(item); + return array; + } + }, []); +} + +function isAbsolutePath(path) { + return /^[A-Z]:|^\//.test(path); +} diff --git a/node_modules/enhanced-resolve/lib/ResultPlugin.js b/node_modules/enhanced-resolve/lib/ResultPlugin.js new file mode 100644 index 000000000..7e262cc17 --- /dev/null +++ b/node_modules/enhanced-resolve/lib/ResultPlugin.js @@ -0,0 +1,18 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +function ResultPlugin(source) { + this.source = source; +} +module.exports = ResultPlugin; + +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); + }); + }); +}; diff --git a/node_modules/enhanced-resolve/lib/SymlinkPlugin.js b/node_modules/enhanced-resolve/lib/SymlinkPlugin.js new file mode 100644 index 000000000..85caf36da --- /dev/null +++ b/node_modules/enhanced-resolve/lib/SymlinkPlugin.js @@ -0,0 +1,49 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +var getPaths = require("./getPaths"); +var forEachBail = require("./forEachBail"); + +function SymlinkPlugin(source, target) { + this.source = source; + this.target = target; +} +module.exports = SymlinkPlugin; + +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; + + var containsSymlink = false; + forEachBail(paths.map(function(_, i) { + return i; + }), function(idx, callback) { + fs.readlink(paths[idx], 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(); + }); + }, 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); + }); + }); +}; diff --git a/node_modules/enhanced-resolve/lib/SyncAsyncFileSystemDecorator.js b/node_modules/enhanced-resolve/lib/SyncAsyncFileSystemDecorator.js new file mode 100644 index 000000000..f5b26c465 --- /dev/null +++ b/node_modules/enhanced-resolve/lib/SyncAsyncFileSystemDecorator.js @@ -0,0 +1,58 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +function SyncAsyncFileSystemDecorator(fs) { + this.fs = fs; + if(fs.statSync) { + this.stat = function(arg, callback) { + try { + var result = fs.statSync(arg); + } catch(e) { + return callback(e); + } + callback(null, result); + }; + } + if(fs.readdirSync) { + this.readdir = function(arg, callback) { + try { + var result = fs.readdirSync(arg); + } catch(e) { + return callback(e); + } + callback(null, result); + }; + } + if(fs.readFileSync) { + this.readFile = function(arg, callback) { + try { + var result = fs.readFileSync(arg); + } catch(e) { + return callback(e); + } + callback(null, result); + }; + } + if(fs.readlinkSync) { + this.readlink = function(arg, callback) { + try { + var result = fs.readlinkSync(arg); + } catch(e) { + return callback(e); + } + callback(null, result); + }; + } + if(fs.readJsonSync) { + this.readJson = function(arg, callback) { + try { + var result = fs.readJsonSync(arg); + } catch(e) { + return callback(e); + } + callback(null, result); + }; + } +} +module.exports = SyncAsyncFileSystemDecorator; diff --git a/node_modules/enhanced-resolve/lib/TryNextPlugin.js b/node_modules/enhanced-resolve/lib/TryNextPlugin.js new file mode 100644 index 000000000..e4c9f9c0f --- /dev/null +++ b/node_modules/enhanced-resolve/lib/TryNextPlugin.js @@ -0,0 +1,18 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +function TryNextPlugin(source, message, target) { + this.source = source; + this.message = message; + this.target = target; +} +module.exports = TryNextPlugin; + +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); + }); +}; diff --git a/node_modules/enhanced-resolve/lib/UnsafeCachePlugin.js b/node_modules/enhanced-resolve/lib/UnsafeCachePlugin.js new file mode 100644 index 000000000..61d9b4730 --- /dev/null +++ b/node_modules/enhanced-resolve/lib/UnsafeCachePlugin.js @@ -0,0 +1,41 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +var createInnerCallback = require("./createInnerCallback"); + +function UnsafeCachePlugin(source, filterPredicate, cache, target) { + this.source = source; + this.filterPredicate = filterPredicate; + this.cache = cache || {}; + this.target = target; +} +module.exports = UnsafeCachePlugin; + +function getCacheId(request) { + return JSON.stringify({ + context: request.context, + path: request.path, + query: request.query, + request: request.request + }); +} + +UnsafeCachePlugin.prototype.apply = function(resolver) { + var filterPredicate = this.filterPredicate; + var cache = this.cache; + var target = this.target; + resolver.plugin(this.source, function(request, callback) { + if(!filterPredicate(request)) return callback(); + var cacheId = getCacheId(request); + 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)); + }); +}; diff --git a/node_modules/enhanced-resolve/lib/UseFilePlugin.js b/node_modules/enhanced-resolve/lib/UseFilePlugin.js new file mode 100644 index 000000000..2413824f4 --- /dev/null +++ b/node_modules/enhanced-resolve/lib/UseFilePlugin.js @@ -0,0 +1,23 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +function UseFilePlugin(source, filename, target) { + this.source = source; + this.filename = filename; + this.target = target; +} +module.exports = UseFilePlugin; + +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) + }); + resolver.doResolve(target, obj, "using path: " + filePath, callback); + }); +}; diff --git a/node_modules/enhanced-resolve/lib/concord.js b/node_modules/enhanced-resolve/lib/concord.js new file mode 100644 index 000000000..c8db37940 --- /dev/null +++ b/node_modules/enhanced-resolve/lib/concord.js @@ -0,0 +1,189 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +var globToRegExp = require("./globToRegExp").globToRegExp; + +function parseType(type) { + var items = type.split("+"); + var t = items.shift(); + return { + type: t === "*" ? null : t, + features: items + }; +} + +function isTypeMatched(baseType, testedType) { + if(typeof baseType === "string") baseType = parseType(baseType); + if(typeof testedType === "string") testedType = parseType(testedType); + if(testedType.type && testedType.type !== baseType.type) return false; + return testedType.features.every(function(requiredFeature) { + return baseType.features.indexOf(requiredFeature) >= 0; + }); +} + +function isResourceTypeMatched(baseType, testedType) { + baseType = baseType.split("/"); + testedType = testedType.split("/"); + if(baseType.length !== testedType.length) return false; + for(var i = 0; i < baseType.length; i++) { + if(!isTypeMatched(baseType[i], testedType[i])) + return false; + } + return true; +} + +function isResourceTypeSupported(context, type) { + return context.supportedResourceTypes && context.supportedResourceTypes.some(function(supportedType) { + return isResourceTypeMatched(supportedType, type); + }); +} + +function isEnvironment(context, env) { + return context.environments && context.environments.every(function(environment) { + return isTypeMatched(environment, env); + }); +} + +var globCache = {}; + +function getGlobRegExp(glob) { + var regExp = globCache[glob] || (globCache[glob] = globToRegExp(glob)); + return regExp; +} + +function matchGlob(glob, relativePath) { + var regExp = getGlobRegExp(glob); + return regExp.exec(relativePath); +} + +function isGlobMatched(glob, relativePath) { + return !!matchGlob(glob, relativePath); +} + +function isConditionMatched(context, condition) { + var items = condition.split("|"); + return items.some(function testFn(item) { + item = item.trim(); + var 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]; + switch(name) { + case "referrer": + return isGlobMatched(value, context.referrer); + default: + return false; + } + } else if(item.indexOf("/") >= 0) { + // match supported type + return isResourceTypeSupported(context, item); + } else { + // match environment + return isEnvironment(context, item); + } + }); +} + +function isKeyMatched(context, key) { + while(true) { //eslint-disable-line + var match = /^\[([^\]]+)\]\s*/.exec(key); + if(!match) return key; + key = key.substr(match[0].length); + var condition = match[1]; + if(!isConditionMatched(context, condition)) { + return false; + } + } +} + +function getField(context, configuration, field) { + var value; + Object.keys(configuration).forEach(function(key) { + var pureKey = isKeyMatched(context, key); + if(pureKey === field) { + value = configuration[key]; + } + }); + return value; +} + +function getMain(context, configuration) { + return getField(context, configuration, "main"); +} + +function getExtensions(context, configuration) { + return getField(context, configuration, "extensions"); +} + +function matchModule(context, configuration, request) { + var 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); + if(match) { + var value = modulesField[key]; + if(typeof value !== "string") { + return value; + } else if(/^\(.+\)$/.test(pureKey)) { + newRequest = newRequest.replace(getGlobRegExp(pureKey), value); + } else { + var index = 1; + newRequest = value.replace(/(\/?\*)?\*/g, replaceMatcher); + } + i = -1; + if(iteration++ > keys.length) { + throw new Error("Request '" + request + "' matches recursively"); + } + } + } + return newRequest; + + function replaceMatcher(find) { + switch(find) { + case "/**": + var m = match[index++]; + return m ? "/" + m : ""; + case "**": + case "*": + return match[index++]; + } + } +} + +function matchType(context, configuration, relativePath) { + var typesField = getField(context, configuration, "types"); + if(!typesField) return undefined; + var type; + Object.keys(typesField).forEach(function(key) { + var pureKey = isKeyMatched(context, key); + if(isGlobMatched(pureKey, relativePath)) { + var value = typesField[key]; + if(!type && /\/\*$/.test(value)) + throw new Error("value ('" + value + "') of key '" + key + "' contains '*', but there is no previous value defined"); + type = value.replace(/\/\*$/, "/" + type); + } + }); + return type; +} + +exports.parseType = parseType; +exports.isTypeMatched = isTypeMatched; +exports.isResourceTypeSupported = isResourceTypeSupported; +exports.isEnvironment = isEnvironment; +exports.isGlobMatched = isGlobMatched; +exports.isConditionMatched = isConditionMatched; +exports.isKeyMatched = isKeyMatched; +exports.getField = getField; +exports.getMain = getMain; +exports.getExtensions = getExtensions; +exports.matchModule = matchModule; +exports.matchType = matchType; diff --git a/node_modules/enhanced-resolve/lib/createInnerCallback.js b/node_modules/enhanced-resolve/lib/createInnerCallback.js new file mode 100644 index 000000000..0acea4662 --- /dev/null +++ b/node_modules/enhanced-resolve/lib/createInnerCallback.js @@ -0,0 +1,41 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +module.exports = function createInnerCallback(callback, options, message, messageOptional) { + var log = options.log; + if(!log) { + if(options.stack !== callback.stack) { + var callbackWrapper = function callbackWrapper() { + return callback.apply(this, arguments); + }; + callbackWrapper.stack = options.stack; + callbackWrapper.missing = options.missing; + return callbackWrapper; + } + return callback; + } + + 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); + }; + loggingCallbackWrapper.stack = options.stack; + loggingCallbackWrapper.missing = options.missing; + return loggingCallbackWrapper; +}; diff --git a/node_modules/enhanced-resolve/lib/forEachBail.js b/node_modules/enhanced-resolve/lib/forEachBail.js new file mode 100644 index 000000000..ce0893160 --- /dev/null +++ b/node_modules/enhanced-resolve/lib/forEachBail.js @@ -0,0 +1,34 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +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); + iterator(array[i], itCb); + if(currentPos === 0) break; + } + + function createIteratorCallback(i) { + return function() { + if(i >= currentPos) return; // ignore + var args = Array.prototype.slice.call(arguments); + done.push(i); + if(args.length > 0) { + currentPos = i + 1; + done = done.filter(function(item) { + return item <= i; + }); + currentResult = args; + } + if(done.length === currentPos) { + callback.apply(null, currentResult); + currentPos = 0; + } + }; + } +}; diff --git a/node_modules/enhanced-resolve/lib/getInnerRequest.js b/node_modules/enhanced-resolve/lib/getInnerRequest.js new file mode 100644 index 000000000..3f6ac148c --- /dev/null +++ b/node_modules/enhanced-resolve/lib/getInnerRequest.js @@ -0,0 +1,22 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +module.exports = function getInnerRequest(resolver, request) { + if(typeof request.__innerRequest === "string" && + request.__innerRequest_request === request.request && + request.__innerRequest_relativePath === request.relativePath) + return request.__innerRequest; + var innerRequest; + if(request.request) { + innerRequest = request.request; + if(/^\.\.?\//.test(innerRequest) && request.relativePath) { + innerRequest = resolver.join(request.relativePath, innerRequest); + } + } else { + innerRequest = request.relativePath; + } + request.__innerRequest_request = request.request; + request.__innerRequest_relativePath = request.relativePath; + return request.__innerRequest = innerRequest; +}; diff --git a/node_modules/enhanced-resolve/lib/getPaths.js b/node_modules/enhanced-resolve/lib/getPaths.js new file mode 100644 index 000000000..695fbcd5f --- /dev/null +++ b/node_modules/enhanced-resolve/lib/getPaths.js @@ -0,0 +1,33 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +module.exports = function getPaths(path) { + var parts = path.split(/(.*?[\\\/]+)/); + var paths = [path]; + var seqments = [parts[parts.length - 1]]; + var 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) { + part = parts[i]; + path = path.substr(0, path.length - part.length) || "/"; + paths.push(path); + seqments.push(part.substr(0, part.length - 1)); + } + part = parts[1]; + seqments.push(part.length > 1 ? part.substr(0, part.length - 1) : part); + return { + paths: paths, + seqments: seqments + }; +}; + +module.exports.basename = function basename(path) { + var i = path.lastIndexOf("/"), + j = path.lastIndexOf("\\"); + var p = i < 0 ? j : j < 0 ? i : i < j ? j : i; + if(p < 0) return null; + var s = path.substr(p + 1); + return s; +}; diff --git a/node_modules/enhanced-resolve/lib/globToRegExp.js b/node_modules/enhanced-resolve/lib/globToRegExp.js new file mode 100644 index 000000000..7b97a6924 --- /dev/null +++ b/node_modules/enhanced-resolve/lib/globToRegExp.js @@ -0,0 +1,188 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +function globToRegExp(glob) { + // * [^\\\/]* + // /**/ /.+/ + // ^* \./.+ (concord special) + // ? [^\\\/] + // [!...] [^...] + // [^...] [^...] + // / [\\\/] + // {...,...} (...|...) + // ?(...|...) (...|...)? + // +(...|...) (...|...)+ + // *(...|...) (...|...)* + // @(...|...) (...|...) + if(/^\(.+\)$/.test(glob)) { + // allow to pass an RegExp in brackets + return new RegExp(glob.substr(1, glob.length - 2)); + } + var tokens = tokenize(glob); + var process = createRoot(); + var regExpStr = tokens.map(process).join(""); + return new RegExp("^" + regExpStr + "$"); +} + +var SIMPLE_TOKENS = { + "@(": "one", + "?(": "zero-one", + "+(": "one-many", + "*(": "zero-many", + "|": "segment-sep", + "/**/": "any-path-segments", + "**": "any-path", + "*": "any-path-segment", + "?": "any-char", + "{": "or", + "/": "path-sep", + ",": "comma", + ")": "closing-segment", + "}": "closing-or" +}; + +function tokenize(glob) { + return glob.split(/([@?+*]\(|\/\*\*\/|\*\*|[?*]|\[[\!\^]?(?:[^\]\\]|\\.)+\]|\{|,|\/|[|)}])/g).map(function(item) { + if(!item) + return null; + var t = SIMPLE_TOKENS[item]; + if(t) { + return { + type: t + }; + } + if(item[0] === "[") { + if(item[1] === "^" || item[1] === "!") { + return { + type: "inverted-char-set", + value: item.substr(2, item.length - 3) + }; + } else { + return { + type: "char-set", + value: item.substr(1, item.length - 2) + }; + } + } + return { + type: "string", + value: item + }; + }).filter(Boolean).concat({ + type: "end" + }); +} + +function createRoot() { + var inOr = []; + var process = createSeqment(); + var initial = true; + return function(token) { + switch(token.type) { + case "or": + inOr.push(initial); + return "("; + case "comma": + if(inOr.length) { + initial = inOr[inOr.length - 1]; + return "|"; + } else { + return process({ + type: "string", + value: "," + }, initial); + } + case "closing-or": + if(inOr.length === 0) + throw new Error("Unmatched '}'"); + inOr.pop(); + return ")"; + case "end": + if(inOr.length) + throw new Error("Unmatched '{'"); + return process(token, initial); + default: + var result = process(token, initial); + initial = false; + return result; + } + }; +} + +function createSeqment() { + var inSeqment = []; + var process = createSimple(); + return function(token, initial) { + switch(token.type) { + case "one": + case "one-many": + case "zero-many": + case "zero-one": + inSeqment.push(token.type); + return "("; + case "segment-sep": + if(inSeqment.length) { + return "|"; + } else { + return process({ + type: "string", + value: "|" + }, initial); + } + case "closing-segment": + var 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); + case "end": + if(inSeqment.length > 0) { + throw new Error("Unmatched segment, missing ')'"); + } + return process(token, initial); + default: + return process(token, initial); + } + }; +} + +function createSimple() { + return function(token, initial) { + switch(token.type) { + case "path-sep": + return "[\\\\/]+"; + case "any-path-segments": + return "[\\\\/]+(?:(.+)[\\\\/]+)?"; + case "any-path": + return "(.*)"; + case "any-path-segment": + if(initial) { + return "\\.[\\\\/]+(?:.*[\\\\/]+)?([^\\\\/]+)"; + } else { + return "([^\\\\/]*)"; + } + case "any-char": + return "[^\\\\/]"; + case "inverted-char-set": + return "[^" + token.value + "]"; + case "char-set": + return "[" + token.value + "]"; + case "string": + return token.value.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"); + case "end": + return ""; + default: + throw new Error("Unsupported token '" + token.type + "'"); + } + }; +} + +exports.globToRegExp = globToRegExp; diff --git a/node_modules/enhanced-resolve/lib/node.js b/node_modules/enhanced-resolve/lib/node.js new file mode 100644 index 000000000..1e79cdc25 --- /dev/null +++ b/node_modules/enhanced-resolve/lib/node.js @@ -0,0 +1,144 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +var ResolverFactory = require("./ResolverFactory"); + +var NodeJsInputFileSystem = require("./NodeJsInputFileSystem"); +var CachedInputFileSystem = require("./CachedInputFileSystem"); + +var nodeFileSystem = new CachedInputFileSystem(new NodeJsInputFileSystem(), 4000); + +var nodeContext = { + environments: [ + "node+es3+es5+process+native" + ] +}; + +var asyncResolver = ResolverFactory.createResolver({ + extensions: [".js", ".json", ".node"], + fileSystem: nodeFileSystem +}); +module.exports = function resolve(context, path, request, callback) { + if(typeof context === "string") { + callback = request; + request = path; + path = context; + context = nodeContext; + } + asyncResolver.resolve(context, path, request, callback); +}; + +var syncResolver = ResolverFactory.createResolver({ + extensions: [".js", ".json", ".node"], + useSyncFileSystemCalls: true, + fileSystem: nodeFileSystem +}); +module.exports.sync = function resolveSync(context, path, request) { + if(typeof context === "string") { + request = path; + path = context; + context = nodeContext; + } + return syncResolver.resolveSync(context, path, request); +}; + +var asyncContextResolver = ResolverFactory.createResolver({ + extensions: [".js", ".json", ".node"], + resolveToContext: true, + fileSystem: nodeFileSystem +}); +module.exports.context = function resolveContext(context, path, request, callback) { + if(typeof context === "string") { + callback = request; + request = path; + path = context; + context = nodeContext; + } + asyncContextResolver.resolve(context, path, request, callback); +}; + +var syncContextResolver = ResolverFactory.createResolver({ + extensions: [".js", ".json", ".node"], + resolveToContext: true, + useSyncFileSystemCalls: true, + fileSystem: nodeFileSystem +}); +module.exports.context.sync = function resolveContextSync(context, path, request) { + if(typeof context === "string") { + request = path; + path = context; + context = nodeContext; + } + return syncContextResolver.resolveSync(context, path, request); +}; + +var asyncLoaderResolver = ResolverFactory.createResolver({ + extensions: [".js", ".json", ".node"], + moduleExtensions: ["-loader"], + mainFields: ["loader", "main"], + fileSystem: nodeFileSystem +}); +module.exports.loader = function resolveLoader(context, path, request, callback) { + if(typeof context === "string") { + callback = request; + request = path; + path = context; + context = nodeContext; + } + asyncLoaderResolver.resolve(context, path, request, callback); +}; + +var syncLoaderResolver = ResolverFactory.createResolver({ + extensions: [".js", ".json", ".node"], + moduleExtensions: ["-loader"], + mainFields: ["loader", "main"], + useSyncFileSystemCalls: true, + fileSystem: nodeFileSystem +}); +module.exports.loader.sync = function resolveLoaderSync(context, path, request) { + if(typeof context === "string") { + request = path; + path = context; + context = nodeContext; + } + return syncLoaderResolver.resolveSync(context, path, request); +}; + +module.exports.create = function create(options) { + options = Object.assign({ + fileSystem: nodeFileSystem + }, options); + var resolver = ResolverFactory.createResolver(options); + return function(context, path, request, callback) { + if(typeof context === "string") { + callback = request; + request = path; + path = context; + context = nodeContext; + } + resolver.resolve(context, path, request, callback); + }; +}; + +module.exports.create.sync = function createSync(options) { + options = Object.assign({ + useSyncFileSystemCalls: true, + fileSystem: nodeFileSystem + }, options); + var resolver = ResolverFactory.createResolver(options); + return function(context, path, request) { + if(typeof context === "string") { + request = path; + path = context; + context = nodeContext; + } + return resolver.resolveSync(context, path, request); + }; +}; + +// Export Resolver, FileSystems and Plugins +module.exports.ResolverFactory = ResolverFactory; + +module.exports.NodeJsInputFileSystem = NodeJsInputFileSystem; +module.exports.CachedInputFileSystem = CachedInputFileSystem; -- cgit v1.2.3