nbwansui 1.0.2 → 1.0.3

package/core/common/create.js

@@ -0,0 +1,9 @@
+import { KEY_COMPONENT_NAME } from '/@/utils/avue/global/variable.js'
+import bem from '/@/utils/avue/utils/bem.js'
+export default function (sfc) {
+  sfc.name = KEY_COMPONENT_NAME + sfc.name
+  sfc.mixins = sfc.mixins || []
+  sfc.mixins.push(bem)
+
+  return sfc
+}

package/core/common/dataformat.js

@@ -0,0 +1,172 @@
+import {
+    ARRAY_LIST,
+    ARRAY_VALUE_LIST,
+    DATE_LIST,
+    DIC_SPLIT,
+    INPUT_LIST,
+    KEY_COMPONENT_NAME,
+    MULTIPLE_LIST,
+    RANGE_LIST,
+    SELECT_LIST,
+} from '/@/utils/avue/global/variable.js'
+import { t } from '/@/utils/avue/locale/index.js'
+import { createObj, detailDataType, findObject } from '/@/utils/avue/utils/util.js'
+import { validatenull } from '/@/utils/avue/utils/validate.js'
+/**
+ * 计算级联属性
+ */
+export const calcCascader = (list = []) => {
+  list.forEach((ele) => {
+    const cascader = ele.cascader
+    if (!validatenull(cascader)) {
+      const parentProp = ele.prop
+      cascader.forEach((citem) => {
+        const column = findObject(list, citem)
+        if (column) column.parentProp = parentProp
+      })
+    }
+  })
+  return list
+}
+/**
+ * 计算空白列row
+ */
+let count = 0
+export const calcCount = (ele, spanDefault = 12, init = false) => {
+  if (init) count = 0
+  const spanAll = 24
+  count = count + (ele.span || spanDefault) + (ele.offset || 0)
+  if (count === spanAll) {
+    count = 0
+  } else if (count > spanAll) {
+    count = 0 + (ele.span || spanDefault) + (ele.offset || 0)
+  } else if (ele.row && count !== spanAll) {
+    ele.count = spanAll - count
+    count = 0
+  }
+  return ele
+}
+
+/**
+ * 初始化数据格式
+ */
+export const initVal = (value, safe) => {
+  const { type, multiple, dataType, separator = DIC_SPLIT, alone, emitPath, range } = safe
+  let list = value
+  if (
+    (MULTIPLE_LIST.includes(type) && multiple == true) ||
+    (ARRAY_VALUE_LIST.includes(type) && emitPath !== false) ||
+    (RANGE_LIST.includes(type) && range == true)
+  ) {
+    if (!Array.isArray(list)) {
+      if (validatenull(list)) {
+        list = []
+      } else {
+        list = `${list}`.split(separator) || []
+      }
+    }
+    // 数据转化
+    list.forEach((ele, index) => {
+      list[index] = detailDataType(ele, dataType)
+    })
+    if (ARRAY_LIST.includes(type) && validatenull(list) && alone) list = ['']
+  } else {
+    list = detailDataType(list, dataType)
+  }
+  return list
+}
+
+/**
+ * 搜索框获取动态组件
+ */
+export const getSearchType = (column) => {
+  const type = column.type
+  const range = column.searchRange
+  let result = type
+  if (column.searchType) return column.searchType
+  if (['radio', 'checkbox', 'switch'].includes(type)) {
+    result = 'select'
+  } else if (DATE_LIST.includes(type)) {
+    const rangeKey = 'range'
+    if (range) {
+      if (!type.includes(rangeKey)) {
+        result = type + rangeKey
+      } else {
+        result = type
+      }
+    } else result = type.replace(rangeKey, '')
+  } else if (['textarea'].includes(type)) {
+    result = 'input'
+  }
+  return result
+}
+
+/**
+ * 动态获取组件
+ */
+export const getComponent = (type, component) => {
+  let result = type || 'input'
+  if (!validatenull(component)) {
+    return component
+  } else if (ARRAY_LIST.includes(type)) {
+    result = 'array'
+  } else if (['time', 'timerange'].includes(type)) {
+    result = 'time'
+  } else if (DATE_LIST.includes(type)) {
+    result = 'date'
+  } else if (['password', 'textarea', 'search'].includes(type)) {
+    result = 'input'
+  } else if (INPUT_LIST.includes(type)) {
+    result = `input-${type}`
+  }
+  return KEY_COMPONENT_NAME + result
+}
+
+/**
+ * 表格初始化值
+ */
+
+export const formInitVal = (list = []) => {
+  let tableForm = {}
+    list.forEach((ele) => {
+        // ARRAY_VALUE_LIST.includes(ele.type) || (MULTIPLE_LIST.includes(ele.type) && ele.multiple) || ele.dataType === 'array'  只有数据类型为array的才为数组
+    if (ele.dataType === 'array') {
+      tableForm[ele.prop] = []
+    } else if (RANGE_LIST.includes(ele.type) && ele.range == true) {
+      tableForm[ele.prop] = [0, 0]
+    } else if (['rate', 'slider', 'number'].includes(ele.type) || ele.dataType === 'number') {
+      tableForm[ele.prop] = undefined
+    } else {
+      tableForm[ele.prop] = ''
+    }
+    if (ele.bind) {
+      tableForm = createObj(tableForm, ele.bind)
+    }
+    // 表单默认值设置
+    if (!validatenull(ele.value)) {
+      tableForm[ele.prop] = ele.value
+    }
+  })
+  return tableForm
+}
+
+export const getPlaceholder = function (column, type) {
+  const placeholder = column.placeholder
+  const label = column.label
+  if (type === 'search') {
+    const searchPlaceholder = column.searchPlaceholder
+    if (!validatenull(searchPlaceholder)) {
+      return searchPlaceholder
+    } else {
+      return label
+    }
+  } else if (validatenull(placeholder)) {
+    if (SELECT_LIST.includes(column.type)) {
+      return `${t('tip.select')} ${label}`
+    } else {
+      return `${t('tip.input')} ${label}`
+    }
+  }
+
+  return placeholder
+}

package/core/common/detail.js

@@ -0,0 +1,57 @@
+import dayjs from 'dayjs'
+import { ARRAY_VALUE_LIST, DATE_LIST, DIC_SHOW_SPLIT, DIC_SPLIT, MULTIPLE_LIST } from '/@/utils/avue/global/variable.js'
+import { detailDataType, getAsVal, getDicValue, getPasswordChar } from '/@/utils/avue/utils/util.js'
+import { validatenull } from '/@/utils/avue/utils/validate.js'
+export const detail = (row = {}, column = {}, option = {}, dic = []) => {
+  let result = row[column.prop]
+  const type = column.type
+  const separator = column.separator
+  // 深结构绑定处理
+  if (column.bind) result = getAsVal(row, column.bind)
+  if (!validatenull(result)) {
+    const selectFlag = MULTIPLE_LIST.includes(column.type) && column.multiple
+    const arrayFlag = ARRAY_VALUE_LIST.includes(column.type)
+    if ((selectFlag || arrayFlag) && !Array.isArray(result) && !column.dataType) column.dataType = 'string'
+    if (column.dataType) {
+      if (selectFlag || arrayFlag) {
+        if (!Array.isArray(result)) result = result.split(separator || DIC_SPLIT)
+        result.forEach((ele) => {
+          ele = detailDataType(ele, column.dataType)
+        })
+      } else {
+        result = detailDataType(result, column.dataType)
+      }
+    }
+    if ('password' === type) {
+      result = getPasswordChar(result, '*')
+    } else if (DATE_LIST.includes(type) && column.format) {
+      const format = column.format
+      const formatValue = dayjs().format('YYYY-MM-DD')
+      if (type.indexOf('range') !== -1) {
+        let date1 = result[0] || '',
+          date2 = result[1] || ''
+        if (type === 'timerange' && date1.length <= 8 && date2.length < 8) {
+          date1 = `${formatValue} ${date1}`
+          date2 = `${formatValue} ${date2}`
+        }
+        result = [dayjs(date1).format(format), dayjs(date2).format(format)].join(column.separator || '~')
+      } else {
+        if (type === 'time' && result.length <= 8) {
+          result = `${formatValue} ${result}`
+        }
+        result = dayjs(result).format(format)
+      }
+    }
+  }
+  // 字典处理
+  if (!validatenull(dic)) {
+    result = getDicValue(dic, result, column.props || option.props)
+  }
+  // 自定义格式化
+  if (typeof column.formatter === 'function') {
+    result = column.formatter(row, row[column.prop], result, column)
+  } else if (Array.isArray(result) && !validatenull(dic)) {
+    result = result.join(separator || DIC_SHOW_SPLIT)
+  }
+  return result
+}

package/core/common/dic.js

@@ -0,0 +1,203 @@
+import http from '/@/api/http'
+import { DIC_PROPS } from '/@/utils/avue/global/variable.js'
+import { getObjValue } from '/@/utils/avue/utils/util'
+import { detailDataType, getAsVal } from '/@/utils/avue/utils/util.js'
+const key = 'key'
+function getDataType(list = [], props = {}, type) {
+  const valueKey = props.value || DIC_PROPS.value
+  const childrenKey = props.children || DIC_PROPS.children
+  list.forEach((ele) => {
+    ele[valueKey] = detailDataType(ele[valueKey], type)
+    if (ele[childrenKey]) getDataType(ele[childrenKey], props, type)
+  })
+  return list
+}
+
+function getResData(data, props, dataType) {
+  const bind = props.res
+  let res = data
+  const deep = data.data
+  if (bind) {
+    res = getAsVal(res, bind)
+  } else if (deep) {
+    res = Array.isArray(deep) ? deep : [deep]
+  }
+  if (dataType) res = getDataType(res, props, dataType)
+  return res
+}
+export const loadCascaderDic = (columnOption, safe) => {
+  return new Promise((resolve) => {
+    const list = []
+    const result = {}
+    const columnList = columnOption.filter((ele) => ele.parentProp)
+    safe.data.forEach((ele, index) => {
+      if (!safe.cascaderDIC[index]) safe.cascaderDIC[index] = {}
+      columnList.forEach((column) => {
+        if (column.hide !== true && column.dicFlag !== false) {
+          list.push(
+            new Promise((resolve) => {
+              if (ele[column.parentProp]) {
+                sendDic({
+                  url: column.dicUrl,
+                  props: column.props,
+                  method: column.dicMethod,
+                  headers: column.dicHeaders,
+                  formatter: column.dicFormatter,
+                  query: column.dicQuery,
+                  dataType: column.dataType,
+                  form: ele,
+                  value: ele[column.parentProp],
+                }).then((res) => {
+                  const obj = {
+                    prop: column.prop,
+                    data: res,
+                    index: index,
+                  }
+                  safe.cascaderDIC[index][obj.prop] = obj.data
+                  resolve(obj)
+                })
+              } else {
+                const obj = {
+                  prop: column.prop,
+                  data: [],
+                  index: index,
+                }
+                safe.cascaderDIC[index][obj.prop] = obj.data
+                resolve(obj)
+              }
+            })
+          )
+        }
+      })
+    })
+    Promise.all(list).then((data) => {
+      data.forEach((ele) => {
+        if (!result[ele.index]) result[ele.index] = {}
+        result[ele.index][ele.prop] = ele.data
+      })
+      resolve(result)
+    })
+  })
+}
+export const loadDic = (option, safe) => {
+  return new Promise((resolve) => {
+    const list = [],
+      result = {}
+    let notList = [],
+      nameList = [],
+      column = option.column || []
+    column.forEach((ele) => {
+      const url = ele.dicUrl
+      const prop = ele.prop
+      const parentProp = ele.parentProp
+      notList = notList.concat(ele.cascader || [])
+      const flag = ele.dicFlag === false || ele.lazy === true || notList.includes(prop)
+      if (url && !parentProp && !flag) {
+        list.push(
+          new Promise((resolve) => {
+            sendDic({
+              url: url,
+              name: prop,
+              method: ele.dicMethod,
+              headers: ele.dicHeaders,
+              formatter: ele.dicFormatter,
+              props: ele.props,
+              dataType: ele.dataType,
+              query: ele.dicQuery,
+            }).then((res) => {
+              safe.DIC[prop] = res
+              resolve(res)
+            })
+          })
+        )
+      }
+    })
+    Promise.all(list).then((res) => {
+      nameList.forEach((ele, index) => {
+        result[ele] = res[index]
+      })
+      resolve(result)
+    })
+  })
+}
+
+export const loadLocalDic = (option, safe) => {
+  const columnData = {}
+  const optionData = option.dicData || {}
+  option.column.forEach((ele) => {
+    if (ele.dicData) columnData[ele.prop] = getDataType(ele.dicData, ele.props, ele.dataType)
+  })
+  const result = { ...optionData, ...columnData }
+  Object.keys(result).forEach((ele) => {
+    safe.DIC[ele] = result[ele]
+  })
+  return result
+}
+
+export const sendDic = (params) => {
+  let { url, query, method, resKey, props, formatter, headers = {}, value = '', column, form = {} } = params
+  if (column) {
+    url = column.dicUrl
+    method = column.dicMethod
+    headers = column.headers || {}
+    query = column.dicQuery || {}
+    formatter = column.dicFormatter
+    props = column.props
+  }
+  const key = 'key'
+  url = url || ''
+  let list = []
+  const data = {}
+  list = url.match(/[^\{\}]+(?=\})/g) || []
+  list.forEach((ele) => {
+    const eleKey = `{{${ele}}}`
+    const eleValue = form[ele]
+    if (ele === key) url = url.replace(eleKey, value)
+    else url = url.replace(eleKey, eleValue)
+  })
+  if (method === 'post') {
+    list = Object.keys(query)
+    list.forEach((ele) => {
+      const eleKey = query[ele]
+      if (typeof eleKey == 'string') {
+        if (eleKey.match(/\{{|}}/g)) {
+          const eleValue = form[eleKey.replace(/\{{|}}/g, '')]
+          data[ele] = eleValue
+        } else {
+          data[ele] = eleKey
+        }
+      } else {
+        data[ele] = eleKey
+      }
+    })
+  }
+
+  if (props) resKey = (props || {}).res || resKey
+  return new Promise((resolve) => {
+    const callback = (res) => {
+      let list = []
+      if (typeof formatter === 'function') {
+        list = formatter(res)
+      } else {
+        list = getObjValue(res, resKey)
+      }
+      resolve(list)
+    }
+
+    if (method === 'post') {
+      http({
+        url: url,
+        method: 'post',
+        data: data,
+      }).then((res) => {
+        callback(res)
+      })
+    } else {
+      http({
+        url: url,
+      }).then((res) => {
+        callback(res)
+      })
+    }
+  })
+}

package/core/common/event.js

@@ -0,0 +1,154 @@
+import { initVal } from '~/packages/core/common/dataformat.js'
+import { findNode } from '/@/utils/avue/utils/util.js'
+
+export default function () {
+  return {
+    methods: {
+      bindEvent(name, params) {
+        // console.log('bindEvent', this)
+        const item = findNode(this.dic, this.props, this.text)
+        params = Object.assign(params, { column: this.column, dic: this.dic, item }, this.tableData)
+        if (typeof this[name] === 'function') {
+          if (name == 'change') {
+            if (this.column.cell != true) {
+              this[name](params)
+            }
+          } else {
+            this[name](params)
+          }
+        }
+        this.$emit(name, params)
+      },
+      initVal() {
+        this.stringMode = typeof this.modelValue == 'string'
+        this.text = initVal(this.modelValue, this)
+      },
+      getLabelText(item) {
+        if (this.validatenull(item)) return ''
+        if (typeof this.typeformat === 'function') {
+          return this.typeformat(item, this.labelKey, this.valueKey)
+        }
+        return item[this.labelKey]
+      },
+      handleFocus(event) {
+        // console.info('handleFocus', event)
+        this.bindEvent('focus', { value: this.modelValue, event })
+      },
+      handleBlur(event) {
+        //  console.info('handleBlur', event)
+        this.bindEvent('blur', { value: this.modelValue, event })
+      },
+      handleClick(event) {
+        // console.info('handleClick', event)
+        this.bindEvent('click', { value: this.modelValue, event })
+      },
+      handleChange(value) {
+        //console.info('handleChange', value)
+        let result = value
+        const flag = this.isString || this.isNumber || this.stringMode || this.listType === 'picture-img'
+        if (flag && Array.isArray(value)) result = value.join(this.separator)
+        this.bindEvent('change', { value: result })
+        this.$emit('update:modelValue', result)
+      },
+
+      Getimg(img) {
+        if (img.startsWith('http')) {
+          return img
+        } else {
+          return configJson.baseUrl + img
+        }
+      },
+
+      GetVideo(img) {
+        if (img.startsWith('http')) {
+          return img
+        } else {
+          return configJson.baseUrl + img
+        }
+      },
+      Getstyle(StyleData, defaultstyle = '') {
+        // console.info(StyleData, defaultstyle, 'qqq111')
+        if (typeof StyleData === 'string') {
+          if (StyleData == '') {
+            return defaultstyle
+          }
+          StyleData = JSON.parse(StyleData)
+        }
+
+        let styleT = ''
+        for (const key in StyleData) {
+          switch (key) {
+            case 'fontfamily': //字体
+              styleT += `font-family:${StyleData[key]};`
+              break
+            case 'fontweight': //自重
+              styleT += `font-weight:${StyleData[key]};`
+              break
+            case 'fontsize': //大小
+              styleT += `font-size:${StyleData[key]}px;`
+              break
+            case 'color': //大小
+              styleT += `color:${StyleData[key]};`
+              break
+            case 'height': //高
+              styleT += `height:${StyleData[key]};`
+              break
+            case 'width': //宽
+              styleT += `width:${StyleData[key]};`
+              break
+            case 'max-width': //最大宽度
+              styleT += `max-width:${StyleData[key]};`
+              break
+            case 'min-width': //最小宽度
+              styleT += `min-width:${StyleData[key]};`
+              break
+            case 'textalign': //布局
+              styleT += `text-align:${StyleData[key]};`
+              break
+            case 'float': //浮动
+              styleT += `float:${StyleData[key]};`
+              break
+            case 'borderradius': //园角
+              styleT += `border-radius:${StyleData[key]}px;`
+              break
+            case 'paddingtop': //padding
+              styleT += `padding-top:${StyleData[key]}px;`
+              break
+            case 'paddingright': //padding
+              styleT += `padding-right:${StyleData[key]}px;`
+              break
+            case 'paddingbottom': //padding
+              styleT += `padding-bottom:${StyleData[key]}px;`
+              break
+            case 'paddingleft': //padding
+              styleT += `padding-left:${StyleData[key]}px;`
+              break
+            case 'margintop': //padding
+              styleT += `margin-top:${StyleData[key]}px;`
+              break
+            case 'marginright': //padding
+              styleT += `margin-right:${StyleData[key]}px;`
+              break
+            case 'marginbottom': //padding
+              styleT += `margin-bottom:${StyleData[key]}px;`
+              break
+            case 'marginleft': //padding
+              styleT += `margin-left:${StyleData[key]}px;`
+              break
+            case 'backgroundcolor': //背景色
+              styleT += `background-color:${StyleData[key]};`
+              break
+            case 'backgroundimage': //大小
+              styleT += `background-image:url(${StyleData[key]});`
+              break
+            case 'QiTaYangShi': //大小
+              styleT += `${StyleData[key]};`
+              break
+          }
+        }
+        // console.info(styleT)
+        return styleT
+      },
+    },
+  }
+}