webpack 5.59.0 → 5.94.0

package/lib/sharing/ProvideSharedPlugin.js

@@ -15,6 +15,7 @@ const ProvideSharedModuleFactory = require("./ProvideSharedModuleFactory");
 /** @typedef {import("../../declarations/plugins/sharing/ProvideSharedPlugin").ProvideSharedPluginOptions} ProvideSharedPluginOptions */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../NormalModuleFactory").NormalModuleCreateData} NormalModuleCreateData */
 
 const validate = createSchemaValidation(
 	require("../../schemas/plugins/sharing/ProvideSharedPlugin.check.js"),
@@ -26,7 +27,7 @@ const validate = createSchemaValidation(
 );
 
 /**
- * @typedef {Object} ProvideOptions
+ * @typedef {object} ProvideOptions
  * @property {string} shareKey
  * @property {string} shareScope
  * @property {string | undefined | false} version
@@ -42,27 +43,28 @@ class ProvideSharedPlugin {
 	constructor(options) {
 		validate(options);
 
-		/** @type {[string, ProvideOptions][]} */
-		this._provides = parseOptions(
-			options.provides,
-			item => {
-				if (Array.isArray(item))
-					throw new Error("Unexpected array of provides");
-				/** @type {ProvideOptions} */
-				const result = {
-					shareKey: item,
-					version: undefined,
-					shareScope: options.shareScope || "default",
-					eager: false
-				};
-				return result;
-			},
-			item => ({
-				shareKey: item.shareKey,
-				version: item.version,
-				shareScope: item.shareScope || options.shareScope || "default",
-				eager: !!item.eager
-			})
+		this._provides = /** @type {[string, ProvideOptions][]} */ (
+			parseOptions(
+				options.provides,
+				item => {
+					if (Array.isArray(item))
+						throw new Error("Unexpected array of provides");
+					/** @type {ProvideOptions} */
+					const result = {
+						shareKey: item,
+						version: undefined,
+						shareScope: options.shareScope || "default",
+						eager: false
+					};
+					return result;
+				},
+				item => ({
+					shareKey: item.shareKey,
+					version: item.version,
+					shareScope: item.shareScope || options.shareScope || "default",
+					eager: Boolean(item.eager)
+				})
+			)
 		);
 		this._provides.sort(([a], [b]) => {
 			if (a < b) return -1;
@@ -111,6 +113,12 @@ class ProvideSharedPlugin {
 					}
 				}
 				compilationData.set(compilation, resolvedProvideMap);
+				/**
+				 * @param {string} key key
+				 * @param {ProvideOptions} config config
+				 * @param {NormalModuleCreateData["resource"]} resource resource
+				 * @param {NormalModuleCreateData["resourceResolveData"]} resourceResolveData resource resolve data
+				 */
 				const provideSharedModule = (
 					key,
 					config,
@@ -121,7 +129,7 @@ class ProvideSharedPlugin {
 					if (version === undefined) {
 						let details = "";
 						if (!resourceResolveData) {
-							details = `No resolve data provided from resolver.`;
+							details = "No resolve data provided from resolver.";
 						} else {
 							const descriptionFileData =
 								resourceResolveData.descriptionFileData;
@@ -129,8 +137,7 @@ class ProvideSharedPlugin {
 								details =
 									"No description file (usually package.json) found. Add description file with name and version, or manually specify version in shared config.";
 							} else if (!descriptionFileData.version) {
-								details =
-									"No version in description file (usually package.json). Add version to description file, or manually specify version in shared config.";
+								details = `No version in description file (usually package.json). Add version to description file ${resourceResolveData.descriptionFilePath}, or manually specify version in shared config.`;
 							} else {
 								version = descriptionFileData.version;
 							}
@@ -151,7 +158,7 @@ class ProvideSharedPlugin {
 				normalModuleFactory.hooks.module.tap(
 					"ProvideSharedPlugin",
 					(module, { resource, resourceResolveData }, resolveData) => {
-						if (resolvedProvideMap.has(resource)) {
+						if (resolvedProvideMap.has(/** @type {string} */ (resource))) {
 							return module;
 						}
 						const { request } = resolveData;
@@ -161,7 +168,7 @@ class ProvideSharedPlugin {
 								provideSharedModule(
 									request,
 									config,
-									resource,
+									/** @type {string} */ (resource),
 									resourceResolveData
 								);
 								resolveData.cacheable = false;
@@ -171,12 +178,12 @@ class ProvideSharedPlugin {
 							if (request.startsWith(prefix)) {
 								const remainder = request.slice(prefix.length);
 								provideSharedModule(
-									resource,
+									/** @type {string} */ (resource),
 									{
 										...config,
 										shareKey: config.shareKey + remainder
 									},
-									resource,
+									/** @type {string} */ (resource),
 									resourceResolveData
 								);
 								resolveData.cacheable = false;
@@ -209,7 +216,7 @@ class ProvideSharedPlugin {
 								},
 								err => {
 									if (err) return reject(err);
-									resolve();
+									resolve(null);
 								}
 							);
 						})

package/lib/sharing/SharePlugin.js

@@ -34,11 +34,11 @@ class SharePlugin {
 					item === key || !isRequiredVersion(item)
 						? {
 								import: item
-						  }
+							}
 						: {
 								import: key,
 								requiredVersion: item
-						  };
+							};
 				return config;
 			},
 			item => item

package/lib/sharing/ShareRuntimeModule.js

@@ -13,24 +13,31 @@ const {
 	compareStrings
 } = require("../util/comparators");
 
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Compilation")} Compilation */
+
 class ShareRuntimeModule extends RuntimeModule {
 	constructor() {
 		super("sharing");
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { compilation, chunkGraph } = this;
+		const compilation = /** @type {Compilation} */ (this.compilation);
 		const {
 			runtimeTemplate,
 			codeGenerationResults,
-			outputOptions: { uniqueName }
+			outputOptions: { uniqueName, ignoreBrowserWarnings }
 		} = compilation;
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
 		/** @type {Map<string, Map<number, Set<string>>>} */
 		const initCodePerScope = new Map();
-		for (const chunk of this.chunk.getAllReferencedChunks()) {
+		for (const chunk of /** @type {Chunk} */ (
+			this.chunk
+		).getAllReferencedChunks()) {
 			const modules = chunkGraph.getOrderedChunkModulesIterableBySourceType(
 				chunk,
 				"share-init",
@@ -77,10 +84,13 @@ class ShareRuntimeModule extends RuntimeModule {
 					`if(!${RuntimeGlobals.hasOwnProperty}(${RuntimeGlobals.shareScopeMap}, name)) ${RuntimeGlobals.shareScopeMap}[name] = {};`,
 					"// runs all init snippets from all modules reachable",
 					`var scope = ${RuntimeGlobals.shareScopeMap}[name];`,
-					`var warn = ${runtimeTemplate.returningFunction(
-						'typeof console !== "undefined" && console.warn && console.warn(msg)',
-						"msg"
-					)};`,
+					`var warn = ${
+						ignoreBrowserWarnings
+							? runtimeTemplate.basicFunction("", "")
+							: runtimeTemplate.basicFunction("msg", [
+									'if (typeof console !== "undefined" && console.warn) console.warn(msg);'
+								])
+					};`,
 					`var uniqueName = ${JSON.stringify(uniqueName || undefined)};`,
 					`var register = ${runtimeTemplate.basicFunction(
 						"name, version, factory, eager",
@@ -97,7 +107,7 @@ class ShareRuntimeModule extends RuntimeModule {
 						)};`,
 						"try {",
 						Template.indent([
-							"var module = __webpack_require__(id);",
+							`var module = ${RuntimeGlobals.require}(id);`,
 							"if(!module) return;",
 							`var initFn = ${runtimeTemplate.returningFunction(
 								`module && module.init && module.init(${RuntimeGlobals.shareScopeMap}[name], initScope)`,
@@ -105,7 +115,7 @@ class ShareRuntimeModule extends RuntimeModule {
 							)}`,
 							"if(module.then) return promises.push(module.then(initFn, handleError));",
 							"var initResult = initFn(module);",
-							"if(initResult && initResult.then) return promises.push(initResult.catch(handleError));"
+							"if(initResult && initResult.then) return promises.push(initResult['catch'](handleError));"
 						]),
 						"} catch(err) { handleError(err); }"
 					])}`,

package/lib/sharing/resolveMatchedConfigs.js

@@ -13,7 +13,7 @@ const LazySet = require("../util/LazySet");
 
 /**
  * @template T
- * @typedef {Object} MatchedConfigs
+ * @typedef {object} MatchedConfigs
  * @property {Map<string, T>} resolved
  * @property {Map<string, T>} unresolved
  * @property {Map<string, T>} prefixed
@@ -28,7 +28,7 @@ const RESOLVE_OPTIONS = { dependencyType: "esm" };
  * @param {[string, T][]} configs to be processed configs
  * @returns {Promise<MatchedConfigs<T>>} resolved matchers
  */
-exports.resolveMatchedConfigs = (compilation, configs) => {
+module.exports.resolveMatchedConfigs = (compilation, configs) => {
 	/** @type {Map<string, T>} */
 	const resolved = new Map();
 	/** @type {Map<string, T>} */
@@ -47,6 +47,7 @@ exports.resolveMatchedConfigs = (compilation, configs) => {
 	const context = compilation.compiler.context;
 
 	return Promise.all(
+		// eslint-disable-next-line array-callback-return
 		configs.map(([request, config]) => {
 			if (/^\.\.?(\/|$)/.test(request)) {
 				// relative request
@@ -64,10 +65,10 @@ exports.resolveMatchedConfigs = (compilation, configs) => {
 										name: `shared module ${request}`
 									})
 								);
-								return resolve();
+								return resolve(null);
 							}
-							resolved.set(result, config);
-							resolve();
+							resolved.set(/** @type {string} */ (result), config);
+							resolve(null);
 						}
 					);
 				});

package/lib/sharing/utils.js

@@ -8,21 +8,325 @@
 const { join, dirname, readJson } = require("../util/fs");
 
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("../util/fs").JsonObject} JsonObject */
+/** @typedef {import("../util/fs").JsonPrimitive} JsonPrimitive */
+
+// Extreme shorthand only for github. eg: foo/bar
+const RE_URL_GITHUB_EXTREME_SHORT = /^[^/@:.\s][^/@:\s]*\/[^@:\s]*[^/@:\s]#\S+/;
+
+// Short url with specific protocol. eg: github:foo/bar
+const RE_GIT_URL_SHORT = /^(github|gitlab|bitbucket|gist):\/?[^/.]+\/?/i;
+
+// Currently supported protocols
+const RE_PROTOCOL =
+	/^((git\+)?(ssh|https?|file)|git|github|gitlab|bitbucket|gist):$/i;
+
+// Has custom protocol
+const RE_CUSTOM_PROTOCOL = /^((git\+)?(ssh|https?|file)|git):\/\//i;
+
+// Valid hash format for npm / yarn ...
+const RE_URL_HASH_VERSION = /#(?:semver:)?(.+)/;
+
+// Simple hostname validate
+const RE_HOSTNAME = /^(?:[^/.]+(\.[^/]+)+|localhost)$/;
+
+// For hostname with colon. eg: ssh://user@github.com:foo/bar
+const RE_HOSTNAME_WITH_COLON =
+	/([^/@#:.]+(?:\.[^/@#:.]+)+|localhost):([^#/0-9]+)/;
+
+// Reg for url without protocol
+const RE_NO_PROTOCOL = /^([^/@#:.]+(?:\.[^/@#:.]+)+)/;
+
+// RegExp for version string
+const VERSION_PATTERN_REGEXP = /^([\d^=v<>~]|[*xX]$)/;
+
+// Specific protocol for short url without normal hostname
+const PROTOCOLS_FOR_SHORT = [
+	"github:",
+	"gitlab:",
+	"bitbucket:",
+	"gist:",
+	"file:"
+];
+
+// Default protocol for git url
+const DEF_GIT_PROTOCOL = "git+ssh://";
+
+// thanks to https://github.com/npm/hosted-git-info/blob/latest/git-host-info.js
+const extractCommithashByDomain = {
+	/**
+	 * @param {string} pathname pathname
+	 * @param {string} hash hash
+	 * @returns {string | undefined} hash
+	 */
+	"github.com": (pathname, hash) => {
+		let [, user, project, type, commithash] = pathname.split("/", 5);
+		if (type && type !== "tree") {
+			return;
+		}
+
+		commithash = !type ? hash : `#${commithash}`;
+
+		if (project && project.endsWith(".git")) {
+			project = project.slice(0, -4);
+		}
+
+		if (!user || !project) {
+			return;
+		}
+
+		return commithash;
+	},
+	/**
+	 * @param {string} pathname pathname
+	 * @param {string} hash hash
+	 * @returns {string | undefined} hash
+	 */
+	"gitlab.com": (pathname, hash) => {
+		const path = pathname.slice(1);
+		if (path.includes("/-/") || path.includes("/archive.tar.gz")) {
+			return;
+		}
+
+		const segments = path.split("/");
+		let project = /** @type {string} */ (segments.pop());
+		if (project.endsWith(".git")) {
+			project = project.slice(0, -4);
+		}
+
+		const user = segments.join("/");
+		if (!user || !project) {
+			return;
+		}
+
+		return hash;
+	},
+	/**
+	 * @param {string} pathname pathname
+	 * @param {string} hash hash
+	 * @returns {string | undefined} hash
+	 */
+	"bitbucket.org": (pathname, hash) => {
+		let [, user, project, aux] = pathname.split("/", 4);
+		if (["get"].includes(aux)) {
+			return;
+		}
+
+		if (project && project.endsWith(".git")) {
+			project = project.slice(0, -4);
+		}
+
+		if (!user || !project) {
+			return;
+		}
+
+		return hash;
+	},
+	/**
+	 * @param {string} pathname pathname
+	 * @param {string} hash hash
+	 * @returns {string | undefined} hash
+	 */
+	"gist.github.com": (pathname, hash) => {
+		let [, user, project, aux] = pathname.split("/", 4);
+		if (aux === "raw") {
+			return;
+		}
+
+		if (!project) {
+			if (!user) {
+				return;
+			}
+
+			project = user;
+		}
+
+		if (project.endsWith(".git")) {
+			project = project.slice(0, -4);
+		}
+
+		return hash;
+	}
+};
+
+/**
+ * extract commit hash from parsed url
+ * @inner
+ * @param {URL} urlParsed parsed url
+ * @returns {string} commithash
+ */
+function getCommithash(urlParsed) {
+	let { hostname, pathname, hash } = urlParsed;
+	hostname = hostname.replace(/^www\./, "");
+
+	try {
+		hash = decodeURIComponent(hash);
+		// eslint-disable-next-line no-empty
+	} catch (_err) {}
+
+	if (
+		extractCommithashByDomain[
+			/** @type {keyof extractCommithashByDomain} */ (hostname)
+		]
+	) {
+		return (
+			extractCommithashByDomain[
+				/** @type {keyof extractCommithashByDomain} */ (hostname)
+			](pathname, hash) || ""
+		);
+	}
+
+	return hash;
+}
+
+/**
+ * make url right for URL parse
+ * @inner
+ * @param {string} gitUrl git url
+ * @returns {string} fixed url
+ */
+function correctUrl(gitUrl) {
+	// like:
+	// proto://hostname.com:user/repo -> proto://hostname.com/user/repo
+	return gitUrl.replace(RE_HOSTNAME_WITH_COLON, "$1/$2");
+}
+
+/**
+ * make url protocol right for URL parse
+ * @inner
+ * @param {string} gitUrl git url
+ * @returns {string} fixed url
+ */
+function correctProtocol(gitUrl) {
+	// eg: github:foo/bar#v1.0. Should not add double slash, in case of error parsed `pathname`
+	if (RE_GIT_URL_SHORT.test(gitUrl)) {
+		return gitUrl;
+	}
+
+	// eg: user@github.com:foo/bar
+	if (!RE_CUSTOM_PROTOCOL.test(gitUrl)) {
+		return `${DEF_GIT_PROTOCOL}${gitUrl}`;
+	}
+
+	return gitUrl;
+}
+
+/**
+ * extract git dep version from hash
+ * @inner
+ * @param {string} hash hash
+ * @returns {string} git dep version
+ */
+function getVersionFromHash(hash) {
+	const matched = hash.match(RE_URL_HASH_VERSION);
+
+	return (matched && matched[1]) || "";
+}
+
+/**
+ * if string can be decoded
+ * @inner
+ * @param {string} str str to be checked
+ * @returns {boolean} if can be decoded
+ */
+function canBeDecoded(str) {
+	try {
+		decodeURIComponent(str);
+	} catch (_err) {
+		return false;
+	}
+
+	return true;
+}
+
+/**
+ * get right dep version from git url
+ * @inner
+ * @param {string} gitUrl git url
+ * @returns {string} dep version
+ */
+function getGitUrlVersion(gitUrl) {
+	const oriGitUrl = gitUrl;
+	// github extreme shorthand
+	gitUrl = RE_URL_GITHUB_EXTREME_SHORT.test(gitUrl)
+		? `github:${gitUrl}`
+		: correctProtocol(gitUrl);
+
+	gitUrl = correctUrl(gitUrl);
+
+	let parsed;
+	try {
+		parsed = new URL(gitUrl);
+		// eslint-disable-next-line no-empty
+	} catch (_err) {}
+
+	if (!parsed) {
+		return "";
+	}
+
+	const { protocol, hostname, pathname, username, password } = parsed;
+	if (!RE_PROTOCOL.test(protocol)) {
+		return "";
+	}
+
+	// pathname shouldn't be empty or URL malformed
+	if (!pathname || !canBeDecoded(pathname)) {
+		return "";
+	}
+
+	// without protocol, there should have auth info
+	if (RE_NO_PROTOCOL.test(oriGitUrl) && !username && !password) {
+		return "";
+	}
+
+	if (!PROTOCOLS_FOR_SHORT.includes(protocol.toLowerCase())) {
+		if (!RE_HOSTNAME.test(hostname)) {
+			return "";
+		}
+
+		const commithash = getCommithash(parsed);
+		return getVersionFromHash(commithash) || commithash;
+	}
+
+	// for protocol short
+	return getVersionFromHash(gitUrl);
+}
 
 /**
  * @param {string} str maybe required version
  * @returns {boolean} true, if it looks like a version
  */
-exports.isRequiredVersion = str => {
-	return /^([\d^=v<>~]|[*xX]$)/.test(str);
-};
+function isRequiredVersion(str) {
+	return VERSION_PATTERN_REGEXP.test(str);
+}
+
+module.exports.isRequiredVersion = isRequiredVersion;
+
+/**
+ * @see https://docs.npmjs.com/cli/v7/configuring-npm/package-json#urls-as-dependencies
+ * @param {string} versionDesc version to be normalized
+ * @returns {string} normalized version
+ */
+function normalizeVersion(versionDesc) {
+	versionDesc = (versionDesc && versionDesc.trim()) || "";
+
+	if (isRequiredVersion(versionDesc)) {
+		return versionDesc;
+	}
+
+	// add handle for URL Dependencies
+	return getGitUrlVersion(versionDesc.toLowerCase());
+}
+
+module.exports.normalizeVersion = normalizeVersion;
+
+/** @typedef {{ data: JsonObject, path: string }} DescriptionFile */
 
 /**
- *
  * @param {InputFileSystem} fs file system
  * @param {string} directory directory to start looking into
  * @param {string[]} descriptionFiles possible description filenames
- * @param {function(Error=, {data: object, path: string}=): void} callback callback
+ * @param {function((Error | null)=, DescriptionFile=): void} callback callback
  */
 const getDescriptionFile = (fs, directory, descriptionFiles, callback) => {
 	let i = 0;
@@ -56,35 +360,35 @@ const getDescriptionFile = (fs, directory, descriptionFiles, callback) => {
 	};
 	tryLoadCurrent();
 };
-exports.getDescriptionFile = getDescriptionFile;
+module.exports.getDescriptionFile = getDescriptionFile;
 
-exports.getRequiredVersionFromDescriptionFile = (data, packageName) => {
-	if (
-		data.optionalDependencies &&
-		typeof data.optionalDependencies === "object" &&
-		packageName in data.optionalDependencies
-	) {
-		return data.optionalDependencies[packageName];
-	}
-	if (
-		data.dependencies &&
-		typeof data.dependencies === "object" &&
-		packageName in data.dependencies
-	) {
-		return data.dependencies[packageName];
-	}
-	if (
-		data.peerDependencies &&
-		typeof data.peerDependencies === "object" &&
-		packageName in data.peerDependencies
-	) {
-		return data.peerDependencies[packageName];
-	}
-	if (
-		data.devDependencies &&
-		typeof data.devDependencies === "object" &&
-		packageName in data.devDependencies
-	) {
-		return data.devDependencies[packageName];
+/**
+ * @param {JsonObject} data description file data i.e.: package.json
+ * @param {string} packageName name of the dependency
+ * @returns {string | undefined} normalized version
+ */
+const getRequiredVersionFromDescriptionFile = (data, packageName) => {
+	const dependencyTypes = [
+		"optionalDependencies",
+		"dependencies",
+		"peerDependencies",
+		"devDependencies"
+	];
+
+	for (const dependencyType of dependencyTypes) {
+		const dependency = /** @type {JsonObject} */ (data[dependencyType]);
+		if (
+			dependency &&
+			typeof dependency === "object" &&
+			packageName in dependency
+		) {
+			return normalizeVersion(
+				/** @type {Exclude<JsonPrimitive, null | boolean| number>} */ (
+					dependency[packageName]
+				)
+			);
+		}
 	}
 };
+module.exports.getRequiredVersionFromDescriptionFile =
+	getRequiredVersionFromDescriptionFile;