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

package/lib/dependencies/WorkerDependency.js

@@ -12,25 +12,40 @@ const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Entrypoint")} Entrypoint */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[WorkerDependencyOptions]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[WorkerDependencyOptions]>} ObjectSerializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 /**
+ * @typedef {object} ResourceHint
+ * @property {true=} prefetch emit `<link rel="prefetch">`
+ * @property {true=} preload emit `<link rel="preload">` (wins over prefetch when both are set)
+ * @property {("high" | "low" | "auto")=} fetchPriority value for the `fetchpriority` attribute
+ * @property {string=} as override for the `as` attribute (defaults to `"script"`)
+ * @property {string=} type value for the `type` attribute
+ * @property {string=} media value for the `media` attribute
+ */
+
+/**
+ * Represents the worker dependency runtime component.
  * @typedef {object} WorkerDependencyOptions
  * @property {string=} publicPath public path for the worker
  * @property {boolean=} needNewUrl true when need generate `new URL(...)`, otherwise false
+ * @property {Range=} workerConstructorRange range of the global `Worker` constructor, set only for the `new Worker()` global syntax that needs a node-target rewrite
+ * @property {ResourceHint=} resourceHint resource hint to inject for the worker chunk
  */
 
 class WorkerDependency extends ModuleDependency {
 	/**
+	 * Creates an instance of WorkerDependency.
 	 * @param {string} request request
 	 * @param {Range} range range
 	 * @param {WorkerDependencyOptions} workerDependencyOptions options
@@ -65,7 +80,7 @@ class WorkerDependency extends ModuleDependency {
 	}
 
 	/**
-	 * Update the hash
+	 * Updates the hash with the data contributed by this instance.
 	 * @param {Hash} hash hash to be updated
 	 * @param {UpdateHashContext} context context
 	 * @returns {void}
@@ -78,21 +93,21 @@ class WorkerDependency extends ModuleDependency {
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-		write(this.options);
+		context.write(this.options);
 		super.serialize(context);
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-		this.options = read();
-		super.deserialize(context);
+		this.options = context.read();
+		super.deserialize(context.rest);
 	}
 }
 
@@ -100,13 +115,15 @@ WorkerDependency.Template = class WorkerDependencyTemplate extends (
 	ModuleDependency.Template
 ) {
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Dependency} dependency the dependency for which the template should be applied
 	 * @param {ReplaceSource} source the current replace source which can be modified
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
 	apply(dependency, source, templateContext) {
-		const { chunkGraph, moduleGraph, runtimeRequirements } = templateContext;
+		const { chunkGraph, moduleGraph, runtimeRequirements, runtimeTemplate } =
+			templateContext;
 		const dep = /** @type {WorkerDependency} */ (dependency);
 		const block = /** @type {AsyncDependenciesBlock} */ (
 			moduleGraph.getParentBlock(dependency)
@@ -115,24 +132,91 @@ WorkerDependency.Template = class WorkerDependencyTemplate extends (
 			chunkGraph.getBlockChunkGroup(block)
 		);
 		const chunk = entrypoint.getEntrypointChunk();
-		// We use the workerPublicPath option if provided, else we fallback to the RuntimeGlobal publicPath
-		const workerImportBaseUrl = dep.options.publicPath
-			? `"${dep.options.publicPath}"`
-			: RuntimeGlobals.publicPath;
-
-		runtimeRequirements.add(RuntimeGlobals.publicPath);
-		runtimeRequirements.add(RuntimeGlobals.baseURI);
-		runtimeRequirements.add(RuntimeGlobals.getChunkScriptFilename);
-
-		const workerImportStr = `/* worker import */ ${workerImportBaseUrl} + ${
-			RuntimeGlobals.getChunkScriptFilename
-		}(${JSON.stringify(chunk.id)}), ${RuntimeGlobals.baseURI}`;
-
-		source.replace(
-			dep.range[0],
-			dep.range[1] - 1,
-			dep.options.needNewUrl ? `new URL(${workerImportStr})` : workerImportStr
-		);
+
+		// For ESM module output emit the analyzable `new URL("./worker.<name>.js",
+		// import.meta.url)` form (literal specifier, no runtime helpers) so other bundlers
+		// and webpack itself can statically follow the worker. Resource-hint workers keep
+		// the runtime form because the hint needs the runtime chunk reference.
+		const analyzableSpecifier =
+			!dep.options.resourceHint && runtimeTemplate.supportsAnalyzableEsm()
+				? runtimeTemplate._getAnalyzableChunkSpecifier(
+						dep.options.publicPath,
+						chunk,
+						templateContext.module,
+						chunkGraph
+					)
+				: null;
+
+		if (analyzableSpecifier !== null) {
+			const urlArgs = `/* worker import */ ${analyzableSpecifier}, ${runtimeTemplate.outputOptions.importMetaName}.url`;
+			source.replace(
+				dep.range[0],
+				dep.range[1] - 1,
+				dep.options.needNewUrl ? `new URL(${urlArgs})` : urlArgs
+			);
+		} else {
+			// We use the workerPublicPath option if provided, else we fallback to the RuntimeGlobal publicPath
+			const workerImportBaseUrl = dep.options.publicPath
+				? `"${dep.options.publicPath}"`
+				: RuntimeGlobals.publicPath;
+
+			runtimeRequirements.add(RuntimeGlobals.publicPath);
+			runtimeRequirements.add(RuntimeGlobals.baseURI);
+			runtimeRequirements.add(RuntimeGlobals.getChunkScriptFilename);
+
+			const hrefExpr = `${workerImportBaseUrl} + ${
+				RuntimeGlobals.getChunkScriptFilename
+			}(${JSON.stringify(chunk.id)})`;
+
+			const hint = dep.options.resourceHint;
+			const rel =
+				hint && hint.preload
+					? "preload"
+					: hint && hint.prefetch
+						? "prefetch"
+						: null;
+			let wrappedHref;
+			if (rel && hint) {
+				const fn =
+					rel === "preload"
+						? RuntimeGlobals.preloadAsset
+						: RuntimeGlobals.prefetchAsset;
+				runtimeRequirements.add(fn);
+				const as = hint.as || "script";
+				const args = [
+					hrefExpr,
+					JSON.stringify(as),
+					hint.type ? JSON.stringify(hint.type) : "undefined",
+					hint.media ? JSON.stringify(hint.media) : "undefined",
+					hint.fetchPriority ? JSON.stringify(hint.fetchPriority) : "undefined"
+				];
+				wrappedHref = `${fn}(${args.join(", ")})`;
+			} else {
+				wrappedHref = hrefExpr;
+			}
+
+			const workerImportStr = `/* worker import */ ${wrappedHref}, ${RuntimeGlobals.baseURI}`;
+
+			source.replace(
+				dep.range[0],
+				dep.range[1] - 1,
+				dep.options.needNewUrl ? `new URL(${workerImportStr})` : workerImportStr
+			);
+		}
+
+		// `Worker` is global only on the web, so route node (universal or node-only) through `worker_threads`
+		const { platform } = runtimeTemplate.compilation.compiler;
+		const ctorRange = dep.options.workerConstructorRange;
+		if (
+			ctorRange &&
+			(runtimeTemplate.isUniversalTarget() || (platform.node && !platform.web))
+		) {
+			// `__webpack_require__.wc` attaches to `__webpack_require__`; the analyzable
+			// branch adds no other requirement that would emit it, so require it here.
+			runtimeRequirements.add(RuntimeGlobals.require);
+			runtimeRequirements.add(RuntimeGlobals.worker);
+			source.replace(ctorRange[0], ctorRange[1] - 1, RuntimeGlobals.worker);
+		}
 	}
 };
 

package/lib/dependencies/WorkletDependency.js

@@ -0,0 +1,278 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author sheo13666q
+*/
+
+"use strict";
+
+const Dependency = require("../Dependency");
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
+const makeSerializable = require("../util/makeSerializable");
+const ModuleDependency = require("./ModuleDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Entrypoint")} Entrypoint */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[WorkletDependencyOptions, Range]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[WorkletDependencyOptions, Range]>} ObjectSerializerContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+/**
+ * @typedef {object} WorkletDependencyOptions
+ * @property {string=} publicPath public path for the worklet
+ */
+
+// The wrapper param forwarded as the module argument to the original `addModule`.
+const WORKLET_MODULE = "__webpack_worklet_module__";
+
+class WorkletDependency extends ModuleDependency {
+	/**
+	 * Creates an instance of WorkletDependency.
+	 * @param {string} request request
+	 * @param {Range} range range of the zero-width insertion point (before the call)
+	 * @param {Range} callRange range of the call argument list `(<url>)`
+	 * @param {WorkletDependencyOptions} workletDependencyOptions options
+	 */
+	constructor(request, range, callRange, workletDependencyOptions) {
+		super(request);
+		this.range = range;
+		/** @type {Range} */
+		this.callRange = callRange;
+		// If options are updated, don't forget to update the hash and serialization functions
+		/** @type {WorkletDependencyOptions} */
+		this.options = workletDependencyOptions;
+		/** Cache the hash */
+		/** @type {undefined | string} */
+		this._hashUpdate = undefined;
+	}
+
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {ReferencedExports} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		return Dependency.NO_EXPORTS_REFERENCED;
+	}
+
+	get type() {
+		return "Worklet.addModule()";
+	}
+
+	get category() {
+		return "worker";
+	}
+
+	/**
+	 * Updates the hash with the data contributed by this instance.
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		if (this._hashUpdate === undefined) {
+			this._hashUpdate = JSON.stringify(this.options);
+		}
+		hash.update(this._hashUpdate);
+	}
+
+	/**
+	 * Serializes this instance into the provided serializer context.
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		context.write(this.options).write(this.callRange);
+		super.serialize(context);
+	}
+
+	/**
+	 * Restores this instance from the provided deserializer context.
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		this.options = context.read();
+		const rest = context.rest;
+		this.callRange = rest.read();
+		super.deserialize(rest.rest);
+	}
+}
+
+WorkletDependency.Template = class WorkletDependencyTemplate extends (
+	ModuleDependency.Template
+) {
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, templateContext) {
+		const {
+			module,
+			chunkGraph,
+			moduleGraph,
+			runtimeRequirements,
+			runtimeTemplate
+		} = templateContext;
+		const dep = /** @type {WorkletDependency} */ (dependency);
+		const block = /** @type {AsyncDependenciesBlock} */ (
+			moduleGraph.getParentBlock(dependency)
+		);
+		const entrypoint = /** @type {Entrypoint} */ (
+			chunkGraph.getBlockChunkGroup(block)
+		);
+
+		const entryChunk = entrypoint.getEntrypointChunk();
+		const runtimeChunk = entrypoint.getRuntimeChunk();
+		const referencedChunks = entryChunk.getAllReferencedChunks();
+		const runtimeChunkId =
+			runtimeChunk && runtimeChunk.id !== null ? runtimeChunk.id : null;
+
+		// For ESM module output emit the analyzable `new URL("./worklet.<name>.js",
+		// import.meta.url)` form (literal specifier, no runtime helpers) so other bundlers
+		// and webpack itself can statically follow the worklet. The worklet chunk links its
+		// splits via native `import`, so only the entry chunk is referenced.
+		const analyzableSpecifier =
+			runtimeTemplate.supportsAnalyzableEsm() && entryChunk.id !== null
+				? runtimeTemplate._getAnalyzableChunkSpecifier(
+						dep.options.publicPath,
+						entryChunk,
+						module,
+						chunkGraph
+					)
+				: null;
+		if (analyzableSpecifier !== null) {
+			source.replace(
+				dep.callRange[0],
+				dep.callRange[1] - 1,
+				`(new URL(/* worklet import */ ${analyzableSpecifier}, ${runtimeTemplate.outputOptions.importMetaName}.url))`
+			);
+			return;
+		}
+
+		const workletImportBaseUrl = dep.options.publicPath
+			? JSON.stringify(dep.options.publicPath)
+			: RuntimeGlobals.publicPath;
+
+		runtimeRequirements.add(RuntimeGlobals.publicPath);
+		runtimeRequirements.add(RuntimeGlobals.baseURI);
+		runtimeRequirements.add(RuntimeGlobals.getChunkScriptFilename);
+
+		/**
+		 * @param {string | number} id chunk id
+		 * @returns {string} `new URL(...)` expression for the chunk file
+		 */
+		const toUrl = (id) =>
+			`new URL(${workletImportBaseUrl} + ${
+				RuntimeGlobals.getChunkScriptFilename
+			}(${JSON.stringify(id)}), ${RuntimeGlobals.baseURI})`;
+
+		// Module output: the worklet chunk is an ES module that links its split
+		// chunks via native `import`, which `addModule` resolves — so add just the
+		// entry chunk, with no worker-scope shim and no chunk pre-loading.
+		if (runtimeTemplate.isModule() && entryChunk.id !== null) {
+			source.replace(
+				dep.callRange[0],
+				dep.callRange[1] - 1,
+				`(${toUrl(entryChunk.id)})`
+			);
+			return;
+		}
+
+		// Fast path: a self-contained worklet (a single chunk, no splits or async
+		// `import()`) needs no chunk-loading runtime and no worker-scope shim, so the
+		// chunk is `addModule`-d directly with no bootstrap.
+		if (referencedChunks.size === 1 && runtimeChunkId !== null) {
+			source.replace(
+				dep.callRange[0],
+				dep.callRange[1] - 1,
+				`(${toUrl(runtimeChunkId)})`
+			);
+			return;
+		}
+
+		// A worklet can't load chunks at runtime, so every reachable chunk (initial
+		// splits and async `import()` targets alike) is pre-added via `addModule`
+		// from the calling scope. The runtime chunk is added last so it installs the
+		// chunks pushed before it and runs entry startup with every module present
+		// (see ImportScriptsChunkLoadingRuntimeModule).
+		/** @type {(string | number)[]} */
+		const restChunkIds = [];
+		for (const chunk of referencedChunks) {
+			if (chunk !== runtimeChunk && chunk.id !== null) {
+				restChunkIds.push(chunk.id);
+			}
+		}
+
+		runtimeRequirements.add(RuntimeGlobals.getWorkletBootstrap);
+
+		const add = "__webpack_worklet_add__";
+		const boot = `${add}(${RuntimeGlobals.getWorkletBootstrap}())`;
+		// Non-runtime chunks have no ordering constraint, so add them concurrently.
+		const addOne = runtimeTemplate.returningFunction(`${add}(u)`, "u");
+		const parallel =
+			restChunkIds.length > 0
+				? `Promise.all([${restChunkIds.map(toUrl).join(", ")}].map(${addOne}))`
+				: undefined;
+		// The runtime chunk is added last: it runs entry startup with every module present.
+		const runtimeAdd =
+			runtimeChunkId !== null ? `${add}(${toUrl(runtimeChunkId)})` : undefined;
+
+		// Emit `async`/`await` only where the target supports async functions;
+		// otherwise fall back to an equivalent Promise chain (boot → rest → runtime).
+		let bootstrap;
+		if (runtimeTemplate.supportsAsyncFunction()) {
+			bootstrap = Template.asString([
+				`async function(${add}) {`,
+				Template.indent(
+					[
+						`await ${boot};`,
+						parallel ? `await ${parallel};` : "",
+						runtimeAdd ? `await ${runtimeAdd};` : ""
+					].filter(Boolean)
+				),
+				"}"
+			]);
+		} else {
+			let chain = boot;
+			if (parallel) {
+				chain += `.then(${runtimeTemplate.returningFunction(parallel)})`;
+			}
+			if (runtimeAdd) {
+				chain += `.then(${runtimeTemplate.returningFunction(runtimeAdd)})`;
+			}
+			bootstrap = `function(${add}) { return ${chain}; }`;
+		}
+
+		// The wrapper forwards to the original `addModule` (its callee stays in the
+		// source, so the receiver is preserved); a plain function keeps it valid on
+		// ES targets without arrow functions.
+		source.insert(
+			dep.range[0],
+			`(/* worklet bootstrap */ ${bootstrap})(function(${WORKLET_MODULE}) { return `
+		);
+		source.replace(
+			dep.callRange[0],
+			dep.callRange[1] - 1,
+			`(${WORKLET_MODULE}); })`
+		);
+	}
+};
+
+makeSerializable(
+	WorkletDependency,
+	"webpack/lib/dependencies/WorkletDependency"
+);
+
+module.exports = WorkletDependency;
+module.exports.WORKLET_MODULE = WORKLET_MODULE;

package/lib/dependencies/getFunctionExpression.js

@@ -13,6 +13,7 @@
 /** @typedef {{ fn: FunctionExpression | ArrowFunctionExpression, expressions: (Expression | SpreadElement)[], needThis: boolean | undefined }} FunctionExpressionResult */
 
 /**
+ * Returns function expression with additional information.
  * @param {Expression | SpreadElement} expr expressions
  * @returns {FunctionExpressionResult | undefined} function expression with additional information
  */

package/lib/dependencies/processExportInfo.js

@@ -12,12 +12,13 @@ const { UsageState } = require("../ExportsInfo");
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 /**
+ * Process export info.
  * @param {RuntimeSpec} runtime the runtime
  * @param {RawReferencedExports} referencedExports list of referenced exports, will be added to
  * @param {string[]} prefix export prefix
  * @param {ExportInfo=} exportInfo the export info
  * @param {boolean} defaultPointsToSelf when true, using default will reference itself
- * @param {Set<ExportInfo>} alreadyVisited already visited export info (to handle circular reexports)
+ * @param {Set<ExportInfo>=} alreadyVisited already visited export info (to handle circular reexports)
  */
 const processExportInfo = (
 	runtime,
@@ -25,7 +26,7 @@ const processExportInfo = (
 	prefix,
 	exportInfo,
 	defaultPointsToSelf = false,
-	alreadyVisited = new Set()
+	alreadyVisited = undefined
 ) => {
 	if (!exportInfo) {
 		referencedExports.push(prefix);
@@ -33,35 +34,37 @@ const processExportInfo = (
 	}
 	const used = exportInfo.getUsed(runtime);
 	if (used === UsageState.Unused) return;
-	if (alreadyVisited.has(exportInfo)) {
+	if (alreadyVisited !== undefined && alreadyVisited.has(exportInfo)) {
 		referencedExports.push(prefix);
 		return;
 	}
-	alreadyVisited.add(exportInfo);
+	// Terminal case: not recursing, so no need to track visited here
 	if (
 		used !== UsageState.OnlyPropertiesUsed ||
 		!exportInfo.exportsInfo ||
 		exportInfo.exportsInfo.otherExportsInfo.getUsed(runtime) !==
 			UsageState.Unused
 	) {
-		alreadyVisited.delete(exportInfo);
 		referencedExports.push(prefix);
 		return;
 	}
+	// Only the recursive path needs the visited set; allocate it lazily
+	const visited = alreadyVisited !== undefined ? alreadyVisited : new Set();
+	visited.add(exportInfo);
 	const exportsInfo = exportInfo.exportsInfo;
-	for (const exportInfo of exportsInfo.orderedExports) {
+	for (const childExportInfo of exportsInfo.orderedExports) {
 		processExportInfo(
 			runtime,
 			referencedExports,
-			defaultPointsToSelf && exportInfo.name === "default"
+			defaultPointsToSelf && childExportInfo.name === "default"
 				? prefix
-				: [...prefix, exportInfo.name],
-			exportInfo,
+				: [...prefix, childExportInfo.name],
+			childExportInfo,
 			false,
-			alreadyVisited
+			visited
 		);
 	}
-	alreadyVisited.delete(exportInfo);
+	visited.delete(exportInfo);
 };
 
 module.exports = processExportInfo;