webpack 4.13.0 → 4.16.0

package/lib/Compiler.js

@@ -27,38 +27,83 @@ const RequestShortener = require("./RequestShortener");
 const { makePathsRelative } = require("./util/identifier");
 const ConcurrentCompilationError = require("./ConcurrentCompilationError");
 
+/**
+ * @typedef {Object} CompilationParams
+ * @property {NormalModuleFactory} normalModuleFactory
+ * @property {ContextModuleFactory} contextModuleFactory
+ * @property {Set<string>} compilationDependencies
+ */
+
+/** @typedef {string|string[]} EntryValues */
+/** @typedef {Record<string, EntryValues>} EntryOptionValues */
+
+/**
+ * @callback EntryOptionValuesFunction
+ * @returns {EntryOptionValues | EntryValues} the computed value
+ */
+
+/** @typedef {EntryOptionValuesFunction | EntryOptionValues | EntryValues} EntryOptions */
+
 class Compiler extends Tapable {
 	constructor(context) {
 		super();
 		this.hooks = {
+			/** @type {SyncBailHook<Compilation>} */
 			shouldEmit: new SyncBailHook(["compilation"]),
+			/** @type {AsyncSeriesHook<Stats>} */
 			done: new AsyncSeriesHook(["stats"]),
+			/** @type {AsyncSeriesHook<>} */
 			additionalPass: new AsyncSeriesHook([]),
-			beforeRun: new AsyncSeriesHook(["compilation"]),
-			run: new AsyncSeriesHook(["compilation"]),
+			/** @type {AsyncSeriesHook<Compiler>} */
+			beforeRun: new AsyncSeriesHook(["compiler"]),
+			/** @type {AsyncSeriesHook<Compiler>} */
+			run: new AsyncSeriesHook(["compiler"]),
+			/** @type {AsyncSeriesHook<Compilation>} */
 			emit: new AsyncSeriesHook(["compilation"]),
+			/** @type {AsyncSeriesHook<Compilation>} */
 			afterEmit: new AsyncSeriesHook(["compilation"]),
+
+			/** @type {SyncHook<Compilation, CompilationParams>} */
 			thisCompilation: new SyncHook(["compilation", "params"]),
+			/** @type {SyncHook<Compilation, CompilationParams>} */
 			compilation: new SyncHook(["compilation", "params"]),
+			/** @type {SyncHook<NormalModuleFactory>} */
 			normalModuleFactory: new SyncHook(["normalModuleFactory"]),
+			/** @type {SyncHook<ContextModuleFactory>}  */
 			contextModuleFactory: new SyncHook(["contextModulefactory"]),
+
+			/** @type {AsyncSeriesHook<CompilationParams>} */
 			beforeCompile: new AsyncSeriesHook(["params"]),
+			/** @type {SyncHook<CompilationParams>} */
 			compile: new SyncHook(["params"]),
+			/** @type {AsyncParallelHook<Compilation>} */
 			make: new AsyncParallelHook(["compilation"]),
+			/** @type {AsyncSeriesHook<Compilation>} */
 			afterCompile: new AsyncSeriesHook(["compilation"]),
+
+			/** @type {AsyncSeriesHook<Compiler>} */
 			watchRun: new AsyncSeriesHook(["compiler"]),
+			/** @type {SyncHook<Error>} */
 			failed: new SyncHook(["error"]),
+			/** @type {SyncHook<string, string>} */
 			invalid: new SyncHook(["filename", "changeTime"]),
+			/** @type {SyncHook} */
 			watchClose: new SyncHook([]),
 
 			// TODO the following hooks are weirdly located here
 			// TODO move them for webpack 5
+			/** @type {SyncHook} */
 			environment: new SyncHook([]),
+			/** @type {SyncHook} */
 			afterEnvironment: new SyncHook([]),
+			/** @type {SyncHook<Compiler>} */
 			afterPlugins: new SyncHook(["compiler"]),
+			/** @type {SyncHook<Compiler>} */
 			afterResolvers: new SyncHook(["compiler"]),
+			/** @type {SyncBailHook<string, EntryOptions>} */
 			entryOption: new SyncBailHook(["context", "entry"])
 		};
+
 		this._pluginCompat.tap("Compiler", options => {
 			switch (options.name) {
 				case "additional-pass":
@@ -75,19 +120,26 @@ class Compiler extends Tapable {
 			}
 		});
 
+		/** @type {string=} */
 		this.name = undefined;
+		/** @type {Compilation=} */
 		this.parentCompilation = undefined;
+		/** @type {string} */
 		this.outputPath = "";
+
 		this.outputFileSystem = null;
 		this.inputFileSystem = null;
 
+		/** @type {string|null} */
 		this.recordsInputPath = null;
+		/** @type {string|null} */
 		this.recordsOutputPath = null;
 		this.records = {};
-
+		/** @type {Map<string, number>} */
 		this.fileTimestamps = new Map();
+		/** @type {Map<string, number>} */
 		this.contextTimestamps = new Map();
-
+		/** @type {ResolverFactory} */
 		this.resolverFactory = new ResolverFactory();
 
 		// TODO remove in webpack 5
@@ -136,6 +188,7 @@ class Compiler extends Tapable {
 
 		this.requestShortener = new RequestShortener(context);
 
+		/** @type {boolean} */
 		this.running = false;
 	}
 

package/lib/ContextModule.js

@@ -3,20 +3,37 @@
 	Author Tobias Koppers @sokra
 */
 "use strict";
-const path = require("path");
 const util = require("util");
 const { OriginalSource, RawSource } = require("webpack-sources");
 const Module = require("./Module");
 const AsyncDependenciesBlock = require("./AsyncDependenciesBlock");
 const Template = require("./Template");
+const contextify = require("./util/identifier").contextify;
 
 /** @typedef {import("./dependencies/ContextElementDependency")} ContextElementDependency */
 
+/**
+ * @callback ResolveDependenciesCallback
+ * @param {Error=} err
+ * @param {ContextElementDependency[]} dependencies
+ */
+
+/**
+ * @callback ResolveDependencies
+ * @param {TODO} fs
+ * @param {TODO} options
+ * @param {ResolveDependenciesCallback} callback
+ */
+
 class ContextModule extends Module {
 	// type ContextMode = "sync" | "eager" | "weak" | "async-weak" | "lazy" | "lazy-once"
 	// type ContextOptions = { resource: string, recursive: boolean, regExp: RegExp, addon?: string, mode?: ContextMode, chunkName?: string, include?: RegExp, exclude?: RegExp, groupOptions?: Object }
 	// resolveDependencies: (fs: FS, options: ContextOptions, (err: Error?, dependencies: Dependency[]) => void) => void
 	// options: ContextOptions
+	/**
+	 * @param {ResolveDependencies} resolveDependencies function to get dependencies in this context
+	 * @param {TODO} options options object
+	 */
 	constructor(resolveDependencies, options) {
 		let resource;
 		let resourceQuery;
@@ -63,18 +80,6 @@ class ContextModule extends Module {
 		return regexString.substring(1, regexString.length - 1);
 	}
 
-	contextify(context, request) {
-		return request
-			.split("!")
-			.map(subrequest => {
-				let rp = path.relative(context, subrequest);
-				if (path.sep === "\\") rp = rp.replace(/\\/g, "/");
-				if (rp.indexOf("../") !== 0) rp = "./" + rp;
-				return rp;
-			})
-			.join("!");
-	}
-
 	_createIdentifier() {
 		let identifier = this.context;
 		if (this.options.resourceQuery) {
@@ -155,7 +160,7 @@ class ContextModule extends Module {
 	}
 
 	libIdent(options) {
-		let identifier = this.contextify(options.context, this.context);
+		let identifier = contextify(options.context, this.context);
 		if (this.options.mode) {
 			identifier += ` ${this.options.mode}`;
 		}
@@ -163,7 +168,7 @@ class ContextModule extends Module {
 			identifier += " recursive";
 		}
 		if (this.options.addon) {
-			identifier += ` ${this.contextify(options.context, this.options.addon)}`;
+			identifier += ` ${contextify(options.context, this.options.addon)}`;
 		}
 		if (this.options.regExp) {
 			identifier += ` ${this.prettyRegExp(this.options.regExp + "")}`;
@@ -206,7 +211,9 @@ class ContextModule extends Module {
 
 			// enhance dependencies with meta info
 			for (const dep of dependencies) {
-				dep.loc = dep.userRequest;
+				dep.loc = {
+					name: dep.userRequest
+				};
 				dep.request = this.options.addon + dep.request;
 			}
 

package/lib/DelegatedModule.js

@@ -11,6 +11,8 @@ const WebpackMissingModule = require("./dependencies/WebpackMissingModule");
 const DelegatedSourceDependency = require("./dependencies/DelegatedSourceDependency");
 const DelegatedExportsDependency = require("./dependencies/DelegatedExportsDependency");
 
+/** @typedef {import("./dependencies/ModuleDependency")} ModuleDependency */
+
 class DelegatedModule extends Module {
 	constructor(sourceRequest, data, type, userRequest, originalRequest) {
 		super("javascript/dynamic", null);
@@ -22,6 +24,9 @@ class DelegatedModule extends Module {
 		this.userRequest = userRequest;
 		this.originalRequest = originalRequest;
 		this.delegateData = data;
+
+		// Build info
+		this.delegatedSourceDependency = undefined;
 	}
 
 	libIdent(options) {
@@ -48,7 +53,10 @@ class DelegatedModule extends Module {
 		this.built = true;
 		this.buildMeta = Object.assign({}, this.delegateData.buildMeta);
 		this.buildInfo = {};
-		this.addDependency(new DelegatedSourceDependency(this.sourceRequest));
+		this.delegatedSourceDependency = new DelegatedSourceDependency(
+			this.sourceRequest
+		);
+		this.addDependency(this.delegatedSourceDependency);
 		this.addDependency(
 			new DelegatedExportsDependency(this, this.delegateData.exports || true)
 		);

package/lib/DelegatedModuleFactoryPlugin.js

@@ -15,7 +15,13 @@ class DelegatedModuleFactoryPlugin {
 	constructor(options) {
 		this.options = options;
 		options.type = options.type || "require";
-		options.extensions = options.extensions || ["", ".js"];
+		options.extensions = options.extensions || [
+			"",
+			".wasm",
+			".mjs",
+			".js",
+			".json"
+		];
 	}
 
 	apply(normalModuleFactory) {

package/lib/DependenciesBlock.js

@@ -8,23 +8,39 @@ const DependenciesBlockVariable = require("./DependenciesBlockVariable");
 
 /** @typedef {import("./ChunkGroup")} ChunkGroup */
 /** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("./DependenciesBlockVariable")} DependenciesBlockVariable */
+/** @typedef {(d: Dependency) => boolean} DependencyFilterFunction */
+/** @typedef {import("./util/createHash").Hash} Hash */
 
 class DependenciesBlock {
 	constructor() {
 		/** @type {Dependency[]} */
 		this.dependencies = [];
+		/** @type {AsyncDependenciesBlock[]} */
 		this.blocks = [];
+		/** @type {DependenciesBlockVariable[]} */
 		this.variables = [];
-		// TODO remove this line, it's wrong
-		/** @type {ChunkGroup=} */
-		this.chunkGroup = undefined;
 	}
 
+	/**
+	 * Adds a DependencyBlock to DependencyBlock relationship.
+	 * This is used for when a Module has a AsyncDependencyBlock tie (for code-splitting)
+	 *
+	 * @param {AsyncDependenciesBlock} block block being added
+	 * @returns {void}
+	 */
 	addBlock(block) {
 		this.blocks.push(block);
 		block.parent = this;
 	}
 
+	/**
+	 * @param {string} name name of dependency
+	 * @param {string} expression expression string for variable
+	 * @param {Dependency[]} dependencies dependency instances tied to variable
+	 * @returns {void}
+	 */
 	addVariable(name, expression, dependencies) {
 		for (let v of this.variables) {
 			if (v.name === name && v.expression === expression) {
@@ -36,10 +52,19 @@ class DependenciesBlock {
 		);
 	}
 
+	/**
+	 * @param {Dependency} dependency dependency being tied to block.
+	 * This is an "edge" pointing to another "node" on module graph.
+	 * @returns {void}
+	 */
 	addDependency(dependency) {
 		this.dependencies.push(dependency);
 	}
 
+	/**
+	 * @param {Dependency} dependency dependency being removed
+	 * @returns {void}
+	 */
 	removeDependency(dependency) {
 		const idx = this.dependencies.indexOf(dependency);
 		if (idx >= 0) {
@@ -47,6 +72,10 @@ class DependenciesBlock {
 		}
 	}
 
+	/**
+	 * @param {Hash} hash the hash used to track dependencies, from "crypto" module
+	 * @returns {void}
+	 */
 	updateHash(hash) {
 		for (const dep of this.dependencies) dep.updateHash(hash);
 		for (const block of this.blocks) block.updateHash(hash);
@@ -63,6 +92,10 @@ class DependenciesBlock {
 		for (const block of this.blocks) block.unseal();
 	}
 
+	/**
+	 * @param {DependencyFilterFunction} filter filter function for dependencies, gets passed all dependency ties from current instance
+	 * @returns {boolean} returns boolean for filter
+	 */
 	hasDependencies(filter) {
 		if (filter) {
 			for (const dep of this.dependencies) {

package/lib/DependenciesBlockVariable.js

@@ -6,13 +6,30 @@
 
 const { RawSource, ReplaceSource } = require("webpack-sources");
 
+/** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./Dependency").DependencyTemplate} DependencyTemplate */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("./util/createHash").Hash} Hash */
+/** @typedef {(d: Dependency) => boolean} DependencyFilterFunction */
+/** @typedef {Map<Function, DependencyTemplate>} DependencyTemplates */
+
 class DependenciesBlockVariable {
+	/**
+	 * Creates an instance of DependenciesBlockVariable.
+	 * @param {string} name name of DependenciesBlockVariable
+	 * @param {string} expression expression string
+	 * @param {Dependency[]=} dependencies dependencies tied to this varaiable
+	 */
 	constructor(name, expression, dependencies) {
 		this.name = name;
 		this.expression = expression;
 		this.dependencies = dependencies || [];
 	}
 
+	/**
+	 * @param {Hash} hash hash for instance to update
+	 * @returns {void}
+	 */
 	updateHash(hash) {
 		hash.update(this.name);
 		hash.update(this.expression);
@@ -21,6 +38,11 @@ class DependenciesBlockVariable {
 		}
 	}
 
+	/**
+	 * @param {DependencyTemplates} dependencyTemplates Dependency constructors and templates Map.
+	 * @param {RuntimeTemplate} runtimeTemplate runtimeTemplate to generate expression souce
+	 * @returns {ReplaceSource} returns constructed source for expression via templates
+	 */
 	expressionSource(dependencyTemplates, runtimeTemplate) {
 		const source = new ReplaceSource(new RawSource(this.expression));
 		for (const dep of this.dependencies) {

package/lib/Dependency.js

@@ -4,25 +4,47 @@
 */
 "use strict";
 
+const util = require("util");
 const compareLocations = require("./compareLocations");
 const DependencyReference = require("./dependencies/DependencyReference");
 
-/** @typedef {Object} Position
- *  @property {number} column
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+
+/**
+ * @typedef {Object} DependencyTemplate
+ * @property {function(Dependency, Source, RuntimeTemplate, Map<Function, DependencyTemplate>): void} apply
+ */
+
+/** @typedef {Object} SourcePosition
  *  @property {number} line
+ *  @property {number=} column
  */
 
-/** @typedef {Object} Loc
- *  @property {Position} start
- *  @property {Position} end
+/** @typedef {Object} RealDependencyLocation
+ *  @property {SourcePosition} start
+ *  @property {SourcePosition=} end
+ *  @property {number=} index
  */
 
+/** @typedef {Object} SynteticDependencyLocation
+ *  @property {string} name
+ *  @property {number=} index
+ */
+
+/** @typedef {SynteticDependencyLocation|RealDependencyLocation} DependencyLocation */
+
 class Dependency {
 	constructor() {
+		/** @type {Module|null} */
 		this.module = null;
 		// TODO remove in webpack 5
+		/** @type {boolean} */
 		this.weak = false;
+		/** @type {boolean} */
 		this.optional = false;
+		/** @type {DependencyLocation} */
 		this.loc = undefined;
 	}
 
@@ -57,6 +79,11 @@ class Dependency {
 		this.module = null;
 	}
 }
-Dependency.compare = (a, b) => compareLocations(a.loc, b.loc);
+
+// TODO remove in webpack 5
+Dependency.compare = util.deprecate(
+	(a, b) => compareLocations(a.loc, b.loc),
+	"Dependency.compare is deprecated and will be removed in the next major version"
+);
 
 module.exports = Dependency;

package/lib/DllEntryPlugin.js

@@ -36,7 +36,10 @@ class DllEntryPlugin {
 				new DllEntryDependency(
 					this.entries.map((e, idx) => {
 						const dep = new SingleEntryDependency(e);
-						dep.loc = `${this.name}:${idx}`;
+						dep.loc = {
+							name: this.name,
+							index: idx
+						};
 						return dep;
 					}),
 					this.name

package/lib/DynamicEntryPlugin.js

@@ -10,12 +10,23 @@ const MultiModuleFactory = require("./MultiModuleFactory");
 const MultiEntryPlugin = require("./MultiEntryPlugin");
 const SingleEntryPlugin = require("./SingleEntryPlugin");
 
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Compiler").EntryOptionValuesFunction} EntryOptionValuesFunction */
+
 class DynamicEntryPlugin {
+	/**
+	 * @param {string} context the context path
+	 * @param {EntryOptionValuesFunction} entry the entry value
+	 */
 	constructor(context, entry) {
 		this.context = context;
 		this.entry = entry;
 	}
 
+	/**
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
 			"DynamicEntryPlugin",
@@ -36,6 +47,11 @@ class DynamicEntryPlugin {
 		compiler.hooks.make.tapAsync(
 			"DynamicEntryPlugin",
 			(compilation, callback) => {
+				/**
+				 * @param {string|string[]} entry entry value or array of entry values
+				 * @param {string} name name of entry
+				 * @returns {Promise<any>} returns the promise resolving the Compilation#addEntry function
+				 */
 				const addEntry = (entry, name) => {
 					const dep = DynamicEntryPlugin.createDependency(entry, name);
 					return new Promise((resolve, reject) => {
@@ -63,7 +79,11 @@ class DynamicEntryPlugin {
 }
 
 module.exports = DynamicEntryPlugin;
-
+/**
+ * @param {string|string[]} entry entry value or array of entry paths
+ * @param {string} name name of entry
+ * @returns {SingleEntryDependency|MultiEntryDependency} returns dep
+ */
 DynamicEntryPlugin.createDependency = (entry, name) => {
 	if (Array.isArray(entry)) {
 		return MultiEntryPlugin.createDependency(entry, name);

package/lib/EntryOptionPlugin.js

@@ -8,6 +8,14 @@ const SingleEntryPlugin = require("./SingleEntryPlugin");
 const MultiEntryPlugin = require("./MultiEntryPlugin");
 const DynamicEntryPlugin = require("./DynamicEntryPlugin");
 
+/** @typedef {import("./Compiler")} Compiler */
+
+/**
+ * @param {string} context context path
+ * @param {string | string[]} item entry array or single path
+ * @param {string} name entry key name
+ * @returns {SingleEntryPlugin | MultiEntryPlugin} returns either a single or multi entry plugin
+ */
 const itemToPlugin = (context, item, name) => {
 	if (Array.isArray(item)) {
 		return new MultiEntryPlugin(context, item, name);
@@ -16,6 +24,10 @@ const itemToPlugin = (context, item, name) => {
 };
 
 module.exports = class EntryOptionPlugin {
+	/**
+	 * @param {Compiler} compiler the compiler instance one is tapping into
+	 * @returns {void}
+	 */
 	apply(compiler) {
 		compiler.hooks.entryOption.tap("EntryOptionPlugin", (context, entry) => {
 			if (typeof entry === "string" || Array.isArray(entry)) {

package/lib/Entrypoint.js

@@ -6,7 +6,7 @@
 
 const ChunkGroup = require("./ChunkGroup");
 
-/** @typedef {import("./Chunk.js")} Chunk */
+/** @typedef {import("./Chunk")} Chunk */
 
 /**
  * Entrypoint serves as an encapsulation primitive for chunks that are

package/lib/EnvironmentPlugin.js

@@ -5,6 +5,9 @@
 
 "use strict";
 
+/** @typedef {import("./Compiler")} Compiler */
+
+const WebpackError = require("./WebpackError");
 const DefinePlugin = require("./DefinePlugin");
 
 const needsEnvVarFix =
@@ -25,6 +28,10 @@ class EnvironmentPlugin {
 		}
 	}
 
+	/**
+	 * @param {Compiler} compiler webpack compiler instance
+	 * @returns {void}
+	 */
 	apply(compiler) {
 		const definitions = this.keys.reduce((defs, key) => {
 			// TODO remove once the fix has made its way into Node 8.
@@ -41,7 +48,7 @@ class EnvironmentPlugin {
 
 			if (value === undefined) {
 				compiler.hooks.thisCompilation.tap("EnvironmentPlugin", compilation => {
-					const error = new Error(
+					const error = new WebpackError(
 						`EnvironmentPlugin - ${key} environment variable is undefined.\n\n` +
 							"You can pass an object with default values to suppress this warning.\n" +
 							"See https://webpack.js.org/plugins/environment-plugin for example."

package/lib/ExtendedAPIPlugin.js

@@ -10,12 +10,16 @@ const ParserHelpers = require("./ParserHelpers");
 const NullFactory = require("./NullFactory");
 
 const REPLACEMENTS = {
-	__webpack_hash__: "__webpack_require__.h", // eslint-disable-line camelcase
-	__webpack_chunkname__: "__webpack_require__.cn" // eslint-disable-line camelcase
+	// eslint-disable-next-line camelcase
+	__webpack_hash__: "__webpack_require__.h",
+	// eslint-disable-next-line camelcase
+	__webpack_chunkname__: "__webpack_require__.cn"
 };
 const REPLACEMENT_TYPES = {
-	__webpack_hash__: "string", // eslint-disable-line camelcase
-	__webpack_chunkname__: "string" // eslint-disable-line camelcase
+	// eslint-disable-next-line camelcase
+	__webpack_hash__: "string",
+	// eslint-disable-next-line camelcase
+	__webpack_chunkname__: "string"
 };
 
 class ExtendedAPIPlugin {

package/lib/ExternalModuleFactoryPlugin.js

@@ -64,7 +64,7 @@ class ExternalModuleFactoryPlugin {
 								asyncFlag = true;
 								if (i >= externals.length) return callback();
 								handleExternals(externals[i++], handleExternalsAndCallback);
-							} while (!asyncFlag); // eslint-disable-line keyword-spacing
+							} while (!asyncFlag);
 							asyncFlag = false;
 						};