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

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

@@ -0,0 +1,99 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { PageList, PaginationAdapter } from '@douyinfe/semi-foundation/lib/cjs/pagination/foundation';
+import '@douyinfe/semi-foundation/lib/cjs/pagination/pagination.css';
+import { Locale } from '../locale/interface';
+import BaseComponent from '../_base/baseComponent';
+import { Position } from '../tooltip';
+export interface PaginationProps {
+    total?: number;
+    showTotal?: boolean;
+    pageSize?: number;
+    pageSizeOpts?: Array<number>;
+    size?: 'small' | 'default';
+    currentPage?: number;
+    defaultCurrentPage?: number;
+    onPageChange?: (currentPage: number) => void;
+    onPageSizeChange?: (newPageSize: number) => void;
+    onChange?: (currentPage: number, pageSize: number) => void;
+    prevText?: React.ReactNode;
+    nextText?: React.ReactNode;
+    showSizeChanger?: boolean;
+    showQuickJumper?: boolean;
+    popoverZIndex?: number;
+    popoverPosition?: PopoverPosition;
+    style?: React.CSSProperties;
+    className?: string;
+    hideOnSinglePage?: boolean;
+    hoverShowPageSelect?: boolean;
+}
+export interface PaginationState {
+    total: number;
+    showTotal: boolean;
+    currentPage: number;
+    pageSize: number;
+    pageList: PageList;
+    prevDisabled: boolean;
+    quickJumpPage: string | number;
+    nextDisabled: boolean;
+    restLeftPageList: number[];
+    restRightPageList: number[];
+}
+export declare type PaginationLocale = Locale['Pagination'];
+export declare type PopoverPosition = Position;
+export { PageList };
+export default class Pagination extends BaseComponent<PaginationProps, PaginationState> {
+    static contextType: React.Context<import("../configProvider/context").ContextValue>;
+    static propTypes: {
+        total: PropTypes.Requireable<number>;
+        showTotal: PropTypes.Requireable<boolean>;
+        pageSize: PropTypes.Requireable<number>;
+        pageSizeOpts: PropTypes.Requireable<any[]>;
+        size: PropTypes.Requireable<string>;
+        currentPage: PropTypes.Requireable<number>;
+        defaultCurrentPage: PropTypes.Requireable<number>;
+        onPageChange: PropTypes.Requireable<(...args: any[]) => any>;
+        onPageSizeChange: PropTypes.Requireable<(...args: any[]) => any>;
+        onChange: PropTypes.Requireable<(...args: any[]) => any>;
+        prevText: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        nextText: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        showSizeChanger: PropTypes.Requireable<boolean>;
+        popoverZIndex: PropTypes.Requireable<number>;
+        popoverPosition: PropTypes.Requireable<string>;
+        style: PropTypes.Requireable<object>;
+        className: PropTypes.Requireable<string>;
+        hideOnSinglePage: PropTypes.Requireable<boolean>;
+        hoverShowPageSelect: PropTypes.Requireable<boolean>;
+        showQuickJumper: PropTypes.Requireable<boolean>;
+    };
+    static defaultProps: {
+        total: number;
+        popoverZIndex: number;
+        showTotal: boolean;
+        pageSize: null;
+        pageSizeOpts: readonly [10, 20, 40, 100];
+        defaultCurrentPage: number;
+        size: string;
+        onPageChange: (...args: any[]) => void;
+        onPageSizeChange: (...args: any[]) => void;
+        onChange: (...args: any[]) => void;
+        showSizeChanger: boolean;
+        className: string;
+        hideOnSinglePage: boolean;
+        showQuickJumper: boolean;
+    };
+    constructor(props: PaginationProps);
+    get adapter(): PaginationAdapter<PaginationProps, PaginationState>;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    componentDidUpdate(prevProps: PaginationProps): void;
+    renderPrevBtn(): JSX.Element;
+    renderNextBtn(): JSX.Element;
+    renderPageSizeSwitch(locale: PaginationLocale): JSX.Element;
+    renderQuickJump(locale: PaginationLocale): JSX.Element;
+    renderPageList(): JSX.Element[];
+    renderRestPageList(restList: ('...' | number)[]): JSX.Element;
+    renderSmallPage(locale: PaginationLocale): JSX.Element;
+    renderDefaultPage(locale: PaginationLocale): JSX.Element;
+    render(): JSX.Element;
+}

package/lib/cjs/pagination/index.js

@@ -0,0 +1,481 @@
+"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 _bind = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/bind"));
+
+var _assign = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/assign"));
+
+var _map = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/map"));
+
+var _concat = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/concat"));
+
+var _from = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/array/from"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _reactWindow = require("react-window");
+
+var _lodashEs = require("lodash-es");
+
+var _foundation = _interopRequireDefault(require("@douyinfe/semi-foundation/lib/cjs/pagination/foundation"));
+
+var _constants = require("@douyinfe/semi-foundation/lib/cjs/pagination/constants");
+
+require("@douyinfe/semi-foundation/lib/cjs/pagination/pagination.css");
+
+var _constants2 = require("@douyinfe/semi-foundation/lib/cjs/popover/constants");
+
+var _semiIcons = require("@douyinfe/semi-icons");
+
+var _context7 = _interopRequireDefault(require("../configProvider/context"));
+
+var _localeConsumer = _interopRequireDefault(require("../locale/localeConsumer"));
+
+var _index = _interopRequireDefault(require("../select/index"));
+
+var _index2 = _interopRequireDefault(require("../inputNumber/index"));
+
+var _baseComponent = _interopRequireDefault(require("../_base/baseComponent"));
+
+var _index3 = _interopRequireDefault(require("../popover/index"));
+
+/* eslint-disable max-len */
+const prefixCls = _constants.cssClasses.PREFIX;
+const {
+  Option
+} = _index.default;
+
+class Pagination extends _baseComponent.default {
+  constructor(props) {
+    var _context, _context2;
+
+    super(props);
+    this.state = {
+      total: props.total,
+      showTotal: props.showTotal,
+      currentPage: props.currentPage || props.defaultCurrentPage,
+      pageSize: props.pageSize || props.pageSizeOpts[0] || _constants.numbers.DEFAULT_PAGE_SIZE,
+      pageList: [],
+      prevDisabled: false,
+      nextDisabled: false,
+      restLeftPageList: [],
+      restRightPageList: [],
+      quickJumpPage: ''
+    };
+    this.foundation = new _foundation.default(this.adapter);
+    this.renderDefaultPage = (0, _bind.default)(_context = this.renderDefaultPage).call(_context, this);
+    this.renderSmallPage = (0, _bind.default)(_context2 = this.renderSmallPage).call(_context2, this);
+  }
+
+  get adapter() {
+    return (0, _assign.default)((0, _assign.default)({}, super.adapter), {
+      setPageList: pageListState => {
+        const {
+          pageList,
+          restLeftPageList,
+          restRightPageList
+        } = pageListState;
+        this.setState({
+          pageList,
+          restLeftPageList,
+          restRightPageList
+        });
+      },
+      setDisabled: (prevIsDisabled, nextIsDisabled) => {
+        this.setState({
+          prevDisabled: prevIsDisabled,
+          nextDisabled: nextIsDisabled
+        });
+      },
+      updateTotal: total => this.setState({
+        total
+      }),
+      updatePageSize: pageSize => this.setState({
+        pageSize
+      }),
+      updateQuickJumpPage: quickJumpPage => this.setState({
+        quickJumpPage
+      }),
+      // updateRestPageList: () => {},
+      setCurrentPage: pageIndex => {
+        this.setState({
+          currentPage: pageIndex
+        });
+      },
+      registerKeyDownHandler: handler => {
+        document.addEventListener('keydown', handler);
+      },
+      unregisterKeyDownHandler: handler => {
+        document.removeEventListener('keydown', handler);
+      },
+      notifyPageChange: pageIndex => {
+        this.props.onPageChange(pageIndex);
+      },
+      notifyPageSizeChange: pageSize => {
+        this.props.onPageSizeChange(pageSize);
+      },
+      notifyChange: (pageIndex, pageSize) => {
+        this.props.onChange(pageIndex, pageSize);
+      }
+    });
+  }
+
+  componentDidMount() {
+    this.foundation.init();
+  }
+
+  componentWillUnmount() {
+    this.foundation.destroy();
+  }
+
+  componentDidUpdate(prevProps) {
+    const pagerProps = {
+      currentPage: this.props.currentPage,
+      total: this.props.total,
+      pageSize: this.props.pageSize
+    };
+    let pagerHasChanged = false;
+
+    if (prevProps.currentPage !== this.props.currentPage) {
+      pagerHasChanged = true; // this.foundation.updatePage(this.props.currentPage);
+    }
+
+    if (prevProps.total !== this.props.total) {
+      pagerHasChanged = true;
+    }
+
+    if (prevProps.pageSize !== this.props.pageSize) {
+      pagerHasChanged = true;
+    }
+
+    if (pagerHasChanged) {
+      this.foundation.updatePage(pagerProps.currentPage, pagerProps.total, pagerProps.pageSize);
+    }
+  }
+
+  renderPrevBtn() {
+    const {
+      prevText
+    } = this.props;
+    const {
+      prevDisabled
+    } = this.state;
+    const preClassName = (0, _classnames.default)({
+      ["".concat(prefixCls, "-item")]: true,
+      ["".concat(prefixCls, "-prev")]: true,
+      ["".concat(prefixCls, "-item-disabled")]: prevDisabled
+    });
+    return /*#__PURE__*/_react.default.createElement("li", {
+      onClick: e => !prevDisabled && this.foundation.goPrev(e),
+      className: preClassName,
+      "tab-index": 0
+    }, prevText || /*#__PURE__*/_react.default.createElement(_semiIcons.IconChevronLeft, {
+      size: "large"
+    }));
+  }
+
+  renderNextBtn() {
+    const {
+      nextText
+    } = this.props;
+    const {
+      nextDisabled
+    } = this.state;
+    const nextClassName = (0, _classnames.default)({
+      ["".concat(prefixCls, "-item")]: true,
+      ["".concat(prefixCls, "-item-disabled")]: nextDisabled,
+      ["".concat(prefixCls, "-next")]: true
+    });
+    return /*#__PURE__*/_react.default.createElement("li", {
+      onClick: e => !nextDisabled && this.foundation.goNext(e),
+      className: nextClassName,
+      "tab-index": 0
+    }, nextText || /*#__PURE__*/_react.default.createElement(_semiIcons.IconChevronRight, {
+      size: "large"
+    }));
+  }
+
+  renderPageSizeSwitch(locale) {
+    // rtl modify the default position
+    const {
+      direction
+    } = this.context;
+    const defaultPopoverPosition = direction === 'rtl' ? 'bottomRight' : 'bottomLeft';
+    const {
+      showSizeChanger,
+      popoverPosition = defaultPopoverPosition
+    } = this.props;
+    const {
+      pageSize
+    } = this.state;
+    const switchCls = (0, _classnames.default)("".concat(prefixCls, "-switch"));
+
+    if (!showSizeChanger) {
+      return null;
+    }
+
+    const pageSizeText = locale.pageSize;
+    const newPageSizeOpts = this.foundation.pageSizeInOpts();
+    const options = (0, _map.default)(newPageSizeOpts).call(newPageSizeOpts, size => /*#__PURE__*/_react.default.createElement(Option, {
+      value: size,
+      key: size
+    }, /*#__PURE__*/_react.default.createElement("span", null, "".concat(size, " "), pageSizeText)));
+    return /*#__PURE__*/_react.default.createElement("div", {
+      className: switchCls
+    }, /*#__PURE__*/_react.default.createElement(_index.default, {
+      onChange: newPageSize => this.foundation.changePageSize(newPageSize),
+      value: pageSize,
+      key: pageSizeText,
+      position: popoverPosition || 'bottomRight',
+      clickToHide: true,
+      dropdownClassName: "".concat(prefixCls, "-select-dropdown")
+    }, options));
+  }
+
+  renderQuickJump(locale) {
+    const {
+      showQuickJumper
+    } = this.props;
+    const {
+      quickJumpPage,
+      total,
+      pageSize
+    } = this.state;
+
+    if (!showQuickJumper) {
+      return null;
+    }
+
+    const totalPageNum = this.foundation._getTotalPageNumber(total, pageSize);
+
+    const isDisabled = totalPageNum === 1;
+    const quickJumpCls = (0, _classnames.default)({
+      ["".concat(prefixCls, "-quickjump")]: true,
+      ["".concat(prefixCls, "-quickjump-disabled")]: isDisabled
+    });
+    return /*#__PURE__*/_react.default.createElement("div", {
+      className: quickJumpCls
+    }, /*#__PURE__*/_react.default.createElement("span", null, locale.jumpTo), /*#__PURE__*/_react.default.createElement(_index2.default, {
+      value: quickJumpPage,
+      className: "".concat(prefixCls, "-quickjump-input-number"),
+      hideButtons: true,
+      disabled: isDisabled,
+      onBlur: e => this.foundation.handleQuickJumpBlur(),
+      onEnterPress: e => this.foundation.handleQuickJumpEnterPress(e.target.value),
+      onChange: v => this.foundation.handleQuickJumpNumberChange(v)
+    }), /*#__PURE__*/_react.default.createElement("span", null, locale.page));
+  }
+
+  renderPageList() {
+    const {
+      pageList,
+      currentPage,
+      restLeftPageList,
+      restRightPageList
+    } = this.state;
+    const {
+      popoverPosition,
+      popoverZIndex
+    } = this.props;
+    return (0, _map.default)(pageList).call(pageList, (page, i) => {
+      var _context3;
+
+      const pageListClassName = (0, _classnames.default)("".concat(prefixCls, "-item"), {
+        ["".concat(prefixCls, "-item-active")]: currentPage === page // [`${prefixCls}-item-rest-opening`]: (i < 3 && isLeftRestHover && page ==='...') || (i > 3 && isRightRestHover && page === '...')
+
+      });
+
+      const pageEl = /*#__PURE__*/_react.default.createElement("li", {
+        key: (0, _concat.default)(_context3 = "".concat(page)).call(_context3, i),
+        onClick: () => this.foundation.goPage(page, i),
+        className: pageListClassName,
+        "tab-index": 0
+      }, page);
+
+      if (page === '...') {
+        var _context4;
+
+        let content;
+        i < 3 ? content = restLeftPageList : content = restRightPageList;
+        return /*#__PURE__*/_react.default.createElement(_index3.default, {
+          trigger: "hover",
+          // onVisibleChange={visible=>this.handleRestHover(visible, i < 3 ? 'left' : 'right')}
+          content: this.renderRestPageList(content),
+          key: (0, _concat.default)(_context4 = "".concat(page)).call(_context4, i),
+          position: popoverPosition,
+          zIndex: popoverZIndex
+        }, pageEl);
+      }
+
+      return pageEl;
+    });
+  }
+
+  renderRestPageList(restList) {
+    // The number of pages may be tens of thousands, here is virtualized with the help of react-window
+    const {
+      direction
+    } = this.context;
+    const className = (0, _classnames.default)("".concat(prefixCls, "-rest-item"));
+    const count = restList.length;
+
+    const row = item => {
+      var _context5;
+
+      const {
+        index,
+        style
+      } = item;
+      const page = restList[index];
+      return /*#__PURE__*/_react.default.createElement("div", {
+        key: (0, _concat.default)(_context5 = "".concat(page)).call(_context5, index),
+        className: className,
+        onClick: () => this.foundation.goPage(page, index),
+        style: style
+      }, page);
+    };
+
+    const itemHeight = 32;
+    const listHeight = count >= 5 ? itemHeight * 5 : itemHeight * count;
+    return /*#__PURE__*/_react.default.createElement(_reactWindow.FixedSizeList, {
+      className: "".concat(prefixCls, "-rest-list"),
+      itemData: restList,
+      itemSize: itemHeight,
+      width: 78,
+      itemCount: count,
+      height: listHeight,
+      style: {
+        direction
+      }
+    }, row);
+  }
+
+  renderSmallPage(locale) {
+    var _context6;
+
+    const {
+      className,
+      style,
+      hideOnSinglePage,
+      hoverShowPageSelect
+    } = this.props;
+    const paginationCls = (0, _classnames.default)("".concat(prefixCls, "-small"), prefixCls, className);
+    const {
+      currentPage,
+      total,
+      pageSize
+    } = this.state;
+    const totalPageNum = Math.ceil(total / pageSize);
+
+    if (totalPageNum < 2 && hideOnSinglePage) {
+      return null;
+    }
+
+    const pageNumbers = (0, _from.default)({
+      length: Math.ceil(total / pageSize)
+    }, (v, i) => i + 1);
+    const pageList = this.renderRestPageList(pageNumbers);
+
+    const page = /*#__PURE__*/_react.default.createElement("div", {
+      className: (0, _concat.default)(_context6 = "".concat(prefixCls, "-item ")).call(_context6, prefixCls, "-item-small")
+    }, currentPage, "/", totalPageNum, " ");
+
+    return /*#__PURE__*/_react.default.createElement("div", {
+      className: paginationCls,
+      style: style
+    }, this.renderPrevBtn(), hoverShowPageSelect ? /*#__PURE__*/_react.default.createElement(_index3.default, {
+      content: pageList
+    }, page) : page, this.renderNextBtn(), this.renderQuickJump(locale));
+  }
+
+  renderDefaultPage(locale) {
+    const {
+      total,
+      pageSize
+    } = this.state;
+    const {
+      showTotal,
+      className,
+      style,
+      hideOnSinglePage
+    } = this.props;
+    const paginationCls = (0, _classnames.default)(className, "".concat(prefixCls));
+    const showTotalCls = "".concat(prefixCls, "-total");
+    const totalPageNum = Math.ceil(total / pageSize);
+
+    if (totalPageNum < 2 && hideOnSinglePage) {
+      return null;
+    }
+
+    return /*#__PURE__*/_react.default.createElement("ul", {
+      className: paginationCls,
+      style: style
+    }, showTotal ? /*#__PURE__*/_react.default.createElement("span", {
+      className: showTotalCls
+    }, locale.total, " ".concat(Math.ceil(total / pageSize), " "), locale.page) : null, this.renderPrevBtn(), this.renderPageList(), this.renderNextBtn(), this.renderPageSizeSwitch(locale), this.renderQuickJump(locale));
+  }
+
+  render() {
+    const {
+      size
+    } = this.props;
+    return /*#__PURE__*/_react.default.createElement(_localeConsumer.default, {
+      componentName: "Pagination"
+    }, locale => size === 'small' ? this.renderSmallPage(locale) : this.renderDefaultPage(locale));
+  }
+
+}
+
+exports.default = Pagination;
+Pagination.contextType = _context7.default;
+Pagination.propTypes = {
+  total: _propTypes.default.number,
+  showTotal: _propTypes.default.bool,
+  pageSize: _propTypes.default.number,
+  pageSizeOpts: _propTypes.default.array,
+  size: _propTypes.default.string,
+  currentPage: _propTypes.default.number,
+  defaultCurrentPage: _propTypes.default.number,
+  onPageChange: _propTypes.default.func,
+  onPageSizeChange: _propTypes.default.func,
+  onChange: _propTypes.default.func,
+  prevText: _propTypes.default.node,
+  nextText: _propTypes.default.node,
+  showSizeChanger: _propTypes.default.bool,
+  popoverZIndex: _propTypes.default.number,
+  popoverPosition: _propTypes.default.string,
+  style: _propTypes.default.object,
+  className: _propTypes.default.string,
+  hideOnSinglePage: _propTypes.default.bool,
+  hoverShowPageSelect: _propTypes.default.bool,
+  showQuickJumper: _propTypes.default.bool
+};
+Pagination.defaultProps = {
+  total: 1,
+  popoverZIndex: _constants2.numbers.DEFAULT_Z_INDEX,
+  showTotal: false,
+  pageSize: null,
+  pageSizeOpts: _constants.numbers.PAGE_SIZE_OPTION,
+  defaultCurrentPage: 1,
+  size: 'default',
+  onPageChange: _lodashEs.noop,
+  onPageSizeChange: _lodashEs.noop,
+  onChange: _lodashEs.noop,
+  showSizeChanger: false,
+  className: '',
+  hideOnSinglePage: false,
+  showQuickJumper: false
+};

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

@@ -0,0 +1,86 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { PopconfirmAdapter } from '@douyinfe/semi-foundation/lib/cjs/popconfirm/popconfirmFoundation';
+import BaseComponent from '../_base/baseComponent';
+import { PopoverProps } from '../popover';
+import { Position, Trigger } from '../tooltip';
+import { ButtonProps } from '../button';
+import { Type as ButtonType } from '../button/Button';
+import '@douyinfe/semi-foundation/lib/cjs/popconfirm/popconfirm.css';
+import { Motion } from '../_base/base';
+export interface PopconfirmProps extends PopoverProps {
+    cancelText?: string;
+    cancelButtonProps?: ButtonProps;
+    cancelType?: ButtonType;
+    content?: React.ReactNode;
+    defaultVisible?: boolean;
+    disabled?: boolean;
+    icon?: React.ReactNode;
+    okText?: string;
+    okType?: ButtonType;
+    okButtonProps?: ButtonProps;
+    motion?: Motion;
+    title?: React.ReactNode;
+    visible?: boolean;
+    prefixCls?: string;
+    zIndex?: number;
+    trigger?: Trigger;
+    position?: Position;
+    onCancel?: (e: React.MouseEvent) => void;
+    onConfirm?: (e: React.MouseEvent) => void;
+    onVisibleChange?: (visible: boolean) => void;
+}
+export interface PopconfirmState {
+    visible: boolean;
+}
+export default class Popconfirm extends BaseComponent<PopconfirmProps, PopconfirmState> {
+    static contextType: React.Context<import("../configProvider/context").ContextValue>;
+    static propTypes: {
+        motion: PropTypes.Requireable<boolean | object>;
+        disabled: PropTypes.Requireable<boolean>;
+        content: PropTypes.Requireable<any>;
+        title: PropTypes.Requireable<any>;
+        prefixCls: PropTypes.Requireable<string>;
+        className: PropTypes.Requireable<string>;
+        style: PropTypes.Requireable<object>;
+        icon: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        okText: PropTypes.Requireable<string>;
+        okType: PropTypes.Requireable<string>;
+        cancelText: PropTypes.Requireable<string>;
+        cancelType: PropTypes.Requireable<string>;
+        onCancel: PropTypes.Requireable<(...args: any[]) => any>;
+        onConfirm: PropTypes.Requireable<(...args: any[]) => any>;
+        zIndex: PropTypes.Requireable<number>;
+        onVisibleChange: PropTypes.Requireable<(...args: any[]) => any>;
+        visible: PropTypes.Requireable<boolean>;
+        defaultVisible: PropTypes.Requireable<boolean>;
+        okButtonProps: PropTypes.Requireable<object>;
+        cancelButtonProps: PropTypes.Requireable<object>;
+        stopPropagation: PropTypes.Requireable<string | boolean>;
+        trigger: PropTypes.Requireable<string>;
+        position: PropTypes.Requireable<string>;
+    };
+    static defaultProps: {
+        stopPropagation: boolean;
+        trigger: string;
+        onVisibleChange: (...args: any[]) => void;
+        disabled: boolean;
+        icon: JSX.Element;
+        okType: string;
+        cancelType: string;
+        prefixCls: string;
+        zIndex: number;
+        onCancel: (...args: any[]) => void;
+        onConfirm: (...args: any[]) => void;
+    };
+    constructor(props: PopconfirmProps);
+    static getDerivedStateFromProps(props: PopconfirmProps, state: PopconfirmState): Partial<PopconfirmState>;
+    get adapter(): PopconfirmAdapter<PopconfirmProps, PopconfirmState>;
+    handleCancel: (e: React.MouseEvent) => void;
+    handleConfirm: (e: React.MouseEvent) => void;
+    handleVisibleChange: (visible: boolean) => void;
+    stopImmediatePropagation: (e: React.SyntheticEvent) => void;
+    renderControls(): JSX.Element;
+    renderConfirmPopCard(): JSX.Element;
+    render(): React.ReactNode;
+}