xhs-mp-compiler-cli 1.1.3 → 1.1.5

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/presets/configs/minigame/service/serviceEntryPlugin.d.ts

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

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 };

package/dist/presets/configs/miniprogram/render/component.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getComponentEntry = void 0;
+const xhs_mp_pack_1 = require("xhs-mp-pack");
+const getComponentEntry = (options) => {
+    const entries = {};
+    const { packSetting } = options;
+    // 编译v2
+    if (packSetting.enableV2) {
+        appendV2Entry(options, entries);
+    }
+    // 构建 v1 的包
+    if (packSetting.enableV1) {
+        appendV1Entry(options, entries);
+    }
+    return entries;
+};
+exports.getComponentEntry = getComponentEntry;
+const appendV2Entry = (options, entries) => {
+    const { project, packSetting } = options;
+    const subPackages = project.getSubPackages();
+    const subPackageRoots = subPackages.map(pkg => pkg.root);
+    const componentsMap = project.getComponentsMap();
+    const { mainPkg, subPkgs } = packSetting.getCompilePkgsForEntries();
+    Object.keys(componentsMap).forEach(compPath => {
+        if (mainPkg && project.isFileInMainPkg(compPath)) {
+            entries[`v2/${compPath}`] = `mp-entry-loader?type=component&mode=v2&compPath=${compPath}&pkg=${xhs_mp_pack_1.CONSTANTS.MAIN_PKG}!`;
+        }
+        for (const subPkg of subPkgs) {
+            if (compPath.startsWith(`${subPkg.root}/`)) {
+                const root = subPackageRoots.find(root => compPath.startsWith(`${root}/`));
+                entries[`v2/${root}/${compPath}`] = `mp-entry-loader?type=component&mode=v2&compPath=${compPath}&pkg=${xhs_mp_pack_1.CONSTANTS.SUB_PKG}&root=${root}!`;
+            }
+        }
+    });
+};
+function appendV1Entry(options, entries) {
+    const { packSetting } = options;
+    const { mainPkg, subPkgs } = packSetting.getCompilePkgsForEntries();
+    if (mainPkg) {
+        entries['v1/components'] = `mp-entry-loader?type=component&mode=v1&pkg=${xhs_mp_pack_1.CONSTANTS.MAIN_PKG}!`;
+    }
+    for (const subPkg of subPkgs) {
+        const { root } = subPkg;
+        entries[`v1/${root}/components`] = `mp-entry-loader?type=component&mode=v1&pkg=${xhs_mp_pack_1.CONSTANTS.SUB_PKG}&root=${root}!`;
+    }
+}

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

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

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

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.presetRender = exports.getRenderEntry = void 0;
+const path_1 = __importDefault(require("path"));
+const css_1 = __importDefault(require("../../../../utils/css"));
+const getSuffixName_1 = require("../../../../utils/getSuffixName");
+const sjsEntryPlugin_1 = __importDefault(require("./sjsEntryPlugin"));
+const render_1 = require("./render");
+const component_1 = require("./component");
+const renderChunkPlugin_1 = __importDefault(require("./renderChunkPlugin"));
+const types_1 = require("../../../../types");
+const InjectorPlugin_1 = require("../../../plugins/InjectorPlugin");
+const getRenderEntry = (options) => () => (Object.assign(Object.assign({}, (0, render_1.getRenderEntry)(options)), (0, component_1.getComponentEntry)(options)));
+exports.getRenderEntry = getRenderEntry;
+const presetRender = (chain, options) => {
+    const { packSetting } = options;
+    const { enableVDom, env, distDir, cacheDirectory } = packSetting;
+    const mlReg = new RegExp(`.${(0, getSuffixName_1.getMlSuffixName)()}$`);
+    const cssReg = new RegExp(`.${(0, getSuffixName_1.getCssSuffixName)()}$`);
+    const isProd = env === types_1.ENV.production;
+    chain.merge({
+        externals: { vue: 'vue' },
+        output: {
+            path: distDir,
+            globalObject: 'globalThis',
+            libraryTarget: 'umd',
+            uniqueName: 'MpRender',
+        },
+        cache: {
+            type: 'filesystem',
+            cacheDirectory: path_1.default.join(cacheDirectory, 'render'),
+        },
+        module: {
+            rule: {
+                ml: {
+                    test: mlReg,
+                    use: {
+                        // 'thread-loader': {
+                        //   loader: require.resolve('thread-loader'),
+                        //   options: {
+                        //     workers: require('os').cpus().length,
+                        //   },
+                        // },
+                        'ml-loader': {
+                            loader: require.resolve('xhs-mp-compiler-ml-loader'),
+                            options: {
+                                removeComentNode: isProd,
+                                vdom: enableVDom,
+                            },
+                        },
+                    },
+                },
+                [(0, getSuffixName_1.getCssSuffixName)()]: {
+                    test: cssReg,
+                    use: (0, css_1.default)(options, [
+                        "mini-style-loader",
+                        'postcss-loader',
+                        'wxss-loader',
+                    ]),
+                },
+            },
+        },
+    });
+    chain.plugin('InjectorPlugin').use(InjectorPlugin_1.InjectorPlugin, [options]);
+    chain.plugin('SjsEntryPlugin').use(sjsEntryPlugin_1.default, [options]);
+    chain.plugin("RenderChunkPlugin").use(renderChunkPlugin_1.default, [options]);
+};
+exports.presetRender = presetRender;

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

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

package/dist/presets/configs/miniprogram/render/render.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRenderEntry = void 0;
+const getSuffixName_1 = require("../../../../utils/getSuffixName");
+const xhs_mp_pack_1 = require("xhs-mp-pack");
+const getRenderEntry = (options) => {
+    const entries = {};
+    const { packSetting } = options;
+    if (packSetting.enableV2) {
+        appendV2Entry(options, entries);
+    }
+    if (packSetting.enableV1) {
+        appendV1Entry(options, entries);
+    }
+    return entries;
+};
+exports.getRenderEntry = getRenderEntry;
+const appendV2Entry = (options, entries) => {
+    const { project, packSetting } = options;
+    const projectMiniprogramPath = project.projectMiniprogramPath;
+    const { mainPkg, subPkgs } = packSetting.getCompilePkgsForEntries();
+    if (mainPkg) {
+        const pages = project.getPages();
+        for (const { path } of pages) {
+            entries[`v2/${path}.render`] = `mp-entry-loader?type=render&mode=v2&pkg=${xhs_mp_pack_1.CONSTANTS.MAIN_PKG}!${projectMiniprogramPath}/${path}.${(0, getSuffixName_1.getMlSuffixName)()}`;
+        }
+    }
+    for (const { pages, root } of subPkgs) {
+        for (const { path } of pages) {
+            entries[`v2/${path}.render`] = `mp-entry-loader?type=render&mode=v2&pkg=${xhs_mp_pack_1.CONSTANTS.SUB_PKG}&root=${root}!${projectMiniprogramPath}/${path}.${(0, getSuffixName_1.getMlSuffixName)()}`;
+        }
+    }
+};
+const appendV1Entry = (options, entries) => {
+    const { project, packSetting } = options;
+    const projectMiniprogramPath = project.projectMiniprogramPath;
+    const { mainPkg, subPkgs } = packSetting.getCompilePkgsForEntries();
+    if (mainPkg) {
+        const pages = project.getPages();
+        for (const { path } of pages) {
+            entries[`v1/${path}.render`] = `mp-entry-loader?type=render&mode=v1&pkg=${xhs_mp_pack_1.CONSTANTS.MAIN_PKG}!${projectMiniprogramPath}/${path}.${(0, getSuffixName_1.getMlSuffixName)()}`;
+        }
+    }
+    for (const { pages, root } of subPkgs) {
+        for (const { path } of pages) {
+            entries[`v1/${path}.render`] = `mp-entry-loader?type=render&mode=v1&pkg=${xhs_mp_pack_1.CONSTANTS.SUB_PKG}&root=${root}!${projectMiniprogramPath}/${path}.${(0, getSuffixName_1.getMlSuffixName)()}`;
+        }
+    }
+};

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

@@ -0,0 +1,8 @@
+import { ICompiler } from '../../../../packs';
+import { IPresetOptions } from '../../../../types';
+declare class RenderChunkPlugin {
+    options: IPresetOptions;
+    constructor(options: IPresetOptions);
+    apply(compiler: ICompiler): void;
+}
+export default RenderChunkPlugin;

package/dist/presets/configs/miniprogram/render/renderChunkPlugin.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const packs_1 = require("../../../../packs");
+const injectCSS = `
+globalThis.__XHS_IS_WEBVIEW = (globalThis.localStorage && document && document.querySelectorAll)
+globalThis.__XHS_APPEND_CSS = function(cssText){
+    if (!globalThis.__XHS_IS_WEBVIEW) return;
+    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.options = options;
+    }
+    apply(compiler) {
+        compiler.hooks.compilation.tap(RenderChunkPlugin.name, compilation => {
+            compilation.hooks.processAssets.tap({
+                name: RenderChunkPlugin.name,
+                stage: packs_1.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+            }, assets => {
+                var _a, _b;
+                const { project } = this.options;
+                // 注入css逻辑
+                const injectCode = injectCSS;
+                // @ts-ignore
+                const appJSON = project.appJSON;
+                const pathMap = [
+                    (_a = appJSON.pages) === null || _a === void 0 ? void 0 : _a.map(({ path }) => path),
+                    (_b = appJSON.subPackages) === null || _b === void 0 ? void 0 : _b.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 packs_1.ConcatSource(injectCode, assets[key]));
+                });
+            });
+        });
+    }
+}
+exports.default = RenderChunkPlugin;

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

@@ -0,0 +1,15 @@
+import { Compilation, ICompiler } from '../../../../packs';
+import { IPresetOptions } from '../../../../types';
+declare class SjsEntryPlugin {
+    options: IPresetOptions;
+    entriesCache: Map<string, boolean>;
+    mainpkgPaths: string[];
+    subPackagePaths: Map<string, string[]>;
+    subPackageRoots: string[];
+    constructor(options: IPresetOptions);
+    isFileInMainPkg(filePath: any): boolean;
+    isFileInSubpackage(filePath: any): boolean;
+    apply(compiler: ICompiler): void;
+    makeSjsFileContent(compilation: Compilation, chunkName: string, sjsFiles: string[] | undefined, sjsModuleName: string, pkgRoot?: string): void;
+}
+export default SjsEntryPlugin;