webpack 5.40.0 → 5.42.1

package/lib/dependencies/WorkerPlugin.js

@@ -48,9 +48,10 @@ const DEFAULT_SYNTAX = [
 const workerIndexMap = new WeakMap();
 
 class WorkerPlugin {
-	constructor(chunkLoading, wasmLoading) {
+	constructor(chunkLoading, wasmLoading, module) {
 		this._chunkLoading = chunkLoading;
 		this._wasmLoading = wasmLoading;
+		this._module = module;
 	}
 	/**
 	 * Apply the plugin
@@ -311,31 +312,45 @@ class WorkerPlugin {
 						if (expressions.type) {
 							const expr = expressions.type;
 							if (options.type !== false) {
-								const dep = new ConstDependency("undefined", expr.range);
+								const dep = new ConstDependency(
+									this._module ? '"module"' : "undefined",
+									expr.range
+								);
 								dep.loc = expr.loc;
 								parser.state.module.addPresentationalDependency(dep);
 								expressions.type = undefined;
 							}
-						} else if (hasSpreadInOptions && insertType === "comma") {
-							const dep = new ConstDependency(
-								", type: undefined",
-								insertLocation
-							);
-							dep.loc = expr.loc;
-							parser.state.module.addPresentationalDependency(dep);
+						} else if (insertType === "comma") {
+							if (this._module || hasSpreadInOptions) {
+								const dep = new ConstDependency(
+									`, type: ${this._module ? '"module"' : "undefined"}`,
+									insertLocation
+								);
+								dep.loc = expr.loc;
+								parser.state.module.addPresentationalDependency(dep);
+							}
 						} else if (insertType === "spread") {
 							const dep1 = new ConstDependency(
 								"Object.assign({}, ",
 								insertLocation[0]
 							);
 							const dep2 = new ConstDependency(
-								", { type: undefined })",
+								`, { type: ${this._module ? '"module"' : "undefined"} })`,
 								insertLocation[1]
 							);
 							dep1.loc = expr.loc;
 							dep2.loc = expr.loc;
 							parser.state.module.addPresentationalDependency(dep1);
 							parser.state.module.addPresentationalDependency(dep2);
+						} else if (insertType === "argument") {
+							if (this._module) {
+								const dep = new ConstDependency(
+									', { type: "module" }',
+									insertLocation
+								);
+								dep.loc = expr.loc;
+								parser.state.module.addPresentationalDependency(dep);
+							}
 						}
 
 						parser.walkExpression(expr.callee);

package/lib/electron/ElectronTargetPlugin.js

@@ -22,7 +22,7 @@ class ElectronTargetPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		new ExternalsPlugin("commonjs", [
+		new ExternalsPlugin("node-commonjs", [
 			"clipboard",
 			"crash-reporter",
 			"electron",
@@ -34,7 +34,7 @@ class ElectronTargetPlugin {
 		]).apply(compiler);
 		switch (this._context) {
 			case "main":
-				new ExternalsPlugin("commonjs", [
+				new ExternalsPlugin("node-commonjs", [
 					"app",
 					"auto-updater",
 					"browser-window",
@@ -54,7 +54,7 @@ class ElectronTargetPlugin {
 				break;
 			case "preload":
 			case "renderer":
-				new ExternalsPlugin("commonjs", [
+				new ExternalsPlugin("node-commonjs", [
 					"desktop-capturer",
 					"ipc-renderer",
 					"remote",

package/lib/esm/ModuleChunkFormatPlugin.js

@@ -0,0 +1,97 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { ConcatSource } = require("webpack-sources");
+const { RuntimeGlobals } = require("..");
+const HotUpdateChunk = require("../HotUpdateChunk");
+const Template = require("../Template");
+const {
+	getCompilationHooks
+} = require("../javascript/JavascriptModulesPlugin");
+
+/** @typedef {import("../Compiler")} Compiler */
+
+class ModuleChunkFormatPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap(
+			"ModuleChunkFormatPlugin",
+			compilation => {
+				compilation.hooks.additionalChunkRuntimeRequirements.tap(
+					"ModuleChunkFormatPlugin",
+					(chunk, set) => {
+						if (chunk.hasRuntime()) return;
+						if (compilation.chunkGraph.getNumberOfEntryModules(chunk) > 0) {
+							set.add(RuntimeGlobals.onChunksLoaded);
+							set.add(RuntimeGlobals.require);
+						}
+					}
+				);
+				const hooks = getCompilationHooks(compilation);
+				hooks.renderChunk.tap(
+					"ModuleChunkFormatPlugin",
+					(modules, renderContext) => {
+						const { chunk, chunkGraph } = renderContext;
+						const hotUpdateChunk =
+							chunk instanceof HotUpdateChunk ? chunk : null;
+						const source = new ConcatSource();
+						if (hotUpdateChunk) {
+							throw new Error(
+								"HMR is not implemented for module chunk format yet"
+							);
+						} else {
+							source.add(`export const id = ${JSON.stringify(chunk.id)};\n`);
+							source.add(`export const ids = ${JSON.stringify(chunk.ids)};\n`);
+							source.add(`export const modules = `);
+							source.add(modules);
+							source.add(`;\n`);
+							const runtimeModules =
+								chunkGraph.getChunkRuntimeModulesInOrder(chunk);
+							if (runtimeModules.length > 0) {
+								source.add("export const runtime =\n");
+								source.add(
+									Template.renderChunkRuntimeModules(
+										runtimeModules,
+										renderContext
+									)
+								);
+							}
+							const entries = Array.from(
+								chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
+							);
+							if (entries.length > 0) {
+								throw new Error(
+									"Entry modules in chunk is not implemented for module chunk format yet"
+								);
+							}
+						}
+						return source;
+					}
+				);
+				hooks.chunkHash.tap(
+					"ModuleChunkFormatPlugin",
+					(chunk, hash, { chunkGraph, runtimeTemplate }) => {
+						if (chunk.hasRuntime()) return;
+						hash.update("ModuleChunkFormatPlugin");
+						hash.update("1");
+						// TODO
+						// const entries = Array.from(
+						// 	chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
+						// );
+						// updateHashForEntryStartup(hash, chunkGraph, entries, chunk);
+					}
+				);
+			}
+		);
+	}
+}
+
+module.exports = ModuleChunkFormatPlugin;

package/lib/esm/ModuleChunkLoadingPlugin.js

@@ -0,0 +1,63 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const ModuleChunkLoadingRuntimeModule = require("./ModuleChunkLoadingRuntimeModule");
+
+/** @typedef {import("../Compiler")} Compiler */
+
+class ModuleChunkLoadingPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap(
+			"ModuleChunkLoadingPlugin",
+			compilation => {
+				const globalChunkLoading = compilation.outputOptions.chunkLoading;
+				const isEnabledForChunk = chunk => {
+					const options = chunk.getEntryOptions();
+					const chunkLoading =
+						(options && options.chunkLoading) || globalChunkLoading;
+					return chunkLoading === "import";
+				};
+				const onceForChunkSet = new WeakSet();
+				const handler = (chunk, set) => {
+					if (onceForChunkSet.has(chunk)) return;
+					onceForChunkSet.add(chunk);
+					if (!isEnabledForChunk(chunk)) return;
+					set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+					set.add(RuntimeGlobals.hasOwnProperty);
+					compilation.addRuntimeModule(
+						chunk,
+						new ModuleChunkLoadingRuntimeModule(set)
+					);
+				};
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.ensureChunkHandlers)
+					.tap("ModuleChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.baseURI)
+					.tap("ModuleChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.onChunksLoaded)
+					.tap("ModuleChunkLoadingPlugin", handler);
+
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.ensureChunkHandlers)
+					.tap("ModuleChunkLoadingPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						set.add(RuntimeGlobals.getChunkScriptFilename);
+					});
+			}
+		);
+	}
+}
+
+module.exports = ModuleChunkLoadingPlugin;

package/lib/esm/ModuleChunkLoadingRuntimeModule.js

@@ -0,0 +1,208 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const { SyncWaterfallHook } = require("tapable");
+const Compilation = require("../Compilation");
+const RuntimeGlobals = require("../RuntimeGlobals");
+const RuntimeModule = require("../RuntimeModule");
+const Template = require("../Template");
+const {
+	getChunkFilenameTemplate,
+	chunkHasJs
+} = require("../javascript/JavascriptModulesPlugin");
+const { getInitialChunkIds } = require("../javascript/StartupHelpers");
+const compileBooleanMatcher = require("../util/compileBooleanMatcher");
+const { getUndoPath } = require("../util/identifier");
+
+/** @typedef {import("../Chunk")} Chunk */
+
+/**
+ * @typedef {Object} JsonpCompilationPluginHooks
+ * @property {SyncWaterfallHook<[string, Chunk]>} linkPreload
+ * @property {SyncWaterfallHook<[string, Chunk]>} linkPrefetch
+ */
+
+/** @type {WeakMap<Compilation, JsonpCompilationPluginHooks>} */
+const compilationHooksMap = new WeakMap();
+
+class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {Compilation} compilation the compilation
+	 * @returns {JsonpCompilationPluginHooks} hooks
+	 */
+	static getCompilationHooks(compilation) {
+		if (!(compilation instanceof Compilation)) {
+			throw new TypeError(
+				"The 'compilation' argument must be an instance of Compilation"
+			);
+		}
+		let hooks = compilationHooksMap.get(compilation);
+		if (hooks === undefined) {
+			hooks = {
+				linkPreload: new SyncWaterfallHook(["source", "chunk"]),
+				linkPrefetch: new SyncWaterfallHook(["source", "chunk"])
+			};
+			compilationHooksMap.set(compilation, hooks);
+		}
+		return hooks;
+	}
+
+	constructor(runtimeRequirements) {
+		super("import chunk loading", RuntimeModule.STAGE_ATTACH);
+		this._runtimeRequirements = runtimeRequirements;
+	}
+
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { compilation, chunk } = this;
+		const {
+			runtimeTemplate,
+			chunkGraph,
+			outputOptions: { importFunctionName, importMetaName }
+		} = compilation;
+		const fn = RuntimeGlobals.ensureChunkHandlers;
+		const withBaseURI = this._runtimeRequirements.has(RuntimeGlobals.baseURI);
+		const withLoading = this._runtimeRequirements.has(
+			RuntimeGlobals.ensureChunkHandlers
+		);
+		const withOnChunkLoad = this._runtimeRequirements.has(
+			RuntimeGlobals.onChunksLoaded
+		);
+		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
+		const hasJsMatcher = compileBooleanMatcher(conditionMap);
+		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph);
+
+		const outputName = this.compilation.getPath(
+			getChunkFilenameTemplate(chunk, this.compilation.outputOptions),
+			{
+				chunk,
+				contentHashType: "javascript"
+			}
+		);
+		const rootOutputDir = getUndoPath(
+			outputName,
+			this.compilation.outputOptions.path,
+			true
+		);
+
+		return Template.asString([
+			withBaseURI
+				? Template.asString([
+						`${RuntimeGlobals.baseURI} = new URL(${JSON.stringify(
+							rootOutputDir
+						)}, ${importMetaName}.url);`
+				  ])
+				: "// no baseURI",
+			"",
+			"// object to store loaded and loading chunks",
+			"// undefined = chunk not loaded, null = chunk preloaded/prefetched",
+			"// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded",
+			"var installedChunks = {",
+			Template.indent(
+				Array.from(initialChunkIds, id => `${JSON.stringify(id)}: 0`).join(
+					",\n"
+				)
+			),
+			"};",
+			"",
+			withLoading
+				? Template.asString([
+						`${fn}.j = ${runtimeTemplate.basicFunction(
+							"chunkId, promises",
+							hasJsMatcher !== false
+								? Template.indent([
+										"// import() chunk loading for javascript",
+										`var installedChunkData = ${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;`,
+										'if(installedChunkData !== 0) { // 0 means "already installed".',
+										Template.indent([
+											"",
+											'// a Promise means "currently loading".',
+											"if(installedChunkData) {",
+											Template.indent([
+												"promises.push(installedChunkData[1]);"
+											]),
+											"} else {",
+											Template.indent([
+												hasJsMatcher === true
+													? "if(true) { // all chunks have JS"
+													: `if(${hasJsMatcher("chunkId")}) {`,
+												Template.indent([
+													"// setup Promise in chunk cache",
+													`var promise = ${importFunctionName}(${JSON.stringify(
+														rootOutputDir
+													)} + ${
+														RuntimeGlobals.getChunkScriptFilename
+													}(chunkId)).then(${runtimeTemplate.basicFunction(
+														"data",
+														[
+															runtimeTemplate.destructureObject(
+																["ids", "modules", "runtime"],
+																"data"
+															),
+															'// add "modules" to the modules object,',
+															'// then flag all "ids" as loaded and fire callback',
+															"var moduleId, chunkId, i = 0;",
+															"for(moduleId in modules) {",
+															Template.indent([
+																`if(${RuntimeGlobals.hasOwnProperty}(modules, moduleId)) {`,
+																Template.indent(
+																	`${RuntimeGlobals.moduleFactories}[moduleId] = modules[moduleId];`
+																),
+																"}"
+															]),
+															"}",
+															"if(runtime) runtime(__webpack_require__);",
+															"for(;i < ids.length; i++) {",
+															Template.indent([
+																"chunkId = ids[i];",
+																`if(${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) && installedChunks[chunkId]) {`,
+																Template.indent(
+																	"installedChunks[chunkId][0]();"
+																),
+																"}",
+																"installedChunks[ids[i]] = 0;"
+															]),
+															"}",
+															withOnChunkLoad
+																? `${RuntimeGlobals.onChunksLoaded}();`
+																: ""
+														]
+													)}, ${runtimeTemplate.basicFunction("e", [
+														"if(installedChunks[chunkId] !== 0) installedChunks[chunkId] = undefined;",
+														"throw e;"
+													])});`,
+													`var promise = Promise.race([promise, new Promise(${runtimeTemplate.expressionFunction(
+														`installedChunkData = installedChunks[chunkId] = [resolve]`,
+														"resolve"
+													)})])`,
+													`promises.push(installedChunkData[1] = promise);`
+												]),
+												"} else installedChunks[chunkId] = 0;"
+											]),
+											"}"
+										]),
+										"}"
+								  ])
+								: Template.indent(["installedChunks[chunkId] = 0;"])
+						)};`
+				  ])
+				: "// no chunk on demand loading",
+			"",
+			withOnChunkLoad
+				? `${
+						RuntimeGlobals.onChunksLoaded
+				  }.j = ${runtimeTemplate.returningFunction(
+						"installedChunks[chunkId] === 0",
+						"chunkId"
+				  )};`
+				: "// no on chunks loaded"
+		]);
+	}
+}
+
+module.exports = ModuleChunkLoadingRuntimeModule;

package/lib/hmr/lazyCompilationBackend.js

@@ -52,6 +52,16 @@ module.exports = (compiler, client, callback) => {
 		}
 		if (moduleActivated && compiler.watching) compiler.watching.invalidate();
 	});
+	let isClosing = false;
+	/** @type {Set<import("net").Socket>} */
+	const sockets = new Set();
+	server.on("connection", socket => {
+		sockets.add(socket);
+		socket.on("close", () => {
+			sockets.delete(socket);
+		});
+		if (isClosing) socket.destroy();
+	});
 	server.listen(err => {
 		if (err) return callback(err);
 		const addr = server.address();
@@ -67,7 +77,13 @@ module.exports = (compiler, client, callback) => {
 		);
 		callback(null, {
 			dispose(callback) {
-				server.close(callback);
+				isClosing = true;
+				server.close(err => {
+					callback(err);
+				});
+				for (const socket of sockets) {
+					socket.destroy(new Error("Server is disposing"));
+				}
 			},
 			module(originalModule) {
 				const key = `${encodeURIComponent(

package/lib/javascript/EnableChunkLoadingPlugin.js

@@ -96,9 +96,11 @@ class EnableChunkLoadingPlugin {
 					}).apply(compiler);
 					break;
 				}
-				case "import":
-					// TODO implement import chunk loading
-					throw new Error("Chunk Loading via import() is not implemented yet");
+				case "import": {
+					const ModuleChunkLoadingPlugin = require("../esm/ModuleChunkLoadingPlugin");
+					new ModuleChunkLoadingPlugin().apply(compiler);
+					break;
+				}
 				case "universal":
 					// TODO implement universal chunk loading
 					throw new Error("Universal Chunk Loading is not implemented yet");