Merge pull request #182 from webpack/next

Improvements for new major version

Author: sokra

.eslintrc.js

@@ -11,7 +11,7 @@ module.exports = {
 		es6: true
 	},
 	parserOptions: {
-		ecmaVersion: 2017
+		ecmaVersion: 2018
 	},
 	rules: {
 		"prettier/prettier": "error",

.gitignore

@@ -1,4 +1,5 @@
 /node_modules
 /coverage
+/.nyc_output
 *.log
 .eslintcache

.travis.yml

@@ -1,11 +1,10 @@
 sudo: false
 language: node_js
 node_js:
+  - "12"
+  - "10"
   - "8"
-  - "6"
 script: npm run travis
 
 after_success:
-  - cat ./coverage/lcov.info | node_modules/.bin/coveralls --verbose
-  - cat ./coverage/coverage.json | node_modules/codecov.io/bin/codecov.io.js
-  - rm -rf ./coverage
+  - bash <(curl -s https://codecov.io/bash) -X gcov

README.md

@@ -4,13 +4,14 @@ Offers an async require.resolve function. It's highly configurable.
 
 ## Features
 
-* plugin system
-* provide a custom filesystem
-* sync and async node.js filesystems included
-
+- plugin system
+- provide a custom filesystem
+- sync and async node.js filesystems included
 
 ## Getting Started
+
 ### Install
+
 ```sh
 # npm
 npm install enhanced-resolve
@@ -19,90 +20,96 @@ yarn add enhanced-resolve
 ```
 
 ### Creating a Resolver
+
 The easiest way to create a resolver is to use the `createResolver` function on `ResolveFactory`, along with one of the supplied File System implementations.
+
 ```js
-const {
-  NodeJsInputFileSystem,
-  CachedInputFileSystem,
-  ResolverFactory
-} = require('enhanced-resolve');
+const fs = require("fs");
+const { CachedInputFileSystem, ResolverFactory } = require("enhanced-resolve");
 
 // create a resolver
 const myResolver = ResolverFactory.createResolver({
-  // Typical usage will consume the `NodeJsInputFileSystem` + `CachedInputFileSystem`, which wraps the Node.js `fs` wrapper to add resilience + caching.
-  fileSystem: new CachedInputFileSystem(new NodeJsInputFileSystem(), 4000),
-  extensions: ['.js', '.json']
-  /* any other resolver options here. Options/defaults can be seen below */
+	// Typical usage will consume the `fs` + `CachedInputFileSystem`, which wraps Node.js `fs` to add caching.
+	fileSystem: new CachedInputFileSystem(fs, 4000),
+	extensions: [".js", ".json"]
+	/* any other resolver options here. Options/defaults can be seen below */
 });
 
 // resolve a file with the new resolver
 const context = {};
 const resolveContext = {};
-const lookupStartPath = '/Users/webpack/some/root/dir';
-const request = './path/to-look-up.js';
-myResolver.resolve({}, lookupStartPath, request, resolveContext, (err/*Error*/, filepath/*string*/) => {
-  // Do something with the path
+const lookupStartPath = "/Users/webpack/some/root/dir";
+const request = "./path/to-look-up.js";
+myResolver.resolve({}, lookupStartPath, request, resolveContext, (
+	err /*Error*/,
+	filepath /*string*/
+) => {
+	// Do something with the path
 });
 ```
 
 For more examples creating different types resolvers (sync/async, context, etc) see `lib/node.js`.
+
 #### Resolver Options
-| Field                    | Default                     | Description                                                                        |
-| ------------------------ | --------------------------- | ---------------------------------------------------------------------------------- |
-| alias                    | []                          | A list of module alias configurations or an object which maps key to value |
-| aliasFields              | []                          | A list of alias fields in description files |
-| cacheWithContext         | true                        | If unsafe cache is enabled, includes `request.context` in the cache key  |
-| descriptionFiles         | ["package.json"]            | A list of description files to read from |
-| enforceExtension         | false                       | Enforce that a extension from extensions must be used |
-| enforceModuleExtension   | false                       | Enforce that a extension from moduleExtensions must be used |
-| extensions               | [".js", ".json", ".node"]   | A list of extensions which should be tried for files |
-| mainFields               | ["main"]                    | A list of main fields in description files |
-| mainFiles                | ["index"]                   | A list of main files in directories |
-| modules                  | ["node_modules"]            | A list of directories to resolve modules from, can be absolute path or folder name |
-| unsafeCache              | false                       | Use this cache object to unsafely cache the successful requests |
-| plugins                  | []                          | A list of additional resolve plugins which should be applied |
-| symlinks                 | true                        | Whether to resolve symlinks to their symlinked location |
-| cachePredicate           | function() { return true }; | A function which decides whether a request should be cached or not. An object is passed to the function with `path` and `request` properties. |
-| moduleExtensions         | []                          | A list of module extensions which should be tried for modules |
-| resolveToContext         | false                       | Resolve to a context instead of a file |
-| fileSystem               |                             | The file system which should be used |
-| resolver                 | undefined                   | A prepared Resolver to which the plugins are attached |
+
+| Field            | Default                     | Description                                                                                                                                   |
+| ---------------- | --------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
+| alias            | []                          | A list of module alias configurations or an object which maps key to value                                                                    |
+| aliasFields      | []                          | A list of alias fields in description files                                                                                                   |
+| cacheWithContext | true                        | If unsafe cache is enabled, includes `request.context` in the cache key                                                                       |
+| descriptionFiles | ["package.json"]            | A list of description files to read from                                                                                                      |
+| enforceExtension | false                       | Enforce that a extension from extensions must be used                                                                                         |
+| extensions       | [".js", ".json", ".node"]   | A list of extensions which should be tried for files                                                                                          |
+| mainFields       | ["main"]                    | A list of main fields in description files                                                                                                    |
+| mainFiles        | ["index"]                   | A list of main files in directories                                                                                                           |
+| modules          | ["node_modules"]            | A list of directories to resolve modules from, can be absolute path or folder name                                                            |
+| unsafeCache      | false                       | Use this cache object to unsafely cache the successful requests                                                                               |
+| plugins          | []                          | A list of additional resolve plugins which should be applied                                                                                  |
+| symlinks         | true                        | Whether to resolve symlinks to their symlinked location                                                                                       |
+| cachePredicate   | function() { return true }; | A function which decides whether a request should be cached or not. An object is passed to the function with `path` and `request` properties. |
+| resolveToContext | false                       | Resolve to a context instead of a file                                                                                                        |
+| fileSystem       |                             | The file system which should be used                                                                                                          |
+| resolver         | undefined                   | A prepared Resolver to which the plugins are attached                                                                                         |
 
 ## Plugins
+
 Similar to `webpack`, the core of `enhanced-resolve` functionality is implemented as individual plugins that are executed using [`Tapable`](https://github.com/webpack/tapable). These plugins can extend the functionality of the library, adding other ways for files/contexts to be resolved.
 
 A plugin should be a `class` (or its ES5 equivalent) with an `apply` method. The `apply` method will receive a `resolver` instance, that can be used to hook in to the event system.
 
 ### Plugin Boilerplate
+
 ```js
 class MyResolverPlugin {
-  constructor(source, target) {
-    this.source = source;
-    this.target = target;
-  }
-
-  apply(resolver) {
-    const target = resolver.ensureHook(this.target);
-    resolver.getHook(this.source).tapAsync("MyResolverPlugin", (request, resolveContext, callback) => {
-      // Any logic you need to create a new `request` can go here
-      resolver.doResolve(target, request, null, resolveContext, callback);
-    });
-  }
+	constructor(source, target) {
+		this.source = source;
+		this.target = target;
+	}
+
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("MyResolverPlugin", (request, resolveContext, callback) => {
+				// Any logic you need to create a new `request` can go here
+				resolver.doResolve(target, request, null, resolveContext, callback);
+			});
+	}
 }
 ```
 
 Plugins are executed in a pipeline, and register which event they should be executed before/after. In the example above, `source` is the name of the event that starts the pipeline, and `target` is what event this plugin should fire, which is what continues the execution of the pipeline. For an example of how these different plugin events create a chain, see `lib/ResolverFactory.js`, in the `//// pipeline ////` section.
 
 ## Tests
 
-``` javascript
+```javascript
 npm test
 ```
 
 [![Build Status](https://secure.travis-ci.org/webpack/enhanced-resolve.png?branch=master)](http://travis-ci.org/webpack/enhanced-resolve)
 
-
 ## Passing options from webpack
+
 If you are using `webpack`, and you want to pass custom options to `enhanced-resolve`, the options are passed from the `resolve` key of your webpack configuration e.g.:
 
 ```

lib/AliasFieldPlugin.js

@@ -41,15 +41,17 @@ module.exports = class AliasFieldPlugin {
 				if (data === innerRequest) return callback();
 				if (data === undefined) return callback();
 				if (data === false) {
-					const ignoreObj = Object.assign({}, request, {
+					const ignoreObj = {
+						...request,
 						path: false
-					});
+					};
 					return callback(null, ignoreObj);
 				}
-				const obj = Object.assign({}, request, {
+				const obj = {
+					...request,
 					path: request.descriptionFileRoot,
 					request: data
-				});
+				};
 				resolver.doResolve(
 					target,
 					obj,

lib/AliasPlugin.js

@@ -4,22 +4,7 @@
 */
 "use strict";
 
-function startsWith(string, searchString) {
-	const stringLength = string.length;
-	const searchLength = searchString.length;
-
-	// early out if the search length is greater than the search string
-	if (searchLength > stringLength) {
-		return false;
-	}
-	let index = -1;
-	while (++index < searchLength) {
-		if (string.charCodeAt(index) !== searchString.charCodeAt(index)) {
-			return false;
-		}
-	}
-	return true;
-}
+const forEachBail = require("./forEachBail");
 
 module.exports = class AliasPlugin {
 	constructor(source, options, target) {
@@ -35,43 +20,68 @@ module.exports = class AliasPlugin {
 			.tapAsync("AliasPlugin", (request, resolveContext, callback) => {
 				const innerRequest = request.request || request.path;
 				if (!innerRequest) return callback();
-				for (const item of this.options) {
-					if (
-						innerRequest === item.name ||
-						(!item.onlyModule && startsWith(innerRequest, item.name + "/"))
-					) {
+				forEachBail(
+					this.options,
+					(item, callback) => {
+						let shouldStop = false;
 						if (
-							innerRequest !== item.alias &&
-							!startsWith(innerRequest, item.alias + "/")
+							innerRequest === item.name ||
+							(!item.onlyModule && innerRequest.startsWith(item.name + "/"))
 						) {
-							const newRequestStr =
-								item.alias + innerRequest.substr(item.name.length);
-							const obj = Object.assign({}, request, {
-								request: newRequestStr
-							});
-							return resolver.doResolve(
-								target,
-								obj,
-								"aliased with mapping '" +
-									item.name +
-									"': '" +
-									item.alias +
-									"' to '" +
-									newRequestStr +
-									"'",
-								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);
+							const remainingRequest = innerRequest.substr(item.name.length);
+							const resolveWithAlias = (alias, callback) => {
+								if (
+									innerRequest !== alias &&
+									!innerRequest.startsWith(alias + "/")
+								) {
+									shouldStop = true;
+									const newRequestStr = alias + remainingRequest;
+									const obj = {
+										...request,
+										request: newRequestStr
+									};
+									return resolver.doResolve(
+										target,
+										obj,
+										"aliased with mapping '" +
+											item.name +
+											"': '" +
+											alias +
+											"' to '" +
+											newRequestStr +
+											"'",
+										resolveContext,
+										(err, result) => {
+											if (err) return callback(err);
+											if (result) return callback(null, result);
+											return callback();
+										}
+									);
 								}
-							);
+								return callback();
+							};
+							const stoppingCallback = (err, result) => {
+								if (err) return callback(err);
+
+								if (result) return callback(null, result);
+								// Don't allow other aliasing or raw request
+								if (shouldStop) return callback(null, null);
+								return callback();
+							};
+							if (Array.isArray(item.alias)) {
+								return forEachBail(
+									item.alias,
+									resolveWithAlias,
+									stoppingCallback
+								);
+							} else {
+								return resolveWithAlias(item.alias, stoppingCallback);
+							}
 						}
-					}
-				}
-				return callback();
+						return callback();
+					},
+					callback
+				);
 			});
 	}
 };

lib/AppendPlugin.js

@@ -16,11 +16,12 @@ module.exports = class AppendPlugin {
 		resolver
 			.getHook(this.source)
 			.tapAsync("AppendPlugin", (request, resolveContext, callback) => {
-				const obj = Object.assign({}, request, {
+				const obj = {
+					...request,
 					path: request.path + this.appending,
 					relativePath:
 						request.relativePath && request.relativePath + this.appending
-				});
+				};
 				resolver.doResolve(
 					target,
 					obj,

lib/CloneBasenamePlugin.js

@@ -19,12 +19,13 @@ module.exports = class CloneBasenamePlugin {
 			.tapAsync("CloneBasenamePlugin", (request, resolveContext, callback) => {
 				const filename = basename(request.path);
 				const filePath = resolver.join(request.path, filename);
-				const obj = Object.assign({}, request, {
+				const obj = {
+					...request,
 					path: filePath,
 					relativePath:
 						request.relativePath &&
 						resolver.join(request.relativePath, filename)
-				});
+				};
 				resolver.doResolve(
 					target,
 					obj,