xhs-mp-pack 1.1.0-beta.0

package/dist/cache/IdleFileCachePlugin.js

@@ -0,0 +1,165 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Cache_1 = __importDefault(require("@/cache/Cache"));
+const ProgressPlugin_1 = __importDefault(require("@/plugins/ProgressPlugin"));
+// eslint-disable-next-line symbol-description
+const BUILD_DEPENDENCIES_KEY = Symbol();
+class IdleFileCachePlugin {
+    constructor(strategy, idleTimeout, idleTimeoutForInitialStore, idleTimeoutAfterLargeChanges) {
+        this.strategy = strategy;
+        this.idleTimeout = idleTimeout;
+        this.idleTimeoutForInitialStore = idleTimeoutForInitialStore;
+        this.idleTimeoutAfterLargeChanges = idleTimeoutAfterLargeChanges;
+    }
+    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;
+        const pendingIdleTasks = new Map();
+        compiler.cache.hooks.store.tap({ name: 'IdleFileCachePlugin', stage: Cache_1.default.STAGE_DISK }, (identifier, etag, data) => {
+            pendingIdleTasks.set(identifier, () => strategy.store(identifier, etag, data));
+        });
+        compiler.cache.hooks.get.tapPromise({ name: 'IdleFileCachePlugin', stage: Cache_1.default.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_1.default.STAGE_DISK }, dependencies => {
+            pendingIdleTasks.set(BUILD_DEPENDENCIES_KEY, () => strategy.storeBuildDependencies(dependencies));
+        });
+        compiler.cache.hooks.shutdown.tapPromise({ name: 'IdleFileCachePlugin', stage: Cache_1.default.STAGE_DISK }, () => {
+            if (idleTimer) {
+                clearTimeout(idleTimer);
+                idleTimer = undefined;
+            }
+            isIdle = false;
+            const reportProgress = ProgressPlugin_1.default.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();
+            });
+        });
+        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(() => __awaiter(this, void 0, void 0, function* () {
+                    yield 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;
+            }
+        };
+        let idleTimer;
+        compiler.cache.hooks.beginIdle.tap({ name: 'IdleFileCachePlugin', stage: Cache_1.default.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_1.default.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 += stats.endTime - stats.startTime;
+        });
+    }
+}
+exports.default = IdleFileCachePlugin;

package/dist/cache/MemoryCachePlugin.d.ts

@@ -0,0 +1,4 @@
+declare class MemoryCachePlugin {
+    apply(compiler: any): void;
+}
+export default MemoryCachePlugin;

package/dist/cache/MemoryCachePlugin.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Cache_1 = __importDefault(require("@/cache/Cache"));
+class MemoryCachePlugin {
+    apply(compiler) {
+        const cache = new Map();
+        compiler.cache.hooks.store.tap({ name: 'MemoryCachePlugin', stage: Cache_1.default.STAGE_MEMORY }, (identifier, etag, data) => {
+            cache.set(identifier, { etag, data });
+        });
+        compiler.cache.hooks.get.tap({ name: 'MemoryCachePlugin', stage: Cache_1.default.STAGE_MEMORY }, (identifier, etag, gotHandlers) => {
+            const cacheEntry = cache.get(identifier);
+            if (cacheEntry === null) {
+                return null;
+            }
+            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_1.default.STAGE_MEMORY }, () => {
+            cache.clear();
+        });
+    }
+}
+exports.default = MemoryCachePlugin;

package/dist/cache/MemoryWithGcCachePlugin.d.ts

@@ -0,0 +1,8 @@
+declare class MemoryWithGcCachePlugin {
+    _maxGenerations: any;
+    constructor({ maxGenerations }: {
+        maxGenerations: any;
+    });
+    apply(compiler: any): void;
+}
+export default MemoryWithGcCachePlugin;

package/dist/cache/MemoryWithGcCachePlugin.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Cache_1 = __importDefault(require("@/cache/Cache"));
+class MemoryWithGcCachePlugin {
+    constructor({ maxGenerations }) {
+        this._maxGenerations = maxGenerations;
+    }
+    apply(compiler) {
+        const maxGenerations = this._maxGenerations;
+        const cache = new Map();
+        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_1.default.STAGE_MEMORY }, (identifier, etag, data) => {
+            cache.set(identifier, { etag, data });
+        });
+        compiler.cache.hooks.get.tap({ name: 'MemoryWithGcCachePlugin', stage: Cache_1.default.STAGE_MEMORY }, (identifier, etag, gotHandlers) => {
+            const cacheEntry = cache.get(identifier);
+            if (cacheEntry === null) {
+                return null;
+            }
+            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_1.default.STAGE_MEMORY }, () => {
+            cache.clear();
+            oldCache.clear();
+        });
+    }
+}
+exports.default = MemoryWithGcCachePlugin;

package/dist/cache/PackFileCacheStrategy.d.ts

@@ -0,0 +1,47 @@
+import { FileSystemInfo } from '@/FileSystemInfo';
+import LazySet from '@/base/LazySet';
+declare class PackFileCacheStrategy {
+    fileSerializer: any;
+    fileSystemInfo: FileSystemInfo;
+    compiler: any;
+    context: any;
+    cacheLocation: any;
+    version: any;
+    logger: any;
+    maxAge: any;
+    profile: any;
+    readonly: any;
+    allowCollectingMemory: any;
+    compression: any;
+    _extension: string;
+    snapshot: any;
+    buildDependencies: Set<any>;
+    newBuildDependencies: LazySet;
+    resolveResults: any;
+    buildSnapshot: any;
+    packPromise: any;
+    storePromise: Promise<void>;
+    resolveBuildDependenciesSnapshot: any;
+    constructor({ compiler, fs, context, cacheLocation, version, logger, snapshot, maxAge, profile, allowCollectingMemory, compression, readonly, }: {
+        compiler: any;
+        fs: any;
+        context: any;
+        cacheLocation: any;
+        version: any;
+        logger: any;
+        snapshot: any;
+        maxAge: any;
+        profile: any;
+        allowCollectingMemory: any;
+        compression: any;
+        readonly: any;
+    });
+    _getPack(): any;
+    _openPack(): any;
+    store(identifier: string, etag: any, data: any): any;
+    restore(identifier: string, etag: any): any;
+    storeBuildDependencies(dependencies: any): void;
+    afterAllStored(): Promise<void>;
+    clear(): void;
+}
+export default PackFileCacheStrategy;