update

node_modules/enhanced-resolve/lib/ResolverFactory.js

@@ -28,6 +28,7 @@ const SymlinkPlugin = require("./SymlinkPlugin");
 const MainFieldPlugin = require("./MainFieldPlugin");
 const UseFilePlugin = require("./UseFilePlugin");
 const AppendPlugin = require("./AppendPlugin");
+const RootPlugin = require("./RootPlugin");
 const RestrictionsPlugin = require("./RestrictionsPlugin");
 const ResultPlugin = require("./ResultPlugin");
 const ModuleAppendPlugin = require("./ModuleAppendPlugin");
@@ -78,6 +79,15 @@ exports.createResolver = function(options) {
 	// Resolve to a context instead of a file
 	const resolveToContext = options.resolveToContext || false;
 
+	// A list of root paths
+	const roots = options.roots || [];
+
+	// Ignore errors happening when resolving roots
+	const ignoreRootsErrors = options.ignoreRootsErrors || false;
+
+	// Prefer to resolve server-relative urls as absolute paths before falling back to resolve in roots
+	const preferAbsolute = options.preferAbsolute || false;
+
 	const restrictions = options.restrictions || [];
 
 	// Use this cache object to unsafely cache the successful requests
@@ -217,7 +227,22 @@ exports.createResolver = function(options) {
 		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"));
+	if (preferAbsolute) {
+		plugins.push(new JoinRequestPlugin("after-described-resolve", "relative"));
+	}
+	roots.forEach(root => {
+		plugins.push(
+			new RootPlugin(
+				"after-described-resolve",
+				root,
+				"relative",
+				ignoreRootsErrors
+			)
+		);
+	});
+	if (!preferAbsolute) {
+		plugins.push(new JoinRequestPlugin("after-described-resolve", "relative"));
+	}
 
 	// raw-module
 	moduleExtensions.forEach(item => {

node_modules/enhanced-resolve/lib/RootPlugin.js

@@ -0,0 +1,68 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+
+class RootPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source hook
+	 * @param {Array<string>} root roots
+	 * @param {string | ResolveStepHook} target target hook
+	 * @param {boolean=} ignoreErrors ignore error during resolving of root paths
+	 */
+	constructor(source, root, target, ignoreErrors) {
+		this.root = root;
+		this.source = source;
+		this.target = target;
+		this._ignoreErrors = ignoreErrors;
+	}
+
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+
+		resolver
+			.getHook(this.source)
+			.tapAsync("RootPlugin", (request, resolveContext, callback) => {
+				const req = request.request;
+				if (!req) return callback();
+				if (!req.startsWith("/")) return callback();
+
+				const path = resolver.join(this.root, req.slice(1));
+				const obj = Object.assign(request, {
+					path,
+					relativePath: request.relativePath && path
+				});
+				resolver.doResolve(
+					target,
+					obj,
+					`root path ${this.root}`,
+					resolveContext,
+					this._ignoreErrors
+						? (err, result) => {
+								if (err) {
+									if (resolveContext.log) {
+										resolveContext.log(
+											`Ignored fatal error while resolving root path:\n${err}`
+										);
+									}
+									return callback();
+								}
+								if (result) return callback(null, result);
+								callback();
+						  }
+						: callback
+				);
+			});
+	}
+}
+
+module.exports = RootPlugin;