refactor(list): rewrite with hook (#23542)

* refactor(list): rewrite with hook

* fix lint

* fix lint

* fix lint

* fix Empty style dep

Co-authored-by: afc163 <afc163@gmail.com>

.depslintrc.js

@@ -10,6 +10,10 @@ module.exports = {
     '**/*.json',
   ],
   modulePattern: [
+    {
+      pattern: /ConfigContext.*renderEmpty/ms,
+      module: '../empty',
+    },
     {
       pattern: /ConfigConsumer.*renderEmpty/ms,
       module: '../empty',

components/list/Item.tsx

@@ -1,9 +1,9 @@
 import * as React from 'react';
 import * as PropTypes from 'prop-types';
 import classNames from 'classnames';
-import { ListGridType, ColumnType } from './index';
+import { ListGridType, ColumnType, ListContext } from './index';
 import { Col } from '../grid';
-import { ConfigConsumer, ConfigConsumerProps } from '../config-provider';
+import { ConfigContext } from '../config-provider';
 import { cloneElement } from '../_util/reactNode';
 
 export interface ListItemProps extends React.HTMLAttributes<HTMLDivElement> {
@@ -26,54 +26,48 @@ export interface ListItemMetaProps {
   title?: React.ReactNode;
 }
 
-export const Meta = (props: ListItemMetaProps) => (
+export const Meta: React.FC<ListItemMetaProps> = ({
-  <ConfigConsumer>
+  prefixCls: customizePrefixCls,
-    {({ getPrefixCls }: ConfigConsumerProps) => {
+  className,
-      const {
+  avatar,
-        prefixCls: customizePrefixCls,
+  title,
-        className,
+  description,
-        avatar,
+  ...others
-        title,
+}) => {
-        description,
+  const { getPrefixCls } = React.useContext(ConfigContext);
-        ...others
+
-      } = props;
+  const prefixCls = getPrefixCls('list', customizePrefixCls);
-
+  const classString = classNames(`${prefixCls}-item-meta`, className);
-      const prefixCls = getPrefixCls('list', customizePrefixCls);
+
-      const classString = classNames(`${prefixCls}-item-meta`, className);
+  const content = (
-
+    <div className={`${prefixCls}-item-meta-content`}>
-      const content = (
+      {title && <h4 className={`${prefixCls}-item-meta-title`}>{title}</h4>}
-        <div className={`${prefixCls}-item-meta-content`}>
+      {description && <div className={`${prefixCls}-item-meta-description`}>{description}</div>}
-          {title && <h4 className={`${prefixCls}-item-meta-title`}>{title}</h4>}
+    </div>
-          {description && <div className={`${prefixCls}-item-meta-description`}>{description}</div>}
+  );
-        </div>
+
-      );
+  return (
-
+    <div {...others} className={classString}>
-      return (
+      {avatar && <div className={`${prefixCls}-item-meta-avatar`}>{avatar}</div>}
-        <div {...others} className={classString}>
+      {(title || description) && content}
-          {avatar && <div className={`${prefixCls}-item-meta-avatar`}>{avatar}</div>}
+    </div>
-          {(title || description) && content}
+  );
-        </div>
+};
-      );
-    }}
-  </ConfigConsumer>
-);
 
 function getGrid(grid: ListGridType, t: ColumnType) {
   return grid[t] && Math.floor(24 / grid[t]!);
 }
 
-export default class Item extends React.Component<ListItemProps, any> {
+export interface ListItemTypeProps extends React.FC<ListItemProps> {
-  static Meta: typeof Meta = Meta;
+  Meta: typeof Meta;
-
+}
-  static contextTypes = {
-    grid: PropTypes.any,
-    itemLayout: PropTypes.string,
-  };
 
-  context: any;
+const Item: ListItemTypeProps = props => {
+  const { grid, itemLayout } = React.useContext(ListContext);
+  const { getPrefixCls } = React.useContext(ConfigContext);
 
-  isItemContainsTextNodeAndNotSingular() {
+  const isItemContainsTextNodeAndNotSingular = () => {
-    const { children } = this.props;
+    const { children } = props;
     let result;
     React.Children.forEach(children, (element: React.ReactElement<any>) => {
       if (typeof element === 'string') {
@@ -81,79 +75,73 @@ export default class Item extends React.Component<ListItemProps, any> {
       }
     });
     return result && React.Children.count(children) > 1;
-  }
+  };
 
-  isFlexMode() {
+  const isFlexMode = () => {
-    const { extra } = this.props;
+    const { extra } = props;
-    const { itemLayout } = this.context;
     if (itemLayout === 'vertical') {
       return !!extra;
     }
-    return !this.isItemContainsTextNodeAndNotSingular();
+    return !isItemContainsTextNodeAndNotSingular();
-  }
-
-  renderItem = ({ getPrefixCls }: ConfigConsumerProps) => {
-    const { grid, itemLayout } = this.context;
-    const {
-      prefixCls: customizePrefixCls,
-      children,
-      actions,
-      extra,
-      className,
-      ...others
-    } = this.props;
-    const prefixCls = getPrefixCls('list', customizePrefixCls);
-    const actionsContent = actions && actions.length > 0 && (
-      <ul className={`${prefixCls}-item-action`} key="actions">
-        {actions.map((action: React.ReactNode, i: number) => (
-          // eslint-disable-next-line react/no-array-index-key
-          <li key={`${prefixCls}-item-action-${i}`}>
-            {action}
-            {i !== actions.length - 1 && <em className={`${prefixCls}-item-action-split`} />}
-          </li>
-        ))}
-      </ul>
-    );
-    const Tag = grid ? 'div' : 'li';
-    const itemChildren = (
-      <Tag
-        {...(others as any)} // `li` element `onCopy` prop args is not same as `div`
-        className={classNames(`${prefixCls}-item`, className, {
-          [`${prefixCls}-item-no-flex`]: !this.isFlexMode(),
-        })}
-      >
-        {itemLayout === 'vertical' && extra
-          ? [
-              <div className={`${prefixCls}-item-main`} key="content">
-                {children}
-                {actionsContent}
-              </div>,
-              <div className={`${prefixCls}-item-extra`} key="extra">
-                {extra}
-              </div>,
-            ]
-          : [children, actionsContent, cloneElement(extra, { key: 'extra' })]}
-      </Tag>
-    );
-
-    return grid ? (
-      <Col
-        span={getGrid(grid, 'column')}
-        xs={getGrid(grid, 'xs')}
-        sm={getGrid(grid, 'sm')}
-        md={getGrid(grid, 'md')}
-        lg={getGrid(grid, 'lg')}
-        xl={getGrid(grid, 'xl')}
-        xxl={getGrid(grid, 'xxl')}
-      >
-        {itemChildren}
-      </Col>
-    ) : (
-      itemChildren
-    );
   };
 
-  render() {
+  const { prefixCls: customizePrefixCls, children, actions, extra, className, ...others } = props;
-    return <ConfigConsumer>{this.renderItem}</ConfigConsumer>;
+  const prefixCls = getPrefixCls('list', customizePrefixCls);
-  }
+  const actionsContent = actions && actions.length > 0 && (
-}
+    <ul className={`${prefixCls}-item-action`} key="actions">
+      {actions.map((action: React.ReactNode, i: number) => (
+        // eslint-disable-next-line react/no-array-index-key
+        <li key={`${prefixCls}-item-action-${i}`}>
+          {action}
+          {i !== actions.length - 1 && <em className={`${prefixCls}-item-action-split`} />}
+        </li>
+      ))}
+    </ul>
+  );
+  const Tag = grid ? 'div' : 'li';
+  const itemChildren = (
+    <Tag
+      {...(others as any)} // `li` element `onCopy` prop args is not same as `div`
+      className={classNames(`${prefixCls}-item`, className, {
+        [`${prefixCls}-item-no-flex`]: !isFlexMode(),
+      })}
+    >
+      {itemLayout === 'vertical' && extra
+        ? [
+            <div className={`${prefixCls}-item-main`} key="content">
+              {children}
+              {actionsContent}
+            </div>,
+            <div className={`${prefixCls}-item-extra`} key="extra">
+              {extra}
+            </div>,
+          ]
+        : [children, actionsContent, cloneElement(extra, { key: 'extra' })]}
+    </Tag>
+  );
+
+  return grid ? (
+    <Col
+      span={getGrid(grid, 'column')}
+      xs={getGrid(grid, 'xs')}
+      sm={getGrid(grid, 'sm')}
+      md={getGrid(grid, 'md')}
+      lg={getGrid(grid, 'lg')}
+      xl={getGrid(grid, 'xl')}
+      xxl={getGrid(grid, 'xxl')}
+    >
+      {itemChildren}
+    </Col>
+  ) : (
+    itemChildren
+  );
+};
+
+Item.Meta = Meta;
+
+Item.contextTypes = {
+  grid: PropTypes.any,
+  itemLayout: PropTypes.string,
+};
+
+export default Item;

components/list/index.tsx

@@ -1,9 +1,8 @@
 import * as React from 'react';
-import * as PropTypes from 'prop-types';
 import classNames from 'classnames';
 import omit from 'omit.js';
 import Spin, { SpinProps } from '../spin';
-import { ConfigConsumer, ConfigConsumerProps, RenderEmptyHandler } from '../config-provider';
+import { RenderEmptyHandler, ConfigContext } from '../config-provider';
 
 import Pagination, { PaginationConfig } from '../pagination';
 import { Row } from '../grid';
@@ -58,73 +57,49 @@ export interface ListLocale {
   emptyText: React.ReactNode | (() => React.ReactNode);
 }
 
-interface ListState {
+export interface ListConsumerProps {
-  paginationCurrent: number;
+  grid?: any;
-  paginationSize: number;
+  itemLayout?: string;
 }
 
-export default class List<T> extends React.Component<ListProps<T>, ListState> {
+export const ListContext = React.createContext<ListConsumerProps>({});
-  static Item: typeof Item = Item;
 
-  static childContextTypes = {
+export const ListConsumer = ListContext.Consumer;
-    grid: PropTypes.any,
-    itemLayout: PropTypes.string,
-  };
 
-  static defaultProps = {
+function List<T>({ pagination, ...props }: ListProps<T>) {
-    dataSource: [],
+  const paginationObj = pagination && typeof pagination === 'object' ? pagination : {};
-    bordered: false,
+
-    split: true,
+  const [paginationCurrent, setPaginationCurrent] = React.useState(
-    loading: false,
+    paginationObj.defaultCurrent || 1,
-    pagination: false as ListProps<any>['pagination'],
+  );
-  };
+  const [paginationSize, setPaginationSize] = React.useState(paginationObj.defaultPageSize || 10);
 
-  defaultPaginationProps = {
+  const { getPrefixCls, renderEmpty, direction } = React.useContext(ConfigContext);
+
+  const defaultPaginationProps = {
     current: 1,
     total: 0,
   };
 
-  private keys: { [key: string]: string } = {};
+  const keys: { [key: string]: string } = {};
-
-  private onPaginationChange = this.triggerPaginationEvent('onChange');
-
-  private onPaginationShowSizeChange = this.triggerPaginationEvent('onShowSizeChange');
-
-  constructor(props: ListProps<T>) {
-    super(props);
-
-    const { pagination } = props;
-    const paginationObj = pagination && typeof pagination === 'object' ? pagination : {};
-
-    this.state = {
-      paginationCurrent: paginationObj.defaultCurrent || 1,
-      paginationSize: paginationObj.defaultPageSize || 10,
-    };
-  }
-
-  getChildContext() {
-    return {
-      grid: this.props.grid,
-      itemLayout: this.props.itemLayout,
-    };
-  }
 
-  triggerPaginationEvent(eventName: string) {
+  const triggerPaginationEvent = (eventName: string) => {
     return (page: number, pageSize: number) => {
-      const { pagination } = this.props;
+      setPaginationCurrent(page);
-      this.setState({
+      setPaginationSize(pageSize);
-        paginationCurrent: page,
-        paginationSize: pageSize,
-      });
       if (pagination && (pagination as any)[eventName]) {
         (pagination as any)[eventName](page, pageSize);
       }
     };
-  }
+  };
+
+  const onPaginationChange = triggerPaginationEvent('onChange');
+
+  const onPaginationShowSizeChange = triggerPaginationEvent('onShowSizeChange');
 
-  renderItem = (item: any, index: number) => {
+  const renderItem = (item: any, index: number) => {
-    const { renderItem, rowKey } = this.props;
+    const { rowKey } = props;
-    if (!renderItem) return null;
+    if (!props.renderItem) return null;
 
     let key;
 
@@ -140,138 +115,136 @@ export default class List<T> extends React.Component<ListProps<T>, ListState> {
       key = `list-item-${index}`;
     }
 
-    this.keys[index] = key;
+    keys[index] = key;
 
-    return renderItem(item, index);
+    return props.renderItem(item, index);
   };
 
-  isSomethingAfterLastItem() {
+  const isSomethingAfterLastItem = () => {
-    const { loadMore, pagination, footer } = this.props;
+    const { loadMore, footer } = props;
     return !!(loadMore || pagination || footer);
-  }
+  };
 
-  renderEmpty = (prefixCls: string, renderEmpty: RenderEmptyHandler) => {
+  const renderEmptyFunc = (prefixCls: string, renderEmptyHandler: RenderEmptyHandler) => {
-    const { locale } = this.props;
+    const { locale } = props;
 
     return (
       <div className={`${prefixCls}-empty-text`}>
-        {(locale && locale.emptyText) || renderEmpty('List')}
+        {(locale && locale.emptyText) || renderEmptyHandler('List')}
       </div>
     );
   };
 
-  renderList = ({ getPrefixCls, renderEmpty, direction }: ConfigConsumerProps) => {
+  const {
-    const { paginationCurrent, paginationSize } = this.state;
+    prefixCls: customizePrefixCls,
-    const {
+    bordered,
-      prefixCls: customizePrefixCls,
+    split,
-      bordered,
+    className,
-      split,
+    children,
-      className,
+    itemLayout,
-      children,
+    loadMore,
-      itemLayout,
+    grid,
-      loadMore,
+    dataSource = [],
-      pagination,
+    size,
-      grid,
+    header,
-      dataSource = [],
+    footer,
-      size,
+    loading,
-      header,
+    ...rest
-      footer,
+  } = props;
-      loading,
+
-      ...rest
+  const prefixCls = getPrefixCls('list', customizePrefixCls);
-    } = this.props;
+  let loadingProp = loading;
-
+  if (typeof loadingProp === 'boolean') {
-    const prefixCls = getPrefixCls('list', customizePrefixCls);
+    loadingProp = {
-    let loadingProp = loading;
+      spinning: loadingProp,
-    if (typeof loadingProp === 'boolean') {
-      loadingProp = {
-        spinning: loadingProp,
-      };
-    }
-    const isLoading = loadingProp && loadingProp.spinning;
-
-    // large => lg
-    // small => sm
-    let sizeCls = '';
-    switch (size) {
-      case 'large':
-        sizeCls = 'lg';
-        break;
-      case 'small':
-        sizeCls = 'sm';
-        break;
-      default:
-        break;
-    }
-
-    const classString = classNames(prefixCls, className, {
-      [`${prefixCls}-vertical`]: itemLayout === 'vertical',
-      [`${prefixCls}-${sizeCls}`]: sizeCls,
-      [`${prefixCls}-split`]: split,
-      [`${prefixCls}-bordered`]: bordered,
-      [`${prefixCls}-loading`]: isLoading,
-      [`${prefixCls}-grid`]: grid,
-      [`${prefixCls}-something-after-last-item`]: this.isSomethingAfterLastItem(),
-      [`${prefixCls}-rtl`]: direction === 'rtl',
-    });
-
-    const paginationProps = {
-      ...this.defaultPaginationProps,
-      total: dataSource.length,
-      current: paginationCurrent,
-      pageSize: paginationSize,
-      ...(pagination || {}),
     };
+  }
+  const isLoading = loadingProp && loadingProp.spinning;
+
+  // large => lg
+  // small => sm
+  let sizeCls = '';
+  switch (size) {
+    case 'large':
+      sizeCls = 'lg';
+      break;
+    case 'small':
+      sizeCls = 'sm';
+      break;
+    default:
+      break;
+  }
 
-    const largestPage = Math.ceil(paginationProps.total / paginationProps.pageSize);
+  const classString = classNames(prefixCls, className, {
-    if (paginationProps.current > largestPage) {
+    [`${prefixCls}-vertical`]: itemLayout === 'vertical',
-      paginationProps.current = largestPage;
+    [`${prefixCls}-${sizeCls}`]: sizeCls,
-    }
+    [`${prefixCls}-split`]: split,
-    const paginationContent = pagination ? (
+    [`${prefixCls}-bordered`]: bordered,
-      <div className={`${prefixCls}-pagination`}>
+    [`${prefixCls}-loading`]: isLoading,
-        <Pagination
+    [`${prefixCls}-grid`]: grid,
-          {...paginationProps}
+    [`${prefixCls}-something-after-last-item`]: isSomethingAfterLastItem(),
-          onChange={this.onPaginationChange}
+    [`${prefixCls}-rtl`]: direction === 'rtl',
-          onShowSizeChange={this.onPaginationShowSizeChange}
+  });
-        />
+
-      </div>
+  const paginationProps = {
-    ) : null;
+    ...defaultPaginationProps,
-
+    total: dataSource.length,
-    let splitDataSource = [...dataSource];
+    current: paginationCurrent,
-    if (pagination) {
+    pageSize: paginationSize,
-      if (dataSource.length > (paginationProps.current - 1) * paginationProps.pageSize) {
+    ...(pagination || {}),
-        splitDataSource = [...dataSource].splice(
+  };
-          (paginationProps.current - 1) * paginationProps.pageSize,
-          paginationProps.pageSize,
-        );
-      }
-    }
 
-    let childrenContent;
+  const largestPage = Math.ceil(paginationProps.total / paginationProps.pageSize);
-    childrenContent = isLoading && <div style={{ minHeight: 53 }} />;
+  if (paginationProps.current > largestPage) {
-    if (splitDataSource.length > 0) {
+    paginationProps.current = largestPage;
-      const items = splitDataSource.map((item: any, index: number) => this.renderItem(item, index));
+  }
-
+  const paginationContent = pagination ? (
-      const childrenList: Array<React.ReactNode> = [];
+    <div className={`${prefixCls}-pagination`}>
-      React.Children.forEach(items, (child: any, index) => {
+      <Pagination
-        childrenList.push(
+        {...paginationProps}
-          React.cloneElement(child, {
+        onChange={onPaginationChange}
-            key: this.keys[index],
+        onShowSizeChange={onPaginationShowSizeChange}
-          }),
+      />
-        );
+    </div>
-      });
+  ) : null;
-
+
-      childrenContent = grid ? (
+  let splitDataSource = [...dataSource];
-        <Row gutter={grid.gutter}>{childrenList}</Row>
+  if (pagination) {
-      ) : (
+    if (dataSource.length > (paginationProps.current - 1) * paginationProps.pageSize) {
-        <ul className={`${prefixCls}-items`}>{childrenList}</ul>
+      splitDataSource = [...dataSource].splice(
+        (paginationProps.current - 1) * paginationProps.pageSize,
+        paginationProps.pageSize,
       );
-    } else if (!children && !isLoading) {
-      childrenContent = this.renderEmpty(prefixCls, renderEmpty);
     }
+  }
+
+  let childrenContent;
+  childrenContent = isLoading && <div style={{ minHeight: 53 }} />;
+  if (splitDataSource.length > 0) {
+    const items = splitDataSource.map((item: any, index: number) => renderItem(item, index));
+
+    const childrenList: Array<React.ReactNode> = [];
+    React.Children.forEach(items, (child: any, index) => {
+      childrenList.push(
+        React.cloneElement(child, {
+          key: keys[index],
+        }),
+      );
+    });
+
+    childrenContent = grid ? (
+      <Row gutter={grid.gutter}>{childrenList}</Row>
+    ) : (
+      <ul className={`${prefixCls}-items`}>{childrenList}</ul>
+    );
+  } else if (!children && !isLoading) {
+    childrenContent = renderEmptyFunc(prefixCls, renderEmpty);
+  }
 
-    const paginationPosition = paginationProps.position || 'bottom';
+  const paginationPosition = paginationProps.position || 'bottom';
 
-    return (
+  return (
+    <ListContext.Provider value={{ grid: props.grid, itemLayout: props.itemLayout }}>
       <div className={classString} {...omit(rest, ['rowKey', 'renderItem', 'locale'])}>
         {(paginationPosition === 'top' || paginationPosition === 'both') && paginationContent}
         {header && <div className={`${prefixCls}-header`}>{header}</div>}
@@ -283,10 +256,18 @@ export default class List<T> extends React.Component<ListProps<T>, ListState> {
         {loadMore ||
           ((paginationPosition === 'bottom' || paginationPosition === 'both') && paginationContent)}
       </div>
-    );
+    </ListContext.Provider>
-  };
+  );
-
-  render() {
-    return <ConfigConsumer>{this.renderList}</ConfigConsumer>;
-  }
 }
+
+List.defaultProps = {
+  dataSource: [],
+  bordered: false,
+  split: true,
+  loading: false,
+  pagination: false as ListProps<any>['pagination'],
+};
+
+List.Item = Item;
+
+export default List;