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

package/lib/cjs/switch/index.js

@@ -0,0 +1,159 @@
+"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 _assign = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/assign"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _foundation = _interopRequireDefault(require("@douyinfe/semi-foundation/lib/cjs/switch/foundation"));
+
+var _constants = require("@douyinfe/semi-foundation/lib/cjs/switch/constants");
+
+var _baseComponent = _interopRequireDefault(require("../_base/baseComponent"));
+
+require("@douyinfe/semi-foundation/lib/cjs/switch/switch.css");
+
+var _lodashEs = require("lodash-es");
+
+var _spin = _interopRequireDefault(require("../spin"));
+
+/* eslint-disable max-len */
+class Switch extends _baseComponent.default {
+  constructor(props) {
+    super(props);
+    this.state = {
+      nativeControlChecked: false,
+      nativeControlDisabled: false
+    };
+    this.switchRef = /*#__PURE__*/_react.default.createRef();
+    this.foundation = new _foundation.default(this.adapter);
+  }
+
+  componentDidMount() {
+    this.foundation.init();
+  }
+
+  componentDidUpdate(prevProps) {
+    if (this.props.checked !== prevProps.checked) {
+      this.foundation.setChecked(this.props.checked);
+    }
+
+    if (this.props.disabled !== prevProps.disabled) {
+      this.foundation.setDisabled(this.props.disabled);
+    }
+  }
+
+  componentWillUnmount() {
+    this.foundation.destroy();
+  }
+
+  get adapter() {
+    return (0, _assign.default)((0, _assign.default)({}, super.adapter), {
+      setNativeControlChecked: nativeControlChecked => {
+        this.setState({
+          nativeControlChecked
+        });
+      },
+      setNativeControlDisabled: nativeControlDisabled => {
+        this.setState({
+          nativeControlDisabled
+        });
+      },
+      notifyChange: (checked, e) => {
+        this.props.onChange(checked, e);
+      }
+    });
+  }
+
+  render() {
+    const {
+      nativeControlChecked,
+      nativeControlDisabled
+    } = this.state;
+    const {
+      className,
+      style,
+      onMouseEnter,
+      onMouseLeave,
+      size,
+      checkedText,
+      uncheckedText,
+      loading
+    } = this.props;
+    const wrapperCls = (0, _classnames.default)(className, {
+      [_constants.cssClasses.PREFIX]: true,
+      [_constants.cssClasses.CHECKED]: nativeControlChecked,
+      [_constants.cssClasses.DISABLED]: nativeControlDisabled,
+      [_constants.cssClasses.LARGE]: size === 'large',
+      [_constants.cssClasses.SMALL]: size === 'small',
+      [_constants.cssClasses.LOADING]: loading
+    });
+    const switchProps = {
+      type: 'checkbox',
+      role: 'switch',
+      className: _constants.cssClasses.NATIVE_CONTROL,
+      disabled: nativeControlDisabled || loading,
+      checked: nativeControlChecked || false
+    };
+    const showCheckedText = checkedText && nativeControlChecked && size !== 'small';
+    const showUncheckedText = uncheckedText && !nativeControlChecked && size !== 'small';
+    return /*#__PURE__*/_react.default.createElement("div", {
+      className: wrapperCls,
+      style: style,
+      onMouseEnter: onMouseEnter,
+      onMouseLeave: onMouseLeave
+    }, loading ? /*#__PURE__*/_react.default.createElement(_spin.default, {
+      wrapperClassName: _constants.cssClasses.LOADING_SPIN,
+      size: size === 'default' ? 'middle' : size
+    }) : /*#__PURE__*/_react.default.createElement("div", {
+      className: _constants.cssClasses.KNOB
+    }), showCheckedText ? /*#__PURE__*/_react.default.createElement("div", {
+      className: _constants.cssClasses.CHECKED_TEXT
+    }, checkedText) : null, showUncheckedText ? /*#__PURE__*/_react.default.createElement("div", {
+      className: _constants.cssClasses.UNCHECKED_TEXT
+    }, uncheckedText) : null, /*#__PURE__*/_react.default.createElement("input", (0, _assign.default)({}, switchProps, {
+      ref: this.switchRef,
+      onChange: e => this.foundation.handleChange(e.target.checked, e)
+    })));
+  }
+
+}
+
+Switch.propTypes = {
+  className: _propTypes.default.string,
+  checked: _propTypes.default.bool,
+  checkedText: _propTypes.default.node,
+  defaultChecked: _propTypes.default.bool,
+  disabled: _propTypes.default.bool,
+  loading: _propTypes.default.bool,
+  onChange: _propTypes.default.func,
+  onMouseEnter: _propTypes.default.func,
+  onMouseLeave: _propTypes.default.func,
+  style: _propTypes.default.object,
+  size: _propTypes.default.oneOf(_constants.strings.SIZE_MAP),
+  uncheckedText: _propTypes.default.node
+};
+Switch.defaultProps = {
+  disabled: false,
+  className: '',
+  onChange: _lodashEs.noop,
+  loading: false,
+  onMouseEnter: _lodashEs.noop,
+  onMouseLeave: _lodashEs.noop,
+  size: 'default'
+};
+var _default = Switch;
+exports.default = _default;

package/lib/cjs/table/Body/BaseRow.d.ts

@@ -0,0 +1,125 @@
+import React, { ReactNode } from 'react';
+import PropTypes from 'prop-types';
+import { TableRowAdapter } from '@douyinfe/semi-foundation/lib/cjs/table/tableRowFoundation';
+import Store from '@douyinfe/semi-foundation/lib/cjs/utils/Store';
+import { BaseRowKeyType } from '@douyinfe/semi-foundation/lib/cjs/table/foundation';
+import BaseComponent from '../../_base/baseComponent';
+import { ColumnProps, Fixed, TableComponents, Virtualized, ExpandIcon, OnRow, RowExpandable } from '../interface';
+export interface BaseRowProps {
+    anyColumnFixed?: boolean;
+    cellWidths?: number[];
+    className?: string;
+    columns: ColumnProps[];
+    components?: TableComponents;
+    disabled?: boolean;
+    expandIcon?: ExpandIcon;
+    expandableRow?: boolean;
+    expanded?: boolean;
+    expandedRow?: boolean;
+    fixed?: Fixed;
+    height?: string | number;
+    hideExpandedColumn?: boolean;
+    hovered: boolean;
+    indent?: number;
+    indentSize?: number;
+    index?: number;
+    isSection?: boolean;
+    level?: number;
+    onDidUpdate?: (ref: React.MutableRefObject<any>) => void;
+    onHover?: (mouseEnter: boolean, rowKey: string | number) => void;
+    onRow?: OnRow<any>;
+    onRowClick?: (rowKey: BaseRowKeyType, e: React.MouseEvent, expand: boolean) => void;
+    onRowDoubleClick?: (record: Record<string, any>, e: React.MouseEvent) => void;
+    onRowMouseEnter?: (record: Record<string, any>, e: React.MouseEvent) => void;
+    onRowMouseLeave?: (record: Record<string, any>, e: React.MouseEvent) => void;
+    prefixCls?: string;
+    record?: Record<string, any>;
+    renderExpandIcon?: RenderExpandIcon;
+    replaceClassName?: string;
+    rowExpandable?: RowExpandable<any>;
+    rowKey?: string | number;
+    selected?: boolean;
+    store?: Store;
+    style?: React.CSSProperties;
+    virtualized?: Virtualized;
+    visible: boolean;
+}
+export default class TableRow extends BaseComponent<BaseRowProps, Record<string, any>> {
+    static propTypes: {
+        anyColumnFixed: PropTypes.Requireable<boolean>;
+        cellWidths: PropTypes.Validator<any[]>;
+        className: PropTypes.Requireable<string>;
+        columns: PropTypes.Validator<any[]>;
+        components: PropTypes.Validator<object>;
+        disabled: PropTypes.Requireable<boolean>;
+        expandIcon: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        expandableRow: PropTypes.Requireable<boolean>;
+        expanded: PropTypes.Requireable<boolean>;
+        expandedRow: PropTypes.Requireable<boolean>;
+        fixed: PropTypes.Requireable<string | boolean>;
+        height: PropTypes.Requireable<string | number>;
+        hideExpandedColumn: PropTypes.Requireable<boolean>;
+        hovered: PropTypes.Validator<boolean>;
+        indent: PropTypes.Requireable<number>;
+        indentSize: PropTypes.Requireable<number>;
+        index: PropTypes.Requireable<number>;
+        isSection: PropTypes.Requireable<boolean>;
+        level: PropTypes.Requireable<number>;
+        onDidUpdate: PropTypes.Requireable<(...args: any[]) => any>;
+        onHover: PropTypes.Requireable<(...args: any[]) => any>;
+        onRow: PropTypes.Requireable<(...args: any[]) => any>;
+        onRowClick: PropTypes.Requireable<(...args: any[]) => any>;
+        onRowContextMenu: PropTypes.Requireable<(...args: any[]) => any>;
+        onRowDoubleClick: PropTypes.Requireable<(...args: any[]) => any>;
+        onRowMouseEnter: PropTypes.Requireable<(...args: any[]) => any>;
+        onRowMouseLeave: PropTypes.Requireable<(...args: any[]) => any>;
+        prefixCls: PropTypes.Requireable<string>;
+        record: PropTypes.Requireable<object>;
+        renderExpandIcon: PropTypes.Requireable<(...args: any[]) => any>;
+        replaceClassName: PropTypes.Requireable<string>;
+        rowExpandable: PropTypes.Requireable<(...args: any[]) => any>;
+        rowKey: PropTypes.Validator<string | number>;
+        selected: PropTypes.Requireable<boolean>;
+        store: PropTypes.Requireable<object>;
+        style: PropTypes.Requireable<object>;
+        virtualized: PropTypes.Requireable<boolean | object>;
+        visible: PropTypes.Validator<boolean>;
+    };
+    static defaultProps: {
+        columns: [];
+        rowExpandable: {
+            (): true;
+            (): true;
+        };
+        components: {
+            body: {
+                row: string;
+                cell: string;
+            };
+        };
+        prefixCls: "semi-table";
+        onRow: (...args: any[]) => void;
+        onRowClick: (...args: any[]) => void;
+        onRowDoubleClick: (...args: any[]) => void;
+        onRowMouseEnter: (...args: any[]) => void;
+        onRowMouseLeave: (...args: any[]) => void;
+        onHover: (...args: any[]) => void;
+        onDidUpdate: (...args: any[]) => void;
+        visible: boolean;
+        hovered: boolean;
+        selected: boolean;
+        disabled: boolean;
+    };
+    get adapter(): TableRowAdapter<BaseRowProps>;
+    ref: React.MutableRefObject<any>;
+    constructor(props: BaseRowProps);
+    shouldComponentUpdate(nextProps: BaseRowProps): boolean;
+    _cacheNode: (node: any) => void;
+    renderExpandIcon: (record: Record<string, any>) => React.ReactNode;
+    renderCells(): React.ReactNode[];
+    handleMouseEnter: (e: React.MouseEvent) => void;
+    handleMouseLeave: (e: React.MouseEvent) => void;
+    handleClick: (e: React.MouseEvent) => void;
+    render(): JSX.Element;
+}
+export declare type RenderExpandIcon = (record: Record<string, any>, isNested: boolean) => ReactNode | null;

package/lib/cjs/table/Body/BaseRow.js

@@ -0,0 +1,347 @@
+"use strict";
+
+var _WeakMap = require("@babel/runtime-corejs3/core-js-stable/weak-map");
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+
+var _Object$getOwnPropertyDescriptor = require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptor");
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = void 0;
+
+var _indexOf = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/index-of"));
+
+var _getOwnPropertySymbols = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-symbols"));
+
+var _assign = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/assign"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _lodashEs = require("lodash-es");
+
+var _constants = require("@douyinfe/semi-foundation/lib/cjs/table/constants");
+
+var _shallowEqualObjects = _interopRequireDefault(require("@douyinfe/semi-foundation/lib/cjs/utils/shallowEqualObjects"));
+
+var _tableRowFoundation = _interopRequireDefault(require("@douyinfe/semi-foundation/lib/cjs/table/tableRowFoundation"));
+
+var _utils = require("@douyinfe/semi-foundation/lib/cjs/table/utils");
+
+var _baseComponent = _interopRequireDefault(require("../../_base/baseComponent"));
+
+var _TableCell = _interopRequireDefault(require("../TableCell"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof _WeakMap !== "function") return null; var cacheBabelInterop = new _WeakMap(); var cacheNodeInterop = new _WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = _Object$defineProperty && _Object$getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? _Object$getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { _Object$defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var __rest = void 0 && (void 0).__rest || function (s, e) {
+  var t = {};
+
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && (0, _indexOf.default)(e).call(e, p) < 0) t[p] = s[p];
+
+  if (s != null && typeof _getOwnPropertySymbols.default === "function") for (var i = 0, p = (0, _getOwnPropertySymbols.default)(s); i < p.length; i++) {
+    if ((0, _indexOf.default)(e).call(e, p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+/* eslint-disable max-len */
+
+/* eslint-disable eqeqeq */
+
+
+class TableRow extends _baseComponent.default {
+  constructor(props) {
+    super(props);
+
+    this._cacheNode = node => {
+      this.ref.current = node;
+    }; // Pass true to render the tree-shaped expand button
+
+
+    this.renderExpandIcon = record => {
+      const {
+        renderExpandIcon
+      } = this.props;
+      return renderExpandIcon(record, true);
+    };
+
+    this.handleMouseEnter = e => {
+      this.foundation.handleMouseEnter(e);
+      const customRowProps = this.adapter.getCache('customRowProps');
+
+      if (typeof customRowProps.onMouseEnter === 'function') {
+        customRowProps.onMouseEnter(e);
+      }
+    };
+
+    this.handleMouseLeave = e => {
+      this.foundation.handleMouseLeave(e);
+      const customRowProps = this.adapter.getCache('customRowProps');
+
+      if (typeof customRowProps.onMouseLeave === 'function') {
+        customRowProps.onMouseLeave(e);
+      }
+    };
+
+    this.handleClick = e => {
+      this.foundation.handleClick(e);
+      const customRowProps = this.adapter.getCache('customRowProps');
+
+      if (customRowProps && typeof customRowProps.onClick === 'function') {
+        customRowProps.onClick(e);
+      }
+    };
+
+    this.ref = /*#__PURE__*/(0, _react.createRef)();
+    this.foundation = new _tableRowFoundation.default(this.adapter);
+  }
+
+  get adapter() {
+    var _this = this;
+
+    return (0, _assign.default)((0, _assign.default)({}, super.adapter), {
+      notifyClick: function () {
+        return _this.props.onRowClick(...arguments);
+      },
+      notifyDoubleClick: function () {
+        return _this.props.onRowDoubleClick(...arguments);
+      },
+      notifyMouseLeave: function () {
+        _this.props.onHover(false, _this.props.rowKey);
+
+        _this.props.onRowMouseEnter(...arguments);
+      },
+      notifyMouseEnter: function () {
+        _this.props.onHover(true, _this.props.rowKey);
+
+        _this.props.onRowMouseEnter(...arguments);
+      }
+    });
+  }
+
+  shouldComponentUpdate(nextProps) {
+    /**
+      * Shallow comparison of incoming props to simulate PureComponent
+      * Deep comparison cellWidths
+      *
+      * 浅层对比传入的 props，模拟 PureComponent
+      * 深比较 cellWidths
+      */
+    const omitProps = ['cellWidths'];
+    const isPropsShallowEqual = (0, _shallowEqualObjects.default)((0, _lodashEs.omit)(nextProps, omitProps), (0, _lodashEs.omit)(this.props, omitProps));
+
+    if (!isPropsShallowEqual || !(0, _lodashEs.isEqual)((0, _lodashEs.pick)(nextProps, omitProps), (0, _lodashEs.pick)(this.props, omitProps))) {
+      return true;
+    }
+
+    return false;
+  }
+
+  renderCells() {
+    const {
+      columns,
+      record,
+      index,
+      prefixCls,
+      fixed,
+      components,
+      expandableRow,
+      level,
+      expandIcon,
+      rowExpandable,
+      isSection,
+      expandedRow,
+      virtualized,
+      indentSize,
+      hideExpandedColumn,
+      cellWidths,
+      selected,
+      expanded,
+      disabled,
+      onDidUpdate
+    } = this.props;
+    const BodyCell = (0, _lodashEs.get)(components, 'body.cell', _constants.strings.DEFAULT_COMPONENTS.body.cell);
+    const cells = [];
+    const displayExpandedColumn = rowExpandable(record);
+    let firstIndex = 0; // const dataColumns = getDataColumns(columns);
+
+    (0, _lodashEs.each)(columns, (column, columnIndex) => {
+      const columnKey = (0, _lodashEs.get)(column, 'key');
+      const expandableProps = {};
+
+      if (fixed !== 'right') {
+        if ((0, _utils.isInnerColumnKey)(columnKey)) {
+          firstIndex++;
+        }
+
+        if (expandableRow && columnIndex === firstIndex) {
+          expandableProps.renderExpandIcon = this.renderExpandIcon;
+
+          if (hideExpandedColumn || isSection) {
+            expandableProps.expandIcon = expandIcon != null ? expandIcon : true;
+          }
+        } // Only the first data row will be indented
+
+
+        if (level != null && columnIndex === firstIndex) {
+          expandableProps.indent = level;
+
+          if (!expandableRow) {
+            expandableProps.indent = level + 1;
+          }
+        }
+      }
+
+      if ((0, _utils.isExpandedColumn)(column) && !displayExpandedColumn) {
+        cells.push( /*#__PURE__*/_react.default.createElement(_TableCell.default, {
+          key: columnIndex,
+          isSection: isSection
+        }));
+      } else if (!(0, _utils.isScrollbarColumn)(column)) {
+        const diyProps = {};
+
+        if (BodyCell !== _constants.strings.DEFAULT_COMPONENTS.body.cell && virtualized && !expandedRow) {
+          diyProps.width = (0, _lodashEs.get)(cellWidths, columnIndex);
+        }
+
+        cells.push( /*#__PURE__*/_react.default.createElement(_TableCell.default, (0, _assign.default)({}, expandableProps, diyProps, {
+          hideExpandedColumn: hideExpandedColumn,
+          indentSize: indentSize,
+          isSection: isSection,
+          prefixCls: "".concat(prefixCls),
+          column: column,
+          key: columnIndex,
+          index: index,
+          record: record,
+          component: BodyCell,
+          fixedLeft: (0, _utils.isFixedLeft)(column) && (0, _utils.arrayAdd)(cellWidths, 0, columnIndex),
+          lastFixedLeft: (0, _utils.isLastLeftFixed)(columns, column),
+          fixedRight: (0, _utils.isFixedRight)(column) && (0, _utils.arrayAdd)(cellWidths, columnIndex + 1),
+          firstFixedRight: (0, _utils.isFirstFixedRight)(columns, column),
+          selected: selected,
+          expanded: expanded,
+          disabled: disabled,
+          onDidUpdate: onDidUpdate
+        })));
+      }
+    });
+    return cells;
+  }
+
+  render() {
+    const {
+      style
+    } = this.props;
+    const {
+      components,
+      prefixCls,
+      selected,
+      onRow,
+      index,
+      className,
+      replaceClassName,
+      record,
+      hovered,
+      expanded
+    } = this.props;
+    const BodyRow = components.body.row;
+
+    const _a = onRow(record, index) || {},
+          {
+      className: customClassName,
+      style: customStyle
+    } = _a,
+          rowProps = __rest(_a, ["className", "style"]);
+
+    this.adapter.setCache('customRowProps', (0, _assign.default)({}, rowProps));
+    const baseRowStyle = (0, _assign.default)((0, _assign.default)({}, style), customStyle);
+    const rowCls = typeof replaceClassName === 'string' && replaceClassName.length ? replaceClassName : (0, _classnames.default)(className, "".concat(prefixCls, "-row"), {
+      ["".concat(prefixCls, "-row-selected")]: selected,
+      ["".concat(prefixCls, "-row-expanded")]: expanded,
+      ["".concat(prefixCls, "-row-hovered")]: hovered
+    }, customClassName);
+    return /*#__PURE__*/_react.default.createElement(BodyRow, (0, _assign.default)({}, rowProps, {
+      style: baseRowStyle,
+      className: rowCls,
+      ref: this._cacheNode,
+      onMouseEnter: this.handleMouseEnter,
+      onMouseLeave: this.handleMouseLeave,
+      onClick: this.handleClick
+    }), this.renderCells());
+  }
+
+}
+
+exports.default = TableRow;
+TableRow.propTypes = {
+  anyColumnFixed: _propTypes.default.bool,
+  cellWidths: _propTypes.default.array.isRequired,
+  className: _propTypes.default.string,
+  columns: _propTypes.default.array.isRequired,
+  components: _propTypes.default.object.isRequired,
+  disabled: _propTypes.default.bool,
+  expandIcon: _propTypes.default.oneOfType([_propTypes.default.bool, _propTypes.default.func, _propTypes.default.node]),
+  expandableRow: _propTypes.default.bool,
+  expanded: _propTypes.default.bool,
+  expandedRow: _propTypes.default.bool,
+  fixed: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.bool]),
+  height: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number]),
+  hideExpandedColumn: _propTypes.default.bool,
+  hovered: _propTypes.default.bool.isRequired,
+  indent: _propTypes.default.number,
+  indentSize: _propTypes.default.number,
+  index: _propTypes.default.number,
+  isSection: _propTypes.default.bool,
+  level: _propTypes.default.number,
+  onDidUpdate: _propTypes.default.func,
+  onHover: _propTypes.default.func,
+  onRow: _propTypes.default.func,
+  onRowClick: _propTypes.default.func,
+  onRowContextMenu: _propTypes.default.func,
+  onRowDoubleClick: _propTypes.default.func,
+  onRowMouseEnter: _propTypes.default.func,
+  onRowMouseLeave: _propTypes.default.func,
+  prefixCls: _propTypes.default.string,
+  record: _propTypes.default.object,
+  renderExpandIcon: _propTypes.default.func,
+  replaceClassName: _propTypes.default.string,
+  rowExpandable: _propTypes.default.func,
+  rowKey: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number]).isRequired,
+  selected: _propTypes.default.bool,
+  store: _propTypes.default.object,
+  style: _propTypes.default.object,
+  virtualized: _propTypes.default.oneOfType([_propTypes.default.object, _propTypes.default.bool]),
+  visible: _propTypes.default.bool.isRequired
+};
+TableRow.defaultProps = {
+  columns: [],
+  rowExpandable: _lodashEs.stubTrue,
+  components: {
+    body: {
+      row: 'tr',
+      cell: 'td'
+    }
+  },
+  prefixCls: _constants.cssClasses.PREFIX,
+  onRow: _lodashEs.noop,
+  onRowClick: _lodashEs.noop,
+  onRowDoubleClick: _lodashEs.noop,
+  onRowMouseEnter: _lodashEs.noop,
+  onRowMouseLeave: _lodashEs.noop,
+  onHover: _lodashEs.noop,
+  onDidUpdate: _lodashEs.noop,
+  visible: true,
+  hovered: false,
+  selected: false,
+  disabled: false
+};

package/lib/cjs/table/Body/ExpandedRow.d.ts

@@ -0,0 +1,63 @@
+import React, { PureComponent, ReactNode } from 'react';
+import PropTypes from 'prop-types';
+import Store from '@douyinfe/semi-foundation/lib/cjs/utils/Store';
+import { ColumnProps, ExpandIcon, TableComponents, Virtualized, Fixed } from '../interface';
+export interface TableExpandedRowProps {
+    cellWidths: number[];
+    className?: string;
+    columns?: ColumnProps[];
+    components?: TableComponents;
+    defaultExpandAllRows?: boolean;
+    defaultExpandedRowKeys?: (string | number)[];
+    expandIcon?: ExpandIcon;
+    expandRowByClick?: boolean;
+    expanded?: boolean;
+    expandedRowKeys?: (string | number)[];
+    expandedRowRender?: (record?: Record<string, any>, index?: number, expanded?: boolean) => ExpandedRowRenderReturnType;
+    indentSize?: number;
+    index?: number;
+    prefixCls?: string;
+    record?: Record<string, any>;
+    renderExpandIcon?: (record?: Record<string, any>, isNested?: boolean) => ReactNode | null;
+    store?: Store;
+    style?: React.CSSProperties;
+    virtualized?: Virtualized;
+}
+/**
+ * Render expanded row
+ */
+export default class TableExpandedRow extends PureComponent<TableExpandedRowProps> {
+    static contextType: React.Context<import("../table-context").TableContextProps>;
+    static propTypes: {
+        cellWidths: PropTypes.Validator<any[]>;
+        className: PropTypes.Requireable<string>;
+        columns: PropTypes.Requireable<any[]>;
+        components: PropTypes.Requireable<object>;
+        defaultExpandAllRows: PropTypes.Requireable<boolean>;
+        defaultExpandedRowKeys: PropTypes.Requireable<any[]>;
+        expandIcon: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        expandRowByClick: PropTypes.Requireable<boolean>;
+        expanded: PropTypes.Requireable<boolean>;
+        expandedRowKeys: PropTypes.Requireable<any[]>;
+        expandedRowRender: PropTypes.Requireable<(...args: any[]) => any>;
+        indentSize: PropTypes.Requireable<number>;
+        index: PropTypes.Requireable<string | number>;
+        onExpand: PropTypes.Requireable<(...args: any[]) => any>;
+        onExpandedRowsChange: PropTypes.Requireable<(...args: any[]) => any>;
+        prefixCls: PropTypes.Requireable<string>;
+        record: PropTypes.Requireable<object>;
+        renderExpandIcon: PropTypes.Requireable<(...args: any[]) => any>;
+        store: PropTypes.Requireable<object>;
+        style: PropTypes.Requireable<object>;
+        virtualized: PropTypes.Requireable<boolean | object>;
+    };
+    static defaultProps: {
+        record: {};
+        prefixCls: "semi-table";
+    };
+    render(): JSX.Element;
+}
+export declare type ExpandedRowRenderReturnType = React.ReactNode | {
+    children: ReactNode;
+    fixed: Fixed;
+} & ColumnProps;