ele-admin-plus 1.1.4-beta.3 → 1.1.5-beta.1

package/es/ele-virtual-table/components/footer-row.js

@@ -0,0 +1,105 @@
+import { defineComponent, computed, openBlock, createElementBlock, normalizeStyle, Fragment, renderList, normalizeClass, createElementVNode, toDisplayString } from "vue";
+import { getSumValue } from "../util";
+const _sfc_main = defineComponent({
+  name: "FooterRow",
+  props: {
+    /** 表格主体列配置 */
+    bodyCols: Array,
+    /** 表格主体列宽 */
+    colSizes: Array,
+    /** 表格主体所有列合计宽度 */
+    sumWidth: Number,
+    /** 表格数据 */
+    tableData: Array,
+    /** 表格行高 */
+    rowHeight: Number,
+    /** 合计行文本 */
+    sumText: String,
+    /** 合计行自定义方法 */
+    summaryMethod: Function
+  },
+  emits: {
+    /** 单元格鼠标移入事件 */
+    mouseenter: (_e) => true
+  },
+  setup(props, { emit }) {
+    const userSums = computed(() => {
+      if (typeof props.summaryMethod !== "function" || !props.bodyCols) {
+        return;
+      }
+      const columns = props.bodyCols.map((col) => {
+        return { ...col.originalCol || {}, property: col.dataKey };
+      });
+      return props.summaryMethod({ columns, data: props.tableData });
+    });
+    const sumCols = computed(() => {
+      if (!props.bodyCols) {
+        return [];
+      }
+      const sums = userSums.value;
+      return props.bodyCols.map((column, i) => {
+        const colSize = props.colSizes ? props.colSizes[i] : void 0;
+        const sumValue = getSumValue(props.tableData, column.dataKey);
+        const col = column.originalCol;
+        return {
+          key: i + "-" + column.key,
+          width: colSize && colSize.width || 0,
+          fixedLeft: colSize ? colSize.fixedLeft : void 0,
+          fixedRight: colSize ? colSize.fixedRight : void 0,
+          text: sums == null ? i === 0 ? props.sumText : sumValue : sums[i],
+          align: col ? col.align : void 0,
+          fixed: col ? col.fixed : void 0,
+          isFixedLeftLast: column.isFixedLeftLast,
+          isFixedRightFirst: column.isFixedRightFirst
+        };
+      });
+    });
+    const onMouseenter = (e) => {
+      emit("mouseenter", e);
+    };
+    return { sumCols, onMouseenter };
+  }
+});
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const _hoisted_1 = { class: "ele-table-cell" };
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("div", {
+    class: "ele-table-foot-tr",
+    style: normalizeStyle({ width: (_ctx.sumWidth || 0) + "px", height: (_ctx.rowHeight || 0) + "px" })
+  }, [
+    (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.sumCols, (col) => {
+      return openBlock(), createElementBlock("div", {
+        key: col.key,
+        class: normalizeClass([
+          "ele-table-td",
+          "is-ellipsis",
+          { "is-align-left": col.align === "left" },
+          { "is-align-center": col.align === "center" },
+          { "is-align-right": col.align === "right" },
+          { "is-fixed-left": col.fixed === "left" || col.fixed === true },
+          { "is-fixed-right": col.fixed === "right" },
+          { "is-fixed-left-last": col.isFixedLeftLast },
+          { "is-fixed-right-first": col.isFixedRightFirst }
+        ]),
+        style: normalizeStyle({
+          width: col.width + "px",
+          left: col.fixedLeft,
+          right: col.fixedRight
+        }),
+        onMouseenter: _cache[0] || (_cache[0] = (...args) => _ctx.onMouseenter && _ctx.onMouseenter(...args))
+      }, [
+        createElementVNode("div", _hoisted_1, toDisplayString(col.text), 1)
+      ], 38);
+    }), 128))
+  ], 4);
+}
+const footerRow = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export {
+  footerRow as default
+};

package/es/ele-virtual-table/components/header-cell.d.ts

@@ -0,0 +1,97 @@
+import type { PropType } from 'vue';
+import { StyleValues } from '../../ele-app/types';
+import type { Column, FilterValue } from '../../ele-data-table/types';
+import type { HeaderColumn, SortBy, CellFilterChangeParams, CustomRenderProps, ColSize } from '../types';
+declare const _default: import("vue").DefineComponent<{
+    /** 当前列配置 */
+    column: PropType<HeaderColumn>;
+    /** 当前列索引 */
+    columnIndex: NumberConstructor;
+    /** 当前行索引 */
+    headerIndex: NumberConstructor;
+    /** 当前列宽 */
+    colSize: PropType<ColSize>;
+    /** 表格排序状态 */
+    sortBy: PropType<SortBy>;
+    /** 表格当前筛选值 */
+    filterValue: PropType<FilterValue>;
+    /** 表格是否是全选状态 */
+    isCheckAll: BooleanConstructor;
+    /** 表格是否是半选状态 */
+    isIndeterminate: BooleanConstructor;
+    /** 是否禁用表头选择框 */
+    disabledCheckbox: BooleanConstructor;
+    /** 表格尺寸 */
+    tableSize: PropType<"" | "default" | "small" | "large" | undefined>;
+    /** 单元格类名自定义 */
+    headerCellClass: PropType<import("element-plus/es/components/table/src/table/defaults").CellCls<import("../../ele-data-table/types").DataItem> | undefined>;
+    /** 单元格样式自定义 */
+    headerCellStyle: PropType<import("element-plus/es/components/table/src/table/defaults").CellStyle<import("../../ele-data-table/types").DataItem> | undefined>;
+    /** 表头单元格是否溢出省略 */
+    headerEllipsis: BooleanConstructor;
+    /** 表格行高 */
+    rowHeight: NumberConstructor;
+}, {
+    originalCol: import("vue").ComputedRef<Column | undefined>;
+    cellClass: import("vue").ComputedRef<string>;
+    cellStyle: import("vue").ComputedRef<StyleValues | undefined>;
+    cellTitle: import("vue").ComputedRef<string | undefined>;
+    renderOpt: import("vue").ComputedRef<CustomRenderProps>;
+    onCheckedChange: (checked: boolean) => void;
+    onFilterChange: (value: FilterValue) => void;
+    onClick: (e: MouseEvent) => void;
+    onContextmenu: (e: MouseEvent) => void;
+    onMouseenter: (e: MouseEvent) => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    /** 多选框选中改变事件 */
+    checkedChange: (_checked: boolean) => true;
+    /** 列筛选改变事件 */
+    filterChange: (_params: CellFilterChangeParams) => true;
+    /** 点击事件 */
+    click: (_col: Column, _e: MouseEvent) => true;
+    /** 右键事件 */
+    contextmenu: (_col: Column, _e: MouseEvent) => true;
+    /** 鼠标移入事件 */
+    mouseenter: (_col: Column, _e: MouseEvent) => true;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    /** 当前列配置 */
+    column: PropType<HeaderColumn>;
+    /** 当前列索引 */
+    columnIndex: NumberConstructor;
+    /** 当前行索引 */
+    headerIndex: NumberConstructor;
+    /** 当前列宽 */
+    colSize: PropType<ColSize>;
+    /** 表格排序状态 */
+    sortBy: PropType<SortBy>;
+    /** 表格当前筛选值 */
+    filterValue: PropType<FilterValue>;
+    /** 表格是否是全选状态 */
+    isCheckAll: BooleanConstructor;
+    /** 表格是否是半选状态 */
+    isIndeterminate: BooleanConstructor;
+    /** 是否禁用表头选择框 */
+    disabledCheckbox: BooleanConstructor;
+    /** 表格尺寸 */
+    tableSize: PropType<"" | "default" | "small" | "large" | undefined>;
+    /** 单元格类名自定义 */
+    headerCellClass: PropType<import("element-plus/es/components/table/src/table/defaults").CellCls<import("../../ele-data-table/types").DataItem> | undefined>;
+    /** 单元格样式自定义 */
+    headerCellStyle: PropType<import("element-plus/es/components/table/src/table/defaults").CellStyle<import("../../ele-data-table/types").DataItem> | undefined>;
+    /** 表头单元格是否溢出省略 */
+    headerEllipsis: BooleanConstructor;
+    /** 表格行高 */
+    rowHeight: NumberConstructor;
+}>> & {
+    onMouseenter?: ((_col: Column, _e: MouseEvent) => any) | undefined;
+    onClick?: ((_col: Column, _e: MouseEvent) => any) | undefined;
+    onContextmenu?: ((_col: Column, _e: MouseEvent) => any) | undefined;
+    onFilterChange?: ((_params: CellFilterChangeParams) => any) | undefined;
+    onCheckedChange?: ((_checked: boolean) => any) | undefined;
+}, {
+    headerEllipsis: boolean;
+    isCheckAll: boolean;
+    isIndeterminate: boolean;
+    disabledCheckbox: boolean;
+}, {}>;
+export default _default;

package/es/ele-virtual-table/components/header-cell.js

@@ -0,0 +1,261 @@
+import { defineComponent, computed, resolveComponent, openBlock, createElementBlock, normalizeClass, normalizeStyle, createElementVNode, createBlock, normalizeProps, mergeProps, withCtx, createTextVNode, toDisplayString, createCommentVNode } from "vue";
+import { CellRender, getColKey, getOrderValue } from "../util";
+import CellCheckbox from "./cell-checkbox";
+import CellFilter from "./cell-filter";
+const _sfc_main = defineComponent({
+  name: "HeaderCell",
+  components: { CellCheckbox, CellFilter, CellRender },
+  props: {
+    /** 当前列配置 */
+    column: Object,
+    /** 当前列索引 */
+    columnIndex: Number,
+    /** 当前行索引 */
+    headerIndex: Number,
+    /** 当前列宽 */
+    colSize: Object,
+    /** 表格排序状态 */
+    sortBy: Object,
+    /** 表格当前筛选值 */
+    filterValue: Object,
+    /** 表格是否是全选状态 */
+    isCheckAll: Boolean,
+    /** 表格是否是半选状态 */
+    isIndeterminate: Boolean,
+    /** 是否禁用表头选择框 */
+    disabledCheckbox: Boolean,
+    /** 表格尺寸 */
+    tableSize: String,
+    /** 单元格类名自定义 */
+    headerCellClass: [String, Function],
+    /** 单元格样式自定义 */
+    headerCellStyle: [Object, Function],
+    /** 表头单元格是否溢出省略 */
+    headerEllipsis: Boolean,
+    /** 表格行高 */
+    rowHeight: Number
+  },
+  emits: {
+    /** 多选框选中改变事件 */
+    checkedChange: (_checked) => true,
+    /** 列筛选改变事件 */
+    filterChange: (_params) => true,
+    /** 点击事件 */
+    click: (_col, _e) => true,
+    /** 右键事件 */
+    contextmenu: (_col, _e) => true,
+    /** 鼠标移入事件 */
+    mouseenter: (_col, _e) => true
+  },
+  setup(props, { emit, slots }) {
+    const originalCol = computed(() => {
+      return props.column ? props.column.originalCol : void 0;
+    });
+    const cellParam = computed(() => {
+      return {
+        column: originalCol.value,
+        columnIndex: props.columnIndex,
+        rowIndex: props.headerIndex
+      };
+    });
+    const cellClass = computed(() => {
+      const classes = ["el-table-v2__header-cell", "ele-table-td"];
+      if (props.column) {
+        if (!props.column.colspan) {
+          classes.push("is-none");
+        } else if (props.column.colspan > 1) {
+          classes.push("is-multi-cell");
+        }
+        if (!props.column.rowspan) {
+          classes.push("is-placeholder");
+        } else if (props.column.rowspan > 1) {
+          classes.push("is-multi-row");
+        }
+      }
+      const col = originalCol.value;
+      if (col) {
+        const align = col.headerAlign || col.align;
+        if (align) {
+          classes.push("is-align-" + align);
+        }
+        if (col.sortable === true || col.sortable === "custom") {
+          classes.push("is-sortable");
+        }
+        if (props.sortBy != null && getColKey(col) === props.sortBy.key) {
+          const sortClass = getOrderValue(props.sortBy.order);
+          if (sortClass) {
+            classes.push("is-" + sortClass);
+          }
+        }
+        if (col.filters && col.filters.length && props.filterValue && props.filterValue.length) {
+          classes.push("is-filtered");
+        }
+        if (col.type === "selection") {
+          classes.push("is-selection");
+        }
+        if (col.type === "expand") {
+          classes.push("is-expand");
+        }
+        if (props.headerEllipsis) {
+          classes.push("is-ellipsis");
+        }
+        if (col.fixed === "right") {
+          classes.push("is-fixed-right");
+        } else if (col.fixed === "left" || col.fixed === true) {
+          classes.push("is-fixed-left");
+        }
+        if (props.column) {
+          if (props.column.isFixedLeftLast) {
+            classes.push("is-fixed-left-last");
+          }
+          if (props.column.isFixedRightFirst) {
+            classes.push("is-fixed-right-first");
+          }
+        }
+        if (typeof props.headerCellClass === "function") {
+          const temp = props.headerCellClass(cellParam.value);
+          if (temp) {
+            classes.push(temp);
+          }
+        } else if (props.headerCellClass) {
+          classes.push(props.headerCellClass);
+        }
+        if (col.labelClassName) {
+          classes.push(col.labelClassName);
+        }
+      }
+      return classes.join(" ");
+    });
+    const cellHeight = computed(() => {
+      if (props.rowHeight == null || props.column == null || !props.column.rowspan || props.column.rowspan <= 1) {
+        return;
+      }
+      return props.column.rowspan * props.rowHeight + "px";
+    });
+    const cellStyle = computed(() => {
+      if (!props.colSize) {
+        return;
+      }
+      const { width, fixedLeft, fixedRight } = props.colSize;
+      const userStyle = props.headerCellStyle;
+      const param = cellParam.value;
+      return [
+        {
+          width: width + "px",
+          height: cellHeight.value,
+          left: fixedLeft,
+          right: fixedRight
+        },
+        (typeof userStyle === "function" ? userStyle(param) : userStyle) || {}
+      ];
+    });
+    const cellTitle = computed(() => {
+      return originalCol.value ? originalCol.value.label : void 0;
+    });
+    const renderOpt = computed(() => {
+      const col = originalCol.value;
+      if (col) {
+        const param = { column: col, $index: props.columnIndex };
+        if (col.headerSlot) {
+          const headerSlot = slots[col.headerSlot];
+          if (typeof headerSlot === "function") {
+            return { render: headerSlot, params: [param] };
+          }
+        }
+        if (typeof col.renderHeader === "function") {
+          return { render: col.renderHeader, params: [param] };
+        }
+      }
+      return {};
+    });
+    const onCheckedChange = (checked) => {
+      emit("checkedChange", checked);
+    };
+    const onFilterChange = (value) => {
+      emit("filterChange", { column: originalCol.value, value });
+    };
+    const onClick = (e) => {
+      emit("click", originalCol.value, e);
+    };
+    const onContextmenu = (e) => {
+      emit("contextmenu", originalCol.value, e);
+    };
+    const onMouseenter = (e) => {
+      emit("mouseenter", originalCol.value, e);
+    };
+    return {
+      originalCol,
+      cellClass,
+      cellStyle,
+      cellTitle,
+      renderOpt,
+      onCheckedChange,
+      onFilterChange,
+      onClick,
+      onContextmenu,
+      onMouseenter
+    };
+  }
+});
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const _hoisted_1 = {
+  key: 0,
+  class: "ele-table-cell"
+};
+const _hoisted_2 = ["title"];
+const _hoisted_3 = {
+  key: 0,
+  class: "ele-table-sorter"
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_CellCheckbox = resolveComponent("CellCheckbox");
+  const _component_CellRender = resolveComponent("CellRender");
+  const _component_CellFilter = resolveComponent("CellFilter");
+  return openBlock(), createElementBlock("div", {
+    class: normalizeClass(_ctx.cellClass),
+    style: normalizeStyle(_ctx.cellStyle),
+    onClick: _cache[0] || (_cache[0] = (...args) => _ctx.onClick && _ctx.onClick(...args)),
+    onContextmenu: _cache[1] || (_cache[1] = (...args) => _ctx.onContextmenu && _ctx.onContextmenu(...args)),
+    onMouseenter: _cache[2] || (_cache[2] = (...args) => _ctx.onMouseenter && _ctx.onMouseenter(...args))
+  }, [
+    _ctx.originalCol ? (openBlock(), createElementBlock("div", _hoisted_1, [
+      createElementVNode("div", {
+        class: "ele-cell-title",
+        title: _ctx.headerEllipsis ? _ctx.cellTitle : void 0
+      }, [
+        _ctx.originalCol.type === "selection" ? (openBlock(), createBlock(_component_CellCheckbox, {
+          key: 0,
+          checked: _ctx.isCheckAll,
+          indeterminate: _ctx.isIndeterminate,
+          disabled: _ctx.disabledCheckbox,
+          size: _ctx.tableSize,
+          onChange: _ctx.onCheckedChange
+        }, null, 8, ["checked", "indeterminate", "disabled", "size", "onChange"])) : (openBlock(), createBlock(_component_CellRender, normalizeProps(mergeProps({ key: 1 }, _ctx.renderOpt)), {
+          default: withCtx(() => [
+            createTextVNode(toDisplayString(_ctx.cellTitle), 1)
+          ]),
+          _: 1
+        }, 16))
+      ], 8, _hoisted_2),
+      _ctx.originalCol.sortable ? (openBlock(), createElementBlock("div", _hoisted_3)) : createCommentVNode("", true),
+      _ctx.originalCol.filters && _ctx.originalCol.filters.length ? (openBlock(), createBlock(_component_CellFilter, {
+        key: 1,
+        filtered: _ctx.filterValue,
+        filterMultiple: _ctx.originalCol.filterMultiple,
+        filters: _ctx.originalCol.filters,
+        filterPlacement: _ctx.originalCol.filterPlacement,
+        onChange: _ctx.onFilterChange
+      }, null, 8, ["filtered", "filterMultiple", "filters", "filterPlacement", "onChange"])) : createCommentVNode("", true)
+    ])) : createCommentVNode("", true)
+  ], 38);
+}
+const headerCell = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export {
+  headerCell as default
+};

package/es/ele-virtual-table/components/header-row.d.ts

@@ -0,0 +1,89 @@
+import type { PropType } from 'vue';
+import type { Column, Filter } from '../../ele-data-table/types';
+import type { VirtualColumn, HeaderColumns, SortBy, CellFilterChangeParams, ColSize } from '../types';
+declare const _default: import("vue").DefineComponent<{
+    /** 表头行配置 */
+    headerCols: PropType<HeaderColumns>;
+    /** 表头所有行列宽 */
+    headerColSizes: PropType<ColSize[]>;
+    /** 当前行索引 */
+    headerIndex: NumberConstructor;
+    /** 表格排序状态 */
+    sortBy: PropType<SortBy>;
+    /** 表格筛选值 */
+    filtered: PropType<Filter>;
+    /** 表格是否是全选状态 */
+    isCheckAll: BooleanConstructor;
+    /** 表格是否是半选状态 */
+    isIndeterminate: BooleanConstructor;
+    /** 是否禁用表头选择框 */
+    disabledCheckbox: BooleanConstructor;
+    /** 表格尺寸 */
+    tableSize: PropType<"" | "default" | "small" | "large" | undefined>;
+    /** 表头单元格类名自定义 */
+    headerCellClass: PropType<import("element-plus/es/components/table/src/table/defaults").CellCls<import("../../ele-data-table/types").DataItem> | undefined>;
+    /** 表头单元样式自定义 */
+    headerCellStyle: PropType<import("element-plus/es/components/table/src/table/defaults").CellStyle<import("../../ele-data-table/types").DataItem> | undefined>;
+    /** 表头单元格是否溢出省略 */
+    headerEllipsis: BooleanConstructor;
+    /** 表格行高 */
+    rowHeight: NumberConstructor;
+}, {
+    getKey: (column: VirtualColumn, columnIndex: number) => string;
+    getFiltered: (column: VirtualColumn) => import("../../ele-data-table/types").FilterValue;
+    onCellCheckedChange: (checked: boolean) => void;
+    onCellFilterChange: (params: CellFilterChangeParams) => void;
+    onCellClick: (col: Column, e: MouseEvent) => void;
+    onCellContextmenu: (col: Column, e: MouseEvent) => void;
+    onCellMouseenter: (col: Column, e: MouseEvent) => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    /** 多选框选中改变事件 */
+    checkedChange: (_checked: boolean) => true;
+    /** 列筛选改变事件 */
+    filterChange: (_params: CellFilterChangeParams) => true;
+    /** 单元格点击事件 */
+    cellClick: (_col: Column, _e: MouseEvent) => true;
+    /** 单元格右键事件 */
+    cellContextmenu: (_col: Column, _e: MouseEvent) => true;
+    /** 单元格鼠标移入事件 */
+    cellMouseenter: (_col: Column, _e: MouseEvent) => true;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    /** 表头行配置 */
+    headerCols: PropType<HeaderColumns>;
+    /** 表头所有行列宽 */
+    headerColSizes: PropType<ColSize[]>;
+    /** 当前行索引 */
+    headerIndex: NumberConstructor;
+    /** 表格排序状态 */
+    sortBy: PropType<SortBy>;
+    /** 表格筛选值 */
+    filtered: PropType<Filter>;
+    /** 表格是否是全选状态 */
+    isCheckAll: BooleanConstructor;
+    /** 表格是否是半选状态 */
+    isIndeterminate: BooleanConstructor;
+    /** 是否禁用表头选择框 */
+    disabledCheckbox: BooleanConstructor;
+    /** 表格尺寸 */
+    tableSize: PropType<"" | "default" | "small" | "large" | undefined>;
+    /** 表头单元格类名自定义 */
+    headerCellClass: PropType<import("element-plus/es/components/table/src/table/defaults").CellCls<import("../../ele-data-table/types").DataItem> | undefined>;
+    /** 表头单元样式自定义 */
+    headerCellStyle: PropType<import("element-plus/es/components/table/src/table/defaults").CellStyle<import("../../ele-data-table/types").DataItem> | undefined>;
+    /** 表头单元格是否溢出省略 */
+    headerEllipsis: BooleanConstructor;
+    /** 表格行高 */
+    rowHeight: NumberConstructor;
+}>> & {
+    onCellClick?: ((_col: Column, _e: MouseEvent) => any) | undefined;
+    onCellContextmenu?: ((_col: Column, _e: MouseEvent) => any) | undefined;
+    onFilterChange?: ((_params: CellFilterChangeParams) => any) | undefined;
+    onCheckedChange?: ((_checked: boolean) => any) | undefined;
+    onCellMouseenter?: ((_col: Column, _e: MouseEvent) => any) | undefined;
+}, {
+    headerEllipsis: boolean;
+    isCheckAll: boolean;
+    isIndeterminate: boolean;
+    disabledCheckbox: boolean;
+}, {}>;
+export default _default;

package/es/ele-virtual-table/components/header-row.js

@@ -0,0 +1,126 @@
+import { defineComponent, resolveComponent, openBlock, createElementBlock, Fragment, renderList, createBlock, createSlots, withCtx, renderSlot, normalizeProps, guardReactiveProps } from "vue";
+import { getColFiltered } from "../util";
+import HeaderCell from "./header-cell";
+const _sfc_main = defineComponent({
+  name: "HeaderRow",
+  components: { HeaderCell },
+  props: {
+    /** 表头行配置 */
+    headerCols: Array,
+    /** 表头所有行列宽 */
+    headerColSizes: Array,
+    /** 当前行索引 */
+    headerIndex: Number,
+    /** 表格排序状态 */
+    sortBy: Object,
+    /** 表格筛选值 */
+    filtered: Object,
+    /** 表格是否是全选状态 */
+    isCheckAll: Boolean,
+    /** 表格是否是半选状态 */
+    isIndeterminate: Boolean,
+    /** 是否禁用表头选择框 */
+    disabledCheckbox: Boolean,
+    /** 表格尺寸 */
+    tableSize: String,
+    /** 表头单元格类名自定义 */
+    headerCellClass: [String, Function],
+    /** 表头单元样式自定义 */
+    headerCellStyle: [Object, Function],
+    /** 表头单元格是否溢出省略 */
+    headerEllipsis: Boolean,
+    /** 表格行高 */
+    rowHeight: Number
+  },
+  emits: {
+    /** 多选框选中改变事件 */
+    checkedChange: (_checked) => true,
+    /** 列筛选改变事件 */
+    filterChange: (_params) => true,
+    /** 单元格点击事件 */
+    cellClick: (_col, _e) => true,
+    /** 单元格右键事件 */
+    cellContextmenu: (_col, _e) => true,
+    /** 单元格鼠标移入事件 */
+    cellMouseenter: (_col, _e) => true
+  },
+  setup(props, { emit }) {
+    const getKey = (column, columnIndex) => {
+      return props.headerIndex + "-" + (column.key ?? columnIndex);
+    };
+    const getFiltered = (column) => {
+      return getColFiltered(column.originalCol, props.filtered);
+    };
+    const onCellCheckedChange = (checked) => {
+      emit("checkedChange", checked);
+    };
+    const onCellFilterChange = (params) => {
+      emit("filterChange", params);
+    };
+    const onCellClick = (col, e) => {
+      emit("cellClick", col, e);
+    };
+    const onCellContextmenu = (col, e) => {
+      emit("cellContextmenu", col, e);
+    };
+    const onCellMouseenter = (col, e) => {
+      emit("cellMouseenter", col, e);
+    };
+    return {
+      getKey,
+      getFiltered,
+      onCellCheckedChange,
+      onCellFilterChange,
+      onCellClick,
+      onCellContextmenu,
+      onCellMouseenter
+    };
+  }
+});
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_HeaderCell = resolveComponent("HeaderCell");
+  return openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.headerCols, (column, index) => {
+    return openBlock(), createBlock(_component_HeaderCell, {
+      key: _ctx.getKey(column, index),
+      column,
+      columnIndex: index,
+      headerIndex: _ctx.headerIndex,
+      colSize: _ctx.headerColSizes ? _ctx.headerColSizes[index] : void 0,
+      sortBy: _ctx.sortBy,
+      filterValue: _ctx.getFiltered(column),
+      isCheckAll: _ctx.isCheckAll,
+      isIndeterminate: _ctx.isIndeterminate,
+      disabledCheckbox: _ctx.disabledCheckbox,
+      tableSize: _ctx.tableSize,
+      headerCellClass: _ctx.headerCellClass,
+      headerCellStyle: _ctx.headerCellStyle,
+      headerEllipsis: _ctx.headerEllipsis,
+      rowHeight: _ctx.rowHeight,
+      onCheckedChange: _ctx.onCellCheckedChange,
+      onFilterChange: _ctx.onCellFilterChange,
+      onClick: _ctx.onCellClick,
+      onContextmenu: _ctx.onCellContextmenu,
+      onMouseenter: _ctx.onCellMouseenter
+    }, createSlots({ _: 2 }, [
+      renderList(Object.keys(_ctx.$slots), (name) => {
+        return {
+          name,
+          fn: withCtx((slotProps) => [
+            renderSlot(_ctx.$slots, name, normalizeProps(guardReactiveProps(slotProps || {})))
+          ])
+        };
+      })
+    ]), 1032, ["column", "columnIndex", "headerIndex", "colSize", "sortBy", "filterValue", "isCheckAll", "isIndeterminate", "disabledCheckbox", "tableSize", "headerCellClass", "headerCellStyle", "headerEllipsis", "rowHeight", "onCheckedChange", "onFilterChange", "onClick", "onContextmenu", "onMouseenter"]);
+  }), 128);
+}
+const headerRow = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export {
+  headerRow as default
+};