@cloudbase/framework-plugin-low-code 1.7.2 → 1.7.3

package/lib/builder/mp/materials.js

@@ -0,0 +1,338 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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.getWxmlTag = exports.extractUsedCompsRecursively = exports.installMaterials = void 0;
+const path = __importStar(require("path"));
+const util_1 = require("util");
+const fs = __importStar(require("fs-extra"));
+const weapps_core_1 = require("../../weapps-core");
+const config_1 = require("../config");
+const mp_1 = require("../config/mp");
+const util_2 = require("../util");
+const util_3 = require("./util");
+const wxml_1 = require("./wxml");
+const generateFiles_1 = __importDefault(require("../util/generateFiles"));
+const lowcode_1 = require("./lowcode");
+const net_1 = require("../util/net");
+const util_4 = require("../util");
+const junk = __importStar(require("../util/junk"));
+const templateDir = config_1.appTemplateDir + '/mp/';
+function installMaterials(projDir, usedComps, weapps, ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let { materialLibs } = ctx;
+        const weappsList = ctx.isMixMode
+            ? weapps
+            : weapps.filter((item) => !item.rootPath);
+        const localPkg = (0, util_2.getCurrentPackageJson)();
+        yield Promise.all(materialLibs
+            .filter((lib) => !lib.isComposite && usedComps[lib.name])
+            .map((lib) => __awaiter(this, void 0, void 0, function* () {
+            const { name, version, mpPkgUrl } = lib;
+            let materialsSrcDir = '';
+            const materialId = `${name}@${version}`;
+            if (localPkg && localPkg.name === name) {
+                materialsSrcDir = path.join(process.cwd(), 'build', 'mp');
+            }
+            else {
+                materialsSrcDir = path.join(config_1.sharedMaterialsDir, `${name}-mp@${version}`);
+                yield downloadMaterial(mpPkgUrl, materialsSrcDir);
+            }
+            function libUpdated(libDir, version) {
+                const meta = (0, util_4.readComponentLibMata)(libDir);
+                if (!meta) {
+                    return true;
+                }
+                if (meta.version !== lib.version) {
+                    return true;
+                }
+            }
+            const usingMaterialMap = {};
+            yield Promise.all(weappsList.map((app) => __awaiter(this, void 0, void 0, function* () {
+                const targetDir = path.join(projDir, config_1.materialsDirName, name);
+                if (usingMaterialMap[targetDir]) {
+                    return;
+                }
+                else {
+                    usingMaterialMap[targetDir] = true;
+                }
+                const materialsSrcDirPath = path.join(materialsSrcDir, 'src');
+                let dirsToDelete = [];
+                let compGroupIndexJson = {};
+                let componentsJsonUsed = {};
+                if (libUpdated(targetDir, version)) {
+                    if (fs.existsSync(materialsSrcDirPath)) {
+                        console.log(`Copying material ${materialId} from ${materialsSrcDir}/src to ${targetDir}`);
+                        const metaJosnPath = path.join(materialsSrcDir, 'meta.json');
+                        if (fs.existsSync(metaJosnPath)) {
+                            yield fs.copy(metaJosnPath, path.join(targetDir, 'meta.json'));
+                        }
+                        yield fs.copy(materialsSrcDirPath, targetDir, {
+                            filter: function (src, dest) {
+                                return !junk.is(path.basename(src));
+                            },
+                        });
+                    }
+                    else {
+                        console.log(`Copying material ${materialId} from ${materialsSrcDir} to ${targetDir}`);
+                        yield fs.copy(materialsSrcDir, targetDir, {
+                            filter: function (src, dest) {
+                                return !junk.is(path.basename(src));
+                            },
+                        });
+                    }
+                }
+                const libMeta = (0, util_4.readComponentLibMata)(targetDir);
+                if (!lib.components) {
+                    lib.components = Object.keys((libMeta === null || libMeta === void 0 ? void 0 : libMeta.components) || {}).map((name) => {
+                        var _a;
+                        return ({
+                            name,
+                            meta: (_a = libMeta === null || libMeta === void 0 ? void 0 : libMeta.components[name]) === null || _a === void 0 ? void 0 : _a.meta,
+                        });
+                    });
+                }
+                lib.styles = libMeta === null || libMeta === void 0 ? void 0 : libMeta.styles;
+                lib.dependencies = libMeta === null || libMeta === void 0 ? void 0 : libMeta.dependencies;
+            })));
+        })));
+        materialLibs = ctx.materialLibs.filter((lib) => usedComps[lib.name]);
+        ctx.materialLibs = materialLibs;
+        materialLibs.map((lib) => {
+            lib.components = lib.components.filter((comp) => usedComps[lib.name].has(comp.name));
+        });
+        materialLibs.map((lib) => {
+            lib.components.map((comp) => {
+                comp.materialName = lib.name;
+            });
+        });
+        const compositedLibs = materialLibs.filter((lib) => lib.isComposite && usedComps[lib.name]);
+        compositedLibs.map((lib) => {
+            lib.dependencies = lib.dependencies || {};
+            lib.components.map((cmp) => {
+                cmp.meta.syncProps = {};
+                const { dataForm = {} } = cmp;
+                for (const prop in dataForm) {
+                    const { inputProp, syncProp } = dataForm[prop];
+                    if (syncProp || inputProp) {
+                        cmp.meta.syncProps[prop] = syncProp || inputProp;
+                    }
+                }
+                cmp.meta.platforms = {
+                    mp: {
+                        path: cmp.name + '/index',
+                    },
+                };
+                lib.dependencies = Object.assign(Object.assign({}, lib.dependencies), cmp.npmDependencies);
+            });
+        });
+        compositedLibs.map((lib) => __awaiter(this, void 0, void 0, function* () {
+            console.log('Generate composited library ' + lib.name);
+            yield (0, util_4.writeLibCommonRes2file)(lib, path.join(ctx.projDir, config_1.materialsDirName, lib.name, 'libCommonRes'));
+            return lib.components.map((cmp) => {
+                weappsList.forEach((app) => {
+                    generateCompositeComponent(cmp, Object.assign({}, ctx), lib.compLibCommonResource);
+                });
+            });
+        }));
+    });
+}
+exports.installMaterials = installMaterials;
+function extractUsedCompsRecursively(comps, checkedComps, compositedLibs, outputComps) {
+    let usedComps = (outputComps || comps);
+    const libsUsedByApp = Object.keys(comps);
+    libsUsedByApp.forEach((libName) => {
+        const cmpNames = comps[libName];
+        const lib = compositedLibs.find((lib) => lib.name == libName);
+        if (!lib || !lib.isComposite)
+            return;
+        cmpNames.forEach((cmpName) => {
+            const cmp = lib.components.find((c) => c.name === cmpName);
+            if (!cmp) {
+                console.warn('Component not found', libName + ':' + cmpName);
+                return;
+            }
+            if (checkedComps.indexOf(cmp) > -1)
+                return;
+            checkedComps.push(cmp);
+            const cmpsUsedByThisComp = (0, wxml_1.getUsedComponents)(cmp.componentInstances);
+            const libs = Object.keys(cmpsUsedByThisComp);
+            libs.forEach((libName) => {
+                if (!usedComps[libName]) {
+                    usedComps[libName] = cmpsUsedByThisComp[libName];
+                }
+                else {
+                    cmpsUsedByThisComp[libName].forEach((n) => usedComps[libName].add(n));
+                }
+            });
+            extractUsedCompsRecursively(cmpsUsedByThisComp, checkedComps, compositedLibs, usedComps);
+        });
+    });
+    return usedComps;
+}
+exports.extractUsedCompsRecursively = extractUsedCompsRecursively;
+function downloadMaterial(zipUrl, dstFolder) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (fs.existsSync(path.join(dstFolder, 'meta.json')))
+            return;
+        yield (0, net_1.downloadZip)(zipUrl, dstFolder);
+    });
+}
+function generateCompositeComponent(compositedComp, ctx, compLibCommonResource) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { materialName } = compositedComp;
+        const outDir = path.join(ctx.projDir, ctx.rootPath || '', config_1.materialsDirName, materialName, compositedComp.name);
+        console.log(`Generating composited component ${materialName}:${compositedComp.name} to ${outDir}`);
+        const wxmlDataPrefix = (0, mp_1.getWxmlDataPrefix)(!ctx.isProduction);
+        const usingComponents = {};
+        const cmpContainer = Object.values(compositedComp.componentInstances)[0];
+        const wxml = (0, wxml_1.generateWxml)(compositedComp.componentInstances, 'Component ' + materialName + ':' + compositedComp.name, wxmlDataPrefix, Object.assign(Object.assign({}, ctx), { isPage: false }), usingComponents, (cmp, node) => {
+            if (cmp === cmpContainer) {
+                const { attributes } = node;
+                const classAttrName = (0, mp_1.getClassAttrName)(node.name);
+                const oldClass = attributes[classAttrName];
+                attributes[classAttrName] =
+                    (0, weapps_core_1.getCompositedComponentClass)(compositedComp) +
+                        ' ' +
+                        oldClass +
+                        ' {{className}}';
+                attributes.style += ';{{style}}';
+            }
+        });
+        const { syncProps } = compositedComp.meta;
+        const formEvents = {};
+        Object.keys(syncProps).map((prop) => {
+            const config = syncProps[prop];
+            const configs = Array.isArray(config) ? config : [config];
+            configs.forEach(({ changeEvent, valueFromEvent, isFormField }) => {
+                if (isFormField) {
+                    formEvents[changeEvent] = valueFromEvent;
+                }
+            });
+        });
+        const pageFileData = {
+            'index.js': {
+                materialName: materialName,
+                propDefs: compositedComp.dataForm,
+                handlers: compositedComp.lowCodes
+                    .filter((m) => m.type === 'handler-fn' && m.name !== '____index____')
+                    .map((m) => m.name),
+                eventHandlers: (0, util_3.createEventHanlders)(compositedComp.componentInstances, weapps_core_1.COMPONENT_API_PREFIX, ctx),
+                emitEvents: compositedComp.emitEvents.map((evt) => evt.eventName),
+                widgetProps: (0, util_3.createWidgetProps)(compositedComp.componentInstances, ctx),
+                compApi: weapps_core_1.COMPONENT_API_PREFIX,
+                jsonSchemaType2jsClass: mp_1.jsonSchemaType2jsClass,
+                key: compositedComp.materialName + ':' + compositedComp.name,
+                dataBinds: (0, util_3.createDataBinds)(compositedComp.componentInstances, ctx),
+                debug: !ctx.isProduction,
+                stringifyObj: util_1.inspect,
+                formEvents: Object.keys(formEvents).length > 0 ? formEvents : null,
+                config: compositedComp.compConfig,
+            },
+            'index.json': { usingComponents },
+            'index.wxml': {
+                content: wxml,
+            },
+            'index.wxss': {},
+        };
+        yield (0, generateFiles_1.default)(pageFileData, templateDir + '/component', outDir, ctx);
+        const codes = [...compositedComp.lowCodes];
+        if (!codes.find((m) => m.name === 'index')) {
+            codes.push({
+                code: 'export default {}',
+                name: 'index',
+                path: 'index',
+            });
+        }
+        codes
+            .filter((mod) => mod.name !== '____index____')
+            .map((mod) => {
+            let themeCode;
+            if (mod.type === 'style' && compLibCommonResource) {
+                themeCode = `
+         ${compLibCommonResource.theme.variable || ''}
+         ${compLibCommonResource.class || ''}
+         ${compLibCommonResource.theme.class || ''}
+      `;
+            }
+            return (0, lowcode_1.writeCode2file)(mod, path.join(outDir, 'lowcode'), { comp: compositedComp }, themeCode, ctx);
+        });
+    });
+}
+function getWxmlTag(cmp, ctx, nameMangler) {
+    var _a, _b, _c, _d, _e, _f;
+    const { moduleName, name } = cmp;
+    const materialLib = ctx.materialLibs.find((lib) => lib.name === moduleName);
+    const miniprogramPlugin = (_a = ctx.miniprogramPlugins) === null || _a === void 0 ? void 0 : _a.find((plugin) => plugin.name === moduleName);
+    let tagName = name.toLocaleUpperCase();
+    let compPath;
+    const components = (materialLib === null || materialLib === void 0 ? void 0 : materialLib.components) || (miniprogramPlugin === null || miniprogramPlugin === void 0 ? void 0 : miniprogramPlugin.componentConfigs);
+    const findComponent = components === null || components === void 0 ? void 0 : components.find((comp) => comp.name === name);
+    if (!findComponent) {
+        return { tagName };
+    }
+    if (materialLib) {
+        let cmpMeta = (findComponent === null || findComponent === void 0 ? void 0 : findComponent.meta) || { platforms: undefined };
+        if (!cmpMeta.platforms) {
+            return { tagName };
+        }
+        compPath = (_c = (_b = cmpMeta === null || cmpMeta === void 0 ? void 0 : cmpMeta.platforms) === null || _b === void 0 ? void 0 : _b.mp) === null || _c === void 0 ? void 0 : _c.path;
+        if ((_e = (_d = cmpMeta === null || cmpMeta === void 0 ? void 0 : cmpMeta.platforms) === null || _d === void 0 ? void 0 : _d.mp) === null || _e === void 0 ? void 0 : _e.tagName) {
+            tagName = (_f = cmpMeta === null || cmpMeta === void 0 ? void 0 : cmpMeta.platforms) === null || _f === void 0 ? void 0 : _f.mp.tagName;
+        }
+        if (compPath) {
+            const rootPath = ctx.rootPath || '';
+            compPath = compPath.startsWith('/')
+                ? compPath
+                : path.posix.join('', `/${config_1.materialsDirName}/${cmp.moduleName}`, compPath);
+            tagName = `${moduleName}-${name}`;
+            if (nameMangler) {
+                tagName = nameMangler.mangle(tagName);
+            }
+        }
+    }
+    else {
+        compPath = `plugin://${miniprogramPlugin === null || miniprogramPlugin === void 0 ? void 0 : miniprogramPlugin.name}/${name}`;
+        tagName = `${moduleName}-${name}`;
+        if (nameMangler) {
+            tagName = nameMangler.mangle(tagName);
+        }
+    }
+    if (!tagName) {
+        tagName = name.toLocaleUpperCase();
+    }
+    return {
+        tagName,
+        path: compPath,
+    };
+}
+exports.getWxmlTag = getWxmlTag;

package/lib/builder/mp/mixMode.d.ts

@@ -0,0 +1,10 @@
+import { IWeAppData, IPlugin, IMaterialItem } from '../../weapps-core';
+import { IAppUsedComp } from '../types/common';
+export declare function handleMixMode({ apps, generateMpPath, miniprogramRoot, plugins, }: {
+    apps: IWeAppData[];
+    generateMpPath: string;
+    miniprogramRoot: string;
+    plugins: IPlugin[];
+}): Promise<void>;
+export declare function handleMixMaterials(projDir: string, apps: IWeAppData[], appUsedComps: IAppUsedComp[], compositedLibs: IMaterialItem[]): Promise<void[]>;
+//# sourceMappingURL=mixMode.d.ts.map

package/lib/builder/mp/mixMode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mixMode.d.ts","sourceRoot":"","sources":["../../../src/builder/mp/mixMode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAUvE,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAO/C,wBAAsB,aAAa,CAAC,EAClC,IAAS,EACT,cAAc,EACd,eAAe,EACf,OAAY,GACb,EAAE;IACD,IAAI,EAAE,UAAU,EAAE,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,OAAO,EAAE,CAAC;CACpB,iBA6LA;AAGD,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,UAAU,EAAE,EAClB,YAAY,EAAE,YAAY,EAAE,EAC5B,cAAc,EAAE,aAAa,EAAE,mBA0ChC"}

package/lib/builder/mp/mixMode.js

@@ -0,0 +1,215 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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.handleMixMaterials = exports.handleMixMode = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importStar(require("fs-extra"));
+const mp_1 = require("../util/mp");
+const plugin_1 = require("../service/builder/plugin");
+const lodash_1 = __importDefault(require("lodash"));
+const chalk_1 = __importDefault(require("chalk"));
+const generateFiles_1 = require("../util/generateFiles");
+const webpack_1 = require("../service/builder/webpack");
+function handleMixMode({ apps = [], generateMpPath, miniprogramRoot, plugins = [], }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield handleSubApps();
+        yield (0, webpack_1.installDependencies)(miniprogramRoot);
+        yield handlePlugins();
+        function handleMainApp() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const aloneDirs = ['common', 'app', 'lowcode', 'materials'];
+                const dirs = aloneDirs;
+                yield Promise.all(dirs.map((dirname) => __awaiter(this, void 0, void 0, function* () {
+                    const srcDir = path_1.default.join(miniprogramRoot, dirname);
+                    if (yield fs_extra_1.default.pathExists(srcDir)) {
+                        const distDir = path_1.default.join(generateMpPath, dirname);
+                        if (aloneDirs.includes(dirname)) {
+                            yield fs_extra_1.default.remove(distDir);
+                        }
+                        yield fs_extra_1.default.copy(srcDir, distDir);
+                    }
+                })));
+            });
+        }
+        function handleAppPages() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const srcDir = path_1.default.join(miniprogramRoot, 'pages');
+                const distDir = path_1.default.join(generateMpPath, 'pages');
+                const pageList = yield fs_extra_1.default.readdir(srcDir);
+                yield Promise.all(pageList.map((page) => __awaiter(this, void 0, void 0, function* () {
+                    const srcPageDir = path_1.default.join(srcDir, page);
+                    const srcDistDir = path_1.default.join(distDir, page);
+                    if (yield fs_extra_1.default.pathExists(srcDistDir)) {
+                        console.log(chalk_1.default.yellow(`【混合模式】 WeApps 中的 pages/${page} 与小程序 pages/${page} 重复，会以 WeApps 的为主`));
+                    }
+                    yield fs_extra_1.default.copy(srcPageDir, srcDistDir);
+                })));
+            });
+        }
+        function handleSubApps() {
+            return __awaiter(this, void 0, void 0, function* () {
+                let modifiedAppJson = false;
+                const rootAppJosnPath = path_1.default.join(miniprogramRoot, 'app.json');
+                let rootAppJosn = yield fs_extra_1.default.readJSON(rootAppJosnPath);
+                let modifiedPackageJosn = false;
+                const rootPackageJosnPath = path_1.default.join(miniprogramRoot, 'package.json');
+                let rootPackageJson = fs_extra_1.default.existsSync(rootPackageJosnPath)
+                    ? yield fs_extra_1.default.readJson(rootPackageJosnPath)
+                    : {
+                        name: 'WeDa-app',
+                        version: '1.0.0',
+                    };
+                let mergeDependencies = {};
+                yield Promise.all(apps
+                    .filter((app) => app.rootPath)
+                    .map((app) => __awaiter(this, void 0, void 0, function* () {
+                    const subAppPath = path_1.default.join(miniprogramRoot, app.rootPath || '');
+                    const appJsonPath = path_1.default.join(subAppPath, 'app.json');
+                    if (fs_extra_1.default.existsSync(appJsonPath)) {
+                        let appJson = yield fs_extra_1.default.readJson(appJsonPath);
+                        if (appJson) {
+                            let { subpackages = [] } = rootAppJosn;
+                            const find = subpackages.find((item) => item.root == app.rootPath);
+                            if (find) {
+                                find.pages = appJson.pages;
+                            }
+                            else {
+                                if (!rootAppJosn.subpackages) {
+                                    rootAppJosn.subpackages = [];
+                                }
+                                rootAppJosn.subpackages.push({
+                                    root: app.rootPath,
+                                    pages: appJson.pages,
+                                });
+                            }
+                            modifiedAppJson = true;
+                        }
+                    }
+                    const packageJosnPath = path_1.default.join(subAppPath, 'package.json');
+                    if (fs_extra_1.default.existsSync(packageJosnPath)) {
+                        mergeDependencies = Object.assign(Object.assign({}, mergeDependencies), (yield (0, mp_1.mergePackageDependiences)(mergeDependencies, yield fs_extra_1.default.readJson(packageJosnPath))));
+                        modifiedPackageJosn = true;
+                    }
+                    yield Promise.all([
+                        'app.json',
+                        'app.js',
+                        'app.wxss',
+                        'project.config.json',
+                        'package.json',
+                        'node_modules',
+                        'miniprograme_npm',
+                    ].map((name) => {
+                        let clearPath = path_1.default.join(subAppPath, name);
+                        return name.includes('.')
+                            ? (0, generateFiles_1.removeFile)(clearPath)
+                            : (0, generateFiles_1.cleanDir)(clearPath, []);
+                    }));
+                })));
+                if (modifiedAppJson) {
+                    yield (0, fs_extra_1.writeFile)(rootAppJosnPath, JSON.stringify(rootAppJosn, undefined, 2));
+                }
+                if (modifiedPackageJosn) {
+                    yield (0, fs_extra_1.writeFile)(rootPackageJosnPath, JSON.stringify(Object.assign(Object.assign({}, rootPackageJson), (0, mp_1.mergePackageDependiences)(mergeDependencies, rootPackageJson)), undefined, 2));
+                }
+            });
+        }
+        function handlePlugins() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const mpPlugins = (yield (0, plugin_1.getPluginType)(generateMpPath, plugins)).filter((item) => item.type === 'mp');
+                return Promise.all(mpPlugins.map((plugin) => __awaiter(this, void 0, void 0, function* () {
+                    const pluginModule = plugin.module;
+                    const pluginNodeModuleDir = path_1.default.resolve(generateMpPath, 'node_modules', pluginModule);
+                    const pluginPkgJson = yield fs_extra_1.default.readJson(path_1.default.join(pluginNodeModuleDir, 'package.json'));
+                    const { pluginName } = pluginPkgJson;
+                    const pluginDir = path_1.default.join(miniprogramRoot, pluginName);
+                    const distDir = path_1.default.join(generateMpPath, pluginName);
+                    yield fs_extra_1.default.copy(pluginDir, distDir, { overwrite: true });
+                })));
+            });
+        }
+        function handleAppJson() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const baseAppJsonPath = path_1.default.join(generateMpPath, 'app.json');
+                const mergeAppJsonPath = path_1.default.join(miniprogramRoot, 'app.json');
+                yield (0, mp_1.mergePages)(baseAppJsonPath, mergeAppJsonPath);
+                yield (0, mp_1.mergeSubPackages)(baseAppJsonPath, mergeAppJsonPath);
+            });
+        }
+        function handlePkgJson() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const basePkgJsonPath = path_1.default.join(generateMpPath, 'package.json');
+                const mergePkgJsonPath = path_1.default.join(miniprogramRoot, 'package.json');
+                yield (0, mp_1.mergePackageJson)(basePkgJsonPath, mergePkgJsonPath);
+            });
+        }
+    });
+}
+exports.handleMixMode = handleMixMode;
+function handleMixMaterials(projDir, apps, appUsedComps, compositedLibs) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return Promise.all(apps.map((app) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const rootPath = app.rootPath || '';
+            const materialsDirPath = path_1.default.join(projDir, rootPath, 'materials');
+            const usedComps = ((_a = appUsedComps.find((item) => item.rootPath === rootPath)) === null || _a === void 0 ? void 0 : _a.usedComps) ||
+                {};
+            const materialsLib = yield readDirs(materialsDirPath);
+            const cleanLibs = lodash_1.default.difference(materialsLib, Object.keys(usedComps));
+            yield removeDirs(cleanLibs.map((libName) => path_1.default.join(materialsDirPath, libName)));
+            yield Promise.all(Object.keys(usedComps).map((libName) => __awaiter(this, void 0, void 0, function* () {
+                if (!compositedLibs.find((item) => item.name === libName)) {
+                    return;
+                }
+                const libComponents = usedComps[libName];
+                const materialsLibComps = yield readDirs(path_1.default.join(materialsDirPath, libName));
+                const cleanComps = lodash_1.default.difference(materialsLibComps, Array.from(libComponents));
+                yield removeDirs(cleanComps.map((compName) => path_1.default.join(materialsDirPath, libName, compName)));
+            })));
+        })));
+    });
+}
+exports.handleMixMaterials = handleMixMaterials;
+function removeDirs(dirs) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return Promise.all(dirs.map((dir) => {
+            console.log('【MIX MODE 清理】', dir);
+            return fs_extra_1.default.remove(dir);
+        }));
+    });
+}
+function readDirs(dirPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const isDirectory = (source) => (0, fs_extra_1.lstatSync)(source).isDirectory();
+        return ((yield fs_extra_1.default.readdir(dirPath)) || []).filter((name) => isDirectory(path_1.default.join(dirPath, name)));
+    });
+}

package/lib/builder/mp/mp_config.d.ts

@@ -0,0 +1,18 @@
+import { IWeAppData } from '../../weapps-core';
+import { IBuildContext } from './BuildContext';
+export declare function generateMpConfig(weapps: IWeAppData[], ctx: IBuildContext): {
+    appConfig: any;
+    projConfig: any;
+    pageConfigs: {}[];
+};
+interface ISubpackage {
+    root: string;
+    pages?: string[];
+    plugins?: Record<string, {
+        version?: string;
+        provider?: string;
+    }>;
+}
+export declare function mergeSubPackages(base?: ISubpackage[], extra?: ISubpackage[]): ISubpackage[];
+export {};
+//# sourceMappingURL=mp_config.d.ts.map

package/lib/builder/mp/mp_config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mp_config.d.ts","sourceRoot":"","sources":["../../../src/builder/mp/mp_config.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAA8B,MAAM,mBAAmB,CAAC;AAC3E,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAW/C,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,GAAG,EAAE,aAAa;;;;EAoGxE;AAyFD,UAAU,WAAW;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACnE;AAED,wBAAgB,gBAAgB,CAC9B,IAAI,GAAE,WAAW,EAAO,EACxB,KAAK,GAAE,WAAW,EAAO,iBAoB1B"}