ep-craft 0.1.37 → 0.1.39

package/dist/components/table-v2/src/table-grid.js

@@ -0,0 +1,240 @@
+import { defineComponent as q, inject as Q, provide as X, onActivated as Z, nextTick as $, unref as i, createVNode as L, ref as A, computed as f, watch as O } from "vue";
+import ee from "../../virtual-list/src/components/dynamic-size-grid.js";
+import te from "../../virtual-list/src/components/fixed-size-grid.js";
+import { isNumber as N } from "../../../utils/types.js";
+import "lodash-unified";
+import "@vueuse/core";
+import { isObject as oe } from "@vue/shared";
+import "@element-plus/icons-vue";
+import "./components/cell.js";
+import "./components/header-cell.js";
+import "./header-row.js";
+import re from "./components/header.js";
+import "./row.js";
+import { TableV2InjectionKey as ie, TABLE_V2_GRID_INJECTION_KEY as le } from "./tokens.js";
+import "../../icon/index.js";
+import "./components/expand-icon.js";
+import { tableV2GridProps as ce } from "./grid.js";
+import { sum as ae } from "./utils.js";
+const ne = "EpTableV2Grid", de = (r) => {
+  const c = A(), a = A(), n = A(0), u = f(() => {
+    const {
+      data: e,
+      rowHeight: t,
+      estimatedRowHeight: o
+    } = r;
+    if (!o)
+      return e.length * t;
+  }), s = f(() => {
+    const {
+      fixedData: e,
+      rowHeight: t
+    } = r;
+    return ((e == null ? void 0 : e.length) || 0) * t;
+  }), h = f(() => ae(r.headerHeight)), T = f(() => {
+    const {
+      height: e
+    } = r;
+    return Math.max(0, e - i(h) - i(s));
+  }), H = f(() => i(h) + i(s) > 0), R = ({
+    data: e,
+    rowIndex: t
+  }) => e[t][r.rowKey];
+  function b({
+    rowCacheStart: e,
+    rowCacheEnd: t,
+    rowVisibleStart: o,
+    rowVisibleEnd: l
+  }) {
+    var d;
+    (d = r.onRowsRendered) == null || d.call(r, {
+      rowCacheStart: e,
+      rowCacheEnd: t,
+      rowVisibleStart: o,
+      rowVisibleEnd: l
+    });
+  }
+  function y(e, t) {
+    var o;
+    (o = a.value) == null || o.resetAfterRowIndex(e, t);
+  }
+  function g(e, t) {
+    const o = i(c), l = i(a);
+    oe(e) ? (o == null || o.scrollToLeft(e.scrollLeft), n.value = e.scrollLeft, l == null || l.scrollTo(e)) : (o == null || o.scrollToLeft(e), n.value = e, l == null || l.scrollTo({
+      scrollLeft: e,
+      scrollTop: t
+    }));
+  }
+  function I(e) {
+    var t;
+    (t = i(a)) == null || t.scrollTo({
+      scrollTop: e
+    });
+  }
+  function x(e, t) {
+    const o = i(a);
+    if (!o) return;
+    const l = n.value;
+    o.scrollToItem(e, 0, t), l && g({
+      scrollLeft: l
+    });
+  }
+  function G() {
+    var e, t;
+    (e = i(a)) == null || e.$forceUpdate(), (t = i(c)) == null || t.$forceUpdate();
+  }
+  return O(() => r.bodyWidth, () => {
+    var e;
+    N(r.estimatedRowHeight) && ((e = a.value) == null || e.resetAfter({
+      columnIndex: 0
+    }, !1));
+  }), {
+    bodyRef: a,
+    forceUpdate: G,
+    fixedRowHeight: s,
+    gridHeight: T,
+    hasHeader: H,
+    headerHeight: h,
+    headerRef: c,
+    totalHeight: u,
+    itemKey: R,
+    onItemRendered: b,
+    resetAfterRowIndex: y,
+    scrollTo: g,
+    scrollToTop: I,
+    scrollToRow: x,
+    scrollLeft: n
+  };
+}, Ee = /* @__PURE__ */ q({
+  name: ne,
+  props: ce,
+  setup(r, {
+    slots: c,
+    expose: a
+  }) {
+    const {
+      ns: n
+    } = Q(ie), {
+      bodyRef: u,
+      fixedRowHeight: s,
+      gridHeight: h,
+      hasHeader: T,
+      headerRef: H,
+      headerHeight: R,
+      totalHeight: b,
+      forceUpdate: y,
+      itemKey: g,
+      onItemRendered: I,
+      resetAfterRowIndex: x,
+      scrollTo: G,
+      scrollToTop: e,
+      scrollToRow: t,
+      scrollLeft: o
+    } = de(r);
+    X(le, o), Z(async () => {
+      var m;
+      await $();
+      const d = (m = u.value) == null ? void 0 : m.states.scrollTop;
+      d && e(Math.round(d) + 1);
+    }), a({
+      forceUpdate: y,
+      /**
+       * @description fetch total height
+       */
+      totalHeight: b,
+      /**
+       * @description scroll to a position
+       */
+      scrollTo: G,
+      /**
+       * @description scroll vertically to position y
+       */
+      scrollToTop: e,
+      /**
+       * @description scroll to a given row
+       * @params row {Number} which row to scroll to
+       * @params strategy {ScrollStrategy} use what strategy to scroll to
+       */
+      scrollToRow: t,
+      /**
+       * @description reset rendered state after row index
+       */
+      resetAfterRowIndex: x
+    });
+    const l = () => r.bodyWidth;
+    return () => {
+      const {
+        cache: d,
+        columns: m,
+        data: w,
+        fixedData: W,
+        useIsScrolling: D,
+        scrollbarAlwaysOn: K,
+        scrollbarEndGap: M,
+        scrollbarStartGap: V,
+        style: _,
+        rowHeight: E,
+        bodyWidth: U,
+        estimatedRowHeight: j,
+        headerWidth: z,
+        height: P,
+        width: S,
+        getRowHeight: k,
+        onScroll: B
+      } = r, v = N(j), F = v ? ee : te, J = i(R);
+      return L("div", {
+        role: "table",
+        class: [n.e("table"), r.class],
+        style: _
+      }, [L(F, {
+        ref: u,
+        data: w,
+        useIsScrolling: D,
+        itemKey: g,
+        columnCache: 0,
+        columnWidth: v ? l : U,
+        totalColumn: 1,
+        totalRow: w.length,
+        rowCache: d,
+        rowHeight: v ? k : E,
+        width: S,
+        height: i(h),
+        class: n.e("body"),
+        role: "rowgroup",
+        scrollbarStartGap: V,
+        scrollbarEndGap: M,
+        scrollbarAlwaysOn: K,
+        onScroll: B,
+        onItemRendered: I,
+        perfMode: !1
+      }, {
+        default: (p) => {
+          var C;
+          const Y = w[p.rowIndex];
+          return (C = c.row) == null ? void 0 : C.call(c, {
+            ...p,
+            columns: m,
+            rowData: Y
+          });
+        }
+      }), i(T) && L(re, {
+        ref: H,
+        class: n.e("header-wrapper"),
+        columns: m,
+        headerData: w,
+        headerHeight: r.headerHeight,
+        fixedHeaderData: W,
+        rowWidth: z,
+        rowHeight: E,
+        width: S,
+        height: Math.min(J + i(s), P)
+      }, {
+        dynamic: c.header,
+        fixed: c.row
+      })]);
+    };
+  }
+});
+export {
+  Ee as default
+};

package/dist/components/table-v2/src/table.d.ts

@@ -0,0 +1,194 @@
+import type { CSSProperties, ExtractPropTypes, ExtractPublicPropTypes } from 'vue';
+import type { SortOrder } from './constants';
+import type { Column, ColumnCommonParams, DataGetter, KeyType, RowCommonParams, SortBy, SortState } from './types';
+/**
+ * Param types
+ */
+export type ColumnSortParams<T> = {
+    column: Column<T>;
+    key: KeyType;
+    order: SortOrder;
+};
+/**
+ * Renderer/Getter types
+ */
+export type ExtraCellPropGetter<T> = (params: ColumnCommonParams<T> & RowCommonParams & {
+    cellData: T;
+    rowData: any;
+}) => any;
+export type ExtractHeaderPropGetter<T> = (params: {
+    columns: Column<T>[];
+    headerIndex: number;
+}) => any;
+export type ExtractHeaderCellPropGetter<T> = (params: ColumnCommonParams<T> & {
+    headerIndex: number;
+}) => any;
+export type ExtractRowPropGetter<T> = (params: {
+    columns: Column<T>[];
+} & RowCommonParams) => any;
+export type HeaderClassNameGetter<T> = (params: {
+    columns: Column<T>[];
+    headerIndex: number;
+}) => string;
+export type RowClassNameGetter<T> = (params: {
+    columns: Column<T>[];
+} & RowCommonParams) => string;
+/**
+ * Handler types
+ */
+export type ColumnSortHandler<T> = (params: ColumnSortParams<T>) => void;
+export type ColumnResizeHandler<T> = (column: Column<T>, width: number) => void;
+export type ExpandedRowsChangeHandler = (expandedRowKeys: KeyType[]) => void;
+export declare const tableV2Props: {
+    readonly cache: import("../../../utils").EpPropFinalized<NumberConstructor, never, never, 2, false>;
+    readonly estimatedRowHeight: {
+        readonly default: undefined;
+        readonly type: import("vue").PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        readonly __epPropKey: true;
+    };
+    readonly rowKey: import("../../../utils").EpPropFinalized<(new (...args: any[]) => string | number | symbol) | (() => KeyType) | (((new (...args: any[]) => string | number | symbol) | (() => KeyType)) | null)[], unknown, unknown, "id", boolean>;
+    readonly headerClass: {
+        readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<(new (...args: any[]) => string | HeaderClassNameGetter<any>) | (() => string | HeaderClassNameGetter<any>) | (((new (...args: any[]) => string | HeaderClassNameGetter<any>) | (() => string | HeaderClassNameGetter<any>)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly headerProps: {
+        readonly type: import("vue").PropType<any>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly headerCellProps: {
+        readonly type: import("vue").PropType<any>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly headerHeight: import("../../../utils").EpPropFinalized<(new (...args: any[]) => number | number[]) | (() => number | number[]) | (((new (...args: any[]) => number | number[]) | (() => number | number[])) | null)[], unknown, unknown, 50, boolean>;
+    readonly footerHeight: import("../../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly rowClass: {
+        readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<(new (...args: any[]) => string | RowClassNameGetter<any>) | (() => string | RowClassNameGetter<any>) | (((new (...args: any[]) => string | RowClassNameGetter<any>) | (() => string | RowClassNameGetter<any>)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowProps: {
+        readonly type: import("vue").PropType<any>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowHeight: import("../../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 50, boolean>;
+    readonly cellProps: {
+        readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<(new (...args: any[]) => Record<string, any> | ExtraCellPropGetter<any>) | (() => Record<string, any> | ExtraCellPropGetter<any>) | (((new (...args: any[]) => Record<string, any> | ExtraCellPropGetter<any>) | (() => Record<string, any> | ExtraCellPropGetter<any>)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly columns: {
+        readonly type: import("vue").PropType<import("./common").AnyColumn[]>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly data: {
+        readonly type: import("vue").PropType<any[]>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly dataGetter: {
+        readonly type: import("vue").PropType<DataGetter<any>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly fixedData: {
+        readonly type: import("vue").PropType<any[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly expandColumnKey: StringConstructor;
+    readonly expandedRowKeys: import("../../../utils").EpPropFinalized<(new (...args: any[]) => KeyType[]) | (() => KeyType[]) | (((new (...args: any[]) => KeyType[]) | (() => KeyType[])) | null)[], unknown, unknown, () => never[], boolean>;
+    readonly defaultExpandedRowKeys: import("../../../utils").EpPropFinalized<(new (...args: any[]) => KeyType[]) | (() => KeyType[]) | (((new (...args: any[]) => KeyType[]) | (() => KeyType[])) | null)[], unknown, unknown, () => never[], boolean>;
+    readonly class: StringConstructor;
+    readonly fixed: BooleanConstructor;
+    readonly style: {
+        readonly type: import("vue").PropType<CSSProperties>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly width: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly height: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly maxHeight: NumberConstructor;
+    readonly useIsScrolling: BooleanConstructor;
+    readonly indentSize: import("../../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 12, boolean>;
+    readonly iconSize: import("../../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 12, boolean>;
+    readonly hScrollbarSize: import("../../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 6, boolean>;
+    readonly vScrollbarSize: import("../../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 6, boolean>;
+    readonly scrollbarAlwaysOn: BooleanConstructor;
+    readonly sortBy: import("../../../utils").EpPropFinalized<(new (...args: any[]) => SortBy) | (() => SortBy) | (((new (...args: any[]) => SortBy) | (() => SortBy)) | null)[], unknown, unknown, () => {
+        key: KeyType;
+        order: SortOrder;
+    }, boolean>;
+    readonly sortState: import("../../../utils").EpPropFinalized<(new (...args: any[]) => SortState) | (() => SortState) | (((new (...args: any[]) => SortState) | (() => SortState)) | null)[], unknown, unknown, undefined, boolean>;
+    readonly onColumnSort: {
+        readonly type: import("vue").PropType<ColumnSortHandler<any>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onExpandedRowsChange: {
+        readonly type: import("vue").PropType<ExpandedRowsChangeHandler>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onEndReached: {
+        readonly type: import("vue").PropType<(remainDistance: number) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onRowExpand: {
+        readonly type: import("vue").PropType<import("./row").RowExpandHandler>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onScroll: {
+        readonly type: import("vue").PropType<(...args: any[]) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onRowsRendered: {
+        readonly type: import("vue").PropType<(params: import("./grid").onRowRenderedParams) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowEventHandlers: {
+        readonly type: import("vue").PropType<import("./row").RowEventHandlers>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+};
+export type TableV2Props = ExtractPropTypes<typeof tableV2Props>;
+export type TableV2PropsPublic = ExtractPublicPropTypes<typeof tableV2Props>;

package/dist/components/table-v2/src/table.js

@@ -0,0 +1,134 @@
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import { buildProps as i, definePropType as e } from "../../../utils/vue/props/runtime.js";
+import "vue";
+import { virtualizedScrollbarProps as p, virtualizedGridProps as r } from "../../virtual-list/src/props.js";
+import { requiredNumber as a, classType as l, expandKeys as n, fixedDataType as d, dataType as s, columns as c, rowKey as u } from "./common.js";
+import { tableV2RowProps as t } from "./row.js";
+import { tableV2HeaderProps as y } from "./header.js";
+import { tableV2GridProps as o } from "./grid.js";
+const H = i({
+  cache: o.cache,
+  estimatedRowHeight: t.estimatedRowHeight,
+  rowKey: u,
+  // Header attributes
+  headerClass: {
+    type: e([
+      String,
+      Function
+    ])
+  },
+  headerProps: {
+    type: e([
+      Object,
+      Function
+    ])
+  },
+  headerCellProps: {
+    type: e([
+      Object,
+      Function
+    ])
+  },
+  headerHeight: y.headerHeight,
+  /**
+   * Footer attributes
+   */
+  footerHeight: {
+    type: Number,
+    default: 0
+  },
+  /**
+   * Row attributes
+   */
+  rowClass: {
+    type: e([String, Function])
+  },
+  rowProps: {
+    type: e([Object, Function])
+  },
+  rowHeight: {
+    type: Number,
+    default: 50
+  },
+  /**
+   * Cell attributes
+   */
+  cellProps: {
+    type: e([
+      Object,
+      Function
+    ])
+  },
+  /**
+   * Data models
+   */
+  columns: c,
+  data: s,
+  dataGetter: {
+    type: e(Function)
+  },
+  fixedData: d,
+  /**
+   * Expanded keys
+   */
+  expandColumnKey: t.expandColumnKey,
+  expandedRowKeys: n,
+  defaultExpandedRowKeys: n,
+  /**
+   * Attributes
+   */
+  class: l,
+  // disabled: Boolean,
+  fixed: Boolean,
+  style: {
+    type: e(Object)
+  },
+  width: a,
+  height: a,
+  maxHeight: Number,
+  useIsScrolling: Boolean,
+  indentSize: {
+    type: Number,
+    default: 12
+  },
+  iconSize: {
+    type: Number,
+    default: 12
+  },
+  hScrollbarSize: r.hScrollbarSize,
+  vScrollbarSize: r.vScrollbarSize,
+  scrollbarAlwaysOn: p.alwaysOn,
+  /**
+   * Sorting
+   */
+  sortBy: {
+    type: e(Object),
+    default: () => ({})
+  },
+  sortState: {
+    type: e(Object),
+    default: void 0
+  },
+  /**
+   * Handlers
+   */
+  onColumnSort: {
+    type: e(Function)
+  },
+  onExpandedRowsChange: {
+    type: e(Function)
+  },
+  onEndReached: {
+    type: e(Function)
+  },
+  onRowExpand: t.onRowExpand,
+  onScroll: o.onScroll,
+  onRowsRendered: o.onRowsRendered,
+  rowEventHandlers: t.rowEventHandlers
+});
+export {
+  H as tableV2Props
+};

package/dist/components/table-v2/src/tokens.d.ts

@@ -0,0 +1,9 @@
+import type { InjectionKey, Ref } from 'vue';
+import type { UseNamespaceReturn } from '../../../hooks';
+export type TableV2Context = {
+    isScrolling: Ref<boolean>;
+    isResetting: Ref<boolean>;
+    ns: UseNamespaceReturn;
+};
+export declare const TableV2InjectionKey: InjectionKey<TableV2Context>;
+export declare const TABLE_V2_GRID_INJECTION_KEY = "tableV2GridScrollLeft";

package/dist/components/table-v2/src/tokens.js

@@ -0,0 +1,5 @@
+const e = Symbol("tableV2"), t = "tableV2GridScrollLeft";
+export {
+  t as TABLE_V2_GRID_INJECTION_KEY,
+  e as TableV2InjectionKey
+};

package/dist/components/table-v2/src/types.d.ts

@@ -0,0 +1,99 @@
+import type { ColumnAlignment } from '../../../constants/column-alignment';
+import type { FixedDir, SortOrder } from './constants';
+import type { CSSProperties, FunctionalComponent, HTMLAttributes, RendererElement, RendererNode, VNode } from 'vue';
+export type Alignment = ColumnAlignment;
+export type FixedDirection = FixedDir;
+export type KeyType = string | number | symbol;
+/**
+ * Param types
+ */
+export type CellRendererParams<T> = {
+    cellData: T;
+} & RowCommonParams & ColumnCommonParams<T>;
+export type ColumnCommonParams<T> = {
+    columns: Column<T>[];
+    column: Column<T>;
+    columnIndex: number;
+};
+export type HeaderCellRendererParams<T> = {
+    headerIndex: number;
+} & ColumnCommonParams<T>;
+export type RowCommonParams = {
+    rowData: any;
+    rowIndex: number;
+};
+export type ClassNameGetterParams<T> = {
+    cellData: T;
+} & RowCommonParams & ColumnCommonParams<T>;
+export type DataGetterParams<T> = {
+    columns: Column<T>[];
+    column: Column<T>;
+    columnIndex: number;
+} & RowCommonParams;
+export type DataGetter<T> = (params: DataGetterParams<T>) => T;
+export type ClassNameGetter<T> = (params: ClassNameGetterParams<T>) => string;
+export type HeaderClassGetter<T> = (params: ColumnCommonParams<T> & {
+    headerIndex: number;
+}) => string;
+/**
+ * Renderer/Getter types
+ */
+export type CellRenderer<T> = (params: CellRendererParams<T>) => VNode;
+export type HeaderCellRenderer<T> = (params: HeaderCellRendererParams<T>) => VNode;
+export type Column<T = any> = {
+    /**
+     * Attributes
+     */
+    align?: Alignment;
+    class?: string | ClassNameGetter<T>;
+    key?: KeyType;
+    dataKey?: KeyType;
+    fixed?: true | FixedDirection;
+    flexGrow?: CSSProperties['flexGrow'];
+    flexShrink?: CSSProperties['flexShrink'];
+    title?: string;
+    hidden?: boolean;
+    headerClass?: HeaderClassGetter<T> | string;
+    maxWidth?: number;
+    minWidth?: number;
+    style?: CSSProperties;
+    sortable?: boolean;
+    width: number;
+    /**
+     * Renderers
+     */
+    cellRenderer?: CellRenderer<T>;
+    headerCellRenderer?: HeaderCellRenderer<T>;
+    /**
+     * Extendable sections
+     */
+    [key: string]: any;
+};
+export type Columns<T> = Column<T>[];
+export type AnyColumns = Columns<any>;
+export type SortBy = {
+    key: KeyType;
+    order: SortOrder;
+};
+export type SortState = {
+    [key: KeyType]: SortOrder;
+};
+export type CustomizedCellsType = VNode<RendererNode, RendererElement, {
+    [key: string]: any;
+}>[];
+export type DefaultCellsType = VNode<RendererNode, RendererElement, {
+    [key: string]: any;
+}>[][];
+export type ColumnCellsType = DefaultCellsType | CustomizedCellsType;
+export type TableV2CustomizedHeaderSlotParam<T = any> = {
+    cells: VNode[];
+    columns: Columns<T>;
+    headerIndex: number;
+};
+export type SimpleFunctionalComponentProps<T extends object> = {
+    class?: HTMLAttributes['class'];
+    style?: CSSProperties;
+} & T;
+export type SimpleFunctionalComponent<E extends object = {
+    [key: string]: any;
+}> = FunctionalComponent<SimpleFunctionalComponentProps<E>>;