xhs-mp-pack 1.1.0-beta.0

package/dist/base/stats/StatsPrinter.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tapable_1 = require("tapable");
+class StatsPrinter {
+    constructor() {
+        this.hooks = Object.freeze({
+            sortElements: new tapable_1.HookMap(() => new tapable_1.SyncBailHook(['elements', 'context'])),
+            printElements: new tapable_1.HookMap(() => new tapable_1.SyncBailHook(['printedElements', 'context'])),
+            sortItems: new tapable_1.HookMap(() => new tapable_1.SyncBailHook(['items', 'context'])),
+            getItemName: new tapable_1.HookMap(() => new tapable_1.SyncBailHook(['item', 'context'])),
+            printItems: new tapable_1.HookMap(() => new tapable_1.SyncBailHook(['printedItems', 'context'])),
+            print: new tapable_1.HookMap(() => new tapable_1.SyncBailHook(['object', 'context'])),
+            result: new tapable_1.HookMap(() => new tapable_1.SyncWaterfallHook(['result', 'context'])),
+        });
+        this._levelHookCache = new Map();
+        this._inPrint = false;
+    }
+    _getAllLevelHooks(hookMap, type) {
+        let cache = this._levelHookCache.get(hookMap);
+        if (cache === undefined) {
+            cache = new Map();
+            this._levelHookCache.set(hookMap, cache);
+        }
+        const cacheEntry = cache.get(type);
+        if (cacheEntry !== undefined) {
+            return cacheEntry;
+        }
+        const hooks = [];
+        const typeParts = type.split('.');
+        for (let i = 0; i < typeParts.length; i++) {
+            const hook = hookMap.get(typeParts.slice(i).join('.'));
+            if (hook) {
+                hooks.push(hook);
+            }
+        }
+        cache.set(type, hooks);
+        return hooks;
+    }
+    _forEachLevel(hookMap, type, fn) {
+        for (const hook of this._getAllLevelHooks(hookMap, type)) {
+            const result = fn(hook);
+            if (result !== undefined)
+                return result;
+        }
+    }
+    _forEachLevelWaterfall(hookMap, type, data, fn) {
+        for (const hook of this._getAllLevelHooks(hookMap, type)) {
+            data = fn(hook, data);
+        }
+        return data;
+    }
+    print(type, object, baseContext) {
+        if (this._inPrint) {
+            return this._print(type, object, baseContext);
+        }
+        try {
+            this._inPrint = true;
+            return this._print(type, object, baseContext);
+        }
+        finally {
+            this._levelHookCache.clear();
+            this._inPrint = false;
+        }
+    }
+    _print(type, object, baseContext) {
+        const context = Object.assign(Object.assign({}, baseContext), { type, [type]: object });
+        let printResult = this._forEachLevel(this.hooks.print, type, hook => hook.call(object, context));
+        if (printResult === undefined) {
+            if (Array.isArray(object)) {
+                const sortedItems = object.slice();
+                this._forEachLevel(this.hooks.sortItems, type, h => h.call(sortedItems, context));
+                const printedItems = sortedItems.map((item, i) => {
+                    const itemContext = Object.assign(Object.assign({}, context), { _index: i });
+                    const itemName = this._forEachLevel(this.hooks.getItemName, `${type}[]`, h => h.call(item, itemContext));
+                    if (itemName)
+                        itemContext[itemName] = item;
+                    return this.print(itemName ? `${type}[].${itemName}` : `${type}[]`, item, itemContext);
+                });
+                printResult = this._forEachLevel(this.hooks.printItems, type, h => h.call(printedItems, context));
+                if (printResult === undefined) {
+                    const result = printedItems.filter(Boolean);
+                    if (result.length > 0)
+                        printResult = result.join('\n');
+                }
+            }
+            else if (object !== null && typeof object === 'object') {
+                const elements = Object.keys(object).filter(key => object[key] !== undefined);
+                this._forEachLevel(this.hooks.sortElements, type, h => h.call(elements, context));
+                const printedElements = elements.map(element => {
+                    const content = this.print(`${type}.${element}`, object[element], Object.assign(Object.assign({}, context), { _parent: object, _element: element, [element]: object[element] }));
+                    return { element, content };
+                });
+                printResult = this._forEachLevel(this.hooks.printElements, type, h => h.call(printedElements, context));
+                if (printResult === undefined) {
+                    const result = printedElements.map(e => e.content).filter(Boolean);
+                    if (result.length > 0)
+                        printResult = result.join('\n');
+                }
+            }
+        }
+        return this._forEachLevelWaterfall(this.hooks.result, type, printResult, (h, r) => h.call(r, context));
+    }
+}
+exports.default = StatsPrinter;

package/dist/base/utils.d.ts

@@ -0,0 +1,5 @@
+declare const hasFile: (filepath: any) => boolean;
+declare function getEntryOptions(filename: any, url: any, type?: 'umd' | 'global', libraryName?: string): any;
+declare function objectToMap(obj: any): Map<string, any>;
+declare const formatPath: (pathStr?: string) => string;
+export { hasFile, getEntryOptions, objectToMap, formatPath };

package/dist/base/utils.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatPath = exports.objectToMap = exports.getEntryOptions = exports.hasFile = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const hasFile = filepath => {
+    try {
+        const stat = fs_1.default.statSync(filepath);
+        return stat.isFile();
+    }
+    catch (e) {
+        return false;
+    }
+};
+exports.hasFile = hasFile;
+function getEntryOptions(filename, url, type = 'global', libraryName) {
+    const opts = {
+        import: [url],
+        filename,
+    };
+    if (type === 'umd') {
+        opts.library = { name: libraryName, type };
+    }
+    return opts;
+}
+exports.getEntryOptions = getEntryOptions;
+function objectToMap(obj) {
+    return new Map(Object.keys(obj).map(key => [key, obj[key]]));
+}
+exports.objectToMap = objectToMap;
+const formatPath = (pathStr = '') => pathStr.split(path_1.default.sep).join(path_1.default.posix.sep);
+exports.formatPath = formatPath;

package/dist/cache/AddBuildDependenciesPlugin.d.ts

@@ -0,0 +1,6 @@
+declare class AddBuildDependenciesPlugin {
+    buildDependencies: Set<unknown>;
+    constructor(buildDependencies: any);
+    apply(compiler: any): void;
+}
+export default AddBuildDependenciesPlugin;

package/dist/cache/AddBuildDependenciesPlugin.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class AddBuildDependenciesPlugin {
+    constructor(buildDependencies) {
+        this.buildDependencies = new Set(buildDependencies);
+    }
+    apply(compiler) {
+        compiler.hooks.compilation.tap('AddBuildDependenciesPlugin', compilation => {
+            compilation.buildDependencies.addAll(this.buildDependencies);
+        });
+    }
+}
+exports.default = AddBuildDependenciesPlugin;

package/dist/cache/AddManagedPathsPlugin.d.ts

@@ -0,0 +1,7 @@
+declare class AddManagedPathsPlugin {
+    managedPaths: Set<unknown>;
+    immutablePaths: Set<string | RegExp>;
+    constructor(managedPaths: Iterable<string | RegExp>, immutablePaths: Iterable<string | RegExp>);
+    apply(compiler: any): void;
+}
+export default AddManagedPathsPlugin;

package/dist/cache/AddManagedPathsPlugin.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class AddManagedPathsPlugin {
+    constructor(managedPaths, immutablePaths) {
+        this.managedPaths = new Set(managedPaths);
+        this.immutablePaths = new Set(immutablePaths);
+    }
+    apply(compiler) {
+        for (const managedPath of this.managedPaths) {
+            compiler.managedPaths.add(managedPath);
+        }
+        for (const immutablePath of this.immutablePaths) {
+            compiler.immutablePaths.add(immutablePath);
+        }
+    }
+}
+exports.default = AddManagedPathsPlugin;

package/dist/cache/Cache.d.ts

@@ -0,0 +1,15 @@
+declare class Cache {
+    hooks: any;
+    static STAGE_MEMORY: number;
+    static STAGE_DEFAULT: number;
+    static STAGE_DISK: number;
+    static STAGE_NETWORK: number;
+    constructor();
+    get(identifier: any, etag: any, callback: any): void;
+    store(identifier: any, etag: any, data: any, callback: any): void;
+    storeBuildDependencies(dependencies: any, callback: any): void;
+    beginIdle(): void;
+    endIdle(callback: any): void;
+    shutdown(callback: any): void;
+}
+export default Cache;

package/dist/cache/Cache.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tapable_1 = require("tapable");
+const HookBaseError_1 = require("@/base/errors/HookBaseError");
+const needCalls = (times, callback) => err => {
+    if (--times === 0) {
+        return callback(err);
+    }
+    if (err && times > 0) {
+        times = 0;
+        return callback(err);
+    }
+};
+class Cache {
+    constructor() {
+        this.hooks = {
+            get: new tapable_1.AsyncSeriesBailHook(['identifier', 'etag', 'gotHandlers']),
+            store: new tapable_1.AsyncParallelHook(['identifier', 'etag', 'data']),
+            storeBuildDependencies: new tapable_1.AsyncParallelHook(['dependencies']),
+            beginIdle: new tapable_1.SyncHook([]),
+            endIdle: new tapable_1.AsyncParallelHook([]),
+            shutdown: new tapable_1.AsyncParallelHook([]),
+        };
+    }
+    get(identifier, etag, callback) {
+        const gotHandlers = [];
+        this.hooks.get.callAsync(identifier, etag, gotHandlers, (err, result) => {
+            if (err) {
+                callback((0, HookBaseError_1.makeBaseError)(err, 'Cache.hooks.get'));
+                return;
+            }
+            if (result === null) {
+                result = undefined;
+            }
+            if (gotHandlers.length > 1) {
+                const innerCallback = needCalls(gotHandlers.length, () => callback(null, result));
+                for (const gotHandler of gotHandlers) {
+                    gotHandler(result, innerCallback);
+                }
+            }
+            else if (gotHandlers.length === 1) {
+                gotHandlers[0](result, () => callback(null, result));
+            }
+            else {
+                callback(null, result);
+            }
+        });
+    }
+    store(identifier, etag, data, callback) {
+        this.hooks.store.callAsync(identifier, etag, data, (0, HookBaseError_1.makeBaseErrorCallback)(callback, 'Cache.hooks.store'));
+    }
+    storeBuildDependencies(dependencies, callback) {
+        this.hooks.storeBuildDependencies.callAsync(dependencies, (0, HookBaseError_1.makeBaseErrorCallback)(callback, 'Cache.hooks.storeBuildDependencies'));
+    }
+    beginIdle() {
+        this.hooks.beginIdle.call();
+    }
+    endIdle(callback) {
+        this.hooks.endIdle.callAsync((0, HookBaseError_1.makeBaseErrorCallback)(callback, 'Cache.hooks.endIdle'));
+    }
+    shutdown(callback) {
+        this.hooks.shutdown.callAsync((0, HookBaseError_1.makeBaseErrorCallback)(callback, 'Cache.hooks.shutdown'));
+    }
+}
+Cache.STAGE_MEMORY = -10;
+Cache.STAGE_DEFAULT = 0;
+Cache.STAGE_DISK = 10;
+Cache.STAGE_NETWORK = 20;
+exports.default = Cache;

package/dist/cache/CacheFacade.d.ts

@@ -0,0 +1,37 @@
+declare class MultiItemCache {
+    _items: any;
+    constructor(items: any);
+    get(callback: any): void;
+    getPromise(): any;
+    store(data: any, callback: any): void;
+    storePromise(data: any): Promise<void>;
+}
+declare class ItemCacheFacade {
+    _cache: any;
+    _name: any;
+    _etag: any;
+    constructor(cache: any, name: any, etag: any);
+    get(callback: any): void;
+    getPromise(): Promise<unknown>;
+    store(data: any, callback: any): void;
+    storePromise(data: any): Promise<unknown>;
+    provide(computer: any, callback: any): void;
+    providePromise(computer: any): Promise<any>;
+}
+declare class CacheFacade {
+    _cache: any;
+    _name: any;
+    _hashFunction: any;
+    constructor(cache: any, name: any, hashFunction: any);
+    getChildCache(name: any): CacheFacade;
+    getItemCache(identifier: any, etag: any): ItemCacheFacade;
+    getLazyHashedEtag(obj: any): any;
+    mergeEtags(a: any, b: any): any;
+    get(identifier: any, etag: any, callback: any): void;
+    getPromise(identifier: any, etag: any): Promise<unknown>;
+    store(identifier: any, etag: any, data: any, callback: any): void;
+    storePromise(identifier: any, etag: any, data: any): Promise<unknown>;
+    provide(identifier: any, etag: any, computer: any, callback: any): void;
+    providePromise(identifier: any, etag: any, computer: any): Promise<any>;
+}
+export { CacheFacade, ItemCacheFacade, MultiItemCache };

package/dist/cache/CacheFacade.js

@@ -0,0 +1,187 @@
+"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 });
+exports.MultiItemCache = exports.ItemCacheFacade = exports.CacheFacade = void 0;
+const enhanced_resolve_1 = require("enhanced-resolve");
+const neo_async_1 = __importDefault(require("neo-async"));
+const getLazyHashedEtag_1 = __importDefault(require("@/cache/getLazyHashedEtag"));
+const mergeEtags_1 = __importDefault(require("@/cache/mergeEtags"));
+class MultiItemCache {
+    constructor(items) {
+        this._items = items;
+        if (items.length === 1)
+            return items[0];
+    }
+    get(callback) {
+        (0, enhanced_resolve_1.forEachBail)(this._items, (item, callback) => item.get(callback), callback);
+    }
+    getPromise() {
+        const next = i => this._items[i].getPromise().then(result => {
+            if (result !== undefined)
+                return result;
+            if (++i < this._items.length)
+                return next(i);
+        });
+        return next(0);
+    }
+    store(data, callback) {
+        neo_async_1.default.each(this._items, (item, callback) => item.store(data, callback), callback);
+    }
+    storePromise(data) {
+        return Promise.all(this._items.map(item => item.storePromise(data))).then(() => { });
+    }
+}
+exports.MultiItemCache = MultiItemCache;
+class ItemCacheFacade {
+    constructor(cache, name, etag) {
+        this._cache = cache;
+        this._name = name;
+        this._etag = etag;
+    }
+    get(callback) {
+        this._cache.get(this._name, this._etag, callback);
+    }
+    getPromise() {
+        return new Promise((resolve, reject) => {
+            this._cache.get(this._name, this._etag, (err, data) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(data);
+                }
+            });
+        });
+    }
+    store(data, callback) {
+        this._cache.store(this._name, this._etag, data, callback);
+    }
+    storePromise(data) {
+        return new Promise((resolve, reject) => {
+            this._cache.store(this._name, this._etag, data, err => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(null);
+                }
+            });
+        });
+    }
+    provide(computer, callback) {
+        this.get((err, cacheEntry) => {
+            if (err)
+                return callback(err);
+            if (cacheEntry !== undefined)
+                return cacheEntry;
+            computer((err, result) => {
+                if (err)
+                    return callback(err);
+                this.store(result, err => {
+                    if (err)
+                        return callback(err);
+                    callback(null, result);
+                });
+            });
+        });
+    }
+    providePromise(computer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cacheEntry = yield this.getPromise();
+            if (cacheEntry !== undefined)
+                return cacheEntry;
+            const result = yield computer();
+            yield this.storePromise(result);
+            return result;
+        });
+    }
+}
+exports.ItemCacheFacade = ItemCacheFacade;
+class CacheFacade {
+    constructor(cache, name, hashFunction) {
+        this._cache = cache;
+        this._name = name;
+        this._hashFunction = hashFunction;
+    }
+    getChildCache(name) {
+        return new CacheFacade(this._cache, `${this._name}|${name}`, this._hashFunction);
+    }
+    getItemCache(identifier, etag) {
+        return new ItemCacheFacade(this._cache, `${this._name}|${identifier}`, etag);
+    }
+    getLazyHashedEtag(obj) {
+        return (0, getLazyHashedEtag_1.default)(obj, this._hashFunction);
+    }
+    mergeEtags(a, b) {
+        return (0, mergeEtags_1.default)(a, b);
+    }
+    get(identifier, etag, callback) {
+        this._cache.get(`${this._name}|${identifier}`, etag, callback);
+    }
+    getPromise(identifier, etag) {
+        return new Promise((resolve, reject) => {
+            this._cache.get(`${this._name}|${identifier}`, etag, (err, data) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(data);
+                }
+            });
+        });
+    }
+    store(identifier, etag, data, callback) {
+        this._cache.store(`${this._name}|${identifier}`, etag, data, callback);
+    }
+    storePromise(identifier, etag, data) {
+        return new Promise((resolve, reject) => {
+            this._cache.store(`${this._name}|${identifier}`, etag, data, err => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(null);
+                }
+            });
+        });
+    }
+    provide(identifier, etag, computer, callback) {
+        this.get(identifier, etag, (err, cacheEntry) => {
+            if (err)
+                return callback(err);
+            if (cacheEntry !== undefined)
+                return cacheEntry;
+            computer((err, result) => {
+                if (err)
+                    return callback(err);
+                this.store(identifier, etag, result, err => {
+                    if (err)
+                        return callback(err);
+                    callback(null, result);
+                });
+            });
+        });
+    }
+    providePromise(identifier, etag, computer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cacheEntry = yield this.getPromise(identifier, etag);
+            if (cacheEntry !== undefined)
+                return cacheEntry;
+            const result = yield computer();
+            yield this.storePromise(identifier, etag, result);
+            return result;
+        });
+    }
+}
+exports.CacheFacade = CacheFacade;

package/dist/cache/IdleFileCachePlugin.d.ts

@@ -0,0 +1,9 @@
+declare class IdleFileCachePlugin {
+    strategy: any;
+    idleTimeout: any;
+    idleTimeoutForInitialStore: any;
+    idleTimeoutAfterLargeChanges: any;
+    constructor(strategy: any, idleTimeout: number, idleTimeoutForInitialStore: number, idleTimeoutAfterLargeChanges: number);
+    apply(compiler: any): void;
+}
+export default IdleFileCachePlugin;