xhs-mp-pack 1.1.0-beta.0

package/dist/Watching.js

@@ -0,0 +1,359 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const const_1 = __importDefault(require("@/base/const"));
+const Stats_1 = __importDefault(require("@/base/stats/Stats"));
+const { BUILD_REASON } = const_1.default;
+class Watching {
+    constructor(compiler, watchOptions, handler) {
+        this._closeCallbacks = [];
+        this.lastWatcherStartTime = 0;
+        this.startTime = 0;
+        this.invalid = false;
+        this.handler = handler;
+        this.callbacks = [];
+        this._closeCallbacks = [];
+        this.closed = false;
+        this.suspended = false;
+        this.blocked = false;
+        console.log('start init');
+        this.buildReason = BUILD_REASON.INIT;
+        this._isBlocked = () => false;
+        this._onChange = () => { };
+        this._onInvalid = () => { };
+        if (typeof watchOptions === 'number') {
+            this.watchOptions = {
+                aggregateTimeout: watchOptions,
+            };
+        }
+        else if (watchOptions && typeof watchOptions === 'object') {
+            this.watchOptions = Object.assign({}, watchOptions);
+        }
+        else {
+            this.watchOptions = {};
+        }
+        if (typeof this.watchOptions.aggregateTimeout !== 'number') {
+            this.watchOptions.aggregateTimeout = 20;
+        }
+        this.compiler = compiler;
+        this.running = false;
+        this._initial = true;
+        this._invalidReported = true;
+        this._needRecords = true;
+        this.watcher = undefined;
+        this.pausedWatcher = undefined;
+        this._collectedChangedFiles = undefined;
+        this._collectedRemovedFiles = undefined;
+        this._done = this._done.bind(this);
+        process.nextTick(() => {
+            if (this._initial)
+                this._invalidate();
+        });
+    }
+    _mergeWithCollected(changedFiles, removedFiles) {
+        if (!changedFiles)
+            return;
+        if (!this._collectedChangedFiles) {
+            this._collectedChangedFiles = new Set(changedFiles);
+            this._collectedRemovedFiles = new Set(removedFiles);
+        }
+        else {
+            for (const file of changedFiles) {
+                this._collectedChangedFiles.add(file);
+                this._collectedRemovedFiles.delete(file);
+            }
+            for (const file of removedFiles) {
+                this._collectedChangedFiles.delete(file);
+                this._collectedRemovedFiles.add(file);
+            }
+        }
+    }
+    _go(fileTimeInfoEntries, contextTimeInfoEntries, changedFiles, removedFiles) {
+        var _a, _b, _c, _d;
+        this._initial = false;
+        if (this.startTime === null)
+            this.startTime = Date.now();
+        this.running = true;
+        if (this.watcher) {
+            this.pausedWatcher = this.watcher;
+            this.lastWatcherStartTime = Date.now();
+            this.watcher.pause();
+            this.watcher = null;
+        }
+        else if (!this.lastWatcherStartTime) {
+            this.lastWatcherStartTime = Date.now();
+        }
+        this.compiler.fsStartTime = Date.now();
+        if (changedFiles && removedFiles && fileTimeInfoEntries && contextTimeInfoEntries) {
+            this._mergeWithCollected(changedFiles, removedFiles);
+            this.compiler.fileTimestamps = fileTimeInfoEntries;
+            this.compiler.contextTimestamps = contextTimeInfoEntries;
+        }
+        else if (this.pausedWatcher) {
+            if (this.pausedWatcher.getInfo) {
+                const { changes, removals, fileTimeInfoEntries, contextTimeInfoEntries } = this.pausedWatcher.getInfo();
+                this._mergeWithCollected(changes, removals);
+                this.compiler.fileTimestamps = fileTimeInfoEntries;
+                this.compiler.contextTimestamps = contextTimeInfoEntries;
+            }
+            else {
+                this._mergeWithCollected((_b = (_a = this.pausedWatcher).getAggregatedChanges) === null || _b === void 0 ? void 0 : _b.call(_a), (_d = (_c = this.pausedWatcher).getAggregatedRemovals) === null || _d === void 0 ? void 0 : _d.call(_c));
+                this.compiler.fileTimestamps = this.pausedWatcher.getFileTimeInfoEntries();
+                this.compiler.contextTimestamps = this.pausedWatcher.getContextTimeInfoEntries();
+            }
+        }
+        this.compiler.modifiedFiles = this._collectedChangedFiles;
+        this._collectedChangedFiles = undefined;
+        this.compiler.removedFiles = this._collectedRemovedFiles;
+        this._collectedRemovedFiles = undefined;
+        const run = () => {
+            if (this.compiler.idle) {
+                return this.compiler.cache.endIdle(err => {
+                    if (err)
+                        return this._done(err);
+                    this.compiler.idle = false;
+                    run();
+                });
+            }
+            if (this._needRecords) {
+                return this.compiler.readRecords(err => {
+                    if (err)
+                        return this._done(err);
+                    this._needRecords = false;
+                    run();
+                });
+            }
+            this.invalid = false;
+            this._invalidReported = false;
+            this.compiler.hooks.watchRun.callAsync(this.compiler, err => {
+                if (err)
+                    return this._done(err);
+                const onCompiled = (err, compilation) => {
+                    if (err)
+                        return this._done(err, compilation);
+                    if (this.invalid)
+                        return this._done(null, compilation);
+                    if (this.compiler.hooks.shouldEmit.call(compilation) === false) {
+                        return this._done(null, compilation);
+                    }
+                    process.nextTick(() => {
+                        const logger = compilation.getLogger('webpack.Compiler');
+                        logger.time('emitAssets');
+                        this.compiler.emitAssets(compilation, err => {
+                            logger.timeEnd('emitAssets');
+                            if (err)
+                                return this._done(err, compilation);
+                            if (this.invalid)
+                                return this._done(null, compilation);
+                            logger.time('emitRecords');
+                            this.compiler.emitRecords(err => {
+                                logger.timeEnd('emitRecords');
+                                if (err)
+                                    return this._done(err, compilation);
+                                return this._done(null, compilation);
+                            });
+                        });
+                    });
+                };
+                this.compiler.compile(onCompiled);
+            });
+        };
+        run();
+    }
+    _getStats(compilation) {
+        const stats = new Stats_1.default(compilation);
+        return stats;
+    }
+    _done(err, compilation) {
+        this.running = false;
+        const logger = compilation === null || compilation === void 0 ? void 0 : compilation.getLogger('webpack.Watching');
+        let stats = null;
+        const handleError = (err, cbs) => {
+            this.compiler.hooks.failed.call(err);
+            this.compiler.cache.beginIdle();
+            this.compiler.idle = true;
+            this.handler(err, stats);
+            if (!cbs) {
+                cbs = this.callbacks;
+                this.callbacks = [];
+            }
+            for (const cb of cbs)
+                cb(err, null);
+        };
+        if (this.invalid &&
+            !this.suspended &&
+            !this.blocked &&
+            !(this._isBlocked() && (this.blocked = true))) {
+            if (compilation) {
+                logger.time('storeBuildDependencies');
+                this.compiler.cache.storeBuildDependencies(compilation.buildDependencies, err => {
+                    logger.timeEnd('storeBuildDependencies');
+                    if (err)
+                        return handleError(err);
+                    this._go();
+                });
+            }
+            else {
+                this._go();
+            }
+            return;
+        }
+        if (compilation) {
+            compilation.startTime = this.startTime;
+            compilation.endTime = Date.now();
+            stats = new Stats_1.default(compilation);
+        }
+        this.startTime = null;
+        if (err)
+            return handleError(err);
+        const cbs = this.callbacks;
+        this.callbacks = [];
+        logger.time('done hook');
+        this.compiler.hooks.done.callAsync(stats, err => {
+            logger.timeEnd('done hook');
+            if (err)
+                return handleError(err, cbs);
+            this.handler(null, stats);
+            logger.time('storeBuildDependencies');
+            this.compiler.cache.storeBuildDependencies(compilation.buildDependencies, err => {
+                logger.timeEnd('storeBuildDependencies');
+                if (err)
+                    return handleError(err, cbs);
+                logger.time('beginIdle');
+                this.compiler.cache.beginIdle();
+                this.compiler.idle = true;
+                logger.timeEnd('beginIdle');
+                process.nextTick(() => {
+                    if (!this.closed) {
+                        this.watch(compilation.fileDependencies, compilation.contextDependencies, compilation.missingDependencies);
+                    }
+                });
+                for (const cb of cbs)
+                    cb(null, null);
+                this.compiler.hooks.afterDone.call(stats);
+            });
+        });
+    }
+    watch(files, dirs, missing) {
+        this.pausedWatcher = null;
+        this.watcher = this.compiler.watchFileSystem.watch(files, dirs, missing, this.lastWatcherStartTime, this.watchOptions, (err, fileTimeInfoEntries, contextTimeInfoEntries, changedFiles, removedFiles) => {
+            if (err) {
+                this.compiler.modifiedFiles = undefined;
+                this.compiler.removedFiles = undefined;
+                this.compiler.fileTimestamps = undefined;
+                this.compiler.contextTimestamps = undefined;
+                this.compiler.fsStartTime = undefined;
+                return this.handler(err, null);
+            }
+            console.log('trigger watch', changedFiles, removedFiles);
+            this.buildReason = BUILD_REASON.FILE_CHANGE;
+            this._invalidate(fileTimeInfoEntries, contextTimeInfoEntries, changedFiles, removedFiles);
+            this._onChange();
+        }, (fileName, changeTime) => {
+            if (!this._invalidReported) {
+                this._invalidReported = true;
+                this.compiler.hooks.invalid.call(fileName, changeTime);
+            }
+            this._onInvalid();
+        });
+    }
+    invalidateWithReason(reason, callback) {
+        console.log('invalidate', reason);
+        this.buildReason = reason;
+        this.invalidate(callback);
+    }
+    invalidate(callback) {
+        if (callback) {
+            this.callbacks.push(callback);
+        }
+        if (!this._invalidReported) {
+            this._invalidReported = true;
+            this.compiler.hooks.invalid.call(null, Date.now());
+        }
+        this._onChange();
+        this._invalidate();
+    }
+    _invalidate(fileTimeInfoEntries, contextTimeInfoEntries, changedFiles, removedFiles) {
+        if (this.suspended || (this._isBlocked() && (this.blocked = true))) {
+            this._mergeWithCollected(changedFiles, removedFiles);
+            return;
+        }
+        console.log('invalidate', this.buildReason, this.running);
+        if (this.running) {
+            this._mergeWithCollected(changedFiles, removedFiles);
+            this.invalid = true;
+        }
+        else {
+            this._go(fileTimeInfoEntries, contextTimeInfoEntries, changedFiles, removedFiles);
+        }
+    }
+    suspend() {
+        this.suspended = true;
+    }
+    resume() {
+        if (this.suspended) {
+            this.suspended = false;
+            this._invalidate();
+        }
+    }
+    close(callback) {
+        if (this._closeCallbacks) {
+            if (callback) {
+                this._closeCallbacks.push(callback);
+            }
+            return;
+        }
+        const finalCallback = (err, compilation) => {
+            this.running = false;
+            this.compiler.running = false;
+            this.compiler.watching = undefined;
+            this.compiler.watchMode = false;
+            this.compiler.modifiedFiles = undefined;
+            this.compiler.removedFiles = undefined;
+            this.compiler.fileTimestamps = undefined;
+            this.compiler.contextTimestamps = undefined;
+            this.compiler.fsStartTime = undefined;
+            const shutdown = (err) => {
+                this.compiler.hooks.watchClose.call();
+                const closeCallbacks = this._closeCallbacks;
+                this._closeCallbacks = [];
+                for (const cb of closeCallbacks)
+                    cb(err);
+            };
+            if (compilation) {
+                const logger = compilation.getLogger('webpack.Watching');
+                logger.time('storeBuildDependencies');
+                this.compiler.cache.storeBuildDependencies(compilation.buildDependencies, err2 => {
+                    logger.timeEnd('storeBuildDependencies');
+                    shutdown(err || err2);
+                });
+            }
+            else {
+                shutdown(err);
+            }
+        };
+        this.closed = true;
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+        }
+        if (this.pausedWatcher) {
+            this.pausedWatcher.close();
+            this.pausedWatcher = null;
+        }
+        this._closeCallbacks = [];
+        if (callback) {
+            this._closeCallbacks.push(callback);
+        }
+        if (this.running) {
+            this.invalid = true;
+            this._done = finalCallback;
+        }
+        else {
+            finalCallback();
+        }
+    }
+}
+exports.default = Watching;

package/dist/base/ArrayHelpers.d.ts

@@ -0,0 +1,6 @@
+declare const equals: (a: any, b: any) => boolean;
+/**
+ * Partition an array by calling a predicate function on each value.
+ */
+declare const groupBy: (arr: never[] | undefined, fn: any) => never[][];
+export { equals, groupBy };

package/dist/base/ArrayHelpers.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupBy = exports.equals = void 0;
+const equals = (a, b) => {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+};
+exports.equals = equals;
+/**
+ * Partition an array by calling a predicate function on each value.
+ */
+const groupBy = (arr = [], fn) => arr.reduce((groups, value) => {
+    groups[fn(value) ? 0 : 1].push(value);
+    return groups;
+}, [[], []]);
+exports.groupBy = groupBy;

package/dist/base/ArrayQueue.d.ts

@@ -0,0 +1,29 @@
+declare class ArrayQueue {
+    _list: any[];
+    _listReversed: any[];
+    constructor(items?: any);
+    get length(): number;
+    /**
+     * Empties the queue.
+     */
+    clear(): void;
+    /**
+     * Appends the specified element to this queue.
+     */
+    enqueue(item: any): void;
+    /**
+     * Retrieves and removes the head of this queue.
+     */
+    dequeue(): any;
+    /**
+     * Finds and removes an item
+     */
+    delete(item: any): void;
+    [Symbol.iterator](): {
+        next: () => {
+            done: boolean;
+            value: any;
+        };
+    };
+}
+export default ArrayQueue;

package/dist/base/ArrayQueue.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ArrayQueue {
+    constructor(items) {
+        this._list = items ? Array.from(items) : [];
+        this._listReversed = [];
+    }
+    get length() {
+        return this._list.length + this._listReversed.length;
+    }
+    /**
+     * Empties the queue.
+     */
+    clear() {
+        this._list.length = 0;
+        this._listReversed.length = 0;
+    }
+    /**
+     * Appends the specified element to this queue.
+     */
+    enqueue(item) {
+        this._list.push(item);
+    }
+    /**
+     * Retrieves and removes the head of this queue.
+     */
+    dequeue() {
+        if (this._listReversed.length === 0) {
+            if (this._list.length === 0)
+                return undefined;
+            if (this._list.length === 1)
+                return this._list.pop();
+            if (this._list.length < 16)
+                return this._list.shift();
+            const temp = this._listReversed;
+            this._listReversed = this._list;
+            this._listReversed.reverse();
+            this._list = temp;
+        }
+        return this._listReversed.pop();
+    }
+    /**
+     * Finds and removes an item
+     */
+    delete(item) {
+        const i = this._list.indexOf(item);
+        if (i >= 0) {
+            this._list.splice(i, 1);
+        }
+        else {
+            const i = this._listReversed.indexOf(item);
+            if (i >= 0)
+                this._listReversed.splice(i, 1);
+        }
+    }
+    [Symbol.iterator]() {
+        let i = -1;
+        let reversed = false;
+        return {
+            next: () => {
+                if (!reversed) {
+                    i++;
+                    if (i < this._list.length) {
+                        return {
+                            done: false,
+                            value: this._list[i],
+                        };
+                    }
+                    reversed = true;
+                    i = this._listReversed.length;
+                }
+                i--;
+                if (i < 0) {
+                    return {
+                        done: true,
+                        value: undefined,
+                    };
+                }
+                return {
+                    done: false,
+                    value: this._listReversed[i],
+                };
+            },
+        };
+    }
+}
+exports.default = ArrayQueue;

package/dist/base/AsyncQueue.d.ts

@@ -0,0 +1,37 @@
+import ArrayQueue from './ArrayQueue';
+declare class AsyncQueue {
+    _name: any;
+    _parallelism: any;
+    _processor: any;
+    _getKey: any;
+    _entries: Map<any, any>;
+    _queued: ArrayQueue;
+    _children: any;
+    _activeTasks: number;
+    _willEnsureProcessing: boolean;
+    _needProcessing: boolean;
+    _stopped: boolean;
+    _root: any;
+    hooks: any;
+    constructor({ name, parallelism, parent, processor, getKey, }: {
+        name: string;
+        parallelism?: number;
+        parent?: any;
+        processor: any;
+        getKey?: any;
+    });
+    add(item: any, callback: any): any;
+    invalidate(item: any): void;
+    waitFor(item: any, callback: any): any;
+    stop(): void;
+    increaseParallelism(): void;
+    decreaseParallelism(): void;
+    isProcessing(item: any): boolean;
+    isQueued(item: any): boolean;
+    isDone(item: any): boolean;
+    _ensureProcessing(): void;
+    _startProcessing(entry: any): void;
+    _handleResult(entry: any, err?: any, result?: any): void;
+    clear(): void;
+}
+export default AsyncQueue;