@depup/webpack 5.106.1-depup.0 → 5.109.2-depup.0

package/lib/ExternalModuleFactoryPlugin.js

@@ -7,11 +7,13 @@
 
 const util = require("util");
 const ExternalModule = require("./ExternalModule");
+const { ASSET_URL_TYPE } = require("./ModuleSourceTypeConstants");
 const ContextElementDependency = require("./dependencies/ContextElementDependency");
 const CssImportDependency = require("./dependencies/CssImportDependency");
 const CssUrlDependency = require("./dependencies/CssUrlDependency");
 const HarmonyImportDependency = require("./dependencies/HarmonyImportDependency");
 const ImportDependency = require("./dependencies/ImportDependency");
+const { coreModules } = require("./node/nodeBuiltins");
 const { cachedSetProperty, resolveByProperty } = require("./util/cleverMerge");
 
 /** @typedef {import("enhanced-resolve").ResolveContext} ResolveContext */
@@ -21,6 +23,7 @@ const { cachedSetProperty, resolveByProperty } = require("./util/cleverMerge");
 /** @typedef {import("../declarations/WebpackOptions").ExternalItemValue} ExternalItemValue */
 /** @typedef {import("../declarations/WebpackOptions").ExternalItemObjectKnown} ExternalItemObjectKnown */
 /** @typedef {import("../declarations/WebpackOptions").ExternalItemObjectUnknown} ExternalItemObjectUnknown */
+/** @typedef {import("../declarations/WebpackOptions").ExternalItemInterop} ExternalItemInterop */
 /** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
 /** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./ExternalModule").DependencyMeta} DependencyMeta */
@@ -33,6 +36,7 @@ const { cachedSetProperty, resolveByProperty } = require("./util/cleverMerge");
 /** @typedef {(options?: ResolveOptions) => ExternalItemFunctionDataGetResolveCallbackResult | ExternalItemFunctionDataGetResolveResult} ExternalItemFunctionDataGetResolve */
 
 /**
+ * Defines the external item function data type used by this module.
  * @typedef {object} ExternalItemFunctionData
  * @property {string} context the directory in which the request is placed
  * @property {ModuleFactoryCreateDataContextInfo} contextInfo contextual information
@@ -46,10 +50,26 @@ const { cachedSetProperty, resolveByProperty } = require("./util/cleverMerge");
 
 const UNSPECIFIED_EXTERNAL_TYPE_REGEXP = /^[a-z0-9-]+ /;
 const EMPTY_RESOLVE_OPTIONS = {};
+const NODE_PREFIX = "node:";
+
+/**
+ * For a node.js core module request, returns its `node:`-prefixed/unprefixed
+ * counterpart so externals match regardless of which form the code uses.
+ * @param {string} request the request as written in the import/require
+ * @returns {string | undefined} the alternate form, or undefined when not a core module
+ */
+const getAlternateCoreModuleRequest = (request) => {
+	if (request.startsWith(NODE_PREFIX)) {
+		const name = request.slice(NODE_PREFIX.length);
+		return coreModules.has(name) ? name : undefined;
+	}
+	return coreModules.has(request) ? NODE_PREFIX + request : undefined;
+};
 
 // TODO webpack 6 remove this
 const callDeprecatedExternals = util.deprecate(
 	/**
+	 * Handles the callback logic for this hook.
 	 * @param {EXPECTED_FUNCTION} externalsFunction externals function
 	 * @param {string} context context
 	 * @param {string} request request
@@ -67,6 +87,7 @@ const callDeprecatedExternals = util.deprecate(
 /** @typedef {ExternalItemObjectKnown & ExternalItemObjectUnknown} ExternalItemObject */
 
 /**
+ * Defines the external weak cache type used by this module.
  * @template {ExternalItemObject} T
  * @typedef {WeakMap<T, Map<IssuerLayer, Omit<T, "byLayer">>>} ExternalWeakCache
  */
@@ -75,6 +96,7 @@ const callDeprecatedExternals = util.deprecate(
 const cache = new WeakMap();
 
 /**
+ * Returns result.
  * @param {ExternalItemObject} obj obj
  * @param {IssuerLayer} layer layer
  * @returns {Omit<ExternalItemObject, "byLayer">} result
@@ -99,15 +121,18 @@ const PLUGIN_NAME = "ExternalModuleFactoryPlugin";
 
 class ExternalModuleFactoryPlugin {
 	/**
+	 * Creates an instance of ExternalModuleFactoryPlugin.
 	 * @param {ExternalsType | ((dependency: Dependency) => ExternalsType)} type default external type
 	 * @param {Externals} externals externals config
 	 */
 	constructor(type, externals) {
 		this.type = type;
+		/** @type {Externals} */
 		this.externals = externals;
 	}
 
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {NormalModuleFactory} normalModuleFactory the normal module factory
 	 * @returns {void}
 	 */
@@ -124,6 +149,7 @@ class ExternalModuleFactoryPlugin {
 				/** @typedef {(err?: Error | null, externalModule?: ExternalModule) => void} HandleExternalCallback */
 
 				/**
+				 * Processes the provided value.
 				 * @param {ExternalValue} value the external config
 				 * @param {ExternalsType | undefined} type type of external
 				 * @param {HandleExternalCallback} callback callback
@@ -136,6 +162,23 @@ class ExternalModuleFactoryPlugin {
 					}
 					/** @type {ExternalValue} */
 					let externalConfig = value === true ? dependency.request : value;
+					// `interop` is a reserved key on the object form, not a target;
+					// pull it out so the rest stays a pure externalsType->request map.
+					/** @type {ExternalItemInterop | undefined} */
+					let interop;
+					if (
+						typeof externalConfig === "object" &&
+						externalConfig !== null &&
+						!Array.isArray(externalConfig) &&
+						Object.prototype.hasOwnProperty.call(externalConfig, "interop")
+					) {
+						const { interop: interopValue, ...rest } =
+							/** @type {Record<string, string | string[]> & { interop?: ExternalItemInterop }} */ (
+								externalConfig
+							);
+						interop = interopValue;
+						externalConfig = rest;
+					}
 					// When no explicit type is specified, extract it from the externalConfig
 					if (type === undefined) {
 						if (
@@ -186,6 +229,11 @@ class ExternalModuleFactoryPlugin {
 
 						dependencyMeta = {
 							attributes: dependency.attributes,
+							phase:
+								dependency instanceof HarmonyImportDependency ||
+								dependency instanceof ImportDependency
+									? dependency.phase
+									: undefined,
 							externalType
 						};
 					} else if (dependency instanceof CssImportDependency) {
@@ -200,7 +248,7 @@ class ExternalModuleFactoryPlugin {
 						resolvedType === "asset" &&
 						dependency instanceof CssUrlDependency
 					) {
-						dependencyMeta = { sourceType: "css-url" };
+						dependencyMeta = { sourceType: ASSET_URL_TYPE };
 					}
 
 					callback(
@@ -209,19 +257,24 @@ class ExternalModuleFactoryPlugin {
 							externalConfig,
 							resolvedType,
 							dependency.request,
-							dependencyMeta
+							dependencyMeta,
+							interop
 						)
 					);
 				};
 
 				/**
+				 * Processes the provided external.
 				 * @param {Externals} externals externals config
 				 * @param {HandleExternalCallback} callback callback
 				 * @returns {void}
 				 */
 				const handleExternals = (externals, callback) => {
 					if (typeof externals === "string") {
-						if (externals === dependency.request) {
+						if (
+							externals === dependency.request ||
+							externals === getAlternateCoreModuleRequest(dependency.request)
+						) {
 							return handleExternal(dependency.request, undefined, callback);
 						}
 					} else if (Array.isArray(externals)) {
@@ -230,6 +283,7 @@ class ExternalModuleFactoryPlugin {
 							/** @type {boolean | undefined} */
 							let asyncFlag;
 							/**
+							 * Handle externals and callback.
 							 * @param {(Error | null)=} err err
 							 * @param {ExternalModule=} module module
 							 * @returns {void}
@@ -262,6 +316,7 @@ class ExternalModuleFactoryPlugin {
 						}
 					} else if (typeof externals === "function") {
 						/**
+						 * Processes the provided err.
 						 * @param {Error | null | undefined} err err
 						 * @param {ExternalValue=} value value
 						 * @param {ExternalsType=} type type
@@ -357,6 +412,23 @@ class ExternalModuleFactoryPlugin {
 								callback
 							);
 						}
+						// Fall back to the `node:`-prefixed/unprefixed core module form.
+						const alternateRequest = getAlternateCoreModuleRequest(
+							dependency.request
+						);
+						if (
+							alternateRequest !== undefined &&
+							Object.prototype.hasOwnProperty.call(
+								resolvedExternals,
+								alternateRequest
+							)
+						) {
+							return handleExternal(
+								resolvedExternals[alternateRequest],
+								undefined,
+								callback
+							);
+						}
 					}
 					callback();
 				};

package/lib/ExternalsPlugin.js

@@ -19,16 +19,18 @@ const PLUGIN_NAME = "ExternalsPlugin";
 
 class ExternalsPlugin {
 	/**
+	 * Creates an instance of ExternalsPlugin.
 	 * @param {ExternalsType | ((dependency: Dependency) => ExternalsType)} type default external type
 	 * @param {Externals} externals externals config
 	 */
 	constructor(type, externals) {
 		this.type = type;
+		/** @type {Externals} */
 		this.externals = externals;
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */