@eriche/webpack 4.47.0

package/lib/ParserHelpers.js

@@ -0,0 +1,103 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const path = require("path");
+
+const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
+const ConstDependency = require("./dependencies/ConstDependency");
+const UnsupportedFeatureWarning = require("./UnsupportedFeatureWarning");
+
+const ParserHelpers = exports;
+
+ParserHelpers.addParsedVariableToModule = (parser, name, expression) => {
+	if (!parser.state.current.addVariable) return false;
+	var deps = [];
+	parser.parse(expression, {
+		current: {
+			addDependency: dep => {
+				dep.userRequest = name;
+				deps.push(dep);
+			}
+		},
+		module: parser.state.module
+	});
+	parser.state.current.addVariable(name, expression, deps);
+	return true;
+};
+
+ParserHelpers.requireFileAsExpression = (context, pathToModule) => {
+	var moduleJsPath = path.relative(context, pathToModule);
+	if (!/^[A-Z]:/i.test(moduleJsPath)) {
+		moduleJsPath = "./" + moduleJsPath.replace(/\\/g, "/");
+	}
+	return "require(" + JSON.stringify(moduleJsPath) + ")";
+};
+
+ParserHelpers.toConstantDependency = (parser, value) => {
+	return function constDependency(expr) {
+		var dep = new ConstDependency(value, expr.range, false);
+		dep.loc = expr.loc;
+		parser.state.current.addDependency(dep);
+		return true;
+	};
+};
+
+ParserHelpers.toConstantDependencyWithWebpackRequire = (parser, value) => {
+	return function constDependencyWithWebpackRequire(expr) {
+		var dep = new ConstDependency(value, expr.range, true);
+		dep.loc = expr.loc;
+		parser.state.current.addDependency(dep);
+		return true;
+	};
+};
+
+ParserHelpers.evaluateToString = value => {
+	return function stringExpression(expr) {
+		return new BasicEvaluatedExpression().setString(value).setRange(expr.range);
+	};
+};
+
+ParserHelpers.evaluateToBoolean = value => {
+	return function booleanExpression(expr) {
+		return new BasicEvaluatedExpression()
+			.setBoolean(value)
+			.setRange(expr.range);
+	};
+};
+
+ParserHelpers.evaluateToIdentifier = (identifier, truthy) => {
+	return function identifierExpression(expr) {
+		let evex = new BasicEvaluatedExpression()
+			.setIdentifier(identifier)
+			.setRange(expr.range);
+		if (truthy === true) {
+			evex = evex.setTruthy();
+		} else if (truthy === false) {
+			evex = evex.setFalsy();
+		}
+		return evex;
+	};
+};
+
+ParserHelpers.expressionIsUnsupported = (parser, message) => {
+	return function unsupportedExpression(expr) {
+		var dep = new ConstDependency("(void 0)", expr.range, false);
+		dep.loc = expr.loc;
+		parser.state.current.addDependency(dep);
+		if (!parser.state.module) return;
+		parser.state.module.warnings.push(
+			new UnsupportedFeatureWarning(parser.state.module, message, expr.loc)
+		);
+		return true;
+	};
+};
+
+ParserHelpers.skipTraversal = function skipTraversal() {
+	return true;
+};
+
+ParserHelpers.approve = function approve() {
+	return true;
+};

package/lib/PrefetchPlugin.js

@@ -0,0 +1,37 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const PrefetchDependency = require("./dependencies/PrefetchDependency");
+
+class PrefetchPlugin {
+	constructor(context, request) {
+		if (!request) {
+			this.request = context;
+		} else {
+			this.context = context;
+			this.request = request;
+		}
+	}
+
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"PrefetchPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					PrefetchDependency,
+					normalModuleFactory
+				);
+			}
+		);
+		compiler.hooks.make.tapAsync("PrefetchPlugin", (compilation, callback) => {
+			compilation.prefetch(
+				this.context || compiler.context,
+				new PrefetchDependency(this.request),
+				callback
+			);
+		});
+	}
+}
+module.exports = PrefetchPlugin;

package/lib/ProgressPlugin.js

@@ -0,0 +1,307 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const validateOptions = require("schema-utils");
+const schema = require("../schemas/plugins/ProgressPlugin.json");
+
+/** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginArgument} ProgressPluginArgument */
+/** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginOptions} ProgressPluginOptions */
+
+const createDefaultHandler = (profile, logger) => {
+	let lastState;
+	let lastStateTime;
+
+	const defaultHandler = (percentage, msg, ...args) => {
+		logger.status(`${Math.floor(percentage * 100)}%`, msg, ...args);
+		if (profile) {
+			let state = msg;
+			state = state.replace(/^\d+\/\d+\s+/, "");
+			if (percentage === 0) {
+				lastState = null;
+				lastStateTime = Date.now();
+			} else if (state !== lastState || percentage === 1) {
+				const now = Date.now();
+				if (lastState) {
+					const diff = now - lastStateTime;
+					const stateMsg = `${diff}ms ${lastState}`;
+					if (diff > 1000) {
+						logger.warn(stateMsg);
+					} else if (diff > 10) {
+						logger.info(stateMsg);
+					} else if (diff > 0) {
+						logger.log(stateMsg);
+					} else {
+						logger.debug(stateMsg);
+					}
+				}
+				lastState = state;
+				lastStateTime = now;
+			}
+		}
+		if (percentage === 1) logger.status();
+	};
+
+	return defaultHandler;
+};
+
+class ProgressPlugin {
+	/**
+	 * @param {ProgressPluginArgument} options options
+	 */
+	constructor(options) {
+		if (typeof options === "function") {
+			options = {
+				handler: options
+			};
+		}
+
+		options = options || {};
+		validateOptions(schema, options, "Progress Plugin");
+		options = Object.assign({}, ProgressPlugin.defaultOptions, options);
+
+		this.profile = options.profile;
+		this.handler = options.handler;
+		this.modulesCount = options.modulesCount;
+		this.showEntries = options.entries;
+		this.showModules = options.modules;
+		this.showActiveModules = options.activeModules;
+	}
+
+	apply(compiler) {
+		const { modulesCount } = this;
+		const handler =
+			this.handler ||
+			createDefaultHandler(
+				this.profile,
+				compiler.getInfrastructureLogger("webpack.Progress")
+			);
+		const showEntries = this.showEntries;
+		const showModules = this.showModules;
+		const showActiveModules = this.showActiveModules;
+		if (compiler.compilers) {
+			const states = new Array(compiler.compilers.length);
+			compiler.compilers.forEach((compiler, idx) => {
+				new ProgressPlugin((p, msg, ...args) => {
+					states[idx] = [p, msg, ...args];
+					handler(
+						states
+							.map(state => (state && state[0]) || 0)
+							.reduce((a, b) => a + b) / states.length,
+						`[${idx}] ${msg}`,
+						...args
+					);
+				}).apply(compiler);
+			});
+		} else {
+			let lastModulesCount = 0;
+			let lastEntriesCount = 0;
+			let moduleCount = modulesCount;
+			let entriesCount = 1;
+			let doneModules = 0;
+			let doneEntries = 0;
+			const activeModules = new Set();
+			let lastActiveModule = "";
+
+			const update = () => {
+				const percentByModules =
+					doneModules / Math.max(lastModulesCount, moduleCount);
+				const percentByEntries =
+					doneEntries / Math.max(lastEntriesCount, entriesCount);
+
+				const items = [
+					0.1 + Math.max(percentByModules, percentByEntries) * 0.6,
+					"building"
+				];
+				if (showEntries) {
+					items.push(`${doneEntries}/${entriesCount} entries`);
+				}
+				if (showModules) {
+					items.push(`${doneModules}/${moduleCount} modules`);
+				}
+				if (showActiveModules) {
+					items.push(`${activeModules.size} active`);
+					items.push(lastActiveModule);
+				}
+				handler(...items);
+			};
+
+			const moduleAdd = module => {
+				moduleCount++;
+				if (showActiveModules) {
+					const ident = module.identifier();
+					if (ident) {
+						activeModules.add(ident);
+						lastActiveModule = ident;
+					}
+				}
+				update();
+			};
+
+			const entryAdd = (entry, name) => {
+				entriesCount++;
+				update();
+			};
+
+			const moduleDone = module => {
+				doneModules++;
+				if (showActiveModules) {
+					const ident = module.identifier();
+					if (ident) {
+						activeModules.delete(ident);
+						if (lastActiveModule === ident) {
+							lastActiveModule = "";
+							for (const m of activeModules) {
+								lastActiveModule = m;
+							}
+						}
+					}
+				}
+				update();
+			};
+
+			const entryDone = (entry, name) => {
+				doneEntries++;
+				update();
+			};
+
+			compiler.hooks.compilation.tap("ProgressPlugin", compilation => {
+				if (compilation.compiler.isChild()) return;
+				lastModulesCount = moduleCount;
+				lastEntriesCount = entriesCount;
+				moduleCount = entriesCount = 0;
+				doneModules = doneEntries = 0;
+				handler(0, "compiling");
+
+				compilation.hooks.buildModule.tap("ProgressPlugin", moduleAdd);
+				compilation.hooks.failedModule.tap("ProgressPlugin", moduleDone);
+				compilation.hooks.succeedModule.tap("ProgressPlugin", moduleDone);
+
+				compilation.hooks.addEntry.tap("ProgressPlugin", entryAdd);
+				compilation.hooks.failedEntry.tap("ProgressPlugin", entryDone);
+				compilation.hooks.succeedEntry.tap("ProgressPlugin", entryDone);
+
+				const hooks = {
+					finishModules: "finish module graph",
+					seal: "sealing",
+					beforeChunks: "chunk graph",
+					afterChunks: "after chunk graph",
+					optimizeDependenciesBasic: "basic dependencies optimization",
+					optimizeDependencies: "dependencies optimization",
+					optimizeDependenciesAdvanced: "advanced dependencies optimization",
+					afterOptimizeDependencies: "after dependencies optimization",
+					optimize: "optimizing",
+					optimizeModulesBasic: "basic module optimization",
+					optimizeModules: "module optimization",
+					optimizeModulesAdvanced: "advanced module optimization",
+					afterOptimizeModules: "after module optimization",
+					optimizeChunksBasic: "basic chunk optimization",
+					optimizeChunks: "chunk optimization",
+					optimizeChunksAdvanced: "advanced chunk optimization",
+					afterOptimizeChunks: "after chunk optimization",
+					optimizeTree: "module and chunk tree optimization",
+					afterOptimizeTree: "after module and chunk tree optimization",
+					optimizeChunkModulesBasic: "basic chunk modules optimization",
+					optimizeChunkModules: "chunk modules optimization",
+					optimizeChunkModulesAdvanced: "advanced chunk modules optimization",
+					afterOptimizeChunkModules: "after chunk modules optimization",
+					reviveModules: "module reviving",
+					optimizeModuleOrder: "module order optimization",
+					advancedOptimizeModuleOrder: "advanced module order optimization",
+					beforeModuleIds: "before module ids",
+					moduleIds: "module ids",
+					optimizeModuleIds: "module id optimization",
+					afterOptimizeModuleIds: "module id optimization",
+					reviveChunks: "chunk reviving",
+					optimizeChunkOrder: "chunk order optimization",
+					beforeChunkIds: "before chunk ids",
+					optimizeChunkIds: "chunk id optimization",
+					afterOptimizeChunkIds: "after chunk id optimization",
+					recordModules: "record modules",
+					recordChunks: "record chunks",
+					beforeHash: "hashing",
+					afterHash: "after hashing",
+					recordHash: "record hash",
+					beforeModuleAssets: "module assets processing",
+					beforeChunkAssets: "chunk assets processing",
+					additionalChunkAssets: "additional chunk assets processing",
+					record: "recording",
+					additionalAssets: "additional asset processing",
+					optimizeChunkAssets: "chunk asset optimization",
+					afterOptimizeChunkAssets: "after chunk asset optimization",
+					optimizeAssets: "asset optimization",
+					afterOptimizeAssets: "after asset optimization",
+					afterSeal: "after seal"
+				};
+				const numberOfHooks = Object.keys(hooks).length;
+				Object.keys(hooks).forEach((name, idx) => {
+					const title = hooks[name];
+					const percentage = (idx / numberOfHooks) * 0.25 + 0.7;
+					compilation.hooks[name].intercept({
+						name: "ProgressPlugin",
+						context: true,
+						call: () => {
+							handler(percentage, title);
+						},
+						tap: (context, tap) => {
+							if (context) {
+								// p is percentage from 0 to 1
+								// args is any number of messages in a hierarchical matter
+								context.reportProgress = (p, ...args) => {
+									handler(percentage, title, tap.name, ...args);
+								};
+							}
+							handler(percentage, title, tap.name);
+						}
+					});
+				});
+			});
+			compiler.hooks.emit.intercept({
+				name: "ProgressPlugin",
+				context: true,
+				call: () => {
+					handler(0.95, "emitting");
+				},
+				tap: (context, tap) => {
+					if (context) {
+						context.reportProgress = (p, ...args) => {
+							handler(0.95, "emitting", tap.name, ...args);
+						};
+					}
+					handler(0.95, "emitting", tap.name);
+				}
+			});
+			compiler.hooks.afterEmit.intercept({
+				name: "ProgressPlugin",
+				context: true,
+				call: () => {
+					handler(0.98, "after emitting");
+				},
+				tap: (context, tap) => {
+					if (context) {
+						context.reportProgress = (p, ...args) => {
+							handler(0.98, "after emitting", tap.name, ...args);
+						};
+					}
+					handler(0.98, "after emitting", tap.name);
+				}
+			});
+			compiler.hooks.done.tap("ProgressPlugin", () => {
+				handler(1, "");
+			});
+		}
+	}
+}
+
+ProgressPlugin.defaultOptions = {
+	profile: false,
+	modulesCount: 500,
+	modules: true,
+	activeModules: true,
+	// TODO webpack 5 default this to true
+	entries: false
+};
+
+module.exports = ProgressPlugin;

package/lib/ProvidePlugin.js

@@ -0,0 +1,86 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const ParserHelpers = require("./ParserHelpers");
+const ConstDependency = require("./dependencies/ConstDependency");
+
+const NullFactory = require("./NullFactory");
+
+class ProvidePlugin {
+	constructor(definitions) {
+		this.definitions = definitions;
+	}
+
+	apply(compiler) {
+		const definitions = this.definitions;
+		compiler.hooks.compilation.tap(
+			"ProvidePlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(ConstDependency, new NullFactory());
+				compilation.dependencyTemplates.set(
+					ConstDependency,
+					new ConstDependency.Template()
+				);
+				const handler = (parser, parserOptions) => {
+					Object.keys(definitions).forEach(name => {
+						var request = [].concat(definitions[name]);
+						var splittedName = name.split(".");
+						if (splittedName.length > 0) {
+							splittedName.slice(1).forEach((_, i) => {
+								const name = splittedName.slice(0, i + 1).join(".");
+								parser.hooks.canRename
+									.for(name)
+									.tap("ProvidePlugin", ParserHelpers.approve);
+							});
+						}
+						parser.hooks.expression.for(name).tap("ProvidePlugin", expr => {
+							let nameIdentifier = name;
+							const scopedName = name.includes(".");
+							let expression = `require(${JSON.stringify(request[0])})`;
+							if (scopedName) {
+								nameIdentifier = `__webpack_provided_${name.replace(
+									/\./g,
+									"_dot_"
+								)}`;
+							}
+							if (request.length > 1) {
+								expression += request
+									.slice(1)
+									.map(r => `[${JSON.stringify(r)}]`)
+									.join("");
+							}
+							if (
+								!ParserHelpers.addParsedVariableToModule(
+									parser,
+									nameIdentifier,
+									expression
+								)
+							) {
+								return false;
+							}
+							if (scopedName) {
+								ParserHelpers.toConstantDependency(
+									parser,
+									nameIdentifier
+								)(expr);
+							}
+							return true;
+						});
+					});
+				};
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("ProvidePlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("ProvidePlugin", handler);
+
+				// Disable ProvidePlugin for javascript/esm, see https://github.com/webpack/webpack/issues/7032
+			}
+		);
+	}
+}
+module.exports = ProvidePlugin;

package/lib/RawModule.js

@@ -0,0 +1,56 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const Module = require("./Module");
+const { OriginalSource, RawSource } = require("webpack-sources");
+
+module.exports = class RawModule extends Module {
+	constructor(source, identifier, readableIdentifier) {
+		super("javascript/dynamic", null);
+		this.sourceStr = source;
+		this.identifierStr = identifier || this.sourceStr;
+		this.readableIdentifierStr = readableIdentifier || this.identifierStr;
+		this.built = false;
+	}
+
+	identifier() {
+		return this.identifierStr;
+	}
+
+	size() {
+		return this.sourceStr.length;
+	}
+
+	readableIdentifier(requestShortener) {
+		return requestShortener.shorten(this.readableIdentifierStr);
+	}
+
+	needRebuild() {
+		return false;
+	}
+
+	build(options, compilations, resolver, fs, callback) {
+		this.built = true;
+		this.buildMeta = {};
+		this.buildInfo = {
+			cacheable: true
+		};
+		callback();
+	}
+
+	source() {
+		if (this.useSourceMap) {
+			return new OriginalSource(this.sourceStr, this.identifier());
+		} else {
+			return new RawSource(this.sourceStr);
+		}
+	}
+
+	updateHash(hash) {
+		hash.update(this.sourceStr);
+		super.updateHash(hash);
+	}
+};