xhs-mp-compiler-cli 1.0.2 → 1.1.0

package/dist/{webpack-config/presets → presets}/babel.js

@@ -3,14 +3,16 @@ 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"));
-const types_1 = require("../../types");
+const const_1 = __importDefault(require("../utils/const"));
+const types_1 = require("../types");
 /**
  * babel 仅关注语法转换，polyfill 在 js-core 中已经内置
  * 目前 polyfill 仅支持到 'ios_saf >= 10', 'chrome >= 83'。语法构建中，会默认支持。
  */
 const getBaseConfig = (chain, options) => {
-    const swcTargets = options.env === types_1.ENV.development ? const_1.default.DEV_TARGETS : const_1.default.PROD_TARGETS;
+    const { packSetting } = options;
+    const { env, tsConfigPath } = packSetting;
+    const swcTargets = env === types_1.ENV.development ? const_1.default.DEV_TARGETS : const_1.default.PROD_TARGETS;
     chain.module
         .rule('js')
         .test(/\.js$/)
@@ -22,7 +24,7 @@ const getBaseConfig = (chain, options) => {
         jsc: { externalHelpers: true },
         env: {
             targets: swcTargets,
-            coreJS: 3,
+            coreJS: 3
         }
     });
     chain.module
@@ -42,16 +44,16 @@ const getBaseConfig = (chain, options) => {
             coreJS: 3
         }
     });
-    if (options.tsConfigPath) {
+    if (tsConfigPath) {
         chain.resolve.extensions.add('.ts');
-        chain
-            .plugin('ts-checker')
-            .use(require.resolve('fork-ts-checker-webpack-plugin'), [{
+        chain.plugin('ts-checker').use(require.resolve('fork-ts-checker-webpack-plugin'), [
+            {
                 async: true,
                 typescript: {
-                    configFile: options.tsConfigPath,
-                },
-            }]);
+                    configFile: tsConfigPath
+                }
+            }
+        ]);
     }
 };
 exports.default = getBaseConfig;

package/dist/presets/common.d.ts

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

package/dist/presets/common.js

@@ -0,0 +1,46 @@
+"use strict";
+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 types_1 = require("../types");
+const presetCommon = (chain, options) => {
+    const { packSetting, project } = options;
+    const { env, watch, enableSourcemap, cacheDirectory } = packSetting;
+    chain.merge({
+        stats: 'errors-only',
+        output: {
+            pathinfo: false,
+        },
+        resolve: {
+            roots: [project.miniprogramDir],
+            extensions: ['.js'],
+            modules: [
+                path_1.default.join(project.projectPath, 'node_modules'),
+                project.projectPath,
+                path_1.default.join(__dirname, '../../node_modules/')
+            ],
+        },
+        resolveLoader: {
+            modules: [path_1.default.join(__dirname, './loaders')],
+            extensions: ['.js', '.ts'],
+        },
+    });
+    chain.watch(!!watch);
+    chain.mode('development');
+    chain.devtool(enableSourcemap ? 'source-map' : false);
+    // @ts-ignore
+    chain.target(['web', 'es5']);
+    chain.cache(env === types_1.ENV.production
+        ? false
+        : {
+            type: 'filesystem',
+            cacheDirectory: cacheDirectory || path_1.default.join(__dirname, '../../node_modules/.cache'),
+            version: project.miniprogramDir,
+            buildDependencies: {
+                config: [path_1.default.join(project.miniprogramDir, 'app.json')],
+            },
+        });
+};
+exports.default = presetCommon;

package/dist/presets/configs/minigame/assets/assetsEntryPlugin.d.ts

@@ -0,0 +1,10 @@
+import { ICompiler, RawSource } from '../../../../packs';
+import { IPresetOptions } from '../../../../types';
+declare class MpEntryPlugin {
+    options: IPresetOptions;
+    constructor(options: IPresetOptions);
+    apply(compiler: ICompiler): void;
+    getAppJson(appJSON: any): Record<string, RawSource>;
+    getLegacyAppJSON(appJSON: any): RawSource;
+}
+export default MpEntryPlugin;

package/dist/presets/configs/minigame/assets/assetsEntryPlugin.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const packs_1 = require("../../../../packs");
+const lodash_1 = require("lodash");
+const common_1 = require("../../../../utils/common");
+const xhs_mp_project_1 = require("xhs-mp-project");
+class MpEntryPlugin {
+    constructor(options) {
+        this.options = options;
+    }
+    apply(compiler) {
+        // 在资源优化阶段处理app.json
+        compiler.hooks.compilation.tap(MpEntryPlugin.name, compilation => {
+            // @ts-ignore
+            compilation.hooks.processAssets.tap({
+                name: MpEntryPlugin.name,
+                stage: packs_1.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_COMPATIBILITY, // see below for more stages
+            }, (assets) => {
+                // @ts-ignore
+                const { appJSON } = this.options.project;
+                if (assets) {
+                    Object.assign(assets, this.getAppJson((0, lodash_1.cloneDeep)(appJSON)));
+                    // 兼容服务端，始终创建 v0/app.json
+                    assets['v0/app.json'] = this.getLegacyAppJSON((0, lodash_1.cloneDeep)(appJSON));
+                }
+            });
+        });
+    }
+    getAppJson(appJSON) {
+        const assets = {};
+        const appJsonSource = new packs_1.RawSource(JSON.stringify(xhs_mp_project_1.utils.pureAppJSON(appJSON)));
+        assets['v1/app.json'] = appJsonSource;
+        for (const subpackage of appJSON.subPackages) {
+            if (subpackage.independent) {
+                assets[(0, common_1.unixJoin)("v1", subpackage.dirname, "app.json")] = appJsonSource;
+            }
+        }
+        return assets;
+    }
+    getLegacyAppJSON(appJSON) {
+        // 兼容的整包，将 subPackages 合并到 pages 内
+        appJSON = xhs_mp_project_1.utils.pureAppJSON(appJSON, 'v0');
+        return new packs_1.RawSource(JSON.stringify(appJSON));
+    }
+}
+exports.default = MpEntryPlugin;

package/dist/presets/configs/minigame/assets/index.d.ts

@@ -0,0 +1,3 @@
+import { Config } from '../../../../packs';
+import { IPresetOptions } from '../../../../types';
+export declare const presetAssets: (chain: Config, options: IPresetOptions) => void;

package/dist/presets/configs/minigame/assets/index.js

@@ -0,0 +1,65 @@
+"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.presetAssets = void 0;
+const path_1 = __importDefault(require("path"));
+const assetsEntryPlugin_1 = __importDefault(require("./assetsEntryPlugin"));
+const copy_webpack_plugin_1 = __importDefault(require("copy-webpack-plugin"));
+const const_1 = __importDefault(require("../../../../utils/const"));
+const InjectorPlugin_1 = require("../../../plugins/InjectorPlugin");
+const ASSETS_EXTS = const_1.default.ASSETS_EXTS
+    .map(i => `.${i}`);
+const presetAssets = (chain, options) => {
+    const { packSetting, project } = options;
+    const { distDir } = packSetting;
+    chain.merge({
+        output: {
+            path: distDir,
+        },
+    });
+    const projectJsons = [
+        'game.json',
+        'package.json',
+        'package-lock.json',
+        'pkgInfo.json',
+        'project.config.json',
+        'project.private.config.json',
+    ].map(i => path_1.default.resolve(project.projectPath, i));
+    const copyPatterns = [
+        {
+            noErrorOnMissing: true,
+            from: `${project.projectPath}/**/*`,
+            filter: (resourcePath) => __awaiter(void 0, void 0, void 0, function* () {
+                if (resourcePath.includes('node_modules')) {
+                    return false;
+                }
+                const extname = path_1.default.extname(resourcePath);
+                if (ASSETS_EXTS.includes(extname)) {
+                    return true;
+                }
+                if (extname === '.json' && !projectJsons.includes(resourcePath)) {
+                    return true;
+                }
+                return false;
+            }),
+            to: 'v1',
+            context: project.projectPath,
+            globOptions: { gitignore: true },
+        },
+    ];
+    chain.plugin('InjectorPlugin').use(InjectorPlugin_1.InjectorPlugin, [options]);
+    chain.plugin('CopyPlugin').use(copy_webpack_plugin_1.default, [{ patterns: copyPatterns }]);
+    chain.plugin('AssetsEntryPlugin').use(assetsEntryPlugin_1.default, [options]);
+};
+exports.presetAssets = presetAssets;

package/dist/presets/configs/minigame/service/index.d.ts

@@ -0,0 +1,3 @@
+import { Config } from '../../../../packs';
+import { IPresetOptions } from '../../../../types';
+export declare const presetService: (chain: Config, options: IPresetOptions) => void;

package/dist/presets/configs/minigame/service/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.presetService = void 0;
+const serviceEntryPlugin_1 = __importDefault(require("./serviceEntryPlugin"));
+const serviceChunkPlugin_1 = __importDefault(require("./serviceChunkPlugin"));
+const resolveLimitPlugin_1 = __importDefault(require("./resolveLimitPlugin"));
+const InjectorPlugin_1 = require("../../../plugins/InjectorPlugin");
+const presetService = (chain, options) => {
+    const { packSetting } = options;
+    const { distDir } = packSetting;
+    chain.merge({
+        output: {
+            path: distDir,
+            globalObject: 'globalThis'
+        }
+    });
+    chain.plugin('InjectorPlugin').use(InjectorPlugin_1.InjectorPlugin, [options]);
+    chain.resolve.plugin('ResolveLimitPlugin').use(resolveLimitPlugin_1.default, [options]);
+    chain.plugin('ServiceEntryPlugin').use(serviceEntryPlugin_1.default, [options]);
+    chain.plugin('ServiceChunkPlugin').use(serviceChunkPlugin_1.default, [options]);
+    chain.optimization
+        .runtimeChunk({
+        name: 'runtime'
+    })
+        .splitChunks({
+        chunks: chunk => !chunk.name.startsWith('v0/'),
+        minSize: 0,
+        name: 'service-common'
+    });
+};
+exports.presetService = presetService;

package/dist/{webpack-config/presets/service/XhsResolveLimitPlugin.d.ts → presets/configs/minigame/service/resolveLimitPlugin.d.ts}

@@ -1,8 +1,8 @@
 import { Resolver } from 'enhanced-resolve';
-import { CliConfig } from '../../../types';
+import { IPresetOptions } from '../../../../types';
 declare class XhsResolveLimitPlugin {
-    miniprogramDir: string;
-    constructor(options: CliConfig);
+    options: IPresetOptions;
+    constructor(options: IPresetOptions);
     apply(resolver: Resolver): void;
 }
 export default XhsResolveLimitPlugin;

package/dist/presets/configs/minigame/service/resolveLimitPlugin.js

@@ -0,0 +1,35 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_extra_1 = require("fs-extra");
+class XhsResolveLimitPlugin {
+    constructor(options) {
+        this.options = options;
+    }
+    apply(resolver) {
+        const target1 = resolver.ensureHook("resolve");
+        resolver.getHook('file')
+            .tapAsync('XhsResolveLimitPlugin', (request, contextResolver, callback) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // @ts-ignore
+            const issuer = ((_a = request.context) === null || _a === void 0 ? void 0 : _a.issuer) || '';
+            const target = request.path || '';
+            if ((target.includes('node_modules') && (0, fs_extra_1.existsSync)(target))) {
+                return callback();
+            }
+            // console.log(`issuer: ${issuer}`, `target: ${target}`)
+            // return resolver.doResolve(target1, request, null, contextResolver, callback);
+            // console.log(issuer, target)
+            return callback();
+        }));
+    }
+}
+exports.default = XhsResolveLimitPlugin;

package/dist/presets/configs/minigame/service/serviceChunkPlugin.d.ts

@@ -0,0 +1,9 @@
+import { Compiler } from 'webpack';
+import { IPresetOptions } from '../../../../types';
+declare class ServiceChunkPlugin {
+    options: IPresetOptions;
+    constructor(options: IPresetOptions);
+    apply(compiler: Compiler): void;
+    updateService(compiler: any, compilation: any, runtimeCode: any, commonSource: any): void;
+}
+export default ServiceChunkPlugin;

package/dist/presets/configs/minigame/service/serviceChunkPlugin.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const webpack_1 = require("webpack");
+const webpack_sources_1 = require("webpack-sources");
+const common_1 = require("../../../../utils/common");
+class ServiceChunkPlugin {
+    constructor(options) {
+        this.options = options;
+    }
+    apply(compiler) {
+        compiler.hooks.compilation.tap('ServiceChunkPlugin', compilation => {
+            compilation.hooks.processAssets.tap({
+                name: 'ServiceChunkPlugin',
+                stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS,
+            }, () => {
+                var _a, _b;
+                let runtimeCode = (_a = compilation.getAsset('runtime.js')) === null || _a === void 0 ? void 0 : _a.source.source();
+                // 当没有引用相同 js 场景时， commonChunk 将是 undefined
+                const commonSource = ((_b = compilation.getAsset('service-common.js')) === null || _b === void 0 ? void 0 : _b.source) || '';
+                runtimeCode = `
+          if (!globalThis.__XHS_RUNTIME_REGISTERED__) {
+            globalThis.__XHS_RUNTIME_REGISTERED__ = true;
+            ${runtimeCode}
+          }`;
+                this.updateService(compiler, compilation, runtimeCode, commonSource);
+                compilation.deleteAsset('runtime.js');
+                compilation.deleteAsset('service-common.js');
+            });
+            compilation.hooks.processAssets.tap({
+                name: 'ServiceChunkPlugin1',
+                stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE,
+            }, (assets) => {
+                var _a;
+                const { project } = this.options;
+                // service层注入gameGlobal
+                const services = [
+                    "v1/service.js",
+                    // @ts-ignore
+                    ...(_a = project.appJSON.subPackages) === null || _a === void 0 ? void 0 : _a.map(i => (0, common_1.unixJoin)('v1', `${i.entry}.js`))
+                ];
+                services.forEach(servicePath => {
+                    if (servicePath in assets) {
+                        // @ts-ignore 
+                        compilation.updateAsset(servicePath, new webpack_sources_1.ConcatSource(`with(GameGlobal) {\n"use strict";\n`, assets[servicePath], '\n}'));
+                    }
+                });
+            });
+        });
+    }
+    updateService(compiler, compilation, runtimeCode, commonSource) {
+        var _a;
+        const { project } = this.options;
+        // 独立分包
+        const independent = (_a = project.appJSON.subPackages) === null || _a === void 0 ? void 0 : _a.filter(sub => sub.independent);
+        const services = [
+            "v1/service.js",
+            ...independent === null || independent === void 0 ? void 0 : independent.map(i => (0, common_1.unixJoin)('v1', `${i.entry}.js`))
+        ];
+        services.forEach(servicePath => {
+            var _a;
+            const serviceCode = (_a = compilation.getAsset(servicePath)) === null || _a === void 0 ? void 0 : _a.source;
+            if (serviceCode) {
+                // @ts-ignore
+                compilation.updateAsset(servicePath, new webpack_sources_1.ConcatSource(runtimeCode, commonSource, serviceCode));
+            }
+        });
+    }
+}
+exports.default = ServiceChunkPlugin;

package/dist/{webpack-config/presets/service/ServiceEntryPlugin.d.ts → presets/configs/minigame/service/serviceEntryPlugin.d.ts}

@@ -1,7 +1,9 @@
 import { Compiler } from 'webpack';
+import { IPresetOptions } from '../../../../types';
 declare class ServiceEntryPlugin {
     entriesCache: Map<string, boolean>;
-    constructor();
+    options: IPresetOptions;
+    constructor(options: IPresetOptions);
     apply(compiler: Compiler): void;
     makeUmdEntry(compiler: Compiler, filename: string, url: string, libraryName: string): void;
 }

package/dist/presets/configs/minigame/service/serviceEntryPlugin.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const webpack_1 = require("webpack");
+const common_1 = require("../../../../utils/common");
+class ServiceEntryPlugin {
+    constructor(options) {
+        this.options = options;
+        this.entriesCache = new Map();
+    }
+    apply(compiler) {
+        new webpack_1.library.EnableLibraryPlugin('umd').apply(compiler);
+        const { project } = this.options;
+        const { appJSON } = project;
+        const subPackages = appJSON.subPackages || [];
+        this.makeUmdEntry(compiler, 'v1/service.js', `mg-entry-loader?entry=${common_1.DEFAULT_ENTRY}!`, `XHS_SERVICE_${common_1.DEFAULT_ENTRY}`);
+        for (const { entry } of subPackages) {
+            this.makeUmdEntry(compiler, (0, common_1.unixJoin)('v1', `${entry}.js`), `mg-entry-loader?entry=${entry}!`, `XHS_SERVICE_${entry}`);
+        }
+    }
+    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/presets/configs/miniprogram/assets/assetsEntryPlugin.d.ts

@@ -0,0 +1,12 @@
+import { IPresetOptions } from '../../../../types';
+import { RawSource, CopyPatterns, ICompiler } from '../../../../packs';
+declare class XhsAssetsPlugin {
+    options: IPresetOptions;
+    copyPatterns: CopyPatterns;
+    constructor(options: IPresetOptions);
+    apply(compiler: ICompiler): void;
+    emitAppJson(compilation: any, appJSON: any): void;
+    emitLegacyAppJSON(compilation: any, legacyAppJSON: any): void;
+    emitJson(compilation: any, path: string, json: RawSource): void;
+}
+export default XhsAssetsPlugin;

package/dist/presets/configs/miniprogram/assets/assetsEntryPlugin.js

@@ -0,0 +1,132 @@
+"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 packs_1 = require("../../../../packs");
+const const_1 = __importDefault(require("../../../../utils/const"));
+class XhsAssetsPlugin {
+    constructor(options) {
+        this.options = options;
+        this.copyPatterns = new packs_1.CopyPatterns();
+    }
+    apply(compiler) {
+        compiler.hooks.compilation.tap('XhsMpAssetsPlugin', compilation => {
+            const { project, packSetting } = this.options;
+            const { appJSON, legacyAppJSON } = project;
+            const usingPackageType = packSetting.usingPackageType;
+            //   app.json
+            if (compilation) {
+                this.emitAppJson(compilation, JSON.parse(JSON.stringify(appJSON)));
+                // 兼容服务端，始终创建 v0/app.json
+                this.emitLegacyAppJSON(compilation, legacyAppJSON);
+            }
+            // app.css 复用
+            compilation.hooks.processAssets.tap({
+                name: 'XhsMpAssetsCommonPlugin',
+                stage: packs_1.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+            }, assets => {
+                // 删除因为 entry 是 app.(wxss|css) 而产生的的 js 文件
+                for (const key of Object.keys(assets)) {
+                    if (key === `${usingPackageType}/${const_1.default.ENTRY_CSS_NAME}.js` ||
+                        key === `${usingPackageType}/${const_1.default.ENTRY_CSS_NAME}.js.map`) {
+                        Reflect.deleteProperty(assets, key);
+                    }
+                }
+                // 复用app.css，copy v2到v1
+                if (packSetting.usingPackageType === 'v2' && packSetting.enableV1) {
+                    if (assets[`${usingPackageType}/app.css`]) {
+                        assets['v1/app.css'] = assets[`${usingPackageType}/app.css`];
+                    }
+                }
+            });
+            // 图片等资源
+            const cache = compilation.getCache('CopyWebpackPlugin');
+            const logger = compilation.getLogger('XhsMpAssetsCopyPlugin');
+            compilation.hooks.processAssets.tapAsync({
+                name: 'XhsMpAssetsCopyPlugin',
+                stage: packs_1.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+            }, (assets, callback) => __awaiter(this, void 0, void 0, function* () {
+                const patterns = [];
+                if (packSetting.enableV2) {
+                    patterns.push({
+                        noErrorOnMissing: true,
+                        from: `**/*.{${const_1.default.ASSETS_EXTS}}`,
+                        to: 'v2',
+                        context: project.projectMiniprogramPath,
+                        globOptions: { gitignore: true }
+                    });
+                }
+                if (packSetting.enableV1) {
+                    patterns.push({
+                        noErrorOnMissing: true,
+                        from: `**/*.{${const_1.default.ASSETS_EXTS}}`,
+                        to: 'v1',
+                        context: project.projectMiniprogramPath,
+                        globOptions: { gitignore: true }
+                    });
+                }
+                yield this.copyPatterns.copy({
+                    compiler,
+                    compilation,
+                    cache,
+                    logger,
+                    patterns
+                });
+                callback();
+            }));
+        });
+    }
+    emitAppJson(compilation, appJSON) {
+        const { project, packSetting } = this.options;
+        const { compilePkgs = [const_1.default.MAIN_PKG] } = packSetting;
+        // const { mainPkg, subPkgs } = packSetting.getCompilePkgsForEntries()
+        // 先删除，用户配置的默认不生效
+        Reflect.deleteProperty(appJSON, 'lazyCodeLoading');
+        if (packSetting.enableVDom) {
+            appJSON.xhsVersionStrategy.enableVDom = true;
+            appJSON.usingFramework = '2.0';
+        }
+        if (packSetting.enableV2) {
+            appJSON.xhsVersionStrategy.lazyCodeLoading = true;
+            appJSON.lazyCodeLoading = 'requiredComponents';
+        }
+        const appJsonSource = new packs_1.RawSource(JSON.stringify(appJSON));
+        // app.json合并了普通分包的json内容，每次都emit
+        if (packSetting.enableV2) {
+            this.emitJson(compilation, 'v2/app.json', appJsonSource);
+        }
+        if (packSetting.enableV1) {
+            this.emitJson(compilation, 'v1/app.json', appJsonSource);
+        }
+        // 独立分包的 app.json
+        const subPkgs = project.getSubPackages().filter(pkg => compilePkgs.includes(pkg.root));
+        subPkgs.forEach(subPkg => {
+            if (subPkg === null || subPkg === void 0 ? void 0 : subPkg.independent) {
+                if (packSetting.enableV2) {
+                    this.emitJson(compilation, `v2/${subPkg.root}/app.json`, appJsonSource);
+                }
+                if (packSetting.enableV1) {
+                    this.emitJson(compilation, `v1/${subPkg.root}/app.json`, appJsonSource);
+                }
+            }
+        });
+    }
+    emitLegacyAppJSON(compilation, legacyAppJSON) {
+        this.emitJson(compilation, 'v0/app.json', new packs_1.RawSource(JSON.stringify(legacyAppJSON)));
+    }
+    emitJson(compilation, path, json) {
+        // @ts-ignore
+        compilation.emitAsset(path, json);
+    }
+}
+exports.default = XhsAssetsPlugin;

package/dist/presets/configs/miniprogram/assets/index.d.ts

@@ -0,0 +1,4 @@
+import type { IPresetOptions } from '../../../../types';
+declare const getAssetsEntry: (options: IPresetOptions) => () => {};
+declare const presetAssets: (chain: any, options: IPresetOptions) => void;
+export { getAssetsEntry, presetAssets };

package/dist/presets/configs/miniprogram/assets/index.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.presetAssets = exports.getAssetsEntry = void 0;
+const css_1 = __importDefault(require("../../../../utils/css"));
+const getSuffixName_1 = require("../../../../utils/getSuffixName");
+const assetsEntryPlugin_1 = __importDefault(require("./assetsEntryPlugin"));
+const const_1 = __importDefault(require("../../../../utils/const"));
+const InjectorPlugin_1 = require("../../../plugins/InjectorPlugin");
+const getAssetsEntry = (options) => () => {
+    const { project, packSetting } = options;
+    const entry = {};
+    entry[`${packSetting.usingPackageType}/${const_1.default.ENTRY_CSS_NAME}`] = `${project.projectMiniprogramPath}/app.${(0, getSuffixName_1.getCssSuffixName)()}`;
+    return entry;
+};
+exports.getAssetsEntry = getAssetsEntry;
+const presetAssets = (chain, options) => {
+    const { packSetting, project } = options;
+    const { distDir, enableV1, enableV2 } = packSetting;
+    const { miniprogramDir } = project;
+    const cssReg = new RegExp(`.${(0, getSuffixName_1.getCssSuffixName)()}$`);
+    chain.merge({
+        output: {
+            path: distDir
+        },
+        // cache: {
+        //   type: 'filesystem',
+        //   cacheDirectory: packSetting.cacheDirectory,
+        // },
+        module: {
+            rule: {
+                [(0, getSuffixName_1.getCssSuffixName)()]: {
+                    test: cssReg,
+                    use: Object.assign({ 'mini-style-loader': {
+                            loader: require.resolve('../../../loaders/mini-style-loader'),
+                            options: Object.assign(Object.assign({}, options), { independent: true })
+                        } }, (0, css_1.default)(options, ['css-loader', 'postcss-loader', 'wxss-loader']))
+                }
+            }
+        }
+    });
+    chain.plugin('InjectorPlugin').use(InjectorPlugin_1.InjectorPlugin, [options]);
+    chain.plugin('XhsMpAssetsPlugin').use(assetsEntryPlugin_1.default, [options]);
+};
+exports.presetAssets = presetAssets;

package/dist/presets/configs/miniprogram/render/component.d.ts

@@ -0,0 +1,3 @@
+import { IPresetOptions } from '../../../../types';
+declare const getComponentEntry: (options: IPresetOptions) => {};
+export { getComponentEntry };