xhs-mp-compiler-cli 2.0.4 → 2.0.5

package/dist/compilerManager.d.ts

@@ -0,0 +1,95 @@
+import { COMPILE_ENTRY } from './config/constant.config';
+import { Project } from 'xhs-mp-project';
+import EventEmitter from 'events';
+import { Logger } from 'xhs-mp-shared';
+import { prepareDevPool } from './compiler';
+export { COMPILE_ENTRY, prepareDevPool };
+interface ILibFeatures {
+    supportV2?: boolean;
+    supportVDom?: boolean;
+}
+export type IArchType = 'v0' | 'v1' | 'v2';
+export type IZipResult = {
+    type: IArchType;
+    zipPath: string;
+    zipSize: number;
+    root: string;
+    originSize: number;
+};
+export type ICompileOpts = {
+    logger?: any;
+    report?: (key: string, data?: any) => void;
+    compileDistDir?: string;
+    compileCacheDir?: string;
+    nodeJsPath?: string;
+    getLibFeatures?: () => Promise<ILibFeatures>;
+};
+export type ICompilerProps = {
+    projectPath?: string;
+    project?: Project;
+} & ICompileOpts;
+interface ICompileBaseConfig {
+    compressCss?: boolean;
+    compressJs?: boolean;
+    enableSourcemap?: boolean;
+    appendSourcemapComment?: boolean;
+    runInServiceSandbox?: boolean;
+    enableV2?: boolean;
+    enableV1?: boolean;
+    enableVDom?: boolean;
+}
+type IMakePkgsReadyConfig = ICompileBaseConfig & {
+    compilePkgs?: string[];
+};
+type ICompilePkgsConfig = ICompileBaseConfig & {
+    compilePkgs?: string[];
+};
+type ICompileProjectConfig = ICompileBaseConfig & {
+    entryType?: string;
+    mpUploadOptions?: ICompileAndZipOptions | false;
+};
+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 ProjectCompilerManager extends EventEmitter {
+    compilerProps: ICompilerProps;
+    project: Project;
+    compilerImplMap: {};
+    logger: Logger;
+    report?: (key: string, data?: any) => void;
+    constructor(props: ICompilerProps);
+    bindProject(props: any): void;
+    private getCompilerType;
+    getDistDir(entryType?: string): string;
+    removeDistDir(entryType?: string): void;
+    getCacheDir(entryType?: string): string;
+    removeCacheDir(entryType?: string): void;
+    removeAllCacheDir(): void;
+    private createCompiler;
+    private getCompiler;
+    getUsingPackageType(entryType?: string): Promise<{
+        enableV1: boolean;
+        enableV2: boolean;
+        enableVDom: boolean;
+    }>;
+    private initSimulatorCompiler;
+    private initBuildCompiler;
+    makePkgsReady(opts: IMakePkgsReadyConfig): Promise<void>;
+    reCompilePkgs(opts: ICompilePkgsConfig): Promise<void>;
+    compileProject(config: ICompileProjectConfig): Promise<void>;
+    compileAndZip(opts: ICompileAndZipOptions): Promise<IZipResult[]>;
+    closeCompiler(entryType?: string): void;
+    killCompiler(entryType?: string): void;
+    killAll(): void;
+    private zipWithFullPackage;
+    private zipWithSubPackage;
+}

package/dist/compilerManager.js

@@ -0,0 +1,590 @@
+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 };
+};
+(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", "./config/constant.config", "xhs-mp-project", "events", "fs-extra", "path", "./utils/utils", "./utils/project", "./config/dir.config", "./compiler", "./sharedFs"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ProjectCompilerManager = exports.prepareDevPool = exports.COMPILE_ENTRY = void 0;
+    const constant_config_1 = require("./config/constant.config");
+    Object.defineProperty(exports, "COMPILE_ENTRY", { enumerable: true, get: function () { return constant_config_1.COMPILE_ENTRY; } });
+    const xhs_mp_project_1 = require("xhs-mp-project");
+    const events_1 = __importDefault(require("events"));
+    const fs_extra_1 = __importDefault(require("fs-extra"));
+    const path_1 = __importDefault(require("path"));
+    const utils_1 = require("./utils/utils");
+    const project_1 = require("./utils/project");
+    const dir_config_1 = require("./config/dir.config");
+    const compiler_1 = require("./compiler");
+    Object.defineProperty(exports, "prepareDevPool", { enumerable: true, get: function () { return compiler_1.prepareDevPool; } });
+    const sharedFs_1 = __importDefault(require("./sharedFs"));
+    class ProjectCompilerManager extends events_1.default {
+        constructor(props) {
+            super();
+            this.compilerImplMap = {};
+            this.getCompiler = (entryType = constant_config_1.COMPILE_ENTRY.simulator) => {
+                if (!this.compilerImplMap[entryType]) {
+                    this.compilerImplMap[entryType] = this.createCompiler(entryType);
+                    if (entryType === constant_config_1.COMPILE_ENTRY.simulator) {
+                        this.initSimulatorCompiler(this.compilerImplMap[entryType]);
+                    }
+                    else {
+                        this.initBuildCompiler(this.compilerImplMap[entryType]);
+                    }
+                }
+                return this.compilerImplMap[entryType];
+            };
+            this.initSimulatorCompiler = compiler => {
+                compiler.on('buildStart', data => {
+                    this.emit('simulator-compile-start', data);
+                });
+                compiler.on('compileInfo', data => {
+                    this.emit('simulator-compile-info', data);
+                });
+                compiler.on('buildSuccess', data => {
+                    this.emit('simulator-compile-success', data);
+                });
+                compiler.on('buildError', data => {
+                    this.emit('simulator-compile-error', data);
+                });
+                compiler.on('compileFinishWhenFileChange', data => {
+                    this.emit('simulator-file-change-compile-finish', data);
+                });
+                compiler.on('compilePercent', data => {
+                    this.emit('simulator-compile-percent', data);
+                });
+                compiler.on('emitCompileStats', data => {
+                    this.emit('simulator-compile-stats', data);
+                });
+                compiler.on('unexpectedExit', data => {
+                    this.emit('simulator-compile-unexpectedExit', data);
+                });
+            };
+            this.initBuildCompiler = compiler => {
+                compiler.on('compilePercent', data => {
+                    this.emit('full-compile-percent', data);
+                });
+                compiler.on('compileInfo', data => {
+                    this.emit('full-compiler-info', data);
+                });
+                compiler.on('emitCompileStats', data => {
+                    this.emit('full-compile-stats', data);
+                });
+            };
+            const { logger, report, projectPath, project } = props;
+            this.logger = logger || console;
+            this.report = report;
+            this.compilerProps = props;
+            if (!project && !projectPath)
+                return;
+            this.project = (project ||
+                new xhs_mp_project_1.Project({
+                    projectPath: projectPath
+                }));
+        }
+        bindProject(props) {
+            const { projectPath, project } = props;
+            if (!project && !projectPath) {
+                throw new Error('project 和 projectPath 均为undefined');
+            }
+            this.project = (project ||
+                new xhs_mp_project_1.Project({
+                    projectPath: projectPath
+                }));
+        }
+        // 根据使用的场景或者配置，采用不同的compiler类型
+        getCompilerType(entryType = constant_config_1.COMPILE_ENTRY.simulator) {
+            const isGame = this.project.appMode === constant_config_1.MiniMode.minigame;
+            const settings = this.project.settings || {};
+            // 使用旧编译
+            if (isGame || !settings.useNewCompiler) {
+                return entryType === constant_config_1.COMPILE_ENTRY.simulator
+                    ? constant_config_1.COMPILER_TYPE.legacy_dev
+                    : constant_config_1.COMPILER_TYPE.legacy_build;
+            }
+            // 使用新编译
+            return entryType === constant_config_1.COMPILE_ENTRY.simulator
+                ? constant_config_1.COMPILER_TYPE.dev
+                : entryType === constant_config_1.COMPILE_ENTRY.upload
+                    ? constant_config_1.COMPILER_TYPE.legacy_build
+                    : constant_config_1.COMPILER_TYPE.build;
+        }
+        getDistDir(entryType = constant_config_1.COMPILE_ENTRY.simulator) {
+            const { compileDistDir = dir_config_1.mpCompileDirPath } = this.compilerProps;
+            const compilerType = this.getCompilerType(entryType);
+            const projectPath = this.project.projectPath;
+            const basename = path_1.default.basename(projectPath);
+            const hash = (0, utils_1.getMd5)(projectPath).slice(0, 8);
+            const distDir = path_1.default.join(path_1.default.resolve(compileDistDir, `${basename}_${hash}`), compilerType);
+            fs_extra_1.default.ensureDirSync(distDir);
+            return distDir;
+        }
+        removeDistDir(entryType = constant_config_1.COMPILE_ENTRY.simulator) {
+            try {
+                const distDir = this.getDistDir(entryType);
+                if (fs_extra_1.default.existsSync(distDir)) {
+                    fs_extra_1.default.removeSync(distDir);
+                }
+            }
+            catch (error) { }
+        }
+        getCacheDir(entryType = constant_config_1.COMPILE_ENTRY.simulator) {
+            const { compileCacheDir = dir_config_1.mpCompileCachePath } = this.compilerProps;
+            const projectPath = this.project.projectPath;
+            const compilerType = this.getCompilerType(entryType);
+            const basename = path_1.default.basename(projectPath);
+            const hash = (0, utils_1.getMd5)(projectPath).slice(0, 8);
+            const distDir = path_1.default.join(path_1.default.resolve(compileCacheDir, `${basename}_${hash}`), compilerType);
+            fs_extra_1.default.ensureDirSync(distDir);
+            return distDir;
+        }
+        removeCacheDir(entryType = constant_config_1.COMPILE_ENTRY.simulator) {
+            const cacheDir = this.getCacheDir(entryType);
+            if (fs_extra_1.default.existsSync(cacheDir)) {
+                fs_extra_1.default.removeSync(cacheDir);
+            }
+        }
+        removeAllCacheDir() {
+            // 移除编译缓存
+            const cacheDir = this.getCacheDir();
+            const parenCacheDir = path_1.default.dirname(cacheDir);
+            if (fs_extra_1.default.existsSync(parenCacheDir)) {
+                fs_extra_1.default.removeSync(parenCacheDir);
+            }
+            // 移除编译产物
+            const distDir = this.getDistDir();
+            const parentDistDir = path_1.default.dirname(distDir);
+            if (fs_extra_1.default.existsSync(parentDistDir)) {
+                fs_extra_1.default.removeSync(parentDistDir);
+            }
+        }
+        createCompiler(entryType = constant_config_1.COMPILE_ENTRY.simulator) {
+            const { nodeJsPath } = this.compilerProps;
+            const distDir = this.getDistDir(entryType);
+            const cacheDir = this.getCacheDir(entryType);
+            const compilerType = this.getCompilerType(entryType);
+            const packMode = compilerType === constant_config_1.COMPILER_TYPE.legacy_dev || compilerType === constant_config_1.COMPILER_TYPE.legacy_build
+                ? 'webpack'
+                : 'mp-pack';
+            const options = {
+                packMode,
+                projectPath: this.project.projectPath,
+                appMode: this.project.appMode,
+                extJsonPath: this.project.extJsonDir,
+                platform: 'xhs',
+                distDir,
+                enablePersistCache: entryType !== constant_config_1.COMPILE_ENTRY.upload,
+                cacheDirectory: cacheDir
+            };
+            this.removeDistDir(entryType);
+            // this.removeCacheDir(entryType)
+            const CompilerClass = (0, compiler_1.getProjectCompilerClass)(compilerType);
+            const compiler = new CompilerClass(options, {
+                workerType: entryType === constant_config_1.COMPILE_ENTRY.simulator ? 'web' : 'process',
+                nodeJsPath
+            });
+            return compiler;
+        }
+        // 使用的编译目标包类型
+        getUsingPackageType() {
+            return __awaiter(this, arguments, void 0, function* (entryType = constant_config_1.COMPILE_ENTRY.simulator) {
+                let enableV1 = false;
+                let enableV2 = true;
+                let enableVDom = false;
+                const settings = this.project.settings || {};
+                const isUpload = entryType === constant_config_1.COMPILE_ENTRY.upload;
+                if (this.project.appMode === constant_config_1.MiniMode.minigame) {
+                    enableV1 = true;
+                    enableV2 = false;
+                    enableVDom = false;
+                }
+                else if (entryType === constant_config_1.COMPILE_ENTRY.simulator) {
+                    if (this.compilerProps.getLibFeatures) {
+                        const libFeatures = yield this.compilerProps.getLibFeatures();
+                        enableV2 = libFeatures.supportV2 && settings.enableV2;
+                        enableVDom = !enableV2 && libFeatures.supportVDom && settings.enableVDom;
+                    }
+                    else {
+                        enableV2 = settings.enableV2;
+                        enableVDom = !enableV2 && settings.enableVDom;
+                    }
+                    // enableVDom = !enableV2 && settings.enableVDom
+                    enableV1 = !enableV2;
+                }
+                else {
+                    // 上传模式下按照勾选开启
+                    enableVDom = settings.enableVDom;
+                    enableV2 = settings.enableV2;
+                    enableV1 = true;
+                }
+                return {
+                    enableV1,
+                    enableV2,
+                    enableVDom
+                };
+            });
+        }
+        makePkgsReady(opts) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                const { compilePkgs } = opts;
+                const entryType = constant_config_1.COMPILE_ENTRY.simulator;
+                const defaultOptions = yield this.getUsingPackageType(entryType);
+                const compiler = this.getCompiler(entryType);
+                const startTime = Date.now();
+                // 如果要编主包，看看入口页是否普通分包,也加进去
+                if (compilePkgs === null || compilePkgs === void 0 ? void 0 : compilePkgs.includes(constant_config_1.MAIN_PKG_ROOT)) {
+                    const customEntry = this.project.customEntry;
+                    const subPackages = this.project.getSubPackages();
+                    const subPkg = subPackages.find((item) => customEntry.startsWith(`${item.root}/`));
+                    if (subPkg && !subPkg.independent) {
+                        compilePkgs.push(subPkg.root);
+                    }
+                }
+                const config = Object.assign(Object.assign({ compilePkgs, compressCss: false, compressJs: true, enableSourcemap: true, appendSourcemapComment: true, runInServiceSandbox: true, devWriteToDisk: true }, defaultOptions), opts);
+                console.log('[compiler]makePkgsReady', config);
+                try {
+                    this.emit('makePkgsReady-start', { config });
+                    yield compiler.makePkgsReady(config);
+                    this.emit('makePkgsReady-end', { config });
+                    (_a = this.report) === null || _a === void 0 ? void 0 : _a.call(this, 'compile', {
+                        result: 'success',
+                        entryType,
+                        config: JSON.stringify(config),
+                        duration: Date.now() - startTime
+                    });
+                }
+                catch (error) {
+                    this.emit('makePkgsReady-error', { config, error });
+                    (_b = this.report) === null || _b === void 0 ? void 0 : _b.call(this, 'compile', {
+                        result: 'fail',
+                        entryType,
+                        config: JSON.stringify(config),
+                        reason: error === null || error === void 0 ? void 0 : error.message
+                    });
+                    throw error;
+                }
+            });
+        }
+        reCompilePkgs(opts) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a, _b, _c;
+                const { compilePkgs } = opts;
+                const entryType = constant_config_1.COMPILE_ENTRY.simulator;
+                const compiler = this.getCompiler(entryType);
+                const defaultOptions = yield this.getUsingPackageType(entryType);
+                const startTime = Date.now();
+                const config = Object.assign(Object.assign({ compilePkgs, compressCss: false, compressJs: true, enableSourcemap: true, appendSourcemapComment: true, runInServiceSandbox: true, devWriteToDisk: true }, defaultOptions), opts);
+                console.log('[compiler]reCompilePkgs', config);
+                try {
+                    this.emit('recompile-pkgs-start', { config });
+                    (_a = (0, sharedFs_1.default)(true)) === null || _a === void 0 ? void 0 : _a.clear();
+                    yield compiler.reCompilePkgs(config);
+                    this.emit('recompile-pkgs-end', { config });
+                    (_b = this.report) === null || _b === void 0 ? void 0 : _b.call(this, 'compile', {
+                        result: 'success',
+                        entryType,
+                        config: JSON.stringify(config),
+                        duration: Date.now() - startTime
+                    });
+                }
+                catch (error) {
+                    this.emit('recompile-pkgs-error', { config, error });
+                    (_c = this.report) === null || _c === void 0 ? void 0 : _c.call(this, 'compile', {
+                        result: 'fail',
+                        entryType,
+                        config: JSON.stringify(config),
+                        reason: error.message
+                    });
+                    throw error;
+                }
+            });
+        }
+        compileProject(config) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a, _b, _c, _d, _e;
+                const { entryType } = config;
+                try {
+                    this.emit('compile-project-start');
+                    const startTime = Date.now();
+                    const compiler = this.getCompiler(entryType);
+                    this.removeDistDir(entryType);
+                    (_a = (0, sharedFs_1.default)(true)) === null || _a === void 0 ? void 0 : _a.clear();
+                    (_b = this.logger) === null || _b === void 0 ? void 0 : _b.log('Compile project...');
+                    yield compiler.build(config);
+                    (_c = this.logger) === null || _c === void 0 ? void 0 : _c.log('Compile project done...');
+                    this.emit('compile-project-end');
+                    (_d = this.report) === null || _d === void 0 ? void 0 : _d.call(this, 'compile', {
+                        result: 'success',
+                        entryType,
+                        config: JSON.stringify(config),
+                        duration: Date.now() - startTime
+                    });
+                }
+                catch (stats) {
+                    let errors = [];
+                    if (stats.errors) {
+                        errors = stats.errors;
+                    }
+                    else if (stats instanceof Error) {
+                        errors = [stats.message];
+                    }
+                    this.emit('compile-project-error', { config, errors });
+                    const error = new Error(errors.join('\n\n'));
+                    (_e = this.report) === null || _e === void 0 ? void 0 : _e.call(this, 'compile', {
+                        result: 'fail',
+                        entryType,
+                        config: JSON.stringify(config),
+                        reason: error.message
+                    });
+                    throw error;
+                }
+            });
+        }
+        compileAndZip(opts) {
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const { can_upload_ext_json, entryType } = opts;
+                try {
+                    const appJsonContent = this.project.appJsonContent;
+                    const settings = this.project.settings || {};
+                    let subPackages = appJsonContent.subPackages || appJsonContent.subpackages || [];
+                    const formatGameAppJSON = this.project.formatGameAppJSON;
+                    subPackages =
+                        this.project.appMode === constant_config_1.MiniMode.miniprogram
+                            ? subPackages
+                            : formatGameAppJSON(subPackages);
+                    const { enableV1, enableV2, enableVDom } = yield this.getUsingPackageType(entryType);
+                    let compressJs = false;
+                    let compressCss = false;
+                    let enableSourcemap = true;
+                    let appendSourcemapComment = true;
+                    let runInServiceSandbox = false;
+                    if (entryType === constant_config_1.COMPILE_ENTRY.preview) {
+                        compressCss = true;
+                        compressJs = true;
+                        enableSourcemap = false;
+                        appendSourcemapComment = false;
+                    }
+                    else if (entryType === constant_config_1.COMPILE_ENTRY.upload) {
+                        compressCss = true;
+                        compressJs = true;
+                        appendSourcemapComment = false;
+                    }
+                    else {
+                        compressCss = false;
+                        compressJs = (_a = settings.minified) !== null && _a !== void 0 ? _a : false;
+                        runInServiceSandbox = true;
+                    }
+                    const buildConfig = Object.assign({ entryType,
+                        compressCss,
+                        compressJs,
+                        enableSourcemap,
+                        appendSourcemapComment,
+                        runInServiceSandbox,
+                        enableV1,
+                        enableV2,
+                        enableVDom, mpUploadOptions: this.project.appMode === constant_config_1.MiniMode.miniprogram && opts }, opts);
+                    // 编译
+                    this.emit('compile-and-zip-status', { status: 'build-start' });
+                    yield this.compileProject(buildConfig);
+                    this.emit('compile-and-zip-status', { status: 'build-done' });
+                    // 生成zip
+                    this.emit('compile-and-zip-status', { status: 'zip-start' });
+                    let entryZips = [];
+                    if (entryType === constant_config_1.COMPILE_ENTRY.preview) {
+                        entryZips = [
+                            this.zipWithFullPackage(opts, subPackages, 'v0'),
+                            this.zipWithSubPackage(opts, subPackages, 'v1'),
+                            // 小程序模式有v2包
+                            buildConfig.enableV2 && this.zipWithSubPackage(opts, subPackages, 'v2')
+                        ];
+                    }
+                    else if (entryType === constant_config_1.COMPILE_ENTRY.upload) {
+                        entryZips = [
+                            this.zipWithFullPackage(opts, subPackages, 'v0', true),
+                            this.zipWithSubPackage(opts, subPackages, 'v1', true),
+                            // 小程序模式有v2包
+                            enableV2 && this.zipWithSubPackage(opts, subPackages, 'v2', true)
+                        ];
+                    }
+                    else {
+                        // 真机调试
+                        entryZips = [this.zipWithSubPackage(opts, subPackages, enableV2 ? 'v2' : 'v1')];
+                    }
+                    const zipTask = yield Promise.all(entryZips.filter(Boolean));
+                    const zipResult = zipTask.flat(2);
+                    this.emit('compile-and-zip-status', { status: 'zip-done' });
+                    resolve(zipResult);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            }));
+        }
+        closeCompiler(entryType = constant_config_1.COMPILE_ENTRY.simulator) {
+            const compiler = this.compilerImplMap[entryType];
+            if (compiler) {
+                compiler.close();
+            }
+        }
+        killCompiler(entryType = constant_config_1.COMPILE_ENTRY.simulator) {
+            const compiler = this.compilerImplMap[entryType];
+            if (!compiler) {
+                return;
+            }
+            compiler.kill();
+            delete this.compilerImplMap[entryType];
+        }
+        killAll() {
+            Object.values(this.compilerImplMap).forEach((compiler) => {
+                compiler.kill();
+            });
+            this.compilerImplMap = {};
+        }
+        /* 使用v0的入口，zip整包 */
+        zipWithFullPackage(opts_1) {
+            return __awaiter(this, arguments, void 0, function* (opts, subPackages = [], type, excludeSourcemap) {
+                const { upload_app_id, can_upload_ext_json, pkgInfo, entryType } = opts;
+                const buildDir = this.getDistDir(entryType);
+                const appendFile = [];
+                const appendBuffer = [];
+                appendFile.push(this.project.projectJsonPath); // zip添加project.config.json
+                /* 是否需要上传ext.json */
+                if (can_upload_ext_json && fs_extra_1.default.existsSync(this.project.extJsonPath)) {
+                    appendFile.push(this.project.extJsonPath);
+                }
+                if (pkgInfo) {
+                    /* 是否需要额外添加pkgInfo.json信息 */
+                    const content = { version: pkgInfo.version };
+                    const contentStr = JSON.stringify(content);
+                    appendBuffer.push({
+                        name: 'pkgInfo.json',
+                        buffer: Buffer.from(contentStr, 'utf-8')
+                    });
+                }
+                let ignore = [];
+                if (excludeSourcemap) {
+                    ignore = ['**/*.map'];
+                }
+                const tasks = [];
+                const baseZipConfig = {
+                    inputDir: path_1.default.resolve(buildDir, !subPackages.length ? 'v1' : 'v0' // 如果没有开启分包，则把v1包当作v0包
+                    ), // 输入的路径
+                    type,
+                    prefix: upload_app_id,
+                    meta: {
+                        root: ''
+                    }
+                };
+                tasks.push((0, project_1.zipFactory)(Object.assign(Object.assign({}, baseZipConfig), { pattern: '**/*', ignore,
+                    appendFile,
+                    appendBuffer, outputDir: path_1.default.resolve(buildDir, `${type}-full-pack.zip`) // 输出的路径
+                 })));
+                if (excludeSourcemap) {
+                    tasks.push((0, project_1.zipFactory)(Object.assign(Object.assign({}, baseZipConfig), { pattern: '**/*.map', ignore: [], appendFile: [], appendBuffer: [], outputDir: path_1.default.resolve(buildDir, `${type}-full-pack-sourcemap.zip`) // 输出的路径
+                     })));
+                }
+                return Promise.all(tasks);
+            });
+        }
+        /* 使用v1的入口。zip主包和分包 */
+        zipWithSubPackage(opts, subPackages, type, excludeSourcemap) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const projectConfig = this.project;
+                const { can_upload_ext_json, pkgInfo, entryType } = opts;
+                const isRemoteDebug = entryType === constant_config_1.COMPILE_ENTRY.remotedebug;
+                const appendFile = []; // 额外的文件
+                const appendBuffer = [];
+                appendFile.push(projectConfig.projectJsonPath); // zip添加project.config.json
+                const buildDir = this.getDistDir(entryType);
+                const mainEntry = path_1.default.resolve(buildDir, type);
+                // 主包里需要忽略分包的路径
+                const mainIgnore = (subPackages || []).map((item) => item.root.endsWith('/') ? `${item.root}**` : `${item.root}/**`);
+                const subIgnore = [];
+                if (excludeSourcemap) {
+                    mainIgnore.push('**/*.map');
+                    subIgnore.push('**/*.map');
+                }
+                /* 是否需要上传ext.json */
+                if (can_upload_ext_json && fs_extra_1.default.existsSync(projectConfig.extJsonPath)) {
+                    appendFile.push(projectConfig.extJsonPath);
+                }
+                if (pkgInfo) {
+                    /* 是否需要额外添加pkgInfo.json信息 */
+                    const content = { version: pkgInfo.version };
+                    const contentStr = JSON.stringify(content);
+                    appendBuffer.push({
+                        name: 'pkgInfo.json',
+                        buffer: Buffer.from(contentStr, 'utf-8')
+                    });
+                }
+                const tasks = [];
+                // // 主包
+                tasks.push((0, project_1.zipFactory)({
+                    inputDir: mainEntry, // 输入的路径
+                    type,
+                    prefix: '',
+                    meta: {
+                        root: '/'
+                    },
+                    pattern: '**/*',
+                    ignore: mainIgnore,
+                    appendFile,
+                    appendBuffer,
+                    outputDir: path_1.default.resolve(buildDir, `${type}-main-pack.zip`) // 输出的路径
+                }));
+                (subPackages || []).forEach((item, index) => {
+                    const pkgRoot = item.root.replace(/\//g, constant_config_1.PKG_ROOT_SEP);
+                    tasks.push((0, project_1.zipFactory)({
+                        inputDir: path_1.default.resolve(buildDir, type, item.root),
+                        prefix: `${item.root}`,
+                        appendFile: [],
+                        appendBuffer: [],
+                        pattern: '**/*',
+                        ignore: subIgnore,
+                        type,
+                        meta: {
+                            root: item.root
+                        },
+                        outputDir: path_1.default.resolve(buildDir, `${type}-sub-pack-${isRemoteDebug ? pkgRoot : index}.zip`)
+                    }));
+                });
+                // sourcemap
+                if (excludeSourcemap) {
+                    tasks.push((0, project_1.zipFactory)({
+                        inputDir: mainEntry, // 输入的路径
+                        pattern: '**/*.map',
+                        ignore: [],
+                        appendFile: [],
+                        appendBuffer: [],
+                        type,
+                        prefix: '',
+                        meta: {
+                            root: '/'
+                        },
+                        outputDir: path_1.default.resolve(buildDir, `${type}-pack-sourcemap.zip`) // 输出的路径
+                    }));
+                }
+                return Promise.all(tasks);
+            });
+        }
+    }
+    exports.ProjectCompilerManager = ProjectCompilerManager;
+});