qn-lcdp/ui/design/utils/index.js

青能科技低代码前端

/**
 * 组件相关工具方法
 */
 import Vue from 'vue'

 /**
  * 向响应式对象中添加一个 property，并确保这个新 property 同样是响应式的，且触发视图更新。
  * 它必须用于向响应式对象上添加新 property，因为 Vue 无法探测普通的新增 property (比如 this.myObject.newProperty = 'hi')
  * @param {Object | Array} target 目标对象
  * @param {string | number} key 属性键
  * @param {Object} value 设置的数据
  * @returns {Object} 设置的数据
  */
 export function set(target, key, value) {
   return Vue.set(target, key, value)
 }

 /**
  * 动态执行
  * @param {String} script 脚本
  * @param {Object} model 数据模型
  * @param {String} key 数据标识
  * @returns 执行结果
  */
 export function dynamicFun(script, model = {}, key = '$') {
   if (!script) return false
   const func = script.indexOf('return') >= 0 ? '{' + script + '}' : 'return (' + script + ')'
   const Fn = new Function(key, func)
   return Fn(model)
 }
 
 /**
  * 文本转换，支持动态脚本方法
  * @param {String} text 待转换文本
  * @param {Object} model 数据
  * @returns {String} 转换后的文本
  */
 export function transformText(text, model = {}) {
   if (text && (text.indexOf('return') >= 0 || text.indexOf('$') >= 0)) {
     return dynamicFun(text, model)
   }
   return text
 }
 
 /**
  * 复制属性
  * @param {Object} from 源数据
  * @param {Object} to 目标数据
  * @param {String | Array} props 复制属性，为空则复制全部属性
  */
 export function copyProperties(from, to, props) {
   if (!from || !to) {
     return
   }
   const copy = (prop) => {
     const value = from[prop]
     if (value !== null && value !== undefined) {
       to[prop] = value
     }
   }
   if (Array.isArray(props)) {
     props.forEach(copy)
   } else if (typeof props === 'string') {
     copy(props)
   } else {
     for (const prop in from) {
       copy(prop)
     }
   }
 }
 /**
  * 生成组件信息的唯一键
  * @param {Object} item
  */
 export function generateKey(item) {
   const time = new Date().getTime() + 1
   const key = item.type + '_' + time
   item.key = key
 }
 /**
  * 判断指定数据是否设置
  * @param {Object} value
  */
 export function isUnset(value) {
   return value === undefined || value === null
 }
 
 /**
  * 校验器
  */
 const validators = {
   /**
    * 正则校验
    * @param {Object} rule 校验规则
    * @param {any} value 待校验数据
    * @param {Function} callback 回调函数
    */
   pattern: (rule, value, callback) => {
     const pattern = rule.pattern
     if (!pattern) {
       callback()
       return
     }
     if (new RegExp(pattern).test(value)) {
       callback()
     } else {
       callback(new Error(rule.message))
     }
   },
   /**
    * 脚本校验
    * @param {Object} rule 校验规则
    * @param {any} value 待校验数据
    * @param {Function} callback 回调函数
    * @param {Object} model 表单数据
    */
   script: (rule, value, callback, model) => {
     const script = rule.script
     if (!script) {
       callback()
       return
     }
 
     if (!dynamicFun(script, model || {})) {
       callback(new Error(rule.message))
     } else {
       callback()
     }
   }
 }
 
 /**
  * 计算校验规则
  * @param {Object} requiredRule 组件必填规则配置
  * @param {Array} rules 组件自定义规则配置
  * @param {Object} model 表单数据
  * @param {Boolean} isDesign 是否为设计模式
  * @returns {Array} 计算后的校验规则
  */
 export function extractRules(requiredRule, rules, model, isDesign = false) {
   const isRequire = requiredRule.required
   // 校验规则为空且非必填，不设置校验规则
   if (rules.length === 0 && !isRequire) {
     return []
   }
 
   const finalRules = []
   if (isRequire) {
     requiredRule.required = isRequire
     finalRules.push(requiredRule)
   }
   // 设计状态不设置自定义规则
   if (isDesign) {
     return finalRules
   }
   rules.forEach(rule => {
     rule.required = isRequire
     const validator = validators[rule.type]
     if (validator) {
       rule.validator = (rule, value, callback) => {
         validator(rule, value, callback, model)
       }
     }
     if (!rule.trigger) {
       rule.trigger = ['change', 'blur']
     }
     finalRules.push(rule)
   })
   return finalRules
 }
 /**
  * 继承
  * @param {Function} Child 子类
  * @param {Function} Parent 父类
  */
 export function inherit(Child, Parent) {
   const Fun = function () {}
   Fun.prototype = Parent.prototype
   Child.prototype = new Fun()
   Child.prototype.constructor = Child
 }
 /**
  * 获得原始数据
  * @param {Object} data
  * @returns
  */
 export function rawData(data) {
   return JSON.parse(JSON.stringify(data))
 }
 
 
 export function makeHashCode(prefix) {
   const rhashcode = /\d\.\d{4}/
   prefix = prefix || 'Option '
   return String(Math.random() + Math.random()).replace(rhashcode, prefix)
 }