resolver-egretimp-plus 0.1.113 → 0.1.115

package/src-bak/rules/parseCondition.js

@@ -0,0 +1,378 @@
+/* eslint-disable */
+/**
+ * rule
+ * {
+      "eventId": "0",
+      "relId": "100000000000006",
+      "targetEventId": "0",
+      "targetObj": "--",
+      "targetObjVal": null,
+      "updateTime": "2023-04-13 20:14:13",
+      "updateOperId": "72523",
+      "targetMsg": null,
+      "eventRefValue": null,
+      "createTime": "2023-04-13 20:14:13",
+      "targetMsgEn": null,
+      "state": "0",
+      "ruleId": "100000000000006",
+      "createOperId": "72523",
+      "eventCode": null,
+      "eventName": null,
+      "remark": null,
+      "id": null,
+      "ruleType": "1",
+      "eventExpress": "{\"relation\":1,\"conditions\":[{\"refCode\":\"xiangmuxinxi->CustomerName\",\"refName\":\"项目信息->客户名称\",\"refNameEn\":\"xiangmuxinxi->Customer Name\",\"symbol\":1,\"type\":1,\"targetValue\":\"xiangmuxinxi->Businesstype\",\"targetName\":\"项目信息->业务类型\",\"targetNameEn\":\"xiangmuxinxi->Business type\"}]}",
+      "eventType": null,
+      "pmRuleTargetEventVoList": [
+        {
+          "targetEventId": "1002",
+          "relId": "100000000000006",
+          "eventId": "0",
+          "eventCode": null,
+          "actionType": "0",
+          "targetObj": "xiangmuxinxi->dutyparagraph",
+          "targetObjVal": null,
+          "targetMsg": null,
+          "targetMsgEn": null,
+          "state": "1",
+          "createTime": "2023-04-13 20:14:13",
+          "createOperId": "72523",
+          "updateTime": "2023-04-13 20:14:13",
+          "updateOperId": "72523"
+        }
+      ]
+    }
+    
+    eventExpress
+ * {
+      relation: 1, // 1: 与；2: 或
+      conditions: [
+        {
+          refCode: '', // 这个表格引用的字段，这边是使用->连接code
+          refName: 'aa', // 这边表示引用的字段描述，主要是配置化工具那边的展示
+          symbol: 1, // 1: >;2: >=; 3: <;4: <=;5: ==;6: !=;
+          type: 1, // 1: 组件；2: 系统参数； 3: 手动输入
+          targetValue: 'bb', // 这边是对比的值，可以跟refCode一样的值，也可以是具体的值，根据type进行生效
+          targetName: 'cc' // 这边在targetValue跟refcode一样时，跟refName一样的效果
+          targetName_en: 'cc' // // 这边在targetValue跟refcode一样时，跟refName一样的效果
+        },
+        {
+          refCode: '',
+          refName: '22',
+          symbol: 1, // 1: >;2: >=; 3: <;4: <=;5: ==;6: !=; 7: include; 8: no include
+          type: 3, // 1: 组件；2: 系统参数； 3: 手动输入
+          targetValue: '33',
+          targetName: 'c44c'
+          targetName_en: 'c44c'
+        }
+      ]
+    }
+ */
+import { getConfigValue, getCurrentComp, parseRules } from './ruleUtils'
+import {formatDate, isArray} from '../utils/index'
+
+export const rulesTypes = {
+  constrast: '1',
+  nonNull: '2',
+  regular: '3',
+  enumeration: '4',
+  event: '5'
+}
+export const conditionType = {
+  COMPONENT: 1, // 1: 组件
+  SYSTEM: 2, // 2: 系统参数
+  SELF: 3, // 3: 手动输入
+  COMPONENT_ENMU: 4, // 组件枚举
+  NULL: 5 // 空
+}
+
+const calcConditionValue = {
+  [conditionType.COMPONENT] ({tabpanelCode, value}) {
+    // const labelInfos = getCurrentComp.call(this, `${tabpanelCode ? tabpanelCode + '->' : ''}${value}`)
+    // // if (!labelInfos || labelInfos.length !== 1) {
+    // //   return false
+    // // }
+    let refVal = getConfigValue.call(this, `${tabpanelCode ? tabpanelCode + '->' : ''}${value}`)
+    return refVal
+  },
+  [conditionType.SYSTEM]: ({value}) => {
+    return getSystemArgVal(value)
+  },
+  [conditionType.SELF]: ({value}) => {
+    return value
+  },
+  [conditionType.COMPONENT_ENMU]: ({value}) => {
+    return value
+  },
+  [conditionType.NULL]: () => {
+    return null
+  }
+}
+
+export function parseCondition(rule) {
+  const { eventExpress, pmRuleTargetEventVoList: eventList, ruleType, tabpanelCode } = rule || {}
+  if (!eventExpress) return false
+
+  const expressObj = JSON.parse(eventExpress)
+  const { relation, conditions } = expressObj
+  let conditionsRet = []
+  let isIllegalSymbol = false
+  // 不同规则对应不同解析
+  // 如果ruleType有值，表示是配置化平台的的交付体验规则类型
+  // debugger
+  // if (ruleType) {
+  //   switch (ruleType) {
+  //     case rulesTypes.constrast:
+  //     case rulesTypes.enumeration:
+  //       conditionsRet = conditions.map(condition => {
+  //         const labelInfos = getCurrentComp.call(this, `${tabpanelCode ? tabpanelCode + '->' : ''}${condition.refCode || condition.refValue}`)
+  //         // if (condition.refCode.indexOf('custType') > -1) {
+  //         //   console.log('conditions==:', conditions)
+  //         //   debugger
+  //         // }
+  //         if (!labelInfos || labelInfos.length !== 1) {
+  //           return false
+  //         }
+  //         let refVal = getConfigValue.call(this, `${tabpanelCode ? tabpanelCode + '->' : ''}${condition.refCode || condition.refValue}`)
+  //         let targetVal = condition.targetValue
+  //         if (rulesTypes.constrast === ruleType) {
+  //           targetVal = getTraget.call(this, condition, tabpanelCode)
+  //         }
+  //         refVal = (refVal === undefined || refVal === null) ? '' : refVal
+  //         targetVal = (targetVal === undefined || targetVal === null) ? '' : targetVal
+  //         switch (condition.symbol) {
+  //           case 1:
+  //             return refVal > targetVal
+  //           case 2:
+  //               return refVal >= targetVal
+  //           case 3:
+  //               return refVal < targetVal
+  //           case 4:
+  //               return refVal <= targetVal
+  //           case 5:
+  //               return refVal == targetVal || (!targetVal && isArray(refVal) && !refVal.length)
+  //           case 6:
+  //               return refVal != targetVal
+  //           case 7:
+  //             if (typeof refVal === 'number') refVal = `${refVal}`
+  //             if (Array.isArray(refVal) || typeof refVal === 'string') {
+  //               return refVal.indexOf(targetVal) > -1
+  //             }
+  //             return false
+  //           case 8:
+  //               if (typeof refVal === 'number') refVal = `${refVal}`
+  //               if (Array.isArray(refVal) || typeof refVal === 'string') {
+  //                 return refVal.indexOf(targetVal) === -1
+  //               }
+  //               return false
+  //           default:
+  //             isIllegalSymbol = true
+  //         }
+  //       })
+  //       break
+  //     case rulesTypes.nonNull:
+  //       conditionsRet = conditions.map(condition => {
+  //         const labelInfos = getCurrentComp.call(this, `${tabpanelCode ? tabpanelCode + '->' : ''}${condition.refCode || condition.refValue}`)
+  //         if (!labelInfos || labelInfos.length !== 1) {
+  //           return false
+  //         }
+  //         const refVal = getConfigValue.call(this, `${tabpanelCode ? tabpanelCode + '->' : ''}${condition.refCode || condition.refValue}`)
+  //         return !refVal || (isArray(refVal) && !refVal.length)
+  //       })
+  //       break
+  //     case rulesTypes.regular:
+  //       conditionsRet = conditions.map(condition => {
+  //         const labelInfos = getCurrentComp.call(this, `${tabpanelCode ? tabpanelCode + '->' : ''}${condition.refCode || condition.refValue}`)
+  //         if (!labelInfos || labelInfos.length !== 1) {
+  //           return false
+  //         }
+  //         const refVal = getConfigValue.call(this, `${tabpanelCode ? tabpanelCode + '->' : ''}${condition.refCode || condition.refValue}`)
+  //         if (!condition.targetValue) return false
+  //         const reg = new RegExp(condition.targetValue)
+  //         return reg.test(refVal)
+  //       })
+  //       break
+  //     default:
+  //       return false
+  //   }
+  //   if (isIllegalSymbol) return false
+  // } else {
+    conditionsRet = conditions.map(condition => {
+      const { refType, refValue, targetType, targetValue } = condition
+      if (conditionType.COMPONENT == refType) {
+        const labelInfos = getCurrentComp.call(this, `${tabpanelCode ? tabpanelCode + '->' : ''}${refValue}`)
+        if (!labelInfos || labelInfos.length !== 1) {
+          return false
+        }
+      }
+      // if (refValue?.indexOf('itemId') > -1) {
+      //   debugger
+      // }
+      if (!calcConditionValue[refType]) return false
+      let refVal = calcConditionValue[refType].call(this, {tabpanelCode, value: refValue})
+
+      if (conditionType.COMPONENT == targetType) {
+        const labelInfos = getCurrentComp.call(this, `${tabpanelCode ? tabpanelCode + '->' : ''}${targetValue}`)
+        if (!labelInfos || labelInfos.length !== 1) {
+          return false
+        }
+      }
+      if (!calcConditionValue[targetType]) return false
+      let targetVal = calcConditionValue[targetType].call(this, {tabpanelCode, value: targetValue})
+
+      refVal = (refVal === undefined || refVal === null) ? '' : refVal
+      targetVal = (targetVal === undefined || targetVal === null) ? '' : targetVal
+
+      let formatRefVal = refVal
+      let formatTargetVal = targetVal
+      if (refVal == Number(refVal) && targetVal == Number(targetVal)) {
+        formatRefVal = Number(refVal)
+        formatTargetVal = Number(targetVal)
+      }
+      switch (condition.symbol) {
+        case 1:
+          return formatRefVal > formatTargetVal
+        case 2:
+            return formatRefVal >= formatTargetVal
+        case 3:
+            return formatRefVal < formatTargetVal
+        case 4:
+            return formatRefVal <= formatTargetVal
+        case 5:
+            return refVal == targetVal || (!targetVal && isArray(refVal) && !refVal.length)
+        case 6:
+            return refVal != targetVal
+        case 7:
+          if (typeof refVal === 'number') refVal = `${refVal}`
+          if (Array.isArray(refVal) || typeof refVal === 'string') {
+            return refVal.indexOf(targetVal) > -1
+          }
+          return false
+        case 8:
+          if (['string', 'number'].includes(typeof targetVal)) {
+            const reg = new RegExp(targetVal)
+            return reg.test(refVal)
+          }
+          return false
+        default:
+          return false
+      }
+    })
+  // }
+  const ret = conditionsRet[relation == 1 ? 'every' : 'some'](item => item)
+  return ret
+}
+
+function getTraget(condition, tabpanelCode) {
+  switch (condition.type) {
+    case 1:
+      return getConfigValue.call(this, `${tabpanelCode ? tabpanelCode + '->' : ''}${condition.refCode || condition.refValue}`)
+    case 2:
+      return getSystemArgVal(condition.targetValue)
+    case 3:
+      return condition.targetValue
+    default:
+      return ''
+  }
+}
+
+export function parseRuleForRefCodeAndEvents(rule) {
+  const codeRules = []
+  const { eventExpress, pmRuleTargetEventVoList: eventList, tabpanelCode } = rule || {}
+  if (!eventExpress) return false
+  const expressObj = JSON.parse(eventExpress)
+  const { conditions = [] } = expressObj
+  conditions.forEach(condition => {
+    if (condition.refType == conditionType.COMPONENT || condition.targetType == conditionType.COMPONENT) {
+      if (condition.refType == conditionType.COMPONENT) {
+        codeRules.push({
+          key: tabpanelCode ? `${tabpanelCode}->${condition.refCode || condition.refValue}` : condition.refCode || condition.refValue,
+          rules: [rule]
+        })
+      }
+      if (condition.targetType == conditionType.COMPONENT) {
+        codeRules.push({
+          key: tabpanelCode ? `${tabpanelCode}->${condition.targetValue}` : condition.targetValue,
+          rules: [rule]
+        })
+      }
+    } else {
+      
+    }
+  });
+  return codeRules
+}
+
+export function getCodeMapRules(config) {
+  const rules = parseRules(config)
+  return codeMapRules(rules)
+}
+
+export function codeMapRules(rules = []) {
+  const mapObj = {}
+  rules.forEach(rule => {
+    const keyEvents = parseRuleForRefCodeAndEvents(rule)
+    if (keyEvents && keyEvents.length) {
+      keyEvents.forEach(keyEvent => {
+        const { key = '', rules = [] } = keyEvent
+        if (mapObj[key]) {
+          rules.forEach(rule => {
+            if (!mapObj[key]?.some(itemR => itemR?.relId === rule?.relId)) {
+              mapObj[key].push(rule)
+            }
+          })
+        } else {
+          mapObj[key] = rules
+        }
+      })
+    }
+  })
+  return mapObj
+}
+
+
+// 事件添加动作，判断当前点击的item是否出发事件
+export function assertEventConditionsRef (rule, refCode) {
+  const { eventExpress, pmRuleTargetEventVoList: eventList, ruleType } = rule || {}
+  if (!eventExpress) return false
+  const expressObj = JSON.parse(eventExpress)
+  const { relation, conditions } = expressObj
+  const conditionsRet = conditions.map(condition => {
+    return condition.refCode == refCode
+  })
+  return conditionsRet[relation == 1 ? 'every' : 'some'](item => item)
+}
+
+const systemFlag = {
+  currentDate: '1', // 获取当前日期
+  currentTimestamp: '2', // 获取当前时间戳
+  CurrentYear: '3', // 当前年
+  CurrentMonth: '4', // 当前月
+  CurrentDay: '5', // 当前日
+  CurrentAfter30Day: '6', // 当前后30天
+  CurrentBefore30Day: '7' // 当前前30天
+}
+
+function getSystemArgVal(flag) {
+  const now = new Date()
+  switch (flag) {
+    case systemFlag.currentDate:
+      return formatDate(new Date(),"yyyy-MM-dd")
+    case systemFlag.currentTimestamp:
+      return new Date().getTime()
+    case systemFlag.CurrentYear:
+      return formatDate(new Date(),"yyyy")
+    case systemFlag.CurrentMonth:
+      return formatDate(new Date(),"MM")
+    case systemFlag.CurrentDay:
+      return formatDate(new Date(),"dd")
+    case systemFlag.CurrentAfter30Day:
+      now.setDate(now.getDate() + 30);
+      return formatDate(now, "yyyy-MM-dd")
+    case systemFlag.CurrentBefore30Day:
+      now.setDate(now.getDate() - 30);
+      return formatDate(now, "yyyy-MM-dd")
+    default:
+      return flag
+  }
+}

package/src-bak/rules/ruleUtils.js

@@ -0,0 +1,273 @@
+/* eslint-disable */
+import { hasOwn, isPlainObject } from "../utils"
+import { formatSelectVal } from "../utils/defaultVal"
+import { MULTI_PAGE_META_LIST_TYPES, findComponent } from '../utils/index'
+
+const pmPageMetaListTypeList = ['setShow', 'setHidden']
+// 这边是一些组件在执行规则的时候，如果还没有加载出来，规则会走不动，这边就是存储没走通的规则，等组件加载完之后，再去执行
+export const penddingRules = {}
+
+export function getConfigValue(codesStr = '', refVal) {
+  if (!codesStr) return ''
+  const { config, dynamicMapComp } = this
+  const { hireRelat = '', dynamicHireRelat = '' } = config
+  if (hireRelat === codesStr) {
+    // 如果走到这里，表示是触发条件中的一个条件是当前的配置项（config）
+    return config.bindValue
+  }
+
+  // 如果没有循环渲染组件，可以直接获对应的config返回上面的bindValue====start====
+  // const codes = codesStr.split('->')
+  // const circulConfigFlags = codes.map((code, idx) => {
+  //   return findComponent(MULTI_PAGE_META_LIST_TYPES, code) !== -1
+  // })
+  // if (!circulConfigFlags.some(flag => flag)) {
+  //   return dynamicMapComp?.[codesStr]?.bindValue
+  // }
+  // 如果没有循环渲染组件，可以直接获对应的config返回上面的bindValue====end====
+
+  const configs = getRelateConfigs.call(this, codesStr, config)
+  if (configs.length !== 1) {
+    return null
+  }
+  const retVal = refVal ? configs[0]?.refValue : configs[0]?.bindValue
+  return retVal
+}
+// 设置对应的值
+export function setFormVal(pathStr, val) {
+  if (!pathStr) {
+    return
+  }
+  if (isPlainObject(pathStr)) {
+    hasOwn(pathStr, 'refValue') && (pathStr.refValue = val)
+    return
+  }
+  const { config } = this
+  const configs = getRelateConfigs.call(this, pathStr, config)
+  configs.forEach(cg => {
+    if (hasOwn(cg, 'refValue')) {
+      if (cg.metaType === 'ElSelect') {
+        val = formatSelectVal({config: cg, val: val, isActive: true})
+      }
+      cg.refValue = val
+    } else {
+      const { _mapComp } = this
+      if (_mapComp?.value?.[cg.hireRelat]) {
+        if (!penddingRules[cg.hireRelat]) {
+          penddingRules[cg.hireRelat] = []
+        }
+        if (!penddingRules[cg.hireRelat].some((item) => item?.rules === this?.rules && item?.config === this?.config)) {
+          penddingRules[cg.hireRelat].push(this)
+        }
+      }
+    }
+  })
+}
+
+function getRelateConfigs(codesStr, config, type) {
+  const { dynamicHireRelat = '' } = config
+  // 这边逻辑目前主要是为了兼容日志的时候，也可以正常使用规则========start=====
+  let normalDynamicHireRelat = dynamicHireRelat
+  let preFlagStr = ''
+  // 这个规则是因为在日志直接拷贝配置的时候，在analysisComponent组件中会在前面额外加上 这个 标识 所以需要转换一下
+  const preFlagStrReg = /(__@__[^(->)]*__)$/
+  const preFlagStrMatchs = dynamicHireRelat?.match(preFlagStrReg)
+  if (preFlagStrMatchs) {
+    preFlagStr = preFlagStrMatchs[1]
+    normalDynamicHireRelat = normalDynamicHireRelat?.replace(preFlagStrReg, '')
+  }
+  // 这边逻辑目前主要是为了兼容日志的时候，也可以正常使用规则========end=====
+
+  // 组装成此数据结果，用于后续的获取对应字段=====start====
+  const dynamicCodeInfos = normalDynamicHireRelat.split('->').map(code => {
+    const matchs = code?.match(/^(\w+)\[(\d+)\]$/)
+    if (matchs) {
+      return {
+        idx: parseInt(matchs[2]),
+        code: matchs[1]
+      }
+    } else {
+      return {
+        idx: -1,
+        code,
+      }
+    }
+  })
+  // 组装成此数据结果，用于后续的获取对应字段=====end====
+
+  let diffIdx = -1 // 次标识表示，是从那个所以开始，code不一样了
+  const codes = codesStr.split('->')
+
+  for (let i = 0; i < codes.length; i ++) {
+    const code = codes[i]
+    const dynamicCodeInfo = dynamicCodeInfos[i]
+    if (dynamicCodeInfo.code !== code) {
+      diffIdx = i
+      break
+    }
+  }
+
+  const diffCodes = codes.slice(diffIdx)
+  const sameCodesStr = dynamicCodeInfos.slice(0, diffIdx).map(({idx, code}) => {
+    return idx !== -1 ? `${code}[${idx}]` : code
+  }).join('->')
+  let sameStr = sameCodesStr
+  let sameIdx = null
+  const sameMatchs = sameCodesStr.match(/^([\w\W]*)\[(\d*)\]$/)
+  // 这边是在出现a->c->c[0]这种情况的时候，可以正常获取的组件config
+  if (sameMatchs) {
+    sameStr = sameMatchs[1]
+    sameIdx = sameMatchs[2]
+  }
+  const { dynamicMapComp, _mapComp } = this
+  let retConfigs = []
+  if (sameStr) {
+    retConfigs = [dynamicMapComp[`${sameStr}${preFlagStr}`]]
+  } else {
+    const code = diffCodes.shift()
+    retConfigs = [dynamicMapComp[`${code}${preFlagStr}`]]
+  }
+  while (diffCodes.length) {
+    const code = diffCodes.shift()
+    const list = []
+    retConfigs.forEach(cg => {
+      // multiPmPageMetaList有值，表示为数据循环渲染子组件
+      if (cg.multiPmPageMetaList) {
+        if (sameIdx !== null) {
+          const childCgList = cg.multiPmPageMetaList[sameIdx]
+          const fincCg = childCgList && childCgList.find(childCg => childCg.metaCode === code)
+          if (!fincCg) return
+          list.push(fincCg)
+          sameIdx = null
+        } else {
+          if (pmPageMetaListTypeList.includes(type)) {
+            const fincCg = cg?.pmPageMetaList?.find(childCg => childCg.metaCode === code)
+            if (!fincCg) return
+            list.push(fincCg)
+          }
+          cg.multiPmPageMetaList.forEach(childCgList => {
+            const fincCg = childCgList.find(childCg => childCg.metaCode === code)
+            if (!fincCg) return
+            list.push(fincCg)
+          })
+        }
+      } else {
+        const fincCg = cg?.pmPageMetaList?.find(childCg => childCg.metaCode === code)
+        if (!fincCg) return
+        list.push(fincCg)
+      }
+    })
+    retConfigs = list
+  }
+  if (_mapComp?.value?.[codesStr] && !retConfigs.length) {
+    if (!penddingRules[codesStr]) {
+      penddingRules[codesStr] = []
+    }
+    if (!penddingRules[codesStr].some((item) => item?.rules === this?.rules && item?.config === this?.config)) {
+      penddingRules[codesStr].push(this)
+    }
+  }
+  return retConfigs
+}
+
+export function greaterThan(val, targ) {
+  const valCanTran = canTransNumber(val)
+  const tragCanTran = canTransNumber(targ)
+  if (valCanTran && tragCanTran) {
+    return Number(val) > Number(targ)
+  } else {
+    return val + '' > targ + ''
+  }
+}
+
+export function lessThan(val, targ) {
+  const valCanTran = canTransNumber(val)
+  const tragCanTran = canTransNumber(targ)
+  if (valCanTran && tragCanTran) {
+    return Number(val) < Number(targ)
+  } else {
+    return val + '' < targ + ''
+  }
+}
+
+export function canTransNumber(val) {
+  return !isNaN(Number(val))
+}
+
+/**
+ * 根据code path 获取到对应的组件或者label
+ */
+ export function getCurrentComp(codesStr, type) {
+  if (!codesStr) return null
+  const { config } = this
+  return getRelateConfigs.call(this, codesStr, config, type)
+}
+
+export function parseRules(config) {
+  if (!config) return []
+  const retRules = []
+  const { pmRuleDefVoList, pmRuleDefVOList } = config
+  const ruleDefVoList = (pmRuleDefVoList || pmRuleDefVOList?.filter(item => item?.ruleType == '1') || [])
+  ruleDefVoList.forEach(ruleTypeItem => {
+    const pmRuleEventRelVoList = ruleTypeItem.pmRuleEventRelVOList || ruleTypeItem.pmRuleEventRelVoList || []
+    const itemRulesFlat = pmRuleEventRelVoList.map(item => ({
+      ...item,
+      ruleType: ruleTypeItem.ruleType
+    }))
+    retRules.push(...itemRulesFlat)
+  })
+  return retRules
+}
+
+// 解析最原始的配置数据，生成Code链对应的配置信息
+export function generateConfigsHireRelat(configs, hireRelat = '', retObj = {}) {
+  if (!configs) return
+  const list = Array.isArray(configs) ? configs : [configs]
+  list.forEach(config => {
+    let currentHireRelat = hireRelat
+    if (hasOwn(config, 'pmTabpanelInfoVoList')) {
+      currentHireRelat = ''
+      generateConfigsHireRelat(config.pmTabpanelInfoVoList, currentHireRelat, retObj)
+    } else if (hasOwn(config, 'pmComponentInfoVoList')) {
+      currentHireRelat += currentHireRelat ? `->${config.tabpanelCode}` : config.tabpanelCode
+      generateConfigsHireRelat(config.pmComponentInfoVoList, currentHireRelat, retObj)
+    } else if (hasOwn(config, 'pmLabelInfoVoList') || hasOwn(config, 'subComponentInfoVo')) {
+      currentHireRelat += currentHireRelat ? `->${config.componentCode}` : config.componentCode
+      generateConfigsHireRelat(config.pmLabelInfoVoList, currentHireRelat, retObj)
+      generateConfigsHireRelat(config.subComponentInfoVo, currentHireRelat, retObj)
+    } else {
+      currentHireRelat += currentHireRelat ? `->${config.labelCode}` : config.labelCode
+    }
+    if (currentHireRelat) {
+      config.nativeHireRelat = currentHireRelat
+      retObj[currentHireRelat] = config
+    }
+  })
+  return retObj
+}
+
+export function getRelateConfigKeys(keys = [], path = '', relatePath = '') {
+  const pathArr = path ? path.split('->') : []
+  const relatePathArr = relatePath ? relatePath.split('->') : []
+  let diffIdx = -1 // 此标识表示，是从那个所以开始，code不一样了
+  let currentIdx = 0
+  while(diffIdx === -1 && currentIdx < pathArr.length && currentIdx < relatePathArr.length) {
+    const pathCode = pathArr[currentIdx]
+    const pathCodeReg = new RegExp(`^${pathCode}(\\[\\d+\\])?$`)
+    const relateCode = relatePathArr[currentIdx]
+    if (pathCodeReg.test(relateCode)) {
+      pathArr.splice(currentIdx, 1, relateCode)
+      currentIdx++
+    } else {
+      diffIdx = currentIdx
+    }
+  }
+  const normalPath = pathArr.reduce((ret, pathCode) => {
+    const noramlPathCode = pathCode.replace(/([\[\]]{1})/g, (_,b) => {return `\\${b}`})
+    return ret + (ret ? `->${noramlPathCode}(\\[\\d+\\])?` : `${noramlPathCode}(\\[\\d+\\])?`)
+  }, '')
+  const normalPathReg = new RegExp(`^${normalPath}$`)
+  return keys.filter(code => {
+    return normalPathReg.test(code)
+  })
+}