summaryrefslogtreecommitdiff
path: root/node_modules/webpack/lib/cache
diff options
context:
space:
mode:
Diffstat (limited to 'node_modules/webpack/lib/cache')
-rw-r--r--node_modules/webpack/lib/cache/AddBuildDependenciesPlugin.js33
-rw-r--r--node_modules/webpack/lib/cache/AddManagedPathsPlugin.js40
-rw-r--r--node_modules/webpack/lib/cache/IdleFileCachePlugin.js240
-rw-r--r--node_modules/webpack/lib/cache/MemoryCachePlugin.js57
-rw-r--r--node_modules/webpack/lib/cache/MemoryWithGcCachePlugin.js135
-rw-r--r--node_modules/webpack/lib/cache/PackFileCacheStrategy.js1501
-rw-r--r--node_modules/webpack/lib/cache/ResolverCachePlugin.js365
-rw-r--r--node_modules/webpack/lib/cache/getLazyHashedEtag.js81
-rw-r--r--node_modules/webpack/lib/cache/mergeEtags.js69
9 files changed, 2521 insertions, 0 deletions
diff --git a/node_modules/webpack/lib/cache/AddBuildDependenciesPlugin.js b/node_modules/webpack/lib/cache/AddBuildDependenciesPlugin.js
new file mode 100644
index 00000000..f2283ffc
--- /dev/null
+++ b/node_modules/webpack/lib/cache/AddBuildDependenciesPlugin.js
@@ -0,0 +1,33 @@
+/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @typedef {import("../Compiler")} Compiler */
+
+class AddBuildDependenciesPlugin {
+ /**
+ * @param {Iterable<string>} buildDependencies list of build dependencies
+ */
+ constructor(buildDependencies) {
+ this.buildDependencies = new Set(buildDependencies);
+ }
+
+ /**
+ * Apply the plugin
+ * @param {Compiler} compiler the compiler instance
+ * @returns {void}
+ */
+ apply(compiler) {
+ compiler.hooks.compilation.tap(
+ "AddBuildDependenciesPlugin",
+ compilation => {
+ compilation.buildDependencies.addAll(this.buildDependencies);
+ }
+ );
+ }
+}
+
+module.exports = AddBuildDependenciesPlugin;
diff --git a/node_modules/webpack/lib/cache/AddManagedPathsPlugin.js b/node_modules/webpack/lib/cache/AddManagedPathsPlugin.js
new file mode 100644
index 00000000..d8e860f5
--- /dev/null
+++ b/node_modules/webpack/lib/cache/AddManagedPathsPlugin.js
@@ -0,0 +1,40 @@
+/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @typedef {import("../Compiler")} Compiler */
+
+class AddManagedPathsPlugin {
+ /**
+ * @param {Iterable<string | RegExp>} managedPaths list of managed paths
+ * @param {Iterable<string | RegExp>} immutablePaths list of immutable paths
+ * @param {Iterable<string | RegExp>} unmanagedPaths list of unmanaged paths
+ */
+ constructor(managedPaths, immutablePaths, unmanagedPaths) {
+ this.managedPaths = new Set(managedPaths);
+ this.immutablePaths = new Set(immutablePaths);
+ this.unmanagedPaths = new Set(unmanagedPaths);
+ }
+
+ /**
+ * Apply the plugin
+ * @param {Compiler} compiler the compiler instance
+ * @returns {void}
+ */
+ apply(compiler) {
+ for (const managedPath of this.managedPaths) {
+ compiler.managedPaths.add(managedPath);
+ }
+ for (const immutablePath of this.immutablePaths) {
+ compiler.immutablePaths.add(immutablePath);
+ }
+ for (const unmanagedPath of this.unmanagedPaths) {
+ compiler.unmanagedPaths.add(unmanagedPath);
+ }
+ }
+}
+
+module.exports = AddManagedPathsPlugin;
diff --git a/node_modules/webpack/lib/cache/IdleFileCachePlugin.js b/node_modules/webpack/lib/cache/IdleFileCachePlugin.js
new file mode 100644
index 00000000..3ac59121
--- /dev/null
+++ b/node_modules/webpack/lib/cache/IdleFileCachePlugin.js
@@ -0,0 +1,240 @@
+/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const Cache = require("../Cache");
+const ProgressPlugin = require("../ProgressPlugin");
+
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("./PackFileCacheStrategy")} PackFileCacheStrategy */
+
+const BUILD_DEPENDENCIES_KEY = Symbol("build dependencies key");
+
+class IdleFileCachePlugin {
+ /**
+ * @param {PackFileCacheStrategy} strategy cache strategy
+ * @param {number} idleTimeout timeout
+ * @param {number} idleTimeoutForInitialStore initial timeout
+ * @param {number} idleTimeoutAfterLargeChanges timeout after changes
+ */
+ constructor(
+ strategy,
+ idleTimeout,
+ idleTimeoutForInitialStore,
+ idleTimeoutAfterLargeChanges
+ ) {
+ this.strategy = strategy;
+ this.idleTimeout = idleTimeout;
+ this.idleTimeoutForInitialStore = idleTimeoutForInitialStore;
+ this.idleTimeoutAfterLargeChanges = idleTimeoutAfterLargeChanges;
+ }
+
+ /**
+ * Apply the plugin
+ * @param {Compiler} compiler the compiler instance
+ * @returns {void}
+ */
+ apply(compiler) {
+ const strategy = this.strategy;
+ const idleTimeout = this.idleTimeout;
+ const idleTimeoutForInitialStore = Math.min(
+ idleTimeout,
+ this.idleTimeoutForInitialStore
+ );
+ const idleTimeoutAfterLargeChanges = this.idleTimeoutAfterLargeChanges;
+ const resolvedPromise = Promise.resolve();
+
+ let timeSpendInBuild = 0;
+ let timeSpendInStore = 0;
+ let avgTimeSpendInStore = 0;
+
+ /** @type {Map<string | typeof BUILD_DEPENDENCIES_KEY, () => Promise<void>>} */
+ const pendingIdleTasks = new Map();
+
+ compiler.cache.hooks.store.tap(
+ { name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+ (identifier, etag, data) => {
+ pendingIdleTasks.set(identifier, () =>
+ strategy.store(identifier, etag, data)
+ );
+ }
+ );
+
+ compiler.cache.hooks.get.tapPromise(
+ { name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+ (identifier, etag, gotHandlers) => {
+ const restore = () =>
+ strategy.restore(identifier, etag).then(cacheEntry => {
+ if (cacheEntry === undefined) {
+ gotHandlers.push((result, callback) => {
+ if (result !== undefined) {
+ pendingIdleTasks.set(identifier, () =>
+ strategy.store(identifier, etag, result)
+ );
+ }
+ callback();
+ });
+ } else {
+ return cacheEntry;
+ }
+ });
+ const pendingTask = pendingIdleTasks.get(identifier);
+ if (pendingTask !== undefined) {
+ pendingIdleTasks.delete(identifier);
+ return pendingTask().then(restore);
+ }
+ return restore();
+ }
+ );
+
+ compiler.cache.hooks.storeBuildDependencies.tap(
+ { name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+ dependencies => {
+ pendingIdleTasks.set(BUILD_DEPENDENCIES_KEY, () =>
+ Promise.resolve().then(() =>
+ strategy.storeBuildDependencies(dependencies)
+ )
+ );
+ }
+ );
+
+ compiler.cache.hooks.shutdown.tapPromise(
+ { name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+ () => {
+ if (idleTimer) {
+ clearTimeout(idleTimer);
+ idleTimer = undefined;
+ }
+ isIdle = false;
+ const reportProgress = ProgressPlugin.getReporter(compiler);
+ const jobs = Array.from(pendingIdleTasks.values());
+ if (reportProgress) reportProgress(0, "process pending cache items");
+ const promises = jobs.map(fn => fn());
+ pendingIdleTasks.clear();
+ promises.push(currentIdlePromise);
+ const promise = Promise.all(promises);
+ currentIdlePromise = promise.then(() => strategy.afterAllStored());
+ if (reportProgress) {
+ currentIdlePromise = currentIdlePromise.then(() => {
+ reportProgress(1, "stored");
+ });
+ }
+ return currentIdlePromise.then(() => {
+ // Reset strategy
+ if (strategy.clear) strategy.clear();
+ });
+ }
+ );
+
+ /** @type {Promise<any>} */
+ let currentIdlePromise = resolvedPromise;
+ let isIdle = false;
+ let isInitialStore = true;
+ const processIdleTasks = () => {
+ if (isIdle) {
+ const startTime = Date.now();
+ if (pendingIdleTasks.size > 0) {
+ const promises = [currentIdlePromise];
+ const maxTime = startTime + 100;
+ let maxCount = 100;
+ for (const [filename, factory] of pendingIdleTasks) {
+ pendingIdleTasks.delete(filename);
+ promises.push(factory());
+ if (maxCount-- <= 0 || Date.now() > maxTime) break;
+ }
+ currentIdlePromise = Promise.all(promises);
+ currentIdlePromise.then(() => {
+ timeSpendInStore += Date.now() - startTime;
+ // Allow to exit the process between
+ idleTimer = setTimeout(processIdleTasks, 0);
+ idleTimer.unref();
+ });
+ return;
+ }
+ currentIdlePromise = currentIdlePromise
+ .then(async () => {
+ await strategy.afterAllStored();
+ timeSpendInStore += Date.now() - startTime;
+ avgTimeSpendInStore =
+ Math.max(avgTimeSpendInStore, timeSpendInStore) * 0.9 +
+ timeSpendInStore * 0.1;
+ timeSpendInStore = 0;
+ timeSpendInBuild = 0;
+ })
+ .catch(err => {
+ const logger = compiler.getInfrastructureLogger(
+ "IdleFileCachePlugin"
+ );
+ logger.warn(`Background tasks during idle failed: ${err.message}`);
+ logger.debug(err.stack);
+ });
+ isInitialStore = false;
+ }
+ };
+ /** @type {ReturnType<typeof setTimeout> | undefined} */
+ let idleTimer;
+ compiler.cache.hooks.beginIdle.tap(
+ { name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+ () => {
+ const isLargeChange = timeSpendInBuild > avgTimeSpendInStore * 2;
+ if (isInitialStore && idleTimeoutForInitialStore < idleTimeout) {
+ compiler
+ .getInfrastructureLogger("IdleFileCachePlugin")
+ .log(
+ `Initial cache was generated and cache will be persisted in ${
+ idleTimeoutForInitialStore / 1000
+ }s.`
+ );
+ } else if (
+ isLargeChange &&
+ idleTimeoutAfterLargeChanges < idleTimeout
+ ) {
+ compiler
+ .getInfrastructureLogger("IdleFileCachePlugin")
+ .log(
+ `Spend ${Math.round(timeSpendInBuild) / 1000}s in build and ${
+ Math.round(avgTimeSpendInStore) / 1000
+ }s in average in cache store. This is considered as large change and cache will be persisted in ${
+ idleTimeoutAfterLargeChanges / 1000
+ }s.`
+ );
+ }
+ idleTimer = setTimeout(
+ () => {
+ idleTimer = undefined;
+ isIdle = true;
+ resolvedPromise.then(processIdleTasks);
+ },
+ Math.min(
+ isInitialStore ? idleTimeoutForInitialStore : Infinity,
+ isLargeChange ? idleTimeoutAfterLargeChanges : Infinity,
+ idleTimeout
+ )
+ );
+ idleTimer.unref();
+ }
+ );
+ compiler.cache.hooks.endIdle.tap(
+ { name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+ () => {
+ if (idleTimer) {
+ clearTimeout(idleTimer);
+ idleTimer = undefined;
+ }
+ isIdle = false;
+ }
+ );
+ compiler.hooks.done.tap("IdleFileCachePlugin", stats => {
+ // 10% build overhead is ignored, as it's not cacheable
+ timeSpendInBuild *= 0.9;
+ timeSpendInBuild +=
+ /** @type {number} */ (stats.endTime) -
+ /** @type {number} */ (stats.startTime);
+ });
+ }
+}
+
+module.exports = IdleFileCachePlugin;
diff --git a/node_modules/webpack/lib/cache/MemoryCachePlugin.js b/node_modules/webpack/lib/cache/MemoryCachePlugin.js
new file mode 100644
index 00000000..814f4cdd
--- /dev/null
+++ b/node_modules/webpack/lib/cache/MemoryCachePlugin.js
@@ -0,0 +1,57 @@
+/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const Cache = require("../Cache");
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Cache").Etag} Etag */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+
+class MemoryCachePlugin {
+ /**
+ * Apply the plugin
+ * @param {Compiler} compiler the compiler instance
+ * @returns {void}
+ */
+ apply(compiler) {
+ /** @type {Map<string, { etag: Etag | null, data: any } | null>} */
+ const cache = new Map();
+ compiler.cache.hooks.store.tap(
+ { name: "MemoryCachePlugin", stage: Cache.STAGE_MEMORY },
+ (identifier, etag, data) => {
+ cache.set(identifier, { etag, data });
+ }
+ );
+ compiler.cache.hooks.get.tap(
+ { name: "MemoryCachePlugin", stage: Cache.STAGE_MEMORY },
+ (identifier, etag, gotHandlers) => {
+ const cacheEntry = cache.get(identifier);
+ if (cacheEntry === null) {
+ return null;
+ } else if (cacheEntry !== undefined) {
+ return cacheEntry.etag === etag ? cacheEntry.data : null;
+ }
+ gotHandlers.push((result, callback) => {
+ if (result === undefined) {
+ cache.set(identifier, null);
+ } else {
+ cache.set(identifier, { etag, data: result });
+ }
+ return callback();
+ });
+ }
+ );
+ compiler.cache.hooks.shutdown.tap(
+ { name: "MemoryCachePlugin", stage: Cache.STAGE_MEMORY },
+ () => {
+ cache.clear();
+ }
+ );
+ }
+}
+module.exports = MemoryCachePlugin;
diff --git a/node_modules/webpack/lib/cache/MemoryWithGcCachePlugin.js b/node_modules/webpack/lib/cache/MemoryWithGcCachePlugin.js
new file mode 100644
index 00000000..ddfb80b1
--- /dev/null
+++ b/node_modules/webpack/lib/cache/MemoryWithGcCachePlugin.js
@@ -0,0 +1,135 @@
+/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const Cache = require("../Cache");
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Cache").Etag} Etag */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+
+class MemoryWithGcCachePlugin {
+ /**
+ * @param {object} options Options
+ * @param {number} options.maxGenerations max generations
+ */
+ constructor({ maxGenerations }) {
+ this._maxGenerations = maxGenerations;
+ }
+
+ /**
+ * Apply the plugin
+ * @param {Compiler} compiler the compiler instance
+ * @returns {void}
+ */
+ apply(compiler) {
+ const maxGenerations = this._maxGenerations;
+ /** @type {Map<string, { etag: Etag | null, data: any } | undefined | null>} */
+ const cache = new Map();
+ /** @type {Map<string, { entry: { etag: Etag | null, data: any } | null, until: number }>} */
+ const oldCache = new Map();
+ let generation = 0;
+ let cachePosition = 0;
+ const logger = compiler.getInfrastructureLogger("MemoryWithGcCachePlugin");
+ compiler.hooks.afterDone.tap("MemoryWithGcCachePlugin", () => {
+ generation++;
+ let clearedEntries = 0;
+ let lastClearedIdentifier;
+ // Avoid coverage problems due indirect changes
+ /* istanbul ignore next */
+ for (const [identifier, entry] of oldCache) {
+ if (entry.until > generation) break;
+
+ oldCache.delete(identifier);
+ if (cache.get(identifier) === undefined) {
+ cache.delete(identifier);
+ clearedEntries++;
+ lastClearedIdentifier = identifier;
+ }
+ }
+ if (clearedEntries > 0 || oldCache.size > 0) {
+ logger.log(
+ `${cache.size - oldCache.size} active entries, ${
+ oldCache.size
+ } recently unused cached entries${
+ clearedEntries > 0
+ ? `, ${clearedEntries} old unused cache entries removed e. g. ${lastClearedIdentifier}`
+ : ""
+ }`
+ );
+ }
+ let i = (cache.size / maxGenerations) | 0;
+ let j = cachePosition >= cache.size ? 0 : cachePosition;
+ cachePosition = j + i;
+ for (const [identifier, entry] of cache) {
+ if (j !== 0) {
+ j--;
+ continue;
+ }
+ if (entry !== undefined) {
+ // We don't delete the cache entry, but set it to undefined instead
+ // This reserves the location in the data table and avoids rehashing
+ // when constantly adding and removing entries.
+ // It will be deleted when removed from oldCache.
+ cache.set(identifier, undefined);
+ oldCache.delete(identifier);
+ oldCache.set(identifier, {
+ entry,
+ until: generation + maxGenerations
+ });
+ if (i-- === 0) break;
+ }
+ }
+ });
+ compiler.cache.hooks.store.tap(
+ { name: "MemoryWithGcCachePlugin", stage: Cache.STAGE_MEMORY },
+ (identifier, etag, data) => {
+ cache.set(identifier, { etag, data });
+ }
+ );
+ compiler.cache.hooks.get.tap(
+ { name: "MemoryWithGcCachePlugin", stage: Cache.STAGE_MEMORY },
+ (identifier, etag, gotHandlers) => {
+ const cacheEntry = cache.get(identifier);
+ if (cacheEntry === null) {
+ return null;
+ } else if (cacheEntry !== undefined) {
+ return cacheEntry.etag === etag ? cacheEntry.data : null;
+ }
+ const oldCacheEntry = oldCache.get(identifier);
+ if (oldCacheEntry !== undefined) {
+ const cacheEntry = oldCacheEntry.entry;
+ if (cacheEntry === null) {
+ oldCache.delete(identifier);
+ cache.set(identifier, cacheEntry);
+ return null;
+ }
+ if (cacheEntry.etag !== etag) return null;
+ oldCache.delete(identifier);
+ cache.set(identifier, cacheEntry);
+ return cacheEntry.data;
+ }
+ gotHandlers.push((result, callback) => {
+ if (result === undefined) {
+ cache.set(identifier, null);
+ } else {
+ cache.set(identifier, { etag, data: result });
+ }
+ return callback();
+ });
+ }
+ );
+ compiler.cache.hooks.shutdown.tap(
+ { name: "MemoryWithGcCachePlugin", stage: Cache.STAGE_MEMORY },
+ () => {
+ cache.clear();
+ oldCache.clear();
+ }
+ );
+ }
+}
+module.exports = MemoryWithGcCachePlugin;
diff --git a/node_modules/webpack/lib/cache/PackFileCacheStrategy.js b/node_modules/webpack/lib/cache/PackFileCacheStrategy.js
new file mode 100644
index 00000000..3f340dbc
--- /dev/null
+++ b/node_modules/webpack/lib/cache/PackFileCacheStrategy.js
@@ -0,0 +1,1501 @@
+/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const FileSystemInfo = require("../FileSystemInfo");
+const ProgressPlugin = require("../ProgressPlugin");
+const { formatSize } = require("../SizeFormatHelpers");
+const SerializerMiddleware = require("../serialization/SerializerMiddleware");
+const LazySet = require("../util/LazySet");
+const makeSerializable = require("../util/makeSerializable");
+const memoize = require("../util/memoize");
+const {
+ createFileSerializer,
+ NOT_SERIALIZABLE
+} = require("../util/serialization");
+
+/** @typedef {import("../../declarations/WebpackOptions").SnapshotOptions} SnapshotOptions */
+/** @typedef {import("../Cache").Etag} Etag */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../FileSystemInfo").ResolveBuildDependenciesResult} ResolveBuildDependenciesResult */
+/** @typedef {import("../FileSystemInfo").Snapshot} Snapshot */
+/** @typedef {import("../logging/Logger").Logger} Logger */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
+
+/** @typedef {Map<string, string | false>} ResolveResults */
+/** @typedef {Set<string>} Items */
+/** @typedef {Set<string>} BuildDependencies */
+/** @typedef {Map<string, PackItemInfo>} ItemInfo */
+
+class PackContainer {
+ /**
+ * @param {object} data stored data
+ * @param {string} version version identifier
+ * @param {Snapshot} buildSnapshot snapshot of all build dependencies
+ * @param {BuildDependencies} buildDependencies list of all unresolved build dependencies captured
+ * @param {ResolveResults} resolveResults result of the resolved build dependencies
+ * @param {Snapshot} resolveBuildDependenciesSnapshot snapshot of the dependencies of the build dependencies resolving
+ */
+ constructor(
+ data,
+ version,
+ buildSnapshot,
+ buildDependencies,
+ resolveResults,
+ resolveBuildDependenciesSnapshot
+ ) {
+ this.data = data;
+ this.version = version;
+ this.buildSnapshot = buildSnapshot;
+ this.buildDependencies = buildDependencies;
+ this.resolveResults = resolveResults;
+ this.resolveBuildDependenciesSnapshot = resolveBuildDependenciesSnapshot;
+ }
+
+ /**
+ * @param {ObjectSerializerContext} context context
+ */
+ serialize({ write, writeLazy }) {
+ write(this.version);
+ write(this.buildSnapshot);
+ write(this.buildDependencies);
+ write(this.resolveResults);
+ write(this.resolveBuildDependenciesSnapshot);
+ /** @type {NonNullable<ObjectSerializerContext["writeLazy"]>} */
+ (writeLazy)(this.data);
+ }
+
+ /**
+ * @param {ObjectDeserializerContext} context context
+ */
+ deserialize({ read }) {
+ this.version = read();
+ this.buildSnapshot = read();
+ this.buildDependencies = read();
+ this.resolveResults = read();
+ this.resolveBuildDependenciesSnapshot = read();
+ this.data = read();
+ }
+}
+
+makeSerializable(
+ PackContainer,
+ "webpack/lib/cache/PackFileCacheStrategy",
+ "PackContainer"
+);
+
+const MIN_CONTENT_SIZE = 1024 * 1024; // 1 MB
+const CONTENT_COUNT_TO_MERGE = 10;
+const MIN_ITEMS_IN_FRESH_PACK = 100;
+const MAX_ITEMS_IN_FRESH_PACK = 50000;
+const MAX_TIME_IN_FRESH_PACK = 1 * 60 * 1000; // 1 min
+
+class PackItemInfo {
+ /**
+ * @param {string} identifier identifier of item
+ * @param {string | null} etag etag of item
+ * @param {any} value fresh value of item
+ */
+ constructor(identifier, etag, value) {
+ this.identifier = identifier;
+ this.etag = etag;
+ this.location = -1;
+ this.lastAccess = Date.now();
+ this.freshValue = value;
+ }
+}
+
+class Pack {
+ /**
+ * @param {Logger} logger a logger
+ * @param {number} maxAge max age of cache items
+ */
+ constructor(logger, maxAge) {
+ /** @type {ItemInfo} */
+ this.itemInfo = new Map();
+ /** @type {(string | undefined)[]} */
+ this.requests = [];
+ this.requestsTimeout = undefined;
+ /** @type {ItemInfo} */
+ this.freshContent = new Map();
+ /** @type {(undefined | PackContent)[]} */
+ this.content = [];
+ this.invalid = false;
+ this.logger = logger;
+ this.maxAge = maxAge;
+ }
+
+ /**
+ * @param {string} identifier identifier
+ */
+ _addRequest(identifier) {
+ this.requests.push(identifier);
+ if (this.requestsTimeout === undefined) {
+ this.requestsTimeout = setTimeout(() => {
+ this.requests.push(undefined);
+ this.requestsTimeout = undefined;
+ }, MAX_TIME_IN_FRESH_PACK);
+ if (this.requestsTimeout.unref) this.requestsTimeout.unref();
+ }
+ }
+
+ stopCapturingRequests() {
+ if (this.requestsTimeout !== undefined) {
+ clearTimeout(this.requestsTimeout);
+ this.requestsTimeout = undefined;
+ }
+ }
+
+ /**
+ * @param {string} identifier unique name for the resource
+ * @param {string | null} etag etag of the resource
+ * @returns {any} cached content
+ */
+ get(identifier, etag) {
+ const info = this.itemInfo.get(identifier);
+ this._addRequest(identifier);
+ if (info === undefined) {
+ return;
+ }
+ if (info.etag !== etag) return null;
+ info.lastAccess = Date.now();
+ const loc = info.location;
+ if (loc === -1) {
+ return info.freshValue;
+ }
+ if (!this.content[loc]) {
+ return;
+ }
+ return /** @type {PackContent} */ (this.content[loc]).get(identifier);
+ }
+
+ /**
+ * @param {string} identifier unique name for the resource
+ * @param {string | null} etag etag of the resource
+ * @param {any} data cached content
+ * @returns {void}
+ */
+ set(identifier, etag, data) {
+ if (!this.invalid) {
+ this.invalid = true;
+ this.logger.log(`Pack got invalid because of write to: ${identifier}`);
+ }
+ const info = this.itemInfo.get(identifier);
+ if (info === undefined) {
+ const newInfo = new PackItemInfo(identifier, etag, data);
+ this.itemInfo.set(identifier, newInfo);
+ this._addRequest(identifier);
+ this.freshContent.set(identifier, newInfo);
+ } else {
+ const loc = info.location;
+ if (loc >= 0) {
+ this._addRequest(identifier);
+ this.freshContent.set(identifier, info);
+ const content = /** @type {PackContent} */ (this.content[loc]);
+ content.delete(identifier);
+ if (content.items.size === 0) {
+ this.content[loc] = undefined;
+ this.logger.debug("Pack %d got empty and is removed", loc);
+ }
+ }
+ info.freshValue = data;
+ info.lastAccess = Date.now();
+ info.etag = etag;
+ info.location = -1;
+ }
+ }
+
+ getContentStats() {
+ let count = 0;
+ let size = 0;
+ for (const content of this.content) {
+ if (content !== undefined) {
+ count++;
+ const s = content.getSize();
+ if (s > 0) {
+ size += s;
+ }
+ }
+ }
+ return { count, size };
+ }
+
+ /**
+ * @returns {number} new location of data entries
+ */
+ _findLocation() {
+ let i;
+ for (i = 0; i < this.content.length && this.content[i] !== undefined; i++);
+ return i;
+ }
+
+ /**
+ * @private
+ * @param {Items} items items
+ * @param {Items} usedItems used items
+ * @param {number} newLoc new location
+ */
+ _gcAndUpdateLocation(items, usedItems, newLoc) {
+ let count = 0;
+ let lastGC;
+ const now = Date.now();
+ for (const identifier of items) {
+ const info = /** @type {PackItemInfo} */ (this.itemInfo.get(identifier));
+ if (now - info.lastAccess > this.maxAge) {
+ this.itemInfo.delete(identifier);
+ items.delete(identifier);
+ usedItems.delete(identifier);
+ count++;
+ lastGC = identifier;
+ } else {
+ info.location = newLoc;
+ }
+ }
+ if (count > 0) {
+ this.logger.log(
+ "Garbage Collected %d old items at pack %d (%d items remaining) e. g. %s",
+ count,
+ newLoc,
+ items.size,
+ lastGC
+ );
+ }
+ }
+
+ _persistFreshContent() {
+ const itemsCount = this.freshContent.size;
+ if (itemsCount > 0) {
+ const packCount = Math.ceil(itemsCount / MAX_ITEMS_IN_FRESH_PACK);
+ const itemsPerPack = Math.ceil(itemsCount / packCount);
+ const packs = [];
+ let i = 0;
+ let ignoreNextTimeTick = false;
+ const createNextPack = () => {
+ const loc = this._findLocation();
+ this.content[loc] = null; // reserve
+ const pack = {
+ /** @type {Items} */
+ items: new Set(),
+ /** @type {Map<string, any>} */
+ map: new Map(),
+ loc
+ };
+ packs.push(pack);
+ return pack;
+ };
+ let pack = createNextPack();
+ if (this.requestsTimeout !== undefined)
+ clearTimeout(this.requestsTimeout);
+ for (const identifier of this.requests) {
+ if (identifier === undefined) {
+ if (ignoreNextTimeTick) {
+ ignoreNextTimeTick = false;
+ } else if (pack.items.size >= MIN_ITEMS_IN_FRESH_PACK) {
+ i = 0;
+ pack = createNextPack();
+ }
+ continue;
+ }
+ const info = this.freshContent.get(identifier);
+ if (info === undefined) continue;
+ pack.items.add(identifier);
+ pack.map.set(identifier, info.freshValue);
+ info.location = pack.loc;
+ info.freshValue = undefined;
+ this.freshContent.delete(identifier);
+ if (++i > itemsPerPack) {
+ i = 0;
+ pack = createNextPack();
+ ignoreNextTimeTick = true;
+ }
+ }
+ this.requests.length = 0;
+ for (const pack of packs) {
+ this.content[pack.loc] = new PackContent(
+ pack.items,
+ new Set(pack.items),
+ new PackContentItems(pack.map)
+ );
+ }
+ this.logger.log(
+ `${itemsCount} fresh items in cache put into pack ${
+ packs.length > 1
+ ? packs
+ .map(pack => `${pack.loc} (${pack.items.size} items)`)
+ .join(", ")
+ : packs[0].loc
+ }`
+ );
+ }
+ }
+
+ /**
+ * Merges small content files to a single content file
+ */
+ _optimizeSmallContent() {
+ // 1. Find all small content files
+ // Treat unused content files separately to avoid
+ // a merge-split cycle
+ /** @type {number[]} */
+ const smallUsedContents = [];
+ /** @type {number} */
+ let smallUsedContentSize = 0;
+ /** @type {number[]} */
+ const smallUnusedContents = [];
+ /** @type {number} */
+ let smallUnusedContentSize = 0;
+ for (let i = 0; i < this.content.length; i++) {
+ const content = this.content[i];
+ if (content === undefined) continue;
+ if (content.outdated) continue;
+ const size = content.getSize();
+ if (size < 0 || size > MIN_CONTENT_SIZE) continue;
+ if (content.used.size > 0) {
+ smallUsedContents.push(i);
+ smallUsedContentSize += size;
+ } else {
+ smallUnusedContents.push(i);
+ smallUnusedContentSize += size;
+ }
+ }
+
+ // 2. Check if minimum number is reached
+ let mergedIndices;
+ if (
+ smallUsedContents.length >= CONTENT_COUNT_TO_MERGE ||
+ smallUsedContentSize > MIN_CONTENT_SIZE
+ ) {
+ mergedIndices = smallUsedContents;
+ } else if (
+ smallUnusedContents.length >= CONTENT_COUNT_TO_MERGE ||
+ smallUnusedContentSize > MIN_CONTENT_SIZE
+ ) {
+ mergedIndices = smallUnusedContents;
+ } else return;
+
+ /** @type {PackContent[] } */
+ const mergedContent = [];
+
+ // 3. Remove old content entries
+ for (const i of mergedIndices) {
+ mergedContent.push(/** @type {PackContent} */ (this.content[i]));
+ this.content[i] = undefined;
+ }
+
+ // 4. Determine merged items
+ /** @type {Items} */
+ const mergedItems = new Set();
+ /** @type {Items} */
+ const mergedUsedItems = new Set();
+ /** @type {(function(Map<string, any>): Promise<void>)[]} */
+ const addToMergedMap = [];
+ for (const content of mergedContent) {
+ for (const identifier of content.items) {
+ mergedItems.add(identifier);
+ }
+ for (const identifier of content.used) {
+ mergedUsedItems.add(identifier);
+ }
+ addToMergedMap.push(async map => {
+ // unpack existing content
+ // after that values are accessible in .content
+ await content.unpack(
+ "it should be merged with other small pack contents"
+ );
+ for (const [identifier, value] of content.content) {
+ map.set(identifier, value);
+ }
+ });
+ }
+
+ // 5. GC and update location of merged items
+ const newLoc = this._findLocation();
+ this._gcAndUpdateLocation(mergedItems, mergedUsedItems, newLoc);
+
+ // 6. If not empty, store content somewhere
+ if (mergedItems.size > 0) {
+ this.content[newLoc] = new PackContent(
+ mergedItems,
+ mergedUsedItems,
+ memoize(async () => {
+ /** @type {Map<string, any>} */
+ const map = new Map();
+ await Promise.all(addToMergedMap.map(fn => fn(map)));
+ return new PackContentItems(map);
+ })
+ );
+ this.logger.log(
+ "Merged %d small files with %d cache items into pack %d",
+ mergedContent.length,
+ mergedItems.size,
+ newLoc
+ );
+ }
+ }
+
+ /**
+ * Split large content files with used and unused items
+ * into two parts to separate used from unused items
+ */
+ _optimizeUnusedContent() {
+ // 1. Find a large content file with used and unused items
+ for (let i = 0; i < this.content.length; i++) {
+ const content = this.content[i];
+ if (content === undefined) continue;
+ const size = content.getSize();
+ if (size < MIN_CONTENT_SIZE) continue;
+ const used = content.used.size;
+ const total = content.items.size;
+ if (used > 0 && used < total) {
+ // 2. Remove this content
+ this.content[i] = undefined;
+
+ // 3. Determine items for the used content file
+ const usedItems = new Set(content.used);
+ const newLoc = this._findLocation();
+ this._gcAndUpdateLocation(usedItems, usedItems, newLoc);
+
+ // 4. Create content file for used items
+ if (usedItems.size > 0) {
+ this.content[newLoc] = new PackContent(
+ usedItems,
+ new Set(usedItems),
+ async () => {
+ await content.unpack(
+ "it should be splitted into used and unused items"
+ );
+ const map = new Map();
+ for (const identifier of usedItems) {
+ map.set(identifier, content.content.get(identifier));
+ }
+ return new PackContentItems(map);
+ }
+ );
+ }
+
+ // 5. Determine items for the unused content file
+ const unusedItems = new Set(content.items);
+ const usedOfUnusedItems = new Set();
+ for (const identifier of usedItems) {
+ unusedItems.delete(identifier);
+ }
+ const newUnusedLoc = this._findLocation();
+ this._gcAndUpdateLocation(unusedItems, usedOfUnusedItems, newUnusedLoc);
+
+ // 6. Create content file for unused items
+ if (unusedItems.size > 0) {
+ this.content[newUnusedLoc] = new PackContent(
+ unusedItems,
+ usedOfUnusedItems,
+ async () => {
+ await content.unpack(
+ "it should be splitted into used and unused items"
+ );
+ const map = new Map();
+ for (const identifier of unusedItems) {
+ map.set(identifier, content.content.get(identifier));
+ }
+ return new PackContentItems(map);
+ }
+ );
+ }
+
+ this.logger.log(
+ "Split pack %d into pack %d with %d used items and pack %d with %d unused items",
+ i,
+ newLoc,
+ usedItems.size,
+ newUnusedLoc,
+ unusedItems.size
+ );
+
+ // optimizing only one of them is good enough and
+ // reduces the amount of serialization needed
+ return;
+ }
+ }
+ }
+
+ /**
+ * Find the content with the oldest item and run GC on that.
+ * Only runs for one content to avoid large invalidation.
+ */
+ _gcOldestContent() {
+ /** @type {PackItemInfo | undefined} */
+ let oldest;
+ for (const info of this.itemInfo.values()) {
+ if (oldest === undefined || info.lastAccess < oldest.lastAccess) {
+ oldest = info;
+ }
+ }
+ if (
+ Date.now() - /** @type {PackItemInfo} */ (oldest).lastAccess >
+ this.maxAge
+ ) {
+ const loc = /** @type {PackItemInfo} */ (oldest).location;
+ if (loc < 0) return;
+ const content = /** @type {PackContent} */ (this.content[loc]);
+ const items = new Set(content.items);
+ const usedItems = new Set(content.used);
+ this._gcAndUpdateLocation(items, usedItems, loc);
+
+ this.content[loc] =
+ items.size > 0
+ ? new PackContent(items, usedItems, async () => {
+ await content.unpack(
+ "it contains old items that should be garbage collected"
+ );
+ const map = new Map();
+ for (const identifier of items) {
+ map.set(identifier, content.content.get(identifier));
+ }
+ return new PackContentItems(map);
+ })
+ : undefined;
+ }
+ }
+
+ /**
+ * @param {ObjectSerializerContext} context context
+ */
+ serialize({ write, writeSeparate }) {
+ this._persistFreshContent();
+ this._optimizeSmallContent();
+ this._optimizeUnusedContent();
+ this._gcOldestContent();
+ for (const identifier of this.itemInfo.keys()) {
+ write(identifier);
+ }
+ write(null); // null as marker of the end of keys
+ for (const info of this.itemInfo.values()) {
+ write(info.etag);
+ }
+ for (const info of this.itemInfo.values()) {
+ write(info.lastAccess);
+ }
+ for (let i = 0; i < this.content.length; i++) {
+ const content = this.content[i];
+ if (content !== undefined) {
+ write(content.items);
+ content.writeLazy(lazy => writeSeparate(lazy, { name: `${i}` }));
+ } else {
+ write(undefined); // undefined marks an empty content slot
+ }
+ }
+ write(null); // null as marker of the end of items
+ }
+
+ /**
+ * @param {ObjectDeserializerContext & { logger: Logger }} context context
+ */
+ deserialize({ read, logger }) {
+ this.logger = logger;
+ {
+ const items = [];
+ let item = read();
+ while (item !== null) {
+ items.push(item);
+ item = read();
+ }
+ this.itemInfo.clear();
+ const infoItems = items.map(identifier => {
+ const info = new PackItemInfo(identifier, undefined, undefined);
+ this.itemInfo.set(identifier, info);
+ return info;
+ });
+ for (const info of infoItems) {
+ info.etag = read();
+ }
+ for (const info of infoItems) {
+ info.lastAccess = read();
+ }
+ }
+ this.content.length = 0;
+ let items = read();
+ while (items !== null) {
+ if (items === undefined) {
+ this.content.push(items);
+ } else {
+ const idx = this.content.length;
+ const lazy = read();
+ this.content.push(
+ new PackContent(
+ items,
+ new Set(),
+ lazy,
+ logger,
+ `${this.content.length}`
+ )
+ );
+ for (const identifier of items) {
+ this.itemInfo.get(identifier).location = idx;
+ }
+ }
+ items = read();
+ }
+ }
+}
+
+makeSerializable(Pack, "webpack/lib/cache/PackFileCacheStrategy", "Pack");
+
+class PackContentItems {
+ /**
+ * @param {Map<string, any>} map items
+ */
+ constructor(map) {
+ this.map = map;
+ }
+
+ /**
+ * @param {ObjectSerializerContext & { snapshot: TODO, rollback: TODO, logger: Logger, profile: boolean | undefined }} context context
+ */
+ serialize({ write, snapshot, rollback, logger, profile }) {
+ if (profile) {
+ write(false);
+ for (const [key, value] of this.map) {
+ const s = snapshot();
+ try {
+ write(key);
+ const start = process.hrtime();
+ write(value);
+ const durationHr = process.hrtime(start);
+ const duration = durationHr[0] * 1000 + durationHr[1] / 1e6;
+ if (duration > 1) {
+ if (duration > 500)
+ logger.error(`Serialization of '${key}': ${duration} ms`);
+ else if (duration > 50)
+ logger.warn(`Serialization of '${key}': ${duration} ms`);
+ else if (duration > 10)
+ logger.info(`Serialization of '${key}': ${duration} ms`);
+ else if (duration > 5)
+ logger.log(`Serialization of '${key}': ${duration} ms`);
+ else logger.debug(`Serialization of '${key}': ${duration} ms`);
+ }
+ } catch (err) {
+ rollback(s);
+ if (err === NOT_SERIALIZABLE) continue;
+ const msg = "Skipped not serializable cache item";
+ if (err.message.includes("ModuleBuildError")) {
+ logger.log(`${msg} (in build error): ${err.message}`);
+ logger.debug(`${msg} '${key}' (in build error): ${err.stack}`);
+ } else {
+ logger.warn(`${msg}: ${err.message}`);
+ logger.debug(`${msg} '${key}': ${err.stack}`);
+ }
+ }
+ }
+ write(null);
+ return;
+ }
+ // Try to serialize all at once
+ const s = snapshot();
+ try {
+ write(true);
+ write(this.map);
+ } catch (_err) {
+ rollback(s);
+
+ // Try to serialize each item on it's own
+ write(false);
+ for (const [key, value] of this.map) {
+ const s = snapshot();
+ try {
+ write(key);
+ write(value);
+ } catch (err) {
+ rollback(s);
+ if (err === NOT_SERIALIZABLE) continue;
+ logger.warn(
+ `Skipped not serializable cache item '${key}': ${err.message}`
+ );
+ logger.debug(err.stack);
+ }
+ }
+ write(null);
+ }
+ }
+
+ /**
+ * @param {ObjectDeserializerContext & { logger: Logger, profile: boolean | undefined }} context context
+ */
+ deserialize({ read, logger, profile }) {
+ if (read()) {
+ this.map = read();
+ } else if (profile) {
+ const map = new Map();
+ let key = read();
+ while (key !== null) {
+ const start = process.hrtime();
+ const value = read();
+ const durationHr = process.hrtime(start);
+ const duration = durationHr[0] * 1000 + durationHr[1] / 1e6;
+ if (duration > 1) {
+ if (duration > 100)
+ logger.error(`Deserialization of '${key}': ${duration} ms`);
+ else if (duration > 20)
+ logger.warn(`Deserialization of '${key}': ${duration} ms`);
+ else if (duration > 5)
+ logger.info(`Deserialization of '${key}': ${duration} ms`);
+ else if (duration > 2)
+ logger.log(`Deserialization of '${key}': ${duration} ms`);
+ else logger.debug(`Deserialization of '${key}': ${duration} ms`);
+ }
+ map.set(key, value);
+ key = read();
+ }
+ this.map = map;
+ } else {
+ const map = new Map();
+ let key = read();
+ while (key !== null) {
+ map.set(key, read());
+ key = read();
+ }
+ this.map = map;
+ }
+ }
+}
+
+makeSerializable(
+ PackContentItems,
+ "webpack/lib/cache/PackFileCacheStrategy",
+ "PackContentItems"
+);
+
+class PackContent {
+ /*
+ This class can be in these states:
+ | this.lazy | this.content | this.outdated | state
+ A1 | undefined | Map | false | fresh content
+ A2 | undefined | Map | true | (will not happen)
+ B1 | lazy () => {} | undefined | false | not deserialized
+ B2 | lazy () => {} | undefined | true | not deserialized, but some items has been removed
+ C1 | lazy* () => {} | Map | false | deserialized
+ C2 | lazy* () => {} | Map | true | deserialized, and some items has been removed
+
+ this.used is a subset of this.items.
+ this.items is a subset of this.content.keys() resp. this.lazy().map.keys()
+ When this.outdated === false, this.items === this.content.keys() resp. this.lazy().map.keys()
+ When this.outdated === true, this.items should be used to recreated this.lazy/this.content.
+ When this.lazy and this.content is set, they contain the same data.
+ this.get must only be called with a valid item from this.items.
+ In state C this.lazy is unMemoized
+ */
+
+ /**
+ * @param {Items} items keys
+ * @param {Items} usedItems used keys
+ * @param {PackContentItems | function(): Promise<PackContentItems>} dataOrFn sync or async content
+ * @param {Logger=} logger logger for logging
+ * @param {string=} lazyName name of dataOrFn for logging
+ */
+ constructor(items, usedItems, dataOrFn, logger, lazyName) {
+ this.items = items;
+ /** @type {(function(): Promise<PackContentItems> | PackContentItems) | undefined} */
+ this.lazy = typeof dataOrFn === "function" ? dataOrFn : undefined;
+ /** @type {Map<string, any> | undefined} */
+ this.content = typeof dataOrFn === "function" ? undefined : dataOrFn.map;
+ this.outdated = false;
+ this.used = usedItems;
+ this.logger = logger;
+ this.lazyName = lazyName;
+ }
+
+ /**
+ * @param {string} identifier identifier
+ * @returns {string | Promise<string>} result
+ */
+ get(identifier) {
+ this.used.add(identifier);
+ if (this.content) {
+ return this.content.get(identifier);
+ }
+
+ const logger = /** @type {Logger} */ (this.logger);
+ // We are in state B
+ const { lazyName } = this;
+ /** @type {string | undefined} */
+ let timeMessage;
+ if (lazyName) {
+ // only log once
+ this.lazyName = undefined;
+ timeMessage = `restore cache content ${lazyName} (${formatSize(
+ this.getSize()
+ )})`;
+ logger.log(
+ `starting to restore cache content ${lazyName} (${formatSize(
+ this.getSize()
+ )}) because of request to: ${identifier}`
+ );
+ logger.time(timeMessage);
+ }
+ const value = this.lazy();
+ if ("then" in value) {
+ return value.then(data => {
+ const map = data.map;
+ if (timeMessage) {
+ logger.timeEnd(timeMessage);
+ }
+ // Move to state C
+ this.content = map;
+ this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy);
+ return map.get(identifier);
+ });
+ }
+
+ const map = value.map;
+ if (timeMessage) {
+ logger.timeEnd(timeMessage);
+ }
+ // Move to state C
+ this.content = map;
+ this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy);
+ return map.get(identifier);
+ }
+
+ /**
+ * @param {string} reason explanation why unpack is necessary
+ * @returns {void | Promise<void>} maybe a promise if lazy
+ */
+ unpack(reason) {
+ if (this.content) return;
+
+ const logger = /** @type {Logger} */ (this.logger);
+ // Move from state B to C
+ if (this.lazy) {
+ const { lazyName } = this;
+ /** @type {string | undefined} */
+ let timeMessage;
+ if (lazyName) {
+ // only log once
+ this.lazyName = undefined;
+ timeMessage = `unpack cache content ${lazyName} (${formatSize(
+ this.getSize()
+ )})`;
+ logger.log(
+ `starting to unpack cache content ${lazyName} (${formatSize(
+ this.getSize()
+ )}) because ${reason}`
+ );
+ logger.time(timeMessage);
+ }
+ const value = this.lazy();
+ if ("then" in value) {
+ return value.then(data => {
+ if (timeMessage) {
+ logger.timeEnd(timeMessage);
+ }
+ this.content = data.map;
+ });
+ }
+ if (timeMessage) {
+ logger.timeEnd(timeMessage);
+ }
+ this.content = value.map;
+ }
+ }
+
+ /**
+ * @returns {number} size of the content or -1 if not known
+ */
+ getSize() {
+ if (!this.lazy) return -1;
+ const options = /** @type {any} */ (this.lazy).options;
+ if (!options) return -1;
+ const size = options.size;
+ if (typeof size !== "number") return -1;
+ return size;
+ }
+
+ /**
+ * @param {string} identifier identifier
+ */
+ delete(identifier) {
+ this.items.delete(identifier);
+ this.used.delete(identifier);
+ this.outdated = true;
+ }
+
+ /**
+ * @template T
+ * @param {function(any): function(): Promise<PackContentItems> | PackContentItems} write write function
+ * @returns {void}
+ */
+ writeLazy(write) {
+ if (!this.outdated && this.lazy) {
+ // State B1 or C1
+ // this.lazy is still the valid deserialized version
+ write(this.lazy);
+ return;
+ }
+ if (!this.outdated && this.content) {
+ // State A1
+ const map = new Map(this.content);
+ // Move to state C1
+ this.lazy = SerializerMiddleware.unMemoizeLazy(
+ write(() => new PackContentItems(map))
+ );
+ return;
+ }
+ if (this.content) {
+ // State A2 or C2
+ /** @type {Map<string, any>} */
+ const map = new Map();
+ for (const item of this.items) {
+ map.set(item, this.content.get(item));
+ }
+ // Move to state C1
+ this.outdated = false;
+ this.content = map;
+ this.lazy = SerializerMiddleware.unMemoizeLazy(
+ write(() => new PackContentItems(map))
+ );
+ return;
+ }
+ const logger = /** @type {Logger} */ (this.logger);
+ // State B2
+ const { lazyName } = this;
+ /** @type {string | undefined} */
+ let timeMessage;
+ if (lazyName) {
+ // only log once
+ this.lazyName = undefined;
+ timeMessage = `unpack cache content ${lazyName} (${formatSize(
+ this.getSize()
+ )})`;
+ logger.log(
+ `starting to unpack cache content ${lazyName} (${formatSize(
+ this.getSize()
+ )}) because it's outdated and need to be serialized`
+ );
+ logger.time(timeMessage);
+ }
+ const value = this.lazy();
+ this.outdated = false;
+ if ("then" in value) {
+ // Move to state B1
+ this.lazy = write(() =>
+ value.then(data => {
+ if (timeMessage) {
+ logger.timeEnd(timeMessage);
+ }
+ const oldMap = data.map;
+ /** @type {Map<string, any>} */
+ const map = new Map();
+ for (const item of this.items) {
+ map.set(item, oldMap.get(item));
+ }
+ // Move to state C1 (or maybe C2)
+ this.content = map;
+ this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy);
+
+ return new PackContentItems(map);
+ })
+ );
+ } else {
+ // Move to state C1
+ if (timeMessage) {
+ logger.timeEnd(timeMessage);
+ }
+ const oldMap = value.map;
+ /** @type {Map<string, any>} */
+ const map = new Map();
+ for (const item of this.items) {
+ map.set(item, oldMap.get(item));
+ }
+ this.content = map;
+ this.lazy = write(() => new PackContentItems(map));
+ }
+ }
+}
+
+/**
+ * @param {Buffer} buf buffer
+ * @returns {Buffer} buffer that can be collected
+ */
+const allowCollectingMemory = buf => {
+ const wasted = buf.buffer.byteLength - buf.byteLength;
+ if (wasted > 8192 && (wasted > 1048576 || wasted > buf.byteLength)) {
+ return Buffer.from(buf);
+ }
+ return buf;
+};
+
+class PackFileCacheStrategy {
+ /**
+ * @param {object} options options
+ * @param {Compiler} options.compiler the compiler
+ * @param {IntermediateFileSystem} options.fs the filesystem
+ * @param {string} options.context the context directory
+ * @param {string} options.cacheLocation the location of the cache data
+ * @param {string} options.version version identifier
+ * @param {Logger} options.logger a logger
+ * @param {SnapshotOptions} options.snapshot options regarding snapshotting
+ * @param {number} options.maxAge max age of cache items
+ * @param {boolean | undefined} options.profile track and log detailed timing information for individual cache items
+ * @param {boolean | undefined} options.allowCollectingMemory allow to collect unused memory created during deserialization
+ * @param {false | "gzip" | "brotli" | undefined} options.compression compression used
+ * @param {boolean | undefined} options.readonly disable storing cache into filesystem
+ */
+ constructor({
+ compiler,
+ fs,
+ context,
+ cacheLocation,
+ version,
+ logger,
+ snapshot,
+ maxAge,
+ profile,
+ allowCollectingMemory,
+ compression,
+ readonly
+ }) {
+ this.fileSerializer = createFileSerializer(
+ fs,
+ compiler.options.output.hashFunction
+ );
+ this.fileSystemInfo = new FileSystemInfo(fs, {
+ managedPaths: snapshot.managedPaths,
+ immutablePaths: snapshot.immutablePaths,
+ logger: logger.getChildLogger("webpack.FileSystemInfo"),
+ hashFunction: compiler.options.output.hashFunction
+ });
+ this.compiler = compiler;
+ this.context = context;
+ this.cacheLocation = cacheLocation;
+ this.version = version;
+ this.logger = logger;
+ this.maxAge = maxAge;
+ this.profile = profile;
+ this.readonly = readonly;
+ this.allowCollectingMemory = allowCollectingMemory;
+ this.compression = compression;
+ this._extension =
+ compression === "brotli"
+ ? ".pack.br"
+ : compression === "gzip"
+ ? ".pack.gz"
+ : ".pack";
+ this.snapshot = snapshot;
+ /** @type {BuildDependencies} */
+ this.buildDependencies = new Set();
+ /** @type {LazySet<string>} */
+ this.newBuildDependencies = new LazySet();
+ /** @type {Snapshot | undefined} */
+ this.resolveBuildDependenciesSnapshot = undefined;
+ /** @type {ResolveResults | undefined} */
+ this.resolveResults = undefined;
+ /** @type {Snapshot | undefined} */
+ this.buildSnapshot = undefined;
+ /** @type {Promise<Pack> | undefined} */
+ this.packPromise = this._openPack();
+ this.storePromise = Promise.resolve();
+ }
+
+ /**
+ * @returns {Promise<Pack>} pack
+ */
+ _getPack() {
+ if (this.packPromise === undefined) {
+ this.packPromise = this.storePromise.then(() => this._openPack());
+ }
+ return this.packPromise;
+ }
+
+ /**
+ * @returns {Promise<Pack>} the pack
+ */
+ _openPack() {
+ const { logger, profile, cacheLocation, version } = this;
+ /** @type {Snapshot} */
+ let buildSnapshot;
+ /** @type {BuildDependencies} */
+ let buildDependencies;
+ /** @type {BuildDependencies} */
+ let newBuildDependencies;
+ /** @type {Snapshot} */
+ let resolveBuildDependenciesSnapshot;
+ /** @type {ResolveResults | undefined} */
+ let resolveResults;
+ logger.time("restore cache container");
+ return this.fileSerializer
+ .deserialize(null, {
+ filename: `${cacheLocation}/index${this._extension}`,
+ extension: `${this._extension}`,
+ logger,
+ profile,
+ retainedBuffer: this.allowCollectingMemory
+ ? allowCollectingMemory
+ : undefined
+ })
+ .catch(err => {
+ if (err.code !== "ENOENT") {
+ logger.warn(
+ `Restoring pack failed from ${cacheLocation}${this._extension}: ${err}`
+ );
+ logger.debug(err.stack);
+ } else {
+ logger.debug(
+ `No pack exists at ${cacheLocation}${this._extension}: ${err}`
+ );
+ }
+ return undefined;
+ })
+ .then(packContainer => {
+ logger.timeEnd("restore cache container");
+ if (!packContainer) return;
+ if (!(packContainer instanceof PackContainer)) {
+ logger.warn(
+ `Restored pack from ${cacheLocation}${this._extension}, but contained content is unexpected.`,
+ packContainer
+ );
+ return;
+ }
+ if (packContainer.version !== version) {
+ logger.log(
+ `Restored pack from ${cacheLocation}${this._extension}, but version doesn't match.`
+ );
+ return;
+ }
+ logger.time("check build dependencies");
+ return Promise.all([
+ new Promise((resolve, reject) => {
+ this.fileSystemInfo.checkSnapshotValid(
+ packContainer.buildSnapshot,
+ (err, valid) => {
+ if (err) {
+ logger.log(
+ `Restored pack from ${cacheLocation}${this._extension}, but checking snapshot of build dependencies errored: ${err}.`
+ );
+ logger.debug(err.stack);
+ return resolve(false);
+ }
+ if (!valid) {
+ logger.log(
+ `Restored pack from ${cacheLocation}${this._extension}, but build dependencies have changed.`
+ );
+ return resolve(false);
+ }
+ buildSnapshot = packContainer.buildSnapshot;
+ return resolve(true);
+ }
+ );
+ }),
+ new Promise((resolve, reject) => {
+ this.fileSystemInfo.checkSnapshotValid(
+ packContainer.resolveBuildDependenciesSnapshot,
+ (err, valid) => {
+ if (err) {
+ logger.log(
+ `Restored pack from ${cacheLocation}${this._extension}, but checking snapshot of resolving of build dependencies errored: ${err}.`
+ );
+ logger.debug(err.stack);
+ return resolve(false);
+ }
+ if (valid) {
+ resolveBuildDependenciesSnapshot =
+ packContainer.resolveBuildDependenciesSnapshot;
+ buildDependencies = packContainer.buildDependencies;
+ resolveResults = packContainer.resolveResults;
+ return resolve(true);
+ }
+ logger.log(
+ "resolving of build dependencies is invalid, will re-resolve build dependencies"
+ );
+ this.fileSystemInfo.checkResolveResultsValid(
+ packContainer.resolveResults,
+ (err, valid) => {
+ if (err) {
+ logger.log(
+ `Restored pack from ${cacheLocation}${this._extension}, but resolving of build dependencies errored: ${err}.`
+ );
+ logger.debug(err.stack);
+ return resolve(false);
+ }
+ if (valid) {
+ newBuildDependencies = packContainer.buildDependencies;
+ resolveResults = packContainer.resolveResults;
+ return resolve(true);
+ }
+ logger.log(
+ `Restored pack from ${cacheLocation}${this._extension}, but build dependencies resolve to different locations.`
+ );
+ return resolve(false);
+ }
+ );
+ }
+ );
+ })
+ ])
+ .catch(err => {
+ logger.timeEnd("check build dependencies");
+ throw err;
+ })
+ .then(([buildSnapshotValid, resolveValid]) => {
+ logger.timeEnd("check build dependencies");
+ if (buildSnapshotValid && resolveValid) {
+ logger.time("restore cache content metadata");
+ const d = packContainer.data();
+ logger.timeEnd("restore cache content metadata");
+ return d;
+ }
+ return undefined;
+ });
+ })
+ .then(pack => {
+ if (pack) {
+ pack.maxAge = this.maxAge;
+ this.buildSnapshot = buildSnapshot;
+ if (buildDependencies) this.buildDependencies = buildDependencies;
+ if (newBuildDependencies)
+ this.newBuildDependencies.addAll(newBuildDependencies);
+ this.resolveResults = resolveResults;
+ this.resolveBuildDependenciesSnapshot =
+ resolveBuildDependenciesSnapshot;
+ return pack;
+ }
+ return new Pack(logger, this.maxAge);
+ })
+ .catch(err => {
+ this.logger.warn(
+ `Restoring pack from ${cacheLocation}${this._extension} failed: ${err}`
+ );
+ this.logger.debug(err.stack);
+ return new Pack(logger, this.maxAge);
+ });
+ }
+
+ /**
+ * @param {string} identifier unique name for the resource
+ * @param {Etag | null} etag etag of the resource
+ * @param {any} data cached content
+ * @returns {Promise<void>} promise
+ */
+ store(identifier, etag, data) {
+ if (this.readonly) return Promise.resolve();
+
+ return this._getPack().then(pack => {
+ pack.set(identifier, etag === null ? null : etag.toString(), data);
+ });
+ }
+
+ /**
+ * @param {string} identifier unique name for the resource
+ * @param {Etag | null} etag etag of the resource
+ * @returns {Promise<any>} promise to the cached content
+ */
+ restore(identifier, etag) {
+ return this._getPack()
+ .then(pack =>
+ pack.get(identifier, etag === null ? null : etag.toString())
+ )
+ .catch(err => {
+ if (err && err.code !== "ENOENT") {
+ this.logger.warn(
+ `Restoring failed for ${identifier} from pack: ${err}`
+ );
+ this.logger.debug(err.stack);
+ }
+ });
+ }
+
+ /**
+ * @param {LazySet<string> | Iterable<string>} dependencies dependencies to store
+ */
+ storeBuildDependencies(dependencies) {
+ if (this.readonly) return;
+ this.newBuildDependencies.addAll(dependencies);
+ }
+
+ afterAllStored() {
+ const packPromise = this.packPromise;
+ if (packPromise === undefined) return Promise.resolve();
+ const reportProgress = ProgressPlugin.getReporter(this.compiler);
+ return (this.storePromise = packPromise
+ .then(pack => {
+ pack.stopCapturingRequests();
+ if (!pack.invalid) return;
+ this.packPromise = undefined;
+ this.logger.log("Storing pack...");
+ let promise;
+ const newBuildDependencies = new Set();
+ for (const dep of this.newBuildDependencies) {
+ if (!this.buildDependencies.has(dep)) {
+ newBuildDependencies.add(dep);
+ }
+ }
+ if (newBuildDependencies.size > 0 || !this.buildSnapshot) {
+ if (reportProgress) reportProgress(0.5, "resolve build dependencies");
+ this.logger.debug(
+ `Capturing build dependencies... (${Array.from(
+ newBuildDependencies
+ ).join(", ")})`
+ );
+ promise = new Promise((resolve, reject) => {
+ this.logger.time("resolve build dependencies");
+ this.fileSystemInfo.resolveBuildDependencies(
+ this.context,
+ newBuildDependencies,
+ (err, result) => {
+ this.logger.timeEnd("resolve build dependencies");
+ if (err) return reject(err);
+
+ this.logger.time("snapshot build dependencies");
+ const {
+ files,
+ directories,
+ missing,
+ resolveResults,
+ resolveDependencies
+ } = /** @type {ResolveBuildDependenciesResult} */ (result);
+ if (this.resolveResults) {
+ for (const [key, value] of resolveResults) {
+ this.resolveResults.set(key, value);
+ }
+ } else {
+ this.resolveResults = resolveResults;
+ }
+ if (reportProgress) {
+ reportProgress(
+ 0.6,
+ "snapshot build dependencies",
+ "resolving"
+ );
+ }
+ this.fileSystemInfo.createSnapshot(
+ undefined,
+ resolveDependencies.files,
+ resolveDependencies.directories,
+ resolveDependencies.missing,
+ this.snapshot.resolveBuildDependencies,
+ (err, snapshot) => {
+ if (err) {
+ this.logger.timeEnd("snapshot build dependencies");
+ return reject(err);
+ }
+ if (!snapshot) {
+ this.logger.timeEnd("snapshot build dependencies");
+ return reject(
+ new Error("Unable to snapshot resolve dependencies")
+ );
+ }
+ if (this.resolveBuildDependenciesSnapshot) {
+ this.resolveBuildDependenciesSnapshot =
+ this.fileSystemInfo.mergeSnapshots(
+ this.resolveBuildDependenciesSnapshot,
+ snapshot
+ );
+ } else {
+ this.resolveBuildDependenciesSnapshot = snapshot;
+ }
+ if (reportProgress) {
+ reportProgress(
+ 0.7,
+ "snapshot build dependencies",
+ "modules"
+ );
+ }
+ this.fileSystemInfo.createSnapshot(
+ undefined,
+ files,
+ directories,
+ missing,
+ this.snapshot.buildDependencies,
+ (err, snapshot) => {
+ this.logger.timeEnd("snapshot build dependencies");
+ if (err) return reject(err);
+ if (!snapshot) {
+ return reject(
+ new Error("Unable to snapshot build dependencies")
+ );
+ }
+ this.logger.debug("Captured build dependencies");
+
+ if (this.buildSnapshot) {
+ this.buildSnapshot =
+ this.fileSystemInfo.mergeSnapshots(
+ this.buildSnapshot,
+ snapshot
+ );
+ } else {
+ this.buildSnapshot = snapshot;
+ }
+
+ resolve();
+ }
+ );
+ }
+ );
+ }
+ );
+ });
+ } else {
+ promise = Promise.resolve();
+ }
+ return promise.then(() => {
+ if (reportProgress) reportProgress(0.8, "serialize pack");
+ this.logger.time("store pack");
+ const updatedBuildDependencies = new Set(this.buildDependencies);
+ for (const dep of newBuildDependencies) {
+ updatedBuildDependencies.add(dep);
+ }
+ const content = new PackContainer(
+ pack,
+ this.version,
+ /** @type {Snapshot} */ (this.buildSnapshot),
+ updatedBuildDependencies,
+ this.resolveResults,
+ this.resolveBuildDependenciesSnapshot
+ );
+ return this.fileSerializer
+ .serialize(content, {
+ filename: `${this.cacheLocation}/index${this._extension}`,
+ extension: `${this._extension}`,
+ logger: this.logger,
+ profile: this.profile
+ })
+ .then(() => {
+ for (const dep of newBuildDependencies) {
+ this.buildDependencies.add(dep);
+ }
+ this.newBuildDependencies.clear();
+ this.logger.timeEnd("store pack");
+ const stats = pack.getContentStats();
+ this.logger.log(
+ "Stored pack (%d items, %d files, %d MiB)",
+ pack.itemInfo.size,
+ stats.count,
+ Math.round(stats.size / 1024 / 1024)
+ );
+ })
+ .catch(err => {
+ this.logger.timeEnd("store pack");
+ this.logger.warn(`Caching failed for pack: ${err}`);
+ this.logger.debug(err.stack);
+ });
+ });
+ })
+ .catch(err => {
+ this.logger.warn(`Caching failed for pack: ${err}`);
+ this.logger.debug(err.stack);
+ }));
+ }
+
+ clear() {
+ this.fileSystemInfo.clear();
+ this.buildDependencies.clear();
+ this.newBuildDependencies.clear();
+ this.resolveBuildDependenciesSnapshot = undefined;
+ this.resolveResults = undefined;
+ this.buildSnapshot = undefined;
+ this.packPromise = undefined;
+ }
+}
+
+module.exports = PackFileCacheStrategy;
diff --git a/node_modules/webpack/lib/cache/ResolverCachePlugin.js b/node_modules/webpack/lib/cache/ResolverCachePlugin.js
new file mode 100644
index 00000000..3096157f
--- /dev/null
+++ b/node_modules/webpack/lib/cache/ResolverCachePlugin.js
@@ -0,0 +1,365 @@
+/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const LazySet = require("../util/LazySet");
+const makeSerializable = require("../util/makeSerializable");
+
+/** @typedef {import("enhanced-resolve").Resolver} Resolver */
+/** @typedef {import("../CacheFacade").ItemCacheFacade} ItemCacheFacade */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../FileSystemInfo")} FileSystemInfo */
+/** @typedef {import("../FileSystemInfo").Snapshot} Snapshot */
+
+class CacheEntry {
+ constructor(result, snapshot) {
+ this.result = result;
+ this.snapshot = snapshot;
+ }
+
+ serialize({ write }) {
+ write(this.result);
+ write(this.snapshot);
+ }
+
+ deserialize({ read }) {
+ this.result = read();
+ this.snapshot = read();
+ }
+}
+
+makeSerializable(CacheEntry, "webpack/lib/cache/ResolverCachePlugin");
+
+/**
+ * @template T
+ * @param {Set<T> | LazySet<T>} set set to add items to
+ * @param {Set<T> | LazySet<T>} otherSet set to add items from
+ * @returns {void}
+ */
+const addAllToSet = (set, otherSet) => {
+ if (set instanceof LazySet) {
+ set.addAll(otherSet);
+ } else {
+ for (const item of otherSet) {
+ set.add(item);
+ }
+ }
+};
+
+/**
+ * @param {object} object an object
+ * @param {boolean} excludeContext if true, context is not included in string
+ * @returns {string} stringified version
+ */
+const objectToString = (object, excludeContext) => {
+ let str = "";
+ for (const key in object) {
+ if (excludeContext && key === "context") continue;
+ const value = object[key];
+ str +=
+ typeof value === "object" && value !== null
+ ? `|${key}=[${objectToString(value, false)}|]`
+ : `|${key}=|${value}`;
+ }
+ return str;
+};
+
+class ResolverCachePlugin {
+ /**
+ * Apply the plugin
+ * @param {Compiler} compiler the compiler instance
+ * @returns {void}
+ */
+ apply(compiler) {
+ const cache = compiler.getCache("ResolverCachePlugin");
+ /** @type {FileSystemInfo} */
+ let fileSystemInfo;
+ let snapshotOptions;
+ let realResolves = 0;
+ let cachedResolves = 0;
+ let cacheInvalidResolves = 0;
+ let concurrentResolves = 0;
+ compiler.hooks.thisCompilation.tap("ResolverCachePlugin", compilation => {
+ snapshotOptions = compilation.options.snapshot.resolve;
+ fileSystemInfo = compilation.fileSystemInfo;
+ compilation.hooks.finishModules.tap("ResolverCachePlugin", () => {
+ if (realResolves + cachedResolves > 0) {
+ const logger = compilation.getLogger("webpack.ResolverCachePlugin");
+ logger.log(
+ `${Math.round(
+ (100 * realResolves) / (realResolves + cachedResolves)
+ )}% really resolved (${realResolves} real resolves with ${cacheInvalidResolves} cached but invalid, ${cachedResolves} cached valid, ${concurrentResolves} concurrent)`
+ );
+ realResolves = 0;
+ cachedResolves = 0;
+ cacheInvalidResolves = 0;
+ concurrentResolves = 0;
+ }
+ });
+ });
+ /**
+ * @param {ItemCacheFacade} itemCache cache
+ * @param {Resolver} resolver the resolver
+ * @param {object} resolveContext context for resolving meta info
+ * @param {object} request the request info object
+ * @param {function((Error | null)=, object=): void} callback callback function
+ * @returns {void}
+ */
+ const doRealResolve = (
+ itemCache,
+ resolver,
+ resolveContext,
+ request,
+ callback
+ ) => {
+ realResolves++;
+ const newRequest = {
+ _ResolverCachePluginCacheMiss: true,
+ ...request
+ };
+ const newResolveContext = {
+ ...resolveContext,
+ stack: new Set(),
+ /** @type {LazySet<string>} */
+ missingDependencies: new LazySet(),
+ /** @type {LazySet<string>} */
+ fileDependencies: new LazySet(),
+ /** @type {LazySet<string>} */
+ contextDependencies: new LazySet()
+ };
+ let yieldResult;
+ let withYield = false;
+ if (typeof newResolveContext.yield === "function") {
+ yieldResult = [];
+ withYield = true;
+ newResolveContext.yield = obj => yieldResult.push(obj);
+ }
+ const propagate = key => {
+ if (resolveContext[key]) {
+ addAllToSet(resolveContext[key], newResolveContext[key]);
+ }
+ };
+ const resolveTime = Date.now();
+ resolver.doResolve(
+ resolver.hooks.resolve,
+ newRequest,
+ "Cache miss",
+ newResolveContext,
+ (err, result) => {
+ propagate("fileDependencies");
+ propagate("contextDependencies");
+ propagate("missingDependencies");
+ if (err) return callback(err);
+ const fileDependencies = newResolveContext.fileDependencies;
+ const contextDependencies = newResolveContext.contextDependencies;
+ const missingDependencies = newResolveContext.missingDependencies;
+ fileSystemInfo.createSnapshot(
+ resolveTime,
+ fileDependencies,
+ contextDependencies,
+ missingDependencies,
+ snapshotOptions,
+ (err, snapshot) => {
+ if (err) return callback(err);
+ const resolveResult = withYield ? yieldResult : result;
+ // since we intercept resolve hook
+ // we still can get result in callback
+ if (withYield && result) yieldResult.push(result);
+ if (!snapshot) {
+ if (resolveResult) return callback(null, resolveResult);
+ return callback();
+ }
+ itemCache.store(
+ new CacheEntry(resolveResult, snapshot),
+ storeErr => {
+ if (storeErr) return callback(storeErr);
+ if (resolveResult) return callback(null, resolveResult);
+ callback();
+ }
+ );
+ }
+ );
+ }
+ );
+ };
+ compiler.resolverFactory.hooks.resolver.intercept({
+ factory(type, hook) {
+ /** @type {Map<string, (function(Error=, object=): void)[]>} */
+ const activeRequests = new Map();
+ /** @type {Map<string, [function(Error=, object=): void, function(Error=, object=): void][]>} */
+ const activeRequestsWithYield = new Map();
+ hook.tap(
+ "ResolverCachePlugin",
+ /**
+ * @param {Resolver} resolver the resolver
+ * @param {object} options resolve options
+ * @param {object} userOptions resolve options passed by the user
+ * @returns {void}
+ */
+ (resolver, options, userOptions) => {
+ if (options.cache !== true) return;
+ const optionsIdent = objectToString(userOptions, false);
+ const cacheWithContext =
+ options.cacheWithContext !== undefined
+ ? options.cacheWithContext
+ : false;
+ resolver.hooks.resolve.tapAsync(
+ {
+ name: "ResolverCachePlugin",
+ stage: -100
+ },
+ (request, resolveContext, callback) => {
+ if (
+ /** @type {TODO} */ (request)._ResolverCachePluginCacheMiss ||
+ !fileSystemInfo
+ ) {
+ return callback();
+ }
+ const withYield = typeof resolveContext.yield === "function";
+ const identifier = `${type}${
+ withYield ? "|yield" : "|default"
+ }${optionsIdent}${objectToString(request, !cacheWithContext)}`;
+
+ if (withYield) {
+ const activeRequest = activeRequestsWithYield.get(identifier);
+ if (activeRequest) {
+ activeRequest[0].push(callback);
+ activeRequest[1].push(
+ /** @type {TODO} */ (resolveContext.yield)
+ );
+ return;
+ }
+ } else {
+ const activeRequest = activeRequests.get(identifier);
+ if (activeRequest) {
+ activeRequest.push(callback);
+ return;
+ }
+ }
+ const itemCache = cache.getItemCache(identifier, null);
+ let callbacks;
+ let yields;
+ const done = withYield
+ ? (err, result) => {
+ if (callbacks === undefined) {
+ if (err) {
+ callback(err);
+ } else {
+ if (result)
+ for (const r of result) resolveContext.yield(r);
+ callback(null, null);
+ }
+ yields = undefined;
+ callbacks = false;
+ } else {
+ if (err) {
+ for (const cb of callbacks) cb(err);
+ } else {
+ for (let i = 0; i < callbacks.length; i++) {
+ const cb = callbacks[i];
+ const yield_ = yields[i];
+ if (result) for (const r of result) yield_(r);
+ cb(null, null);
+ }
+ }
+ activeRequestsWithYield.delete(identifier);
+ yields = undefined;
+ callbacks = false;
+ }
+ }
+ : (err, result) => {
+ if (callbacks === undefined) {
+ callback(err, result);
+ callbacks = false;
+ } else {
+ for (const callback of callbacks) {
+ callback(err, result);
+ }
+ activeRequests.delete(identifier);
+ callbacks = false;
+ }
+ };
+ /**
+ * @param {Error=} err error if any
+ * @param {CacheEntry=} cacheEntry cache entry
+ * @returns {void}
+ */
+ const processCacheResult = (err, cacheEntry) => {
+ if (err) return done(err);
+
+ if (cacheEntry) {
+ const { snapshot, result } = cacheEntry;
+ fileSystemInfo.checkSnapshotValid(
+ snapshot,
+ (err, valid) => {
+ if (err || !valid) {
+ cacheInvalidResolves++;
+ return doRealResolve(
+ itemCache,
+ resolver,
+ resolveContext,
+ request,
+ done
+ );
+ }
+ cachedResolves++;
+ if (resolveContext.missingDependencies) {
+ addAllToSet(
+ /** @type {LazySet<string>} */
+ (resolveContext.missingDependencies),
+ snapshot.getMissingIterable()
+ );
+ }
+ if (resolveContext.fileDependencies) {
+ addAllToSet(
+ /** @type {LazySet<string>} */
+ (resolveContext.fileDependencies),
+ snapshot.getFileIterable()
+ );
+ }
+ if (resolveContext.contextDependencies) {
+ addAllToSet(
+ /** @type {LazySet<string>} */
+ (resolveContext.contextDependencies),
+ snapshot.getContextIterable()
+ );
+ }
+ done(null, result);
+ }
+ );
+ } else {
+ doRealResolve(
+ itemCache,
+ resolver,
+ resolveContext,
+ request,
+ done
+ );
+ }
+ };
+ itemCache.get(processCacheResult);
+ if (withYield && callbacks === undefined) {
+ callbacks = [callback];
+ yields = [resolveContext.yield];
+ activeRequestsWithYield.set(
+ identifier,
+ /** @type {[any, any]} */ ([callbacks, yields])
+ );
+ } else if (callbacks === undefined) {
+ callbacks = [callback];
+ activeRequests.set(identifier, callbacks);
+ }
+ }
+ );
+ }
+ );
+ return hook;
+ }
+ });
+ }
+}
+
+module.exports = ResolverCachePlugin;
diff --git a/node_modules/webpack/lib/cache/getLazyHashedEtag.js b/node_modules/webpack/lib/cache/getLazyHashedEtag.js
new file mode 100644
index 00000000..7fa918b4
--- /dev/null
+++ b/node_modules/webpack/lib/cache/getLazyHashedEtag.js
@@ -0,0 +1,81 @@
+/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const createHash = require("../util/createHash");
+
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {typeof import("../util/Hash")} HashConstructor */
+
+/**
+ * @typedef {object} HashableObject
+ * @property {function(Hash): void} updateHash
+ */
+
+class LazyHashedEtag {
+ /**
+ * @param {HashableObject} obj object with updateHash method
+ * @param {string | HashConstructor} hashFunction the hash function to use
+ */
+ constructor(obj, hashFunction = "md4") {
+ this._obj = obj;
+ this._hash = undefined;
+ this._hashFunction = hashFunction;
+ }
+
+ /**
+ * @returns {string} hash of object
+ */
+ toString() {
+ if (this._hash === undefined) {
+ const hash = createHash(this._hashFunction);
+ this._obj.updateHash(hash);
+ this._hash = /** @type {string} */ (hash.digest("base64"));
+ }
+ return this._hash;
+ }
+}
+
+/** @type {Map<string | HashConstructor, WeakMap<HashableObject, LazyHashedEtag>>} */
+const mapStrings = new Map();
+
+/** @type {WeakMap<HashConstructor, WeakMap<HashableObject, LazyHashedEtag>>} */
+const mapObjects = new WeakMap();
+
+/**
+ * @param {HashableObject} obj object with updateHash method
+ * @param {(string | HashConstructor)=} hashFunction the hash function to use
+ * @returns {LazyHashedEtag} etag
+ */
+const getter = (obj, hashFunction = "md4") => {
+ let innerMap;
+ if (typeof hashFunction === "string") {
+ innerMap = mapStrings.get(hashFunction);
+ if (innerMap === undefined) {
+ const newHash = new LazyHashedEtag(obj, hashFunction);
+ innerMap = new WeakMap();
+ innerMap.set(obj, newHash);
+ mapStrings.set(hashFunction, innerMap);
+ return newHash;
+ }
+ } else {
+ innerMap = mapObjects.get(hashFunction);
+ if (innerMap === undefined) {
+ const newHash = new LazyHashedEtag(obj, hashFunction);
+ innerMap = new WeakMap();
+ innerMap.set(obj, newHash);
+ mapObjects.set(hashFunction, innerMap);
+ return newHash;
+ }
+ }
+ const hash = innerMap.get(obj);
+ if (hash !== undefined) return hash;
+ const newHash = new LazyHashedEtag(obj, hashFunction);
+ innerMap.set(obj, newHash);
+ return newHash;
+};
+
+module.exports = getter;
diff --git a/node_modules/webpack/lib/cache/mergeEtags.js b/node_modules/webpack/lib/cache/mergeEtags.js
new file mode 100644
index 00000000..9a212f21
--- /dev/null
+++ b/node_modules/webpack/lib/cache/mergeEtags.js
@@ -0,0 +1,69 @@
+/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @typedef {import("../Cache").Etag} Etag */
+
+class MergedEtag {
+ /**
+ * @param {Etag} a first
+ * @param {Etag} b second
+ */
+ constructor(a, b) {
+ this.a = a;
+ this.b = b;
+ }
+
+ toString() {
+ return `${this.a.toString()}|${this.b.toString()}`;
+ }
+}
+
+const dualObjectMap = new WeakMap();
+const objectStringMap = new WeakMap();
+
+/**
+ * @param {Etag} a first
+ * @param {Etag} b second
+ * @returns {Etag} result
+ */
+const mergeEtags = (a, b) => {
+ if (typeof a === "string") {
+ if (typeof b === "string") {
+ return `${a}|${b}`;
+ }
+ const temp = b;
+ b = a;
+ a = temp;
+ } else if (typeof b !== "string") {
+ // both a and b are objects
+ let map = dualObjectMap.get(a);
+ if (map === undefined) {
+ dualObjectMap.set(a, (map = new WeakMap()));
+ }
+ const mergedEtag = map.get(b);
+ if (mergedEtag === undefined) {
+ const newMergedEtag = new MergedEtag(a, b);
+ map.set(b, newMergedEtag);
+ return newMergedEtag;
+ }
+ return mergedEtag;
+ }
+ // a is object, b is string
+ let map = objectStringMap.get(a);
+ if (map === undefined) {
+ objectStringMap.set(a, (map = new Map()));
+ }
+ const mergedEtag = map.get(b);
+ if (mergedEtag === undefined) {
+ const newMergedEtag = new MergedEtag(a, b);
+ map.set(b, newMergedEtag);
+ return newMergedEtag;
+ }
+ return mergedEtag;
+};
+
+module.exports = mergeEtags;
generated by cgit v1.2.3 (git 2.25.1) at 2026-11-01 22:56:09 +0000