vxe-table 3.8.8-beta.6 → 3.8.8-beta.8

package/packages/table/src/methods.js

@@ -1103,6 +1103,63 @@ const Methods = {
     }
     return this.$nextTick()
   },
+  getCellElement (row, fieldOrColumn) {
+    const column = handleFieldOrColumn(this, fieldOrColumn)
+    if (!column) {
+      return null
+    }
+    const { $refs } = this
+    const rowid = getRowid(this, row)
+    let bodyElem = null
+    if (column) {
+      bodyElem = $refs[`${column.fixed || 'table'}Body`] || $refs.tableBody
+    }
+    if (bodyElem && bodyElem.$el) {
+      return bodyElem.$el.querySelector(`.vxe-body--row[rowid="${rowid}"] .${column.id}`)
+    }
+    return null
+  },
+  getCellLabel (row, fieldOrColumn) {
+    const column = handleFieldOrColumn(this, fieldOrColumn)
+    if (!column) {
+      return null
+    }
+    const formatter = column.formatter
+    const cellValue = UtilTools.getCellValue(row, column)
+    let cellLabel = cellValue
+    if (formatter) {
+      let rest, formatData
+      const { fullAllDataRowMap } = this
+      const colid = column.id
+      const cacheFormat = fullAllDataRowMap.has(row)
+      if (cacheFormat) {
+        rest = fullAllDataRowMap.get(row)
+        formatData = rest.formatData
+        if (!formatData) {
+          formatData = fullAllDataRowMap.get(row).formatData = {}
+        }
+        if (rest && formatData[colid]) {
+          if (formatData[colid].value === cellValue) {
+            return formatData[colid].label
+          }
+        }
+      }
+      const formatParams = { cellValue, row, rowIndex: this.getRowIndex(row), column, columnIndex: this.getColumnIndex(column) }
+      if (XEUtils.isString(formatter)) {
+        const gFormatOpts = formats.get(formatter)
+        cellLabel = gFormatOpts && gFormatOpts.cellFormatMethod ? gFormatOpts.cellFormatMethod(formatParams) : ''
+      } else if (XEUtils.isArray(formatter)) {
+        const gFormatOpts = formats.get(formatter[0])
+        cellLabel = gFormatOpts && gFormatOpts.cellFormatMethod ? gFormatOpts.cellFormatMethod(formatParams, ...formatter.slice(1)) : ''
+      } else {
+        cellLabel = formatter(formatParams)
+      }
+      if (formatData) {
+        formatData[colid] = { value: cellValue, label: cellLabel }
+      }
+    }
+    return cellLabel
+  },
   /**
    * 检查是否为临时行数据
    * @param {Row} row 行对象
@@ -1156,6 +1213,13 @@ const Methods = {
     const columns = this.visibleColumn
     return XEUtils.isUndefined(columnIndex) ? columns.slice(0) : columns[columnIndex]
   },
+  /**
+   * 根据列获取列的唯一主键
+   */
+  getColid (fieldOrColumn) {
+    const column = handleFieldOrColumn(this, fieldOrColumn)
+    return column ? column.id : null
+  },
   /**
    * 根据列的唯一主键获取列
    * @param {String} colid 列主键
@@ -1287,8 +1351,8 @@ const Methods = {
           if (valueList.length && !allRemoteFilter) {
             const { filterMethod, filterRender, field } = column
             const compConf = filterRender ? VXETable.renderer.get(filterRender.name) : null
-            const compFilterMethod = compConf && compConf.renderFilter ? compConf.filterMethod : null
-            const defaultFilterMethod = compConf ? compConf.defaultFilterMethod : null
+            const compFilterMethod = compConf && compConf.renderFilter ? (compConf.tableFilterMethod || compConf.filterMethod) : null
+            const defaultFilterMethod = compConf ? (compConf.defaultTableFilterMethod || compConf.defaultFilterMethod) : null
             const cellValue = UtilTools.getCellValue(row, column)
             if (filterMethod) {
               return itemList.some((item) => filterMethod({ value: item.value, option: item, cellValue, row, column, $table: this }))
@@ -1620,8 +1684,7 @@ const Methods = {
         this.clearCopyCellArea()
       }
     }
-    this.saveCustomVisible()
-    this.saveCustomSort()
+    this.saveCustomStore()
     this.analyColumnWidth()
     return this.refreshColumn(true)
   },
@@ -1854,6 +1917,12 @@ const Methods = {
     })
     return storeData
   },
+  saveCustomStore () {
+    this.saveCustomVisible()
+    this.saveCustomSort()
+    this.saveCustomFixed()
+    this.saveCustomResizable()
+  },
   saveCustomResizable (isReset) {
     const { id, collectColumn, customConfig, customOpts } = this
     const { storage } = customOpts
@@ -2729,7 +2798,7 @@ const Methods = {
         const { filterStore, isCtxMenu, ctxMenuStore, editStore, editOpts, editConfig, mouseConfig, mouseOpts, keyboardConfig, keyboardOpts, treeConfig, treeOpts, highlightCurrentRow, currentRow, bodyCtxMenu, rowOpts } = this
         const { selected, actived } = editStore
         const { keyCode } = evnt
-        const isBack = keyCode === 8
+        const hasBackspaceKey = keyCode === 8
         const isTab = keyCode === 9
         const isEnter = keyCode === 13
         const isEsc = keyCode === 27
@@ -2849,11 +2918,11 @@ const Methods = {
           } else if (actived.row || actived.column) {
             this.moveTabSelected(actived.args, hasShiftKey, evnt)
           }
-        } else if (keyboardConfig && (isDel || (treeConfig && (rowOpts.isCurrent || highlightCurrentRow) && currentRow ? isBack && keyboardOpts.isArrow : isBack))) {
+        } else if (keyboardConfig && (treeConfig || isEnableConf(editConfig)) && (isDel || (treeConfig && (rowOpts.isCurrent || highlightCurrentRow) && currentRow ? hasBackspaceKey && keyboardOpts.isArrow : hasBackspaceKey))) {
           if (!isEditStatus) {
             const { delMethod, backMethod } = keyboardOpts
             // 如果是删除键
-            if (keyboardOpts.isDel && (selected.row || selected.column)) {
+            if (keyboardOpts.isDel && isEnableConf(editConfig) && (selected.row || selected.column)) {
               const delPaqrams = {
                 row: selected.row,
                 rowIndex: this.getRowIndex(selected.row),
@@ -2866,7 +2935,7 @@ const Methods = {
               } else {
                 setCellValue(selected.row, selected.column, null)
               }
-              if (isBack) {
+              if (hasBackspaceKey) {
                 if (backMethod) {
                   backMethod({
                     row: selected.row,
@@ -2883,7 +2952,7 @@ const Methods = {
                 this.updateFooter()
               }
               this.emitEvent('cell-delete-value', delPaqrams, evnt)
-            } else if (isBack && keyboardOpts.isArrow && treeConfig && (rowOpts.isCurrent || highlightCurrentRow) && currentRow) {
+            } else if (hasBackspaceKey && keyboardOpts.isArrow && treeConfig && (rowOpts.isCurrent || highlightCurrentRow) && currentRow) {
               // 如果树形表格回退键关闭当前行返回父节点
               const { parent: parentRow } = XEUtils.findTree(this.afterFullData, item => item === currentRow, { children: childrenField })
               if (parentRow) {
@@ -3394,8 +3463,11 @@ const Methods = {
   },
   handleToggleCheckRowEvent (evnt, params) {
     const { selectCheckboxMaps, checkboxOpts } = this
-    const { checkField } = checkboxOpts
+    const { checkField, trigger } = checkboxOpts
     const { row } = params
+    if (trigger === 'manual') {
+      return
+    }
     let value = false
     if (checkField) {
       value = !XEUtils.get(row, checkField)
@@ -3410,8 +3482,12 @@ const Methods = {
   },
   triggerCheckRowEvent (evnt, params, value) {
     const { checkboxOpts, afterFullData } = this
-    const { checkMethod } = checkboxOpts
+    const { checkMethod, trigger } = checkboxOpts
     const { row } = params
+    if (trigger === 'manual') {
+      return
+    }
+    evnt.stopPropagation()
     if (checkboxOpts.isShiftKey && evnt.shiftKey && !this.treeConfig) {
       const checkboxRecords = this.getCheckboxRecords()
       if (checkboxRecords.length) {
@@ -3771,18 +3847,31 @@ const Methods = {
       }
     }
   },
+  handleCheckAllEvent (evnt, value) {
+    this.handleCheckedAllCheckboxRow(value)
+    if (evnt) {
+      this.emitEvent('checkbox-all', { records: this.getCheckboxRecords(), reserves: this.getCheckboxReserveRecords(), indeterminates: this.getCheckboxIndeterminateRecords(), checked: value }, evnt)
+    }
+  },
   /**
    * 多选，选中所有事件
    */
   triggerCheckAllEvent (evnt, value) {
-    this.handleCheckedAllCheckboxRow(value)
-    this.emitEvent('checkbox-all', { records: this.getCheckboxRecords(), reserves: this.getCheckboxReserveRecords(), indeterminates: this.getCheckboxIndeterminateRecords(), checked: value }, evnt)
+    const { checkboxOpts } = this
+    const { trigger } = checkboxOpts
+    if (trigger === 'manual') {
+      return
+    }
+    if (evnt) {
+      evnt.stopPropagation()
+    }
+    this.handleCheckAllEvent(evnt, value)
   },
   /**
    * 多选，切换所有行的选中状态
    */
   toggleAllCheckboxRow () {
-    this.triggerCheckAllEvent(null, !this.isAllSelected)
+    this.handleCheckAllEvent(null, !this.isAllSelected)
     return this.$nextTick()
   },
   /**
@@ -3838,6 +3927,11 @@ const Methods = {
   triggerRadioRowEvent (evnt, params) {
     const { selectRadioRow: oldValue, radioOpts } = this
     const { row } = params
+    const { trigger } = radioOpts
+    if (trigger === 'manual') {
+      return
+    }
+    evnt.stopPropagation()
     let newValue = row
     let isChange = oldValue !== newValue
     if (isChange) {
@@ -4413,7 +4507,11 @@ const Methods = {
   triggerRowExpandEvent (evnt, params) {
     const { expandOpts, rowExpandLazyLoadedMaps, expandColumn: column } = this
     const { row } = params
-    const { lazy } = expandOpts
+    const { lazy, trigger } = expandOpts
+    if (trigger === 'manual') {
+      return
+    }
+    evnt.stopPropagation()
     const rowid = getRowid(this, row)
     if (!lazy || !rowExpandLazyLoadedMaps[rowid]) {
       const expanded = !this.isRowExpandByRow(row)
@@ -4688,7 +4786,11 @@ const Methods = {
   triggerTreeExpandEvent (evnt, params) {
     const { treeOpts, treeExpandLazyLoadedMaps } = this
     const { row, column } = params
-    const { lazy } = treeOpts
+    const { lazy, trigger } = treeOpts
+    if (trigger === 'manual') {
+      return
+    }
+    evnt.stopPropagation()
     const rowid = getRowid(this, row)
     if (!lazy || !treeExpandLazyLoadedMaps[rowid]) {
       const expanded = !this.isTreeExpandByRow(row)
@@ -5259,7 +5361,7 @@ const Methods = {
         const type = 'change'
         if (this.hasCellRules) {
           if (this.hasCellRules(type, row, column)) {
-            const cell = this.getCell(row, column)
+            const cell = this.getCellElement(row, column)
             if (cell) {
               return this.validCellRules(type, row, column, cellValue)
                 .then(() => {
@@ -5404,54 +5506,12 @@ const Methods = {
   /*************************
    * Publish methods
    *************************/
+  /**
+   * 已废弃，被 getCellElement 替换
+   * @deprecated
+   */
   getCell (row, column) {
-    const { $refs } = this
-    const rowid = getRowid(this, row)
-    let bodyElem = null
-    if (column) {
-      bodyElem = $refs[`${column.fixed || 'table'}Body`] || $refs.tableBody
-    }
-    if (bodyElem && bodyElem.$el) {
-      return bodyElem.$el.querySelector(`.vxe-body--row[rowid="${rowid}"] .${column.id}`)
-    }
-    return null
-  },
-  getCellLabel (row, column) {
-    const formatter = column.formatter
-    const cellValue = UtilTools.getCellValue(row, column)
-    let cellLabel = cellValue
-    if (formatter) {
-      let rest, formatData
-      const { fullAllDataRowMap } = this
-      const colid = column.id
-      const cacheFormat = fullAllDataRowMap.has(row)
-      if (cacheFormat) {
-        rest = fullAllDataRowMap.get(row)
-        formatData = rest.formatData
-        if (!formatData) {
-          formatData = fullAllDataRowMap.get(row).formatData = {}
-        }
-        if (rest && formatData[colid]) {
-          if (formatData[colid].value === cellValue) {
-            return formatData[colid].label
-          }
-        }
-      }
-      const formatParams = { cellValue, row, rowIndex: this.getRowIndex(row), column, columnIndex: this.getColumnIndex(column) }
-      if (XEUtils.isString(formatter)) {
-        const gFormatOpts = formats.get(formatter)
-        cellLabel = gFormatOpts && gFormatOpts.cellFormatMethod ? gFormatOpts.cellFormatMethod(formatParams) : ''
-      } else if (XEUtils.isArray(formatter)) {
-        const gFormatOpts = formats.get(formatter[0])
-        cellLabel = gFormatOpts && gFormatOpts.cellFormatMethod ? gFormatOpts.cellFormatMethod(formatParams, ...formatter.slice(1)) : ''
-      } else {
-        cellLabel = formatter(formatParams)
-      }
-      if (formatData) {
-        formatData[colid] = { value: cellValue, label: cellLabel }
-      }
-    }
-    return cellLabel
+    return this.getCellElement(row, column)
   },
   findRowIndexOf (list, row) {
     return row ? XEUtils.findIndexOf(list, item => this.eqRow(item, row)) : -1

package/packages/table/src/table.js

@@ -70,7 +70,7 @@ function renderEmptyContenet (h, _vm) {
     emptyContent = $scopedSlots.empty.call(_vm, params, h)
   } else {
     const compConf = emptyOpts.name ? VXETable.renderer.get(emptyOpts.name) : null
-    const renderTableEmptyView = compConf ? compConf.renderTableEmptyView || compConf.renderEmpty : null
+    const renderTableEmptyView = compConf ? (compConf.renderTableEmptyView || compConf.renderEmpty) : null
     if (renderTableEmptyView) {
       emptyContent = getSlotVNs(renderTableEmptyView.call(_vm, h, emptyOpts, params))
     } else {

package/packages/validator/src/mixin.js

@@ -221,7 +221,7 @@ export default {
               })
             }
             const posAndFinish = () => {
-              firstErrParams.cell = this.getCell(firstErrParams.row, firstErrParams.column)
+              firstErrParams.cell = this.getCellElement(firstErrParams.row, firstErrParams.column)
               DomTools.scrollToView(firstErrParams.cell)
               this.handleValidError(firstErrParams).then(finish)
             }

package/styles/custom.scss

@@ -63,19 +63,19 @@
   border: 1px solid $vxe-table-border-color;
   border-radius: $vxe-border-radius;
   box-shadow: $vxe-base-popup-box-shadow;
-  &.placement--topLeft {
+  &.placement--top-left {
     top: 2px;
     left: 2px;
   }
-  &.placement--topRight {
+  &.placement--top-right {
     top: 2px;
     right: 2px;
   }
-  &.placement--bottomLeft {
+  &.placement--bottom-left {
     bottom: 2px;
     left: 2px;
   }
-  &.placement--bottomRight {
+  &.placement--bottom-right {
     bottom: 2px;
     right: 2px;
   }

package/styles/table.scss

@@ -1032,6 +1032,15 @@
       padding-left: 0.5em;
     }
   }
+  .vxe-body--expanded-row {
+    &.is--padding {
+      & > .vxe-body--expanded-column {
+        & > .vxe-body--expanded-cell {
+          padding: $vxe-table-expand-padding-default;
+        }
+      }
+    }
+  }
   .vxe-body--expanded-column {
     border-bottom: $vxe-table-border-width solid $vxe-table-border-color;
     border-right: $vxe-table-border-width solid $vxe-table-border-color;

package/styles/variable.scss

@@ -113,6 +113,8 @@ $vxe-table-cell-extend-area-border-color: $vxe-table-cell-area-border-color !def
 $vxe-table-cell-active-area-border-color: $vxe-table-cell-area-border-color !default;
 $vxe-table-cell-area-background-color: rgba(64,158,255,0.2) !default;
 
+$vxe-table-expand-padding-default: 16px !default;
+
 $vxe-table-checkbox-range-border-width: 1px !default;
 $vxe-table-checkbox-range-border-color: #006af1 !default;
 $vxe-table-checkbox-range-background-color: rgba(50,128,252,0.2) !default;

package/types/table.d.ts

@@ -1558,6 +1558,10 @@ export interface TableKeyboardConfig {
    * 是否开启删除键功能
    */
   isDel?: boolean;
+  /**
+   * 是否开启回退键功能
+   */
+  isBack?: boolean
   /**
    * 是否开启回车移动上下行移动
    */

package/types/v-x-e-table/renderer.d.ts

@@ -33,31 +33,124 @@ export interface RendererMapOptions {
    */
   isFooter?: boolean;
 
-  // 筛选渲染
+  /**
+   * 请使用 tableFilterClassName
+   * @deprecated
+   */
   filterClassName?: string | ((params: ColumnFilterRenderParams) => string | VNodeClassName)
+  tableFilterClassName?: string | ((params: ColumnFilterRenderParams) => string | VNodeClassName)
+
+  /**
+   * 请使用 showTableFilterFooter
+   * @deprecated
+   */
   showFilterFooter?: boolean;
+  showTableFilterFooter?: boolean;
+
+  /**
+   * 已废弃，请使用 renderTableFilter
+   * @deprecated
+   */
   renderFilter?(h: CreateElement, renderOpts: ColumnFilterRenderOptions, params: ColumnFilterRenderParams): SlotVNodeType | SlotVNodeType[];
+  renderTableFilter?(h: CreateElement, renderOpts: ColumnFilterRenderOptions, params: ColumnFilterRenderParams): SlotVNodeType | SlotVNodeType[];
+
+  /**
+   * 已废弃，请使用 tableFilterMethod
+   * @deprecated
+   */
   filterMethod?(params: ColumnFilterMethodParams): boolean;
+  tableFilterMethod?(params: ColumnFilterMethodParams): boolean;
+
+  /**
+   * 已废弃，请使用 tableFilterResetMethod
+   * @deprecated
+   */
   filterResetMethod?(params: ColumnFilterResetParams): void;
-  // 默认行为
+  tableFilterResetMethod?(params: ColumnFilterResetParams): void;
+
+  /**
+   * 已废弃，请使用 defaultTableFilterMethod
+   * @deprecated
+   */
   defaultFilterMethod?(params: ColumnFilterMethodParams): boolean;
+  defaultTableFilterMethod?(params: ColumnFilterMethodParams): boolean;
 
-  // 单元格渲染
+  /**
+   * 已废弃，请使用 tableCellClassName
+   * @deprecated
+   */
   cellClassName?: string | ((params: ColumnCellRenderParams | ColumnEditRenderParams) => string | VNodeClassName)
+  tableCellClassName?: string | ((params: ColumnCellRenderParams | ColumnEditRenderParams) => string | VNodeClassName)
+
+  /**
+   * 已废弃，请使用 tableCellStyle
+   * @deprecated
+   */
   cellStyle?: VNodeStyle | ((params: ColumnCellRenderParams | ColumnEditRenderParams) => VNodeStyle)
+  tableCellStyle?: VNodeStyle | ((params: ColumnCellRenderParams | ColumnEditRenderParams) => VNodeStyle)
+
+  /**
+   * 已废弃，请使用 renderTableHeader
+   * @deprecated
+   */
   renderHeader?(h: CreateElement, renderOpts: ColumnCellRenderOptions | ColumnEditRenderOptions, params: ColumnCellRenderParams | ColumnEditRenderParams): SlotVNodeType | SlotVNodeType[];
+  renderTableHeader?(h: CreateElement, renderOpts: ColumnCellRenderOptions | ColumnEditRenderOptions, params: ColumnCellRenderParams | ColumnEditRenderParams): SlotVNodeType | SlotVNodeType[];
+
+  /**
+   * 已废弃，请使用 renderTableDefault
+   * @deprecated
+   */
   renderDefault?(h: CreateElement, renderOpts: ColumnCellRenderOptions | ColumnEditRenderOptions, params: ColumnCellRenderParams | ColumnEditRenderParams): SlotVNodeType | SlotVNodeType[];
+  renderTableDefault?(h: CreateElement, renderOpts: ColumnCellRenderOptions | ColumnEditRenderOptions, params: ColumnCellRenderParams | ColumnEditRenderParams): SlotVNodeType | SlotVNodeType[];
+
+  /**
+   * 已废弃，请使用 renderTableFooter
+   * @deprecated
+   */
   renderFooter?(h: CreateElement, renderOpts: ColumnCellRenderOptions | ColumnEditRenderOptions, params: any): SlotVNodeType | SlotVNodeType[];
+  renderTableFooter?(h: CreateElement, renderOpts: ColumnCellRenderOptions | ColumnEditRenderOptions, params: any): SlotVNodeType | SlotVNodeType[];
+
+  /**
+   * 已废弃，请使用 tableExportMethod
+   * @deprecated
+   */
   exportMethod?(params: ColumnExportCellRenderParams): string;
+  tableExportMethod?(params: ColumnExportCellRenderParams): string;
+
+  /**
+   * 已废弃，请使用 tableFooterExportMethod
+   * @deprecated
+   */
   footerExportMethod?(params: ColumnExportFooterRenderParams): string;
+  tableFooterExportMethod?(params: ColumnExportFooterRenderParams): string;
 
-  // 编辑渲染
+  /**
+   * 已废弃，请使用 tableAutofocus
+   * @deprecated
+   */
   autofocus?: string | ((params: ColumnCellRenderParams | ColumnEditRenderParams) => HTMLElement | null);
+  tableAutofocus?: string | ((params: ColumnCellRenderParams | ColumnEditRenderParams) => HTMLElement | null);
+
+  /**
+   * 已废弃，请使用 renderTableEdit
+   * @deprecated
+   */
   renderEdit?(h: CreateElement, renderOpts: ColumnCellRenderOptions | ColumnEditRenderOptions, params: ColumnCellRenderParams | ColumnEditRenderParams): SlotVNodeType | SlotVNodeType[];
+  renderTableEdit?(h: CreateElement, renderOpts: ColumnCellRenderOptions | ColumnEditRenderOptions, params: ColumnCellRenderParams | ColumnEditRenderParams): SlotVNodeType | SlotVNodeType[];
+
+  /**
+   * 已废弃，请使用 renderTableCell
+   * @deprecated
+   */
   renderCell?(h: CreateElement, renderOpts: ColumnCellRenderOptions | ColumnEditRenderOptions, params: ColumnCellRenderParams | ColumnEditRenderParams): SlotVNodeType | SlotVNodeType[];
+  renderTableCell?(h: CreateElement, renderOpts: ColumnCellRenderOptions | ColumnEditRenderOptions, params: ColumnCellRenderParams | ColumnEditRenderParams): SlotVNodeType | SlotVNodeType[];
 
-  // 内容渲染
+  /**
+   * 已废弃，请使用 renderTableExpand
+   * @deprecated
+   */
   renderExpand?(h: CreateElement, renderOpts: ColumnContentRenderOptions, params: ColumnCellRenderParams | ColumnEditRenderParams): SlotVNodeType | SlotVNodeType[];
+  renderTableExpand?(h: CreateElement, renderOpts: ColumnContentRenderOptions, params: ColumnCellRenderParams | ColumnEditRenderParams): SlotVNodeType | SlotVNodeType[];
 
   // 工具栏-按钮渲染
   toolbarButtonClassName?: string | ((params: ToolbarButtonRenderParams) => string | VNodeClassName)
@@ -65,26 +158,82 @@ export interface RendererMapOptions {
   toolbarToolClassName?: string | ((params: ToolbarToolRenderParams) => string | VNodeClassName)
   renderToolbarTool?(h: CreateElement, renderOpts: ToolbarToolRenderOptions, params: ToolbarToolRenderParams): SlotVNodeType | SlotVNodeType[];
 
-  // 表单-项渲染
+  /**
+   * 已废弃，请使用 formItemClassName
+   * @deprecated
+   */
   itemClassName?: string | ((params: FormItemRenderParams) => string | VNodeClassName)
+  formItemClassName?: string | ((params: FormItemRenderParams) => string | VNodeClassName)
+
+  /**
+   * 已废弃，请使用 formItemStyle
+   * @deprecated
+   */
   itemStyle?: VNodeStyle | ((params: FormItemRenderParams) => VNodeStyle)
+  formItemStyle?: VNodeStyle | ((params: FormItemRenderParams) => VNodeStyle)
+
+  /**
+   * 已废弃，请使用 formItemContentClassName
+   * @deprecated
+   */
   itemContentClassName?: string | ((params: FormItemRenderParams) => string | VNodeClassName)
+  formItemContentClassName?: string | ((params: FormItemRenderParams) => string | VNodeClassName)
+
+  /**
+   * 已废弃，请使用 formItemContentStyle
+   * @deprecated
+   */
   itemContentStyle?: VNodeStyle | ((params: FormItemRenderParams) => VNodeStyle)
+  formItemContentStyle?: VNodeStyle | ((params: FormItemRenderParams) => VNodeStyle)
+
+  /**
+   * 已废弃，请使用 formItemTitleClassName
+   * @deprecated
+   */
   itemTitleClassName?: string | ((params: FormItemRenderParams) => string | VNodeClassName)
+  formItemTitleClassName?: string | ((params: FormItemRenderParams) => string | VNodeClassName)
+
+  /**
+   * 已废弃，请使用 formItemTitleStyle
+   * @deprecated
+   */
   itemTitleStyle?: VNodeStyle | ((params: FormItemRenderParams) => VNodeStyle)
+  formItemTitleStyle?: VNodeStyle | ((params: FormItemRenderParams) => VNodeStyle)
+
+  /**
+   * 已废弃，请使用 renderFormItemTitle
+   * @deprecated
+   */
   renderItemTitle?(h: CreateElement, renderOpts: FormItemRenderOptions, params: FormItemRenderParams): SlotVNodeType | SlotVNodeType[];
+  renderFormItemTitle?(h: CreateElement, renderOpts: FormItemRenderOptions, params: FormItemRenderParams): SlotVNodeType | SlotVNodeType[];
+
+  /**
+   * 已废弃，请使用 renderFormItemContent
+   * @deprecated
+   */
   renderItemContent?(h: CreateElement, renderOpts: FormItemRenderOptions, params: FormItemRenderParams): SlotVNodeType | SlotVNodeType[];
+  renderFormItemContent?(h: CreateElement, renderOpts: FormItemRenderOptions, params: FormItemRenderParams): SlotVNodeType | SlotVNodeType[];
+
+  /**
+   * 已废弃，请使用 formItemVisibleMethod
+   * @deprecated
+   */
   itemVisibleMethod?(params: FormItemVisibleParams): boolean;
-  itemResetMethod?(params: FormItemResetParams): void;
+  formItemVisibleMethod?(params: FormItemVisibleParams): boolean;
 
-  // 空内容渲染
-  renderTableEmptyView?(h: CreateElement, renderOpts: TableEmptyRender, params: EmptyRenderParams): SlotVNodeType | SlotVNodeType[];
+  /**
+   * 已废弃，请使用 formItemResetMethod
+   * @deprecated
+   */
+  itemResetMethod?(params: FormItemResetParams): void;
+  formItemResetMethod?(params: FormItemResetParams): void;
 
   /**
    * 已废弃，请使用 renderTableEmptyView
    * @deprecated
    */
   renderEmpty?(h: CreateElement, renderOpts: TableEmptyRender, params: EmptyRenderParams): SlotVNodeType | SlotVNodeType[];
+  renderTableEmptyView?(h: CreateElement, renderOpts: TableEmptyRender, params: EmptyRenderParams): SlotVNodeType | SlotVNodeType[];
 
   [key: string]: any;
 }