xhs-mp-compiler-cli 1.1.3 → 1.1.4

package/dist/compilerCP.js

@@ -0,0 +1,175 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const packs_1 = require("./packs");
+let globalConfig = JSON.parse(process.argv[2]);
+let hadWatchBuilt = false;
+let projectCompiler;
+/* 发送消息给父进程 */
+const sendToMaster = (method, data = {}) => {
+    var _a;
+    (_a = process.send) === null || _a === void 0 ? void 0 : _a.call(process, JSON.stringify(Object.assign({ method }, data)));
+};
+const tryGC = () => {
+    if (global.gc) {
+        global.gc();
+    }
+};
+function formatWebpackMessages(err, stats) {
+    if (err) {
+        return { errors: [err.message], warnings: [] };
+    }
+    const json = stats.toJson({ warnings: true, errors: true, all: false });
+    const formattedErrors = json.errors.map(item => item.message);
+    const formattedWarnings = json.warnings.map(item => item.message);
+    const result = { errors: formattedErrors, warnings: formattedWarnings };
+    return result;
+}
+const handlers = {
+    runWatch: (msg) => __awaiter(void 0, void 0, void 0, function* () {
+        const { uuid, data } = msg;
+        if (!projectCompiler) {
+            projectCompiler = (0, packs_1.createCompiler)(data);
+        }
+        sendToMaster('run watch start');
+        const { err, stats } = (yield projectCompiler.watch({
+            scene: data.scene
+        }, (err, stats) => {
+            var _a;
+            console.log('file change...');
+            // 修改文件时构建
+            const hasError = err || ((_a = stats === null || stats === void 0 ? void 0 : stats.hasErrors) === null || _a === void 0 ? void 0 : _a.call(stats));
+            if (hasError) {
+                sendToMaster('emitCompileStats', {
+                    stats: formatWebpackMessages(err, stats)
+                });
+                return;
+            }
+            sendToMaster('compileFinishWhenFileChange');
+        }));
+        console.log('it is watching...');
+        const hasError = err || stats.hasErrors();
+        if (hasError) {
+            sendToMaster('callback', {
+                uuid,
+                success: false,
+                stats: formatWebpackMessages(err, stats)
+            });
+        }
+        else {
+            hadWatchBuilt = true;
+            sendToMaster('callback', {
+                uuid,
+                success: true
+            });
+        }
+    }),
+    changeCompileOptions(msg) {
+        const { data } = msg;
+        projectCompiler === null || projectCompiler === void 0 ? void 0 : projectCompiler.changeCompileOptions(data);
+    },
+    activatePkgs: (msg) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const { uuid, data: { compilePkgs } } = msg;
+        console.log('run activate start', compilePkgs);
+        const { err, stats } = (yield ((_b = (_a = projectCompiler).activatePkgs) === null || _b === void 0 ? void 0 : _b.call(_a, compilePkgs)));
+        console.log('run activate finish', err, stats);
+        const hasError = err || ((_c = stats === null || stats === void 0 ? void 0 : stats.hasErrors) === null || _c === void 0 ? void 0 : _c.call(stats));
+        if (hasError) {
+            sendToMaster('callback', {
+                uuid,
+                success: false,
+                stats: formatWebpackMessages(err, stats)
+            });
+        }
+        else {
+            hadWatchBuilt = true;
+            sendToMaster('callback', {
+                uuid,
+                success: true
+            });
+        }
+    }),
+    runBuild: msg => {
+        console.log('sp run build', msg);
+        const { uuid, data } = msg;
+        if (!projectCompiler) {
+            projectCompiler = (0, packs_1.createCompiler)(data);
+        }
+        projectCompiler.on('progress', progress => {
+            sendToMaster('compilePercent', {
+                percentage: progress
+            });
+        });
+        projectCompiler.build((err, stats) => {
+            var _a;
+            const hasError = err || ((_a = stats === null || stats === void 0 ? void 0 : stats.hasErrors) === null || _a === void 0 ? void 0 : _a.call(stats));
+            console.log('sp run build finish', stats);
+            if (hasError) {
+                const statsInfo = formatWebpackMessages(err, stats);
+                sendToMaster('callback', {
+                    uuid,
+                    success: false,
+                    stats: statsInfo
+                });
+                return;
+            }
+            sendToMaster('callback', {
+                uuid,
+                success: true
+            });
+            tryGC();
+        });
+    },
+    runTask: (msg) => {
+        if (msg) {
+            globalConfig = Object.assign(Object.assign({}, globalConfig), msg);
+        }
+        const { uuid, data } = globalConfig;
+        if (data.action === 'dev') {
+            handlers.runWatch({ uuid, data });
+        }
+        else {
+            handlers.runBuild({ uuid, data });
+        }
+    },
+    close() {
+        var _a;
+        console.log('close');
+        (_a = projectCompiler === null || projectCompiler === void 0 ? void 0 : projectCompiler.close) === null || _a === void 0 ? void 0 : _a.call(projectCompiler, () => { });
+        projectCompiler = null;
+    }
+};
+process.on('message', (message) => {
+    let objData = {};
+    try {
+        objData = JSON.parse(message);
+    }
+    catch (error) {
+        // do something
+    }
+    const { uuid, method, data = {} } = objData;
+    if (!handlers[method]) {
+        return;
+    }
+    handlers[method](objData);
+});
+process.on('uncaughtException', error => {
+    console.error(error);
+    sendToMaster('emitCompileStats', {
+        stats: {
+            errors: [error.message]
+        }
+    });
+});
+process.on('disconnect', () => {
+    process.exit(-1);
+});

package/dist/config/constant.config.d.ts

@@ -0,0 +1,27 @@
+export declare const MAIN_PKG_ROOT = "xhs-main";
+export declare const COMPILER_TYPE: {
+    dev: string;
+    build: string;
+    legacy_dev: string;
+    legacy_build: string;
+};
+export declare const COMPILE_TYPE: {
+    mp: string;
+    component: string;
+    service: string;
+    render: string;
+};
+export declare const COMPILE_ENTRY: {
+    simulator: string;
+    preview: string;
+    remotedebug: string;
+    upload: string;
+};
+export declare const MiniMode: {
+    miniprogram: string;
+    minigame: string;
+};
+export declare const PKG_ROOT_SEP = "_XHSPKG_";
+export declare const COMPILE_FULL_PKG = "xhs-full";
+export declare const COMPILE_MAIN_PKG = "xhs-main";
+export declare const COMPILE_SUB_PKG = "xhs-sub";

package/dist/config/constant.config.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMPILE_SUB_PKG = exports.COMPILE_MAIN_PKG = exports.COMPILE_FULL_PKG = exports.PKG_ROOT_SEP = exports.MiniMode = exports.COMPILE_ENTRY = exports.COMPILE_TYPE = exports.COMPILER_TYPE = exports.MAIN_PKG_ROOT = void 0;
+exports.MAIN_PKG_ROOT = 'xhs-main';
+exports.COMPILER_TYPE = {
+    dev: 'dev',
+    build: 'build',
+    legacy_dev: 'legacy_dev',
+    legacy_build: 'legacy_build'
+};
+exports.COMPILE_TYPE = {
+    mp: 'mp',
+    component: 'component',
+    service: 'service',
+    render: 'render'
+};
+exports.COMPILE_ENTRY = {
+    simulator: 'simulator',
+    preview: 'preview',
+    remotedebug: 'remotedebug',
+    upload: 'upload'
+};
+exports.MiniMode = {
+    miniprogram: 'miniprogram',
+    minigame: 'minigame'
+};
+exports.PKG_ROOT_SEP = '_XHSPKG_';
+exports.COMPILE_FULL_PKG = 'xhs-full';
+exports.COMPILE_MAIN_PKG = 'xhs-main';
+exports.COMPILE_SUB_PKG = 'xhs-sub';

package/dist/config/dir.config.d.ts

@@ -0,0 +1,3 @@
+export declare const baseDirPath: any;
+export declare const mpCompileDirPath: any;
+export declare const mpCompileCachePath: any;

package/dist/config/dir.config.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mpCompileCachePath = exports.mpCompileDirPath = exports.baseDirPath = void 0;
+const utils_1 = require("../utils/utils");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+exports.baseDirPath = (0, utils_1.normalizePath)(path_1.default.join(os_1.default.tmpdir(), '@xhs-toolkit'));
+fs_extra_1.default.ensureDirSync(exports.baseDirPath);
+exports.mpCompileDirPath = (0, utils_1.normalizePath)(path_1.default.join(exports.baseDirPath, 'xhs-mp-baba'));
+fs_extra_1.default.ensureDirSync(exports.mpCompileDirPath);
+exports.mpCompileCachePath = (0, utils_1.normalizePath)(path_1.default.join(exports.baseDirPath, 'xhs-compile-cache'));
+fs_extra_1.default.ensureDirSync(exports.mpCompileCachePath);

package/dist/index.d.ts

@@ -0,0 +1,84 @@
+/// <reference types="node/events" />
+import { COMPILE_ENTRY } from './config/constant.config';
+import { Project } from 'xhs-mp-project';
+import EventEmitter from 'events';
+import { Logger } from 'xhs-mp-utils';
+import { getProcessCompilerClass } from './compiler';
+interface ILibFeatures {
+    supportV2?: boolean;
+    supportVdom?: boolean;
+}
+export { COMPILE_ENTRY, getProcessCompilerClass };
+export type ICompileOpts = {
+    logger?: any;
+    compileDir?: string;
+    nodeJsPath?: string;
+    mpDevJsonPath?: string;
+    libFeatures?: ILibFeatures;
+};
+export type ICompilerProps = ({
+    projectPath: string;
+} | {
+    project: Project;
+}) & ICompileOpts;
+interface ICompileBaseConfig {
+    compressJs: boolean;
+    enableSourcemap: boolean;
+    enableV2: boolean;
+    enableV1: boolean;
+    enableVDom: boolean;
+}
+type IMakePkgsReadyConfig = ICompileBaseConfig & {
+    compilePkgs: any;
+};
+type ICompilePkgsConfig = ICompileBaseConfig & {
+    compilePkgs: any;
+};
+type ICompileBuildConfig = ICompileBaseConfig & {
+    entryType: string;
+};
+export interface ICompileAndZipOptions {
+    entryType: string;
+    can_upload_ext_json?: boolean;
+    upload_app_id?: string;
+    pkgInfo?: {
+        version: string;
+    };
+}
+export interface ISubPackages {
+    root: string;
+    pages: string;
+}
+export declare class Compiler extends EventEmitter {
+    projectPath: string;
+    compilerProps: ICompilerProps;
+    project: Project;
+    compilerImplMap: {};
+    logger: Logger;
+    constructor(props: ICompilerProps);
+    createProject(props: any): any;
+    private getCompilerDir;
+    private initSimulatorCompiler;
+    private initBuildCompiler;
+    getUsingPackageType(entryType?: string): Promise<{
+        enableV1: boolean;
+        enableV2: boolean;
+        enableVDom: boolean;
+    }>;
+    private getCompilerType;
+    getDistDir(entryType?: string): string;
+    removeDistDir(entryType?: string): void;
+    getCacheDir(entryType?: string): string;
+    removeCacheDir(entryType?: string): void;
+    private createCompilerImpl;
+    private getComilerImpl;
+    makePkgsReady(config: IMakePkgsReadyConfig): Promise<void>;
+    reCompilePkgs(config: ICompilePkgsConfig): Promise<void>;
+    compileProject(config: ICompileBuildConfig): Promise<void>;
+    compileAndZip(opts: ICompileAndZipOptions): Promise<any>;
+    private zipWithFullPackageWithAppId;
+    private zipWithFullPackage;
+    private zipWithSubPackage;
+    close(entryType?: string): void;
+    kill(entryType?: string): void;
+}