@depup/webpack 5.105.4-depup.37

package/lib/AsyncDependenciesBlock.js

@@ -0,0 +1,128 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const DependenciesBlock = require("./DependenciesBlock");
+const makeSerializable = require("./util/makeSerializable");
+
+/** @typedef {import("./ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("./util/Hash")} Hash */
+
+/** @typedef {(ChunkGroupOptions & { entryOptions?: EntryOptions } & { circular?: boolean })} GroupOptions */
+
+class AsyncDependenciesBlock extends DependenciesBlock {
+	/**
+	 * @param {GroupOptions | string | null} groupOptions options for the group
+	 * @param {(DependencyLocation | null)=} loc the line of code
+	 * @param {(string | null)=} request the request
+	 */
+	constructor(groupOptions, loc, request) {
+		super();
+		if (typeof groupOptions === "string") {
+			groupOptions = { name: groupOptions };
+		} else if (!groupOptions) {
+			groupOptions = { name: undefined };
+		}
+		if (typeof groupOptions.circular !== "boolean") {
+			// default allow circular references
+			groupOptions.circular = true;
+		}
+		/** @type {GroupOptions} */
+		this.groupOptions = groupOptions;
+		/** @type {DependencyLocation | null | undefined} */
+		this.loc = loc;
+		/** @type {string | null | undefined} */
+		this.request = request;
+		/** @type {undefined | string} */
+		this._stringifiedGroupOptions = undefined;
+	}
+
+	/**
+	 * @returns {ChunkGroupOptions["name"]} The name of the chunk
+	 */
+	get chunkName() {
+		return this.groupOptions.name;
+	}
+
+	/**
+	 * @param {string | undefined} value The new chunk name
+	 * @returns {void}
+	 */
+	set chunkName(value) {
+		if (this.groupOptions.name !== value) {
+			this.groupOptions.name = value;
+			this._stringifiedGroupOptions = undefined;
+		}
+	}
+
+	/**
+	 * @returns {boolean} Whether circular references are allowed
+	 */
+	get circular() {
+		return Boolean(this.groupOptions.circular);
+	}
+
+	/**
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		const { chunkGraph } = context;
+		if (this._stringifiedGroupOptions === undefined) {
+			this._stringifiedGroupOptions = JSON.stringify(this.groupOptions);
+		}
+		const chunkGroup = chunkGraph.getBlockChunkGroup(this);
+		hash.update(
+			`${this._stringifiedGroupOptions}${chunkGroup ? chunkGroup.id : ""}`
+		);
+		super.updateHash(hash, context);
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.groupOptions);
+		write(this.loc);
+		write(this.request);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.groupOptions = read();
+		this.loc = read();
+		this.request = read();
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(AsyncDependenciesBlock, "webpack/lib/AsyncDependenciesBlock");
+
+Object.defineProperty(AsyncDependenciesBlock.prototype, "module", {
+	get() {
+		throw new Error(
+			"module property was removed from AsyncDependenciesBlock (it's not needed)"
+		);
+	},
+	set() {
+		throw new Error(
+			"module property was removed from AsyncDependenciesBlock (it's not needed)"
+		);
+	}
+});
+
+module.exports = AsyncDependenciesBlock;

package/lib/AsyncDependencyToInitialChunkError.js

@@ -0,0 +1,34 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Sean Larkin @thelarkinn
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("./Module")} Module */
+
+class AsyncDependencyToInitialChunkError extends WebpackError {
+	/**
+	 * Creates an instance of AsyncDependencyToInitialChunkError.
+	 * @param {string} chunkName Name of Chunk
+	 * @param {Module} module module tied to dependency
+	 * @param {DependencyLocation} loc location of dependency
+	 */
+	constructor(chunkName, module, loc) {
+		super(
+			`It's not allowed to load an initial chunk on demand. The chunk name "${chunkName}" is already used by an entrypoint.`
+		);
+
+		/** @type {string} */
+		this.name = "AsyncDependencyToInitialChunkError";
+		/** @type {Module} */
+		this.module = module;
+		/** @type {DependencyLocation} */
+		this.loc = loc;
+	}
+}
+
+module.exports = AsyncDependencyToInitialChunkError;

package/lib/AutomaticPrefetchPlugin.js

@@ -0,0 +1,66 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const asyncLib = require("neo-async");
+const NormalModule = require("./NormalModule");
+const PrefetchDependency = require("./dependencies/PrefetchDependency");
+
+/** @typedef {import("./Compiler")} Compiler */
+
+const PLUGIN_NAME = "AutomaticPrefetchPlugin";
+
+class AutomaticPrefetchPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			PLUGIN_NAME,
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					PrefetchDependency,
+					normalModuleFactory
+				);
+			}
+		);
+		/** @type {{ context: string | null, request: string }[] | null} */
+		let lastModules = null;
+		compiler.hooks.afterCompile.tap(PLUGIN_NAME, (compilation) => {
+			lastModules = [];
+
+			for (const m of compilation.modules) {
+				if (m instanceof NormalModule) {
+					lastModules.push({
+						context: m.context,
+						request: m.request
+					});
+				}
+			}
+		});
+		compiler.hooks.make.tapAsync(PLUGIN_NAME, (compilation, callback) => {
+			if (!lastModules) return callback();
+			asyncLib.each(
+				lastModules,
+				(m, callback) => {
+					compilation.addModuleChain(
+						m.context || compiler.context,
+						new PrefetchDependency(`!!${m.request}`),
+						callback
+					);
+				},
+				(err) => {
+					lastModules = null;
+					callback(err);
+				}
+			);
+		});
+	}
+}
+
+module.exports = AutomaticPrefetchPlugin;

package/lib/BannerPlugin.js

@@ -0,0 +1,138 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { ConcatSource } = require("webpack-sources");
+const Compilation = require("./Compilation");
+const ModuleFilenameHelpers = require("./ModuleFilenameHelpers");
+const Template = require("./Template");
+const createSchemaValidation = require("./util/create-schema-validation");
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../declarations/plugins/BannerPlugin").BannerPluginArgument} BannerPluginArgument */
+/** @typedef {import("./Compilation").PathData} PathData */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./TemplatedPathPlugin").TemplatePath} TemplatePath */
+
+/** @typedef {(data: { hash?: string, chunk: Chunk, filename: string }) => string} BannerFunction */
+
+const validate = createSchemaValidation(
+	/** @type {((value: typeof import("../schemas/plugins/BannerPlugin.json")) => boolean)} */
+	(require("../schemas/plugins/BannerPlugin.check")),
+	() => require("../schemas/plugins/BannerPlugin.json"),
+	{
+		name: "Banner Plugin",
+		baseDataPath: "options"
+	}
+);
+
+/**
+ * @param {string} str string to wrap
+ * @returns {string} wrapped string
+ */
+const wrapComment = (str) => {
+	if (!str.includes("\n")) {
+		return Template.toComment(str);
+	}
+	return `/*!\n * ${str
+		.replace(/\*\//g, "* /")
+		.split("\n")
+		.join("\n * ")
+		.replace(/\s+\n/g, "\n")
+		.trimEnd()}\n */`;
+};
+
+const PLUGIN_NAME = "BannerPlugin";
+
+class BannerPlugin {
+	/**
+	 * @param {BannerPluginArgument} options options object
+	 */
+	constructor(options) {
+		if (typeof options === "string" || typeof options === "function") {
+			options = {
+				banner: options
+			};
+		}
+
+		validate(options);
+
+		this.options = options;
+
+		const bannerOption = options.banner;
+		if (typeof bannerOption === "function") {
+			const getBanner = bannerOption;
+			/** @type {BannerFunction} */
+			this.banner = this.options.raw
+				? getBanner
+				: /** @type {BannerFunction} */ (data) => wrapComment(getBanner(data));
+		} else {
+			const banner = this.options.raw
+				? bannerOption
+				: wrapComment(bannerOption);
+			/** @type {BannerFunction} */
+			this.banner = () => banner;
+		}
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const options = this.options;
+		const banner = this.banner;
+		const matchObject = ModuleFilenameHelpers.matchObject.bind(
+			undefined,
+			options
+		);
+		/** @type {WeakMap<Source, { source: ConcatSource, comment: string }>} */
+		const cache = new WeakMap();
+		const stage =
+			this.options.stage || Compilation.PROCESS_ASSETS_STAGE_ADDITIONS;
+
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			compilation.hooks.processAssets.tap({ name: PLUGIN_NAME, stage }, () => {
+				for (const chunk of compilation.chunks) {
+					if (options.entryOnly && !chunk.canBeInitial()) {
+						continue;
+					}
+
+					for (const file of chunk.files) {
+						if (!matchObject(file)) {
+							continue;
+						}
+
+						/** @type {PathData} */
+						const data = { chunk, filename: file };
+
+						const comment = compilation.getPath(
+							/** @type {TemplatePath} */
+							(banner),
+							data
+						);
+
+						compilation.updateAsset(file, (old) => {
+							const cached = cache.get(old);
+							if (!cached || cached.comment !== comment) {
+								const source = options.footer
+									? new ConcatSource(old, "\n", comment)
+									: new ConcatSource(comment, "\n", old);
+								cache.set(old, { source, comment });
+								return source;
+							}
+							return cached.source;
+						});
+					}
+				}
+			});
+		});
+	}
+}
+
+module.exports = BannerPlugin;

package/lib/Cache.js

@@ -0,0 +1,168 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { AsyncParallelHook, AsyncSeriesBailHook, SyncHook } = require("tapable");
+const {
+	makeWebpackError,
+	makeWebpackErrorCallback
+} = require("./HookWebpackError");
+
+/** @typedef {import("./WebpackError")} WebpackError */
+
+/**
+ * @typedef {object} Etag
+ * @property {() => string} toString
+ */
+
+/**
+ * @template T
+ * @callback CallbackCache
+ * @param {WebpackError | null} err
+ * @param {T=} result
+ * @returns {void}
+ */
+
+/** @typedef {EXPECTED_ANY} Data */
+
+/**
+ * @template T
+ * @callback GotHandler
+ * @param {T} result
+ * @param {() => void} callback
+ * @returns {void}
+ */
+
+/**
+ * @param {number} times times
+ * @param {(err?: Error | null) => void} callback callback
+ * @returns {(err?: Error | null) => void} callback
+ */
+const needCalls = (times, callback) => (err) => {
+	if (--times === 0) {
+		return callback(err);
+	}
+	if (err && times > 0) {
+		times = 0;
+		return callback(err);
+	}
+};
+
+class Cache {
+	constructor() {
+		this.hooks = {
+			/** @type {AsyncSeriesBailHook<[string, Etag | null, GotHandler<EXPECTED_ANY>[]], Data>} */
+			get: new AsyncSeriesBailHook(["identifier", "etag", "gotHandlers"]),
+			/** @type {AsyncParallelHook<[string, Etag | null, Data]>} */
+			store: new AsyncParallelHook(["identifier", "etag", "data"]),
+			/** @type {AsyncParallelHook<[Iterable<string>]>} */
+			storeBuildDependencies: new AsyncParallelHook(["dependencies"]),
+			/** @type {SyncHook<[]>} */
+			beginIdle: new SyncHook([]),
+			/** @type {AsyncParallelHook<[]>} */
+			endIdle: new AsyncParallelHook([]),
+			/** @type {AsyncParallelHook<[]>} */
+			shutdown: new AsyncParallelHook([])
+		};
+	}
+
+	/**
+	 * @template T
+	 * @param {string} identifier the cache identifier
+	 * @param {Etag | null} etag the etag
+	 * @param {CallbackCache<T>} callback signals when the value is retrieved
+	 * @returns {void}
+	 */
+	get(identifier, etag, callback) {
+		/** @type {GotHandler<T>[]} */
+		const gotHandlers = [];
+		this.hooks.get.callAsync(identifier, etag, gotHandlers, (err, result) => {
+			if (err) {
+				callback(makeWebpackError(err, "Cache.hooks.get"));
+				return;
+			}
+			if (result === null) {
+				result = undefined;
+			}
+			if (gotHandlers.length > 1) {
+				const innerCallback = needCalls(gotHandlers.length, () =>
+					callback(null, result)
+				);
+				for (const gotHandler of gotHandlers) {
+					gotHandler(result, innerCallback);
+				}
+			} else if (gotHandlers.length === 1) {
+				gotHandlers[0](result, () => callback(null, result));
+			} else {
+				callback(null, result);
+			}
+		});
+	}
+
+	/**
+	 * @template T
+	 * @param {string} identifier the cache identifier
+	 * @param {Etag | null} etag the etag
+	 * @param {T} data the value to store
+	 * @param {CallbackCache<void>} callback signals when the value is stored
+	 * @returns {void}
+	 */
+	store(identifier, etag, data, callback) {
+		this.hooks.store.callAsync(
+			identifier,
+			etag,
+			data,
+			makeWebpackErrorCallback(callback, "Cache.hooks.store")
+		);
+	}
+
+	/**
+	 * After this method has succeeded the cache can only be restored when build dependencies are
+	 * @param {Iterable<string>} dependencies list of all build dependencies
+	 * @param {CallbackCache<void>} callback signals when the dependencies are stored
+	 * @returns {void}
+	 */
+	storeBuildDependencies(dependencies, callback) {
+		this.hooks.storeBuildDependencies.callAsync(
+			dependencies,
+			makeWebpackErrorCallback(callback, "Cache.hooks.storeBuildDependencies")
+		);
+	}
+
+	/**
+	 * @returns {void}
+	 */
+	beginIdle() {
+		this.hooks.beginIdle.call();
+	}
+
+	/**
+	 * @param {CallbackCache<void>} callback signals when the call finishes
+	 * @returns {void}
+	 */
+	endIdle(callback) {
+		this.hooks.endIdle.callAsync(
+			makeWebpackErrorCallback(callback, "Cache.hooks.endIdle")
+		);
+	}
+
+	/**
+	 * @param {CallbackCache<void>} callback signals when the call finishes
+	 * @returns {void}
+	 */
+	shutdown(callback) {
+		this.hooks.shutdown.callAsync(
+			makeWebpackErrorCallback(callback, "Cache.hooks.shutdown")
+		);
+	}
+}
+
+Cache.STAGE_MEMORY = -10;
+Cache.STAGE_DEFAULT = 0;
+Cache.STAGE_DISK = 10;
+Cache.STAGE_NETWORK = 20;
+
+module.exports = Cache;