@eriche/webpack 4.47.0

package/lib/JavascriptGenerator.js

@@ -0,0 +1,229 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const { RawSource, ReplaceSource } = require("webpack-sources");
+
+// TODO: clean up this file
+// replace with newer constructs
+
+// TODO: remove DependencyVariables and replace them with something better
+
+class JavascriptGenerator {
+	generate(module, dependencyTemplates, runtimeTemplate) {
+		const originalSource = module.originalSource();
+		if (!originalSource) {
+			return new RawSource("throw new Error('No source available');");
+		}
+
+		const source = new ReplaceSource(originalSource);
+
+		this.sourceBlock(
+			module,
+			module,
+			[],
+			dependencyTemplates,
+			source,
+			runtimeTemplate
+		);
+
+		return source;
+	}
+
+	sourceBlock(
+		module,
+		block,
+		availableVars,
+		dependencyTemplates,
+		source,
+		runtimeTemplate
+	) {
+		for (const dependency of block.dependencies) {
+			this.sourceDependency(
+				dependency,
+				dependencyTemplates,
+				source,
+				runtimeTemplate
+			);
+		}
+
+		/**
+		 * Get the variables of all blocks that we need to inject.
+		 * These will contain the variable name and its expression.
+		 * The name will be added as a parameter in a IIFE the expression as its value.
+		 */
+		const vars = block.variables.reduce((result, value) => {
+			const variable = this.sourceVariables(
+				value,
+				availableVars,
+				dependencyTemplates,
+				runtimeTemplate
+			);
+
+			if (variable) {
+				result.push(variable);
+			}
+
+			return result;
+		}, []);
+
+		/**
+		 * if we actually have variables
+		 * this is important as how #splitVariablesInUniqueNamedChunks works
+		 * it will always return an array in an array which would lead to a IIFE wrapper around
+		 * a module if we do this with an empty vars array.
+		 */
+		if (vars.length > 0) {
+			/**
+			 * Split all variables up into chunks of unique names.
+			 * e.g. imagine you have the following variable names that need to be injected:
+			 * [foo, bar, baz, foo, some, more]
+			 * we can not inject "foo" twice, therefore we just make two IIFEs like so:
+			 * (function(foo, bar, baz){
+			 *   (function(foo, some, more){
+			 *     …
+			 *   }(…));
+			 * }(…));
+			 *
+			 * "splitVariablesInUniqueNamedChunks" splits the variables shown above up to this:
+			 * [[foo, bar, baz], [foo, some, more]]
+			 */
+			const injectionVariableChunks = this.splitVariablesInUniqueNamedChunks(
+				vars
+			);
+
+			// create all the beginnings of IIFEs
+			const functionWrapperStarts = injectionVariableChunks.map(
+				variableChunk => {
+					return this.variableInjectionFunctionWrapperStartCode(
+						variableChunk.map(variable => variable.name)
+					);
+				}
+			);
+
+			// and all the ends
+			const functionWrapperEnds = injectionVariableChunks.map(variableChunk => {
+				return this.variableInjectionFunctionWrapperEndCode(
+					module,
+					variableChunk.map(variable => variable.expression),
+					block
+				);
+			});
+
+			// join them to one big string
+			const varStartCode = functionWrapperStarts.join("");
+
+			// reverse the ends first before joining them, as the last added must be the inner most
+			const varEndCode = functionWrapperEnds.reverse().join("");
+
+			// if we have anything, add it to the source
+			if (varStartCode && varEndCode) {
+				const start = block.range ? block.range[0] : -10;
+				const end = block.range
+					? block.range[1]
+					: module.originalSource().size() + 1;
+				source.insert(start + 0.5, varStartCode);
+				source.insert(end + 0.5, "\n/* WEBPACK VAR INJECTION */" + varEndCode);
+			}
+		}
+
+		for (const childBlock of block.blocks) {
+			this.sourceBlock(
+				module,
+				childBlock,
+				availableVars.concat(vars),
+				dependencyTemplates,
+				source,
+				runtimeTemplate
+			);
+		}
+	}
+
+	sourceDependency(dependency, dependencyTemplates, source, runtimeTemplate) {
+		const template = dependencyTemplates.get(dependency.constructor);
+		if (!template) {
+			throw new Error(
+				"No template for dependency: " + dependency.constructor.name
+			);
+		}
+		template.apply(dependency, source, runtimeTemplate, dependencyTemplates);
+	}
+
+	sourceVariables(
+		variable,
+		availableVars,
+		dependencyTemplates,
+		runtimeTemplate
+	) {
+		const name = variable.name;
+		const expr = variable.expressionSource(
+			dependencyTemplates,
+			runtimeTemplate
+		);
+
+		if (
+			availableVars.some(
+				v => v.name === name && v.expression.source() === expr.source()
+			)
+		) {
+			return;
+		}
+		return {
+			name: name,
+			expression: expr
+		};
+	}
+
+	/*
+	 * creates the start part of a IIFE around the module to inject a variable name
+	 * (function(…){   <- this part
+	 * }.call(…))
+	 */
+	variableInjectionFunctionWrapperStartCode(varNames) {
+		const args = varNames.join(", ");
+		return `/* WEBPACK VAR INJECTION */(function(${args}) {`;
+	}
+
+	contextArgument(module, block) {
+		if (this === block) {
+			return module.exportsArgument;
+		}
+		return "this";
+	}
+
+	/*
+	 * creates the end part of a IIFE around the module to inject a variable name
+	 * (function(…){
+	 * }.call(…))   <- this part
+	 */
+	variableInjectionFunctionWrapperEndCode(module, varExpressions, block) {
+		const firstParam = this.contextArgument(module, block);
+		const furtherParams = varExpressions.map(e => e.source()).join(", ");
+		return `}.call(${firstParam}, ${furtherParams}))`;
+	}
+
+	splitVariablesInUniqueNamedChunks(vars) {
+		const startState = [[]];
+		return vars.reduce((chunks, variable) => {
+			const current = chunks[chunks.length - 1];
+			// check if variable with same name exists already
+			// if so create a new chunk of variables.
+			const variableNameAlreadyExists = current.some(
+				v => v.name === variable.name
+			);
+
+			if (variableNameAlreadyExists) {
+				// start new chunk with current variable
+				chunks.push([variable]);
+			} else {
+				// else add it to current chunk
+				current.push(variable);
+			}
+			return chunks;
+		}, startState);
+	}
+}
+
+module.exports = JavascriptGenerator;

package/lib/JavascriptModulesPlugin.js

@@ -0,0 +1,185 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const Parser = require("./Parser");
+const Template = require("./Template");
+const { ConcatSource } = require("webpack-sources");
+const JavascriptGenerator = require("./JavascriptGenerator");
+const createHash = require("./util/createHash");
+
+class JavascriptModulesPlugin {
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"JavascriptModulesPlugin",
+			(compilation, { normalModuleFactory }) => {
+				normalModuleFactory.hooks.createParser
+					.for("javascript/auto")
+					.tap("JavascriptModulesPlugin", options => {
+						return new Parser(options, "auto");
+					});
+				normalModuleFactory.hooks.createParser
+					.for("javascript/dynamic")
+					.tap("JavascriptModulesPlugin", options => {
+						return new Parser(options, "script");
+					});
+				normalModuleFactory.hooks.createParser
+					.for("javascript/esm")
+					.tap("JavascriptModulesPlugin", options => {
+						return new Parser(options, "module");
+					});
+				normalModuleFactory.hooks.createGenerator
+					.for("javascript/auto")
+					.tap("JavascriptModulesPlugin", () => {
+						return new JavascriptGenerator();
+					});
+				normalModuleFactory.hooks.createGenerator
+					.for("javascript/dynamic")
+					.tap("JavascriptModulesPlugin", () => {
+						return new JavascriptGenerator();
+					});
+				normalModuleFactory.hooks.createGenerator
+					.for("javascript/esm")
+					.tap("JavascriptModulesPlugin", () => {
+						return new JavascriptGenerator();
+					});
+				compilation.mainTemplate.hooks.renderManifest.tap(
+					"JavascriptModulesPlugin",
+					(result, options) => {
+						const chunk = options.chunk;
+						const hash = options.hash;
+						const fullHash = options.fullHash;
+						const outputOptions = options.outputOptions;
+						const moduleTemplates = options.moduleTemplates;
+						const dependencyTemplates = options.dependencyTemplates;
+
+						const filenameTemplate =
+							chunk.filenameTemplate || outputOptions.filename;
+
+						const useChunkHash = compilation.mainTemplate.useChunkHash(chunk);
+
+						result.push({
+							render: () =>
+								compilation.mainTemplate.render(
+									hash,
+									chunk,
+									moduleTemplates.javascript,
+									dependencyTemplates
+								),
+							filenameTemplate,
+							pathOptions: {
+								noChunkHash: !useChunkHash,
+								contentHashType: "javascript",
+								chunk
+							},
+							identifier: `chunk${chunk.id}`,
+							hash: useChunkHash ? chunk.hash : fullHash
+						});
+						return result;
+					}
+				);
+				compilation.mainTemplate.hooks.modules.tap(
+					"JavascriptModulesPlugin",
+					(source, chunk, hash, moduleTemplate, dependencyTemplates) => {
+						return Template.renderChunkModules(
+							chunk,
+							m => typeof m.source === "function",
+							moduleTemplate,
+							dependencyTemplates,
+							"/******/ "
+						);
+					}
+				);
+				compilation.chunkTemplate.hooks.renderManifest.tap(
+					"JavascriptModulesPlugin",
+					(result, options) => {
+						const chunk = options.chunk;
+						const outputOptions = options.outputOptions;
+						const moduleTemplates = options.moduleTemplates;
+						const dependencyTemplates = options.dependencyTemplates;
+						const filenameTemplate =
+							chunk.filenameTemplate || outputOptions.chunkFilename;
+
+						result.push({
+							render: () =>
+								this.renderJavascript(
+									compilation.chunkTemplate,
+									chunk,
+									moduleTemplates.javascript,
+									dependencyTemplates
+								),
+							filenameTemplate,
+							pathOptions: {
+								chunk,
+								contentHashType: "javascript"
+							},
+							identifier: `chunk${chunk.id}`,
+							hash: chunk.hash
+						});
+
+						return result;
+					}
+				);
+				compilation.hooks.contentHash.tap("JavascriptModulesPlugin", chunk => {
+					const outputOptions = compilation.outputOptions;
+					const {
+						hashSalt,
+						hashDigest,
+						hashDigestLength,
+						hashFunction
+					} = outputOptions;
+					const hash = createHash(hashFunction);
+					if (hashSalt) hash.update(hashSalt);
+					const template = chunk.hasRuntime()
+						? compilation.mainTemplate
+						: compilation.chunkTemplate;
+					hash.update(`${chunk.id} `);
+					hash.update(chunk.ids ? chunk.ids.join(",") : "");
+					template.updateHashForChunk(
+						hash,
+						chunk,
+						compilation.moduleTemplates.javascript,
+						compilation.dependencyTemplates
+					);
+					for (const m of chunk.modulesIterable) {
+						if (typeof m.source === "function") {
+							hash.update(m.hash);
+						}
+					}
+					const digest = /** @type {string} */ (hash.digest(hashDigest));
+					chunk.contentHash.javascript = digest.substr(0, hashDigestLength);
+				});
+			}
+		);
+	}
+
+	renderJavascript(chunkTemplate, chunk, moduleTemplate, dependencyTemplates) {
+		const moduleSources = Template.renderChunkModules(
+			chunk,
+			m => typeof m.source === "function",
+			moduleTemplate,
+			dependencyTemplates
+		);
+		const core = chunkTemplate.hooks.modules.call(
+			moduleSources,
+			chunk,
+			moduleTemplate,
+			dependencyTemplates
+		);
+		let source = chunkTemplate.hooks.render.call(
+			core,
+			chunk,
+			moduleTemplate,
+			dependencyTemplates
+		);
+		if (chunk.hasEntryModule()) {
+			source = chunkTemplate.hooks.renderWithEntry.call(source, chunk);
+		}
+		chunk.rendered = true;
+		return new ConcatSource(source, ";");
+	}
+}
+
+module.exports = JavascriptModulesPlugin;

package/lib/JsonGenerator.js

@@ -0,0 +1,57 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const { ConcatSource, RawSource } = require("webpack-sources");
+
+const stringifySafe = data => {
+	const stringified = JSON.stringify(data);
+	if (!stringified) {
+		return undefined; // Invalid JSON
+	}
+
+	return stringified.replace(/\u2028|\u2029/g, str =>
+		str === "\u2029" ? "\\u2029" : "\\u2028"
+	); // invalid in JavaScript but valid JSON
+};
+
+class JsonGenerator {
+	generate(module, dependencyTemplates, runtimeTemplate) {
+		const source = new ConcatSource();
+		const data = module.buildInfo.jsonData;
+		if (data === undefined) {
+			return new RawSource(
+				runtimeTemplate.missingModuleStatement({
+					request: module.rawRequest
+				})
+			);
+		}
+		let finalJson;
+		if (
+			Array.isArray(module.buildMeta.providedExports) &&
+			!module.isUsed("default")
+		) {
+			// Only some exports are used: We can optimize here, by only generating a part of the JSON
+			const reducedJson = {};
+			for (const exportName of module.buildMeta.providedExports) {
+				if (exportName === "default") continue;
+				const used = module.isUsed(exportName);
+				if (used) {
+					reducedJson[used] = data[exportName];
+				}
+			}
+			finalJson = reducedJson;
+		} else {
+			finalJson = data;
+		}
+		// Use JSON because JSON.parse() is much faster than JavaScript evaluation
+		const jsonSource = JSON.stringify(stringifySafe(finalJson));
+		const jsonExpr = `JSON.parse(${jsonSource})`;
+		source.add(`${module.moduleArgument}.exports = ${jsonExpr};`);
+		return source;
+	}
+}
+
+module.exports = JsonGenerator;

package/lib/JsonModulesPlugin.js

@@ -0,0 +1,30 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const JsonParser = require("./JsonParser");
+const JsonGenerator = require("./JsonGenerator");
+
+class JsonModulesPlugin {
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"JsonModulesPlugin",
+			(compilation, { normalModuleFactory }) => {
+				normalModuleFactory.hooks.createParser
+					.for("json")
+					.tap("JsonModulesPlugin", () => {
+						return new JsonParser();
+					});
+				normalModuleFactory.hooks.createGenerator
+					.for("json")
+					.tap("JsonModulesPlugin", () => {
+						return new JsonGenerator();
+					});
+			}
+		);
+	}
+}
+
+module.exports = JsonModulesPlugin;

package/lib/JsonParser.js

@@ -0,0 +1,27 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const parseJson = require("json-parse-better-errors");
+const JsonExportsDependency = require("./dependencies/JsonExportsDependency");
+
+class JsonParser {
+	constructor(options) {
+		this.options = options;
+	}
+
+	parse(source, state) {
+		const data = parseJson(source[0] === "\ufeff" ? source.slice(1) : source);
+		state.module.buildInfo.jsonData = data;
+		state.module.buildMeta.exportsType = "named";
+		if (typeof data === "object" && data) {
+			state.module.addDependency(new JsonExportsDependency(Object.keys(data)));
+		}
+		state.module.addDependency(new JsonExportsDependency(["default"]));
+		return state;
+	}
+}
+
+module.exports = JsonParser;

package/lib/LibManifestPlugin.js

@@ -0,0 +1,90 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const path = require("path");
+const asyncLib = require("neo-async");
+const SingleEntryDependency = require("./dependencies/SingleEntryDependency");
+
+class LibManifestPlugin {
+	constructor(options) {
+		this.options = options;
+	}
+
+	apply(compiler) {
+		compiler.hooks.emit.tapAsync(
+			"LibManifestPlugin",
+			(compilation, callback) => {
+				asyncLib.forEach(
+					compilation.chunks,
+					(chunk, callback) => {
+						if (!chunk.isOnlyInitial()) {
+							callback();
+							return;
+						}
+						const targetPath = compilation.getPath(this.options.path, {
+							hash: compilation.hash,
+							chunk
+						});
+						const name =
+							this.options.name &&
+							compilation.getPath(this.options.name, {
+								hash: compilation.hash,
+								chunk
+							});
+						const manifest = {
+							name,
+							type: this.options.type,
+							content: Array.from(chunk.modulesIterable, module => {
+								if (
+									this.options.entryOnly &&
+									!module.reasons.some(
+										r => r.dependency instanceof SingleEntryDependency
+									)
+								) {
+									return;
+								}
+								if (module.libIdent) {
+									const ident = module.libIdent({
+										context: this.options.context || compiler.options.context
+									});
+									if (ident) {
+										return {
+											ident,
+											data: {
+												id: module.id,
+												buildMeta: module.buildMeta
+											}
+										};
+									}
+								}
+							})
+								.filter(Boolean)
+								.reduce((obj, item) => {
+									obj[item.ident] = item.data;
+									return obj;
+								}, Object.create(null))
+						};
+						// Apply formatting to content if format flag is true;
+						const manifestContent = this.options.format
+							? JSON.stringify(manifest, null, 2)
+							: JSON.stringify(manifest);
+						const content = Buffer.from(manifestContent, "utf8");
+						compiler.outputFileSystem.mkdirp(path.dirname(targetPath), err => {
+							if (err) return callback(err);
+							compiler.outputFileSystem.writeFile(
+								targetPath,
+								content,
+								callback
+							);
+						});
+					},
+					callback
+				);
+			}
+		);
+	}
+}
+module.exports = LibManifestPlugin;