xhs-mp-pack 1.1.0-beta.0

package/dist/cache/ResolverCachePlugin.d.ts

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

package/dist/cache/ResolverCachePlugin.js

@@ -0,0 +1,248 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const LazySet_1 = __importDefault(require("@/base/LazySet"));
+const makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+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();
+    }
+}
+(0, makeSerializable_1.default)(CacheEntry, 'mp-compiler/core/cache/ResolverCachePlugin');
+const addAllToSet = (set, otherSet) => {
+    if (set instanceof LazySet_1.default) {
+        set.addAll(otherSet);
+    }
+    else {
+        for (const item of otherSet) {
+            set.add(item);
+        }
+    }
+};
+const objectToString = (object, excludeContext) => {
+    let str = '';
+    for (const key in object) {
+        if (excludeContext && key === 'context')
+            continue;
+        const value = object[key];
+        if (typeof value === 'object' && value !== null) {
+            str += `|${key}=[${objectToString(value, false)}|]`;
+        }
+        else {
+            str += `|${key}=|${value}`;
+        }
+    }
+    return str;
+};
+class ResolverCachePlugin {
+    apply(compiler) {
+        const cache = compiler.getCache('ResolverCachePlugin');
+        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;
+                }
+            });
+        });
+        const doRealResolve = (itemCache, resolver, resolveContext, request, callback) => {
+            realResolves++;
+            const newRequest = Object.assign({ _ResolverCachePluginCacheMiss: true }, request);
+            const newResolveContext = Object.assign(Object.assign({}, resolveContext), { stack: new Set(), missingDependencies: new LazySet_1.default(), fileDependencies: new LazySet_1.default(), contextDependencies: new LazySet_1.default() });
+            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) {
+                const activeRequests = new Map();
+                const activeRequestsWithYield = new Map();
+                hook.tap('ResolverCachePlugin', (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 (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(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;
+                                }
+                            };
+                        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(resolveContext.missingDependencies, snapshot.getMissingIterable());
+                                    }
+                                    if (resolveContext.fileDependencies) {
+                                        addAllToSet(resolveContext.fileDependencies, snapshot.getFileIterable());
+                                    }
+                                    if (resolveContext.contextDependencies) {
+                                        addAllToSet(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, [callbacks, yields]);
+                        }
+                        else if (callbacks === undefined) {
+                            callbacks = [callback];
+                            activeRequests.set(identifier, callbacks);
+                        }
+                    });
+                });
+                return hook;
+            },
+        });
+    }
+}
+exports.default = ResolverCachePlugin;

package/dist/cache/getLazyHashedEtag.d.ts

@@ -0,0 +1,2 @@
+declare const getter: (obj: any, hashFunction?: string) => any;
+export default getter;

package/dist/cache/getLazyHashedEtag.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const createHash_1 = __importDefault(require("@/base/createHash"));
+class LazyHashedEtag {
+    constructor(obj, hashFunction = 'md4') {
+        this._obj = obj;
+        this._hash = undefined;
+        this._hashFunction = hashFunction;
+    }
+    toString() {
+        if (this._hash === undefined) {
+            const hash = (0, createHash_1.default)(this._hashFunction);
+            this._obj.updateHash(hash);
+            this._hash = hash.digest('base64');
+        }
+        return this._hash;
+    }
+}
+const mapStrings = new Map();
+const mapObjects = new WeakMap();
+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;
+};
+exports.default = getter;

package/dist/cache/mergeEtags.d.ts

@@ -0,0 +1,2 @@
+declare const mergeEtags: (a: any, b: any) => any;
+export default mergeEtags;

package/dist/cache/mergeEtags.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class MergedEtag {
+    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();
+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;
+};
+exports.default = mergeEtags;

package/dist/chunk/Chunk.d.ts

@@ -0,0 +1,75 @@
+import SortableSet from '@/base/SortableSet';
+type ChunkId = number | string;
+/**
+ * A Chunk is a unit of encapsulation for Modules.
+ * Chunks are "rendered" into bundles that get emitted when the build completes.
+ */
+declare class Chunk {
+    id: ChunkId | null;
+    ids: ChunkId[] | null;
+    debugId: number;
+    name: string;
+    idNameHints: SortableSet;
+    preventIntegration: boolean;
+    filenameTemplate: any;
+    cssFilenameTemplate: any;
+    _groups: SortableSet;
+    runtime: any;
+    files: any;
+    auxiliaryFiles: Set<unknown>;
+    rendered: boolean;
+    hash: any;
+    contentHash: any;
+    renderedHash: any;
+    chunkReason: any;
+    extraAsync: boolean;
+    constructor(name: string, backCompat?: boolean);
+    get entryModule(): unknown;
+    hasEntryModule(): boolean;
+    addModule(module: any): boolean;
+    removeModule(module: any): void;
+    getNumberOfModules(): any;
+    get modulesIterable(): any;
+    compareTo(otherChunk: any): any;
+    containsModule(module: any): any;
+    getModules(): any;
+    remove(): void;
+    moveModule(module: any, otherChunk: any): void;
+    integrate(otherChunk: any): boolean;
+    canBeIntegrated(otherChunk: any): any;
+    isEmpty(): boolean;
+    modulesSize(): any;
+    size(options?: {}): any;
+    integratedSize(otherChunk: any, options: any): any;
+    getChunkModuleMaps(filterFn: any): {
+        id: any;
+        hash: any;
+    };
+    hasModuleInGraph(filterFn: any, filterChunkFn: any): any;
+    getChunkMaps(realHash: any): {
+        hash: any;
+        contentHash: any;
+        name: any;
+    };
+    hasRuntime(): boolean;
+    canBeInitial(): boolean;
+    isOnlyInitial(): boolean;
+    getEntryOptions(): any;
+    addGroup(chunkGroup: any): void;
+    removeGroup(chunkGroup: any): void;
+    isInGroup(chunkGroup: any): boolean;
+    getNumberOfGroups(): number;
+    get groupsIterable(): SortableSet;
+    disconnectFromGroups(): void;
+    split(newChunk: any): void;
+    updateHash(hash: any, chunkGraph: any): void;
+    getAllAsyncChunks(): any;
+    getAllInitialChunks(): Set<unknown>;
+    getAllReferencedChunks(): Set<unknown>;
+    getAllReferencedAsyncEntrypoints(): any;
+    hasAsyncChunks(): boolean;
+    getChildIdsByOrders(chunkGraph: any, filterFn: any): any;
+    getChildrenOfTypeInOrder(chunkGraph: any, type: string): any[] | undefined;
+    getChildIdsByOrdersMap(chunkGraph: any, includeDirectChildren: any, filterFn: any): any;
+}
+export default Chunk;