xhs-mp-compiler-cli 1.0.1-beta.0

package/dist/webpack-config/presets/prod.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const const_1 = __importDefault(require("../lib/const"));
+// import { BundleAnalyzerPlugin } from 'webpack-bundle-analyzer'
+const getProdConfig = (chain, options) => {
+    chain.mode('production');
+    if (!options.noJs) {
+        // 生产环境使用 babel-loader
+        chain.module
+            .rule('js')
+            .use('js-loader')
+            .loader(require.resolve('babel-loader'))
+            .options({
+            configFile: false,
+            babelrc: false,
+            sourceType: 'unambiguous',
+            presets: [
+                [
+                    require.resolve('@babel/preset-env'),
+                    {
+                        useBuiltIns: false,
+                        corejs: {
+                            version: 3,
+                            proposals: true,
+                        },
+                        shippedProposals: true,
+                        targets: const_1.default.PROD_BROWSERSLIST,
+                    },
+                ],
+            ],
+            plugins: [[require.resolve('@babel/plugin-transform-runtime'), { corejs: false }]],
+        });
+        chain.module
+            .rule('ts')
+            .use('ts-loader')
+            .loader(require.resolve('babel-loader'))
+            .options({
+            sourceType: 'unambiguous',
+            presets: [
+                [
+                    require.resolve('@babel/preset-typescript'),
+                    {
+                        allExtensions: true,
+                        isTSX: true,
+                    },
+                ],
+                [
+                    require.resolve('@babel/preset-env'),
+                    {
+                        useBuiltIns: false,
+                        corejs: {
+                            version: 3,
+                            proposals: true,
+                        },
+                        shippedProposals: true,
+                        targets: const_1.default.PROD_BROWSERSLIST,
+                    },
+                ],
+            ],
+            plugins: [[require.resolve('@babel/plugin-transform-runtime'), { corejs: false }]],
+        });
+        chain.optimization.minimizer('js').use(require.resolve('terser-webpack-plugin'), [
+            {
+                terserOptions: {
+                    safari10: true,
+                    compress: { drop_console: false },
+                },
+            },
+        ]);
+    }
+    chain.optimization.minimize(!!options.compressJs);
+    // mini-style-loader 中已压缩
+    // chain.optimization.minimizer('css').use(require.resolve('css-minimizer-webpack-plugin'), [
+    //   {
+    //     minimizerOptions: {
+    //       preset: ['default', { normalizeUrl: false }],
+    //     },
+    //   },
+    // ])
+    // chain.plugin('abc').use(BundleAnalyzerPlugin)
+};
+exports.default = getProdConfig;

package/dist/webpack-config/presets/render/ComponentEntryPlugin.d.ts

@@ -0,0 +1,18 @@
+import { Compiler } from 'webpack';
+interface IRenderEntryPluginOptions {
+    enableV1?: boolean;
+    enableV2?: boolean;
+}
+declare class RenderEntryPlugin {
+    enableV1?: boolean;
+    enableV2?: boolean;
+    entriesCache: Map<string, boolean>;
+    subPackageRoots: string[];
+    constructor(options: IRenderEntryPluginOptions);
+    isFileInMainPkg(filePath: any): boolean;
+    isFileInSubpackage(filePath: any): boolean;
+    apply(compiler: Compiler): void;
+    makeGlobalEntry(compiler: Compiler, filename: string, url: string): void;
+    makeUmdEntry(compiler: Compiler, filename: string, url: string, libraryName: string): void;
+}
+export default RenderEntryPlugin;

package/dist/webpack-config/presets/render/ComponentEntryPlugin.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const webpack_1 = require("webpack");
+const XhsMpJsonPlugin_1 = __importDefault(require("../../plugins/XhsMpJsonPlugin"));
+class RenderEntryPlugin {
+    constructor(options) {
+        const { enableV1, enableV2 } = options;
+        this.enableV1 = enableV1;
+        this.enableV2 = enableV2;
+        this.entriesCache = new Map();
+        this.subPackageRoots = [];
+    }
+    isFileInMainPkg(filePath) {
+        return this.subPackageRoots.every(root => !filePath.startsWith(`${root}/`));
+    }
+    isFileInSubpackage(filePath) {
+        return this.subPackageRoots.some(root => filePath.startsWith(`${root}/`));
+    }
+    apply(compiler) {
+        new webpack_1.library.EnableLibraryPlugin('global').apply(compiler);
+        const hooks = XhsMpJsonPlugin_1.default.getHooks();
+        hooks.collected.tap('RenderEntryPlugin', ({ xhsData }) => {
+            const { appJSON } = xhsData;
+            this.subPackageRoots = appJSON.subPackages.map(pkg => pkg.root);
+            if (this.enableV2) {
+                new webpack_1.library.EnableLibraryPlugin('global').apply(compiler);
+                Object.keys(appJSON.componentsMap).forEach(compPath => {
+                    if (this.isFileInMainPkg(compPath)) {
+                        this.makeGlobalEntry(compiler, `v2/${compPath}.js`, `component-entry-requirements-loader?compPath=${compPath}&pkg=main!`);
+                    }
+                    if (this.isFileInSubpackage(compPath)) {
+                        const root = this.subPackageRoots.find(root => compPath.startsWith(`${root}/`));
+                        this.makeGlobalEntry(compiler, `v2/${root}/${compPath}.js`, `component-entry-requirements-loader?compPath=${compPath}&pkg=sub&root=${root}!`);
+                    }
+                });
+            }
+            /**
+             * 继续构建 v1 的包，向前兼容
+             */
+            if (this.enableV1) {
+                new webpack_1.library.EnableLibraryPlugin('umd').apply(compiler);
+                // components
+                this.makeUmdEntry(compiler, 'v1/components.js', 'component-entry-loader?pkg=main!', 'XHS_COMPONENTS');
+                for (const subPackage of appJSON.subPackages) {
+                    const { root } = subPackage;
+                    // subPackages 的 components
+                    this.makeUmdEntry(compiler, `v1/${root}/components.js`, `component-entry-loader?pkg=sub&root=${root}!`, `XHS_COMPONENTS_${root}`);
+                }
+            }
+        });
+    }
+    makeGlobalEntry(compiler, filename, url) {
+        if (this.entriesCache.get(filename))
+            return;
+        const entryOption = webpack_1.EntryOptionPlugin.entryDescriptionToOptions(compiler, filename, {
+            import: [url],
+            filename,
+        });
+        new webpack_1.EntryPlugin(compiler.context, url, entryOption).apply(compiler);
+        this.entriesCache.set(filename, true);
+    }
+    makeUmdEntry(compiler, filename, url, libraryName) {
+        if (this.entriesCache.get(filename))
+            return;
+        const entryOption = webpack_1.EntryOptionPlugin.entryDescriptionToOptions(compiler, filename, {
+            import: [url],
+            filename,
+            library: { name: libraryName, type: 'umd' },
+        });
+        new webpack_1.EntryPlugin(compiler.context, url, entryOption).apply(compiler);
+        this.entriesCache.set(filename, true);
+    }
+}
+exports.default = RenderEntryPlugin;

package/dist/webpack-config/presets/render/RenderChunkPlugin.d.ts

@@ -0,0 +1,9 @@
+import { Compiler } from 'webpack';
+declare class RenderChunkPlugin {
+    enableVDom?: boolean;
+    constructor(options: {
+        enableVDom?: boolean;
+    });
+    apply(compiler: Compiler): void;
+}
+export default RenderChunkPlugin;

package/dist/webpack-config/presets/render/RenderChunkPlugin.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const webpack_1 = require("webpack");
+const webpack_sources_1 = require("webpack-sources");
+const runtimeName = 'runtime.render.js';
+const injectCSS = `
+globalThis.__XHS_APPEND_CSS = function(cssText){
+    var headTags = document.getElementsByTagName('head')
+    var head = document.head || (headTags && headTags[0])
+    var cssTextNode = document.createTextNode(String(cssText))
+    var styleNode = document.createElement('style')
+    styleNode.appendChild(cssTextNode)
+    head.appendChild(styleNode)
+};
+`;
+// 注入css跟webpack runtime
+class RenderChunkPlugin {
+    constructor(options) {
+        this.enableVDom = options.enableVDom;
+    }
+    apply(compiler) {
+        compiler.hooks.compilation.tap(RenderChunkPlugin.name, compilation => {
+            compilation.hooks.processAssets.tap({
+                name: RenderChunkPlugin.name,
+                stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS,
+            }, (assets) => {
+                var _a, _b, _c;
+                let injectCode = "";
+                if (this.enableVDom) {
+                    // 向前兼容旧架构
+                    injectCode = injectCSS;
+                }
+                else {
+                    const runtimeCode = (_a = compilation.getAsset(runtimeName)) === null || _a === void 0 ? void 0 : _a.source.source();
+                    // 注入css逻辑
+                    injectCode = `
+                            ${injectCSS}
+                            if (!globalThis.__XHS_RUNTIME_REGISTERED__) {
+                                globalThis.__XHS_RUNTIME_REGISTERED__ = true;
+                                ${runtimeCode}
+                            };`;
+                }
+                // @ts-ignore
+                const appJSON = compiler.xhsData.appJSON;
+                const pathMap = [
+                    (_b = appJSON.pages) === null || _b === void 0 ? void 0 : _b.map(({ path }) => path),
+                    (_c = appJSON.subPackages) === null || _c === void 0 ? void 0 : _c.map(sub => { var _a; return (_a = sub.pages) === null || _a === void 0 ? void 0 : _a.map(({ path }) => path); })
+                ].flat(4).filter(Boolean)
+                    .reduce((ac, path) => {
+                    ac[`v1/${path}.render.js`] = true;
+                    ac[`v2/${path}.render.js`] = true;
+                    return ac;
+                }, {});
+                // 将runtime 塞到render.js中去
+                Object.keys(assets).forEach(key => {
+                    if (!pathMap[key])
+                        return;
+                    // @ts-ignore
+                    compilation.updateAsset(key, new webpack_sources_1.ConcatSource(injectCode, assets[key]));
+                });
+            });
+        });
+    }
+}
+exports.default = RenderChunkPlugin;

package/dist/webpack-config/presets/render/RenderEntryPlugin.d.ts

@@ -0,0 +1,14 @@
+import { Compiler } from 'webpack';
+interface IRenderEntryPluginOptions {
+    enableV1?: boolean;
+    enableV2?: boolean;
+}
+declare class RenderEntryPlugin {
+    enableV1?: boolean;
+    enableV2?: boolean;
+    entriesCache: Map<string, boolean>;
+    constructor(options: IRenderEntryPluginOptions);
+    apply(compiler: Compiler): void;
+    makeEntry(compiler: Compiler, name: string, url: string): void;
+}
+export default RenderEntryPlugin;

package/dist/webpack-config/presets/render/RenderEntryPlugin.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const webpack_1 = require("webpack");
+const XhsMpJsonPlugin_1 = __importDefault(require("../../plugins/XhsMpJsonPlugin"));
+class RenderEntryPlugin {
+    constructor(options) {
+        const { enableV1, enableV2 } = options;
+        this.enableV1 = enableV1;
+        this.enableV2 = enableV2;
+        this.entriesCache = new Map();
+    }
+    apply(compiler) {
+        const hooks = XhsMpJsonPlugin_1.default.getHooks();
+        hooks.collected.tap('RenderEntryPlugin', ({ xhsData }) => {
+            const { appJSON } = xhsData;
+            new webpack_1.library.EnableLibraryPlugin('umd').apply(compiler);
+            for (const { path } of appJSON.pages) {
+                this.enableV1 && this.makeEntry(compiler, `v1/${path}`, `render-entry-loader?mode=v1&path=${path}!`);
+                this.enableV2 && this.makeEntry(compiler, `v2/${path}`, `render-entry-loader?mode=v2&path=${path}!`);
+            }
+            for (const subPackage of appJSON.subPackages) {
+                const { pages } = subPackage;
+                for (const { path } of pages) {
+                    // subPackages 的 pages
+                    this.enableV1 && this.makeEntry(compiler, `v1/${path}`, `render-entry-loader?mode=v1&path=${path}!`);
+                    this.enableV2 && this.makeEntry(compiler, `v2/${path}`, `render-entry-loader?mode=v2&path=${path}!`);
+                }
+            }
+        });
+    }
+    makeEntry(compiler, name, url) {
+        if (this.entriesCache.get(name))
+            return;
+        const entryOption = webpack_1.EntryOptionPlugin.entryDescriptionToOptions(compiler, name, { import: [url] });
+        new webpack_1.EntryPlugin(compiler.context, url, entryOption).apply(compiler);
+        this.entriesCache.set(name, true);
+    }
+}
+exports.default = RenderEntryPlugin;

package/dist/webpack-config/presets/render/SjsEntryPlugin.d.ts

@@ -0,0 +1,31 @@
+import { Compilation, Compiler } from 'webpack';
+/**
+ * @NOTE 分包中使用 SJS 的规则
+ *
+ *  - 整包情况下，可以在所有页面中引用整包内的任意SJS模块。
+ *  - 分包情况下：
+ *    - 主包不能引入分包的 SJS 模块。
+ *    - 分包内部可以引用主分包内的SJS模块。
+ *    - 分包A 和 分包B 之间不可以互相引用SJS模块。
+ *    - 独立分包内的SJS模块只能在独立分包内使用，不能跨分包引用。
+ */
+interface IRenderEntryPluginOptions {
+    enableV1?: boolean;
+    enableV2?: boolean;
+    miniprogramDir: string;
+}
+declare class SjsEntryPlugin {
+    enableV1?: boolean;
+    enableV2?: boolean;
+    entriesCache: Map<string, boolean>;
+    mainpkgPaths: string[];
+    subPackagePaths: Map<string, string[]>;
+    miniprogramDir: string;
+    subPackageRoots: string[];
+    constructor(options: IRenderEntryPluginOptions);
+    isFileInMainPkg(filePath: any): boolean;
+    isFileInSubpackage(filePath: any): boolean;
+    apply(compiler: Compiler): void;
+    makeSjsFileContent(compilation: Compilation, chunkName: string, sjsFiles: string[] | undefined, sjsModuleName: string, pkgRoot?: string): void;
+}
+export default SjsEntryPlugin;

package/dist/webpack-config/presets/render/SjsEntryPlugin.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const glob_1 = __importDefault(require("glob"));
+const webpack_sources_1 = require("webpack-sources");
+const webpack_1 = require("webpack");
+// @ts-ignore
+const sjs_loader_1 = __importDefault(require("../../loaders/sjs-loader"));
+const common_1 = require("../../../utils/common");
+function formatSJSPath(i) {
+    if (/\.(sjs|wxs)$/.test(i)) {
+        return (0, common_1.toUnixPath)(i);
+    }
+    const suffix = ['sjs', 'wxs'].find(n => fs_extra_1.default.existsSync(`${i}.${n}`));
+    if (!suffix) {
+        throw new webpack_1.WebpackError(`[SJS文件编译错误] ${i}.sjs 不存在`);
+    }
+    return (0, common_1.toUnixPath)(suffix ? `${i}.${suffix}` : i);
+}
+class SjsEntryPlugin {
+    constructor(options) {
+        const { enableV1, enableV2, miniprogramDir } = options;
+        this.miniprogramDir = miniprogramDir;
+        this.enableV1 = enableV1;
+        this.enableV2 = enableV2;
+        this.entriesCache = new Map();
+        this.mainpkgPaths = [];
+        this.subPackagePaths = new Map();
+        this.subPackageRoots = [];
+    }
+    isFileInMainPkg(filePath) {
+        return this.subPackageRoots.every(root => !filePath.startsWith(`${root}/`));
+    }
+    isFileInSubpackage(filePath) {
+        return this.subPackageRoots.some(root => filePath.startsWith(`${root}/`));
+    }
+    apply(compiler) {
+        new webpack_1.library.EnableLibraryPlugin('umd').apply(compiler);
+        compiler.hooks.watchRun.tap('SjsEntryPlugin', () => {
+            this.subPackagePaths.clear();
+            this.mainpkgPaths = [];
+        });
+        compiler.hooks.emit.tapAsync('SjsEntryPlugin', (compilation, callback) => {
+            // @ts-ignore
+            const { appJSON, miniprogramDir } = (compiler === null || compiler === void 0 ? void 0 : compiler.xhsData) || {};
+            this.subPackageRoots = appJSON.subPackages.map(pkg => pkg.root);
+            // 默认输出一个空的sjs文件
+            this.subPackageRoots.forEach(root => {
+                this.subPackagePaths.has(root) || this.subPackagePaths.set(root, []);
+            });
+            const relativePaths = glob_1.default.sync('**/*.sjs', { cwd: miniprogramDir });
+            relativePaths.forEach(relativePath => {
+                var _a;
+                const sjsAbsPath = (0, common_1.unixJoin)(miniprogramDir, relativePath);
+                // 如果是主包内的文件
+                if (this.isFileInMainPkg(relativePath)) {
+                    this.mainpkgPaths.push(sjsAbsPath);
+                }
+                // 如果命中了分包内的文件
+                if (this.isFileInSubpackage(relativePath)) {
+                    const root = this.subPackageRoots.find(root => relativePath.startsWith(`${root}/`));
+                    if (root) {
+                        (_a = this.subPackagePaths.get(root)) === null || _a === void 0 ? void 0 : _a.push(sjsAbsPath);
+                    }
+                }
+            });
+            // 主包
+            this.makeSjsFileContent(compilation, 'sjs.js', [...this.mainpkgPaths], 'XHS_SJS');
+            // 分包
+            Array.from(this.subPackagePaths.keys()).forEach(pkgRoot => {
+                // eslint-disable-next-line
+                const paths = this.subPackagePaths.get(pkgRoot);
+                this.makeSjsFileContent(compilation, `${pkgRoot}/sjs.js`, [...paths], `XHS_SJS_${pkgRoot}`, pkgRoot);
+            });
+            callback();
+        });
+    }
+    makeSjsFileContent(compilation, chunkName, sjsFiles = [], sjsModuleName, pkgRoot) {
+        const sjsModules = [];
+        // 用于去除重复引入
+        const sjsPathCache = new Set();
+        /**
+         * @NOTE
+         *   在这里校验 sjs 模块引入的路径是否符合规则，分包的规则见上方
+         */
+        let sjsPath;
+        // @ts-ignore
+        while ((sjsPath = sjsFiles.shift())) {
+            // eslint-disable-line
+            if (sjsPathCache.has(sjsPath)) {
+                continue;
+            }
+            const sjsAbsPath = formatSJSPath(sjsPath);
+            let content = fs_extra_1.default.readFileSync(sjsAbsPath, 'utf8');
+            content = sjs_loader_1.default.call(compilation, content, sjsAbsPath, this.miniprogramDir, requirePath => {
+                requirePath = (0, common_1.toUnixPath)(requirePath);
+                const relativePath = requirePath.replace(`${this.miniprogramDir}/`, '');
+                /**
+                 * 不是当前分包的 sjs 文件不处理
+                 */
+                if (pkgRoot && !relativePath.startsWith(pkgRoot)) {
+                    throw new webpack_1.WebpackError(`[SJS 文件编译错误] ${sjsAbsPath}，请检测引入路径是否正确或符合分包规则！`);
+                }
+                sjsFiles.push(requirePath);
+            });
+            sjsModules.push(`'${sjsPath.replace(`${this.miniprogramDir}/`, '')}': \`${content}\``);
+            // 处理后的加入缓存
+            sjsPathCache.add(sjsPath);
+        }
+        const source = new webpack_sources_1.ConcatSource(`globalThis['${sjsModuleName}'] = {`, `${sjsModules.join(',')}`, '}');
+        if (this.enableV1) {
+            // @ts-ignore
+            compilation.assets[`v1/${chunkName}`] = source;
+        }
+        if (this.enableV2) {
+            // @ts-ignore
+            compilation.assets[`v2/${chunkName}`] = source;
+        }
+    }
+}
+exports.default = SjsEntryPlugin;

package/dist/webpack-config/presets/render/index.d.ts

@@ -0,0 +1,4 @@
+import Config from 'webpack-chain';
+import { WebpackPresetOptions } from '../../../types';
+declare const getBaseConfig: (chain: Config, options: WebpackPresetOptions) => void;
+export default getBaseConfig;

package/dist/webpack-config/presets/render/index.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const webpack_1 = __importDefault(require("webpack"));
+const VueLoaderPlugin_1 = __importDefault(require("../../plugins/VueLoaderPlugin"));
+const XhsMpJsonPlugin_1 = __importDefault(require("../../plugins/XhsMpJsonPlugin"));
+const RenderEntryPlugin_1 = __importDefault(require("./RenderEntryPlugin"));
+const ComponentEntryPlugin_1 = __importDefault(require("./ComponentEntryPlugin"));
+const XhsMpErrorTransformPlugin_1 = __importDefault(require("../../plugins/XhsMpErrorTransformPlugin"));
+const css_1 = __importDefault(require("../../lib/css"));
+const types_1 = require("../../../types");
+const getMlSuffixName_1 = __importDefault(require("../../../utils/getMlSuffixName"));
+const getCssSuffixName_1 = __importDefault(require("../../../utils/getCssSuffixName"));
+const SjsEntryPlugin_1 = __importDefault(require("./SjsEntryPlugin"));
+const RenderChunkPlugin_1 = __importDefault(require("./RenderChunkPlugin"));
+const getBaseConfig = (chain, options) => {
+    const { extJsonPath, env, enableV1, enableV2, enableVDom, mpDir, miniprogramDir } = options;
+    const isProd = env === types_1.ENV.production;
+    const mlReg = new RegExp(`.${(0, getMlSuffixName_1.default)()}$`);
+    const cssReg = new RegExp(`.${(0, getCssSuffixName_1.default)()}$`);
+    chain.merge({
+        externals: { vue: 'vue' },
+        output: {
+            path: options.distDir,
+            filename: '[name].render.js',
+            globalObject: 'globalThis',
+        },
+        module: {
+            rule: {
+                ml: !options.liteCompiler
+                    ? {
+                        test: mlReg,
+                        use: {
+                            'vue-loader': {
+                                loader: require.resolve('vue-loader'),
+                                // 资源路径由组件层处理
+                                options: {
+                                    transformAssetUrls: { tags: {} },
+                                    compilerOptions: {
+                                        isCustomElement: tag => ['xhs-page', 'xhs-template'].includes(tag),
+                                    },
+                                },
+                            },
+                            'ml-loader': {
+                                loader: require.resolve('../../loaders/ml-loader'),
+                                options,
+                            },
+                        },
+                    }
+                    : {
+                        test: mlReg,
+                        use: {
+                            'ml-loader': {
+                                loader: require.resolve('xhs-mp-compiler-ml-loader'),
+                                options: {
+                                    removeComentNode: isProd,
+                                    vdom: enableVDom,
+                                },
+                            },
+                        },
+                    },
+                [(0, getCssSuffixName_1.default)()]: {
+                    test: cssReg,
+                    use: (0, css_1.default)(options, [
+                        "mini-style-loader",
+                        'postcss-loader',
+                        'wxss-loader',
+                    ].filter(Boolean)),
+                }
+            },
+        },
+    });
+    chain.plugin('XhsMpJsonPlugin').use(XhsMpJsonPlugin_1.default, [{ mpDir, miniprogramDir, extJsonPath }]);
+    // 组件层
+    chain.plugin('ComponentEntryPlugin').use(ComponentEntryPlugin_1.default, [{ enableV1, enableV2 }]);
+    // 渲染层
+    chain.plugin('XhsMpEntryPlugin').use(RenderEntryPlugin_1.default, [{ enableV1, enableV2 }]);
+    chain.plugin('SjsEntryPlugin').use(SjsEntryPlugin_1.default, [{ miniprogramDir, enableV1, enableV2 }]);
+    if (!options.liteCompiler) {
+        chain.plugin('vue').use(VueLoaderPlugin_1.default);
+        chain.plugin('XhsMpErrorTransformPlugin').use(XhsMpErrorTransformPlugin_1.default);
+        chain.plugin('DefinePlugin').use(webpack_1.default.DefinePlugin, [
+            {
+                __VUE_PROD_DEVTOOLS__: JSON.stringify(false),
+                __VUE_OPTIONS_API__: JSON.stringify(true),
+            },
+        ]);
+    }
+    if (!enableVDom) {
+        // 抽取runtime
+        chain.optimization.runtimeChunk({
+            name: 'runtime', // runtime.render.js
+        });
+    }
+    chain.plugin("RenderChunkPlugin").use(RenderChunkPlugin_1.default, [{ enableVDom }]);
+};
+exports.default = getBaseConfig;

package/dist/webpack-config/presets/service/ServiceEntryPlugin.d.ts

@@ -0,0 +1,8 @@
+import { Compiler } from 'webpack';
+declare class ServiceEntryPlugin {
+    entriesCache: Map<string, boolean>;
+    constructor();
+    apply(compiler: Compiler): void;
+    makeUmdEntry(compiler: Compiler, filename: string, url: string, libraryName: string): void;
+}
+export default ServiceEntryPlugin;

package/dist/webpack-config/presets/service/ServiceEntryPlugin.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const webpack_1 = require("webpack");
+const XhsMpJsonPlugin_1 = __importDefault(require("../../plugins/XhsMpJsonPlugin"));
+const common_1 = require("../../../utils/common");
+class ServiceEntryPlugin {
+    constructor() {
+        this.entriesCache = new Map();
+    }
+    apply(compiler) {
+        new webpack_1.library.EnableLibraryPlugin('umd').apply(compiler);
+        const hooks = XhsMpJsonPlugin_1.default.getHooks();
+        hooks.collected.tap('ServiceEntryPlugin', ({ xhsData }) => {
+            const { appJSON } = xhsData;
+            this.makeUmdEntry(compiler, 'v1/service.js', 'service-entry-loader?pkg=main!', 'XHS_SERVICE');
+            for (const { root } of appJSON.subPackages) {
+                this.makeUmdEntry(compiler, (0, common_1.unixJoin)('v1', root, 'service.js'), `service-entry-loader?pkg=sub&root=${root}!`, `XHS_SERVICE_${root}`);
+            }
+        });
+    }
+    makeUmdEntry(compiler, filename, url, libraryName) {
+        if (this.entriesCache.get(filename))
+            return;
+        const entryOption = webpack_1.EntryOptionPlugin.entryDescriptionToOptions(compiler, filename, {
+            import: [url],
+            filename,
+            library: { name: libraryName, type: 'umd', },
+        });
+        new webpack_1.EntryPlugin(compiler.context, url, entryOption).apply(compiler);
+        this.entriesCache.set(filename, true);
+    }
+}
+exports.default = ServiceEntryPlugin;

package/dist/webpack-config/presets/service/XhsMpServiceChunkPlugin.d.ts

@@ -0,0 +1,6 @@
+import { Compiler } from 'webpack';
+declare class XhsMpServiceChunkPlugin {
+    apply(compiler: Compiler): void;
+    updateIndependentService(compiler: any, compilation: any, runtimeCode: any): void;
+}
+export default XhsMpServiceChunkPlugin;