xhs-mp-compiler-cli 2.0.0-beta.3 → 2.0.0

package/dist/utils/workerPool.js

@@ -0,0 +1,125 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    // 获取当前设备的 CPU 线程数目，作为 numberOfThreads 的默认值。
+    const { length: cpusLength } = require('os').cpus();
+    const { Worker } = require('worker_threads');
+    class WorkerPool {
+        constructor(workerPath, options = {}, numberOfThreads = cpusLength) {
+            this._workersById = {};
+            this._activeWorkersById = {};
+            if (numberOfThreads < 1) {
+                throw new Error('Number of threads should be greater or equal than 1!');
+            }
+            this.workerPath = workerPath;
+            this.numberOfThreads = numberOfThreads;
+            // 任务队列
+            this._queue = [];
+            // Worker 索引
+            this._workersById = {};
+            // Worker 激活状态索引
+            this._activeWorkersById = {};
+            // 创建 Workers
+            for (let i = 0; i < this.numberOfThreads; i++) {
+                const worker = new Worker(workerPath, options);
+                this._workersById[i] = worker;
+                // 将这些 Worker 设置为未激活状态
+                this._activeWorkersById[i] = false;
+            }
+        }
+        /**
+         * 检查空闲的 Worker
+         */
+        getInactiveWorkerId() {
+            for (let i = 0; i < this.numberOfThreads; i++) {
+                if (!this._activeWorkersById[i])
+                    return i;
+            }
+            return -1;
+        }
+        /**
+         * 调用 Worker 执行，目的是在指定的 Worker 里执行指定的任务
+         */
+        runWorker(workerId, taskObj) {
+            const worker = this._workersById[workerId];
+            // 当任务执行完毕后执行
+            const doAfterTaskIsFinished = () => {
+                // 去除所有的 Listener，不然一次次添加不同的 Listener 会内存溢出（OOM）
+                worker.removeAllListeners('message');
+                worker.removeAllListeners('error');
+                // 将这个 Worker 设为未激活状态
+                this._activeWorkersById[workerId] = false;
+                if (this._queue.length) {
+                    // 任务队列非空，使用该 Worker 执行任务队列中第一个任务
+                    this.runWorker(workerId, this._queue.shift());
+                }
+            };
+            // 将这个 Worker 设置为激活状态
+            this._activeWorkersById[workerId] = true;
+            // 设置两个回调，用于 Worker 的监听器
+            const messageCallback = result => {
+                taskObj.cb(null, result);
+                doAfterTaskIsFinished();
+            };
+            const errorCallback = error => {
+                taskObj.cb(error);
+                doAfterTaskIsFinished();
+            };
+            // 为 Worker 添加 'message' 和 'error' 两个 Listener
+            worker.once('message', messageCallback);
+            worker.once('error', errorCallback);
+            // 将数据传给 Worker 供其获取和执行
+            worker.postMessage(taskObj.data);
+        }
+        /**
+         * 运行线程
+         */
+        run(data) {
+            // Promise 是个好东西
+            return new Promise((resolve, reject) => {
+                // 调用 getInactiveWorkerId() 获取一个空闲的 Worker
+                const availableWorkerId = this.getInactiveWorkerId();
+                const taskObj = {
+                    data,
+                    cb: (error, result) => {
+                        // 虽然 Workers 需要使用 Listener 和 Callback，但这不能阻止我们使用 Promise，对吧？
+                        // 不，你不能 util.promisify(taskObj) 。人不能，至少不应该。
+                        if (error)
+                            reject(error);
+                        return resolve(result);
+                    }
+                };
+                if (availableWorkerId === -1) {
+                    // 当前没有空闲的 Workers 了，把任务丢进队列里，这样一旦有 Workers 空闲时就会开始执行。
+                    this._queue.push(taskObj);
+                    return null;
+                }
+                // 有一个空闲的 Worker，用它执行任务
+                this.runWorker(availableWorkerId, taskObj);
+            });
+        }
+        /**
+         * 销毁
+         */
+        destroy(force = false) {
+            for (let i = 0; i < this.numberOfThreads; i++) {
+                if (this._activeWorkersById[i] && !force) {
+                    // 通常情况下，不应该在还有 Worker 在执行的时候就销毁它，这一定是什么地方出了问题，所以还是抛个 Error 比较好
+                    // 不过保留一个 force 参数，总有人用得到的
+                    throw new Error(`The worker ${i} is still runing!`);
+                }
+                // 销毁这个 Worker
+                this._workersById[i].terminate();
+            }
+        }
+    }
+    exports.default = WorkerPool;
+});

package/dist/utils/zip.js

@@ -1,4 +1,3 @@
-"use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -31,257 +30,268 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.genZip = exports.unzipMac = exports.unzip = exports.Zip = void 0;
-const child_process_1 = require("child_process");
-const fs_1 = require("fs");
-const fse = __importStar(require("fs-extra"));
-const debug = require('debug')('zip');
-const path = require('path');
-const { promisify } = require('util');
-const stream = require('stream');
-const archiver = require('archiver');
-const yauzl = require('yauzl');
-const openZip = promisify(yauzl.open);
-const pipeline = promisify(stream.pipeline);
-class Extractor {
-    constructor(zipPath, opts) {
-        this.zipPath = '';
-        this.opts = null;
-        this.zipfile = null;
-        this.canceled = false;
-        this.zipPath = zipPath;
-        this.opts = opts;
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
     }
-    extract() {
-        return __awaiter(this, void 0, void 0, function* () {
-            debug('opening', this.zipPath, 'with opts', this.opts);
-            this.zipfile = yield openZip(this.zipPath, { lazyEntries: true });
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "child_process", "fs", "fs-extra"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.genZip = exports.Zip = void 0;
+    exports.unzip = unzip;
+    exports.unzipMac = unzipMac;
+    const child_process_1 = require("child_process");
+    const fs_1 = require("fs");
+    const fse = __importStar(require("fs-extra"));
+    const debug = require('debug')('zip');
+    const path = require('path');
+    const { promisify } = require('util');
+    const stream = require('stream');
+    const archiver = require('archiver');
+    const yauzl = require('yauzl');
+    const openZip = promisify(yauzl.open);
+    const pipeline = promisify(stream.pipeline);
+    class Extractor {
+        constructor(zipPath, opts) {
+            this.zipPath = '';
+            this.opts = null;
+            this.zipfile = null;
             this.canceled = false;
-            return new Promise((resolve, reject) => {
-                this.zipfile.on('error', err => {
-                    this.canceled = true;
-                    reject(err);
-                });
-                this.zipfile.readEntry();
-                this.zipfile.on('close', () => {
-                    if (!this.canceled) {
-                        debug('zip extraction complete');
-                        resolve();
-                    }
-                });
-                this.zipfile.on('entry', (entry) => __awaiter(this, void 0, void 0, function* () {
-                    /* istanbul ignore if */
-                    if (this.canceled) {
-                        debug('skipping entry', entry.fileName, { cancelled: this.canceled });
-                        return;
-                    }
-                    debug('zipfile entry', entry.fileName);
-                    if (entry.fileName.startsWith('__MACOSX/')) {
-                        this.zipfile.readEntry();
-                        return;
-                    }
-                    const destDir = path.dirname(path.join(this.opts.dir, entry.fileName));
-                    try {
-                        yield fs_1.promises.mkdir(destDir, { recursive: true });
-                        let canonicalDestDir = '';
-                        try {
-                            canonicalDestDir = yield fs_1.promises.realpath(destDir);
+            this.zipPath = zipPath;
+            this.opts = opts;
+        }
+        extract() {
+            return __awaiter(this, void 0, void 0, function* () {
+                debug('opening', this.zipPath, 'with opts', this.opts);
+                this.zipfile = yield openZip(this.zipPath, { lazyEntries: true });
+                this.canceled = false;
+                return new Promise((resolve, reject) => {
+                    this.zipfile.on('error', err => {
+                        this.canceled = true;
+                        reject(err);
+                    });
+                    this.zipfile.readEntry();
+                    this.zipfile.on('close', () => {
+                        if (!this.canceled) {
+                            debug('zip extraction complete');
+                            resolve();
                         }
-                        catch (error) {
-                            canonicalDestDir = path.resolve(destDir);
+                    });
+                    this.zipfile.on('entry', (entry) => __awaiter(this, void 0, void 0, function* () {
+                        /* istanbul ignore if */
+                        if (this.canceled) {
+                            debug('skipping entry', entry.fileName, { cancelled: this.canceled });
+                            return;
                         }
-                        const relativeDestDir = path.relative(this.opts.dir, canonicalDestDir);
-                        if (relativeDestDir.split(path.sep).includes('..')) {
-                            throw new Error(`Out of bound path "${canonicalDestDir}" found while processing file ${entry.fileName}`);
+                        debug('zipfile entry', entry.fileName);
+                        if (entry.fileName.startsWith('__MACOSX/')) {
+                            this.zipfile.readEntry();
+                            return;
                         }
-                        yield this.extractEntry(entry);
-                        debug('finished processing', entry.fileName);
-                        this.zipfile.readEntry();
-                    }
-                    catch (err) {
-                        this.canceled = true;
-                        this.zipfile.close();
-                        reject(err);
-                    }
-                }));
-            });
-        });
-    }
-    extractEntry(entry) {
-        return __awaiter(this, void 0, void 0, function* () {
-            /* istanbul ignore if */
-            if (this.canceled) {
-                debug('skipping entry extraction', entry.fileName, {
-                    cancelled: this.canceled
+                        const destDir = path.dirname(path.join(this.opts.dir, entry.fileName));
+                        try {
+                            yield fs_1.promises.mkdir(destDir, { recursive: true });
+                            let canonicalDestDir = '';
+                            try {
+                                canonicalDestDir = yield fs_1.promises.realpath(destDir);
+                            }
+                            catch (error) {
+                                canonicalDestDir = path.resolve(destDir);
+                            }
+                            const relativeDestDir = path.relative(this.opts.dir, canonicalDestDir);
+                            if (relativeDestDir.split(path.sep).includes('..')) {
+                                throw new Error(`Out of bound path "${canonicalDestDir}" found while processing file ${entry.fileName}`);
+                            }
+                            yield this.extractEntry(entry);
+                            debug('finished processing', entry.fileName);
+                            this.zipfile.readEntry();
+                        }
+                        catch (err) {
+                            this.canceled = true;
+                            this.zipfile.close();
+                            reject(err);
+                        }
+                    }));
                 });
-                return;
-            }
-            if (this.opts.onEntry) {
-                this.opts.onEntry(entry, this.zipfile);
-            }
-            const dest = path.join(this.opts.dir, entry.fileName);
-            // convert external file attr int into a fs stat mode int
-            const mode = (entry.externalFileAttributes >> 16) & 0xffff;
-            // check if it's a symlink or dir (using stat mode constants)
-            const IFMT = 61440;
-            const IFDIR = 16384;
-            const IFLNK = 40960;
-            const symlink = (mode & IFMT) === IFLNK;
-            let isDir = (mode & IFMT) === IFDIR;
-            // Failsafe, borrowed from jsZip
-            if (!isDir && entry.fileName.endsWith('/')) {
-                isDir = true;
-            }
-            // check for windows weird way of specifying a directory
-            // https://github.com/maxogden/extract-zip/issues/13#issuecomment-154494566
-            const madeBy = entry.versionMadeBy >> 8;
-            if (!isDir)
-                isDir = madeBy === 0 && entry.externalFileAttributes === 16;
-            debug('extracting entry', {
-                filename: entry.fileName,
-                isDir,
-                isSymlink: symlink
             });
-            const procMode = this.getExtractedMode(mode, isDir) & 0o777;
-            // always ensure folders are created
-            const destDir = isDir ? dest : path.dirname(dest);
-            const mkdirOptions = { recursive: true };
-            if (isDir) {
-                mkdirOptions.mode = procMode;
-            }
-            debug('mkdir', Object.assign({ dir: destDir }, mkdirOptions));
-            yield fs_1.promises.mkdir(destDir, mkdirOptions);
-            if (isDir)
-                return;
-            debug('opening read stream', dest);
-            const readStream = yield promisify(this.zipfile.openReadStream.bind(this.zipfile))(entry);
-            if (symlink) {
-                // const link = await getStream(readStream)
-                // debug('creating symlink', link, dest)
-                // await fs.symlink(link, dest)
-            }
-            else {
-                yield pipeline(readStream, (0, fs_1.createWriteStream)(dest, { mode: procMode }));
-            }
-        });
-    }
-    getExtractedMode(entryMode, isDir) {
-        let mode = entryMode;
-        // Set defaults, if necessary
-        if (mode === 0) {
-            if (isDir) {
-                if (this.opts.defaultDirMode) {
-                    mode = parseInt(this.opts.defaultDirMode, 10);
+        }
+        extractEntry(entry) {
+            return __awaiter(this, void 0, void 0, function* () {
+                /* istanbul ignore if */
+                if (this.canceled) {
+                    debug('skipping entry extraction', entry.fileName, {
+                        cancelled: this.canceled
+                    });
+                    return;
                 }
-                if (!mode) {
-                    mode = 0o755;
+                if (this.opts.onEntry) {
+                    this.opts.onEntry(entry, this.zipfile);
                 }
-            }
-            else {
-                if (this.opts.defaultFileMode) {
-                    mode = parseInt(this.opts.defaultFileMode, 10);
+                const dest = path.join(this.opts.dir, entry.fileName);
+                // convert external file attr int into a fs stat mode int
+                const mode = (entry.externalFileAttributes >> 16) & 0xffff;
+                // check if it's a symlink or dir (using stat mode constants)
+                const IFMT = 61440;
+                const IFDIR = 16384;
+                const IFLNK = 40960;
+                const symlink = (mode & IFMT) === IFLNK;
+                let isDir = (mode & IFMT) === IFDIR;
+                // Failsafe, borrowed from jsZip
+                if (!isDir && entry.fileName.endsWith('/')) {
+                    isDir = true;
+                }
+                // check for windows weird way of specifying a directory
+                // https://github.com/maxogden/extract-zip/issues/13#issuecomment-154494566
+                const madeBy = entry.versionMadeBy >> 8;
+                if (!isDir)
+                    isDir = madeBy === 0 && entry.externalFileAttributes === 16;
+                debug('extracting entry', {
+                    filename: entry.fileName,
+                    isDir,
+                    isSymlink: symlink
+                });
+                const procMode = this.getExtractedMode(mode, isDir) & 0o777;
+                // always ensure folders are created
+                const destDir = isDir ? dest : path.dirname(dest);
+                const mkdirOptions = { recursive: true };
+                if (isDir) {
+                    mkdirOptions.mode = procMode;
+                }
+                debug('mkdir', Object.assign({ dir: destDir }, mkdirOptions));
+                yield fs_1.promises.mkdir(destDir, mkdirOptions);
+                if (isDir)
+                    return;
+                debug('opening read stream', dest);
+                const readStream = yield promisify(this.zipfile.openReadStream.bind(this.zipfile))(entry);
+                if (symlink) {
+                    // const link = await getStream(readStream)
+                    // debug('creating symlink', link, dest)
+                    // await fs.symlink(link, dest)
+                }
+                else {
+                    yield pipeline(readStream, (0, fs_1.createWriteStream)(dest, { mode: procMode }));
                 }
-                if (!mode) {
-                    mode = 0o644;
+            });
+        }
+        getExtractedMode(entryMode, isDir) {
+            let mode = entryMode;
+            // Set defaults, if necessary
+            if (mode === 0) {
+                if (isDir) {
+                    if (this.opts.defaultDirMode) {
+                        mode = parseInt(this.opts.defaultDirMode, 10);
+                    }
+                    if (!mode) {
+                        mode = 0o755;
+                    }
+                }
+                else {
+                    if (this.opts.defaultFileMode) {
+                        mode = parseInt(this.opts.defaultFileMode, 10);
+                    }
+                    if (!mode) {
+                        mode = 0o644;
+                    }
                 }
             }
+            return mode;
         }
-        return mode;
     }
-}
-class Zip {
-    constructor(options) {
-        this.options = options;
-        this.archive = archiver('zip', {
-            zlib: { level: 9 } // Sets the compression level.
-        });
-        this.initOutput();
+    class Zip {
+        constructor(options) {
+            this.options = options;
+            this.archive = archiver('zip', {
+                zlib: { level: 9 } // Sets the compression level.
+            });
+            this.initOutput();
+        }
+        initOutput() {
+            const { outputDir } = this.options;
+            this.output = fse.createWriteStream(outputDir);
+            this.archive.pipe(this.output);
+        }
+        finalize() {
+            return __awaiter(this, void 0, void 0, function* () {
+                return this.archive.finalize();
+            });
+        }
     }
-    initOutput() {
-        const { outputDir } = this.options;
-        this.output = fse.createWriteStream(outputDir);
-        this.archive.pipe(this.output);
+    exports.Zip = Zip;
+    /**
+     * 解压 zip 文件 yauzl
+     * @param zipPath string
+     * @param outputDir string
+     * @param options unzipOptions
+     */
+    function unzip(zipPath, outputDir) {
+        return __awaiter(this, void 0, void 0, function* () {
+            debug('creating target directory', outputDir);
+            if (!path.isAbsolute(outputDir)) {
+                throw new Error('Target directory is expected to be absolute');
+            }
+            yield fs_1.promises.mkdir(outputDir, { recursive: true });
+            const _outputDir = yield fs_1.promises.realpath(outputDir);
+            return new Extractor(zipPath, {
+                dir: _outputDir
+            }).extract();
+        });
     }
-    finalize() {
+    /**
+     * 解压 zip 文件
+     * @param zipPath string
+     * @param outputDir string
+     */
+    function unzipMac(zipPath, outputDir) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.archive.finalize();
+            return new Promise((resolve, reject) => {
+                const proc = (0, child_process_1.spawn)('/usr/bin/unzip', [zipPath, '-d', outputDir]);
+                const output = '';
+                proc.on('error', err => {
+                    reject(err);
+                });
+                proc.on('exit', (code) => {
+                    if (code > 0) {
+                        reject(new Error(`Exited with code ${code}`));
+                    }
+                    else {
+                        resolve(output);
+                    }
+                });
+                proc.stderr.on('data', chunk => {
+                    console.error(chunk.toString());
+                });
+                proc.stdout.on('data', chunk => {
+                    // console.log(chunk.toString());
+                });
+            });
         });
     }
-}
-exports.Zip = Zip;
-/**
- * 解压 zip 文件 yauzl
- * @param zipPath string
- * @param outputDir string
- * @param options unzipOptions
- */
-function unzip(zipPath, outputDir) {
-    return __awaiter(this, void 0, void 0, function* () {
-        debug('creating target directory', outputDir);
-        if (!path.isAbsolute(outputDir)) {
-            throw new Error('Target directory is expected to be absolute');
-        }
-        yield fs_1.promises.mkdir(outputDir, { recursive: true });
-        const _outputDir = yield fs_1.promises.realpath(outputDir);
-        return new Extractor(zipPath, {
-            dir: _outputDir
-        }).extract();
-    });
-}
-exports.unzip = unzip;
-/**
- * 解压 zip 文件
- * @param zipPath string
- * @param outputDir string
- */
-function unzipMac(zipPath, outputDir) {
-    return __awaiter(this, void 0, void 0, function* () {
+    const genZip = (input, output, appId) => __awaiter(void 0, void 0, void 0, function* () {
         return new Promise((resolve, reject) => {
-            const proc = (0, child_process_1.spawn)('/usr/bin/unzip', [zipPath, '-d', outputDir]);
-            const output = '';
-            proc.on('error', err => {
-                reject(err);
-            });
-            proc.on('exit', (code) => {
-                if (code > 0) {
-                    reject(new Error(`Exited with code ${code}`));
-                }
-                else {
-                    resolve(output);
-                }
+            const outputStream = (0, fs_1.createWriteStream)(output);
+            const archive = archiver('zip', {
+                zlib: { level: 9 } // Sets the compression level.
             });
-            proc.stderr.on('data', chunk => {
-                console.error(chunk.toString());
+            outputStream.on('close', () => {
+                resolve();
             });
-            proc.stdout.on('data', chunk => {
-                // console.log(chunk.toString());
+            archive.on('error', error => {
+                console.error('archive error:', error);
+                reject(error);
             });
+            archive.pipe(outputStream);
+            if (appId) {
+                archive.directory(input, appId);
+            }
+            else {
+                archive.directory(input, './');
+            }
+            archive.finalize();
         });
     });
-}
-exports.unzipMac = unzipMac;
-const genZip = (input, output, appId) => __awaiter(void 0, void 0, void 0, function* () {
-    return new Promise((resolve, reject) => {
-        const outputStream = (0, fs_1.createWriteStream)(output);
-        const archive = archiver('zip', {
-            zlib: { level: 9 } // Sets the compression level.
-        });
-        outputStream.on('close', () => {
-            resolve();
-        });
-        archive.on('error', error => {
-            console.error('archive error:', error);
-            reject(error);
-        });
-        archive.pipe(outputStream);
-        if (appId) {
-            archive.directory(input, appId);
-        }
-        else {
-            archive.directory(input, './');
-        }
-        archive.finalize();
-    });
+    exports.genZip = genZip;
 });
-exports.genZip = genZip;