@depup/webpack 5.111.1-depup.2 → 5.112.0-depup.0

package/lib/template/DependencyTemplate.js

@@ -0,0 +1,77 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import ChunkGraph from "../graph/ChunkGraph" */
+/** @import CodeGenerationResults from "../module/CodeGenerationResults" */
+/** @import ConcatenationScope from "../optimize/ConcatenationScope" */
+/** @import Dependency from "../graph/Dependency" */
+/** @import DependencyTemplates from "./DependencyTemplates" */
+/** @import { GenerateContext } from "../module/Generator" */
+/** @import Module, { CodeGenerationResultData, RuntimeRequirements } from "../module/Module" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
+/** @import RuntimeTemplate from "./RuntimeTemplate" */
+/** @import { RuntimeSpec } from "../util/runtime" */
+
+/**
+ * Defines the init fragment type used by this module.
+ * @template T
+ * @typedef {import("./InitFragment")<T>} InitFragment
+ */
+
+/**
+ * Defines the dependency template context type used by this module.
+ * @typedef {object} DependencyTemplateContext
+ * @property {RuntimeTemplate} runtimeTemplate the runtime template
+ * @property {DependencyTemplates} dependencyTemplates the dependency templates
+ * @property {ModuleGraph} moduleGraph the module graph
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ * @property {RuntimeRequirements} runtimeRequirements the requirements for runtime
+ * @property {Module} module current module
+ * @property {RuntimeSpec} runtime current runtimes, for which code is generated
+ * @property {InitFragment<GenerateContext>[]} initFragments mutable array of init fragments for the current module
+ * @property {ConcatenationScope=} concatenationScope when in a concatenated module, information about other concatenated modules
+ * @property {CodeGenerationResults} codeGenerationResults the code generation results
+ * @property {InitFragment<GenerateContext>[]} chunkInitFragments chunkInitFragments
+ * @property {(() => CodeGenerationResultData)=} getData get access to the code generation data
+ */
+
+/**
+ * Defines the css dependency template context extras type used by this module.
+ * @typedef {object} CssDependencyTemplateContextExtras
+ * @property {CssData} cssData the css exports data
+ * @property {string} type the css exports data
+ */
+
+/**
+ * Defines the css data type used by this module.
+ * @typedef {object} CssData
+ * @property {boolean} esModule whether export __esModule
+ * @property {Map<string, string>} exports the css exports
+ * @property {Map<string, { line: number, column: number }>=} exportLocs source position (line is 1-based, column is 0-based) of each export's defining identifier in the original CSS, used to emit fine-grained JS-to-CSS source mappings
+ */
+
+/** @typedef {DependencyTemplateContext & CssDependencyTemplateContextExtras} CssDependencyTemplateContext */
+
+class DependencyTemplate {
+	/* istanbul ignore next */
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @abstract
+	 * @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 AbstractMethodError = require("../errors/AbstractMethodError");
+
+		throw new AbstractMethodError();
+	}
+}
+
+module.exports = DependencyTemplate;

package/lib/{DependencyTemplates.js → template/DependencyTemplates.js}

@@ -5,12 +5,12 @@
 
 "use strict";
 
-const { DEFAULTS } = require("./config/defaults");
-const createHash = require("./util/createHash");
+const { DEFAULTS } = require("../config/defaults");
+const createHash = require("../util/createHash");
 
-/** @import { DependencyConstructor } from "./Compilation" */
+/** @import { DependencyConstructor } from "../Compilation" */
 /** @import DependencyTemplate from "./DependencyTemplate" */
-/** @import { HashFunction } from "./util/Hash" */
+/** @import { HashFunction } from "../util/Hash" */
 
 class DependencyTemplates {
 	/**
@@ -24,6 +24,10 @@ class DependencyTemplates {
 		this._hash = "31d6cfe0d16ae931b73c59d7e0c089c0";
 		/** @type {HashFunction} */
 		this._hashFunction = hashFunction;
+		// Whether to record what each imported binding reads, which only a source
+		// map's `scopes` field names; `SourceMapDevToolModuleOptionsPlugin` sets it.
+		/** @type {boolean} */
+		this.importBindingScopes = false;
 	}
 
 	/**
@@ -64,6 +68,7 @@ class DependencyTemplates {
 		const newInstance = new DependencyTemplates(this._hashFunction);
 		newInstance._map = new Map(this._map);
 		newInstance._hash = this._hash;
+		newInstance.importBindingScopes = this.importBindingScopes;
 		return newInstance;
 	}
 }

package/lib/template/InitFragment.js

@@ -0,0 +1,223 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Florent Cailhol @ooflorent
+*/
+
+"use strict";
+
+const { ConcatSource } = require("webpack-sources");
+const makeSerializable = require("../util/makeSerializable");
+
+/** @import { Source } from "webpack-sources" */
+/** @import { GenerateContext } from "../module/Generator" */
+/**
+ * @import {
+ * 	ObjectDeserializerContext,
+ * 	ObjectSerializerContext
+ * } from "../serialization/ObjectMiddleware"
+ */
+
+/** @typedef {string} InitFragmentKey */
+
+/**
+ * Defines the maybe mergeable init fragment type used by this module.
+ * @template GenerateContext
+ * @typedef {object} MaybeMergeableInitFragment
+ * @property {InitFragmentKey=} key
+ * @property {number} stage
+ * @property {number} position
+ * @property {(context: GenerateContext) => string | Source | undefined} getContent
+ * @property {(context: GenerateContext) => string | Source | undefined} getEndContent
+ * @property {(fragments: MaybeMergeableInitFragment<GenerateContext>) => MaybeMergeableInitFragment<GenerateContext>=} merge
+ * @property {(fragments: MaybeMergeableInitFragment<GenerateContext>[]) => MaybeMergeableInitFragment<GenerateContext>[]=} mergeAll
+ */
+
+/**
+ * Represents InitFragment.
+ * @template GenerateContext
+ * @implements {MaybeMergeableInitFragment<GenerateContext>}
+ */
+class InitFragment {
+	/**
+	 * Creates an instance of InitFragment.
+	 * @param {string | Source | undefined} content the source code that will be included as initialization code
+	 * @param {number} stage category of initialization code (contribute to order)
+	 * @param {number} position position in the category (contribute to order)
+	 * @param {InitFragmentKey=} key unique key to avoid emitting the same initialization code twice
+	 * @param {string | Source=} endContent the source code that will be included at the end of the module
+	 */
+	constructor(content, stage, position, key, endContent) {
+		/** @type {string | Source | undefined} */
+		this.content = content;
+		/** @type {number} */
+		this.stage = stage;
+		/** @type {number} */
+		this.position = position;
+		/** @type {string | undefined} */
+		this.key = key;
+		/** @type {string | Source | undefined} */
+		this.endContent = endContent;
+	}
+
+	/**
+	 * Returns the source code that will be included as initialization code.
+	 * @param {GenerateContext} context context
+	 * @returns {string | Source | undefined} the source code that will be included as initialization code
+	 */
+	getContent(context) {
+		return this.content;
+	}
+
+	/**
+	 * Returns the source code that will be included at the end of the module.
+	 * @param {GenerateContext} context context
+	 * @returns {string | Source | undefined} the source code that will be included at the end of the module
+	 */
+	getEndContent(context) {
+		return this.endContent;
+	}
+
+	/**
+	 * Adds the provided source to the init fragment.
+	 * @template Context
+	 * @param {Source} source sources
+	 * @param {MaybeMergeableInitFragment<Context>[]} initFragments init fragments
+	 * @param {Context} context context
+	 * @returns {Source} source
+	 */
+	static addToSource(source, initFragments, context) {
+		if (initFragments.length > 0) {
+			// Sort fragment indices by (stage, position), falling back to the
+			// original index — one flat number array instead of N [fragment, index]
+			// tuples for a stable-by-index order.
+			const sortedIndices = initFragments.map((_, index) => index);
+			sortedIndices.sort((a, b) => {
+				const fragmentA = initFragments[a];
+				const fragmentB = initFragments[b];
+				const stageCmp = fragmentA.stage - fragmentB.stage;
+				if (stageCmp !== 0) return stageCmp;
+				const positionCmp = fragmentA.position - fragmentB.position;
+				if (positionCmp !== 0) return positionCmp;
+				return a - b;
+			});
+
+			// Deduplicate fragments. If a fragment has no key, it is always included.
+			// Keyless fragments get a unique numeric key; number keys never collide
+			// with the string `InitFragmentKey`s used for keyed fragments.
+			/** @type {Map<InitFragmentKey | number, MaybeMergeableInitFragment<Context> | MaybeMergeableInitFragment<Context>[]>} */
+			const keyedFragments = new Map();
+			let keylessKey = 0;
+			for (const index of sortedIndices) {
+				const fragment = initFragments[index];
+				if (typeof fragment.mergeAll === "function") {
+					if (!fragment.key) {
+						throw new Error(
+							`InitFragment with mergeAll function must have a valid key: ${fragment.constructor.name}`
+						);
+					}
+					const oldValue = keyedFragments.get(fragment.key);
+					if (oldValue === undefined) {
+						keyedFragments.set(fragment.key, fragment);
+					} else if (Array.isArray(oldValue)) {
+						oldValue.push(fragment);
+					} else {
+						keyedFragments.set(fragment.key, [oldValue, fragment]);
+					}
+					continue;
+				} else if (typeof fragment.merge === "function") {
+					const key = /** @type {InitFragmentKey} */ (fragment.key);
+					const oldValue =
+						/** @type {MaybeMergeableInitFragment<Context>} */
+						(keyedFragments.get(key));
+					if (oldValue !== undefined) {
+						keyedFragments.set(key, fragment.merge(oldValue));
+						continue;
+					}
+				}
+				keyedFragments.set(fragment.key || keylessKey++, fragment);
+			}
+
+			const concatSource = new ConcatSource();
+			/** @type {(string | Source)[]} */
+			const endContents = [];
+			for (let fragment of keyedFragments.values()) {
+				if (Array.isArray(fragment)) {
+					fragment =
+						/** @type {[MaybeMergeableInitFragment<Context> & { mergeAll: (fragments: MaybeMergeableInitFragment<Context>[]) => MaybeMergeableInitFragment<Context>[] }, ...MaybeMergeableInitFragment<Context>[]]} */
+						(fragment)[0].mergeAll(fragment);
+				}
+				const content =
+					/** @type {MaybeMergeableInitFragment<Context>} */
+					(fragment).getContent(context);
+				if (content) {
+					concatSource.add(content);
+				}
+				const endContent =
+					/** @type {MaybeMergeableInitFragment<Context>} */
+					(fragment).getEndContent(context);
+				if (endContent) {
+					endContents.push(endContent);
+				}
+			}
+
+			concatSource.add(source);
+			for (const content of endContents.reverse()) {
+				concatSource.add(content);
+			}
+			return concatSource;
+		}
+		return source;
+	}
+
+	/**
+	 * Serializes this instance into the provided serializer context.
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+
+		write(this.content);
+		write(this.stage);
+		write(this.position);
+		write(this.key);
+		write(this.endContent);
+	}
+
+	/**
+	 * Restores this instance from the provided deserializer context.
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+
+		this.content = read();
+		this.stage = read();
+		this.position = read();
+		this.key = read();
+		this.endContent = read();
+	}
+}
+
+makeSerializable(InitFragment, [
+	"webpack/lib/template/InitFragment",
+	// TODO in the next major release: remove, it restores caches written
+	// before this moved into lib/template/
+	"webpack/lib/InitFragment"
+]);
+
+InitFragment.STAGE_CONSTANTS = 10;
+InitFragment.STAGE_ASYNC_BOUNDARY = 20;
+InitFragment.STAGE_ESM_EXPORTS = 30;
+InitFragment.STAGE_ESM_IMPORTS = 40;
+InitFragment.STAGE_PROVIDES = 50;
+InitFragment.STAGE_ASYNC_DEPENDENCIES = 60;
+InitFragment.STAGE_ASYNC_ESM_IMPORTS = 70;
+
+/** @deprecated use `STAGE_ESM_EXPORTS` — TODO in the next major release: remove */
+InitFragment.STAGE_HARMONY_EXPORTS = InitFragment.STAGE_ESM_EXPORTS;
+/** @deprecated use `STAGE_ESM_IMPORTS` — TODO in the next major release: remove */
+InitFragment.STAGE_HARMONY_IMPORTS = InitFragment.STAGE_ESM_IMPORTS;
+/** @deprecated use `STAGE_ASYNC_ESM_IMPORTS` — TODO in the next major release: remove */
+InitFragment.STAGE_ASYNC_HARMONY_IMPORTS = InitFragment.STAGE_ASYNC_ESM_IMPORTS;
+
+module.exports = InitFragment;

package/lib/{MainTemplate.js → template/MainTemplate.js}

@@ -7,16 +7,16 @@
 
 const util = require("util");
 const { SyncWaterfallHook } = require("tapable");
-const RuntimeGlobals = require("./RuntimeGlobals");
-const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin");
-const memoize = require("./util/memoize");
+const JavascriptModulesPlugin = require("../javascript/JavascriptModulesPlugin");
+const RuntimeGlobals = require("../runtime/RuntimeGlobals");
+const memoize = require("../util/memoize");
 
 const getLoadScriptRuntimeModule = memoize(() =>
-	require("./runtime/LoadScriptRuntimeModule")
+	require("../runtime/LoadScriptRuntimeModule")
 );
 
 const getJsonpTemplatePlugin = memoize(() =>
-	require("./web/JsonpTemplatePlugin")
+	require("../web/JsonpTemplatePlugin")
 );
 
 /** @import { Tap } from "tapable" */
@@ -24,23 +24,23 @@ const getJsonpTemplatePlugin = memoize(() =>
 /**
  * @import {
  * 	OutputNormalizedWithDefaults as OutputOptions
- * } from "./config/defaults"
+ * } from "../config/defaults"
  */
 /** @import ModuleTemplate from "./ModuleTemplate" */
-/** @import Chunk from "./Chunk" */
+/** @import Chunk from "../graph/Chunk" */
 /**
  * @import Compilation, {
  * 	AssetInfo,
  * 	InterpolatedPathAndAssetInfo,
  * 	PathData
- * } from "./Compilation"
+ * } from "../Compilation"
  */
-/** @import Hash from "./util/Hash" */
+/** @import Hash from "../util/Hash" */
 /** @import DependencyTemplates from "./DependencyTemplates" */
 /**
  * @import {
  * 	RenderBootstrapContext
- * } from "./javascript/JavascriptModulesPlugin"
+ * } from "../javascript/JavascriptModulesPlugin"
  */
 /** @import { RenderManifestOptions, RenderManifestEntry } from "./Template" */
 /** @import { TemplatePath } from "./TemplatedPathPlugin" */
@@ -50,7 +50,7 @@ const getJsonpTemplatePlugin = memoize(() =>
  * @typedef {import("tapable").IfSet<T>} IfSet
  */
 
-// TODO webpack 6 remove this class
+// TODO in the next major release: remove this class
 class MainTemplate {
 	/**
 	 * Creates an instance of MainTemplate.

package/lib/{ModuleInfoHeaderPlugin.js → template/ModuleInfoHeaderPlugin.js}

@@ -6,17 +6,17 @@
 "use strict";
 
 const { CachedSource, ConcatSource, RawSource } = require("webpack-sources");
-const { UsageState } = require("./ExportsInfo");
+const CssModulesPlugin = require("../css/CssModulesPlugin");
+const { UsageState } = require("../graph/ExportsInfo");
+const JavascriptModulesPlugin = require("../javascript/JavascriptModulesPlugin");
 const Template = require("./Template");
-const CssModulesPlugin = require("./css/CssModulesPlugin");
-const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin");
 
 /** @import { Source } from "webpack-sources" */
-/** @import Compiler from "./Compiler" */
-/** @import ExportsInfo, { ExportInfo } from "./ExportsInfo" */
-/** @import Module, { BuildMeta } from "./Module" */
-/** @import ModuleGraph from "./ModuleGraph" */
-/** @import RequestShortener from "./RequestShortener" */
+/** @import Compiler from "../Compiler" */
+/** @import ExportsInfo, { ExportInfo } from "../graph/ExportsInfo" */
+/** @import Module, { BuildMeta } from "../module/Module" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
+/** @import RequestShortener from "../util/RequestShortener" */
 
 /**
  * Join iterable with comma.
@@ -146,6 +146,12 @@ const printExportsInfoToSource = (
 	}
 };
 
+// `generateHeader`'s shape, as it reads back. A header names the module of the
+// build that wrote it, so a source webpack reads its own output from sheds the
+// one it arrives with and is headed again — see `stripHeaders`.
+const HEADER_REGEXP =
+	/^\/\*!\*+!\*\\\r?\n {2}!\*\*\* .* \*\*\*!\r?\n {2}\\\*+\/\r?\n/;
+
 /** @typedef {{ header: RawSource | undefined, full: WeakMap<Source, CachedSource> }} CacheEntry */
 /** @type {WeakMap<RequestShortener, WeakMap<Module, CacheEntry>>} */
 const caches = new WeakMap();
@@ -303,6 +309,22 @@ class ModuleInfoHeaderPlugin {
 		});
 	}
 
+	/**
+	 * Drop the headers a build wrote at the top of a source that is read back
+	 * in, so this build's own header heads the module rather than the last
+	 * build's.
+	 * @param {string} source source that may have been written by a build
+	 * @returns {string} the source with any header of ours taken off the front
+	 */
+	static stripHeaders(source) {
+		let stripped = source;
+		// A page built before this stripped may carry a stack of them.
+		while (HEADER_REGEXP.test(stripped)) {
+			stripped = stripped.replace(HEADER_REGEXP, "");
+		}
+		return stripped;
+	}
+
 	/**
 	 * Returns the header.
 	 * @param {Module} module the module

package/lib/{ModuleTemplate.js → template/ModuleTemplate.js}

@@ -6,21 +6,21 @@
 "use strict";
 
 const util = require("util");
-const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin");
+const JavascriptModulesPlugin = require("../javascript/JavascriptModulesPlugin");
 
 /** @import { Tap } from "tapable" */
 /** @import { Source } from "webpack-sources" */
-/** @import Compilation from "./Compilation" */
+/** @import Compilation from "../Compilation" */
 /** @import DependencyTemplates from "./DependencyTemplates" */
-/** @import Module from "./Module" */
+/** @import Module from "../module/Module" */
 /** @import RuntimeTemplate from "./RuntimeTemplate" */
 /**
  * @import {
  * 	ChunkRenderContext,
  * 	ModuleRenderContext
- * } from "./javascript/JavascriptModulesPlugin"
+ * } from "../javascript/JavascriptModulesPlugin"
  */
-/** @import Hash from "./util/Hash" */
+/** @import Hash from "../util/Hash" */
 
 /**
  * Defines the if set type used by this module.
@@ -28,7 +28,7 @@ const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin");
  * @typedef {import("tapable").IfSet<T>} IfSet
  */
 
-// TODO webpack 6: remove this class
+// TODO in the next major release: remove this class
 class ModuleTemplate {
 	/**
 	 * Creates an instance of ModuleTemplate.