update packages

1 files changed, 407 insertions, 251 deletions

diff --git a/node_modules/webpack/lib/HotModuleReplacementPlugin.js b/node_modules/webpack/lib/HotModuleReplacementPlugin.js
index f3cc63b94..365a2443a 100644
--- a/node_modules/webpack/lib/HotModuleReplacementPlugin.js
+++ b/node_modules/webpack/lib/HotModuleReplacementPlugin.js
@@ -1,251 +1,407 @@
-/*

-	MIT License http://www.opensource.org/licenses/mit-license.php

-	Author Tobias Koppers @sokra

-*/

-"use strict";

-const Template = require("./Template");

-const ModuleHotAcceptDependency = require("./dependencies/ModuleHotAcceptDependency");

-const ModuleHotDeclineDependency = require("./dependencies/ModuleHotDeclineDependency");

-const RawSource = require("webpack-sources").RawSource;

-const ConstDependency = require("./dependencies/ConstDependency");

-const NullFactory = require("./NullFactory");

-const ParserHelpers = require("./ParserHelpers");

-

-module.exports = class HotModuleReplacementPlugin {

-	constructor(options) {

-		this.options = options || {};

-		this.multiStep = this.options.multiStep;

-		this.fullBuildTimeout = this.options.fullBuildTimeout || 200;

-		this.requestTimeout = this.options.requestTimeout || 10000;

-	}

-

-	apply(compiler) {

-		const multiStep = this.multiStep;

-		const fullBuildTimeout = this.fullBuildTimeout;

-		const requestTimeout = this.requestTimeout;

-		const hotUpdateChunkFilename = compiler.options.output.hotUpdateChunkFilename;

-		const hotUpdateMainFilename = compiler.options.output.hotUpdateMainFilename;

-		compiler.plugin("additional-pass", callback => {

-			if(multiStep)

-				return setTimeout(callback, fullBuildTimeout);

-			return callback();

-		});

-		compiler.plugin("compilation", (compilation, params) => {

-			const hotUpdateChunkTemplate = compilation.hotUpdateChunkTemplate;

-			if(!hotUpdateChunkTemplate) return;

-

-			const normalModuleFactory = params.normalModuleFactory;

-

-			compilation.dependencyFactories.set(ConstDependency, new NullFactory());

-			compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template());

-

-			compilation.dependencyFactories.set(ModuleHotAcceptDependency, normalModuleFactory);

-			compilation.dependencyTemplates.set(ModuleHotAcceptDependency, new ModuleHotAcceptDependency.Template());

-

-			compilation.dependencyFactories.set(ModuleHotDeclineDependency, normalModuleFactory);

-			compilation.dependencyTemplates.set(ModuleHotDeclineDependency, new ModuleHotDeclineDependency.Template());

-

-			compilation.plugin("record", function(compilation, records) {

-				if(records.hash === this.hash) return;

-				records.hash = compilation.hash;

-				records.moduleHashs = {};

-				this.modules.forEach(module => {

-					const identifier = module.identifier();

-					const hash = require("crypto").createHash("md5");

-					module.updateHash(hash);

-					records.moduleHashs[identifier] = hash.digest("hex");

-				});

-				records.chunkHashs = {};

-				this.chunks.forEach(chunk => {

-					records.chunkHashs[chunk.id] = chunk.hash;

-				});

-				records.chunkModuleIds = {};

-				this.chunks.forEach(chunk => {

-					records.chunkModuleIds[chunk.id] = chunk.mapModules(m => m.id);

-				});

-			});

-			let initialPass = false;

-			let recompilation = false;

-			compilation.plugin("after-hash", function() {

-				let records = this.records;

-				if(!records) {

-					initialPass = true;

-					return;

-				}

-				if(!records.hash)

-					initialPass = true;

-				const preHash = records.preHash || "x";

-				const prepreHash = records.prepreHash || "x";

-				if(preHash === this.hash) {

-					recompilation = true;

-					this.modifyHash(prepreHash);

-					return;

-				}

-				records.prepreHash = records.hash || "x";

-				records.preHash = this.hash;

-				this.modifyHash(records.prepreHash);

-			});

-			compilation.plugin("should-generate-chunk-assets", () => {

-				if(multiStep && !recompilation && !initialPass)

-					return false;

-			});

-			compilation.plugin("need-additional-pass", () => {

-				if(multiStep && !recompilation && !initialPass)

-					return true;

-			});

-			compilation.plugin("additional-chunk-assets", function() {

-				const records = this.records;

-				if(records.hash === this.hash) return;

-				if(!records.moduleHashs || !records.chunkHashs || !records.chunkModuleIds) return;

-				this.modules.forEach(module => {

-					const identifier = module.identifier();

-					let hash = require("crypto").createHash("md5");

-					module.updateHash(hash);

-					hash = hash.digest("hex");

-					module.hotUpdate = records.moduleHashs[identifier] !== hash;

-				});

-				const hotUpdateMainContent = {

-					h: this.hash,

-					c: {},

-				};

-				Object.keys(records.chunkHashs).forEach(function(chunkId) {

-					chunkId = isNaN(+chunkId) ? chunkId : +chunkId;

-					const currentChunk = this.chunks.find(chunk => chunk.id === chunkId);

-					if(currentChunk) {

-						const newModules = currentChunk.getModules().filter(module => module.hotUpdate);

-						const allModules = {};

-						currentChunk.forEachModule(module => {

-							allModules[module.id] = true;

-						});

-						const removedModules = records.chunkModuleIds[chunkId].filter(id => !allModules[id]);

-						if(newModules.length > 0 || removedModules.length > 0) {

-							const source = hotUpdateChunkTemplate.render(chunkId, newModules, removedModules, this.hash, this.moduleTemplate, this.dependencyTemplates);

-							const filename = this.getPath(hotUpdateChunkFilename, {

-								hash: records.hash,

-								chunk: currentChunk

-							});

-							this.additionalChunkAssets.push(filename);

-							this.assets[filename] = source;

-							hotUpdateMainContent.c[chunkId] = true;

-							currentChunk.files.push(filename);

-							this.applyPlugins("chunk-asset", currentChunk, filename);

-						}

-					} else {

-						hotUpdateMainContent.c[chunkId] = false;

-					}

-				}, this);

-				const source = new RawSource(JSON.stringify(hotUpdateMainContent));

-				const filename = this.getPath(hotUpdateMainFilename, {

-					hash: records.hash

-				});

-				this.assets[filename] = source;

-			});

-

-			compilation.mainTemplate.plugin("hash", hash => {

-				hash.update("HotMainTemplateDecorator");

-			});

-

-			compilation.mainTemplate.plugin("module-require", (_, chunk, hash, varModuleId) => {

-				return `hotCreateRequire(${varModuleId})`;

-			});

-

-			compilation.mainTemplate.plugin("require-extensions", function(source) {

-				const buf = [source];

-				buf.push("");

-				buf.push("// __webpack_hash__");

-				buf.push(this.requireFn + ".h = function() { return hotCurrentHash; };");

-				return this.asString(buf);

-			});

-

-			compilation.mainTemplate.plugin("bootstrap", function(source, chunk, hash) {

-				source = this.applyPluginsWaterfall("hot-bootstrap", source, chunk, hash);

-				return this.asString([

-					source,

-					"",

-					hotInitCode

-					.replace(/\$require\$/g, this.requireFn)

-					.replace(/\$hash\$/g, JSON.stringify(hash))

-					.replace(/\$requestTimeout\$/g, requestTimeout)

-					.replace(/\/\*foreachInstalledChunks\*\//g, chunk.chunks.length > 0 ? "for(var chunkId in installedChunks)" : `var chunkId = ${JSON.stringify(chunk.id)};`)

-				]);

-			});

-

-			compilation.mainTemplate.plugin("global-hash", () => true);

-

-			compilation.mainTemplate.plugin("current-hash", (_, length) => {

-				if(isFinite(length))

-					return `hotCurrentHash.substr(0, ${length})`;

-				else

-					return "hotCurrentHash";

-			});

-

-			compilation.mainTemplate.plugin("module-obj", function(source, chunk, hash, varModuleId) {

-				return this.asString([

-					`${source},`,

-					`hot: hotCreateModule(${varModuleId}),`,

-					"parents: (hotCurrentParentsTemp = hotCurrentParents, hotCurrentParents = [], hotCurrentParentsTemp),",

-					"children: []"

-				]);

-			});

-

-			params.normalModuleFactory.plugin("parser", (parser, parserOptions) => {

-				parser.plugin("expression __webpack_hash__", ParserHelpers.toConstantDependency("__webpack_require__.h()"));

-				parser.plugin("evaluate typeof __webpack_hash__", ParserHelpers.evaluateToString("string"));

-				parser.plugin("evaluate Identifier module.hot", function(expr) {

-					return ParserHelpers.evaluateToIdentifier("module.hot", !!this.state.compilation.hotUpdateChunkTemplate)(expr);

-				});

-				parser.plugin("call module.hot.accept", function(expr) {

-					if(!this.state.compilation.hotUpdateChunkTemplate) return false;

-					if(expr.arguments.length >= 1) {

-						const arg = this.evaluateExpression(expr.arguments[0]);

-						let params = [];

-						let requests = [];

-						if(arg.isString()) {

-							params = [arg];

-						} else if(arg.isArray()) {

-							params = arg.items.filter(param => param.isString());

-						}

-						if(params.length > 0) {

-							params.forEach((param, idx) => {

-								const request = param.string;

-								const dep = new ModuleHotAcceptDependency(request, param.range);

-								dep.optional = true;

-								dep.loc = Object.create(expr.loc);

-								dep.loc.index = idx;

-								this.state.module.addDependency(dep);

-								requests.push(request);

-							});

-							if(expr.arguments.length > 1)

-								this.applyPluginsBailResult("hot accept callback", expr.arguments[1], requests);

-							else

-								this.applyPluginsBailResult("hot accept without callback", expr, requests);

-						}

-					}

-				});

-				parser.plugin("call module.hot.decline", function(expr) {

-					if(!this.state.compilation.hotUpdateChunkTemplate) return false;

-					if(expr.arguments.length === 1) {

-						const arg = this.evaluateExpression(expr.arguments[0]);

-						let params = [];

-						if(arg.isString()) {

-							params = [arg];

-						} else if(arg.isArray()) {

-							params = arg.items.filter(param => param.isString());

-						}

-						params.forEach((param, idx) => {

-							const dep = new ModuleHotDeclineDependency(param.string, param.range);

-							dep.optional = true;

-							dep.loc = Object.create(expr.loc);

-							dep.loc.index = idx;

-							this.state.module.addDependency(dep);

-						});

-					}

-				});

-				parser.plugin("expression module.hot", ParserHelpers.skipTraversal);

-			});

-		});

-	}

-

-};

-

-const hotInitCode = Template.getFunctionContent(require("./HotModuleReplacement.runtime.js"));

+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const { SyncBailHook } = require("tapable");
+const { RawSource } = require("webpack-sources");
+const Template = require("./Template");
+const ModuleHotAcceptDependency = require("./dependencies/ModuleHotAcceptDependency");
+const ModuleHotDeclineDependency = require("./dependencies/ModuleHotDeclineDependency");
+const ConstDependency = require("./dependencies/ConstDependency");
+const NullFactory = require("./NullFactory");
+const ParserHelpers = require("./ParserHelpers");
+
+module.exports = class HotModuleReplacementPlugin {
+	constructor(options) {
+		this.options = options || {};
+		this.multiStep = this.options.multiStep;
+		this.fullBuildTimeout = this.options.fullBuildTimeout || 200;
+		this.requestTimeout = this.options.requestTimeout || 10000;
+	}
+
+	apply(compiler) {
+		const multiStep = this.multiStep;
+		const fullBuildTimeout = this.fullBuildTimeout;
+		const requestTimeout = this.requestTimeout;
+		const hotUpdateChunkFilename =
+			compiler.options.output.hotUpdateChunkFilename;
+		const hotUpdateMainFilename = compiler.options.output.hotUpdateMainFilename;
+		compiler.hooks.additionalPass.tapAsync(
+			"HotModuleReplacementPlugin",
+			callback => {
+				if (multiStep) return setTimeout(callback, fullBuildTimeout);
+				return callback();
+			}
+		);
+
+		const addParserPlugins = (parser, parserOptions) => {
+			parser.hooks.expression
+				.for("__webpack_hash__")
+				.tap(
+					"HotModuleReplacementPlugin",
+					ParserHelpers.toConstantDependencyWithWebpackRequire(
+						parser,
+						"__webpack_require__.h()"
+					)
+				);
+			parser.hooks.evaluateTypeof
+				.for("__webpack_hash__")
+				.tap(
+					"HotModuleReplacementPlugin",
+					ParserHelpers.evaluateToString("string")
+				);
+			parser.hooks.evaluateIdentifier.for("module.hot").tap(
+				{
+					name: "HotModuleReplacementPlugin",
+					before: "NodeStuffPlugin"
+				},
+				expr => {
+					return ParserHelpers.evaluateToIdentifier(
+						"module.hot",
+						!!parser.state.compilation.hotUpdateChunkTemplate
+					)(expr);
+				}
+			);
+			// TODO webpack 5: refactor this, no custom hooks
+			if (!parser.hooks.hotAcceptCallback) {
+				parser.hooks.hotAcceptCallback = new SyncBailHook([
+					"expression",
+					"requests"
+				]);
+			}
+			if (!parser.hooks.hotAcceptWithoutCallback) {
+				parser.hooks.hotAcceptWithoutCallback = new SyncBailHook([
+					"expression",
+					"requests"
+				]);
+			}
+			parser.hooks.call
+				.for("module.hot.accept")
+				.tap("HotModuleReplacementPlugin", expr => {
+					if (!parser.state.compilation.hotUpdateChunkTemplate) {
+						return false;
+					}
+					if (expr.arguments.length >= 1) {
+						const arg = parser.evaluateExpression(expr.arguments[0]);
+						let params = [];
+						let requests = [];
+						if (arg.isString()) {
+							params = [arg];
+						} else if (arg.isArray()) {
+							params = arg.items.filter(param => param.isString());
+						}
+						if (params.length > 0) {
+							params.forEach((param, idx) => {
+								const request = param.string;
+								const dep = new ModuleHotAcceptDependency(request, param.range);
+								dep.optional = true;
+								dep.loc = Object.create(expr.loc);
+								dep.loc.index = idx;
+								parser.state.module.addDependency(dep);
+								requests.push(request);
+							});
+							if (expr.arguments.length > 1) {
+								parser.hooks.hotAcceptCallback.call(
+									expr.arguments[1],
+									requests
+								);
+								parser.walkExpression(expr.arguments[1]); // other args are ignored
+								return true;
+							} else {
+								parser.hooks.hotAcceptWithoutCallback.call(expr, requests);
+								return true;
+							}
+						}
+					}
+				});
+			parser.hooks.call
+				.for("module.hot.decline")
+				.tap("HotModuleReplacementPlugin", expr => {
+					if (!parser.state.compilation.hotUpdateChunkTemplate) {
+						return false;
+					}
+					if (expr.arguments.length === 1) {
+						const arg = parser.evaluateExpression(expr.arguments[0]);
+						let params = [];
+						if (arg.isString()) {
+							params = [arg];
+						} else if (arg.isArray()) {
+							params = arg.items.filter(param => param.isString());
+						}
+						params.forEach((param, idx) => {
+							const dep = new ModuleHotDeclineDependency(
+								param.string,
+								param.range
+							);
+							dep.optional = true;
+							dep.loc = Object.create(expr.loc);
+							dep.loc.index = idx;
+							parser.state.module.addDependency(dep);
+						});
+					}
+				});
+			parser.hooks.expression
+				.for("module.hot")
+				.tap("HotModuleReplacementPlugin", ParserHelpers.skipTraversal);
+		};
+
+		compiler.hooks.compilation.tap(
+			"HotModuleReplacementPlugin",
+			(compilation, { normalModuleFactory }) => {
+				const hotUpdateChunkTemplate = compilation.hotUpdateChunkTemplate;
+				if (!hotUpdateChunkTemplate) return;
+
+				compilation.dependencyFactories.set(ConstDependency, new NullFactory());
+				compilation.dependencyTemplates.set(
+					ConstDependency,
+					new ConstDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					ModuleHotAcceptDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ModuleHotAcceptDependency,
+					new ModuleHotAcceptDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					ModuleHotDeclineDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ModuleHotDeclineDependency,
+					new ModuleHotDeclineDependency.Template()
+				);
+
+				compilation.hooks.record.tap(
+					"HotModuleReplacementPlugin",
+					(compilation, records) => {
+						if (records.hash === compilation.hash) return;
+						records.hash = compilation.hash;
+						records.moduleHashs = {};
+						for (const module of compilation.modules) {
+							const identifier = module.identifier();
+							records.moduleHashs[identifier] = module.hash;
+						}
+						records.chunkHashs = {};
+						for (const chunk of compilation.chunks) {
+							records.chunkHashs[chunk.id] = chunk.hash;
+						}
+						records.chunkModuleIds = {};
+						for (const chunk of compilation.chunks) {
+							records.chunkModuleIds[chunk.id] = Array.from(
+								chunk.modulesIterable,
+								m => m.id
+							);
+						}
+					}
+				);
+				let initialPass = false;
+				let recompilation = false;
+				compilation.hooks.afterHash.tap("HotModuleReplacementPlugin", () => {
+					let records = compilation.records;
+					if (!records) {
+						initialPass = true;
+						return;
+					}
+					if (!records.hash) initialPass = true;
+					const preHash = records.preHash || "x";
+					const prepreHash = records.prepreHash || "x";
+					if (preHash === compilation.hash) {
+						recompilation = true;
+						compilation.modifyHash(prepreHash);
+						return;
+					}
+					records.prepreHash = records.hash || "x";
+					records.preHash = compilation.hash;
+					compilation.modifyHash(records.prepreHash);
+				});
+				compilation.hooks.shouldGenerateChunkAssets.tap(
+					"HotModuleReplacementPlugin",
+					() => {
+						if (multiStep && !recompilation && !initialPass) return false;
+					}
+				);
+				compilation.hooks.needAdditionalPass.tap(
+					"HotModuleReplacementPlugin",
+					() => {
+						if (multiStep && !recompilation && !initialPass) return true;
+					}
+				);
+				compilation.hooks.additionalChunkAssets.tap(
+					"HotModuleReplacementPlugin",
+					() => {
+						const records = compilation.records;
+						if (records.hash === compilation.hash) return;
+						if (
+							!records.moduleHashs ||
+							!records.chunkHashs ||
+							!records.chunkModuleIds
+						)
+							return;
+						for (const module of compilation.modules) {
+							const identifier = module.identifier();
+							let hash = module.hash;
+							module.hotUpdate = records.moduleHashs[identifier] !== hash;
+						}
+						const hotUpdateMainContent = {
+							h: compilation.hash,
+							c: {}
+						};
+						for (const key of Object.keys(records.chunkHashs)) {
+							const chunkId = isNaN(+key) ? key : +key;
+							const currentChunk = compilation.chunks.find(
+								chunk => chunk.id === chunkId
+							);
+							if (currentChunk) {
+								const newModules = currentChunk
+									.getModules()
+									.filter(module => module.hotUpdate);
+								const allModules = new Set();
+								for (const module of currentChunk.modulesIterable) {
+									allModules.add(module.id);
+								}
+								const removedModules = records.chunkModuleIds[chunkId].filter(
+									id => !allModules.has(id)
+								);
+								if (newModules.length > 0 || removedModules.length > 0) {
+									const source = hotUpdateChunkTemplate.render(
+										chunkId,
+										newModules,
+										removedModules,
+										compilation.hash,
+										compilation.moduleTemplates.javascript,
+										compilation.dependencyTemplates
+									);
+									const filename = compilation.getPath(hotUpdateChunkFilename, {
+										hash: records.hash,
+										chunk: currentChunk
+									});
+									compilation.additionalChunkAssets.push(filename);
+									compilation.assets[filename] = source;
+									hotUpdateMainContent.c[chunkId] = true;
+									currentChunk.files.push(filename);
+									compilation.hooks.chunkAsset.call(currentChunk, filename);
+								}
+							} else {
+								hotUpdateMainContent.c[chunkId] = false;
+							}
+						}
+						const source = new RawSource(JSON.stringify(hotUpdateMainContent));
+						const filename = compilation.getPath(hotUpdateMainFilename, {
+							hash: records.hash
+						});
+						compilation.assets[filename] = source;
+					}
+				);
+
+				const mainTemplate = compilation.mainTemplate;
+
+				mainTemplate.hooks.hash.tap("HotModuleReplacementPlugin", hash => {
+					hash.update("HotMainTemplateDecorator");
+				});
+
+				mainTemplate.hooks.moduleRequire.tap(
+					"HotModuleReplacementPlugin",
+					(_, chunk, hash, varModuleId) => {
+						return `hotCreateRequire(${varModuleId})`;
+					}
+				);
+
+				mainTemplate.hooks.requireExtensions.tap(
+					"HotModuleReplacementPlugin",
+					source => {
+						const buf = [source];
+						buf.push("");
+						buf.push("// __webpack_hash__");
+						buf.push(
+							mainTemplate.requireFn +
+								".h = function() { return hotCurrentHash; };"
+						);
+						return Template.asString(buf);
+					}
+				);
+
+				const needChunkLoadingCode = chunk => {
+					for (const chunkGroup of chunk.groupsIterable) {
+						if (chunkGroup.chunks.length > 1) return true;
+						if (chunkGroup.getNumberOfChildren() > 0) return true;
+					}
+					return false;
+				};
+
+				mainTemplate.hooks.bootstrap.tap(
+					"HotModuleReplacementPlugin",
+					(source, chunk, hash) => {
+						source = mainTemplate.hooks.hotBootstrap.call(source, chunk, hash);
+						return Template.asString([
+							source,
+							"",
+							hotInitCode
+								.replace(/\$require\$/g, mainTemplate.requireFn)
+								.replace(/\$hash\$/g, JSON.stringify(hash))
+								.replace(/\$requestTimeout\$/g, requestTimeout)
+								.replace(
+									/\/\*foreachInstalledChunks\*\//g,
+									needChunkLoadingCode(chunk)
+										? "for(var chunkId in installedChunks)"
+										: `var chunkId = ${JSON.stringify(chunk.id)};`
+								)
+						]);
+					}
+				);
+
+				mainTemplate.hooks.globalHash.tap(
+					"HotModuleReplacementPlugin",
+					() => true
+				);
+
+				mainTemplate.hooks.currentHash.tap(
+					"HotModuleReplacementPlugin",
+					(_, length) => {
+						if (isFinite(length)) {
+							return `hotCurrentHash.substr(0, ${length})`;
+						} else {
+							return "hotCurrentHash";
+						}
+					}
+				);
+
+				mainTemplate.hooks.moduleObj.tap(
+					"HotModuleReplacementPlugin",
+					(source, chunk, hash, varModuleId) => {
+						return Template.asString([
+							`${source},`,
+							`hot: hotCreateModule(${varModuleId}),`,
+							"parents: (hotCurrentParentsTemp = hotCurrentParents, hotCurrentParents = [], hotCurrentParentsTemp),",
+							"children: []"
+						]);
+					}
+				);
+
+				// TODO add HMR support for javascript/esm
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("HotModuleReplacementPlugin", addParserPlugins);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("HotModuleReplacementPlugin", addParserPlugins);
+
+				compilation.hooks.normalModuleLoader.tap(
+					"HotModuleReplacementPlugin",
+					context => {
+						context.hot = true;
+					}
+				);
+			}
+		);
+	}
+};
+
+const hotInitCode = Template.getFunctionContent(
+	require("./HotModuleReplacement.runtime")
+);