webpack 4.10.1 → 4.12.0

package/lib/wasm/WebAssemblyParser.js

@@ -6,36 +6,27 @@
 
 const t = require("@webassemblyjs/ast");
 const { decode } = require("@webassemblyjs/wasm-parser");
+const {
+	moduleContextFromModuleAST
+} = require("@webassemblyjs/helper-module-context");
 
 const { Tapable } = require("tapable");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
+const WebAssemblyExportImportedDependency = require("../dependencies/WebAssemblyExportImportedDependency");
 
 /** @typedef {import("../Module")} Module */
 
-/**
- * @param {t.ModuleImport} n the import
- * @returns {boolean} true, if a memory was imported
- */
-const isMemoryImport = n => n.descr.type === "Memory";
-
-/**
- * @param {t.ModuleImport} n the import
- * @returns {boolean} true, if a table was imported
- */
-const isTableImport = n => n.descr.type === "Table";
-
 const JS_COMPAT_TYPES = new Set(["i32", "f32", "f64"]);
 
 /**
- * @param {t.ModuleImport} moduleImport the import
+ * @param {t.Signature} signature the func signature
  * @returns {null | string} the type incompatible with js types
  */
-const getJsIncompatibleType = moduleImport => {
-	if (moduleImport.descr.type !== "FuncImportDescr") return null;
-	const signature = moduleImport.descr.signature;
+const getJsIncompatibleType = signature => {
 	for (const param of signature.params) {
-		if (!JS_COMPAT_TYPES.has(param.valtype))
+		if (!JS_COMPAT_TYPES.has(param.valtype)) {
 			return `${param.valtype} as parameter`;
+		}
 	}
 	for (const type of signature.results) {
 		if (!JS_COMPAT_TYPES.has(type)) return `${type} as result`;
@@ -43,9 +34,29 @@ const getJsIncompatibleType = moduleImport => {
 	return null;
 };
 
+/**
+ * TODO why are there two different Signature types?
+ * @param {t.FuncSignature} signature the func signature
+ * @returns {null | string} the type incompatible with js types
+ */
+const getJsIncompatibleTypeOfFuncSignature = signature => {
+	for (const param of signature.args) {
+		if (!JS_COMPAT_TYPES.has(param)) {
+			return `${param} as parameter`;
+		}
+	}
+	for (const type of signature.result) {
+		if (!JS_COMPAT_TYPES.has(type)) return `${type} as result`;
+	}
+	return null;
+};
+
 const decoderOpts = {
 	ignoreCodeSection: true,
-	ignoreDataSection: true
+	ignoreDataSection: true,
+
+	// this will avoid having to lookup with identifiers in the ModuleContext
+	ignoreCustomNameSection: true
 };
 
 class WebAssemblyParser extends Tapable {
@@ -60,28 +71,85 @@ class WebAssemblyParser extends Tapable {
 		state.module.buildMeta.exportsType = "namespace";
 
 		// parse it
-		const ast = decode(binary, decoderOpts);
+		const program = decode(binary, decoderOpts);
+		const module = program.body[0];
+
+		const moduleContext = moduleContextFromModuleAST(module);
 
 		// extract imports and exports
 		const exports = (state.module.buildMeta.providedExports = []);
-		t.traverse(ast, {
+		const jsIncompatibleExports = (state.module.buildMeta.jsIncompatibleExports = []);
+
+		const importedGlobals = [];
+		t.traverse(module, {
 			ModuleExport({ node }) {
+				const descriptor = node.descr;
+
+				if (descriptor.exportType === "Func") {
+					const funcidx = descriptor.id.value;
+
+					/** @type {t.FuncSignature} */
+					const funcSignature = moduleContext.getFunction(funcidx);
+
+					const incompatibleType = getJsIncompatibleTypeOfFuncSignature(
+						funcSignature
+					);
+
+					if (incompatibleType) {
+						jsIncompatibleExports[node.name] = incompatibleType;
+					}
+				}
+
 				exports.push(node.name);
+
+				if (node.descr && node.descr.exportType === "Global") {
+					const refNode = importedGlobals[node.descr.id.value];
+					if (refNode) {
+						const dep = new WebAssemblyExportImportedDependency(
+							node.name,
+							refNode.module,
+							refNode.name
+						);
+
+						state.module.addDependency(dep);
+					}
+				}
+			},
+
+			Global({ node }) {
+				const init = node.init[0];
+
+				let importNode = null;
+
+				if (init.id === "get_global") {
+					const globalIdx = init.args[0].value;
+
+					if (globalIdx < importedGlobals.length) {
+						importNode = importedGlobals[globalIdx];
+					}
+				}
+
+				importedGlobals.push(importNode);
 			},
 
 			ModuleImport({ node }) {
 				/** @type {false | string} */
 				let onlyDirectImport = false;
 
-				if (isMemoryImport(node) === true) {
+				if (t.isMemory(node.descr) === true) {
 					onlyDirectImport = "Memory";
-				} else if (isTableImport(node) === true) {
+				} else if (t.isTable(node.descr) === true) {
 					onlyDirectImport = "Table";
-				} else {
-					const incompatibleType = getJsIncompatibleType(node);
+				} else if (t.isFuncImportDescr(node.descr) === true) {
+					const incompatibleType = getJsIncompatibleType(node.descr.signature);
 					if (incompatibleType) {
 						onlyDirectImport = `Non-JS-compatible Func Sigurature (${incompatibleType})`;
 					}
+				} else if (t.isGlobalType(node.descr) === true) {
+					const type = node.descr.valtype;
+					if (!JS_COMPAT_TYPES.has(type)) {
+						onlyDirectImport = `Non-JS-compatible Global Type (${type})`;
+					}
 				}
 
 				const dep = new WebAssemblyImportDependency(
@@ -92,6 +160,10 @@ class WebAssemblyParser extends Tapable {
 				);
 
 				state.module.addDependency(dep);
+
+				if (t.isGlobalType(node.descr)) {
+					importedGlobals.push(node);
+				}
 			}
 		});
 

package/lib/wasm/WebAssemblyUtils.js

@@ -12,15 +12,17 @@ const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDe
 /** @typedef {Object} UsedWasmDependency
  * @property {WebAssemblyImportDependency} dependency the dependency
  * @property {string} name the export name
+ * @property {string} module the module name
  */
 
 const MANGLED_MODULE = "a";
 
 /**
  * @param {Module} module the module
- * @returns {UsedWasmDependency[]} used dependencies and mangled name
+ * @param {boolean} mangle mangle module and export names
+ * @returns {UsedWasmDependency[]} used dependencies and (mangled) name
  */
-const getUsedDependencies = module => {
+const getUsedDependencies = (module, mangle) => {
 	/** @type {UsedWasmDependency[]} */
 	const array = [];
 	let importIndex = 0;
@@ -30,13 +32,22 @@ const getUsedDependencies = module => {
 				continue;
 			}
 
-			const importedModule = dep.module;
 			const exportName = dep.name;
-			const usedName = importedModule && importedModule.isUsed(exportName);
-			if (usedName !== false) {
+			// TODO add the following 3 lines when removing of ModuleExport is possible
+			// const importedModule = dep.module;
+			// const usedName = importedModule && importedModule.isUsed(exportName);
+			// if (usedName !== false) {
+			if (mangle) {
 				array.push({
 					dependency: dep,
-					name: Template.numberToIdentifer(importIndex++)
+					name: Template.numberToIdentifer(importIndex++),
+					module: MANGLED_MODULE
+				});
+			} else {
+				array.push({
+					dependency: dep,
+					name: exportName,
+					module: dep.request
 				});
 			}
 		}

package/lib/web/FetchCompileWasmTemplatePlugin.js

@@ -7,6 +7,10 @@
 const WasmMainTemplatePlugin = require("../wasm/WasmMainTemplatePlugin");
 
 class FetchCompileWasmTemplatePlugin {
+	constructor(options) {
+		this.options = options || {};
+	}
+
 	apply(compiler) {
 		compiler.hooks.thisCompilation.tap(
 			"FetchCompileWasmTemplatePlugin",
@@ -15,7 +19,15 @@ class FetchCompileWasmTemplatePlugin {
 				const generateLoadBinaryCode = path =>
 					`fetch(${mainTemplate.requireFn}.p + ${path})`;
 
-				const plugin = new WasmMainTemplatePlugin(generateLoadBinaryCode, true);
+				const plugin = new WasmMainTemplatePlugin(
+					Object.assign(
+						{
+							generateLoadBinaryCode,
+							supportsStreaming: true
+						},
+						this.options
+					)
+				);
 				plugin.apply(mainTemplate);
 			}
 		);

package/lib/web/JsonpChunkTemplatePlugin.js

@@ -14,6 +14,7 @@ class JsonpChunkTemplatePlugin {
 				const jsonpFunction = chunkTemplate.outputOptions.jsonpFunction;
 				const globalObject = chunkTemplate.outputOptions.globalObject;
 				const source = new ConcatSource();
+				const prefetchChunks = chunk.getChildIdsByOrders().prefetch;
 				source.add(
 					`(${globalObject}[${JSON.stringify(
 						jsonpFunction
@@ -31,6 +32,12 @@ class JsonpChunkTemplatePlugin {
 				);
 				if (entries.length > 0) {
 					source.add(`,${JSON.stringify(entries)}`);
+				} else if (prefetchChunks && prefetchChunks.length) {
+					source.add(`,0`);
+				}
+
+				if (prefetchChunks && prefetchChunks.length) {
+					source.add(`,${JSON.stringify(prefetchChunks)}`);
 				}
 				source.add("])");
 				return source;

package/lib/web/JsonpMainTemplate.runtime.js

@@ -24,8 +24,9 @@ module.exports = function() {
 	function hotDownloadManifest(requestTimeout) {
 		requestTimeout = requestTimeout || 10000;
 		return new Promise(function(resolve, reject) {
-			if (typeof XMLHttpRequest === "undefined")
+			if (typeof XMLHttpRequest === "undefined") {
 				return reject(new Error("No browser support"));
+			}
 			try {
 				var request = new XMLHttpRequest();
 				var requestPath = $require$.p + $hotMainFilename$;

package/lib/web/JsonpMainTemplatePlugin.js

@@ -28,28 +28,21 @@ class JsonpMainTemplatePlugin {
 			}
 			return false;
 		};
-		// TODO refactor this
-		if (!mainTemplate.hooks.jsonpScript) {
-			mainTemplate.hooks.jsonpScript = new SyncWaterfallHook([
-				"source",
-				"chunk",
-				"hash"
-			]);
-		}
-		if (!mainTemplate.hooks.linkPreload) {
-			mainTemplate.hooks.linkPreload = new SyncWaterfallHook([
-				"source",
-				"chunk",
-				"hash"
-			]);
-		}
-		if (!mainTemplate.hooks.linkPrefetch) {
-			mainTemplate.hooks.linkPrefetch = new SyncWaterfallHook([
-				"source",
-				"chunk",
-				"hash"
-			]);
-		}
+		const needPrefetchingCode = chunk => {
+			const allPrefetchChunks = chunk.getChildIdsByOrdersMap(true).prefetch;
+			return allPrefetchChunks && Object.keys(allPrefetchChunks).length;
+		};
+
+		// TODO webpack 5, no adding to .hooks, use WeakMap and static methods
+		["jsonpScript", "linkPreload", "linkPrefetch"].forEach(hook => {
+			if (!mainTemplate.hooks[hook]) {
+				mainTemplate.hooks[hook] = new SyncWaterfallHook([
+					"source",
+					"chunk",
+					"hash"
+				]);
+			}
+		});
 
 		const getScriptSrcPath = (hash, chunk, chunkIdExpression) => {
 			const chunkFilename = mainTemplate.outputOptions.chunkFilename;
@@ -66,11 +59,12 @@ class JsonpMainTemplatePlugin {
 					hashWithLength(length) {
 						const shortChunkHashMap = Object.create(null);
 						for (const chunkId of Object.keys(chunkMaps.hash)) {
-							if (typeof chunkMaps.hash[chunkId] === "string")
+							if (typeof chunkMaps.hash[chunkId] === "string") {
 								shortChunkHashMap[chunkId] = chunkMaps.hash[chunkId].substr(
 									0,
 									length
 								);
+							}
 						}
 						return `" + ${JSON.stringify(
 							shortChunkHashMap
@@ -231,9 +225,21 @@ class JsonpMainTemplatePlugin {
 		mainTemplate.hooks.linkPrefetch.tap(
 			"JsonpMainTemplatePlugin",
 			(_, chunk, hash) => {
+				const crossOriginLoading =
+					mainTemplate.outputOptions.crossOriginLoading;
+
 				return Template.asString([
 					"var link = document.createElement('link');",
+					crossOriginLoading
+						? `link.crossOrigin = ${JSON.stringify(crossOriginLoading)};`
+						: "",
+					`if (${mainTemplate.requireFn}.nc) {`,
+					Template.indent(
+						`link.setAttribute("nonce", ${mainTemplate.requireFn}.nc);`
+					),
+					"}",
 					'link.rel = "prefetch";',
+					'link.as = "script";',
 					"link.href = jsonpScriptSrc(chunkId);"
 				]);
 			}
@@ -287,7 +293,7 @@ class JsonpMainTemplatePlugin {
 					"",
 					"// chunk preloadng for javascript",
 					"",
-					`var chunkPreloadMap = ${JSON.stringify(chunkMap, null, "\t")}`,
+					`var chunkPreloadMap = ${JSON.stringify(chunkMap, null, "\t")};`,
 					"",
 					"var chunkPreloadData = chunkPreloadMap[chunkId];",
 					"if(chunkPreloadData) {",
@@ -309,45 +315,6 @@ class JsonpMainTemplatePlugin {
 				]);
 			}
 		);
-		mainTemplate.hooks.requireEnsure.tap(
-			{
-				name: "JsonpMainTemplatePlugin prefetch",
-				stage: 20
-			},
-			(source, chunk, hash) => {
-				const chunkMap = chunk.getChildIdsByOrdersMap().prefetch;
-				if (!chunkMap || Object.keys(chunkMap).length === 0) return source;
-				return Template.asString([
-					source,
-					"",
-					"// chunk prefetching for javascript",
-					"",
-					`var chunkPrefetchMap = ${JSON.stringify(chunkMap, null, "\t")}`,
-					"",
-					"var chunkPrefetchData = chunkPrefetchMap[chunkId];",
-					"if(chunkPrefetchData) {",
-					Template.indent([
-						"Promise.all(promises).then(function() {",
-						Template.indent([
-							"var head = document.getElementsByTagName('head')[0];",
-							"chunkPrefetchData.forEach(function(chunkId) {",
-							Template.indent([
-								"if(installedChunks[chunkId] === undefined) {",
-								Template.indent([
-									"installedChunks[chunkId] = null;",
-									mainTemplate.hooks.linkPrefetch.call("", chunk, hash),
-									"head.appendChild(link);"
-								]),
-								"}"
-							]),
-							"});"
-						]),
-						"})"
-					]),
-					"}"
-				]);
-			}
-		);
 		mainTemplate.hooks.requireExtensions.tap(
 			"JsonpMainTemplatePlugin",
 			(source, chunk) => {
@@ -368,6 +335,7 @@ class JsonpMainTemplatePlugin {
 			(source, chunk, hash) => {
 				if (needChunkLoadingCode(chunk)) {
 					const withDefer = needEntryDeferringCode(chunk);
+					const withPrefetch = needPrefetchingCode(chunk);
 					return Template.asString([
 						source,
 						"",
@@ -377,6 +345,7 @@ class JsonpMainTemplatePlugin {
 							"var chunkIds = data[0];",
 							"var moreModules = data[1];",
 							withDefer ? "var executeModules = data[2];" : "",
+							withPrefetch ? "var prefetchChunks = data[3] || [];" : "",
 							'// add "moreModules" to the modules object,',
 							'// then flag all "chunkIds" as loaded and fire callback',
 							"var moduleId, chunkId, i = 0, resolves = [];",
@@ -404,6 +373,23 @@ class JsonpMainTemplatePlugin {
 							]),
 							"}",
 							"if(parentJsonpFunction) parentJsonpFunction(data);",
+							withPrefetch
+								? Template.asString([
+										"// chunk prefetching for javascript",
+										"var head = document.getElementsByTagName('head')[0];",
+										"prefetchChunks.forEach(function(chunkId) {",
+										Template.indent([
+											"if(installedChunks[chunkId] === undefined) {",
+											Template.indent([
+												"installedChunks[chunkId] = null;",
+												mainTemplate.hooks.linkPrefetch.call("", chunk, hash),
+												"head.appendChild(link);"
+											]),
+											"}"
+										]),
+										"});"
+								  ])
+								: "",
 							"while(resolves.length) {",
 							Template.indent("resolves.shift()();"),
 							"}",
@@ -478,6 +464,25 @@ class JsonpMainTemplatePlugin {
 				return source;
 			}
 		);
+		mainTemplate.hooks.beforeStartup.tap(
+			"JsonpMainTemplatePlugin",
+			(source, chunk, hash) => {
+				const prefetchChunks = chunk.getChildIdsByOrders().prefetch;
+				if (
+					needChunkLoadingCode(chunk) &&
+					prefetchChunks &&
+					prefetchChunks.length
+				) {
+					return Template.asString([
+						source,
+						`webpackJsonpCallback([[], {}, 0, ${JSON.stringify(
+							prefetchChunks
+						)}]);`
+					]);
+				}
+				return source;
+			}
+		);
 		mainTemplate.hooks.startup.tap(
 			"JsonpMainTemplatePlugin",
 			(source, chunk, hash) => {

package/lib/webpack.js

@@ -44,8 +44,9 @@ const webpack = (options, callback) => {
 		throw new Error("Invalid argument: options");
 	}
 	if (callback) {
-		if (typeof callback !== "function")
+		if (typeof callback !== "function") {
 			throw new Error("Invalid argument: callback");
+		}
 		if (
 			options.watch === true ||
 			(Array.isArray(options) && options.some(o => o.watch))

package/lib/webworker/WebWorkerMainTemplate.runtime.js

@@ -19,8 +19,9 @@ module.exports = function() {
 	function hotDownloadManifest(requestTimeout) {
 		requestTimeout = requestTimeout || 10000;
 		return new Promise(function(resolve, reject) {
-			if (typeof XMLHttpRequest === "undefined")
+			if (typeof XMLHttpRequest === "undefined") {
 				return reject(new Error("No browser support"));
+			}
 			try {
 				var request = new XMLHttpRequest();
 				var requestPath = $require$.p + $hotMainFilename$;

package/package.json

@@ -1,19 +1,20 @@
 {
   "name": "webpack",
-  "version": "4.10.1",
+  "version": "4.12.0",
   "author": "Tobias Koppers @sokra",
   "description": "Packs CommonJs/AMD modules for the browser. Allows to split your codebase into multiple bundles, which can be loaded on demand. Support loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "license": "MIT",
   "dependencies": {
-    "@webassemblyjs/ast": "1.5.8",
-    "@webassemblyjs/wasm-edit": "1.5.8",
-    "@webassemblyjs/wasm-opt": "1.5.8",
-    "@webassemblyjs/wasm-parser": "1.5.8",
-    "acorn": "^5.0.0",
+    "@webassemblyjs/ast": "1.5.12",
+    "@webassemblyjs/helper-module-context": "1.5.12",
+    "@webassemblyjs/wasm-edit": "1.5.12",
+    "@webassemblyjs/wasm-opt": "1.5.12",
+    "@webassemblyjs/wasm-parser": "1.5.12",
+    "acorn": "^5.6.2",
     "acorn-dynamic-import": "^3.0.0",
     "ajv": "^6.1.0",
     "ajv-keywords": "^3.1.0",
-    "chrome-trace-event": "^0.1.1",
+    "chrome-trace-event": "^1.0.0",
     "enhanced-resolve": "^4.0.0",
     "eslint-scope": "^3.7.1",
     "json-parse-better-errors": "^1.0.2",
@@ -43,7 +44,7 @@
     "es6-promise-polyfill": "^1.1.1",
     "eslint": "^4.19.1",
     "eslint-config-prettier": "^2.9.0",
-    "eslint-plugin-jest": "21.12.2",
+    "eslint-plugin-jest": "^21.17.0",
     "eslint-plugin-node": "^6.0.1",
     "eslint-plugin-prettier": "^2.6.0",
     "express": "~4.13.1",
@@ -53,13 +54,13 @@
     "istanbul": "^0.4.5",
     "jade": "^1.11.0",
     "jade-loader": "~0.8.0",
-    "jest": "23.0.0-charlie.3",
-    "jest-silent-reporter": "0.0.4",
+    "jest": "^23.0.1",
+    "jest-silent-reporter": "^0.0.5",
     "json-loader": "^0.5.7",
     "less": "^2.5.1",
     "less-loader": "^4.0.3",
     "lodash": "^4.17.4",
-    "prettier": "^1.11.1",
+    "prettier": "^1.13.2",
     "pug": "^2.0.3",
     "pug-loader": "^2.4.0",
     "raw-loader": "~0.5.0",

package/schemas/WebpackOptions.json

@@ -1542,6 +1542,14 @@
           "description": "Avoid emitting assets when errors occur",
           "type": "boolean"
         },
+        "checkWasmTypes": {
+          "description": "Check for incompatible wasm types when importing/exporting from/to ESM",
+          "type": "boolean"
+        },
+        "mangleWasmImports": {
+          "description": "Reduce size of WASM by changing imports to shorter strings.",
+          "type": "boolean"
+        },
         "namedModules": {
           "description": "Use readable module identifiers for better debugging",
           "type": "boolean"