resolver-egretimp-plus 0.0.124 → 0.0.125

package/src/rulesImp/ruleInstance.js

@@ -0,0 +1,231 @@
+import { Engine, Rule } from 'json-rules-engine'
+import { hasOwn } from '../utils'
+import { calcRelateCodes} from './ruleUtils'
+import { EVENS_INFO, getEventPriority, runEvent } from './events'
+
+const AlwayFlase = 'alwaysFalse'
+const symbolOperatorMap = {
+  '1': 'greaterThan',
+  '2': 'greaterThanInclusive',
+  '3': 'lessThan',
+  '4': 'lessThanInclusive',
+  '5': 'customEqual',
+  '6': 'notEqual',
+  '7': 'fullInclude',
+  '8': 'regular',
+}
+
+export const conditionType = {
+  COMPONENT: 1, // 1: 组件
+  SYSTEM: 2, // 2: 系统参数
+  SELF: 3, // 3: 手动输入
+  COMPONENT_ENMU: 4, // 组件枚举
+  NULL: 5 // 空
+}
+
+export class RuleDriver {
+  engine = null
+  config = null
+  dynamicMapComp = null
+  _mapComp = null
+  penddingRules = null
+  recovers = null
+  engineRule = null
+  rule = null
+  lang = 'zh'
+  messageInstance = null
+  constructor({
+    rule,
+    config,
+    dynamicMapComp,
+    _mapComp,
+    lang,
+    messageInstance,
+    penddingRules = {}
+  }) {
+    this.config = config
+    this.dynamicMapComp = dynamicMapComp
+    this._mapComp = _mapComp
+    this.penddingRules = penddingRules
+    this.rule = rule
+    this.lang = lang
+    this.messageInstance = messageInstance
+
+    this.engineRule = new Rule({
+      conditions: {all:[]},
+      onSuccess: (...arg) => {
+        this.executeEvents(...arg)
+      },
+      onFailure: (...arg) => {
+        this.executeRecoveEvents(...arg)
+      }
+    })
+    this.engine = new Engine()
+    this.engine.addRule(this.engineRule)
+    this.polyfillOperators()
+  }
+  run(rootValue, isInit) {
+    const conditions = this.generateRuleConditions(this.rule)
+    this.engineRule?.setConditions(conditions)
+    this.engine.updateRule(this.engineRule)
+    this.isInit = isInit // 执行run的时候传进来，表示是否时初始化的时候执行的
+    this.engine.run({
+      rootValue,
+      isInit
+    })
+  }
+  async executeEvents(...arg) {
+    console.log('executeEvents arg==:', arg)
+    const isInit = await arg[1]?.factValue?.('isInit')
+    const { pmRuleTargetEventVoList, pmRuleTargetEventVOList } = this.rule
+    const EventVoList = (pmRuleTargetEventVoList || pmRuleTargetEventVOList).sort((a, b) => getEventPriority(a.eventId) - getEventPriority(b.eventId))
+    this.recovers = runEvent.call(this, EventVoList, isInit)
+  }
+  async executeRecoveEvents(...arg) {
+    console.log('executeRecoveEvents arg==:', arg)
+    if (this.recovers) {
+      this.recovers?.reverse?.()?.forEach(recover => {
+        if (recover) {
+          recover()
+        }
+      })
+    } else {
+      const { pmRuleTargetEventVoList, pmRuleTargetEventVOList } = this.rule
+      const initRecoverEventVoList = (pmRuleTargetEventVoList || pmRuleTargetEventVOList).map(item => {
+        const ret = {
+          ...item
+        }
+        ret.eventId = EVENS_INFO[item.eventId]?.recover
+        return ret
+      })
+      const EventVoList = initRecoverEventVoList.sort((a, b) => getEventPriority(b.eventId) - getEventPriority(a.eventId))
+      const isInit = await arg[1]?.factValue?.('isInit')
+      runEvent.call(this, EventVoList, isInit)
+    }
+  }
+  generateRuleConditions(rule) {
+    const { eventExpress } = rule || {}
+    if (!eventExpress) return false
+
+    const expressObj = JSON.parse(eventExpress)
+    return this.paseRuleExpress(expressObj)
+  }
+  paseRuleExpress(expressInfo) {
+    const { relation, conditions } = expressInfo
+    const key = relation == '1' ? 'all' : 'any'
+    return {
+      [key]: conditions?.map(condition => {
+        if (hasOwn(condition ,'relation') && hasOwn(condition ,'conditions')) {
+          return this.paseRuleExpress(condition)
+        } else {
+          return this.generateRuleFace(condition)
+        }
+      })
+    }
+  }
+  polyfillOperators() {
+    this.engine?.addOperator('customEqual', (factValue, jsonValue) => {
+      return factValue == jsonValue || (!jsonValue && isArray(factValue) && !factValue.length)
+    })
+    this.engine?.addOperator('fullInclude', (factValue, jsonValue) => {
+      if (typeof factValue === 'number') factValue = `${factValue}`
+      if (Array.isArray(factValue) || typeof factValue === 'string') {
+        return factValue.indexOf(jsonValue) > -1
+      }
+      return false
+    })
+    this.engine?.addOperator('regular', (factValue, jsonValue) => {
+      if (['string', 'number'].includes(typeof jsonValue)) {
+        const reg = new RegExp(jsonValue)
+        return reg.test(factValue)
+      }
+      return false
+    })
+    this.engine?.addOperator('AlwayFlase', (factValue, jsonValue) => {
+      return false
+    })
+  }
+  getRelateCodes(path) {
+    return calcRelateCodes.call(this, path)
+  }
+  generateRuleFace(condition) {
+    let retCondition = {
+      fact: 'rootValue',
+      path: '',
+      operator: symbolOperatorMap[condition.symbol],
+      value: '',
+    }
+    const { refType, refValue, targetType, targetValue } = condition
+    if (conditionType.COMPONENT == refType) {
+      const configKeys = this.getRelateCodes(refValue)
+      if (configKeys.length > 1) {
+        console.error('ref config must single config', this.config, configCodes, path)
+        retCondition.operator = AlwayFlase
+        return
+      }
+      if (!configKeys.length) {
+        retCondition.operator = AlwayFlase
+        console.error('rule get refType Config fail,', '\nrefType:', refType, '\nrule:', this.rule, '\nconfig:', this.config)
+        return
+      }
+      retCondition.path = `$.${configKeys[0]?.replaceAll('->', '.')}`
+    }
+    if (conditionType.COMPONENT == targetType) {
+      retCondition.value = {
+        fact: 'rootValue',
+      }
+      const configKeys = this.getRelateCodes(targetValue)
+      if (configKeys.length > 1) {
+        console.error('target config must single config', this.config, configCodes, path)
+        retCondition.operator = AlwayFlase
+        return
+      }
+      if (!configKeys.length) {
+        retCondition.operator = AlwayFlase
+        console.error('rule get targetType Config fail,', '\nrefType:', refType, '\nrule:', this.rule, '\nconfig:', this.config)
+        return
+      }
+      retCondition.value.path = `$.${configKeys[0]?.replaceAll('->', '.')}`
+    }
+    if (conditionType.SYSTEM == targetType) {
+      retCondition.value = getSystemArgVal(targetValue)
+    }
+    if (conditionType.SELF == targetType) {
+      retCondition.value = targetValue
+    }
+    if (conditionType.COMPONENT_ENMU == targetType) {
+      retCondition.value = targetValue
+    }
+    if (conditionType.NULL == targetType) {
+      retCondition.value = null
+    }
+    console.log('face, refVal===:', refValue, 'targetValue==:', targetValue, 'condition==:', retCondition)
+    return retCondition
+  }
+}
+
+
+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/rulesImp/ruleUtils.js

@@ -0,0 +1,108 @@
+import { hasOwn } from "../utils"
+
+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)
+  })
+}
+
+export function calcRelateCodes(path) {
+  const dynamicMapCompKeys = Object.keys(this.dynamicMapComp || {})
+  const { dynamicHireRelat = '' } = this.config || {}
+  const configCodes = getRelateConfigKeys(dynamicMapCompKeys, path, dynamicHireRelat,)
+  if (!configCodes.length) {
+    if (this._mapComp[path]) {
+      if (!this.penddingRules[path]) {
+        this.penddingRules[path] = []
+      }
+      if (!this.penddingRules[path].some((item) => item?.rule === this?.rule && item?.config === this?.config)) {
+        this.penddingRules[path].push(this)
+      }
+    }
+  }
+  return configCodes
+}
+
+export function getConfigValue(codesStr = '', refVal) {
+  if (!codesStr) return ''
+  const { config} = this
+  const { hireRelat = '' } = config
+  if (hireRelat === codesStr) {
+    // 如果走到这里，表示是触发条件中的一个条件是当前的配置项（config）
+    return config.bindValue
+  }
+  const configs = getCurrentComp.call(this, codesStr)
+  if (configs.length !== 1) {
+    return null
+  }
+  const retVal = refVal ? configs[0]?.refValue : configs[0]?.bindValue
+  return retVal
+}
+
+
+/**
+ * 根据code path 获取到对应的组件或者label
+ */
+export function getCurrentComp(codesStr) {
+  if (!codesStr) return null
+  const { dynamicMapComp } = this
+  const configCodes = calcRelateCodes.call(this, codesStr)
+  return configCodes.map(code => {
+    return dynamicMapComp[code]
+  })
+}
+
+// 设置对应的值
+export function setFormVal(pathStr, val) {
+  if (!pathStr) {
+    return
+  }
+  const configs = getCurrentComp.call(this, pathStr)
+  configs.forEach(cg => {
+    hasOwn(cg, 'refValue') && (cg.refValue = val)
+  })
+}
+
+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))
+}

package/src/theme/element/components/index.scss

@@ -41,3 +41,4 @@
 @import './tree.scss';
 @import './steps.scss';
 @import './dialog.scss';
+@import './textarea.scss';

package/src/theme/element/components/textarea.scss

@@ -0,0 +1,3 @@
+.el-textarea {
+  --el-input-text-color: #1f2329;
+}

package/src/utils/dom.js

@@ -0,0 +1,36 @@
+export function getDomWidth(dom, offset = 0) {
+  const range = document.createRange()
+  range.setStart(dom, 0)
+  range.setEnd(dom, dom?.childNodes?.length)
+  return range.getBoundingClientRect()?.width - offset
+}
+
+export function getDomComputed(el) {
+  return window.getComputedStyle(el, null)
+}
+
+export function getPadding(el) {
+  const domCss = window.getComputedStyle(el, null)
+  const pl = Number.parseInt(domCss.paddingLeft, 10) || 0
+  const pr = Number.parseInt(domCss.paddingRight, 10) || 0
+
+  return {
+    left: pl,
+    right: pr
+  }
+}
+
+export function calcTextLength(text, fontSize) {
+  if (!text) return 0
+  const size = Number.parseInt(fontSize)
+  let realLength = 0
+  for(let i = 0; i < text.length; i ++) {
+    const charCode = text.charCodeAt(i)
+    if (charCode >= 0 && charCode <= 128) {
+      realLength += Number.parseFloat((0.54714 * size).toFixed(5))
+    } else {
+      realLength += 1 * size
+    }
+  }
+  return realLength
+}

package/src/rules_b/index.js

@@ -1,42 +0,0 @@
-import { Engine, Rule } from 'json-rules-engine'
-import { hasOwn } from '../utils'
-
-class RuleDriver {
-  constructor(rules) {
-    const rules = new Rule({
-      conditions: {
-        all: []
-      }
-    })
-    const engine = new Engine()
-  }
-  generateRuleConditions(rule) {
-    const { eventExpress, pmRuleTargetEventVoList: eventList, ruleType, tabpanelCode } = rule || {}
-    if (!eventExpress) return false
-
-    const expressObj = JSON.parse(eventExpress)
-    const { relation, conditions } = expressObj
-    let conditionsRet = []
-    new Rule()
-  }
-  executeRule(rule) {
-
-  }
-  executeRules(rules) {
-
-  }
-}
-
-function paseRuleExpress(expressInfo) {
-  const { relation, conditions } = expressObj
-  const key = relation == '1' ? 'all' : 'any'
-  return {
-    [key]: conditions?.map(condition => {
-      if (hasOwn(condition ,'relation') && hasOwn(condition ,'conditions')) {
-        return paseRuleExpress(condition)
-      } else {
-        
-      }
-    })
-  }
-}