@fecp/mobile 1.1.23 → 1.1.25

package/lib/node_modules/.pnpm/vxe-table@4.13.27_vue@3.5.13_typescript@5.7.3_/node_modules/vxe-table/es/table/src/header.js

@@ -0,0 +1,367 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const index = require("../../../../../../../../_virtual/index.js");
+require("../../ui/index.js");
+const util = require("./util.js");
+const index_esm = require("../../../../../../@vxe-ui_core@4.1.3_vue@3.5.13_typescript@5.7.3_/node_modules/@vxe-ui/core/es/index.esm.js");
+const { renderer, renderEmptyElement } = index_esm.VxeUI;
+const renderType = "header";
+const TableHeaderComponent = vue.defineComponent({
+  name: "VxeTableHeader",
+  props: {
+    tableData: Array,
+    tableColumn: Array,
+    tableGroupColumn: Array,
+    fixedColumn: Array,
+    fixedType: {
+      type: String,
+      default: null
+    }
+  },
+  setup(props) {
+    const $xeTable = vue.inject("$xeTable", {});
+    const { xID, props: tableProps, reactData: tableReactData, internalData: tableInternalData } = $xeTable;
+    const { computeColumnOpts, computeColumnDragOpts, computeCellOpts, computeMouseOpts, computeHeaderCellOpts, computeDefaultRowHeight, computeVirtualXOpts } = $xeTable.getComputeMaps();
+    const headerColumn = vue.ref([]);
+    const refElem = vue.ref();
+    const refHeaderScroll = vue.ref();
+    const refHeaderTable = vue.ref();
+    const refHeaderColgroup = vue.ref();
+    const refHeaderTHead = vue.ref();
+    const refHeaderXSpace = vue.ref();
+    const refHeaderBorderRepair = vue.ref();
+    const uploadColumn = () => {
+      const { isGroup } = tableReactData;
+      headerColumn.value = isGroup ? util.convertHeaderColumnToRows(props.tableGroupColumn) : [];
+    };
+    const renderRows = (isGroup, isOptimizeMode, cols, $rowIndex) => {
+      const $xeGrid = $xeTable.xeGrid;
+      const { fixedType } = props;
+      const { resizable: allResizable, columnKey, headerCellClassName, headerCellStyle, showHeaderOverflow: allColumnHeaderOverflow, headerAlign: allHeaderAlign, align: allAlign, mouseConfig } = tableProps;
+      const { currentColumn, dragCol, scrollXLoad, scrollYLoad, overflowX } = tableReactData;
+      const { fullColumnIdData, scrollXStore } = tableInternalData;
+      const virtualXOpts = computeVirtualXOpts.value;
+      const columnOpts = computeColumnOpts.value;
+      const columnDragOpts = computeColumnDragOpts.value;
+      const cellOpts = computeCellOpts.value;
+      const defaultRowHeight = computeDefaultRowHeight.value;
+      const headerCellOpts = computeHeaderCellOpts.value;
+      const currCellHeight = util.getCellHeight(headerCellOpts.height) || defaultRowHeight;
+      const { disabledMethod: dragDisabledMethod, isCrossDrag, isPeerDrag } = columnDragOpts;
+      return cols.map((column, $columnIndex) => {
+        const { type, showHeaderOverflow, headerAlign, align, filters, headerClassName, editRender, cellRender } = column;
+        const colid = column.id;
+        const colRest = fullColumnIdData[colid] || {};
+        const renderOpts = editRender || cellRender;
+        const compConf = renderOpts ? renderer.get(renderOpts.name) : null;
+        const isColGroup = column.children && column.children.length;
+        const fixedHiddenColumn = fixedType ? column.fixed !== fixedType && !isColGroup : !!column.fixed && overflowX;
+        const isPadding = index.default.isBoolean(headerCellOpts.padding) ? headerCellOpts.padding : cellOpts.padding;
+        const headOverflow = index.default.eqNull(showHeaderOverflow) ? allColumnHeaderOverflow : showHeaderOverflow;
+        const headAlign = headerAlign || (compConf ? compConf.tableHeaderCellAlign : "") || allHeaderAlign || align || (compConf ? compConf.tableCellAlign : "") || allAlign;
+        const showEllipsis = headOverflow === "ellipsis";
+        const showTitle = headOverflow === "title";
+        const showTooltip = headOverflow === true || headOverflow === "tooltip";
+        const hasEllipsis = showTitle || showTooltip || showEllipsis;
+        let hasFilter = false;
+        let firstFilterOption = null;
+        if (filters) {
+          firstFilterOption = filters[0];
+          hasFilter = filters.some((item) => item.checked);
+        }
+        const columnIndex = colRest.index;
+        const _columnIndex = colRest._index;
+        const cellParams = {
+          $table: $xeTable,
+          $grid: $xeGrid,
+          $rowIndex,
+          column,
+          columnIndex,
+          $columnIndex,
+          _columnIndex,
+          firstFilterOption,
+          fixed: fixedType,
+          type: renderType,
+          isHidden: fixedHiddenColumn,
+          hasFilter
+        };
+        const thAttrs = {
+          colid,
+          colspan: column.colSpan > 1 ? column.colSpan : null,
+          rowspan: column.rowSpan > 1 ? column.rowSpan : null
+        };
+        const thOns = {
+          onClick: (evnt) => $xeTable.triggerHeaderCellClickEvent(evnt, cellParams),
+          onDblclick: (evnt) => $xeTable.triggerHeaderCellDblclickEvent(evnt, cellParams)
+        };
+        const isColDragCell = columnOpts.drag && columnDragOpts.trigger === "cell";
+        let isDisabledDrag = false;
+        if (isColDragCell) {
+          isDisabledDrag = !!(dragDisabledMethod && dragDisabledMethod(cellParams));
+        }
+        if (mouseConfig || isColDragCell) {
+          thOns.onMousedown = (evnt) => $xeTable.triggerHeaderCellMousedownEvent(evnt, cellParams);
+        }
+        if (columnOpts.drag) {
+          thOns.onDragstart = $xeTable.handleHeaderCellDragDragstartEvent;
+          thOns.onDragend = $xeTable.handleHeaderCellDragDragendEvent;
+          thOns.onDragover = $xeTable.handleHeaderCellDragDragoverEvent;
+          if (isColDragCell) {
+            thOns.onMouseup = $xeTable.handleHeaderCellDragMouseupEvent;
+          }
+        }
+        const isLastColumn = $columnIndex === cols.length - 1;
+        const showResizable = index.default.isBoolean(column.resizable) ? column.resizable : columnOpts.resizable || allResizable;
+        const isAutoCellWidth = !column.resizeWidth && (column.minWidth === "auto" || column.width === "auto");
+        let isVNPreEmptyStatus = false;
+        if (isOptimizeMode && !isGroup) {
+          if (!dragCol || dragCol.id !== colid) {
+            if (scrollXLoad && !column.fixed && !virtualXOpts.immediate && (_columnIndex < scrollXStore.visibleStartIndex - scrollXStore.preloadSize || _columnIndex > scrollXStore.visibleEndIndex + scrollXStore.preloadSize)) {
+              isVNPreEmptyStatus = true;
+            }
+          }
+        }
+        const tcStyle = {};
+        if (hasEllipsis) {
+          tcStyle.height = `${currCellHeight}px`;
+        } else {
+          tcStyle.minHeight = `${currCellHeight}px`;
+        }
+        return vue.h("th", Object.assign(Object.assign(Object.assign({ class: [
+          "vxe-header--column",
+          colid,
+          {
+            [`col--${headAlign}`]: headAlign,
+            [`col--${type}`]: type,
+            "col--last": isLastColumn,
+            "col--fixed": column.fixed,
+            "col--group": isColGroup,
+            "col--ellipsis": hasEllipsis,
+            "fixed--width": !isAutoCellWidth,
+            "fixed--hidden": fixedHiddenColumn,
+            "is--padding": isPadding,
+            "is--sortable": column.sortable,
+            "col--filter": !!filters,
+            "is--filter-active": hasFilter,
+            "is--drag-active": columnOpts.drag && !column.fixed && !isDisabledDrag && (isCrossDrag || isPeerDrag || !column.parentId),
+            "is--drag-disabled": columnOpts.drag && isDisabledDrag,
+            "col--current": currentColumn === column
+          },
+          headerClassName ? index.default.isFunction(headerClassName) ? headerClassName(cellParams) : headerClassName : "",
+          headerCellClassName ? index.default.isFunction(headerCellClassName) ? headerCellClassName(cellParams) : headerCellClassName : ""
+        ], style: headerCellStyle ? index.default.isFunction(headerCellStyle) ? headerCellStyle(cellParams) : headerCellStyle : null }, thAttrs), thOns), { key: columnKey || scrollXLoad || scrollYLoad || columnOpts.useKey || columnOpts.drag || isColGroup ? colid : $columnIndex }), [
+          vue.h("div", {
+            class: ["vxe-cell", {
+              "c--title": showTitle,
+              "c--tooltip": showTooltip,
+              "c--ellipsis": showEllipsis
+            }],
+            style: tcStyle
+          }, isVNPreEmptyStatus || isOptimizeMode && fixedHiddenColumn ? [] : [
+            vue.h("div", {
+              colid,
+              class: "vxe-cell--wrapper"
+            }, column.renderHeader(cellParams))
+          ]),
+          /**
+           * 列宽拖动
+           */
+          !fixedHiddenColumn && showResizable ? vue.h("div", {
+            class: "vxe-cell--col-resizable",
+            onMousedown: (evnt) => $xeTable.handleColResizeMousedownEvent(evnt, fixedType, cellParams),
+            onDblclick: (evnt) => $xeTable.handleColResizeDblclickEvent(evnt, cellParams)
+          }) : renderEmptyElement($xeTable)
+        ]);
+      });
+    };
+    const renderHeads = (isGroup, isOptimizeMode, headerGroups) => {
+      const { fixedType } = props;
+      const { headerRowClassName, headerRowStyle } = tableProps;
+      const { isColLoading, isDragColMove } = tableReactData;
+      const columnOpts = computeColumnOpts.value;
+      const columnDragOpts = computeColumnDragOpts.value;
+      return headerGroups.map((cols, $rowIndex) => {
+        const params = { $table: $xeTable, $rowIndex, fixed: fixedType, type: renderType };
+        if (!isColLoading && columnOpts.drag && columnDragOpts.animation) {
+          return vue.h(vue.TransitionGroup, {
+            key: $rowIndex,
+            name: `vxe-header--col-list${isDragColMove ? "" : "-disabled"}`,
+            tag: "tr",
+            class: [
+              "vxe-header--row",
+              headerRowClassName ? index.default.isFunction(headerRowClassName) ? headerRowClassName(params) : headerRowClassName : ""
+            ],
+            style: headerRowStyle ? index.default.isFunction(headerRowStyle) ? headerRowStyle(params) : headerRowStyle : null
+          }, {
+            default: () => renderRows(isGroup, isOptimizeMode, cols, $rowIndex)
+          });
+        }
+        return vue.h("tr", {
+          key: $rowIndex,
+          class: [
+            "vxe-header--row",
+            headerRowClassName ? index.default.isFunction(headerRowClassName) ? headerRowClassName(params) : headerRowClassName : ""
+          ],
+          style: headerRowStyle ? index.default.isFunction(headerRowStyle) ? headerRowStyle(params) : headerRowStyle : null
+        }, renderRows(isGroup, isOptimizeMode, cols, $rowIndex));
+      });
+    };
+    const renderVN = () => {
+      const { fixedType, fixedColumn, tableColumn } = props;
+      const { mouseConfig, showHeaderOverflow: allColumnHeaderOverflow, spanMethod, footerSpanMethod } = tableProps;
+      const { isGroup, isColLoading, overflowX, scrollXLoad, dragCol } = tableReactData;
+      const { visibleColumn, fullColumnIdData } = tableInternalData;
+      const mouseOpts = computeMouseOpts.value;
+      let renderHeaderList = headerColumn.value;
+      let renderColumnList = tableColumn;
+      let isOptimizeMode = false;
+      if (isGroup) {
+        renderColumnList = visibleColumn;
+      } else {
+        if (scrollXLoad && allColumnHeaderOverflow) {
+          if (spanMethod || footerSpanMethod) ;
+          else {
+            isOptimizeMode = true;
+          }
+        }
+        if (!isOptimizeMode || !isColLoading && (fixedType || !overflowX)) {
+          renderColumnList = visibleColumn;
+        }
+        if (fixedType) {
+          if (isOptimizeMode) {
+            renderColumnList = fixedColumn || [];
+          }
+        }
+        renderHeaderList = [renderColumnList];
+      }
+      if (!fixedType && !isGroup) {
+        if (scrollXLoad && dragCol) {
+          if (renderColumnList.length > 2) {
+            const dCowRest = fullColumnIdData[dragCol.id];
+            if (dCowRest) {
+              const dcIndex = dCowRest._index;
+              const firstCol = renderColumnList[0];
+              const lastCol = renderColumnList[renderColumnList.length - 1];
+              const firstColRest = fullColumnIdData[firstCol.id];
+              const lastColRest = fullColumnIdData[lastCol.id];
+              if (firstColRest && lastColRest) {
+                const fcIndex = firstColRest._index;
+                const lcIndex = lastColRest._index;
+                if (dcIndex < fcIndex) {
+                  renderColumnList = [dragCol].concat(renderColumnList);
+                  renderHeaderList = [[dragCol].concat(renderHeaderList[0])].concat(renderHeaderList.slice(1));
+                } else if (dcIndex > lcIndex) {
+                  renderColumnList = renderColumnList.concat([dragCol]);
+                  renderHeaderList = [renderHeaderList[0].concat([dragCol])].concat(renderHeaderList.slice(1));
+                }
+              }
+            }
+          }
+        }
+      }
+      return vue.h("div", {
+        ref: refElem,
+        class: ["vxe-table--header-wrapper", fixedType ? `fixed-${fixedType}--wrapper` : "body--wrapper"],
+        xid: xID
+      }, [
+        vue.h("div", {
+          ref: refHeaderScroll,
+          class: "vxe-table--header-inner-wrapper",
+          onScroll(evnt) {
+            $xeTable.triggerHeaderScrollEvent(evnt, fixedType);
+          }
+        }, [
+          fixedType ? renderEmptyElement($xeTable) : vue.h("div", {
+            ref: refHeaderXSpace,
+            class: "vxe-body--x-space"
+          }),
+          vue.h("table", {
+            ref: refHeaderTable,
+            class: "vxe-table--header",
+            xid: xID,
+            cellspacing: 0,
+            cellpadding: 0,
+            border: 0,
+            xvm: isOptimizeMode ? "1" : null
+          }, [
+            /**
+             * 列宽
+             */
+            vue.h("colgroup", {
+              ref: refHeaderColgroup
+            }, renderColumnList.map((column, $columnIndex) => {
+              return vue.h("col", {
+                name: column.id,
+                key: $columnIndex,
+                style: {
+                  width: `${column.renderWidth}px`
+                }
+              });
+            })),
+            /**
+            * 头部
+            */
+            vue.h("thead", {
+              ref: refHeaderTHead
+            }, renderHeads(isGroup, isOptimizeMode, renderHeaderList))
+          ]),
+          mouseConfig && mouseOpts.area ? vue.h("div", {
+            class: "vxe-table--cell-area"
+          }, [
+            vue.h("span", {
+              class: "vxe-table--cell-main-area"
+            }),
+            vue.h("span", {
+              class: "vxe-table--cell-copy-area"
+            }),
+            vue.h("span", {
+              class: "vxe-table--cell-extend-area"
+            }),
+            vue.h("span", {
+              class: "vxe-table--cell-multi-area"
+            }),
+            vue.h("span", {
+              class: "vxe-table--cell-active-area"
+            }),
+            vue.h("span", {
+              class: "vxe-table--cell-col-status-area"
+            })
+          ]) : renderEmptyElement($xeTable)
+        ])
+      ]);
+    };
+    vue.watch(() => props.tableColumn, uploadColumn);
+    vue.onMounted(() => {
+      vue.nextTick(() => {
+        const { fixedType } = props;
+        const { internalData } = $xeTable;
+        const { elemStore } = internalData;
+        const prefix = `${fixedType || "main"}-header-`;
+        elemStore[`${prefix}wrapper`] = refElem;
+        elemStore[`${prefix}scroll`] = refHeaderScroll;
+        elemStore[`${prefix}table`] = refHeaderTable;
+        elemStore[`${prefix}colgroup`] = refHeaderColgroup;
+        elemStore[`${prefix}list`] = refHeaderTHead;
+        elemStore[`${prefix}xSpace`] = refHeaderXSpace;
+        elemStore[`${prefix}repair`] = refHeaderBorderRepair;
+        uploadColumn();
+      });
+    });
+    vue.onUnmounted(() => {
+      const { fixedType } = props;
+      const { internalData } = $xeTable;
+      const { elemStore } = internalData;
+      const prefix = `${fixedType || "main"}-header-`;
+      elemStore[`${prefix}wrapper`] = null;
+      elemStore[`${prefix}scroll`] = null;
+      elemStore[`${prefix}table`] = null;
+      elemStore[`${prefix}colgroup`] = null;
+      elemStore[`${prefix}list`] = null;
+      elemStore[`${prefix}xSpace`] = null;
+      elemStore[`${prefix}repair`] = null;
+    });
+    return renderVN;
+  }
+});
+exports.default = TableHeaderComponent;

package/lib/node_modules/.pnpm/vxe-table@4.13.27_vue@3.5.13_typescript@5.7.3_/node_modules/vxe-table/es/table/src/props.js

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+require("../../ui/index.js");
+const index_esm = require("../../../../../../@vxe-ui_core@4.1.3_vue@3.5.13_typescript@5.7.3_/node_modules/@vxe-ui/core/es/index.esm.js");
+const { getConfig } = index_esm.VxeUI;
+const tableComponentProps = {
+  /** 基本属性 */
+  id: [String, Function],
+  // 数据
+  data: Array,
+  // 表格的高度
+  height: [Number, String],
+  // 表格的最小高度
+  minHeight: {
+    type: [Number, String],
+    default: () => getConfig().table.minHeight
+  },
+  // 表格的最大高度
+  maxHeight: [Number, String],
+  // 已废弃，被 column-config.resizable 替换
+  resizable: {
+    type: Boolean,
+    default: () => getConfig().table.resizable
+  },
+  // 是否带有斑马纹
+  stripe: {
+    type: Boolean,
+    default: () => getConfig().table.stripe
+  },
+  // 是否带有边框
+  border: {
+    type: [Boolean, String],
+    default: () => getConfig().table.border
+  },
+  // 已废弃，被 cell-config.padding 替换
+  padding: {
+    type: Boolean,
+    default: null
+  },
+  // 是否圆角边框
+  round: {
+    type: Boolean,
+    default: () => getConfig().table.round
+  },
+  // 表格的尺寸
+  size: {
+    type: String,
+    default: () => getConfig().table.size || getConfig().size
+  },
+  // 列的宽度是否自撑开（可能会被废弃的参数，不要使用）
+  fit: {
+    type: Boolean,
+    default: () => getConfig().table.fit
+  },
+  // 表格是否加载中
+  loading: Boolean,
+  // 所有的列对其方式
+  align: {
+    type: String,
+    default: () => getConfig().table.align
+  },
+  // 所有的表头列的对齐方式
+  headerAlign: {
+    type: String,
+    default: () => getConfig().table.headerAlign
+  },
+  // 所有的表尾列的对齐方式
+  footerAlign: {
+    type: String,
+    default: () => getConfig().table.footerAlign
+  },
+  // 是否显示表头
+  showHeader: {
+    type: Boolean,
+    default: () => getConfig().table.showHeader
+  },
+  // （即将废弃）是否要高亮当前选中行
+  highlightCurrentRow: {
+    type: Boolean,
+    default: () => getConfig().table.highlightCurrentRow
+  },
+  // （即将废弃）鼠标移到行是否要高亮显示
+  highlightHoverRow: {
+    type: Boolean,
+    default: () => getConfig().table.highlightHoverRow
+  },
+  /**
+   * （即将废弃）是否要高亮当前选中列
+   * @deprecated
+   */
+  highlightCurrentColumn: {
+    type: Boolean,
+    default: () => getConfig().table.highlightCurrentColumn
+  },
+  /**
+   * （即将废弃）鼠标移到列是否要高亮显示
+   * @deprecated
+   */
+  highlightHoverColumn: {
+    type: Boolean,
+    default: () => getConfig().table.highlightHoverColumn
+  },
+  // （即将废弃）激活单元格编辑时是否高亮显示
+  highlightCell: Boolean,
+  // 是否显示表尾合计
+  showFooter: Boolean,
+  // 表尾数据
+  footerData: Array,
+  // 表尾合计的计算方法
+  footerMethod: Function,
+  // 给行附加 className
+  rowClassName: [String, Function],
+  // 给单元格附加 className
+  cellClassName: [String, Function],
+  // 给表头的行附加 className
+  headerRowClassName: [String, Function],
+  // 给表头的单元格附加 className
+  headerCellClassName: [String, Function],
+  // 给表尾的行附加 className
+  footerRowClassName: [String, Function],
+  // 给表尾的单元格附加 className
+  footerCellClassName: [String, Function],
+  // 给单元格附加样式
+  cellStyle: [Object, Function],
+  // 给表头单元格附加样式
+  headerCellStyle: [Object, Function],
+  // 给表尾单元格附加样式
+  footerCellStyle: [Object, Function],
+  // 给行附加样式
+  rowStyle: [Object, Function],
+  // 给表头行附加样式
+  headerRowStyle: [Object, Function],
+  // 给表尾行附加样式
+  footerRowStyle: [Object, Function],
+  // 合并指定单元格
+  mergeCells: Array,
+  // 合并指定的表尾
+  mergeFooterItems: Array,
+  // 自定义合并行或列的方法
+  spanMethod: Function,
+  // 表尾合并行或列
+  footerSpanMethod: Function,
+  // 设置所有内容过长时显示为省略号
+  showOverflow: {
+    type: [Boolean, String],
+    default: () => getConfig().table.showOverflow
+  },
+  // 设置表头所有内容过长时显示为省略号
+  showHeaderOverflow: {
+    type: [Boolean, String],
+    default: () => getConfig().table.showHeaderOverflow
+  },
+  // 设置表尾所有内容过长时显示为省略号
+  showFooterOverflow: {
+    type: [Boolean, String],
+    default: () => getConfig().table.showFooterOverflow
+  },
+  /** 高级属性 */
+  // （即将废弃）columnKey 已废弃，被 column-config.useKey 替换
+  columnKey: Boolean,
+  // （即将废弃）rowKey 已废弃，被 row-config.useKey 替换
+  rowKey: Boolean,
+  // （即将废弃）rowId 已废弃，被 row-config.keyField 替换
+  rowId: {
+    type: String,
+    default: () => getConfig().table.rowId
+  },
+  zIndex: Number,
+  emptyText: {
+    type: String,
+    default: () => getConfig().table.emptyText
+  },
+  keepSource: {
+    type: Boolean,
+    default: () => getConfig().table.keepSource
+  },
+  // 是否自动监听父容器变化去更新响应式表格宽高
+  autoResize: {
+    type: Boolean,
+    default: () => getConfig().table.autoResize
+  },
+  // 是否自动根据状态属性去更新响应式表格宽高
+  syncResize: [Boolean, String, Number],
+  // 响应式布局配置项
+  resizeConfig: Object,
+  // 列配置项
+  columnConfig: Object,
+  // 当前列配置项
+  currentColumnConfig: Object,
+  // 单元格配置项
+  cellConfig: Object,
+  // 表头单元格配置项
+  headerCellConfig: Object,
+  // 表尾单元格配置项
+  footerCellConfig: Object,
+  // 行配置项
+  rowConfig: Object,
+  // 行分组配置项
+  rowGroupConfig: Object,
+  // 当前行配置项
+  currentRowConfig: Object,
+  // 已废弃，被 rowDragConfig 替换
+  dragConfig: Object,
+  // 行拖拽排序配置项
+  rowDragConfig: Object,
+  // 列拖拽排序配置项
+  columnDragConfig: Object,
+  // 列调整配置项
+  resizableConfig: Object,
+  // 序号配置项
+  seqConfig: Object,
+  // 排序配置项
+  sortConfig: Object,
+  // 筛选配置项
+  filterConfig: Object,
+  // 单选框配置
+  radioConfig: Object,
+  // 复选框配置项
+  checkboxConfig: Object,
+  // tooltip 配置项
+  tooltipConfig: Object,
+  // 导出配置项
+  exportConfig: Object,
+  // 导入配置项
+  importConfig: Object,
+  // 打印配置项
+  printConfig: Object,
+  // 展开行配置项
+  expandConfig: Object,
+  // 树形结构配置项
+  treeConfig: Object,
+  // 快捷菜单配置项
+  menuConfig: Object,
+  // 鼠标配置项
+  mouseConfig: Object,
+  // 区域配置项
+  areaConfig: Object,
+  // 按键配置项
+  keyboardConfig: Object,
+  // 复制粘/贴配置项
+  clipConfig: Object,
+  // 查找/替换配置项
+  fnrConfig: Object,
+  // 编辑配置项
+  editConfig: Object,
+  // 校验配置项
+  validConfig: Object,
+  // 校验规则配置项
+  editRules: Object,
+  // 加载中配置项
+  loadingConfig: Object,
+  // 空内容渲染配置项
+  emptyRender: Object,
+  // 自定义列配置项
+  customConfig: Object,
+  // （即将废弃）横向虚拟滚动配置项
+  scrollX: Object,
+  // （即将废弃）纵向虚拟滚动配置项
+  scrollY: Object,
+  // 横向虚拟滚动配置项
+  virtualXConfig: Object,
+  // 纵向虚拟滚动配置项
+  virtualYConfig: Object,
+  // 滚动条配置项
+  scrollbarConfig: Object,
+  // （即将废弃）优化相关
+  animat: {
+    type: Boolean,
+    default: () => getConfig().table.animat
+  },
+  // （可能会被废弃的参数，不要使用）
+  delayHover: {
+    type: Number,
+    default: () => getConfig().table.delayHover
+  },
+  // 额外的参数
+  params: Object
+};
+exports.default = tableComponentProps;