webpack 4.19.0 → 4.20.2

package/README.md

@@ -11,6 +11,7 @@
 [![deps][deps]][deps-url]
 [![tests][tests]][tests-url]
 [![builds][builds]][builds-url]
+[![builds2][builds2]][builds2-url]
 [![coverage][cover]][cover-url]
 [![licenses][licenses]][licenses-url]
 
@@ -752,6 +753,9 @@ src="https://static.monei.net/monei-logo.svg" height="30" alt="MONEI"></a>
 [builds-url]: https://ci.appveyor.com/project/sokra/webpack/branch/master
 [builds]: https://ci.appveyor.com/api/projects/status/github/webpack/webpack?svg=true
 
+[builds2]: https://dev.azure.com/webpack/webpack/_apis/build/status/webpack.webpack
+[builds2-url]: https://dev.azure.com/webpack/webpack/_build/latest?definitionId=3
+
 [licenses-url]: https://app.fossa.io/projects/git%2Bhttps%3A%2F%2Fgithub.com%2Fwebpack%2Fwebpack?ref=badge_shield
 [licenses]: https://app.fossa.io/api/projects/git%2Bhttps%3A%2F%2Fgithub.com%2Fwebpack%2Fwebpack.svg?type=shield
 

package/lib/AmdMainTemplatePlugin.js

@@ -12,10 +12,10 @@ const Template = require("./Template");
 
 class AmdMainTemplatePlugin {
 	/**
-	 * @param {string} name the library name
+	 * @param {string=} name the library name
 	 */
 	constructor(name) {
-		/** @type {string} */
+		/** @type {string=} */
 		this.name = name;
 	}
 
@@ -79,7 +79,9 @@ class AmdMainTemplatePlugin {
 
 		mainTemplate.hooks.hash.tap("AmdMainTemplatePlugin", hash => {
 			hash.update("exports amd");
-			hash.update(this.name);
+			if (this.name) {
+				hash.update(this.name);
+			}
 		});
 	}
 }

package/lib/BannerPlugin.js

@@ -12,6 +12,9 @@ const Template = require("./Template");
 const validateOptions = require("schema-utils");
 const schema = require("../schemas/plugins/BannerPlugin.json");
 
+/** @typedef {import("../declarations/plugins/BannerPlugin").BannerPluginArgument} BannerPluginArgument */
+/** @typedef {import("../declarations/plugins/BannerPlugin").BannerPluginOptions} BannerPluginOptions */
+
 const wrapComment = str => {
 	if (!str.includes("\n")) {
 		return Template.toComment(str);
@@ -23,6 +26,9 @@ const wrapComment = str => {
 };
 
 class BannerPlugin {
+	/**
+	 * @param {BannerPluginArgument} options options object
+	 */
 	constructor(options) {
 		if (arguments.length > 1) {
 			throw new Error(
@@ -38,17 +44,19 @@ class BannerPlugin {
 			};
 		}
 
-		this.options = options || {};
+		/** @type {BannerPluginOptions} */
+		this.options = options;
 
-		if (typeof options.banner === "function") {
-			const getBanner = this.options.banner;
+		const bannerOption = options.banner;
+		if (typeof bannerOption === "function") {
+			const getBanner = bannerOption;
 			this.banner = this.options.raw
 				? getBanner
 				: data => wrapComment(getBanner(data));
 		} else {
 			const banner = this.options.raw
-				? this.options.banner
-				: wrapComment(this.options.banner);
+				? bannerOption
+				: wrapComment(bannerOption);
 			this.banner = () => banner;
 		}
 	}

package/lib/Chunk.js

@@ -339,6 +339,9 @@ class Chunk {
 		return this._modules.has(module);
 	}
 
+	/**
+	 * @returns {Module[]} an array of modules (do not modify)
+	 */
 	getModules() {
 		return this._modules.getFromCache(getArray);
 	}

package/lib/Compilation.js

@@ -402,7 +402,8 @@ class Compilation extends Tapable {
 		this.inputFileSystem = compiler.inputFileSystem;
 		this.requestShortener = compiler.requestShortener;
 
-		const options = (this.options = compiler.options);
+		const options = compiler.options;
+		this.options = options;
 		this.outputOptions = options && options.output;
 		/** @type {boolean=} */
 		this.bail = options && options.bail;
@@ -2253,24 +2254,28 @@ class Compilation extends Tapable {
 		for (let i = 0; i < chunks.length; i++) {
 			const chunk = chunks[i];
 			const chunkHash = createHash(hashFunction);
-			if (outputOptions.hashSalt) {
-				chunkHash.update(outputOptions.hashSalt);
+			try {
+				if (outputOptions.hashSalt) {
+					chunkHash.update(outputOptions.hashSalt);
+				}
+				chunk.updateHash(chunkHash);
+				const template = chunk.hasRuntime()
+					? this.mainTemplate
+					: this.chunkTemplate;
+				template.updateHashForChunk(
+					chunkHash,
+					chunk,
+					this.moduleTemplates.javascript,
+					this.dependencyTemplates
+				);
+				this.hooks.chunkHash.call(chunk, chunkHash);
+				chunk.hash = chunkHash.digest(hashDigest);
+				hash.update(chunk.hash);
+				chunk.renderedHash = chunk.hash.substr(0, hashDigestLength);
+				this.hooks.contentHash.call(chunk);
+			} catch (err) {
+				this.errors.push(new ChunkRenderError(chunk, "", err));
 			}
-			chunk.updateHash(chunkHash);
-			const template = chunk.hasRuntime()
-				? this.mainTemplate
-				: this.chunkTemplate;
-			template.updateHashForChunk(
-				chunkHash,
-				chunk,
-				this.moduleTemplates.javascript,
-				this.dependencyTemplates
-			);
-			this.hooks.chunkHash.call(chunk, chunkHash);
-			chunk.hash = chunkHash.digest(hashDigest);
-			hash.update(chunk.hash);
-			chunk.renderedHash = chunk.hash.substr(0, hashDigestLength);
-			this.hooks.contentHash.call(chunk);
 		}
 		this.fullHash = hash.digest(hashDigest);
 		this.hash = this.fullHash.substr(0, hashDigestLength);

package/lib/Compiler.js

@@ -27,6 +27,9 @@ const RequestShortener = require("./RequestShortener");
 const { makePathsRelative } = require("./util/identifier");
 const ConcurrentCompilationError = require("./ConcurrentCompilationError");
 
+/** @typedef {import("../declarations/WebpackOptions").Entry} Entry */
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptions} WebpackOptions */
+
 /**
  * @typedef {Object} CompilationParams
  * @property {NormalModuleFactory} normalModuleFactory
@@ -34,16 +37,6 @@ const ConcurrentCompilationError = require("./ConcurrentCompilationError");
  * @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();
@@ -100,7 +93,7 @@ class Compiler extends Tapable {
 			afterPlugins: new SyncHook(["compiler"]),
 			/** @type {SyncHook<Compiler>} */
 			afterResolvers: new SyncHook(["compiler"]),
-			/** @type {SyncBailHook<string, EntryOptions>} */
+			/** @type {SyncBailHook<string, Entry>} */
 			entryOption: new SyncBailHook(["context", "entry"])
 		};
 
@@ -182,7 +175,8 @@ class Compiler extends Tapable {
 			}
 		};
 
-		this.options = {};
+		/** @type {WebpackOptions} */
+		this.options = /** @type {WebpackOptions} */ ({});
 
 		this.context = context;
 

package/lib/DllPlugin.js

@@ -11,7 +11,12 @@ const FlagInitialModulesAsUsedPlugin = require("./FlagInitialModulesAsUsedPlugin
 const validateOptions = require("schema-utils");
 const schema = require("../schemas/plugins/DllPlugin.json");
 
+/** @typedef {import("../declarations/plugins/DllPlugin").DllPluginOptions} DllPluginOptions */
+
 class DllPlugin {
+	/**
+	 * @param {DllPluginOptions} options options object
+	 */
 	constructor(options) {
 		validateOptions(schema, options, "Dll Plugin");
 		this.options = options;

package/lib/DllReferencePlugin.js

@@ -16,7 +16,13 @@ const WebpackError = require("./WebpackError");
 const validateOptions = require("schema-utils");
 const schema = require("../schemas/plugins/DllReferencePlugin.json");
 
+/** @typedef {import("../declarations/plugins/DllReferencePlugin").DllReferencePluginOptions} DllReferencePluginOptions */
+/** @typedef {import("../declarations/plugins/DllReferencePlugin").DllReferencePluginOptionsManifest} DllReferencePluginOptionsManifest */
+
 class DllReferencePlugin {
+	/**
+	 * @param {DllReferencePluginOptions} options options object
+	 */
 	constructor(options) {
 		validateOptions(schema, options, "Dll Reference Plugin");
 		this.options = options;
@@ -40,55 +46,71 @@ class DllReferencePlugin {
 		compiler.hooks.beforeCompile.tapAsync(
 			"DllReferencePlugin",
 			(params, callback) => {
-				const manifest = this.options.manifest;
-				if (typeof manifest === "string") {
-					params.compilationDependencies.add(manifest);
-					compiler.inputFileSystem.readFile(manifest, (err, result) => {
-						if (err) return callback(err);
-						// Catch errors parsing the manifest so that blank
-						// or malformed manifest files don't kill the process.
-						try {
-							params["dll reference " + manifest] = parseJson(
-								result.toString("utf-8")
-							);
-						} catch (e) {
-							// Store the error in the params so that it can
-							// be added as a compilation error later on.
-							const manifestPath = makePathsRelative(
-								compiler.options.context,
-								manifest
-							);
-							params[
-								"dll reference parse error " + manifest
-							] = new DllManifestError(manifestPath, e.message);
-						}
-						return callback();
-					});
-				} else {
-					return callback();
+				if ("manifest" in this.options) {
+					const manifest = this.options.manifest;
+					if (typeof manifest === "string") {
+						params.compilationDependencies.add(manifest);
+						compiler.inputFileSystem.readFile(manifest, (err, result) => {
+							if (err) return callback(err);
+							// Catch errors parsing the manifest so that blank
+							// or malformed manifest files don't kill the process.
+							try {
+								params["dll reference " + manifest] = parseJson(
+									result.toString("utf-8")
+								);
+							} catch (e) {
+								// Store the error in the params so that it can
+								// be added as a compilation error later on.
+								const manifestPath = makePathsRelative(
+									compiler.options.context,
+									manifest
+								);
+								params[
+									"dll reference parse error " + manifest
+								] = new DllManifestError(manifestPath, e.message);
+							}
+							return callback();
+						});
+						return;
+					}
 				}
+				return callback();
 			}
 		);
 
 		compiler.hooks.compile.tap("DllReferencePlugin", params => {
-			let manifest = this.options.manifest;
-			if (typeof manifest === "string") {
-				// If there was an error parsing the manifest
-				// file, exit now because the error will be added
-				// as a compilation error in the "compilation" hook.
-				if (params["dll reference parse error " + manifest]) {
-					return;
+			let name = this.options.name;
+			let sourceType = this.options.sourceType;
+			let content =
+				"content" in this.options ? this.options.content : undefined;
+			if ("manifest" in this.options) {
+				let manifestParameter = this.options.manifest;
+				let manifest;
+				if (typeof manifestParameter === "string") {
+					// If there was an error parsing the manifest
+					// file, exit now because the error will be added
+					// as a compilation error in the "compilation" hook.
+					if (params["dll reference parse error " + manifestParameter]) {
+						return;
+					}
+					manifest =
+						/** @type {DllReferencePluginOptionsManifest} */ (params[
+							"dll reference " + manifestParameter
+						]);
+				} else {
+					manifest = manifestParameter;
+				}
+				if (manifest) {
+					if (!name) name = manifest.name;
+					if (!sourceType) sourceType = manifest.type;
+					if (!content) content = manifest.content;
 				}
-				manifest = params["dll reference " + manifest];
 			}
-			const name = this.options.name || manifest.name;
-			const sourceType =
-				this.options.sourceType || (manifest && manifest.type) || "var";
 			const externals = {};
 			const source = "dll-reference " + name;
 			externals[source] = name;
 			const normalModuleFactory = params.normalModuleFactory;
-			new ExternalModuleFactoryPlugin(sourceType, externals).apply(
+			new ExternalModuleFactoryPlugin(sourceType || "var", externals).apply(
 				normalModuleFactory
 			);
 			new DelegatedModuleFactoryPlugin({
@@ -96,7 +118,7 @@ class DllReferencePlugin {
 				type: this.options.type,
 				scope: this.options.scope,
 				context: this.options.context || compiler.options.context,
-				content: this.options.content || manifest.content,
+				content,
 				extensions: this.options.extensions
 			}).apply(normalModuleFactory);
 		});
@@ -104,13 +126,15 @@ class DllReferencePlugin {
 		compiler.hooks.compilation.tap(
 			"DllReferencePlugin",
 			(compilation, params) => {
-				let manifest = this.options.manifest;
-				if (typeof manifest === "string") {
-					// If there was an error parsing the manifest file, add the
-					// error as a compilation error to make the compilation fail.
-					let e = params["dll reference parse error " + manifest];
-					if (e) {
-						compilation.errors.push(e);
+				if ("manifest" in this.options) {
+					let manifest = this.options.manifest;
+					if (typeof manifest === "string") {
+						// If there was an error parsing the manifest file, add the
+						// error as a compilation error to make the compilation fail.
+						let e = params["dll reference parse error " + manifest];
+						if (e) {
+							compilation.errors.push(e);
+						}
 					}
 				}
 			}

package/lib/DynamicEntryPlugin.js

@@ -10,13 +10,14 @@ const MultiModuleFactory = require("./MultiModuleFactory");
 const MultiEntryPlugin = require("./MultiEntryPlugin");
 const SingleEntryPlugin = require("./SingleEntryPlugin");
 
+/** @typedef {import("../declarations/WebpackOptions").EntryDynamic} EntryDynamic */
+/** @typedef {import("../declarations/WebpackOptions").EntryStatic} EntryStatic */
 /** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Compiler").EntryOptionValuesFunction} EntryOptionValuesFunction */
 
 class DynamicEntryPlugin {
 	/**
 	 * @param {string} context the context path
-	 * @param {EntryOptionValuesFunction} entry the entry value
+	 * @param {EntryDynamic} entry the entry value
 	 */
 	constructor(context, entry) {
 		this.context = context;
@@ -50,7 +51,7 @@ class DynamicEntryPlugin {
 				/**
 				 * @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
+				 * @returns {Promise<EntryStatic>} returns the promise resolving the Compilation#addEntry function
 				 */
 				const addEntry = (entry, name) => {
 					const dep = DynamicEntryPlugin.createDependency(entry, name);

package/lib/EntryOptionPlugin.js

@@ -8,11 +8,12 @@ const SingleEntryPlugin = require("./SingleEntryPlugin");
 const MultiEntryPlugin = require("./MultiEntryPlugin");
 const DynamicEntryPlugin = require("./DynamicEntryPlugin");
 
+/** @typedef {import("../declarations/WebpackOptions").EntryItem} EntryItem */
 /** @typedef {import("./Compiler")} Compiler */
 
 /**
  * @param {string} context context path
- * @param {string | string[]} item entry array or single path
+ * @param {EntryItem} item entry array or single path
  * @param {string} name entry key name
  * @returns {SingleEntryPlugin | MultiEntryPlugin} returns either a single or multi entry plugin
  */

package/lib/ExternalModule.js

@@ -74,7 +74,9 @@ class ExternalModule extends Module {
 			.slice(1)
 			.map(r => `[${JSON.stringify(r)}]`)
 			.join("");
-		return `module.exports = require(${moduleName})${objectLookup};`;
+		return `module.exports = require(${JSON.stringify(
+			moduleName
+		)})${objectLookup};`;
 	}
 
 	checkExternalVariable(variableToCheck, request) {
@@ -94,15 +96,25 @@ class ExternalModule extends Module {
 	}
 
 	getSourceForDefaultCase(optional, request) {
+		if (!Array.isArray(request)) {
+			// make it an array as the look up works the same basically
+			request = [request];
+		}
+
+		const variableName = request[0];
 		const missingModuleError = optional
-			? this.checkExternalVariable(request, request)
+			? this.checkExternalVariable(variableName, request.join("."))
 			: "";
-		return `${missingModuleError}module.exports = ${request};`;
+		const objectLookup = request
+			.slice(1)
+			.map(r => `[${JSON.stringify(r)}]`)
+			.join("");
+		return `${missingModuleError}module.exports = ${variableName}${objectLookup};`;
 	}
 
 	getSourceString(runtime) {
 		const request =
-			typeof this.request === "object"
+			typeof this.request === "object" && !Array.isArray(this.request)
 				? this.request[this.externalType]
 				: this.request;
 		switch (this.externalType) {

package/lib/HashedModuleIdsPlugin.js

@@ -8,10 +8,18 @@ const createHash = require("./util/createHash");
 const validateOptions = require("schema-utils");
 const schema = require("../schemas/plugins/HashedModuleIdsPlugin.json");
 
+/** @typedef {import("../declarations/plugins/HashedModuleIdsPlugin").HashedModuleIdsPluginOptions} HashedModuleIdsPluginOptions */
+
 class HashedModuleIdsPlugin {
+	/**
+	 * @param {HashedModuleIdsPluginOptions=} options options object
+	 */
 	constructor(options) {
-		validateOptions(schema, options || {}, "Hashed Module Ids Plugin");
+		if (!options) options = {};
+
+		validateOptions(schema, options, "Hashed Module Ids Plugin");
 
+		/** @type {HashedModuleIdsPluginOptions} */
 		this.options = Object.assign(
 			{
 				context: null,

package/lib/HotUpdateChunk.js

@@ -9,6 +9,7 @@ const Chunk = require("./Chunk");
 class HotUpdateChunk extends Chunk {
 	constructor() {
 		super();
+		/** @type {(string|number)[]} */
 		this.removedModules = undefined;
 	}
 }

package/lib/IgnorePlugin.js

@@ -7,15 +7,12 @@
 const validateOptions = require("schema-utils");
 const schema = require("../schemas/plugins/IgnorePlugin.json");
 
+/** @typedef {import("../declarations/plugins/IgnorePlugin").IgnorePluginOptions} IgnorePluginOptions */
 /** @typedef {import("./Compiler")} Compiler */
 
 class IgnorePlugin {
 	/**
-	 * @param {object} options IgnorePlugin options
-	 * @param {RegExp} options.resourceRegExp - A RegExp to test the request against
-	 * @param {RegExp} options.contextRegExp - A RegExp to test the context (directory) against
-	 * @param {function(string): boolean=} options.checkResource - A filter function for resource
-	 * @param {function(string): boolean=} options.checkContext - A filter function for context
+	 * @param {IgnorePluginOptions} options IgnorePlugin options
 	 */
 	constructor(options) {
 		// TODO webpack 5 remove this compat-layer
@@ -39,13 +36,13 @@ class IgnorePlugin {
 	 * and the resource given matches the regexp.
 	 */
 	checkResource(resource) {
-		if (this.options.checkResource) {
+		if ("checkResource" in this.options && this.options.checkResource) {
 			return this.options.checkResource(resource);
 		}
-		if (!this.options.resourceRegExp) {
-			return false;
+		if ("resourceRegExp" in this.options && this.options.resourceRegExp) {
+			return this.options.resourceRegExp.test(resource);
 		}
-		return this.options.resourceRegExp.test(resource);
+		return false;
 	}
 
 	/**
@@ -54,14 +51,13 @@ class IgnorePlugin {
 	 * or if context matches the given regexp.
 	 */
 	checkContext(context) {
-		if (this.options.checkContext) {
+		if ("checkContext" in this.options && this.options.checkContext) {
 			return this.options.checkContext(context);
 		}
-
-		if (!this.options.contextRegExp) {
-			return true;
+		if ("contextRegExp" in this.options && this.options.contextRegExp) {
+			return this.options.contextRegExp.test(context);
 		}
-		return this.options.contextRegExp.test(context);
+		return true;
 	}
 
 	/**

package/lib/LibraryTemplatePlugin.js

@@ -6,6 +6,7 @@
 
 const SetVarMainTemplatePlugin = require("./SetVarMainTemplatePlugin");
 
+/** @typedef {import("../declarations/WebpackOptions").LibraryCustomUmdObject} LibraryCustomUmdObject */
 /** @typedef {import("./Compiler")} Compiler */
 
 /**
@@ -18,12 +19,17 @@ const accessorToObjectAccess = accessor => {
 
 /**
  * @param {string=} base the path prefix
- * @param {string|string[]} accessor the accessor
+ * @param {string|string[]|LibraryCustomUmdObject} accessor the accessor
+ * @param {"amd" | "commonjs" | "root"} umdProperty property used when a custom umd object is provided
  * @param {string=} joinWith the element separator
  * @returns {string} the path
  */
-const accessorAccess = (base, accessor, joinWith = "; ") => {
-	const accessors = Array.isArray(accessor) ? accessor : [accessor];
+const accessorAccess = (base, accessor, umdProperty, joinWith = "; ") => {
+	const normalizedAccessor =
+		typeof accessor === "object" ? accessor[umdProperty] : accessor;
+	const accessors = Array.isArray(normalizedAccessor)
+		? normalizedAccessor
+		: [normalizedAccessor];
 	return accessors
 		.map((_, idx) => {
 			const a = base
@@ -40,7 +46,7 @@ const accessorAccess = (base, accessor, joinWith = "; ") => {
 
 class LibraryTemplatePlugin {
 	/**
-	 * @param {string} name name of library
+	 * @param {string|string[]|LibraryCustomUmdObject} name name of library
 	 * @param {string} target type of library
 	 * @param {boolean} umdNamedDefine setting this to true will name the UMD module
 	 * @param {string|TODO} auxiliaryComment comment in the UMD wrapper
@@ -68,14 +74,22 @@ class LibraryTemplatePlugin {
 			}
 			switch (this.target) {
 				case "var":
+					if (
+						!this.name ||
+						(typeof this.name === "object" && !Array.isArray(this.name))
+					) {
+						throw new Error(
+							"library name must be set and not an UMD custom object for non-UMD target"
+						);
+					}
 					new SetVarMainTemplatePlugin(
-						`var ${accessorAccess(undefined, this.name)}`,
+						`var ${accessorAccess(undefined, this.name, "root")}`,
 						false
 					).apply(compilation);
 					break;
 				case "assign":
 					new SetVarMainTemplatePlugin(
-						accessorAccess(undefined, this.name),
+						accessorAccess(undefined, this.name, "root"),
 						false
 					).apply(compilation);
 					break;
@@ -84,7 +98,7 @@ class LibraryTemplatePlugin {
 				case "window":
 					if (this.name) {
 						new SetVarMainTemplatePlugin(
-							accessorAccess(this.target, this.name),
+							accessorAccess(this.target, this.name, "root"),
 							false
 						).apply(compilation);
 					} else {
@@ -96,7 +110,8 @@ class LibraryTemplatePlugin {
 						new SetVarMainTemplatePlugin(
 							accessorAccess(
 								compilation.runtimeTemplate.outputOptions.globalObject,
-								this.name
+								this.name,
+								"root"
 							),
 							false
 						).apply(compilation);
@@ -110,7 +125,7 @@ class LibraryTemplatePlugin {
 				case "commonjs":
 					if (this.name) {
 						new SetVarMainTemplatePlugin(
-							accessorAccess("exports", this.name),
+							accessorAccess("exports", this.name, "commonjs"),
 							false
 						).apply(compilation);
 					} else {
@@ -125,7 +140,13 @@ class LibraryTemplatePlugin {
 					break;
 				case "amd": {
 					const AmdMainTemplatePlugin = require("./AmdMainTemplatePlugin");
-					new AmdMainTemplatePlugin(this.name).apply(compilation);
+					if (this.name) {
+						if (typeof this.name !== "string")
+							throw new Error("library name must be a string for amd target");
+						new AmdMainTemplatePlugin(this.name).apply(compilation);
+					} else {
+						new AmdMainTemplatePlugin().apply(compilation);
+					}
 					break;
 				}
 				case "umd":
@@ -140,6 +161,8 @@ class LibraryTemplatePlugin {
 				}
 				case "jsonp": {
 					const JsonpExportMainTemplatePlugin = require("./web/JsonpExportMainTemplatePlugin");
+					if (typeof this.name !== "string")
+						throw new Error("library name must be a string for jsonp target");
 					new JsonpExportMainTemplatePlugin(this.name).apply(compilation);
 					break;
 				}

package/lib/LoaderOptionsPlugin.js

@@ -9,7 +9,12 @@ const ModuleFilenameHelpers = require("./ModuleFilenameHelpers");
 const validateOptions = require("schema-utils");
 const schema = require("../schemas/plugins/LoaderOptionsPlugin.json");
 
+/** @typedef {import("../declarations/plugins/LoaderOptionsPlugin").LoaderOptionsPluginOptions} LoaderOptionsPluginOptions */
+
 class LoaderOptionsPlugin {
+	/**
+	 * @param {LoaderOptionsPluginOptions} options options object
+	 */
 	constructor(options) {
 		validateOptions(schema, options || {}, "Loader Options Plugin");