webpack 4.14.0 → 4.15.1

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,12 +3,12 @@
 	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 */
 
@@ -63,18 +63,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 +143,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 +151,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 + "")}`;

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/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

@@ -7,22 +7,43 @@
 const compareLocations = require("./compareLocations");
 const DependencyReference = require("./dependencies/DependencyReference");
 
-/** @typedef {Object} Position
+/** @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} column
  *  @property {number} line
  */
 
-/** @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;
 	}
 

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/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;
 						};
 

package/lib/GraphHelpers.js

@@ -2,6 +2,7 @@
 /** @typedef {import("./ChunkGroup")} ChunkGroup */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./DependenciesBlock")} DependenciesBlock */
+/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
 
 /**
  * @param {ChunkGroup} chunkGroup the ChunkGroup to connect
@@ -47,7 +48,7 @@ const disconnectChunkAndModule = (chunk, module) => {
 };
 
 /**
- * @param {DependenciesBlock} depBlock DepBlock being tied to ChunkGroup
+ * @param {AsyncDependenciesBlock} depBlock DepBlock being tied to ChunkGroup
  * @param {ChunkGroup} chunkGroup ChunkGroup being tied to DepBlock
  * @returns {void}
  */

package/lib/HotModuleReplacement.runtime.js

@@ -5,12 +5,15 @@
 /*global $hash$ $requestTimeout$ installedModules $require$ hotDownloadManifest hotDownloadUpdateChunk hotDisposeChunk modules */
 module.exports = function() {
 	var hotApplyOnUpdate = true;
-	var hotCurrentHash = $hash$; // eslint-disable-line no-unused-vars
+	// eslint-disable-next-line no-unused-vars
+	var hotCurrentHash = $hash$;
 	var hotRequestTimeout = $requestTimeout$;
 	var hotCurrentModuleData = {};
-	var hotCurrentChildModule; // eslint-disable-line no-unused-vars
-	var hotCurrentParents = []; // eslint-disable-line no-unused-vars
-	var hotCurrentParentsTemp = []; // eslint-disable-line no-unused-vars
+	var hotCurrentChildModule;
+	// eslint-disable-next-line no-unused-vars
+	var hotCurrentParents = [];
+	// eslint-disable-next-line no-unused-vars
+	var hotCurrentParentsTemp = [];
 
 	// eslint-disable-next-line no-unused-vars
 	function hotCreateRequire(moduleId) {
@@ -199,8 +202,8 @@ module.exports = function() {
 			});
 			hotUpdate = {};
 			/*foreachInstalledChunks*/
+			// eslint-disable-next-line no-lone-blocks
 			{
-				// eslint-disable-line no-lone-blocks
 				/*globals chunkId */
 				hotEnsureUpdateChunk(chunkId);
 			}