@eriche/webpack 4.47.0

package/lib/RecordIdsPlugin.js

@@ -0,0 +1,236 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const identifierUtils = require("./util/identifier");
+
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./Module")} Module */
+
+/**
+ * @typedef {Object} RecordsChunks
+ * @property {Record<string, number>=} byName
+ * @property {Record<string, number>=} bySource
+ * @property {number[]=} usedIds
+ */
+
+/**
+ * @typedef {Object} RecordsModules
+ * @property {Record<string, number>=} byIdentifier
+ * @property {Record<string, number>=} bySource
+ * @property {Record<number, number>=} usedIds
+ */
+
+/**
+ * @typedef {Object} Records
+ * @property {RecordsChunks=} chunks
+ * @property {RecordsModules=} modules
+ */
+
+class RecordIdsPlugin {
+	/**
+	 * @param {Object} options Options object
+	 * @param {boolean=} options.portableIds true, when ids need to be portable
+	 */
+	constructor(options) {
+		this.options = options || {};
+	}
+
+	/**
+	 * @param {Compiler} compiler the Compiler
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const portableIds = this.options.portableIds;
+		compiler.hooks.compilation.tap("RecordIdsPlugin", compilation => {
+			compilation.hooks.recordModules.tap(
+				"RecordIdsPlugin",
+				/**
+				 * @param {Module[]} modules the modules array
+				 * @param {Records} records the records object
+				 * @returns {void}
+				 */
+				(modules, records) => {
+					if (!records.modules) records.modules = {};
+					if (!records.modules.byIdentifier) records.modules.byIdentifier = {};
+					if (!records.modules.usedIds) records.modules.usedIds = {};
+					for (const module of modules) {
+						if (typeof module.id !== "number") continue;
+						const identifier = portableIds
+							? identifierUtils.makePathsRelative(
+									compiler.context,
+									module.identifier(),
+									compilation.cache
+							  )
+							: module.identifier();
+						records.modules.byIdentifier[identifier] = module.id;
+						records.modules.usedIds[module.id] = module.id;
+					}
+				}
+			);
+			compilation.hooks.reviveModules.tap(
+				"RecordIdsPlugin",
+				/**
+				 * @param {Module[]} modules the modules array
+				 * @param {Records} records the records object
+				 * @returns {void}
+				 */
+				(modules, records) => {
+					if (!records.modules) return;
+					if (records.modules.byIdentifier) {
+						/** @type {Set<number>} */
+						const usedIds = new Set();
+						for (const module of modules) {
+							if (module.id !== null) continue;
+							const identifier = portableIds
+								? identifierUtils.makePathsRelative(
+										compiler.context,
+										module.identifier(),
+										compilation.cache
+								  )
+								: module.identifier();
+							const id = records.modules.byIdentifier[identifier];
+							if (id === undefined) continue;
+							if (usedIds.has(id)) continue;
+							usedIds.add(id);
+							module.id = id;
+						}
+					}
+					if (Array.isArray(records.modules.usedIds)) {
+						compilation.usedModuleIds = new Set(records.modules.usedIds);
+					}
+				}
+			);
+
+			/**
+			 * @param {Module} module the module
+			 * @returns {string} the (portable) identifier
+			 */
+			const getModuleIdentifier = module => {
+				if (portableIds) {
+					return identifierUtils.makePathsRelative(
+						compiler.context,
+						module.identifier(),
+						compilation.cache
+					);
+				}
+				return module.identifier();
+			};
+
+			/**
+			 * @param {Chunk} chunk the chunk
+			 * @returns {string[]} sources of the chunk
+			 */
+			const getChunkSources = chunk => {
+				/** @type {string[]} */
+				const sources = [];
+				for (const chunkGroup of chunk.groupsIterable) {
+					const index = chunkGroup.chunks.indexOf(chunk);
+					if (chunkGroup.name) {
+						sources.push(`${index} ${chunkGroup.name}`);
+					} else {
+						for (const origin of chunkGroup.origins) {
+							if (origin.module) {
+								if (origin.request) {
+									sources.push(
+										`${index} ${getModuleIdentifier(origin.module)} ${
+											origin.request
+										}`
+									);
+								} else if (typeof origin.loc === "string") {
+									sources.push(
+										`${index} ${getModuleIdentifier(origin.module)} ${
+											origin.loc
+										}`
+									);
+								} else if (
+									origin.loc &&
+									typeof origin.loc === "object" &&
+									origin.loc.start
+								) {
+									sources.push(
+										`${index} ${getModuleIdentifier(
+											origin.module
+										)} ${JSON.stringify(origin.loc.start)}`
+									);
+								}
+							}
+						}
+					}
+				}
+				return sources;
+			};
+
+			compilation.hooks.recordChunks.tap(
+				"RecordIdsPlugin",
+				/**
+				 * @param {Chunk[]} chunks the chunks array
+				 * @param {Records} records the records object
+				 * @returns {void}
+				 */
+				(chunks, records) => {
+					if (!records.chunks) records.chunks = {};
+					if (!records.chunks.byName) records.chunks.byName = {};
+					if (!records.chunks.bySource) records.chunks.bySource = {};
+					/** @type {Set<number>} */
+					const usedIds = new Set();
+					for (const chunk of chunks) {
+						if (typeof chunk.id !== "number") continue;
+						const name = chunk.name;
+						if (name) records.chunks.byName[name] = chunk.id;
+						const sources = getChunkSources(chunk);
+						for (const source of sources) {
+							records.chunks.bySource[source] = chunk.id;
+						}
+						usedIds.add(chunk.id);
+					}
+					records.chunks.usedIds = Array.from(usedIds).sort();
+				}
+			);
+			compilation.hooks.reviveChunks.tap(
+				"RecordIdsPlugin",
+				/**
+				 * @param {Chunk[]} chunks the chunks array
+				 * @param {Records} records the records object
+				 * @returns {void}
+				 */
+				(chunks, records) => {
+					if (!records.chunks) return;
+					/** @type {Set<number>} */
+					const usedIds = new Set();
+					if (records.chunks.byName) {
+						for (const chunk of chunks) {
+							if (chunk.id !== null) continue;
+							if (!chunk.name) continue;
+							const id = records.chunks.byName[chunk.name];
+							if (id === undefined) continue;
+							if (usedIds.has(id)) continue;
+							usedIds.add(id);
+							chunk.id = id;
+						}
+					}
+					if (records.chunks.bySource) {
+						for (const chunk of chunks) {
+							const sources = getChunkSources(chunk);
+							for (const source of sources) {
+								const id = records.chunks.bySource[source];
+								if (id === undefined) continue;
+								if (usedIds.has(id)) continue;
+								usedIds.add(id);
+								chunk.id = id;
+								break;
+							}
+						}
+					}
+					if (Array.isArray(records.chunks.usedIds)) {
+						compilation.usedChunkIds = new Set(records.chunks.usedIds);
+					}
+				}
+			);
+		});
+	}
+}
+module.exports = RecordIdsPlugin;

package/lib/RemovedPluginError.js

@@ -0,0 +1,11 @@
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+module.exports = class RemovedPluginError extends WebpackError {
+	constructor(message) {
+		super(message);
+
+		Error.captureStackTrace(this, this.constructor);
+	}
+};

package/lib/RequestShortener.js

@@ -0,0 +1,83 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const path = require("path");
+const NORMALIZE_SLASH_DIRECTION_REGEXP = /\\/g;
+const PATH_CHARS_REGEXP = /[-[\]{}()*+?.,\\^$|#\s]/g;
+const SEPARATOR_REGEXP = /[/\\]$/;
+const FRONT_OR_BACK_BANG_REGEXP = /^!|!$/g;
+const INDEX_JS_REGEXP = /\/index.js(!|\?|\(query\))/g;
+const MATCH_RESOURCE_REGEXP = /!=!/;
+
+const normalizeBackSlashDirection = request => {
+	return request.replace(NORMALIZE_SLASH_DIRECTION_REGEXP, "/");
+};
+
+const createRegExpForPath = path => {
+	const regexpTypePartial = path.replace(PATH_CHARS_REGEXP, "\\$&");
+	return new RegExp(`(^|!)${regexpTypePartial}`, "g");
+};
+
+class RequestShortener {
+	constructor(directory) {
+		directory = normalizeBackSlashDirection(directory);
+		if (SEPARATOR_REGEXP.test(directory)) {
+			directory = directory.substr(0, directory.length - 1);
+		}
+
+		if (directory) {
+			this.currentDirectoryRegExp = createRegExpForPath(directory);
+		}
+
+		const dirname = path.dirname(directory);
+		const endsWithSeparator = SEPARATOR_REGEXP.test(dirname);
+		const parentDirectory = endsWithSeparator
+			? dirname.substr(0, dirname.length - 1)
+			: dirname;
+		if (parentDirectory && parentDirectory !== directory) {
+			this.parentDirectoryRegExp = createRegExpForPath(`${parentDirectory}/`);
+		}
+
+		if (__dirname.length >= 2) {
+			const buildins = normalizeBackSlashDirection(path.join(__dirname, ".."));
+			const buildinsAsModule =
+				this.currentDirectoryRegExp &&
+				this.currentDirectoryRegExp.test(buildins);
+			this.buildinsAsModule = buildinsAsModule;
+			this.buildinsRegExp = createRegExpForPath(buildins);
+		}
+
+		this.cache = new Map();
+	}
+
+	shorten(request) {
+		if (!request) return request;
+		const cacheEntry = this.cache.get(request);
+		if (cacheEntry !== undefined) {
+			return cacheEntry;
+		}
+		let result = normalizeBackSlashDirection(request);
+		if (this.buildinsAsModule && this.buildinsRegExp) {
+			result = result.replace(this.buildinsRegExp, "!(webpack)");
+		}
+		if (this.currentDirectoryRegExp) {
+			result = result.replace(this.currentDirectoryRegExp, "!.");
+		}
+		if (this.parentDirectoryRegExp) {
+			result = result.replace(this.parentDirectoryRegExp, "!../");
+		}
+		if (!this.buildinsAsModule && this.buildinsRegExp) {
+			result = result.replace(this.buildinsRegExp, "!(webpack)");
+		}
+		result = result.replace(INDEX_JS_REGEXP, "$1");
+		result = result.replace(FRONT_OR_BACK_BANG_REGEXP, "");
+		result = result.replace(MATCH_RESOURCE_REGEXP, " = ");
+		this.cache.set(request, result);
+		return result;
+	}
+}
+
+module.exports = RequestShortener;

package/lib/RequireJsStuffPlugin.js

@@ -0,0 +1,66 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const ParserHelpers = require("./ParserHelpers");
+const ConstDependency = require("./dependencies/ConstDependency");
+const NullFactory = require("./NullFactory");
+
+module.exports = class RequireJsStuffPlugin {
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"RequireJsStuffPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(ConstDependency, new NullFactory());
+				compilation.dependencyTemplates.set(
+					ConstDependency,
+					new ConstDependency.Template()
+				);
+				const handler = (parser, parserOptions) => {
+					if (parserOptions.requireJs !== undefined && !parserOptions.requireJs)
+						return;
+
+					parser.hooks.call
+						.for("require.config")
+						.tap(
+							"RequireJsStuffPlugin",
+							ParserHelpers.toConstantDependency(parser, "undefined")
+						);
+					parser.hooks.call
+						.for("requirejs.config")
+						.tap(
+							"RequireJsStuffPlugin",
+							ParserHelpers.toConstantDependency(parser, "undefined")
+						);
+
+					parser.hooks.expression
+						.for("require.version")
+						.tap(
+							"RequireJsStuffPlugin",
+							ParserHelpers.toConstantDependency(
+								parser,
+								JSON.stringify("0.0.0")
+							)
+						);
+					parser.hooks.expression
+						.for("requirejs.onError")
+						.tap(
+							"RequireJsStuffPlugin",
+							ParserHelpers.toConstantDependencyWithWebpackRequire(
+								parser,
+								"__webpack_require__.oe"
+							)
+						);
+				};
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("RequireJsStuffPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("RequireJsStuffPlugin", handler);
+			}
+		);
+	}
+};

package/lib/ResolverFactory.js

@@ -0,0 +1,74 @@
+/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+ */
+"use strict";
+
+const { Tapable, HookMap, SyncHook, SyncWaterfallHook } = require("tapable");
+const Factory = require("enhanced-resolve").ResolverFactory;
+const { cachedCleverMerge } = require("./util/cleverMerge");
+
+/** @typedef {import("enhanced-resolve").Resolver} Resolver */
+
+const EMTPY_RESOLVE_OPTIONS = {};
+
+module.exports = class ResolverFactory extends Tapable {
+	constructor() {
+		super();
+		this.hooks = {
+			resolveOptions: new HookMap(
+				() => new SyncWaterfallHook(["resolveOptions"])
+			),
+			resolver: new HookMap(() => new SyncHook(["resolver", "resolveOptions"]))
+		};
+		this._pluginCompat.tap("ResolverFactory", options => {
+			let match;
+			match = /^resolve-options (.+)$/.exec(options.name);
+			if (match) {
+				this.hooks.resolveOptions
+					.for(match[1])
+					.tap(options.fn.name || "unnamed compat plugin", options.fn);
+				return true;
+			}
+			match = /^resolver (.+)$/.exec(options.name);
+			if (match) {
+				this.hooks.resolver
+					.for(match[1])
+					.tap(options.fn.name || "unnamed compat plugin", options.fn);
+				return true;
+			}
+		});
+		this.cache2 = new Map();
+	}
+
+	get(type, resolveOptions) {
+		resolveOptions = resolveOptions || EMTPY_RESOLVE_OPTIONS;
+		const ident = `${type}|${JSON.stringify(resolveOptions)}`;
+		const resolver = this.cache2.get(ident);
+		if (resolver) return resolver;
+		const newResolver = this._create(type, resolveOptions);
+		this.cache2.set(ident, newResolver);
+		return newResolver;
+	}
+
+	_create(type, resolveOptions) {
+		const originalResolveOptions = Object.assign({}, resolveOptions);
+		resolveOptions = this.hooks.resolveOptions.for(type).call(resolveOptions);
+		const resolver = Factory.createResolver(resolveOptions);
+		if (!resolver) {
+			throw new Error("No resolver created");
+		}
+		/** @type {Map<Object, Resolver>} */
+		const childCache = new Map();
+		resolver.withOptions = options => {
+			const cacheEntry = childCache.get(options);
+			if (cacheEntry !== undefined) return cacheEntry;
+			const mergedOptions = cachedCleverMerge(originalResolveOptions, options);
+			const resolver = this.get(type, mergedOptions);
+			childCache.set(options, resolver);
+			return resolver;
+		};
+		this.hooks.resolver.for(type).call(resolver, resolveOptions);
+		return resolver;
+	}
+};