@eriche/webpack 4.47.0

package/lib/FlagDependencyExportsPlugin.js

@@ -0,0 +1,174 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const Queue = require("./util/Queue");
+
+const addToSet = (a, b) => {
+	for (const item of b) {
+		a.add(item);
+	}
+};
+
+class FlagDependencyExportsPlugin {
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"FlagDependencyExportsPlugin",
+			compilation => {
+				compilation.hooks.finishModules.tap(
+					"FlagDependencyExportsPlugin",
+					modules => {
+						const dependencies = new Map();
+
+						const queue = new Queue();
+
+						let module;
+						let moduleWithExports;
+						let moduleProvidedExports;
+						let providedExportsAreTemporary;
+
+						const processDependenciesBlock = depBlock => {
+							for (const dep of depBlock.dependencies) {
+								if (processDependency(dep)) return true;
+							}
+							for (const variable of depBlock.variables) {
+								for (const dep of variable.dependencies) {
+									if (processDependency(dep)) return true;
+								}
+							}
+							for (const block of depBlock.blocks) {
+								if (processDependenciesBlock(block)) return true;
+							}
+							return false;
+						};
+
+						const processDependency = dep => {
+							const exportDesc = dep.getExports && dep.getExports();
+							if (!exportDesc) return;
+							moduleWithExports = true;
+							const exports = exportDesc.exports;
+							// break early if it's only in the worst state
+							if (module.buildMeta.providedExports === true) {
+								return true;
+							}
+							// break if it should move to the worst state
+							if (exports === true) {
+								module.buildMeta.providedExports = true;
+								return true;
+							}
+							// merge in new exports
+							if (Array.isArray(exports)) {
+								addToSet(moduleProvidedExports, exports);
+							}
+							// store dependencies
+							const exportDeps = exportDesc.dependencies;
+							if (exportDeps) {
+								providedExportsAreTemporary = true;
+								for (const exportDependency of exportDeps) {
+									// add dependency for this module
+									const set = dependencies.get(exportDependency);
+									if (set === undefined) {
+										dependencies.set(exportDependency, new Set([module]));
+									} else {
+										set.add(module);
+									}
+								}
+							}
+							return false;
+						};
+
+						const notifyDependencies = () => {
+							const deps = dependencies.get(module);
+							if (deps !== undefined) {
+								for (const dep of deps) {
+									queue.enqueue(dep);
+								}
+							}
+						};
+
+						const notifyDependenciesIfDifferent = (set, array) => {
+							const deps = dependencies.get(module);
+							if (deps !== undefined) {
+								if (set.size === array.length) {
+									let i = 0;
+									let different = false;
+									for (const item of set) {
+										if (item !== array[i++]) {
+											different = true;
+											break;
+										}
+									}
+									if (!different) return;
+								}
+								for (const dep of deps) {
+									queue.enqueue(dep);
+								}
+							}
+						};
+
+						// Start with all modules without provided exports
+						for (const module of modules) {
+							if (module.buildInfo.temporaryProvidedExports) {
+								// Clear exports when they are temporary
+								// and recreate them
+								module.buildMeta.providedExports = null;
+								queue.enqueue(module);
+							} else if (!module.buildMeta.providedExports) {
+								queue.enqueue(module);
+							}
+						}
+
+						while (queue.length > 0) {
+							module = queue.dequeue();
+
+							if (module.buildMeta.providedExports !== true) {
+								moduleWithExports =
+									module.buildMeta && module.buildMeta.exportsType;
+								moduleProvidedExports = new Set();
+								providedExportsAreTemporary = false;
+								processDependenciesBlock(module);
+								module.buildInfo.temporaryProvidedExports = providedExportsAreTemporary;
+								if (!moduleWithExports) {
+									notifyDependencies();
+									module.buildMeta.providedExports = true;
+								} else if (module.buildMeta.providedExports === true) {
+									notifyDependencies();
+								} else if (!module.buildMeta.providedExports) {
+									notifyDependencies();
+									module.buildMeta.providedExports = Array.from(
+										moduleProvidedExports
+									);
+								} else {
+									notifyDependenciesIfDifferent(
+										moduleProvidedExports,
+										module.buildMeta.providedExports
+									);
+									module.buildMeta.providedExports = Array.from(
+										moduleProvidedExports
+									);
+								}
+							}
+						}
+					}
+				);
+				const providedExportsCache = new WeakMap();
+				compilation.hooks.rebuildModule.tap(
+					"FlagDependencyExportsPlugin",
+					module => {
+						providedExportsCache.set(module, module.buildMeta.providedExports);
+					}
+				);
+				compilation.hooks.finishRebuildingModule.tap(
+					"FlagDependencyExportsPlugin",
+					module => {
+						module.buildMeta.providedExports = providedExportsCache.get(module);
+					}
+				);
+			}
+		);
+	}
+}
+
+module.exports = FlagDependencyExportsPlugin;

package/lib/FlagDependencyUsagePlugin.js

@@ -0,0 +1,116 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
+
+/** @typedef {false | true | string[]} UsedExports */
+
+const addToSet = (a, b) => {
+	for (const item of b) {
+		if (!a.includes(item)) a.push(item);
+	}
+	return a;
+};
+
+const isSubset = (biggerSet, subset) => {
+	if (biggerSet === true) return true;
+	if (subset === true) return false;
+	return subset.every(item => biggerSet.indexOf(item) >= 0);
+};
+
+class FlagDependencyUsagePlugin {
+	apply(compiler) {
+		compiler.hooks.compilation.tap("FlagDependencyUsagePlugin", compilation => {
+			compilation.hooks.optimizeDependencies.tap(
+				"FlagDependencyUsagePlugin",
+				modules => {
+					const processModule = (module, usedExports) => {
+						module.used = true;
+						if (module.usedExports === true) return;
+						if (usedExports === true) {
+							module.usedExports = true;
+						} else if (Array.isArray(usedExports)) {
+							const old = module.usedExports ? module.usedExports.length : -1;
+							module.usedExports = addToSet(
+								module.usedExports || [],
+								usedExports
+							);
+							if (module.usedExports.length === old) {
+								return;
+							}
+						} else if (Array.isArray(module.usedExports)) {
+							return;
+						} else {
+							module.usedExports = false;
+						}
+
+						// for a module without side effects we stop tracking usage here when no export is used
+						// This module won't be evaluated in this case
+						if (module.factoryMeta.sideEffectFree) {
+							if (module.usedExports === false) return;
+							if (
+								Array.isArray(module.usedExports) &&
+								module.usedExports.length === 0
+							)
+								return;
+						}
+
+						queue.push([module, module, module.usedExports]);
+					};
+
+					const processDependenciesBlock = (module, depBlock, usedExports) => {
+						for (const dep of depBlock.dependencies) {
+							processDependency(module, dep);
+						}
+						for (const variable of depBlock.variables) {
+							for (const dep of variable.dependencies) {
+								processDependency(module, dep);
+							}
+						}
+						for (const block of depBlock.blocks) {
+							queue.push([module, block, usedExports]);
+						}
+					};
+
+					const processDependency = (module, dep) => {
+						const reference = compilation.getDependencyReference(module, dep);
+						if (!reference) return;
+						const referenceModule = reference.module;
+						const importedNames = reference.importedNames;
+						const oldUsed = referenceModule.used;
+						const oldUsedExports = referenceModule.usedExports;
+						if (
+							!oldUsed ||
+							(importedNames &&
+								(!oldUsedExports || !isSubset(oldUsedExports, importedNames)))
+						) {
+							processModule(referenceModule, importedNames);
+						}
+					};
+
+					for (const module of modules) {
+						if (!module.used) module.used = false;
+					}
+
+					/** @type {[Module, DependenciesBlock, UsedExports][]} */
+					const queue = [];
+					for (const preparedEntrypoint of compilation._preparedEntrypoints) {
+						if (preparedEntrypoint.module) {
+							processModule(preparedEntrypoint.module, true);
+						}
+					}
+
+					while (queue.length) {
+						const queueItem = queue.pop();
+						processDependenciesBlock(queueItem[0], queueItem[1], queueItem[2]);
+					}
+				}
+			);
+		});
+	}
+}
+module.exports = FlagDependencyUsagePlugin;

package/lib/FlagInitialModulesAsUsedPlugin.js

@@ -0,0 +1,36 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+class FlagInitialModulesAsUsedPlugin {
+	constructor(explanation) {
+		this.explanation = explanation;
+	}
+
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"FlagInitialModulesAsUsedPlugin",
+			compilation => {
+				compilation.hooks.afterOptimizeChunks.tap(
+					"FlagInitialModulesAsUsedPlugin",
+					chunks => {
+						for (const chunk of chunks) {
+							if (!chunk.isOnlyInitial()) {
+								return;
+							}
+							for (const module of chunk.modulesIterable) {
+								module.used = true;
+								module.usedExports = true;
+								module.addReason(null, null, this.explanation);
+							}
+						}
+					}
+				);
+			}
+		);
+	}
+}
+
+module.exports = FlagInitialModulesAsUsedPlugin;

package/lib/FunctionModulePlugin.js

@@ -0,0 +1,19 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const FunctionModuleTemplatePlugin = require("./FunctionModuleTemplatePlugin");
+
+class FunctionModulePlugin {
+	apply(compiler) {
+		compiler.hooks.compilation.tap("FunctionModulePlugin", compilation => {
+			new FunctionModuleTemplatePlugin().apply(
+				compilation.moduleTemplates.javascript
+			);
+		});
+	}
+}
+
+module.exports = FunctionModulePlugin;

package/lib/FunctionModuleTemplatePlugin.js

@@ -0,0 +1,102 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const { ConcatSource } = require("webpack-sources");
+const Template = require("./Template");
+
+class FunctionModuleTemplatePlugin {
+	apply(moduleTemplate) {
+		moduleTemplate.hooks.render.tap(
+			"FunctionModuleTemplatePlugin",
+			(moduleSource, module) => {
+				const source = new ConcatSource();
+				const args = [module.moduleArgument];
+				// TODO remove HACK checking type for javascript
+				if (module.type && module.type.startsWith("javascript")) {
+					args.push(module.exportsArgument);
+					if (module.hasDependencies(d => d.requireWebpackRequire !== false)) {
+						args.push("__webpack_require__");
+					}
+				} else if (module.type && module.type.startsWith("json")) {
+					// no additional arguments needed
+				} else {
+					args.push(module.exportsArgument, "__webpack_require__");
+				}
+				source.add("/***/ (function(" + args.join(", ") + ") {\n\n");
+				if (module.buildInfo.strict) source.add('"use strict";\n');
+				source.add(moduleSource);
+				source.add("\n\n/***/ })");
+				return source;
+			}
+		);
+
+		moduleTemplate.hooks.package.tap(
+			"FunctionModuleTemplatePlugin",
+			(moduleSource, module) => {
+				if (moduleTemplate.runtimeTemplate.outputOptions.pathinfo) {
+					const source = new ConcatSource();
+					const req = module.readableIdentifier(
+						moduleTemplate.runtimeTemplate.requestShortener
+					);
+					const reqStr = req.replace(/\*\//g, "*_/");
+					const reqStrStar = "*".repeat(reqStr.length);
+					source.add("/*!****" + reqStrStar + "****!*\\\n");
+					source.add("  !*** " + reqStr + " ***!\n");
+					source.add("  \\****" + reqStrStar + "****/\n");
+					if (
+						Array.isArray(module.buildMeta.providedExports) &&
+						module.buildMeta.providedExports.length === 0
+					) {
+						source.add(Template.toComment("no exports provided") + "\n");
+					} else if (Array.isArray(module.buildMeta.providedExports)) {
+						source.add(
+							Template.toComment(
+								"exports provided: " +
+									module.buildMeta.providedExports.join(", ")
+							) + "\n"
+						);
+					} else if (module.buildMeta.providedExports) {
+						source.add(Template.toComment("no static exports found") + "\n");
+					}
+					if (
+						Array.isArray(module.usedExports) &&
+						module.usedExports.length === 0
+					) {
+						source.add(Template.toComment("no exports used") + "\n");
+					} else if (Array.isArray(module.usedExports)) {
+						source.add(
+							Template.toComment(
+								"exports used: " + module.usedExports.join(", ")
+							) + "\n"
+						);
+					} else if (module.usedExports) {
+						source.add(Template.toComment("all exports used") + "\n");
+					}
+					if (module.optimizationBailout) {
+						for (const text of module.optimizationBailout) {
+							let code;
+							if (typeof text === "function") {
+								code = text(moduleTemplate.runtimeTemplate.requestShortener);
+							} else {
+								code = text;
+							}
+							source.add(Template.toComment(`${code}`) + "\n");
+						}
+					}
+					source.add(moduleSource);
+					return source;
+				}
+				return moduleSource;
+			}
+		);
+
+		moduleTemplate.hooks.hash.tap("FunctionModuleTemplatePlugin", hash => {
+			hash.update("FunctionModuleTemplatePlugin");
+			hash.update("2");
+		});
+	}
+}
+module.exports = FunctionModuleTemplatePlugin;

package/lib/Generator.js

@@ -0,0 +1,60 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+/** @typedef {import("./NormalModule")} NormalModule */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("./Dependency").DependencyTemplate} DependencyTemplate */
+
+/**
+ *
+ */
+class Generator {
+	static byType(map) {
+		return new ByTypeGenerator(map);
+	}
+
+	/**
+	 * @abstract
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {Map<Function, DependencyTemplate>} dependencyTemplates mapping from dependencies to templates
+	 * @param {RuntimeTemplate} runtimeTemplate the runtime template
+	 * @param {string} type which kind of code should be generated
+	 * @returns {Source} generated code
+	 */
+	generate(module, dependencyTemplates, runtimeTemplate, type) {
+		throw new Error("Generator.generate: must be overridden");
+	}
+}
+
+class ByTypeGenerator extends Generator {
+	constructor(map) {
+		super();
+		this.map = map;
+	}
+
+	/**
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {Map<Function, DependencyTemplate>} dependencyTemplates mapping from dependencies to templates
+	 * @param {RuntimeTemplate} runtimeTemplate the runtime template
+	 * @param {string} type which kind of code should be generated
+	 * @returns {Source} generated code
+	 */
+	generate(module, dependencyTemplates, runtimeTemplate, type) {
+		const generator = this.map[type];
+		if (!generator) {
+			throw new Error(`Generator.byType: no generator specified for ${type}`);
+		}
+		return generator.generate(
+			module,
+			dependencyTemplates,
+			runtimeTemplate,
+			type
+		);
+	}
+}
+
+module.exports = Generator;

package/lib/GraphHelpers.js

@@ -0,0 +1,65 @@
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./ChunkGroup")} ChunkGroup */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
+/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
+
+/**
+ * @param {ChunkGroup} chunkGroup the ChunkGroup to connect
+ * @param {Chunk} chunk chunk to tie to ChunkGroup
+ * @returns {void}
+ */
+const connectChunkGroupAndChunk = (chunkGroup, chunk) => {
+	if (chunkGroup.pushChunk(chunk)) {
+		chunk.addGroup(chunkGroup);
+	}
+};
+
+/**
+ * @param {ChunkGroup} parent parent ChunkGroup to connect
+ * @param {ChunkGroup} child child ChunkGroup to connect
+ * @returns {void}
+ */
+const connectChunkGroupParentAndChild = (parent, child) => {
+	if (parent.addChild(child)) {
+		child.addParent(parent);
+	}
+};
+
+/**
+ * @param {Chunk} chunk Chunk to connect to Module
+ * @param {Module} module Module to connect to Chunk
+ * @returns {void}
+ */
+const connectChunkAndModule = (chunk, module) => {
+	if (module.addChunk(chunk)) {
+		chunk.addModule(module);
+	}
+};
+
+/**
+ * @param {Chunk} chunk Chunk being disconnected
+ * @param {Module} module Module being disconnected
+ * @returns {void}
+ */
+const disconnectChunkAndModule = (chunk, module) => {
+	chunk.removeModule(module);
+	module.removeChunk(chunk);
+};
+
+/**
+ * @param {AsyncDependenciesBlock} depBlock DepBlock being tied to ChunkGroup
+ * @param {ChunkGroup} chunkGroup ChunkGroup being tied to DepBlock
+ * @returns {void}
+ */
+const connectDependenciesBlockAndChunkGroup = (depBlock, chunkGroup) => {
+	if (chunkGroup.addBlock(depBlock)) {
+		depBlock.chunkGroup = chunkGroup;
+	}
+};
+
+exports.connectChunkGroupAndChunk = connectChunkGroupAndChunk;
+exports.connectChunkGroupParentAndChild = connectChunkGroupParentAndChild;
+exports.connectChunkAndModule = connectChunkAndModule;
+exports.disconnectChunkAndModule = disconnectChunkAndModule;
+exports.connectDependenciesBlockAndChunkGroup = connectDependenciesBlockAndChunkGroup;

package/lib/HarmonyLinkingError.js

@@ -0,0 +1,17 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+module.exports = class HarmonyLinkingError extends WebpackError {
+	/** @param {string} message Error message */
+	constructor(message) {
+		super(message);
+		this.name = "HarmonyLinkingError";
+		this.hideStack = true;
+
+		Error.captureStackTrace(this, this.constructor);
+	}
+};

package/lib/HashedModuleIdsPlugin.js

@@ -0,0 +1,63 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const createHash = require("./util/createHash");
+
+const validateOptions = require("schema-utils");
+const schema = require("../schemas/plugins/HashedModuleIdsPlugin.json");
+
+/** @typedef {import("../declarations/plugins/HashedModuleIdsPlugin").HashedModuleIdsPluginOptions} HashedModuleIdsPluginOptions */
+
+class HashedModuleIdsPlugin {
+	/**
+	 * @param {HashedModuleIdsPluginOptions=} options options object
+	 */
+	constructor(options) {
+		if (!options) options = {};
+
+		validateOptions(schema, options, "Hashed Module Ids Plugin");
+
+		/** @type {HashedModuleIdsPluginOptions} */
+		this.options = Object.assign(
+			{
+				context: null,
+				hashFunction: "md4",
+				hashDigest: "base64",
+				hashDigestLength: 4
+			},
+			options
+		);
+	}
+
+	apply(compiler) {
+		const options = this.options;
+		compiler.hooks.compilation.tap("HashedModuleIdsPlugin", compilation => {
+			const usedIds = new Set();
+			compilation.hooks.beforeModuleIds.tap(
+				"HashedModuleIdsPlugin",
+				modules => {
+					for (const module of modules) {
+						if (module.id === null && module.libIdent) {
+							const id = module.libIdent({
+								context: this.options.context || compiler.options.context
+							});
+							const hash = createHash(options.hashFunction);
+							hash.update(id);
+							const hashId = /** @type {string} */ (hash.digest(
+								options.hashDigest
+							));
+							let len = options.hashDigestLength;
+							while (usedIds.has(hashId.substr(0, len))) len++;
+							module.id = hashId.substr(0, len);
+							usedIds.add(module.id);
+						}
+					}
+				}
+			);
+		});
+	}
+}
+
+module.exports = HashedModuleIdsPlugin;