@cloudbase/cals 1.0.50 → 1.0.52-alpha.0

package/lib/parser/dependiencies/index.js

@@ -0,0 +1,674 @@
+"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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Dependencies_instances, _Dependencies_schema, _Dependencies_capiRequest, _Dependencies_lowcodeRequest, _Dependencies_cals, _Dependencies_compositeGroupId, _Dependencies_compositeComponentId, _Dependencies_options, _Dependencies_actualUsedDependencies, _Dependencies_resolveComposititeComponentData;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dependencies = void 0;
+// import { CompositeGroupList, SharedCompositeGroupList } from './mock';
+const utils_1 = require("../../utils");
+const X_RUNTIME_DEFAULT = 'x-runtime-default';
+// import { CONST_COMPONENT_MAP } from 'const/component';
+const CONST_COMPONENT_MAP = {};
+const COMPONENT_META_MAP = {};
+const isSemver = (version) => {
+    const SERVEM_REG = /^([0-9])+\.([0-9]+)\.([0-9]+)$/;
+    return version.match(SERVEM_REG);
+};
+class Dependencies {
+    constructor({ request = {}, cals, compositeGroupId, compositeComponentId, }, options = {}) {
+        _Dependencies_instances.add(this);
+        _Dependencies_schema.set(this, []);
+        _Dependencies_capiRequest.set(this, void 0);
+        _Dependencies_lowcodeRequest.set(this, void 0);
+        _Dependencies_cals.set(this, void 0);
+        _Dependencies_compositeGroupId.set(this, void 0);
+        _Dependencies_compositeComponentId.set(this, void 0);
+        _Dependencies_options.set(this, void 0);
+        _Dependencies_actualUsedDependencies.set(this, void 0);
+        __classPrivateFieldSet(this, _Dependencies_cals, cals, "f");
+        __classPrivateFieldSet(this, _Dependencies_compositeGroupId, compositeGroupId, "f");
+        __classPrivateFieldSet(this, _Dependencies_compositeComponentId, compositeComponentId, "f");
+        __classPrivateFieldSet(this, _Dependencies_options, options, "f");
+        const { capiRequest, lowcodeRequest } = request;
+        if (capiRequest) {
+            __classPrivateFieldSet(this, _Dependencies_capiRequest, capiRequest, "f");
+        }
+        if (lowcodeRequest) {
+            __classPrivateFieldSet(this, _Dependencies_lowcodeRequest, lowcodeRequest, "f");
+        }
+        return this;
+    }
+    static diffDependencies(source, target, whiteList = []) {
+        const diff = {};
+        const rollbackDiff = {};
+        const sourceMap = (0, utils_1.processDependenciesVersionMap)(source);
+        const targetMap = (0, utils_1.processDependenciesVersionMap)(target);
+        whiteList === null || whiteList === void 0 ? void 0 : whiteList.forEach((libKey) => {
+            const current = sourceMap[`${utils_1.WEDA_OFFICIAL_NAMESPACE}${libKey}`] || sourceMap[libKey];
+            const target = targetMap[`${utils_1.WEDA_OFFICIAL_NAMESPACE}${libKey}`] || targetMap[libKey];
+            if (current && target && isSemver(current) && isSemver(target)) {
+                if ((0, utils_1.semverComp)(target, current) > 0) {
+                    // 只有当版本号都是sēmver格式的时候才进行对比并根据策略提示升级否则直接升级
+                    if (!isMajorVersionEqual(current, target)) {
+                        diff[libKey] = utils_1.SEMVER_VERSION_TAG.MAJOR;
+                    }
+                    else if (!isMinorVersionEqual(current, target)) {
+                        diff[libKey] = utils_1.SEMVER_VERSION_TAG.MINOR;
+                    }
+                }
+                else if ((0, utils_1.semverComp)(current, target) > 0) {
+                    // 降级的时候，判断如果拉取最新的gsd-h5-react组件版本的中版本号低于当前组件版本，不自动降级
+                    if (!isMajorVersionEqual(current, target)) {
+                        rollbackDiff[libKey] = utils_1.SEMVER_VERSION_TAG.MAJOR;
+                    }
+                    else if (!isMinorVersionEqual(current, target)) {
+                        rollbackDiff[libKey] = utils_1.SEMVER_VERSION_TAG.MINOR;
+                    }
+                }
+            }
+        });
+        return { diff, rollbackDiff };
+    }
+    static normalizeDependencies(dependencies) {
+        const prefixDep = {};
+        Object.keys(dependencies).forEach((key) => {
+            const value = dependencies[key].indexOf(`${utils_1.WEDA_COMP_DEPENDENCIES_PREFIX}`) === 0
+                ? dependencies[key]
+                : `${utils_1.WEDA_COMP_DEPENDENCIES_PREFIX}?v=${dependencies[key]}`;
+            // 如果是官方组件库并且没有前缀
+            if (utils_1.OFFICIAL_LIBS.indexOf(key) > -1 && key.indexOf(utils_1.WEDA_OFFICIAL_NAMESPACE) === -1) {
+                prefixDep[`${utils_1.WEDA_OFFICIAL_NAMESPACE}${key}`] = value;
+            }
+            else {
+                prefixDep[key] = value;
+            }
+        });
+        return prefixDep;
+    }
+    static loadProdMaterial({ name: materialName, title, controlJsPath, controlCssPath, components: materialComponents, isComposite = false, 
+    // @ts-ignore
+    justRelyOn = false, // 不进行显示，仅仅是可显示的组件库的依赖库
+     }, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!isComposite) {
+                    // 普通组件
+                    const [{ lcds, components, plugins, actions }] = yield Promise.all([
+                        loadProdMetaScript(materialName, controlJsPath),
+                        loadProdMetaStyle(materialName, controlCssPath),
+                    ]);
+                    return handleLcdsCompPluginsActions({
+                        materialName,
+                        lcds,
+                        components,
+                        plugins,
+                        title,
+                        actions,
+                        materialComponents,
+                    });
+                } // 组合组件
+                let components = materialComponents.map((cItem) => {
+                    const result = Object.assign(Object.assign({}, cItem), { sourceKey: `${materialName}:${cItem.name}`, materialName, name: cItem.name || cItem.meta.title, title, 
+                        // @ts-ignore
+                        meta: Object.assign(Object.assign({}, cItem.meta), { inputProps: extractInputProps(cItem.dataForm) }), justRelyOn });
+                    // @ts-ignore
+                    // handleComponent(result);
+                    return result;
+                });
+                // 如果是复合组件编辑器，过滤掉本身正在编辑的组件（即当前不支持嵌套）
+                components = components.filter((item) => `${item.id}` !== (options === null || options === void 0 ? void 0 : options.compositeComponentId));
+                // compositeComponentsMap[materialName] = components;
+                const ret = { components, plugins: [], actions: [], name: materialName, title };
+                return ret;
+            }
+            catch (e) {
+                return { materialName, title, error: typeof e === 'string' ? e : e.message || '', components: [] };
+            }
+        });
+    }
+    /**
+     * 处理 component schema
+     * 用于补充设计态相关字段
+     */
+    processCompnent(component) {
+        /**
+         * 如果组件层级中有 `x-runtime-default` 字段，取其值自动设置 `default` 字段
+         * 函数存在副作用
+         * 修改了component 的 item
+         */
+        recursiveTraverse(component, (item) => {
+            if (typeof item === 'object' && item && X_RUNTIME_DEFAULT in item && !('default' in item)) {
+                item.default = item[X_RUNTIME_DEFAULT];
+                // if (!state.meta.hasRuntimeDefault) {
+                //   state.meta.hasRuntimeDefault = true;
+                // }
+            }
+            else if (typeof item === 'object' && item && item['x-component'] === 'page-params') {
+                item.items = {
+                    type: 'object',
+                    properties: {
+                        key: {
+                            type: 'string',
+                            title: '参数名',
+                        },
+                        value: {
+                            type: 'string',
+                            title: '参数值',
+                        },
+                    },
+                };
+                item['x-title-help'] = "参数绑定格式:```[{key:'参数名',value:'参数值'}]```";
+            }
+        });
+        if (COMPONENT_META_MAP[component.sourceKey] && component.meta && /[a-zA-Z]/.test(component.meta.title)) {
+            component.meta = Object.assign(Object.assign({}, component.meta), COMPONENT_META_MAP[component.sourceKey]);
+        }
+        return component;
+    }
+    useLatestDependiencies(latestCompositeGroupList) {
+        var _a, _b;
+        return ((_b = (_a = __classPrivateFieldGet(this, _Dependencies_options, "f")).useLatestDependiencies) === null || _b === void 0 ? void 0 : _b.call(_a, latestCompositeGroupList)) || false;
+    }
+    onCalsDependenciesChange(dependencies) {
+        return __classPrivateFieldGet(this, _Dependencies_options, "f").onCalsDependenciesChange(dependencies);
+    }
+    /**
+     * 核心逻辑。获取组件物料，主要做了以下事情：
+     * 1、加载组件库最新列表
+     * 2、用户组件库立刻加载
+     * 2、官方组件库不加载
+     */
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            /**
+             * 1. 获取最新的组件库
+             */
+            const { Data } = yield this.DescribeLatestCompositeGroupList({ WeAppId: __classPrivateFieldGet(this, _Dependencies_cals, "f").id });
+            const { List: latestCompositeGroupList = [] } = Data;
+            const OFFICIAL_LIB_SET = new Set(utils_1.OFFICIAL_LIBS);
+            const dependenciesVersionMap = (0, utils_1.processDependenciesVersionMap)(Object.assign(Object.assign({}, utils_1.BASE_CALS_DEPENDENCIES), __classPrivateFieldGet(this, _Dependencies_cals, "f").dependencies));
+            // 2、根据对比结果，获取对应组件库的组件
+            let compositeGroupList = [];
+            if (!this.useLatestDependiencies(latestCompositeGroupList)) {
+                // a.如果存在任意一个官方组件库不同，则加载应用的版本
+                // b.如果拉取最新的gsd-h5-react组件版本的中版本号低于当前组件版本，则加载应用版本
+                const officialCompositeGroupMeta = [];
+                latestCompositeGroupList.forEach((compositeGroup) => {
+                    if (OFFICIAL_LIB_SET.has(compositeGroup.GroupName)) {
+                        const version = dependenciesVersionMap[`${utils_1.WEDA_OFFICIAL_NAMESPACE}${compositeGroup.GroupName}`] ||
+                            dependenciesVersionMap[compositeGroup.GroupName];
+                        officialCompositeGroupMeta.push({ Id: compositeGroup.Id, GroupVersion: version });
+                    }
+                    else {
+                        compositeGroupList.push(compositeGroup);
+                    }
+                });
+                const { Data: { List: officialCompositeGroupMetaList = [] }, } = yield this._DescribeCompositeGroupList({ GroupList: officialCompositeGroupMeta });
+                if (!__classPrivateFieldGet(this, _Dependencies_options, "f").autoUpgradeToLatestPatchVersion) {
+                    compositeGroupList.push(...officialCompositeGroupMetaList);
+                }
+                else {
+                    const patchGroupMeta = [];
+                    officialCompositeGroupMetaList.forEach((compGroup) => {
+                        if (
+                        // 有tinyPrimeVersion 并且 tinyPrimeVersion 不等于当前版本
+                        typeof compGroup.TinyPrimeVersion === 'string' &&
+                            compGroup.TinyPrimeVersion.length > 0 &&
+                            compGroup.TinyPrimeVersion !== compGroup.Version) {
+                            // 手机需要 patch 的版本
+                            patchGroupMeta.push({ Id: compGroup.Id, GroupVersion: compGroup.TinyPrimeVersion });
+                        }
+                        else {
+                            // 无需 path 直接使用查找的数据不重复查询
+                            compositeGroupList.push(compGroup);
+                        }
+                    });
+                    if (patchGroupMeta.length) {
+                        const { Data: { List: patchGroupList = [] }, } = yield this._DescribeCompositeGroupList({ GroupList: patchGroupMeta });
+                        compositeGroupList.push(...patchGroupList);
+                    }
+                }
+            }
+            else {
+                compositeGroupList = latestCompositeGroupList;
+            }
+            __classPrivateFieldSet(this, _Dependencies_actualUsedDependencies, Dependencies.normalizeDependencies(compositeGroupList.reduce((acc, cur) => {
+                acc[cur.GroupName] = cur.Version;
+                return acc;
+            }, {})), "f");
+            this.onCalsDependenciesChange(__classPrivateFieldGet(this, _Dependencies_actualUsedDependencies, "f"));
+            let materials = yield __classPrivateFieldGet(this, _Dependencies_instances, "m", _Dependencies_resolveComposititeComponentData).call(this, __classPrivateFieldGet(this, _Dependencies_cals, "f").id, compositeGroupList, {
+                compositeGroupId: __classPrivateFieldGet(this, _Dependencies_compositeGroupId, "f"),
+            });
+            /**
+             * 3、兜底逻辑，获取 gsd-h5-react
+             * @deprecated
+             */
+            // if (!materials.find((m) => m.name === OFFICIAL_MATERIAL_LIB_NAME)) {
+            //   const { materialErr, materialData } = await getOffcialMaterial();
+            //   if (materialErr) {
+            //     materialErr.message = `[listMaterials]${parseRequestErrorMessage(materialErr)}`;
+            //     dispatch.common.updateLoadStatus({ materialDataLoadError: materialErr || new Error('无组件库加载成功') });
+            //     return;
+            //   }
+            //   materials.push(...materialData);
+            // }
+            // 4、转换数据格式，铺平所有组件
+            const prodMaterialResult = yield Promise.all(materials.map((info) => Dependencies.loadProdMaterial(info, { compositeComponentId: __classPrivateFieldGet(this, _Dependencies_compositeComponentId, "f") })));
+            const materialResult = _getMaterialData(materials, prodMaterialResult, this.processCompnent);
+            __classPrivateFieldSet(this, _Dependencies_schema, materialResult.dependencies || [], "f");
+            return materialResult;
+        });
+    }
+    DescribeLatestCompositeGroupList({ WeAppId }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [{ Data: { List: compositeGroup = [] }, }, { Data: { List: sharedCompositeGroup = [] }, },] = yield Promise.all([
+                this._DescribeCompositeGroupList({ WeAppId }),
+                this._DescribeShareCompGroups({ WeAppId }).catch((e) => {
+                    return {
+                        Data: { Count: 0, List: [] },
+                    };
+                }),
+            ]);
+            const COMPOSITE_MAP = compositeGroup.reduce((map, item) => {
+                map[item.GroupName] = true;
+                return map;
+            }, {});
+            sharedCompositeGroup.forEach((item) => {
+                if (item.GroupName && !COMPOSITE_MAP[item.GroupName]) {
+                    compositeGroup.push(item);
+                }
+            });
+            return { Data: { List: compositeGroup } };
+        });
+    }
+    get schema() {
+        return __classPrivateFieldGet(this, _Dependencies_schema, "f");
+    }
+    _DescribeCompositeGroupList(data, opts = undefined) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('need to impl _DescribeCompositeGroupList');
+        });
+    }
+    _DescribeShareCompGroups(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('need to impl _DescribeShareCompGroups');
+            // return { Data: SharedCompositeGroupList };
+        });
+    }
+    _DescribeCompositeContent(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('need to impl _DescribeCompositeContent');
+        });
+    }
+}
+exports.Dependencies = Dependencies;
+_Dependencies_schema = new WeakMap(), _Dependencies_capiRequest = new WeakMap(), _Dependencies_lowcodeRequest = new WeakMap(), _Dependencies_cals = new WeakMap(), _Dependencies_compositeGroupId = new WeakMap(), _Dependencies_compositeComponentId = new WeakMap(), _Dependencies_options = new WeakMap(), _Dependencies_actualUsedDependencies = new WeakMap(), _Dependencies_instances = new WeakSet(), _Dependencies_resolveComposititeComponentData = function _Dependencies_resolveComposititeComponentData(appId, componentGroups, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { compositeGroupId } = options || {};
+        const compData = [];
+        yield Promise.all(componentGroups.map((group) => __awaiter(this, void 0, void 0, function* () {
+            // compositeGroup/list 只能获取到发布prod情况下的组件库信息
+            const { Id: id, Title, GroupName: groupName, Version: version, Content, PrivateCosPrefix: privateCosPrefix, PublicCosPrefix: publicCosPrefix, IsShare, } = group;
+            const obj = {
+                id,
+                version,
+                originName: groupName,
+                name: groupName,
+                title: Title || groupName,
+                components: [],
+                isComposite: true,
+                content: Content ? JSON.parse(Content) : undefined,
+                publicCosPrefix,
+                privateCosPrefix,
+            };
+            // 获取复合组件库的组件列表
+            // dev=true代表获取未发布的组件详情
+            // 目前支持在组件编辑器中，调试同一个库里的未发布的组件
+            // 官方组件库，在组件编辑器里，直接拉取线上，方便刷库@zijie
+            const dev = groupName === utils_1.OFFICIAL_COMPONENT_LIB_NAME ? false : compositeGroupId === obj.id;
+            let data;
+            try {
+                data = yield this._DescribeCompositeContent({
+                    CompositeGroupId: obj.id,
+                    WeAppId: appId,
+                    Version: version,
+                    IsShare,
+                    Dev: dev,
+                });
+            }
+            catch (e) { }
+            if (data === null || data === void 0 ? void 0 : data.Count) {
+                let isMixed = false;
+                let newContent = data.Content || obj.content;
+                const newPublicCosPrefix = data.PublicCosPrefix || publicCosPrefix;
+                const newPrivateCosPrefix = data.PrivateCosPrefix || privateCosPrefix;
+                // 在组件编辑器，可以获取到同一个库的未发布即dev的组件
+                // 利用compositeComp/list 更新相关信息
+                Object.assign(obj, {
+                    content: newContent,
+                    publicCosPrefix: newPublicCosPrefix,
+                    privateCosPrefix: newPrivateCosPrefix,
+                    mainCssPath: `${newPublicCosPrefix}build/dist/comps.complex.main.css`,
+                    mainJsPath: `${newPublicCosPrefix}build/dist/comps.complex.main.js`,
+                });
+                if (!newContent) {
+                    // 纯JSON组件库，不需要进行分拆
+                    obj.components = data.Components;
+                    if (id === 'cg-jgjmnsvid6ot' && version === '1612432272646') {
+                        const find = {};
+                        // eslint-disable-next-line no-restricted-syntax
+                        for (const index in obj.components) {
+                            if (!isNaN(Number(index))) {
+                                const { name, groupName } = obj.components[Number(index)];
+                                const sourceKey = `${groupName}:${name}`;
+                                switch (sourceKey) {
+                                    case `${utils_1.OFFICIAL_COMPONENT_LIB_NAME}:FormRegion`:
+                                    case `${utils_1.OFFICIAL_COMPONENT_LIB_NAME}:GridLayout`: {
+                                        if (CONST_COMPONENT_MAP[sourceKey]) {
+                                            obj.components[index] = CONST_COMPONENT_MAP[sourceKey];
+                                            find[sourceKey] = true;
+                                        }
+                                        break;
+                                    }
+                                    case `${utils_1.OFFICIAL_COMPONENT_LIB_NAME}:TabBarItem`:
+                                    case `${utils_1.OFFICIAL_COMPONENT_LIB_NAME}:Media`:
+                                    case `${utils_1.OFFICIAL_COMPONENT_LIB_NAME}:Icon`:
+                                    case `${utils_1.OFFICIAL_COMPONENT_LIB_NAME}:SlotMachine`:
+                                    case `${utils_1.OFFICIAL_COMPONENT_LIB_NAME}:Form`:
+                                    case `${utils_1.OFFICIAL_COMPONENT_LIB_NAME}:FormItem`:
+                                    case `${utils_1.OFFICIAL_COMPONENT_LIB_NAME}:FormDate`:
+                                    case `${utils_1.OFFICIAL_COMPONENT_LIB_NAME}:ItemList`:
+                                    case `${utils_1.OFFICIAL_COMPONENT_LIB_NAME}:Item`:
+                                    case `${utils_1.OFFICIAL_COMPONENT_LIB_NAME}:TabBar`:
+                                    case `${utils_1.OFFICIAL_COMPONENT_LIB_NAME}:NavBar`:
+                                    case `${utils_1.OFFICIAL_COMPONENT_LIB_NAME}:FormSelect`:
+                                    case `${utils_1.OFFICIAL_COMPONENT_LIB_NAME}:Classification`: {
+                                        if (CONST_COMPONENT_MAP[sourceKey]) {
+                                            obj.components[index] = CONST_COMPONENT_MAP[sourceKey];
+                                        }
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                        if (!find[`${utils_1.OFFICIAL_COMPONENT_LIB_NAME}:GridLayout`] &&
+                            CONST_COMPONENT_MAP[`${utils_1.OFFICIAL_COMPONENT_LIB_NAME}:GridLayout`]) {
+                            obj.components.push(CONST_COMPONENT_MAP[`${utils_1.OFFICIAL_COMPONENT_LIB_NAME}:GridLayout`]);
+                        }
+                        if (!find[`${utils_1.OFFICIAL_COMPONENT_LIB_NAME}:FormRegion`] &&
+                            CONST_COMPONENT_MAP[`${utils_1.OFFICIAL_COMPONENT_LIB_NAME}:FormRegion`]) {
+                            obj.components.push(CONST_COMPONENT_MAP[`${utils_1.OFFICIAL_COMPONENT_LIB_NAME}:FormRegion`]);
+                        }
+                    }
+                    // 纯json库也需要加上 分库的后缀，官方组件库除外
+                    ![utils_1.OFFICIAL_COMPONENT_LIB_NAME, 'weda_standard'].includes(groupName) && (obj.name += utils_1.SPINOFF_SUFFIX);
+                    compData.push(obj);
+                }
+                else {
+                    // 新版组件库，控制台入口是打平code和json组件，在编辑器runtime和builder
+                    // 需要拆分成json和code，适配之前的模式;
+                    const codeComp = [];
+                    const jsonComp = [];
+                    const { actions, manifestMap, sourceMap } = newContent;
+                    const { controlJs, mainCss, mainJs } = manifestMap;
+                    const { source, mpSource } = sourceMap;
+                    const controlJsPath = newPublicCosPrefix + controlJs;
+                    const mainCssPath = newPublicCosPrefix + mainCss;
+                    const mainJsPath = newPublicCosPrefix + mainJs;
+                    const mpPkgUrl = mpSource && newPrivateCosPrefix + mpSource;
+                    const sourceZipPath = newPrivateCosPrefix + source;
+                    const codeLibObj = Object.assign({}, obj, {
+                        actions,
+                        isComposite: false,
+                        controlJsPath,
+                        mainCssPath,
+                        mainJsPath,
+                        mpPkgUrl,
+                        sourceZipPath,
+                    });
+                    // 组件库里有json组件和code组件，需要分拆两个库
+                    data.Components.forEach((comp) => {
+                        if (comp.ctype === 1) {
+                            // code 组件
+                            codeComp.push(comp);
+                        }
+                        else if (comp.ctype === 2) {
+                            // json 组件
+                            jsonComp.push(comp);
+                            isMixed = true;
+                        }
+                    });
+                    obj.components = jsonComp;
+                    isMixed && (obj.name += utils_1.SPINOFF_SUFFIX);
+                    codeLibObj.components = codeComp;
+                    compData.push(codeLibObj);
+                    if (jsonComp.length > 0) {
+                        compData.push(Object.assign(Object.assign({}, obj), { mainCssPath: `${newPublicCosPrefix}build/dist/comps.complex.main.css`, mainJsPath: `${newPublicCosPrefix}build/dist/comps.complex.main.js` }));
+                        obj.components = jsonComp;
+                        isMixed && (obj.name += utils_1.SPINOFF_SUFFIX);
+                        codeLibObj.components = codeComp;
+                        compData.push(codeLibObj);
+                        if (jsonComp.length > 0) {
+                            compData.push(Object.assign(Object.assign({}, obj), { mainCssPath: `${newPublicCosPrefix}build/dist/comps.complex.main.css`, mainJsPath: `${newPublicCosPrefix}build/dist/comps.complex.main.js` }));
+                        }
+                    }
+                }
+            }
+        })));
+        return compData;
+    });
+};
+function loadProdMetaScript(bundleName, filename) {
+    return new Promise((resolve, reject) => {
+        const script = document.createElement('script');
+        script.setAttribute('src', filename);
+        script.setAttribute('class', '@weapps-materials-control');
+        script.addEventListener('load', () => {
+            const moduleName = `@weapps-materials-control-${bundleName}`;
+            if (Object.prototype.hasOwnProperty.call(window, moduleName)) {
+                const value = window[moduleName];
+                return resolve(value);
+            }
+            return reject(new Error(`meta bundle [${bundleName}] must build with UMD`));
+        });
+        script.addEventListener('error', (e) => reject(`meta bundle [${bundleName}] load failed: ${(e === null || e === void 0 ? void 0 : e.message) || ''}`));
+        document.body.appendChild(script);
+    });
+}
+function loadProdMetaStyle(bundleName, filename, entryDoc = document, isLess = false) {
+    if (!filename) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+        const link = document.createElement('link');
+        link.type = 'text/css';
+        link.rel = isLess ? 'stylesheet/less' : 'stylesheet';
+        link.className = '@weapps-materials-style';
+        link.href = filename;
+        link.addEventListener('load', () => resolve());
+        link.addEventListener('error', (e) => {
+            console.warn(`Load [${bundleName}] meta style failed, skip...`, e);
+            resolve();
+        });
+        entryDoc.head.appendChild(link);
+    });
+}
+function handleLcdsCompPluginsActions({ materialName, lcds, components, plugins, actions, title, materialComponents = null, }) {
+    components.forEach((i) => {
+        var _a;
+        i.sourceKey = `${materialName}:${i.name}`;
+        i.materialName = materialName;
+        const { icon, description } = i.meta;
+        if (materialComponents) {
+            const { platform } = i.meta;
+            i.meta = Object.assign(Object.assign(Object.assign({}, i.meta), (((_a = materialComponents.find((c) => c.name === i.name)) === null || _a === void 0 ? void 0 : _a.meta) || {})), { description });
+            i.meta.platform = platform ? platform : i.meta.platform;
+            i.meta.platform = i.meta.platform || [];
+        }
+        if (icon === null || icon === void 0 ? void 0 : icon.startsWith('data:')) {
+            i.meta.icon = icon;
+        }
+        // handleComponent(i);
+    });
+    plugins.forEach((i) => {
+        i.sourceKey = `${materialName}:${i.name}`;
+        i.materialName = materialName;
+    });
+    actions.forEach((i) => {
+        i.sourceKey = `${materialName}:${i.name}`;
+        i.materialName = materialName;
+        i.type = utils_1.ActionType.Material;
+    });
+    return { lcds, components, plugins, actions, title, name: materialName };
+}
+function _getMaterialData(materials, prodMaterialResult, processCompnent) {
+    var _a;
+    const componentMethodList = {};
+    let { successMaterialList: finalMaterialList } = prodMaterialResult.reduce((acc, item) => {
+        if (!item.error) {
+            acc.successMaterialList.push(item);
+        }
+        else {
+            console.log('pull prod material error:', item.error);
+        }
+        return acc;
+    }, {
+        successMaterialList: [],
+    });
+    finalMaterialList = finalMaterialList.map((lib) => {
+        lib.components = lib.components.map((comp) => {
+            var _a;
+            /**
+             * 副作用修改 component schema 信息
+             */
+            comp = processCompnent(comp);
+            if (((_a = comp === null || comp === void 0 ? void 0 : comp.methods) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+                componentMethodList[comp.sourceKey.toLowerCase()] = comp.methods;
+            }
+            return comp;
+        });
+        return lib;
+    });
+    const components = finalMaterialList.reduce((result, material) => result.concat(material.components), []);
+    const componentsMap = {};
+    for (const item of materials) {
+        componentsMap[item.name] = [];
+    }
+    for (const item of components) {
+        (_a = componentsMap[item.materialName]) === null || _a === void 0 ? void 0 : _a.push(item);
+    }
+    return {
+        lcds: finalMaterialList.lcds,
+        compLibs: finalMaterialList.map((item) => {
+            return ['desc', 'name', 'title', 'version', 'isComposite'].reduce((map, key) => {
+                if (item[key] !== undefined) {
+                    map[key] = item[key];
+                }
+                return map;
+            }, {});
+        }),
+        actions: finalMaterialList.reduce((result, material) => result.concat(material.actions), []),
+        components,
+        plugins: finalMaterialList.reduce((result, material) => result.concat(material.plugins), []),
+        componentMethodList,
+        dependencies: materials.map((m) => {
+            let schemaVersion;
+            const find = finalMaterialList.find((item) => item.name === m.name);
+            if (find && !m.isComposite) {
+                // 基础库补充schemaVersion
+                const { lcds = {} } = find;
+                if (lcds.schemaVersion) {
+                    schemaVersion = lcds.schemaVersion;
+                }
+            }
+            return {
+                schemaVersion,
+                name: m.name,
+                originName: m.name === m.originName ? undefined : m.originName,
+                version: m.version,
+                controlJsPath: m.controlJsPath,
+                mainCssPath: m.mainCssPath,
+                mainJsPath: m.mainJsPath,
+                srcZipUrl: m.sourceZipPath,
+                mpPkgUrl: m.mpPkgUrl,
+                isComposite: !!m.isComposite,
+                components: componentsMap[m.name] || [],
+            };
+        }),
+    };
+}
+function extractInputProps(schema) {
+    const inputProps = {};
+    Object.keys(schema).map((prop) => {
+        if (schema[prop].inputProp) {
+            inputProps[prop] = schema[prop].inputProp;
+        }
+    });
+    return inputProps;
+}
+/** 版本号 major不同才认为是不同
+ * @param curVersion 当前版本
+ * @param targetVersion 需要对比的版本
+ * @returns boolean
+ */
+const isMajorVersionEqual = (curVersion, targetVersion) => {
+    const cur = isSemver(curVersion);
+    const target = isSemver(targetVersion);
+    if (cur && target) {
+        return cur[1] === target[1];
+    }
+    return curVersion === targetVersion;
+};
+/** 版本号 minor不同才认为是不同
+ * @param curVersion 当前版本
+ * @param targetVersion 需要对比的版本
+ * @returns boolean
+ */
+const isMinorVersionEqual = (curVersion, targetVersion) => {
+    const cur = isSemver(curVersion);
+    const target = isSemver(targetVersion);
+    if (cur && target) {
+        return cur[1] === target[1] && cur[2] === target[2];
+    }
+    return curVersion === targetVersion;
+};
+function recursiveTraverse(target, visit) {
+    function traverse(obj, path) {
+        if (Array.isArray(obj)) {
+            for (const [index, item] of obj.entries()) {
+                const currPath = path.concat(index);
+                traverse(item, currPath);
+                visit(item, currPath);
+            }
+        }
+        else if (typeof obj === 'object' && obj !== null) {
+            for (const [key, value] of Object.entries(obj)) {
+                const currPath = path.concat(key);
+                traverse(value, currPath);
+                visit(value, currPath);
+            }
+        }
+    }
+    traverse(target, []);
+    // visit target itself lastly
+    visit(target, []);
+}