@douyinfe/semi-ui 2.1.0-beta.3 → 2.1.0-next.3

package/lib/cjs/table/index.d.ts

@@ -0,0 +1,100 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import NormalTable from './Table';
+import Column from './Column';
+import { TableProps, Data } from './interface';
+declare class Table<RecordType extends Record<string, any> = Data> extends React.PureComponent<TableProps<RecordType>> {
+    static Column: typeof Column;
+    static DEFAULT_KEY_COLUMN_SELECTION: "column-selection";
+    static DEFAULT_KEY_COLUMN_EXPAND: "column-expand";
+    static propTypes: {
+        resizable: PropTypes.Requireable<boolean | object>;
+        className: PropTypes.Requireable<string>;
+        style: PropTypes.Requireable<object>;
+        prefixCls: PropTypes.Requireable<string>;
+        components: PropTypes.Requireable<any>;
+        bordered: PropTypes.Requireable<boolean>;
+        loading: PropTypes.Requireable<boolean>;
+        size: PropTypes.Requireable<"default" | "small" | "middle">;
+        tableLayout: PropTypes.Requireable<"" | "fixed" | "auto">;
+        columns: PropTypes.Requireable<PropTypes.InferProps<{
+            align: PropTypes.Requireable<"left" | "right" | "center">;
+            className: PropTypes.Requireable<string>;
+            colSpan: PropTypes.Requireable<number>;
+            dataIndex: PropTypes.Requireable<string>;
+            defaultSortOrder: PropTypes.Requireable<"ascend" | "descend">;
+            filterChildrenRecord: PropTypes.Requireable<boolean>;
+            filterDropdownProps: PropTypes.Requireable<object>;
+            filterDropdown: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+            filterDropdownVisible: PropTypes.Requireable<boolean>;
+            filterIcon: PropTypes.Requireable<(...args: any[]) => any>;
+            filterMultiple: PropTypes.Requireable<boolean>;
+            filteredValue: PropTypes.Requireable<any[]>;
+            filters: PropTypes.Requireable<any[]>;
+            fixed: PropTypes.Requireable<boolean | "left" | "right">;
+            onCell: PropTypes.Requireable<(...args: any[]) => any>;
+            onFilter: PropTypes.Requireable<(...args: any[]) => any>;
+            onFilterDropdownVisibleChange: PropTypes.Requireable<(...args: any[]) => any>;
+            onHeaderCell: PropTypes.Requireable<(...args: any[]) => any>;
+            onSorterChange: PropTypes.Requireable<(...args: any[]) => any>;
+            render: PropTypes.Requireable<(...args: any[]) => any>;
+            renderFilterDropdownItem: PropTypes.Requireable<(...args: any[]) => any>;
+            sortChildrenRecord: PropTypes.Requireable<boolean>;
+            sortDirections: PropTypes.Requireable<string[]>;
+            sortOrder: PropTypes.Requireable<string | boolean>;
+            sorter: PropTypes.Requireable<boolean | ((...args: any[]) => any)>;
+            title: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+            useFullRender: PropTypes.Requireable<boolean>;
+            width: PropTypes.Requireable<string | number>;
+        }>[]>;
+        hideExpandedColumn: PropTypes.Requireable<boolean>;
+        id: PropTypes.Requireable<string>;
+        expandIcon: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        expandCellFixed: PropTypes.Requireable<boolean | "left" | "right">;
+        title: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        onHeaderRow: PropTypes.Requireable<(...args: any[]) => any>;
+        showHeader: PropTypes.Requireable<boolean>;
+        indentSize: PropTypes.Requireable<number>;
+        rowKey: PropTypes.Requireable<string | number | ((...args: any[]) => any)>;
+        onRow: PropTypes.Requireable<(...args: any[]) => any>;
+        onExpandedRowsChange: PropTypes.Requireable<(...args: any[]) => any>;
+        onExpand: PropTypes.Requireable<(...args: any[]) => any>;
+        rowExpandable: PropTypes.Requireable<(...args: any[]) => any>;
+        expandedRowRender: PropTypes.Requireable<(...args: any[]) => any>;
+        expandedRowKeys: PropTypes.Requireable<any[]>;
+        defaultExpandAllRows: PropTypes.Requireable<boolean>;
+        expandAllRows: PropTypes.Requireable<boolean>;
+        defaultExpandAllGroupRows: PropTypes.Requireable<boolean>;
+        expandAllGroupRows: PropTypes.Requireable<boolean>;
+        defaultExpandedRowKeys: PropTypes.Requireable<any[]>;
+        pagination: PropTypes.Requireable<boolean | object>;
+        renderPagination: PropTypes.Requireable<(...args: any[]) => any>;
+        footer: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        empty: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        dataSource: PropTypes.Requireable<any[]>;
+        childrenRecordName: PropTypes.Requireable<string>;
+        rowSelection: PropTypes.Requireable<boolean | object>;
+        onChange: PropTypes.Requireable<(...args: any[]) => any>;
+        scroll: PropTypes.Requireable<PropTypes.InferProps<{
+            x: PropTypes.Requireable<string | number | boolean>;
+            y: PropTypes.Requireable<string | number>;
+        }>>;
+        groupBy: PropTypes.Requireable<string | number | ((...args: any[]) => any)>;
+        renderGroupSection: PropTypes.Requireable<(...args: any[]) => any>;
+        onGroupedRow: PropTypes.Requireable<(...args: any[]) => any>;
+        clickGroupedRowToExpand: PropTypes.Requireable<boolean>;
+        virtualized: PropTypes.Requireable<boolean | object>;
+        dropdownPrefixCls: PropTypes.Requireable<string>;
+        expandRowByClick: PropTypes.Requireable<boolean>;
+        getVirtualizedListRef: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    static defaultProps: {
+        hideExpandedColumn: boolean;
+    };
+    tableRef: React.RefObject<NormalTable<RecordType>>;
+    constructor(props: TableProps);
+    getCurrentPageData: () => any;
+    render(): JSX.Element;
+}
+export * from './interface';
+export default Table;

package/lib/cjs/table/index.js

@@ -0,0 +1,85 @@
+"use strict";
+
+var _context;
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+
+var _forEachInstanceProperty = require("@babel/runtime-corejs3/core-js-stable/instance/for-each");
+
+var _Object$keys = require("@babel/runtime-corejs3/core-js-stable/object/keys");
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _exportNames = {};
+exports.default = void 0;
+
+var _assign = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/assign"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _Table = _interopRequireDefault(require("./Table"));
+
+var _ResizableTable = _interopRequireDefault(require("./ResizableTable"));
+
+var _Column = _interopRequireDefault(require("./Column"));
+
+var _constants = require("@douyinfe/semi-foundation/lib/cjs/table/constants");
+
+var _interface = require("./interface");
+
+_forEachInstanceProperty(_context = _Object$keys(_interface)).call(_context, function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _interface[key]) return;
+
+  _Object$defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _interface[key];
+    }
+  });
+});
+
+class Table extends _react.default.PureComponent {
+  constructor(props) {
+    super(props);
+
+    this.getCurrentPageData = () => this.tableRef.current && this.tableRef.current.getCurrentPageData();
+
+    this.tableRef = /*#__PURE__*/_react.default.createRef();
+  }
+
+  render() {
+    // eslint-disable-next-line prefer-destructuring
+    const props = this.props;
+
+    if (props.resizable) {
+      return /*#__PURE__*/_react.default.createElement(_ResizableTable.default, (0, _assign.default)({}, props, {
+        ref: this.tableRef
+      }));
+    } else {
+      return /*#__PURE__*/_react.default.createElement(_Table.default, (0, _assign.default)({}, props, {
+        ref: this.tableRef
+      }));
+    }
+  }
+
+}
+
+Table.Column = _Column.default;
+Table.DEFAULT_KEY_COLUMN_SELECTION = _constants.strings.DEFAULT_KEY_COLUMN_SELECTION;
+Table.DEFAULT_KEY_COLUMN_EXPAND = _constants.strings.DEFAULT_KEY_COLUMN_EXPAND;
+Table.propTypes = (0, _assign.default)((0, _assign.default)({}, _Table.default.propTypes), {
+  resizable: _propTypes.default.oneOfType([_propTypes.default.bool, _propTypes.default.object])
+});
+Table.defaultProps = {
+  hideExpandedColumn: true
+};
+var _default = Table;
+exports.default = _default;

package/lib/cjs/table/interface.d.ts

@@ -0,0 +1,290 @@
+import React, { ReactNode, MutableRefObject } from 'react';
+import { BaseProps } from '../_base/baseComponent';
+import { PaginationProps } from '../pagination';
+import { CheckboxProps } from '../checkbox';
+import { DropdownProps } from '../dropdown';
+import { Locale } from '../locale/interface';
+import { ArrayElement } from '../_base/base';
+import { strings } from '@douyinfe/semi-foundation/lib/cjs/table/constants';
+import { BaseRowKeyType, BaseSortOrder, BaseGroupBy, BaseGroupByFn, BaseFixed, BaseAlign, BaseChangeInfoSorter, BaseSorter, BaseFilter, BaseChangeInfoFilter, BaseIncludeGroupRecord } from '@douyinfe/semi-foundation/lib/cjs/table/foundation';
+import { ScrollDirection, CSSDirection } from 'react-window';
+export interface TableProps<RecordType extends Record<string, any> = any> extends BaseProps {
+    bordered?: boolean;
+    children?: ReactNode;
+    childrenRecordName?: string;
+    className?: string;
+    clickGroupedRowToExpand?: boolean;
+    columns?: ColumnProps<RecordType>[];
+    components?: TableComponents;
+    dataSource?: RecordType[];
+    defaultExpandAllGroupRows?: boolean;
+    defaultExpandAllRows?: boolean;
+    defaultExpandedRowKeys?: (string | number)[];
+    empty?: ReactNode;
+    expandAllGroupRows?: boolean;
+    expandAllRows?: boolean;
+    expandCellFixed?: Fixed;
+    expandIcon?: ExpandIcon;
+    expandedRowKeys?: (string | number)[];
+    expandedRowRender?: ExpandedRowRender<RecordType>;
+    expandRowByClick?: boolean;
+    footer?: Footer<RecordType>;
+    getVirtualizedListRef?: GetVirtualizedListRef;
+    groupBy?: GroupBy<RecordType>;
+    hideExpandedColumn?: boolean;
+    id?: string;
+    indentSize?: number;
+    loading?: boolean;
+    pagination?: TablePagination;
+    prefixCls?: string;
+    renderGroupSection?: RenderGroupSection;
+    renderPagination?: RenderPagination;
+    resizable?: Resizable<RecordType>;
+    rowExpandable?: RowExpandable<RecordType>;
+    rowKey?: RowKey<RecordType>;
+    rowSelection?: RowSelection<RecordType>;
+    scroll?: Scroll;
+    showHeader?: boolean;
+    size?: Size;
+    style?: React.CSSProperties;
+    title?: Title<RecordType>;
+    virtualized?: Virtualized;
+    onChange?: OnChange<RecordType>;
+    onExpand?: OnExpand<RecordType>;
+    onExpandedRowsChange?: OnExpandedRowsChange<RecordType>;
+    onGroupedRow?: OnGroupedRow<RecordType>;
+    onHeaderRow?: OnHeaderRow<RecordType>;
+    onRow?: OnRow<RecordType>;
+}
+export interface ColumnProps<RecordType extends Record<string, any> = any> {
+    [x: string]: any;
+    align?: Align;
+    children?: Array<ColumnProps<RecordType>>;
+    className?: string;
+    colSpan?: number;
+    dataIndex?: string;
+    defaultSortOrder?: SortOrder;
+    filterChildrenRecord?: boolean;
+    filterDropdown?: React.ReactNode;
+    filterDropdownProps?: DropdownProps;
+    filterDropdownVisible?: boolean;
+    filterIcon?: FilterIcon;
+    filterMultiple?: boolean;
+    filteredValue?: any[];
+    filters?: Filter[];
+    fixed?: Fixed;
+    key?: string | number;
+    render?: ColumnRender<RecordType>;
+    renderFilterDropdownItem?: RenderFilterDropdownItem;
+    sortChildrenRecord?: boolean;
+    sortOrder?: SortOrder;
+    sorter?: Sorter<RecordType>;
+    title?: ColumnTitle;
+    useFullRender?: boolean;
+    width?: string | number;
+    onCell?: OnCell<RecordType>;
+    onFilter?: OnFilter<RecordType>;
+    onFilterDropdownVisibleChange?: OnFilterDropdownVisibleChange;
+    onHeaderCell?: OnHeaderCell<RecordType>;
+}
+export declare type Align = BaseAlign;
+export declare type SortOrder = BaseSortOrder;
+export declare type FilterIcon = boolean | React.ReactNode | FilterIconRenderFunction;
+export interface Filter extends BaseFilter {
+    value?: any;
+    text?: React.ReactNode;
+    children?: Filter[];
+}
+export declare type Fixed = BaseFixed;
+export declare type OnCell<RecordType> = (record?: RecordType, rowIndex?: number) => OnCellReturnObject;
+export declare type OnFilter<RecordType> = (filteredValue?: any, record?: RecordType) => boolean;
+export declare type OnFilterDropdownVisibleChange = (visible?: boolean) => void;
+export declare type OnHeaderCell<RecordType> = (record?: RecordType, columnIndex?: number) => OnHeaderCellReturnObject;
+export declare type ColumnRender<RecordType> = (text: any, record: RecordType, index: number, options?: RenderOptions) => ColumnRenderReturnType;
+export declare type RenderFilterDropdownItem = (itemInfo?: FilterDropdownItem) => ReactNode;
+export declare type Sorter<RecordType> = BaseSorter<RecordType>;
+export declare type ColumnTitle = React.ReactNode | ((ColumnTitleProps?: ColumnTitleProps) => React.ReactNode);
+export declare type FilterIconRenderFunction = (filtered: boolean) => React.ReactNode;
+export declare type ColumnTitleProps = {
+    sorter?: React.ReactNode;
+    filter?: React.ReactNode;
+    selection?: React.ReactNode;
+};
+export declare type ColumnRenderReturnType = React.ReactNode | RenderReturnObject;
+export interface RenderReturnObject {
+    [x: string]: any;
+    children: React.ReactNode;
+    props: {
+        [x: string]: any;
+        colSpan?: number;
+        rowSpan?: number;
+    };
+}
+export interface FilterDropdownItem {
+    [x: string]: any;
+    value?: any;
+    text?: React.ReactNode;
+    onChange?: React.MouseEventHandler<HTMLLIElement>;
+    level?: number;
+    filterMultiple?: boolean;
+    checked?: boolean;
+}
+export interface RenderOptions {
+    expandIcon?: React.ReactNode;
+}
+export interface OnCellReturnObject extends React.TdHTMLAttributes<HTMLElement> {
+    [x: string]: any;
+    style?: React.CSSProperties;
+    className?: string;
+    onClick?: (e: React.MouseEvent) => void;
+}
+export interface OnHeaderCellReturnObject extends React.ThHTMLAttributes<HTMLElement> {
+    [x: string]: any;
+    style?: React.CSSProperties;
+    className?: string;
+    onClick?: (e: React.MouseEvent) => void;
+}
+interface OnRowReturnOmit {
+    ref?: React.RefObject<any>;
+}
+export interface OnRowReturnObject extends Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>, keyof OnRowReturnOmit> {
+    [x: string]: any;
+    className?: string;
+    style?: React.CSSProperties;
+    onClick?: (e: React.MouseEvent) => void;
+}
+export interface OnGroupedRowReturnObject extends Omit<React.HTMLAttributes<HTMLTableRowElement>, 'className'> {
+    [x: string]: any;
+    style?: React.CSSProperties;
+    onClick?: (e: React.MouseEvent) => void;
+}
+export declare type OnHeaderRowReturnObject = Omit<React.HTMLAttributes<HTMLTableRowElement>, 'ref' | 'style'>;
+export interface Scroll {
+    x?: number | string;
+    y?: number | string;
+    scrollToFirstRowOnChange?: boolean;
+}
+export interface Data {
+    [x: string]: any;
+    key?: string | number;
+}
+export interface TableComponents {
+    table?: ReactNode;
+    header?: {
+        outer?: ReactNode;
+        wrapper?: ReactNode;
+        row?: ReactNode;
+        cell?: ReactNode;
+    };
+    body?: {
+        outer?: ReactNode;
+        wrapper?: ReactNode;
+        row?: ReactNode;
+        cell?: ReactNode;
+        colgroup?: {
+            wrapper?: ReactNode;
+            col?: ReactNode;
+        };
+    };
+    footer?: {
+        wrapper?: ReactNode;
+        row?: ReactNode;
+        cell?: ReactNode;
+        outer?: ReactNode;
+    };
+}
+export interface RowSelectionProps<RecordType> {
+    className?: string;
+    disabled?: boolean;
+    fixed?: Fixed;
+    getCheckboxProps?: GetCheckboxProps<RecordType>;
+    hidden?: boolean;
+    selectedRowKeys?: (string | number)[];
+    title?: ReactNode;
+    width?: string | number;
+    onChange?: RowSelectionOnChange<RecordType>;
+    onSelect?: RowSelectionOnSelect<RecordType>;
+    onSelectAll?: RowSelectionOnSelectAll<RecordType>;
+}
+export declare type GetCheckboxProps<RecordType> = (record: RecordType) => CheckboxProps;
+export declare type RowSelectionOnChange<RecordType> = (selectedRowKeys?: (string | number)[], selectedRows?: RecordType[]) => void;
+export declare type RowSelectionOnSelect<RecordType> = (record?: RecordType, selected?: boolean, selectedRows?: RecordType[], nativeEvent?: React.MouseEvent) => void;
+export declare type RowSelectionOnSelectAll<RecordType> = (selected?: boolean, selectedRows?: RecordType[], changedRows?: RecordType[]) => void;
+export declare type ExpandIcon = ((expanded?: boolean) => React.ReactNode) | React.ReactNode | boolean;
+export declare type ExpandedRowRender<RecordType> = (record?: RecordType, index?: number, expanded?: boolean) => React.ReactNode;
+export declare type Footer<RecordType> = ReactNode | ((pageData?: RecordType[]) => React.ReactNode);
+export declare type FormatPageText = ((pageInfo?: {
+    currentStart?: number;
+    currentEnd?: number;
+    total?: number;
+}) => React.ReactNode) | boolean;
+export declare type GetVirtualizedListRef = (ref: MutableRefObject<any>) => void;
+export declare type GroupByFunction<RecordType> = BaseGroupByFn<RecordType>;
+export declare type GroupBy<RecordType> = BaseGroupBy<RecordType>;
+export declare type Size = ArrayElement<typeof strings.SIZES>;
+export declare type Title<RecordType> = React.ReactNode | ((pageData?: RecordType[]) => React.ReactNode);
+export declare type PaginationPosition = ArrayElement<typeof strings.PAGINATION_POSITIONS>;
+export declare type Pagination = TablePaginationProps | boolean;
+export declare type TablePagination = Pagination;
+export interface ChangeInfoFilter<RecordType> extends BaseChangeInfoFilter<RecordType> {
+    filters?: Filter[];
+    onFilter?: OnFilter<RecordType>;
+}
+export declare type ChangeInfoSorter<RecordType> = BaseChangeInfoSorter<RecordType>;
+export interface ChangeInfo<RecordType> {
+    pagination?: TablePaginationProps;
+    filters?: ChangeInfoFilter<RecordType>[];
+    sorter?: ChangeInfoSorter<RecordType>;
+    extra?: Record<string, any>;
+}
+export declare type OnChange<RecordType> = (changeInfo: ChangeInfo<RecordType>) => void;
+export declare type OnRow<RecordType> = (record?: RecordType, index?: number) => OnRowReturnObject;
+export declare type OnGroupedRow<RecordType> = (record?: RecordType, index?: number) => OnGroupedRowReturnObject;
+export declare type OnHeaderRow<RecordType> = (columns?: ColumnProps<RecordType>[], index?: number) => OnHeaderRowReturnObject;
+export declare type OnExpandedRowsChange<RecordType> = (expandedRows?: IncludeGroupRecord<RecordType>[]) => void;
+export declare type OnExpand<RecordType> = (expanded?: boolean, record?: IncludeGroupRecord<RecordType>, mouseEvent?: React.MouseEvent) => void;
+export declare type RenderGroupSection = (groupKey?: string | number, group?: (string | number)[]) => ReactNode | {
+    [x: string]: any;
+    children: ReactNode;
+};
+export declare type RenderPagination = (paginationProps: TablePaginationProps) => ReactNode;
+export declare type RowExpandable<RecordType> = (record?: RecordType) => boolean;
+export declare type RowKey<RecordType> = BaseRowKeyType | ((record?: RecordType) => string);
+export declare type RowSelection<RecordType> = RowSelectionProps<RecordType> | boolean;
+export declare type VirtualizedOnScrollArgs = {
+    scrollDirection?: ScrollDirection;
+    scrollOffset?: number;
+    scrollUpdateWasRequested?: boolean;
+};
+export declare type VirtualizedMode = 'list' | 'grid';
+export declare type VirtualizedItemSizeFn = (index?: number) => number;
+export declare type VirtualizedItemSize = number | VirtualizedItemSizeFn;
+export declare type VirtualizedOnScroll = (object: VirtualizedOnScrollArgs) => void;
+export interface VirtualizedProps {
+    [x: string]: any;
+    mode?: VirtualizedMode;
+    itemSize?: VirtualizedItemSize;
+    onScroll?: VirtualizedOnScroll;
+}
+export declare type Virtualized = boolean | VirtualizedProps;
+export interface TablePaginationProps extends BaseProps, PaginationProps {
+    position?: PaginationPosition;
+    formatPageText?: FormatPageText;
+}
+export declare type Resizable<RecordType> = ResizableProps<RecordType> | boolean;
+export interface ResizableProps<RecordType> {
+    onResize?: ResizeFn<RecordType>;
+    onResizeStart?: ResizeFn<RecordType>;
+    onResizeStop?: ResizeFn<RecordType>;
+}
+export declare type ResizeFn<RecordType> = (column: RecordType) => RecordType;
+export interface BodyScrollEvent extends React.UIEvent {
+    [x: string]: any;
+    currentTarget: any;
+    target: any;
+}
+export declare type BodyScrollPosition = 'both' | 'middle' | 'left' | 'right';
+export declare type TableLocale = Locale['Table'];
+export declare type Direction = CSSDirection;
+export declare type IncludeGroupRecord<RecordType> = BaseIncludeGroupRecord<RecordType>;
+export {};

package/lib/cjs/table/interface.js

@@ -0,0 +1,7 @@
+"use strict";
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/cjs/table/table-context.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import { ColumnProps, GetVirtualizedListRef } from './interface';
+export interface TableContextProps {
+    children?: React.ReactNode;
+    anyColumnFixed?: boolean;
+    flattenedColumns?: ColumnProps[];
+    tableWidth?: number[];
+    headWidths?: number[];
+    setHeadWidths?: (headWidth?: number[], index?: number) => void;
+    getHeadWidths?: (index?: number) => number[];
+    getCellWidths?: (flattenColumns: ColumnProps[], flattenedWidths?: number[], ignoreScrollBarKey?: boolean) => number[];
+    handleRowExpanded?: (expanded: boolean, realKey: string, domEvent: React.MouseEvent<HTMLElement>) => void;
+    renderExpandIcon?: (record: Record<string, any>, isNested?: boolean, groupKey?: string | number) => React.ReactNode;
+    renderSelection?: (record: Record<string, any>, isHeader?: boolean) => React.ReactNode;
+    getVirtualizedListRef?: GetVirtualizedListRef;
+    setBodyHasScrollbar?: (bodyHasScrollBar: boolean) => void;
+}
+declare const TableContext: React.Context<TableContextProps>;
+export default TableContext;

package/lib/cjs/table/table-context.js

@@ -0,0 +1,25 @@
+"use strict";
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = void 0;
+
+var _noop2 = _interopRequireDefault(require("lodash/noop"));
+
+var _react = _interopRequireDefault(require("react"));
+
+/* eslint-disable max-len */
+const TableContext = /*#__PURE__*/_react.default.createContext({
+  headWidths: [],
+  setHeadWidths: _noop2.default,
+  handleRowExpanded: _noop2.default
+});
+
+var _default = TableContext;
+exports.default = _default;

package/lib/cjs/table/utils.d.ts

@@ -0,0 +1,42 @@
+import Logger from '@douyinfe/semi-foundation/lib/cjs/utils/Logger';
+import { cloneDeep } from '../_utils';
+import { TableComponents, Virtualized } from './interface';
+/**
+ * @param {'vertical'|'horizontal'} [direction]
+ * @returns {number}
+ */
+export declare function measureScrollbar(direction?: string): number;
+export declare function amendTableWidth(tableWidth: number): number;
+/**
+ * The user can pass a component to define the rendering method of each level of the table
+ * This function merges the components passed in by the user with the default components
+ * @param {Object} components
+ * @param {Boolean|Object} virtualized
+ * @returns
+ */
+export declare function mergeComponents(components: TableComponents, virtualized: Virtualized): {
+    table: string;
+    header: {
+        outer: string;
+        wrapper: string;
+        row: string;
+        cell: string;
+    };
+    body: {
+        outer: string;
+        wrapper: string;
+        row: string;
+        cell: string;
+        colgroup: {
+            wrapper: string;
+            col: string;
+        };
+    };
+    footer: {
+        wrapper: string;
+        row: string;
+        cell: string;
+    };
+} & TableComponents;
+export declare const logger: Logger;
+export { cloneDeep };