@qsxy/element-plus-react 1.0.3 → 2.0.0

package/dist/TableV2/src/renderers/cell.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { TableV2RowCellRenderParam } from '../components';
+import type { UseNamespaceReturn } from '../../../hooks/useClassNames';
+import type { IconSize } from '../../../Icon/typings';
+import type { TableV2Props } from '../table';
+import type { UseTableReturn } from '../use-table';
+type CellRendererProps = TableV2RowCellRenderParam & Pick<TableV2Props, 'cellProps' | 'expandColumnKey' | 'indentSize' | 'rowKey'> & {
+    expandedRowKeys: UseTableReturn['expandedRowKeys'];
+    ns: UseNamespaceReturn;
+    iconSize?: IconSize;
+    children?: React.ReactNode;
+};
+declare const _default: React.NamedExoticComponent<CellRendererProps>;
+export default _default;

package/dist/TableV2/src/renderers/cell.js

@@ -0,0 +1,120 @@
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+import get from 'lodash/get';
+import isFunction from 'lodash/isFunction';
+import isObject from 'lodash/isObject';
+import React, { useMemo } from 'react';
+import { ExpandIcon, TableCell } from "../components";
+import { Alignment } from "../constants";
+import { placeholderSign } from "../private";
+import { componentToSlot, enforceUnit, tryCall } from "../utils";
+import classNames from 'classnames';
+var CellRenderer = function CellRenderer(_ref) {
+  var columns = _ref.columns,
+    column = _ref.column,
+    columnIndex = _ref.columnIndex,
+    depth = _ref.depth,
+    expandIconProps = _ref.expandIconProps,
+    isScrolling = _ref.isScrolling,
+    rowData = _ref.rowData,
+    rowIndex = _ref.rowIndex,
+    style = _ref.style,
+    expandedRowKeys = _ref.expandedRowKeys,
+    ns = _ref.ns,
+    _cellProps = _ref.cellProps,
+    expandColumnKey = _ref.expandColumnKey,
+    indentSize = _ref.indentSize,
+    iconSize = _ref.iconSize,
+    rowKey = _ref.rowKey,
+    children = _ref.children;
+  var cellStyle = useMemo(function () {
+    return enforceUnit(style);
+  }, [style]);
+  var cellRenderer = column.cellRenderer,
+    dataKey = column.dataKey,
+    dataGetter = column.dataGetter;
+  var cellData = useMemo(function () {
+    if (column.placeholderSign === placeholderSign) {
+      return undefined;
+    }
+    return isFunction(dataGetter) ? dataGetter({
+      columns: columns,
+      column: column,
+      columnIndex: columnIndex,
+      rowData: rowData,
+      rowIndex: rowIndex
+    }) : get(rowData, dataKey !== null && dataKey !== void 0 ? dataKey : '');
+  }, [dataGetter, columns, column, columnIndex, rowData, rowIndex, dataKey]);
+  var extraCellProps = useMemo(function () {
+    if (column.placeholderSign === placeholderSign) {
+      return {};
+    }
+    return tryCall(_cellProps, {
+      cellData: cellData,
+      columns: columns,
+      column: column,
+      columnIndex: columnIndex,
+      rowIndex: rowIndex,
+      rowData: rowData
+    });
+  }, [_cellProps, cellData, columns, column, columnIndex, rowIndex, rowData]);
+  var cellProps = useMemo(function () {
+    return {
+      className: ns.e('cell-text'),
+      columns: columns,
+      column: column,
+      columnIndex: columnIndex,
+      cellData: cellData,
+      isScrolling: isScrolling,
+      rowData: rowData,
+      rowIndex: rowIndex
+    };
+  }, [ns, columns, column, columnIndex, cellData, isScrolling, rowData, rowIndex]);
+  var columnCellRenderer = componentToSlot(cellRenderer);
+  var Cell = columnCellRenderer ? columnCellRenderer(cellProps) : children || /*#__PURE__*/React.createElement(TableCell, cellProps, cellData);
+  var kls = useMemo(function () {
+    return classNames(ns.e('row-cell'), column.className, ns.is({
+      'align-center': column.align === Alignment.CENTER,
+      'align-right': column.align === Alignment.RIGHT
+    }));
+  }, [ns, column.className, column.align]);
+  var expandable = rowIndex >= 0 && expandColumnKey && column.key === expandColumnKey;
+  var expanded = rowIndex >= 0 && expandedRowKeys.includes(rowData[rowKey]);
+  var IconOrPlaceholder = null;
+  if (expandable) {
+    if (isObject(expandIconProps)) {
+      IconOrPlaceholder = /*#__PURE__*/React.createElement(ExpandIcon, _extends({}, expandIconProps, {
+        className: [ns.e('expand-icon'), ns.is('expanded', expanded)].join(' '),
+        size: iconSize,
+        expanded: expanded,
+        ariaLabel: expanded ? '折叠行' : '展开行',
+        style: {
+          marginInlineStart: "".concat(depth * indentSize, "px")
+        },
+        expandable: true
+      }));
+    } else {
+      IconOrPlaceholder = /*#__PURE__*/React.createElement("div", {
+        style: {
+          marginInlineStart: "".concat(depth * indentSize, "px"),
+          width: iconSize,
+          height: iconSize
+        }
+      });
+    }
+  }
+
+  // 占位符单元格
+  if (column.placeholderSign === placeholderSign) {
+    return /*#__PURE__*/React.createElement("div", {
+      className: ns.em('row-cell', 'placeholder'),
+      style: cellStyle
+    });
+  }
+  return /*#__PURE__*/React.createElement("div", _extends({
+    className: kls,
+    style: cellStyle
+  }, extraCellProps, {
+    role: "cell"
+  }), IconOrPlaceholder, Cell);
+};
+export default /*#__PURE__*/React.memo(CellRenderer);

package/dist/TableV2/src/renderers/empty.d.ts

@@ -0,0 +1,7 @@
+import { BaseProps, NativeProps } from "../../../Types/common";
+import React from 'react';
+declare const Footer: {
+    (props: NativeProps & BaseProps): React.JSX.Element;
+    displayName: string;
+};
+export default Footer;

package/dist/TableV2/src/renderers/empty.js

@@ -0,0 +1,11 @@
+import ElEmpty from "../../../Empty/Empty";
+import React from 'react';
+var Footer = function Footer(props) {
+  var _props$children;
+  return /*#__PURE__*/React.createElement("div", {
+    className: props.className,
+    style: props.style
+  }, (_props$children = props.children) !== null && _props$children !== void 0 ? _props$children : /*#__PURE__*/React.createElement(ElEmpty, null));
+};
+Footer.displayName = 'ElTableV2Empty';
+export default Footer;

package/dist/TableV2/src/renderers/footer.d.ts

@@ -0,0 +1,7 @@
+import { BaseProps, NativeProps } from "../../../Types/common";
+import React from 'react';
+declare const Footer: {
+    (props: NativeProps & BaseProps): React.JSX.Element;
+    displayName: string;
+};
+export default Footer;

package/dist/TableV2/src/renderers/footer.js

@@ -0,0 +1,9 @@
+import React from 'react';
+var Footer = function Footer(props) {
+  return /*#__PURE__*/React.createElement("div", {
+    className: props.className,
+    style: props.style
+  }, props.children);
+};
+Footer.displayName = 'ElTableV2Footer';
+export default Footer;

package/dist/TableV2/src/renderers/header-cell.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { type TableV2HeaderRowCellRendererParams } from '../components';
+import type { UseNamespaceReturn } from '../../../hooks/useClassNames';
+import type { TableV2Props } from '../table';
+import type { UseTableReturn } from '../use-table';
+export type HeaderCellRendererProps = TableV2HeaderRowCellRendererParams & Pick<UseTableReturn, 'onColumnSorted'> & Pick<TableV2Props, 'sortBy' | 'sortState' | 'headerCellProps'> & {
+    ns: UseNamespaceReturn;
+};
+declare const HeaderCellRenderer: React.FC<HeaderCellRendererProps>;
+export default HeaderCellRenderer;
+export type HeaderCellSlotProps = HeaderCellRendererProps & {
+    className: string;
+};

package/dist/TableV2/src/renderers/header-cell.js

@@ -0,0 +1,92 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import React, { useMemo } from 'react';
+import { HeaderCell, SortIcon } from "../components";
+// import ColumnResizer from '../table-column-resizer'
+import { Alignment, SortOrder, oppositeOrderMap } from "../constants";
+import { placeholderSign } from "../private";
+import { componentToSlot, enforceUnit, tryCall } from "../utils";
+import classNames from 'classnames';
+var HeaderCellRenderer = function HeaderCellRenderer(props) {
+  var column = props.column,
+    ns = props.ns,
+    style = props.style,
+    onColumnSorted = props.onColumnSorted;
+  var cellStyle = useMemo(function () {
+    return enforceUnit(style);
+  }, [style]);
+  var headerCellRenderer = column.headerCellRenderer,
+    headerClass = column.headerClass,
+    sortable = column.sortable;
+
+  /**
+   * render Cell children
+   */
+
+  var cellProps = useMemo(function () {
+    return _objectSpread(_objectSpread({}, props), {}, {
+      className: ns.e('header-cell-text')
+    });
+  }, [props, ns]);
+  var columnCellRenderer = componentToSlot(headerCellRenderer);
+  var Cell = columnCellRenderer ? columnCellRenderer(cellProps) : /*#__PURE__*/React.createElement(HeaderCell, cellProps);
+
+  /**
+   * Render cell container and sort indicator
+   */
+  var sortBy = props.sortBy,
+    sortState = props.sortState,
+    headerCellProps = props.headerCellProps;
+  var sorting, sortOrder, ariaSort;
+  if (sortState) {
+    var order = sortState[column.key];
+    sorting = Boolean(oppositeOrderMap[order]);
+    sortOrder = sorting ? order : SortOrder.ASC;
+  } else {
+    sorting = column.key === (sortBy === null || sortBy === void 0 ? void 0 : sortBy.key);
+    sortOrder = sorting ? sortBy === null || sortBy === void 0 ? void 0 : sortBy.order : SortOrder.ASC;
+  }
+  if (sortOrder === SortOrder.ASC) {
+    ariaSort = 'ascending';
+  } else if (sortOrder === SortOrder.DESC) {
+    ariaSort = 'descending';
+  } else {
+    ariaSort = undefined;
+  }
+  var cellKls = useMemo(function () {
+    return classNames(ns.e('header-cell'), tryCall(headerClass, props, ''), ns.is({
+      'align-center': column.align === Alignment.CENTER,
+      'align-right': column.align === Alignment.RIGHT,
+      sortable: sortable
+    }));
+  }, [ns, headerClass, props, column.align, sortable]);
+  var cellWrapperProps = useMemo(function () {
+    return _objectSpread(_objectSpread({}, tryCall(headerCellProps, props)), {}, _defineProperty({
+      onClick: column.sortable ? onColumnSorted : undefined,
+      'aria-sort': sortable ? ariaSort : undefined,
+      className: cellKls,
+      style: cellStyle
+    }, 'data-key', column.key));
+  }, [headerCellProps, props, column.sortable, onColumnSorted, sortable, ariaSort, cellKls, cellStyle, column.key]);
+  if (column.placeholderSign === placeholderSign) {
+    return /*#__PURE__*/React.createElement("div", {
+      className: ns.em('header-row-cell', 'placeholder'),
+      style: cellStyle
+    });
+  }
+
+  // For now we don't deliver resizable column feature since it has some UX issue.
+  return /*#__PURE__*/React.createElement("div", _extends({}, cellWrapperProps, {
+    role: "columnheader"
+  }), Cell, sortable && /*#__PURE__*/React.createElement(SortIcon, {
+    className: [ns.e('sort-icon'), sorting && ns.is('sorting')].filter(Boolean).join(' '),
+    sortOrder: sortOrder,
+    ariaLabel: "\u6392\u5E8F: ".concat(column.title || '')
+  }));
+};
+export default HeaderCellRenderer;

package/dist/TableV2/src/renderers/header.d.ts

@@ -0,0 +1,9 @@
+import { TableV2HeaderRendererParams } from '../components';
+import { UseNamespaceReturn } from "../../../hooks/useClassNames";
+import { FC } from 'react';
+import type { TableV2Props } from '../table';
+type HeaderRendererProps = TableV2HeaderRendererParams & Pick<TableV2Props, 'headerClass' | 'headerProps' | 'headerFormatter' | 'cellFormatter'> & {
+    ns: UseNamespaceReturn;
+};
+declare const HeaderRenderer: FC<HeaderRendererProps>;
+export default HeaderRenderer;

package/dist/TableV2/src/renderers/header.js

@@ -0,0 +1,39 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { HeaderRow } from "../components";
+import { tryCall } from "../utils";
+import classNames from 'classnames';
+import React from 'react';
+var HeaderRenderer = function HeaderRenderer(_ref) {
+  var columns = _ref.columns,
+    columnsStyles = _ref.columnsStyles,
+    headerIndex = _ref.headerIndex,
+    style = _ref.style,
+    headerFormatter = _ref.headerFormatter,
+    cellFormatter = _ref.cellFormatter,
+    headerClass = _ref.headerClass,
+    headerProps = _ref.headerProps,
+    ns = _ref.ns,
+    children = _ref.children;
+  var param = {
+    columns: columns,
+    headerIndex: headerIndex
+  };
+  var extraProps = _objectSpread(_objectSpread({}, tryCall(headerProps, param)), {}, {
+    columnsStyles: columnsStyles,
+    className: classNames(ns.e('header-row'), tryCall(headerClass, param, ''), ns.is({
+      customized: Boolean(headerFormatter)
+    })),
+    columns: columns,
+    headerIndex: headerIndex,
+    style: style,
+    headerFormatter: headerFormatter,
+    cellFormatter: cellFormatter
+  });
+  return /*#__PURE__*/React.createElement(HeaderRow, extraProps, children);
+};
+export default HeaderRenderer;

package/dist/TableV2/src/renderers/left-table.d.ts

@@ -0,0 +1,32 @@
+import { TableGridInstance } from '../table-grid';
+import React, { RefObject } from 'react';
+declare const LeftTable: React.ForwardRefExoticComponent<{
+    columns: import("../..").Column<any>[];
+    data: any[];
+    fixedData: any[];
+    estimatedRowHeight: number;
+    height: number;
+    width: number;
+    headerWidth?: number;
+    headerHeight?: number | number[];
+    footerHeight?: number;
+    bodyWidth?: number;
+    rowHeight?: number;
+    cache?: number;
+    useIsScrolling?: boolean;
+    scrollbarAlwaysOn?: boolean;
+    scrollbarStartGap?: number;
+    scrollbarEndGap?: number;
+    containerStyle?: React.CSSProperties;
+    getRowHeight: (index: number) => number;
+    rowKey?: string | number | symbol;
+    headerFormatter?: (props: import("../..").HeaderSlotProps) => React.ReactNode;
+    rowFormatter?: (props: import("../..").TableGridRowSlotParams) => React.ReactNode;
+    onRowsRendered?: (params: import("../grid").onRowRenderedParams) => void;
+    onScroll?: (...args: any[]) => void;
+    children?: (params: import("../..").TableGridRowSlotParams) => React.ReactNode;
+} & import("../../..").NativeProps & {
+    leftTableRef: RefObject<TableGridInstance | undefined>;
+    children?: React.ReactNode;
+} & React.RefAttributes<TableGridInstance>>;
+export default LeftTable;

package/dist/TableV2/src/renderers/left-table.js

@@ -0,0 +1,15 @@
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+import Table from "../table-grid";
+import React, { forwardRef } from 'react';
+var LeftTable = /*#__PURE__*/forwardRef(function (props, ref) {
+  if (!props.columns.length) {
+    return;
+  }
+  return /*#__PURE__*/React.createElement(Table, _extends({
+    ref: ref
+  }, props), function (params) {
+    return props.rowFormatter && props.rowFormatter(params);
+  });
+});
+LeftTable.displayName = 'LeftTable';
+export default LeftTable;

package/dist/TableV2/src/renderers/main-table.d.ts

@@ -0,0 +1,31 @@
+import React from 'react';
+import { TableGridInstance } from '../table-grid';
+import type { TableV2GridProps } from '../grid';
+export type MainTableRendererProps = TableV2GridProps & {};
+declare const MainTable: React.ForwardRefExoticComponent<{
+    columns: import("../..").Column<any>[];
+    data: any[];
+    fixedData: any[];
+    estimatedRowHeight: number;
+    height: number;
+    width: number;
+    headerWidth?: number;
+    headerHeight?: number | number[];
+    footerHeight?: number;
+    bodyWidth?: number;
+    rowHeight?: number;
+    cache?: number;
+    useIsScrolling?: boolean;
+    scrollbarAlwaysOn?: boolean;
+    scrollbarStartGap?: number;
+    scrollbarEndGap?: number;
+    containerStyle?: React.CSSProperties;
+    getRowHeight: (index: number) => number;
+    rowKey?: string | number | symbol;
+    headerFormatter?: (props: import("../..").HeaderSlotProps) => React.ReactNode;
+    rowFormatter?: (props: import("../..").TableGridRowSlotParams) => React.ReactNode;
+    onRowsRendered?: (params: import("../grid").onRowRenderedParams) => void;
+    onScroll?: (...args: any[]) => void;
+    children?: (params: import("../..").TableGridRowSlotParams) => React.ReactNode;
+} & import("../../..").NativeProps & React.RefAttributes<TableGridInstance>>;
+export default MainTable;

package/dist/TableV2/src/renderers/main-table.js

@@ -0,0 +1,12 @@
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+import React, { forwardRef } from 'react';
+import Table from "../table-grid";
+var MainTable = /*#__PURE__*/forwardRef(function (props, ref) {
+  return /*#__PURE__*/React.createElement(Table, _extends({
+    ref: ref
+  }, props), function (params) {
+    return props.rowFormatter && props.rowFormatter(params);
+  });
+});
+MainTable.displayName = 'MainTable';
+export default MainTable;

package/dist/TableV2/src/renderers/overlay.d.ts

@@ -0,0 +1,3 @@
+import type { SimpleFunctionalComponent } from '../types';
+declare const Overlay: SimpleFunctionalComponent;
+export default Overlay;

package/dist/TableV2/src/renderers/overlay.js

@@ -0,0 +1,9 @@
+import React from 'react';
+var Overlay = function Overlay(props) {
+  return /*#__PURE__*/React.createElement("div", {
+    className: props.className,
+    style: props.style
+  }, props.children);
+};
+Overlay.displayName = 'ElTableV2Overlay';
+export default Overlay;

package/dist/TableV2/src/renderers/right-table.d.ts

@@ -0,0 +1,31 @@
+import { TableGridInstance } from '../table-grid';
+import React from 'react';
+declare const RightTable: React.ForwardRefExoticComponent<{
+    columns: import("../..").Column<any>[];
+    data: any[];
+    fixedData: any[];
+    estimatedRowHeight: number;
+    height: number;
+    width: number;
+    headerWidth?: number;
+    headerHeight?: number | number[];
+    footerHeight?: number;
+    bodyWidth?: number;
+    rowHeight?: number;
+    cache?: number;
+    useIsScrolling?: boolean;
+    scrollbarAlwaysOn?: boolean;
+    scrollbarStartGap?: number;
+    scrollbarEndGap?: number;
+    containerStyle?: React.CSSProperties;
+    getRowHeight: (index: number) => number;
+    rowKey?: string | number | symbol;
+    headerFormatter?: (props: import("../..").HeaderSlotProps) => React.ReactNode;
+    rowFormatter?: (props: import("../..").TableGridRowSlotParams) => React.ReactNode;
+    onRowsRendered?: (params: import("../grid").onRowRenderedParams) => void;
+    onScroll?: (...args: any[]) => void;
+    children?: (params: import("../..").TableGridRowSlotParams) => React.ReactNode;
+} & import("../../..").NativeProps & {
+    children?: React.ReactNode;
+} & React.RefAttributes<TableGridInstance>>;
+export default RightTable;

package/dist/TableV2/src/renderers/right-table.js

@@ -0,0 +1,15 @@
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+import Table from "../table-grid";
+import React, { forwardRef } from 'react';
+var RightTable = /*#__PURE__*/forwardRef(function (props, ref) {
+  if (!props.columns.length) {
+    return;
+  }
+  return /*#__PURE__*/React.createElement(Table, _extends({
+    ref: ref
+  }, props), function (params) {
+    return props.rowFormatter && props.rowFormatter(params);
+  });
+});
+RightTable.displayName = 'RightTable';
+export default RightTable;

package/dist/TableV2/src/renderers/row.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { UseNamespaceReturn } from '../../../hooks/useClassNames';
+import type { TableV2Props } from '../table';
+import type { TableGridRowSlotParams } from '../table-grid';
+import type { UseTableReturn } from '../use-table';
+type RowRendererProps = TableGridRowSlotParams & Pick<TableV2Props, 'expandColumnKey' | 'estimatedRowHeight' | 'rowProps' | 'rowClass' | 'rowKey' | 'rowEventHandlers' | 'rowFormatter' | 'cellFormatter'> & Pick<UseTableReturn, 'depthMap' | 'expandedRowKeys' | 'hasFixedColumns' | 'onRowHovered' | 'onRowExpanded' | 'columnsStyles'> & {
+    ns: UseNamespaceReturn;
+    tableInstance?: any;
+};
+declare const _default: React.MemoExoticComponent<(props: RowRendererProps) => React.JSX.Element>;
+export default _default;

package/dist/TableV2/src/renderers/row.js

@@ -0,0 +1,96 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import React from 'react';
+import { Row } from "../components";
+import { tryCall } from "../utils";
+import classNames from 'classnames';
+var RowRenderer = function RowRenderer(props) {
+  var columns = props.columns,
+    columnsStyles = props.columnsStyles,
+    depthMap = props.depthMap,
+    expandColumnKey = props.expandColumnKey,
+    expandedRowKeys = props.expandedRowKeys,
+    estimatedRowHeight = props.estimatedRowHeight,
+    hasFixedColumns = props.hasFixedColumns,
+    rowData = props.rowData,
+    rowIndex = props.rowIndex,
+    style = props.style,
+    isScrolling = props.isScrolling,
+    rowProps = props.rowProps,
+    rowClass = props.rowClass,
+    rowKey = props.rowKey,
+    rowEventHandlers = props.rowEventHandlers,
+    ns = props.ns,
+    onRowHovered = props.onRowHovered,
+    onRowExpanded = props.onRowExpanded;
+  var rowKls = tryCall(rowClass, {
+    columns: columns,
+    rowData: rowData,
+    rowIndex: rowIndex
+  }, '');
+  var additionalProps = tryCall(rowProps, {
+    columns: columns,
+    rowData: rowData,
+    rowIndex: rowIndex
+  });
+  var _rowKey = rowData[rowKey];
+  var depth = depthMap[_rowKey] || 0;
+  var canExpand = Boolean(expandColumnKey);
+  var isFixedRow = rowIndex < 0;
+  var kls = classNames(ns.e('row'), rowKls, ns.is({
+    expanded: canExpand && expandedRowKeys.includes(_rowKey),
+    fixed: !depth && isFixedRow,
+    customized: Boolean(props.rowFormatter)
+  }), _defineProperty({}, ns.e("row-depth-".concat(depth)), canExpand && rowIndex >= 0));
+  var onRowHover = hasFixedColumns ? onRowHovered : undefined;
+  var _rowProps = _objectSpread(_objectSpread({}, props), {}, {
+    columns: columns,
+    columnsStyles: columnsStyles,
+    className: kls,
+    depth: depth,
+    expandColumnKey: expandColumnKey,
+    estimatedRowHeight: isFixedRow ? undefined : estimatedRowHeight,
+    isScrolling: isScrolling,
+    rowIndex: rowIndex,
+    rowData: rowData,
+    rowKey: _rowKey,
+    rowEventHandlers: rowEventHandlers,
+    style: style,
+    rowFormatter: props.rowFormatter,
+    cellFormatter: props.cellFormatter
+  });
+  var handlerMouseEnter = function handlerMouseEnter(_ref) {
+    var e = _ref.event;
+    onRowHover === null || onRowHover === void 0 || onRowHover({
+      hovered: true,
+      rowKey: _rowKey,
+      event: e,
+      rowData: rowData,
+      rowIndex: rowIndex
+    });
+  };
+  var handlerMouseLeave = function handlerMouseLeave(_ref2) {
+    var e = _ref2.event;
+    onRowHover === null || onRowHover === void 0 || onRowHover({
+      hovered: false,
+      rowKey: _rowKey,
+      event: e,
+      rowData: rowData,
+      rowIndex: rowIndex
+    });
+  };
+  return /*#__PURE__*/React.createElement(Row, _extends({}, _rowProps, {
+    onRowExpand: onRowExpanded,
+    rowEventHandlers: {
+      onMouseEnter: handlerMouseEnter,
+      onMouseLeave: handlerMouseLeave
+    },
+    rowKey: _rowKey
+  }));
+};
+export default /*#__PURE__*/React.memo(RowRenderer);

package/dist/TableV2/src/row.d.ts

@@ -0,0 +1,51 @@
+import React, { CSSProperties } from 'react';
+import { CellFormatProps, RowFormatProps } from './table';
+import type { Column, FixedDirection, KeyType, RowCommonParams } from './types';
+export type RowExpandParams = {
+    expanded: boolean;
+    rowKey: KeyType;
+} & RowCommonParams;
+export type RowHoverParams = {
+    event?: MouseEvent;
+    hovered: boolean;
+    rowKey: KeyType;
+} & Partial<RowCommonParams>;
+export type RowEventHandlerParams = {
+    rowKey?: KeyType;
+    event: Event;
+} & Partial<RowCommonParams>;
+export type RowHeightChangedParams = {
+    rowKey: KeyType;
+    height: number;
+    rowIndex: number;
+};
+export type RowExpandHandler = (params: RowExpandParams) => void;
+export type RowHoverHandler = (params: RowHoverParams) => void;
+export type RowEventHandler = (params: RowEventHandlerParams) => void;
+export type RowHeightChangeHandler = (row: RowHeightChangedParams, fixedDirection: boolean | FixedDirection | undefined) => void;
+export type RowEventHandlers = {
+    onClick?: RowEventHandler;
+    onContextMenu?: RowEventHandler;
+    onDblClick?: RowEventHandler;
+    onMouseEnter?: RowEventHandler;
+    onMouseLeave?: RowEventHandler;
+};
+export interface TableV2RowProps {
+    className?: string;
+    columns: Column<any>[];
+    columnsStyles: Record<KeyType, CSSProperties>;
+    depth?: number;
+    expandColumnKey?: string;
+    estimatedRowHeight?: number;
+    isScrolling?: boolean;
+    onRowExpand?: RowExpandHandler;
+    onRowHover?: RowHoverHandler;
+    onRowHeightChange?: RowHeightChangeHandler;
+    rowData: any;
+    rowEventHandlers?: RowEventHandlers;
+    rowIndex: number;
+    rowKey: KeyType;
+    style?: CSSProperties;
+    rowFormatter?: (props: RowFormatProps) => React.ReactNode[];
+    cellFormatter?: (props: CellFormatProps<any>) => React.ReactNode;
+}