xhs-mp-compiler-cli 1.0.2 → 1.1.0-beta.0

package/dist/bin/xhs-mp-cli-build.js

@@ -16,14 +16,14 @@ commander.usage('[options]').option('-v1, --enableV1 <boolean>', 'package v1');
 commander.usage('[options]').option('-v2, --enableV2 <boolean>', 'package v2');
 commander.usage('[options]').option('-vdom, --enableVDom <boolean>', 'vdom 架构支持');
 commander.parse(process.argv);
-const mpDir = commander.opts().mpDir ? path_1.default.resolve(commander.opts().mpDir) : process.cwd();
+const projectPath = commander.opts().mpDir ? path_1.default.resolve(commander.opts().mpDir) : process.cwd();
 const platform = commander.opts().platform ? commander.opts().platform : 'xhs';
 const enableV1 = commander.opts().enableV1 === "true";
 const enableV2 = commander.opts().enableV2 === "true";
 const enableVDom = commander.opts().enableVDom === "true";
 const compressJs = commander.opts().compressJs === "true";
-const multiCompiler = (0, index_1.nodeStart)({
-    mpDir,
+const multiCompiler = (0, index_1.createCompiler)({
+    projectPath,
     action: 'build',
     platform,
     compressJs,

package/dist/bin/xhs-mp-cli-dev.js

@@ -1,35 +1,12 @@
 #!/usr/bin/env node
 "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);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const path_1 = __importDefault(require("path"));
-const index_1 = __importStar(require("../index"));
+const index_1 = require("../index");
 const commander = new commander_1.Command();
 commander.usage('[options]').option('-d, --mpDir <path>', 'set workdir [default: ./]');
 commander.usage('[options]').option('-p, --platform <string>', 'set platform [default: xhs]');
@@ -40,17 +17,17 @@ commander.usage('[options]').option('-v1, --enableV1 <boolean>', 'package v1');
 commander.usage('[options]').option('-v2, --enableV2 <boolean>', 'package v2');
 commander.usage('[options]').option('-vdom, --enableVDom <boolean>', 'vdom 架构支持');
 commander.parse(process.argv);
-const mpDir = commander.opts().mpDir ? path_1.default.resolve(commander.opts().mpDir) : process.cwd();
+const projectPath = commander.opts().mpDir ? path_1.default.resolve(commander.opts().mpDir) : process.cwd();
 const platform = commander.opts().platform ? commander.opts().platform : 'xhs';
-const port = commander.opts().port ? commander.opts().port : 1388;
+const devServerPort = commander.opts().port ? commander.opts().port : 1388;
 const out = commander.opts().out === "true";
 const enableV1 = commander.opts().enableV1 === "true";
 const enableV2 = commander.opts().enableV2 === "true";
 const enableVDom = commander.opts().enableVDom === "true";
 process.env.PRETTIER_XHSML = "true";
 if (out) {
-    const multiCompiler = (0, index_1.nodeStart)({
-        mpDir,
+    const multiCompiler = (0, index_1.createCompiler)({
+        projectPath,
         action: 'dev',
         platform,
         compressJs: false,
@@ -67,12 +44,13 @@ if (out) {
     });
 }
 else {
-    (0, index_1.default)({
-        mpDir,
+    (0, index_1.createCompiler)({
+        projectPath,
         action: 'dev',
+        enableDevServer: true,
         platform,
         compressJs: false,
-        port,
+        devServerPort,
         enableSourcemap: true,
         enableV1,
         enableV2,

package/dist/compiler.d.ts

@@ -0,0 +1,76 @@
+/// <reference types="node/child_process" />
+/// <reference types="node/stream" />
+/**
+ * 在子进程执行编译
+ */
+import { ChildProcess } from 'child_process';
+import { EventEmitter } from 'stream';
+type Platform = 'wx' | 'xhs';
+export interface ICompilerOption {
+    projectPath: string;
+    appMode: string;
+}
+export interface ICompilerArgs {
+    logger?: any;
+    type?: string;
+    inspectPort?: number;
+    maxSpaceSaze?: number;
+    nodeJsPath?: string;
+}
+export interface ForkWebpackOption {
+    platform: Platform;
+    extJsonPath: string;
+    distDir: string;
+    cacheDirectory: string | null;
+}
+export interface ICheckOptions {
+    compilePkgs?: string[];
+    compressJs: boolean;
+    enableV2?: boolean;
+    enableV1?: boolean;
+}
+declare abstract class AbstractCompiler extends EventEmitter {
+    protected inspectPort: any;
+    private _cp;
+    private compilerOpts;
+    private cpArgs;
+    private logger;
+    private _handlerMap;
+    constructor(opts: ICompilerOption, args?: ICompilerArgs);
+    get cp(): any;
+    protected createSp: (passData?: {}) => any;
+    protected create: (passData?: {}) => ChildProcess;
+    close(): void;
+    kill(): void;
+    private handleMessage;
+    call: (method: any, data: any) => Promise<unknown>;
+    send: (method: any, data: any) => void;
+}
+declare class MPPackDevCompiler extends AbstractCompiler {
+    private pending;
+    private pendingPkgs;
+    private readyPkgs;
+    private watching;
+    constructor(props: any, args: any);
+    reset(): void;
+    doCompilePkgs(opts: ICheckOptions): Promise<unknown>;
+    private compilePkgsAndWatch;
+    private addPkgsToWatch;
+    changeCompileOptions(options: any): void;
+    makePkgsReady(opts: ICheckOptions): Promise<void>;
+    reCompilePkgs(options: any): Promise<void>;
+}
+declare class WebPackDevCompiler extends AbstractCompiler {
+    private watching;
+    private pendingTask?;
+    constructor(props: any);
+    makePkgsReady(opts: any): Promise<unknown>;
+    reCompilePkgs(opts: any): Promise<void>;
+}
+declare class BuildCompiler extends AbstractCompiler {
+    cps: any;
+    constructor(props: any, args: any);
+    build(option: ICheckOptions): Promise<unknown>;
+}
+export declare function getProcessCompilerClass(compilerType: any): typeof MPPackDevCompiler | typeof WebPackDevCompiler | typeof BuildCompiler;
+export {};

package/dist/compiler.js

@@ -0,0 +1,361 @@
+"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.getProcessCompilerClass = void 0;
+/**
+ * 在子进程执行编译
+ */
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+const stream_1 = require("stream");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const constant_config_1 = require("./config/constant.config");
+const uuid = require('uuid');
+const isMac = process.platform === 'darwin';
+class AbstractCompiler extends stream_1.EventEmitter {
+    constructor(opts, args = {}) {
+        super();
+        this._handlerMap = {};
+        this.createSp = (passData = {}) => {
+            if (!this._cp) {
+                this._cp = this.create(Object.assign({}, passData));
+                this._cp.on('exit', code => {
+                    this._cp = null;
+                });
+                this._cp.on('message', this.handleMessage);
+            }
+            return this._cp;
+        };
+        this.create = (passData = {}) => {
+            var _a, _b;
+            const { type = 'keepalive', inspectPort = this.inspectPort, maxSpaceSaze = 12288, nodeJsPath, } = this.cpArgs;
+            // const presistent = type === 'keepalive'
+            const entry = (0, path_1.join)(__dirname, './compilerCP.js');
+            const execArgv = [`--max-old-space-size=${maxSpaceSaze}`, '--expose-gc'];
+            const customNodeJs = nodeJsPath && fs_extra_1.default.existsSync(nodeJsPath);
+            if (process.env.DEV_IDE_SP) {
+                execArgv.push(`--inspect=${inspectPort}`);
+            }
+            if (customNodeJs) {
+                try {
+                    fs_extra_1.default.chmodSync(nodeJsPath, 755);
+                }
+                catch (error) {
+                    // do something
+                }
+            }
+            const options = {
+                stdio: 'pipe',
+                execArgv,
+                // detached: presistent,
+                windowsHide: true,
+            };
+            if (customNodeJs) {
+                options.execPath = nodeJsPath;
+            }
+            const child = (0, child_process_1.fork)(entry, [JSON.stringify(passData)], options);
+            // if (presistent) {
+            //   child.unref()
+            // }
+            (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', msg => {
+                this.logger.debug('[compiler stdout]', msg.toString());
+            });
+            (_b = child.stderr) === null || _b === void 0 ? void 0 : _b.on('data', msg => {
+                this.logger.error('[compiler stderr]', msg.toString());
+            });
+            child.on('error', err => {
+                this.logger.error('sp error:', err);
+            });
+            child.on('exit', code => {
+                if (code !== 0 && code !== null) {
+                    this.logger.error('sp exit:', code);
+                    this.emit('unexpectedExit', code);
+                }
+            });
+            return child;
+        };
+        this.handleMessage = msg => {
+            var _a, _b, _c, _d;
+            let data = {};
+            try {
+                data = JSON.parse(`${msg}`);
+            }
+            catch (error) {
+                // do something
+            }
+            const { uuid, method, success, stats } = data;
+            if (method === 'callback') {
+                if (uuid && this._handlerMap[uuid]) {
+                    if (success) {
+                        (_b = (_a = this._handlerMap[uuid]).resolve) === null || _b === void 0 ? void 0 : _b.call(_a, data.data);
+                    }
+                    else {
+                        (_d = (_c = this._handlerMap[uuid]).reject) === null || _d === void 0 ? void 0 : _d.call(_c, stats);
+                    }
+                    delete this._handlerMap[uuid];
+                }
+                return;
+            }
+            this.emit(method, data);
+        };
+        this.call = (method, data) => new Promise((resolve, reject) => {
+            const id = uuid.v4();
+            const final = {
+                uuid: id,
+                method,
+                data: Object.assign(Object.assign({}, (this.compilerOpts || {})), data),
+            };
+            this._handlerMap[id] = {
+                resolve,
+                reject,
+            };
+            this.cp.send(JSON.stringify(final));
+        });
+        this.send = (method, data) => {
+            const final = {
+                method,
+                data: Object.assign(Object.assign({}, (this.compilerOpts || {})), data),
+            };
+            this.cp.send(JSON.stringify(final));
+        };
+        this.compilerOpts = opts;
+        this.cpArgs = args;
+        this.logger = args.logger || console;
+    }
+    get cp() {
+        return this.createSp();
+    }
+    close() {
+        if (this._cp) {
+            this._cp.send(JSON.stringify({ method: 'close' }));
+        }
+    }
+    kill() {
+        if (this._cp) {
+            this._cp.kill();
+            this._cp = null;
+        }
+    }
+}
+class MPPackDevCompiler extends AbstractCompiler {
+    constructor(props, args) {
+        super(props, args);
+        this.pending = false;
+        this.pendingPkgs = {};
+        this.readyPkgs = [];
+        this.watching = false;
+        this.inspectPort = 9227;
+        this.createSp();
+    }
+    reset() {
+        this.pendingPkgs = {};
+        this.readyPkgs = [];
+        this.watching = false;
+        this.pending = false;
+    }
+    doCompilePkgs(opts) {
+        // eslint-disable-next-line no-async-promise-executor
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            const { compilePkgs = [constant_config_1.MAIN_PKG_ROOT] } = opts;
+            const todoPkgs = [];
+            let allReady = true;
+            compilePkgs.forEach(pkg => {
+                var _a, _b;
+                if (this.readyPkgs.includes(pkg)) {
+                    return;
+                }
+                allReady = false;
+                if (this.pendingPkgs[pkg]) {
+                    (_a = this.pendingPkgs[pkg].resolve) === null || _a === void 0 ? void 0 : _a.push(resolve);
+                    (_b = this.pendingPkgs[pkg].reject) === null || _b === void 0 ? void 0 : _b.push(reject);
+                    return;
+                }
+                this.pendingPkgs[pkg] = {
+                    resolve: [resolve],
+                    reject: [reject],
+                };
+                todoPkgs.push(pkg);
+            });
+            if (allReady) {
+                return resolve(null);
+            }
+            if (!todoPkgs.length) {
+                return;
+            }
+            try {
+                if (!this.pending && !this.watching) {
+                    yield this.compilePkgsAndWatch(Object.assign({ compilePkgs: todoPkgs }, opts));
+                }
+                else {
+                    yield this.addPkgsToWatch(Object.assign({ compilePkgs }, opts));
+                }
+                todoPkgs.forEach(pkg => {
+                    var _a, _b;
+                    (_b = (_a = this.pendingPkgs[pkg].resolve) === null || _a === void 0 ? void 0 : _a.forEach) === null || _b === void 0 ? void 0 : _b.call(_a, fn => fn());
+                    delete this.pendingPkgs[pkg];
+                    this.readyPkgs.push(pkg);
+                });
+            }
+            catch (error) {
+                todoPkgs.forEach(pkg => {
+                    var _a, _b;
+                    (_b = (_a = this.pendingPkgs[pkg].reject) === null || _a === void 0 ? void 0 : _a.forEach) === null || _b === void 0 ? void 0 : _b.call(_a, fn => fn());
+                    delete this.pendingPkgs[pkg];
+                });
+            }
+        }));
+    }
+    compilePkgsAndWatch(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // if (this.pending || this.watching) {
+                //   return
+                // }
+                this.pending = true;
+                this.emit('buildStart');
+                yield this.call('runTask', Object.assign({ scene: 'watch', action: 'dev' }, opts));
+                this.watching = true;
+                this.emit('buildSuccess');
+            }
+            catch (error) {
+                this.watching = false;
+                this.emit('buildError', error);
+            }
+            finally {
+                this.pending = false;
+            }
+        });
+    }
+    addPkgsToWatch(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { compilePkgs = [] } = opts;
+            try {
+                this.pending = true;
+                this.emit('buildStart');
+                yield this.call('activatePkgs', { compilePkgs });
+                this.emit('buildSuccess');
+            }
+            catch (error) {
+                this.emit('buildError', error);
+            }
+            finally {
+                this.pending = false;
+            }
+        });
+    }
+    changeCompileOptions(options) {
+        this.call('changeCompileOptions', options);
+    }
+    makePkgsReady(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.doCompilePkgs(opts);
+        });
+    }
+    reCompilePkgs(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.readyPkgs = [];
+            this.changeCompileOptions(options);
+            if (!this.pending && !this.watching) {
+                this.pendingPkgs = {};
+            }
+            yield this.doCompilePkgs(options);
+        });
+    }
+}
+class WebPackDevCompiler extends AbstractCompiler {
+    constructor(props) {
+        super(props);
+        this.watching = false;
+        this.inspectPort = 9230;
+        this.createSp();
+    }
+    makePkgsReady(opts) {
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            if (this.watching) {
+                return resolve(null);
+            }
+            if (this.pendingTask) {
+                (_a = this.pendingTask.resolve) === null || _a === void 0 ? void 0 : _a.push(resolve);
+                (_b = this.pendingTask.reject) === null || _b === void 0 ? void 0 : _b.push(reject);
+                return;
+            }
+            this.pendingTask = {
+                resolve: [resolve],
+                reject: [reject]
+            };
+            try {
+                this.emit('buildStart');
+                yield this.call('runTask', Object.assign({ scene: 'watch', action: 'dev' }, opts));
+                this.watching = true;
+                (_c = this.pendingTask.resolve) === null || _c === void 0 ? void 0 : _c.forEach((fn) => fn());
+                this.emit('buildSuccess');
+            }
+            catch (error) {
+                this.watching = false;
+                (_d = this.pendingTask.reject) === null || _d === void 0 ? void 0 : _d.forEach((fn) => fn());
+                this.kill();
+                this.emit('buildError', error);
+            }
+            finally {
+                this.pendingTask = undefined;
+            }
+        }));
+    }
+    reCompilePkgs(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.watching) {
+                yield this.makePkgsReady(opts);
+                return;
+            }
+            try {
+                this.emit('buildStart');
+                yield this.call('runTask', Object.assign({ action: 'dev', scene: 'reWatch' }, opts));
+                this.emit('buildSuccess');
+            }
+            catch (error) {
+                this.emit('buildError', error);
+            }
+        });
+    }
+}
+class BuildCompiler extends AbstractCompiler {
+    constructor(props, args) {
+        super(props, args);
+        this.cps = [];
+        this.inspectPort = 9228;
+        this.createSp();
+    }
+    build(option) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const res = yield this.call('runTask', Object.assign({ action: 'build' }, option));
+                return res;
+            }
+            finally {
+                // 进程不退出，手动kill下
+                this.kill();
+            }
+        });
+    }
+}
+function getProcessCompilerClass(compilerType) {
+    const CompilerClass = compilerType === constant_config_1.COMPILER_TYPE.legacy_dev
+        ? WebPackDevCompiler
+        : compilerType === constant_config_1.COMPILER_TYPE.dev
+            ? MPPackDevCompiler
+            : BuildCompiler;
+    return CompilerClass;
+}
+exports.getProcessCompilerClass = getProcessCompilerClass;