@douyinfe/semi-ui 2.1.1 → 2.1.2

package/lib/cjs/cascader/item.d.ts

@@ -0,0 +1,72 @@
+import React, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import { CheckboxEvent } from '../checkbox';
+import { BasicCascaderData, BasicEntity, ShowNextType, BasicData } from '@douyinfe/semi-foundation/lib/cjs/cascader/foundation';
+export interface CascaderData extends BasicCascaderData {
+    label: React.ReactNode;
+}
+export interface Entity extends BasicEntity {
+    children?: Array<Entity>;
+    data: CascaderData;
+    parent?: Entity;
+}
+export interface Entities {
+    [idx: string]: Entity;
+}
+export interface Data extends BasicData {
+    data: CascaderData;
+    searchText: React.ReactNode[];
+}
+export interface CascaderItemProps {
+    activeKeys: Set<string>;
+    selectedKeys: Set<string>;
+    loadedKeys: Set<string>;
+    loadingKeys: Set<string>;
+    onItemClick: (e: React.MouseEvent, item: Entity | Data) => void;
+    onItemHover: (e: React.MouseEvent, item: Entity) => void;
+    showNext: ShowNextType;
+    onItemCheckboxClick: (item: Entity | Data) => void;
+    onListScroll: (e: React.UIEvent<HTMLUListElement, UIEvent>, ind: number) => void;
+    searchable: boolean;
+    keyword: string;
+    empty: boolean;
+    emptyContent: React.ReactNode;
+    loadData: (selectOptions: CascaderData[]) => Promise<void>;
+    data: Array<Data | Entity>;
+    multiple: boolean;
+    checkedKeys: Set<string>;
+    halfCheckedKeys: Set<string>;
+}
+export default class Item extends PureComponent<CascaderItemProps> {
+    static contextType: React.Context<import("../configProvider/context").ContextValue>;
+    static propTypes: {
+        data: PropTypes.Requireable<any[]>;
+        emptyContent: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        searchable: PropTypes.Requireable<boolean>;
+        onItemClick: PropTypes.Requireable<(...args: any[]) => any>;
+        onItemHover: PropTypes.Requireable<(...args: any[]) => any>;
+        multiple: PropTypes.Requireable<boolean>;
+        showNext: PropTypes.Requireable<"hover" | "click">;
+        checkedKeys: PropTypes.Requireable<object>;
+        halfCheckedKeys: PropTypes.Requireable<object>;
+        onItemCheckboxClick: PropTypes.Requireable<(...args: any[]) => any>;
+        keyword: PropTypes.Requireable<string>;
+    };
+    static defaultProps: {
+        empty: boolean;
+    };
+    onClick: (e: React.MouseEvent, item: Entity | Data) => void;
+    onHover: (e: React.MouseEvent, item: Entity) => void;
+    onCheckboxChange: (e: CheckboxEvent, item: Entity | Data) => void;
+    getItemStatus: (key: string) => {
+        active: boolean;
+        selected: boolean;
+        loading: boolean;
+    };
+    renderIcon: (type: string) => JSX.Element;
+    highlight: (searchText: React.ReactNode[]) => React.ReactNode[];
+    renderFlattenOption: (data: Data[]) => JSX.Element;
+    renderItem(renderData: Array<Entity>, content?: Array<React.ReactNode>): React.ReactNode[];
+    renderEmpty(): JSX.Element;
+    render(): JSX.Element;
+}

package/lib/cjs/cascader/item.js

@@ -0,0 +1,351 @@
+"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 _concat = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/concat"));
+
+var _forEach = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/for-each"));
+
+var _map = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/map"));
+
+var _includes2 = _interopRequireDefault(require("lodash/includes"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _constants = require("@douyinfe/semi-foundation/lib/cjs/cascader/constants");
+
+var _context7 = _interopRequireDefault(require("../configProvider/context"));
+
+var _localeConsumer = _interopRequireDefault(require("../locale/localeConsumer"));
+
+var _semiIcons = require("@douyinfe/semi-icons");
+
+var _spin = _interopRequireDefault(require("../spin"));
+
+var _checkbox = _interopRequireDefault(require("../checkbox"));
+
+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; }
+
+const prefixcls = _constants.cssClasses.PREFIX_OPTION;
+
+class Item extends _react.PureComponent {
+  constructor() {
+    super(...arguments);
+
+    this.onClick = (e, item) => {
+      const {
+        onItemClick
+      } = this.props;
+
+      if (item.data.disabled || 'disabled' in item && item.disabled) {
+        return;
+      }
+
+      onItemClick(e, item);
+    };
+
+    this.onHover = (e, item) => {
+      const {
+        showNext,
+        onItemHover
+      } = this.props;
+
+      if (item.data.disabled) {
+        return;
+      }
+
+      if (showNext === _constants.strings.SHOW_NEXT_BY_HOVER) {
+        onItemHover(e, item);
+      }
+    };
+
+    this.onCheckboxChange = (e, item) => {
+      const {
+        onItemCheckboxClick
+      } = this.props; // Prevent Checkbox's click event bubbling to trigger the li click event
+
+      e.stopPropagation();
+      onItemCheckboxClick(item);
+    };
+
+    this.getItemStatus = key => {
+      const {
+        activeKeys,
+        selectedKeys,
+        loadedKeys,
+        loadingKeys
+      } = this.props;
+      const state = {
+        active: false,
+        selected: false,
+        loading: false
+      };
+
+      if (activeKeys.has(key)) {
+        state.active = true;
+      }
+
+      if (selectedKeys.has(key)) {
+        state.selected = true;
+      }
+
+      if (loadingKeys.has(key) && !loadedKeys.has(key)) {
+        state.loading = true;
+      }
+
+      return state;
+    };
+
+    this.renderIcon = type => {
+      var _context, _context2, _context3;
+
+      switch (type) {
+        case 'child':
+          return /*#__PURE__*/_react.default.createElement(_semiIcons.IconChevronRight, {
+            className: (0, _concat.default)(_context = "".concat(prefixcls, "-icon ")).call(_context, prefixcls, "-icon-expand")
+          });
+
+        case 'tick':
+          return /*#__PURE__*/_react.default.createElement(_semiIcons.IconTick, {
+            className: (0, _concat.default)(_context2 = "".concat(prefixcls, "-icon ")).call(_context2, prefixcls, "-icon-active")
+          });
+
+        case 'loading':
+          return /*#__PURE__*/_react.default.createElement(_spin.default, {
+            wrapperClassName: "".concat(prefixcls, "-spin-icon")
+          });
+
+        case 'empty':
+          return /*#__PURE__*/_react.default.createElement("span", {
+            className: (0, _concat.default)(_context3 = "".concat(prefixcls, "-icon ")).call(_context3, prefixcls, "-icon-empty")
+          });
+
+        default:
+          return null;
+      }
+    };
+
+    this.highlight = searchText => {
+      const content = [];
+      const {
+        keyword
+      } = this.props;
+      (0, _forEach.default)(searchText).call(searchText, (item, idx) => {
+        if (typeof item === 'string' && (0, _includes2.default)(item, keyword)) {
+          var _context4;
+
+          (0, _forEach.default)(_context4 = item.split(keyword)).call(_context4, (node, index) => {
+            if (index > 0) {
+              var _context5;
+
+              content.push( /*#__PURE__*/_react.default.createElement("span", {
+                className: "".concat(prefixcls, "-label-highlight"),
+                key: (0, _concat.default)(_context5 = "".concat(index, "-")).call(_context5, idx)
+              }, keyword));
+            }
+
+            content.push(node);
+          });
+        } else {
+          content.push(item);
+        }
+
+        if (idx !== searchText.length - 1) {
+          content.push(' / ');
+        }
+      });
+      return content;
+    };
+
+    this.renderFlattenOption = data => {
+      const {
+        multiple,
+        checkedKeys,
+        halfCheckedKeys
+      } = this.props;
+
+      const content = /*#__PURE__*/_react.default.createElement("ul", {
+        className: "".concat(prefixcls, "-list"),
+        key: 'flatten-list'
+      }, (0, _map.default)(data).call(data, item => {
+        const {
+          searchText,
+          key,
+          disabled
+        } = item;
+        const className = (0, _classnames.default)(prefixcls, {
+          ["".concat(prefixcls, "-flatten")]: true,
+          ["".concat(prefixcls, "-disabled")]: disabled
+        });
+        return /*#__PURE__*/_react.default.createElement("li", {
+          className: className,
+          key: key,
+          onClick: e => {
+            this.onClick(e, item);
+          }
+        }, /*#__PURE__*/_react.default.createElement("span", {
+          className: "".concat(prefixcls, "-label")
+        }, !multiple && this.renderIcon('empty'), multiple && /*#__PURE__*/_react.default.createElement(_checkbox.default, {
+          onChange: e => this.onCheckboxChange(e, item),
+          disabled: disabled,
+          indeterminate: halfCheckedKeys.has(item.key),
+          checked: checkedKeys.has(item.key),
+          className: "".concat(prefixcls, "-label-checkbox")
+        }), this.highlight(searchText)));
+      }));
+
+      return content;
+    };
+  }
+
+  renderItem(renderData) {
+    let content = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    const {
+      multiple,
+      checkedKeys,
+      halfCheckedKeys
+    } = this.props;
+    let showChildItem;
+    const ind = content.length;
+    content.push( /*#__PURE__*/_react.default.createElement("ul", {
+      className: "".concat(prefixcls, "-list"),
+      key: renderData[0].key,
+      onScroll: e => this.props.onListScroll(e, ind)
+    }, (0, _map.default)(renderData).call(renderData, item => {
+      const {
+        data,
+        key
+      } = item;
+      const {
+        children,
+        label,
+        disabled,
+        isLeaf
+      } = data;
+      const {
+        active,
+        selected,
+        loading
+      } = this.getItemStatus(key);
+      const hasChild = Boolean(children) && children.length;
+      const showExpand = hasChild || this.props.loadData && !isLeaf;
+
+      if (active && hasChild) {
+        showChildItem = item;
+      }
+
+      const className = (0, _classnames.default)(prefixcls, {
+        ["".concat(prefixcls, "-active")]: active && !selected,
+        ["".concat(prefixcls, "-select")]: selected && !multiple,
+        ["".concat(prefixcls, "-disabled")]: disabled
+      });
+      return /*#__PURE__*/_react.default.createElement("li", {
+        className: className,
+        key: key,
+        onClick: e => {
+          this.onClick(e, item);
+        },
+        onMouseEnter: e => {
+          this.onHover(e, item);
+        }
+      }, /*#__PURE__*/_react.default.createElement("span", {
+        className: "".concat(prefixcls, "-label")
+      }, selected && !multiple && this.renderIcon('tick'), !selected && !multiple && this.renderIcon('empty'), multiple && /*#__PURE__*/_react.default.createElement(_checkbox.default, {
+        onChange: e => this.onCheckboxChange(e, item),
+        disabled: disabled,
+        indeterminate: halfCheckedKeys.has(item.key),
+        checked: checkedKeys.has(item.key),
+        className: "".concat(prefixcls, "-label-checkbox")
+      }), /*#__PURE__*/_react.default.createElement("span", null, label)), showExpand ? this.renderIcon(loading ? 'loading' : 'child') : null);
+    })));
+
+    if (showChildItem) {
+      (0, _concat.default)(content).call(content, this.renderItem(showChildItem.children, content));
+    }
+
+    return content;
+  }
+
+  renderEmpty() {
+    const {
+      emptyContent
+    } = this.props;
+    return /*#__PURE__*/_react.default.createElement(_localeConsumer.default, {
+      componentName: "Cascader"
+    }, locale => {
+      var _context6;
+
+      return /*#__PURE__*/_react.default.createElement("ul", {
+        className: (0, _concat.default)(_context6 = "".concat(prefixcls, " ")).call(_context6, prefixcls, "-empty"),
+        key: 'empty-list'
+      }, /*#__PURE__*/_react.default.createElement("span", {
+        className: "".concat(prefixcls, "-label")
+      }, emptyContent || locale.emptyText));
+    });
+  }
+
+  render() {
+    const {
+      data,
+      searchable
+    } = this.props;
+    const {
+      direction
+    } = this.context;
+    const isEmpty = !data || !data.length;
+    let content;
+    const listsCls = (0, _classnames.default)({
+      ["".concat(prefixcls, "-lists")]: true,
+      ["".concat(prefixcls, "-lists-rtl")]: direction === 'rtl',
+      ["".concat(prefixcls, "-lists-empty")]: isEmpty
+    });
+
+    if (isEmpty) {
+      content = this.renderEmpty();
+    } else {
+      content = searchable ? this.renderFlattenOption(data) : this.renderItem(data);
+    }
+
+    return /*#__PURE__*/_react.default.createElement("div", {
+      className: listsCls
+    }, content);
+  }
+
+}
+
+exports.default = Item;
+Item.contextType = _context7.default;
+Item.propTypes = {
+  data: _propTypes.default.array,
+  emptyContent: _propTypes.default.node,
+  searchable: _propTypes.default.bool,
+  onItemClick: _propTypes.default.func,
+  onItemHover: _propTypes.default.func,
+  multiple: _propTypes.default.bool,
+  showNext: _propTypes.default.oneOf([_constants.strings.SHOW_NEXT_BY_CLICK, _constants.strings.SHOW_NEXT_BY_HOVER]),
+  checkedKeys: _propTypes.default.object,
+  halfCheckedKeys: _propTypes.default.object,
+  onItemCheckboxClick: _propTypes.default.func,
+  keyword: _propTypes.default.string
+};
+Item.defaultProps = {
+  empty: false
+};

package/lib/cjs/checkbox/checkbox.d.ts

@@ -0,0 +1,61 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { CheckboxAdapter, BasicCheckboxEvent, BasicTargetObject, BaseCheckboxProps } from '@douyinfe/semi-foundation/lib/cjs/checkbox/checkboxFoundation';
+import CheckboxInner from './checkboxInner';
+import BaseComponent from '../_base/baseComponent';
+import '@douyinfe/semi-foundation/lib/cjs/checkbox/checkbox.css';
+export declare type CheckboxEvent = BasicCheckboxEvent;
+export declare type TargetObject = BasicTargetObject;
+export interface CheckboxProps extends BaseCheckboxProps {
+    onChange?: (e: CheckboxEvent) => any;
+    style?: React.CSSProperties;
+    onMouseEnter?: React.MouseEventHandler<HTMLSpanElement>;
+    onMouseLeave?: React.MouseEventHandler<HTMLSpanElement>;
+    extra?: React.ReactNode;
+}
+interface CheckboxState {
+    checked: boolean;
+}
+declare class Checkbox extends BaseComponent<CheckboxProps, CheckboxState> {
+    static contextType: React.Context<{
+        checkboxGroup?: {
+            onChange: (evt: BasicCheckboxEvent) => void;
+            value: any[];
+            disabled: boolean;
+            name: any;
+            isCardType: boolean;
+            isPureCardType: boolean;
+        };
+    }>;
+    static propTypes: {
+        checked: PropTypes.Requireable<boolean>;
+        defaultChecked: PropTypes.Requireable<boolean>;
+        disabled: PropTypes.Requireable<boolean>;
+        indeterminate: PropTypes.Requireable<boolean>;
+        onChange: PropTypes.Requireable<(...args: any[]) => any>;
+        value: PropTypes.Requireable<any>;
+        style: PropTypes.Requireable<object>;
+        className: PropTypes.Requireable<string>;
+        prefixCls: PropTypes.Requireable<string>;
+        onMouseEnter: PropTypes.Requireable<(...args: any[]) => any>;
+        onMouseLeave: PropTypes.Requireable<(...args: any[]) => any>;
+        extra: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+    };
+    static defaultProps: {
+        defaultChecked: boolean;
+        indeterminate: boolean;
+        onChange: (...args: any[]) => void;
+        onMouseEnter: (...args: any[]) => void;
+        onMouseLeave: (...args: any[]) => void;
+    };
+    checkboxEntity: CheckboxInner;
+    get adapter(): CheckboxAdapter<CheckboxProps, CheckboxState>;
+    constructor(props: CheckboxProps);
+    componentDidUpdate(prevProps: CheckboxProps): void;
+    isInGroup(): any;
+    focus(): void;
+    blur(): void;
+    handleChange: React.MouseEventHandler<HTMLSpanElement>;
+    render(): JSX.Element;
+}
+export default Checkbox;

package/lib/cjs/checkbox/checkbox.js

@@ -0,0 +1,209 @@
+"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 _includes = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/includes"));
+
+var _noop2 = _interopRequireDefault(require("lodash/noop"));
+
+var _isBoolean2 = _interopRequireDefault(require("lodash/isBoolean"));
+
+var _isUndefined2 = _interopRequireDefault(require("lodash/isUndefined"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _constants = require("@douyinfe/semi-foundation/lib/cjs/checkbox/constants");
+
+var _checkboxFoundation = _interopRequireDefault(require("@douyinfe/semi-foundation/lib/cjs/checkbox/checkboxFoundation"));
+
+var _checkboxInner = _interopRequireDefault(require("./checkboxInner"));
+
+var _baseComponent = _interopRequireDefault(require("../_base/baseComponent"));
+
+require("@douyinfe/semi-foundation/lib/cjs/checkbox/checkbox.css");
+
+var _context2 = require("./context");
+
+/* eslint-disable max-len */
+class Checkbox extends _baseComponent.default {
+  constructor(props) {
+    super(props);
+
+    this.handleChange = e => this.foundation.handleChange(e);
+
+    const checked = false;
+    this.state = {
+      checked: props.checked || props.defaultChecked || checked
+    };
+    this.checkboxEntity = null;
+    this.foundation = new _checkboxFoundation.default(this.adapter);
+  }
+
+  get adapter() {
+    return (0, _assign.default)((0, _assign.default)({}, super.adapter), {
+      setNativeControlChecked: checked => {
+        this.setState({
+          checked
+        });
+      },
+      notifyChange: cbContent => {
+        const {
+          onChange
+        } = this.props;
+        onChange && onChange(cbContent);
+      },
+      getIsInGroup: () => this.isInGroup(),
+      getGroupValue: () => this.context && this.context.checkboxGroup.value || [],
+      notifyGroupChange: cbContent => {
+        this.context.checkboxGroup.onChange(cbContent);
+      },
+      getGroupDisabled: () => this.context && this.context.checkboxGroup.disabled
+    });
+  }
+
+  componentDidUpdate(prevProps) {
+    if (this.props.checked !== prevProps.checked) {
+      if ((0, _isUndefined2.default)(this.props.checked)) {
+        this.foundation.setChecked(false);
+      } else if ((0, _isBoolean2.default)(this.props.checked)) {
+        this.foundation.setChecked(this.props.checked);
+      }
+    }
+  }
+
+  isInGroup() {
+    return this.context && this.context.checkboxGroup;
+  }
+
+  focus() {
+    this.checkboxEntity && this.checkboxEntity.focus();
+  }
+
+  blur() {
+    this.checkboxEntity && this.checkboxEntity.blur();
+  }
+
+  render() {
+    const {
+      disabled,
+      style,
+      prefixCls,
+      className,
+      indeterminate,
+      children,
+      onMouseEnter,
+      onMouseLeave,
+      extra,
+      value
+    } = this.props;
+    const {
+      checked
+    } = this.state;
+    const props = {
+      checked,
+      disabled
+    };
+
+    if (this.isInGroup()) {
+      if (this.context.checkboxGroup.value) {
+        var _context;
+
+        const realChecked = (0, _includes.default)(_context = this.context.checkboxGroup.value || []).call(_context, value);
+        props.checked = realChecked;
+      }
+
+      if (this.context.checkboxGroup.disabled) {
+        props.disabled = this.context.checkboxGroup.disabled || this.props.disabled;
+      }
+
+      const {
+        isCardType,
+        isPureCardType
+      } = this.context.checkboxGroup;
+      props.isCardType = isCardType;
+      props.isPureCardType = isPureCardType;
+    }
+
+    const prefix = prefixCls || _constants.checkboxClasses.PREFIX;
+    const wrapper = (0, _classnames.default)(prefix, {
+      ["".concat(prefix, "-disabled")]: props.disabled,
+      ["".concat(prefix, "-indeterminate")]: indeterminate,
+      ["".concat(prefix, "-checked")]: props.checked,
+      ["".concat(prefix, "-unChecked")]: !props.checked,
+      ["".concat(prefix, "-cardType")]: props.isCardType,
+      ["".concat(prefix, "-cardType_disabled")]: props.disabled && props.isCardType,
+      ["".concat(prefix, "-cardType_unDisabled")]: !(props.disabled && props.isCardType),
+      ["".concat(prefix, "-cardType_checked")]: props.isCardType && props.checked && !props.disabled,
+      [className]: Boolean(className)
+    });
+    const extraCls = (0, _classnames.default)("".concat(prefix, "-extra"), {
+      ["".concat(prefix, "-cardType_extra_noChildren")]: props.isCardType && !children
+    });
+    const name = this.isInGroup() && this.context.checkboxGroup.name;
+
+    const renderContent = () => /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, children ? /*#__PURE__*/_react.default.createElement("span", {
+      className: "".concat(prefix, "-addon")
+    }, children) : null, extra ? /*#__PURE__*/_react.default.createElement("div", {
+      className: extraCls
+    }, extra) : null);
+
+    return /*#__PURE__*/_react.default.createElement("span", {
+      style: style,
+      className: wrapper,
+      onMouseEnter: onMouseEnter,
+      onMouseLeave: onMouseLeave,
+      onClick: this.handleChange
+    }, /*#__PURE__*/_react.default.createElement(_checkboxInner.default, (0, _assign.default)({}, this.props, props, {
+      name: name,
+      isPureCardType: props.isPureCardType,
+      ref: ref => {
+        this.checkboxEntity = ref;
+      }
+    })), props.isCardType ? /*#__PURE__*/_react.default.createElement("div", null, renderContent()) : renderContent());
+  }
+
+}
+
+Checkbox.contextType = _context2.Context;
+Checkbox.propTypes = {
+  // Specifies whether it is currently selected
+  checked: _propTypes.default.bool,
+  // Initial check
+  defaultChecked: _propTypes.default.bool,
+  // Failure state
+  disabled: _propTypes.default.bool,
+  // Set indeterminate state, only responsible for style control
+  indeterminate: _propTypes.default.bool,
+  // Callback function when changing
+  onChange: _propTypes.default.func,
+  value: _propTypes.default.any,
+  style: _propTypes.default.object,
+  className: _propTypes.default.string,
+  prefixCls: _propTypes.default.string,
+  onMouseEnter: _propTypes.default.func,
+  onMouseLeave: _propTypes.default.func,
+  extra: _propTypes.default.node
+};
+Checkbox.defaultProps = {
+  defaultChecked: false,
+  indeterminate: false,
+  onChange: _noop2.default,
+  onMouseEnter: _noop2.default,
+  onMouseLeave: _noop2.default
+};
+var _default = Checkbox;
+exports.default = _default;