first commit

zhaowei

2024-06-25 e68724aee9b82d65796cb29f2d91c409c4a3c008

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
import { AllCells, JVXETypes } from '@/components/jeecg/JVxeTable'
import JVxeCellMixins from '../mixins/JVxeCellMixins'
 
export const JVXERenderType = {
  editer: 'editer',
  spaner: 'spaner',
  default: 'default',
}
 
/** 安装所有vxe组件 */
export function installAllCell(VXETable) {
  // 遍历所有组件批量注册
  Object.keys(AllCells).forEach(type => installOneCell(VXETable, type))
}
 
/** 安装单个vxe组件 */
export function installOneCell(VXETable, type) {
  const switches = getEnhancedMixins(type, 'switches')
  if (switches.editRender === false) {
    installCellRender(VXETable, type, AllCells[type])
  } else {
    installEditRender(VXETable, type, AllCells[type])
  }
}
 
/** 注册可编辑组件 */
export function installEditRender(VXETable, type, comp, spanComp) {
  // 获取当前组件的增强
  const enhanced = getEnhancedMixins(type)
  // span 组件
  if (!spanComp && AllCells[type + ':span']) {
    spanComp = AllCells[type + ':span']
  } else {
    spanComp = AllCells[JVXETypes.normal]
  }
  // 添加渲染
  VXETable.renderer.add(JVXETypes._prefix + type, {
    // 可编辑模板
    renderEdit: createRender(comp, enhanced, JVXERenderType.editer),
    // 显示模板
    renderCell: createRender(spanComp, enhanced, JVXERenderType.spaner),
    // 增强注册
    ...enhanced.installOptions,
  })
}
 
/** 注册普通组件 */
export function installCellRender(VXETable, type, comp = AllCells[JVXETypes.normal]) {
  // 获取当前组件的增强
  const enhanced = getEnhancedMixins(type)
  VXETable.renderer.add(JVXETypes._prefix + type, {
    // 默认显示模板
    renderDefault: createRender(comp, enhanced, JVXERenderType.default),
    // 增强注册
    ...enhanced.installOptions,
  })
}
 
function createRender(comp, enhanced, renderType) {
  return function (h, renderOptions, params) {
    return [h(comp, {
      props: {
        value: params.row[params.column.property],
        row: params.row,
        column: params.column,
        params: params,
        renderOptions: renderOptions,
        renderType: renderType,
      }
    })]
  }
}
 
// 已混入的组件增强
const AllCellsMixins = new Map()
 
/** 获取某个组件的增强 */
export function getEnhanced(type) {
  let cell = AllCells[type]
  if (cell && cell.enhanced) {
    return cell.enhanced
  }
  return null
}
 
/**
 * 获取某个组件的增强（混入默认值）
 *
 * @param type JVXETypes
 * @param name 可空，增强名称，留空返回所有增强
 */
export function getEnhancedMixins(type, name) {
  const getByName = (e) => name ? e[name] : e
  if (AllCellsMixins.has(type)) {
    return getByName(AllCellsMixins.get(type))
  }
  let defEnhanced = JVxeCellMixins.enhanced
  let enhanced = getEnhanced(type)
  if (enhanced) {
    Object.keys(defEnhanced).forEach(key => {
      let def = defEnhanced[key]
      if (enhanced.hasOwnProperty(key)) {
        // 方法如果存在就不覆盖
        if (typeof def !== 'function' && typeof def !== 'string') {
          enhanced[key] = Object.assign({}, def, enhanced[key])
        }
      } else {
        enhanced[key] = def
      }
    })
    AllCellsMixins.set(type, enhanced)
    return getByName(enhanced)
  }
  AllCellsMixins.set(type, defEnhanced)
  return getByName(defEnhanced)
}
 
 
/** 辅助方法：替换${...}变量 */
export function replaceProps(col, value) {
  if (value && typeof value === 'string') {
    let text = value
    text = text.replace(/\${title}/g, col.title)
    text = text.replace(/\${key}/g, col.key)
    text = text.replace(/\${defaultValue}/g, col.defaultValue)
    return text
  }
  return value
}