xhs-mp-compiler-cli 1.1.3 → 1.1.5

package/dist/index.js

@@ -0,0 +1,454 @@
+"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.Compiler = exports.getProcessCompilerClass = 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 zip_1 = require("./utils/zip");
+const project_1 = require("./utils/project");
+const dir_config_1 = require("./config/dir.config");
+const compiler_1 = require("./compiler");
+Object.defineProperty(exports, "getProcessCompilerClass", { enumerable: true, get: function () { return compiler_1.getProcessCompilerClass; } });
+class Compiler extends events_1.default {
+    constructor(props) {
+        super();
+        this.compilerImplMap = {};
+        this.initSimulatorCompiler = compiler => {
+            compiler.on('buildStart', data => {
+                this.emit('buildStart', data);
+            });
+            compiler.on('buildSuccess', data => {
+                this.emit('buildSuccess', data);
+            });
+            compiler.on('buildError', data => {
+                this.emit('buildError', data);
+            });
+            compiler.on('compileFinishWhenFileChange', data => {
+                this.emit('compileFinishWhenFileChange', data);
+            });
+            compiler.on('emitCompileStats', data => {
+                this.emit('emitCompileStats', data);
+            });
+            compiler.on('unexpectedExit', data => {
+                this.emit('unexpectedExit', data);
+            });
+        };
+        this.initBuildCompiler = compiler => {
+            compiler.on('compilePercent', data => {
+                this.emit('compilePercent', data);
+            });
+            compiler.on('emitCompileStats', data => {
+                this.emit('emitCompileStats', data);
+            });
+        };
+        this.getComilerImpl = (entryType = constant_config_1.COMPILE_ENTRY.simulator) => {
+            const compilerType = this.getCompilerType(entryType);
+            if (!this.compilerImplMap[compilerType]) {
+                this.compilerImplMap[compilerType] = this.createCompilerImpl(entryType);
+                if (entryType === constant_config_1.COMPILE_ENTRY.simulator) {
+                    this.initSimulatorCompiler(this.compilerImplMap[compilerType]);
+                }
+                else {
+                    this.initBuildCompiler(this.compilerImplMap[compilerType]);
+                }
+            }
+            return this.compilerImplMap[compilerType];
+        };
+        const { logger } = props;
+        this.logger = logger || console;
+        this.compilerProps = props;
+        this.project = this.createProject(props);
+        this.projectPath = this.project.projectPath;
+    }
+    createProject(props) {
+        const { projectPath, project } = props;
+        return (project ||
+            new xhs_mp_project_1.Project({
+                projectPath
+            }));
+    }
+    getCompilerDir() {
+        let compileDirPath;
+        let compileCachePath;
+        const { compileDir } = this.compilerProps;
+        if (compileDir) {
+            compileDirPath = path_1.default.join(compileDir, 'xhs-mp-baba');
+            compileCachePath = path_1.default.join(compileDir, 'xhs-compile-cache');
+        }
+        else {
+            compileDirPath = dir_config_1.mpCompileDirPath;
+            compileCachePath = dir_config_1.mpCompileCachePath;
+        }
+        return {
+            mpCompileDirPath: compileDirPath,
+            mpCompileCachePath: compileCachePath
+        };
+    }
+    // 使用的编译目标包类型
+    getUsingPackageType() {
+        return __awaiter(this, arguments, void 0, function* (entryType = constant_config_1.COMPILE_ENTRY.simulator) {
+            var _a, _b;
+            const { libFeatures } = this.compilerProps;
+            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) {
+                const supportV2 = (_a = libFeatures === null || libFeatures === void 0 ? void 0 : libFeatures.supportV2) !== null && _a !== void 0 ? _a : true;
+                const supportVDom = (_b = libFeatures === null || libFeatures === void 0 ? void 0 : libFeatures.supportVdom) !== null && _b !== void 0 ? _b : true;
+                // 模拟器预览模式下，按照基础库是否支持相关功能 + 用户是否勾选进行判断
+                enableV2 = supportV2 && settings.enableV2;
+                // 开启v2不编译vdom
+                enableVDom = !enableV2 && supportVDom && settings.enableVDom;
+                // enableVDom = !enableV2 && settings.enableVDom
+                enableV1 = !enableV2;
+            }
+            else {
+                // 上传模式下按照勾选开启
+                enableVDom = settings.enableVDom;
+                enableV2 = settings.enableV2;
+                enableV1 = true;
+            }
+            return {
+                enableV1,
+                enableV2,
+                enableVDom
+            };
+        });
+    }
+    // 根据使用的场景或者配置，采用不同的compiler类型
+    getCompilerType(entryType = constant_config_1.COMPILE_ENTRY.simulator) {
+        const isGame = this.project.appMode === constant_config_1.MiniMode.minigame;
+        const settings = this.project.projectJsonContent.setting || {};
+        // 使用旧编译
+        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 { mpCompileDirPath } = this.getCompilerDir();
+        const compilerType = this.getCompilerType(entryType);
+        const basename = path_1.default.basename(this.project.projectPath);
+        const hash = (0, utils_1.getMd5)(this.project.projectPath).slice(0, 8);
+        const distDir = path_1.default.join(path_1.default.resolve(mpCompileDirPath, `${basename}_${hash}`), compilerType);
+        fs_extra_1.default.ensureDirSync(distDir);
+        return distDir;
+    }
+    removeDistDir(entryType = constant_config_1.COMPILE_ENTRY.simulator) {
+        const distDir = this.getDistDir(entryType);
+        if (fs_extra_1.default.existsSync(distDir)) {
+            fs_extra_1.default.removeSync(distDir);
+        }
+    }
+    getCacheDir(entryType = constant_config_1.COMPILE_ENTRY.simulator) {
+        const { mpCompileCachePath } = this.getCompilerDir();
+        const compilerType = this.getCompilerType(entryType);
+        const basename = path_1.default.basename(this.project.projectPath);
+        const hash = (0, utils_1.getMd5)(this.project.projectPath).slice(0, 8);
+        const distDir = path_1.default.join(path_1.default.resolve(mpCompileCachePath, `${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);
+        }
+    }
+    createCompilerImpl(entryType = constant_config_1.COMPILE_ENTRY.simulator) {
+        const { nodeJsPath, mpDevJsonPath } = this.compilerProps;
+        const { mpCompileDirPath } = this.getCompilerDir();
+        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,
+            cacheDirectory: cacheDir
+        };
+        this.removeDistDir(entryType);
+        this.removeCacheDir(entryType);
+        const CompilerClass = (0, compiler_1.getProcessCompilerClass)(compilerType);
+        const compilerImpl = new CompilerClass(options, {
+            logger: this.logger,
+            nodeJsPath
+        });
+        return compilerImpl;
+    }
+    makePkgsReady(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entryType = constant_config_1.COMPILE_ENTRY.simulator;
+            const compilerImpl = this.getComilerImpl(entryType);
+            yield compilerImpl.makePkgsReady(config);
+        });
+    }
+    reCompilePkgs(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entryType = constant_config_1.COMPILE_ENTRY.simulator;
+            const compilerImpl = this.getComilerImpl(entryType);
+            yield compilerImpl.reCompilePkgs(config);
+        });
+    }
+    compileProject(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            try {
+                const { entryType, compressJs, enableSourcemap, enableV2, enableV1, enableVDom } = config;
+                this.emit('compile-project-start');
+                (_a = this.logger) === null || _a === void 0 ? void 0 : _a.log('Compile project...');
+                const compilerImpl = this.getComilerImpl(entryType);
+                yield compilerImpl.build({
+                    compressJs,
+                    enableSourcemap,
+                    enableV2,
+                    enableV1,
+                    enableVDom
+                });
+                this.emit('compile-project-done');
+                (_b = this.logger) === null || _b === void 0 ? void 0 : _b.log('Compile project done');
+            }
+            catch (stats) {
+                let error;
+                if (stats instanceof Error) {
+                    error = stats;
+                }
+                else {
+                    const { errors } = stats || {};
+                    error = new Error(errors.join('\n\n'));
+                }
+                (_c = this.logger) === null || _c === void 0 ? void 0 : _c.log('Compile project failed', error);
+                this.emit('compile-project-fail', error);
+                throw error;
+            }
+        });
+    }
+    compileAndZip(opts) {
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            const { can_upload_ext_json, upload_app_id, 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 { enableV2, enableV1, enableVDom } = yield this.getUsingPackageType(entryType);
+                let compressJs = false;
+                let enableSourcemap = true;
+                if (entryType === constant_config_1.COMPILE_ENTRY.upload || entryType === constant_config_1.COMPILE_ENTRY.preview) {
+                    compressJs = true;
+                    enableSourcemap = false;
+                }
+                else if (settings.hasOwnProperty('minified')) {
+                    compressJs = settings.minified;
+                }
+                const buildConfig = {
+                    entryType,
+                    compressJs,
+                    enableSourcemap,
+                    enableV2,
+                    enableV1,
+                    enableVDom
+                };
+                // 编译
+                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 || entryType === constant_config_1.COMPILE_ENTRY.upload) {
+                    entryZips = [
+                        this.zipWithFullPackage(opts, subPackages, 'v0'),
+                        this.zipWithSubPackage(opts, subPackages, 'v1'),
+                        // 小程序模式有v2包
+                        enableV2 && this.zipWithSubPackage(opts, subPackages, 'v2')
+                    ];
+                }
+                else {
+                    // 真机调试
+                    // eslint-disable-next-line no-lonely-if
+                    if (!subPackages.length) {
+                        // 真机调试整包zip内产物文件需要放在appid目录下
+                        entryZips = [this.zipWithFullPackageWithAppId(opts, subPackages, 'v0')];
+                    }
+                    else {
+                        // eslint-disable-next-line no-lonely-if
+                        if (enableV2) {
+                            entryZips = [this.zipWithSubPackage(opts, subPackages, 'v2')];
+                        }
+                        else {
+                            entryZips = [this.zipWithSubPackage(opts, subPackages, 'v1')];
+                        }
+                    }
+                }
+                const zipTask = yield Promise.all(entryZips.filter(Boolean));
+                const zipResult = zipTask.flat(2);
+                this.emit('compile-and-zip-status', { status: 'zip-done' });
+                // change ext
+                if (entryType === constant_config_1.COMPILE_ENTRY.preview || entryType === constant_config_1.COMPILE_ENTRY.upload) {
+                    this.project.changeExtJsonPermission(!!can_upload_ext_json);
+                }
+                resolve(zipResult);
+            }
+            catch (error) {
+                reject(error);
+            }
+        }));
+    }
+    zipWithFullPackageWithAppId(opts_1) {
+        return __awaiter(this, arguments, void 0, function* (opts, subPackages = [], type) {
+            const { entryType } = opts;
+            const buildDir = this.getDistDir(entryType);
+            const distFullZip = path_1.default.resolve(buildDir, 'v0-full-pack.zip');
+            const srcDirPath = path_1.default.resolve(buildDir, !subPackages.length ? 'v1' : 'v0'); // 如果没有开启分包，则把v1包当作v0包
+            return (0, zip_1.genZip)(srcDirPath, distFullZip, this.project.projectAppId);
+        });
+    }
+    /* 使用v0的入口，zip整包 */
+    zipWithFullPackage(opts_1) {
+        return __awaiter(this, arguments, void 0, function* (opts, subPackages = [], type) {
+            const project = this.project;
+            const { upload_app_id, can_upload_ext_json, pkgInfo, entryType } = opts;
+            const buildDir = this.getDistDir(entryType);
+            const appendFile = [];
+            const appendBuffer = [];
+            appendFile.push(project.projectJsonPath); // zip添加project.config.json
+            /* 是否需要上传ext.json */
+            if (can_upload_ext_json && fs_extra_1.default.existsSync(project.extJsonPath)) {
+                appendFile.push(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')
+                });
+            }
+            const zipConfig = {
+                outputDir: path_1.default.resolve(buildDir, `${type}-full-pack.zip`), // 输出的路径
+                type,
+                inputDir: path_1.default.resolve(buildDir, !subPackages.length ? 'v1' : 'v0' // 如果没有开启分包，则把v1包当作v0包
+                ), // 输入的路径
+                ignore: [],
+                prefix: upload_app_id,
+                appendFile,
+                appendBuffer,
+                meta: {
+                    root: ''
+                }
+            };
+            return (0, project_1.zipFactory)(zipConfig);
+        });
+    }
+    /* 使用v1的入口。zip主包和分包 */
+    zipWithSubPackage(opts, subPackages, type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const project = 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(project.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}/**`); // 主包里需要忽略分包的路径
+            /* 是否需要上传ext.json */
+            if (can_upload_ext_json && fs_extra_1.default.existsSync(project.extJsonPath)) {
+                appendFile.push(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')
+                });
+            }
+            /* 分包的zip配置 */
+            const zipConfig = [
+                {
+                    outputDir: path_1.default.resolve(buildDir, `${type}-main-pack.zip`), // 输出的路径
+                    type,
+                    inputDir: mainEntry, // 输入的路径
+                    ignore: mainIgnore,
+                    prefix: '',
+                    appendFile,
+                    appendBuffer,
+                    meta: {
+                        root: '/'
+                    }
+                },
+                ...(subPackages || []).map((item, index) => {
+                    const pkgRoot = item.root.replace(/\//g, constant_config_1.PKG_ROOT_SEP);
+                    return {
+                        outputDir: path_1.default.resolve(buildDir, `${type}-sub-pack-${isRemoteDebug ? pkgRoot : index}.zip`),
+                        type,
+                        inputDir: path_1.default.resolve(buildDir, type, item.root),
+                        ignore: [],
+                        prefix: `${item.root}`,
+                        meta: {
+                            root: item.root
+                        }
+                    };
+                })
+            ];
+            return Promise.all(zipConfig.map(config => (0, project_1.zipFactory)(config)));
+        });
+    }
+    close(entryType = constant_config_1.COMPILE_ENTRY.simulator) {
+        const compilerType = this.getCompilerType(entryType);
+        const compiler = this.compilerImplMap[compilerType];
+        if (compiler) {
+            compiler.close();
+        }
+    }
+    kill(entryType = constant_config_1.COMPILE_ENTRY.simulator) {
+        const compilerType = this.getCompilerType(entryType);
+        const compiler = this.compilerImplMap[compilerType];
+        if (!compiler) {
+            return;
+        }
+        compiler.kill();
+        delete this.compilerImplMap[entryType];
+    }
+}
+exports.Compiler = Compiler;

package/dist/packs/index.d.ts

@@ -0,0 +1,14 @@
+import { Compilation, RawSource, CopyPatterns, Config, ConcatSource, MPPackSetting } from 'xhs-mp-pack';
+import { Configuration, WebpackError, library, LoaderContext } from 'webpack';
+import type { Project } from 'xhs-mp-project';
+import { IStart } from '../types';
+export type ICompilation = any;
+export type ICompiler = any;
+export type ILoaderContext = LoaderContext<any> & {
+    _compiler: {
+        project: Project;
+        packSetting: MPPackSetting;
+    };
+};
+export { Compilation, RawSource, ConcatSource, CopyPatterns, Config, Configuration, WebpackError, library, LoaderContext };
+export declare function createCompiler(startConfig: IStart): ICompiler;

package/dist/packs/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCompiler = exports.library = exports.WebpackError = exports.Config = exports.CopyPatterns = exports.ConcatSource = exports.RawSource = exports.Compilation = void 0;
+/**
+ * 抹平差异：抹平webpack和mp-pack的差异
+ * 统一收口，所有对webpack和mp-pack的调用都走这个出口，不可用直接调用
+ */
+const webpack_1 = require("./webpack");
+const mp_pack_1 = require("./mp-pack");
+const xhs_mp_pack_1 = require("xhs-mp-pack");
+Object.defineProperty(exports, "Compilation", { enumerable: true, get: function () { return xhs_mp_pack_1.Compilation; } });
+Object.defineProperty(exports, "RawSource", { enumerable: true, get: function () { return xhs_mp_pack_1.RawSource; } });
+Object.defineProperty(exports, "CopyPatterns", { enumerable: true, get: function () { return xhs_mp_pack_1.CopyPatterns; } });
+Object.defineProperty(exports, "Config", { enumerable: true, get: function () { return xhs_mp_pack_1.Config; } });
+Object.defineProperty(exports, "ConcatSource", { enumerable: true, get: function () { return xhs_mp_pack_1.ConcatSource; } });
+const webpack_2 = require("webpack");
+Object.defineProperty(exports, "WebpackError", { enumerable: true, get: function () { return webpack_2.WebpackError; } });
+Object.defineProperty(exports, "library", { enumerable: true, get: function () { return webpack_2.library; } });
+const const_1 = __importDefault(require("../utils/const"));
+const { PACK_MODE } = const_1.default;
+function createCompiler(startConfig) {
+    const { packMode = PACK_MODE.MPPACK } = startConfig;
+    if (packMode === PACK_MODE.WEBPACK) {
+        return (0, webpack_1.createCompiler)(startConfig);
+    }
+    return (0, mp_pack_1.createCompiler)(startConfig);
+}
+exports.createCompiler = createCompiler;

package/dist/packs/mp-pack/index.d.ts

@@ -0,0 +1,3 @@
+import { IStart } from '../../types';
+import { MPPack } from 'xhs-mp-pack';
+export declare const createCompiler: (startConfig: IStart) => Promise<void> | MPPack;

package/dist/packs/mp-pack/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCompiler = void 0;
+const presets_1 = require("../../presets");
+const path_1 = __importDefault(require("path"));
+const xhs_mp_pack_1 = require("xhs-mp-pack");
+const dev_server_1 = __importDefault(require("../webpack/dev-server"));
+const createCompiler = (startConfig) => {
+    const { action, enableDevServer } = startConfig;
+    const mppack = new xhs_mp_pack_1.MPPack(startConfig);
+    const compilerOptions = {
+        project: mppack.project,
+        packSetting: mppack.packSetting
+    };
+    const mpPackConfigs = (0, presets_1.createConfigs)(compilerOptions);
+    mpPackConfigs.forEach(config => {
+        var _a, _b, _c, _d;
+        /* 修改在ide里的node_modules的路径 */
+        (_b = (_a = config.resolve) === null || _a === void 0 ? void 0 : _a.modules) === null || _b === void 0 ? void 0 : _b.push(path_1.default.resolve(__dirname, '../../../'));
+        // cli的node_modules路径
+        (_d = (_c = config.resolve) === null || _c === void 0 ? void 0 : _c.modules) === null || _d === void 0 ? void 0 : _d.push(path_1.default.resolve(__dirname, '../../'));
+    });
+    if (action === 'dev' && enableDevServer) {
+        return (0, dev_server_1.default)(compilerOptions);
+    }
+    mppack.createCompiler(mpPackConfigs);
+    return mppack;
+};
+exports.createCompiler = createCompiler;

package/dist/packs/webpack/dev-server/index.d.ts

@@ -0,0 +1,3 @@
+import { IPresetOptions } from '../../../types';
+declare const devServer: (config: IPresetOptions) => Promise<void>;
+export default devServer;

package/dist/packs/webpack/dev-server/index.js

@@ -0,0 +1,64 @@
+"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 });
+const path_1 = __importDefault(require("path"));
+const webpack_1 = __importDefault(require("webpack"));
+const ensurePort_1 = __importDefault(require("./lib/ensurePort"));
+const openBrowser_1 = __importDefault(require("./lib/openBrowser"));
+const presets_1 = require("../../../presets");
+const devServer = (config) => __awaiter(void 0, void 0, void 0, function* () {
+    const { packSetting } = config;
+    const { devServerPort, distDir } = packSetting;
+    const webpackConfigs = (0, presets_1.createConfigs)(config);
+    const compiler = (0, webpack_1.default)(webpackConfigs);
+    const host = 'localhost';
+    const devServerConfig = {
+        open: false,
+        historyApiFallback: true,
+        port: devServerPort || 1388,
+        hot: false,
+        static: [
+            // emulator entry 地址
+            path_1.default.resolve('node_modules/@xhs/mp-simulator/dist'),
+            path_1.default.resolve('node_modules/@xhs/mp-js-core/dist'),
+            ...JSON.parse(process.env.XHS_MP_LIB || '[]'), // 自定义地址
+            distDir,
+        ],
+        client: {
+            logging: 'error',
+            overlay: false,
+            progress: false,
+        },
+        // firewall: false,
+        headers: {
+            'Access-Control-Allow-Origin': '*',
+        },
+    };
+    // 检查端口是否被占用，若占用会修改 devServerConfig.port
+    yield (0, ensurePort_1.default)(devServerConfig);
+    const Server = require('webpack-dev-server');
+    const server = new Server(compiler, Object.assign(Object.assign({}, devServerConfig), { open: false }));
+    server.listen(devServerConfig.port, host, () => { });
+    let isBrowserOpened = false;
+    compiler.hooks.done.tap('xhs-mp-cli', stats => {
+        if (stats.hasErrors()) {
+            return;
+        }
+        if (devServerConfig.open && !isBrowserOpened) {
+            isBrowserOpened = true;
+            (0, openBrowser_1.default)(host, devServerConfig.port);
+        }
+    });
+});
+exports.default = devServer;

package/dist/packs/webpack/dev-server/lib/ensurePort.d.ts

@@ -0,0 +1,2 @@
+declare const ensurePort: (devServerConfig: any) => Promise<unknown>;
+export default ensurePort;

package/dist/packs/webpack/dev-server/lib/ensurePort.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-nocheck
+const net_1 = __importDefault(require("net"));
+const ensurePort = (devServerConfig) => new Promise(res => {
+    const checkPort = () => {
+        const server = net_1.default.createServer().listen(devServerConfig.port, devServerConfig.client.host);
+        server.on('listening', () => {
+            server.close();
+            res(1);
+        });
+        server.on('error', err => {
+            if (err.code === 'EADDRINUSE') {
+                devServerConfig.port += 1;
+                checkPort(devServerConfig);
+            }
+        });
+    };
+    try {
+        checkPort();
+    }
+    catch (err) {
+        if (err.code === 'EADDRINUSE') {
+            devServerConfig.port += 1;
+            checkPort(devServerConfig);
+        }
+    }
+});
+exports.default = ensurePort;

package/dist/packs/webpack/dev-server/lib/openBrowser.d.ts

@@ -0,0 +1,2 @@
+declare const openBrowser: (host: string, port: number) => true | undefined;
+export default openBrowser;

package/dist/packs/webpack/dev-server/lib/openBrowser.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const open_1 = __importDefault(require("open"));
+// eslint-disable-next-line consistent-return
+const openBrowser = (host, port) => {
+    const url = `http://${host}:${port}`;
+    try {
+        (0, child_process_1.execSync)(`osascript ${__dirname}/openChrome.applescript ${encodeURI(url)}`, {
+            stdio: 'ignore',
+        });
+        return true;
+    }
+    catch (error) {
+        // Ignore errors.
+    }
+    // fallback to normal open
+    (0, open_1.default)(url);
+};
+exports.default = openBrowser;