resolver-egretimp-plus 0.1.115 → 0.1.116

package/src/rulesOfDate/parseCondition.js

@@ -0,0 +1,257 @@
+/* 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]({rootValue, currentPath, value}) {
+    let refVal = getConfigValue(rootValue, value, currentPath)
+    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,
+  rootValue,
+  currentPath
+}) {
+  debugger
+  const { eventExpress } = rule || {}
+  if (!eventExpress) return false
+
+  const expressObj = JSON.parse(eventExpress)
+  const { relation, conditions } = expressObj
+
+  const conditionsRet = conditions.map(condition => {
+    const { refType, refValue, targetType, targetValue } = condition
+
+    if (!calcConditionValue[refType]) return false
+    let refVal = calcConditionValue[refType]({rootValue, currentPath, value: refValue})
+
+    if (!calcConditionValue[targetType]) return false
+    let targetVal = calcConditionValue[targetType]({rootValue, currentPath, 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
+}
+
+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
+}
+
+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
+}
+
+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/rulesOfDate/ruleUtils.js

@@ -0,0 +1,343 @@
+/* eslint-disable */
+import { assignmentPathVal, getPathVal, hasOwn, isCycleConfig, 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(rootValue, path, relatePath) {
+  if (path === relatePath) {
+    return getPathVal(rootValue, path, '->')
+  }
+
+  // 这边逻辑目前主要是为了兼容日志的时候，也可以正常使用规则========start=====
+  let normalRelatePath = relatePath
+  let preFlagStr = ''
+  // 这个规则是因为在日志直接拷贝配置的时候，在analysisComponent组件中会在前面额外加上 这个 标识 所以需要转换一下
+  const preFlagStrReg = /(__@__[^(->)]*__)$/
+  const preFlagStrMatchs = relatePath?.match(preFlagStrReg)
+  if (preFlagStrMatchs) {
+    preFlagStr = preFlagStrMatchs[1]
+    normalRelatePath = normalRelatePath?.replace(preFlagStrReg, '')
+  }
+  // 这边逻辑目前主要是为了兼容日志的时候，也可以正常使用规则========end=====
+
+  const relatePathArr = normalRelatePath ? normalRelatePath.split('->') : []
+  const pathArr = path ? path.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 getValPath = pathArr.join('->')
+  return getPathVal(rootValue, getValPath, '->')
+}
+// 设置对应的值
+export function setFormVal(pathStr, val, mapComp, rootValue, currentPath) {
+  if (!pathStr) {
+    return
+  }
+  let difComps = null
+  let comps = []
+  let key = pathStr
+  while (key) {
+    const comp = mapComp[key]
+    if (comp) {
+      comps.unshift(comp)
+      const convertkey = key.replace(/->\w*$/, '')
+      if (convertkey === key) {
+        key = ''
+      } else {
+        key = convertkey
+      }
+    } else {
+      comps = []
+      key = ''
+    }
+  }
+  if (!comps || !comps.length) {
+    return
+  }
+
+  const relatePathArr = currentPath ? currentPath.split('->') : []
+  const pathArr = pathStr ? pathStr.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
+    }
+  }
+  let sssignPath = null
+  if (diffIdx !== -1) {
+    difComps = comps.slice(diffIdx)
+    const prefix = comps.slice(0, diffIdx).join('->')
+    sssignPath = calcAssignPath(difComps, 0, prefix)
+  } else {
+    sssignPath = pathArr.join('->')
+  }
+
+  assignmentPathVal(rootValue, sssignPath, val, '->')
+
+  
+  // 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 calcAssignPath(comps, idx = 0, prefix = '') {
+  if (comps && comps.length) {
+    return []
+  }
+  const comp = comps[idx]
+  prefix += prefix ? `->${comp.metaCode}` : comp.metaCode
+  if (comps.length === idx + 1) {
+    return prefix
+  } else {
+    let nextPrefix = prefix
+    nextPrefix = `${prefix}[%all]`
+    idx++
+    return calcAssignPath(comps, idx, nextPrefix)
+  }
+}
+
+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)
+  })
+}

package/src/rulesOfDate/rulesDriver.js

@@ -0,0 +1,67 @@
+/* eslint-disable */
+import { parseCondition } from './parseCondition'
+import { runEvent } from './eventsSupplement'
+import { unref } from 'vue'
+
+const recoverCb = {}
+const recoverCbTimer = {}
+
+export default function({
+  mapComp,
+  rules,
+  rootValue,
+  route, lang,
+  isInit,
+  currentPath
+}) {
+  rules = rules || []
+  
+  // this.rules = rules
+
+  if (rules && rules.length) {
+    rules.forEach(rule => {
+      if (!rule) return
+      const { pmRuleTargetEventVoList, pmRuleTargetEventVOList, relId } = rule
+      const relIdKey = `${relId}__${currentPath}`
+      if (parseCondition({rule, rootValue: unref(rootValue), currentPath})) {
+        const recovers = runEvent({events: pmRuleTargetEventVoList || pmRuleTargetEventVOList, rootValue, route, lang, mapComp, isInit, rule})
+        recoverCb[relIdKey] = recovers
+      } else {
+        recoverCb[relIdKey] && recoverCb[relIdKey].forEach(recover => {
+          if (recover) {
+            recover()
+          }
+        })
+        delete recoverCb[relIdKey]
+      }
+    })
+  }
+}
+
+function splitRelat(relat) {
+  // const rowCodes = []
+  let nativeRelat = ''
+  const codes = relat.split('->').map(code => {
+    const matchs = code?.match(/^(\w+)\[(\d+)\]$/)
+    if (matchs) {
+      nativeRelat += nativeRelat ? `->${matchs[1]}` : matchs[1]
+      return {
+        idx: parseInt(matchs[2]),
+        code: matchs[1]
+      }
+    } else {
+      nativeRelat += nativeRelat ? `->${code}` : code
+      return {
+        idx: -1,
+        code,
+      }
+    }
+  })
+  return {
+    nativeRelat,
+    codes
+  }
+}
+
+export { generateConfigsHireRelat } from './ruleUtils' 
+export { getCodeMapRules } from './parseCondition.js'