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

package/lib/cjs/progress/index.js

@@ -0,0 +1,303 @@
+"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 _parseInt2 = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/parse-int"));
+
+var _concat = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/concat"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _constants = require("@douyinfe/semi-foundation/lib/cjs/progress/constants");
+
+require("@douyinfe/semi-foundation/lib/cjs/progress/progress.css");
+
+var _semiAnimation = require("@douyinfe/semi-animation");
+
+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;
+
+class Progress extends _react.Component {
+  constructor(props) {
+    super(props);
+    this._mounted = true;
+    this._mounted = true;
+    this.state = {
+      percentNumber: this.props.percent // Specially used for animation of numbers
+
+    };
+  }
+
+  componentDidUpdate(prevProps) {
+    if (isNaN(this.props.percent) || isNaN(prevProps.percent)) {
+      throw new Error('[Semi Progress]:percent can not be NaN');
+      return;
+    }
+
+    if (prevProps.percent !== this.props.percent) {
+      if (!this.props.motion) {
+        // eslint-disable-next-line
+        this.setState({
+          percentNumber: this.props.percent
+        });
+        return;
+      }
+
+      if (this.animation && this.animation.destroy) {
+        this.animation.destroy();
+      }
+
+      this.animation = new _semiAnimation.Animation({
+        from: {
+          value: prevProps.percent
+        },
+        to: {
+          value: this.props.percent
+        }
+      }, {
+        // easing: 'cubic-bezier(0, .68, .3, 1)'
+        easing: 'linear',
+        duration: 300
+      });
+      this.animation.on('frame', props => {
+        // prevent setState while component is unmounted but this timer is called
+        if (this._mounted === false) {
+          return;
+        } // let percentNumber = Number.isInteger(props.value) ? props.value : Math.floor(props.value * 100) / 100;
+
+
+        const percentNumber = (0, _parseInt2.default)(props.value);
+        this.setState({
+          percentNumber
+        });
+      });
+      this.animation.on('rest', () => {
+        // prevent setState while component is unmounted but this timer is called
+        if (this._mounted === false) {
+          return;
+        }
+
+        this.setState({
+          percentNumber: this.props.percent
+        });
+      });
+      this.animation.start();
+    }
+  }
+
+  componentWillUnmount() {
+    this.animation && this.animation.destroy();
+    this._mounted = false;
+  }
+
+  renderCircleProgress() {
+    var _context;
+
+    const {
+      strokeLinecap,
+      style,
+      className,
+      strokeWidth,
+      format,
+      size,
+      stroke,
+      showInfo,
+      percent,
+      orbitStroke
+    } = this.props;
+    const {
+      percentNumber
+    } = this.state;
+    const classNames = {
+      wrapper: (0, _classnames.default)("".concat(prefixCls, "-circle"), className),
+      svg: (0, _classnames.default)("".concat(prefixCls, "-circle-ring")),
+      circle: (0, _classnames.default)("".concat(prefixCls, "-circle-ring-inner"))
+    };
+    const perc = this.calcPercent(percent);
+    const percNumber = this.calcPercent(percentNumber);
+    let width;
+
+    if (this.props.width) {
+      width = this.props.width;
+    } else {
+      size === _constants.strings.DEFAULT_SIZE ? width = 72 : width = 24;
+    } // cx, cy is circle center
+
+
+    const cy = width / 2;
+    const cx = width / 2;
+    const radius = (width - strokeWidth) / 2; // radius
+
+    const circumference = radius * 2 * Math.PI;
+    const strokeDashoffset = (1 - perc / 100) * circumference; // Offset
+
+    const strokeDasharray = (0, _concat.default)(_context = "".concat(circumference, " ")).call(_context, circumference);
+    const text = format(percNumber);
+    return /*#__PURE__*/_react.default.createElement("div", {
+      className: classNames.wrapper,
+      style: style
+    }, /*#__PURE__*/_react.default.createElement("svg", {
+      key: size,
+      className: classNames.svg,
+      height: width,
+      width: width
+    }, /*#__PURE__*/_react.default.createElement("circle", {
+      strokeDashoffset: 0,
+      strokeWidth: strokeWidth,
+      strokeDasharray: strokeDasharray,
+      strokeLinecap: strokeLinecap,
+      fill: "transparent",
+      stroke: orbitStroke,
+      r: radius,
+      cx: cx,
+      cy: cy
+    }), /*#__PURE__*/_react.default.createElement("circle", {
+      className: classNames.circle,
+      strokeDashoffset: strokeDashoffset,
+      strokeWidth: strokeWidth,
+      strokeDasharray: strokeDasharray,
+      strokeLinecap: strokeLinecap,
+      fill: "transparent",
+      stroke: stroke,
+      r: radius,
+      cx: cx,
+      cy: cy
+    })), showInfo && size !== 'small' ? /*#__PURE__*/_react.default.createElement("span", {
+      className: "".concat(prefixCls, "-circle-text")
+    }, text) : null);
+  }
+
+  calcPercent(percent) {
+    let perc;
+
+    if (percent > 100) {
+      perc = 100;
+    } else if (percent < 0) {
+      perc = 0;
+    } else {
+      perc = percent;
+    }
+
+    return perc;
+  }
+
+  renderLineProgress() {
+    const {
+      className,
+      style,
+      stroke,
+      direction,
+      format,
+      showInfo,
+      size,
+      percent,
+      orbitStroke
+    } = this.props;
+    const {
+      percentNumber
+    } = this.state;
+    const progressWrapperCls = (0, _classnames.default)(prefixCls, className, {
+      ["".concat(prefixCls, "-horizontal")]: direction === _constants.strings.DEFAULT_DIRECTION,
+      ["".concat(prefixCls, "-vertical")]: direction !== _constants.strings.DEFAULT_DIRECTION,
+      ["".concat(prefixCls, "-large")]: size === 'large'
+    });
+    const progressTrackCls = (0, _classnames.default)({
+      ["".concat(prefixCls, "-track")]: true
+    });
+    const innerCls = (0, _classnames.default)("".concat(prefixCls, "-track-inner"));
+    const perc = this.calcPercent(percent);
+    const percNumber = this.calcPercent(percentNumber);
+    const innerStyle = {
+      backgroundColor: stroke
+    };
+
+    if (direction === _constants.strings.DEFAULT_DIRECTION) {
+      innerStyle.width = "".concat(perc, "%");
+    } else {
+      innerStyle.height = "".concat(perc, "%");
+    }
+
+    const text = format(percNumber);
+    return /*#__PURE__*/_react.default.createElement("div", {
+      className: progressWrapperCls,
+      style: style
+    }, /*#__PURE__*/_react.default.createElement("div", {
+      className: progressTrackCls,
+      style: orbitStroke ? {
+        backgroundColor: orbitStroke
+      } : {}
+    }, /*#__PURE__*/_react.default.createElement("div", {
+      className: innerCls,
+      style: innerStyle
+    })), showInfo ? /*#__PURE__*/_react.default.createElement("div", {
+      className: "".concat(prefixCls, "-line-text")
+    }, text) : null);
+  }
+
+  render() {
+    const {
+      type
+    } = this.props;
+
+    if (type === 'line') {
+      return this.renderLineProgress();
+    } else {
+      return this.renderCircleProgress();
+    }
+  }
+
+}
+
+Progress.propTypes = {
+  className: _propTypes.default.string,
+  direction: _propTypes.default.oneOf(_constants.strings.directions),
+  format: _propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.node]),
+  motion: _propTypes.default.oneOfType([_propTypes.default.bool, _propTypes.default.func, _propTypes.default.object]),
+  orbitStroke: _propTypes.default.string,
+  percent: _propTypes.default.number,
+  scale: _propTypes.default.number,
+  showInfo: _propTypes.default.bool,
+  size: _propTypes.default.oneOf(_constants.strings.sizes),
+  stroke: _propTypes.default.string,
+  strokeLinecap: _propTypes.default.oneOf(_constants.strings.strokeLineCap),
+  strokeWidth: _propTypes.default.number,
+  style: _propTypes.default.object,
+  type: _propTypes.default.oneOf(_constants.strings.types),
+  width: _propTypes.default.number
+};
+Progress.defaultProps = {
+  className: '',
+  direction: _constants.strings.DEFAULT_DIRECTION,
+  format: text => "".concat(text, "%"),
+  motion: true,
+  orbitStroke: 'var(--semi-color-fill-0)',
+  percent: 0,
+  showInfo: false,
+  size: _constants.strings.DEFAULT_SIZE,
+  stroke: 'var(--semi-color-success)',
+  strokeLinecap: _constants.strings.DEFAULT_LINECAP,
+  strokeWidth: 4,
+  style: {},
+  type: _constants.strings.DEFAULT_TYPE
+};
+var _default = Progress;
+exports.default = _default;

package/lib/cjs/radio/context.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+import { RadioChangeEvent } from '@douyinfe/semi-foundation/lib/cjs/radio/radioInnerFoundation';
+import { strings } from '@douyinfe/semi-foundation/lib/cjs/radio/constants';
+import { ArrayElement } from '../_base/base';
+export declare type RadioGroupButtonSize = ArrayElement<typeof strings.BUTTON_SIZE>;
+export declare type RadioMode = ArrayElement<typeof strings.MODE>;
+export interface RadioContextValue {
+    mode?: RadioMode;
+    radioGroup?: {
+        value?: any;
+        isButtonRadio?: any;
+        disabled?: boolean;
+        prefixCls?: string;
+        name?: string;
+        onChange?: (e: RadioChangeEvent) => void;
+        buttonSize?: RadioGroupButtonSize;
+        isCardRadio?: boolean;
+        isPureCardRadio?: boolean;
+    };
+}
+declare const Context: React.Context<RadioContextValue>;
+export default Context;

package/lib/cjs/radio/context.js

@@ -0,0 +1,18 @@
+"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 _react = _interopRequireDefault(require("react"));
+
+const Context = /*#__PURE__*/_react.default.createContext(null);
+
+var _default = Context;
+exports.default = _default;

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

@@ -0,0 +1,10 @@
+import Group from './radioGroup';
+import Radio from './radio';
+declare class RadioWithGroup extends Radio {
+    static Group: typeof Group;
+}
+export default RadioWithGroup;
+export { RadioWithGroup, Radio };
+export { RadioInnerMode, RadioInnerProps } from './radioInner';
+export { RadioGroupProps, OptionItem } from './radioGroup';
+export { RadioDisplayMode, RadioType, RadioProps, RadioChangeEvent } from './radio';

package/lib/cjs/radio/index.js

@@ -0,0 +1,29 @@
+"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
+});
+
+_Object$defineProperty(exports, "Radio", {
+  enumerable: true,
+  get: function () {
+    return _radio.default;
+  }
+});
+
+exports.default = exports.RadioWithGroup = void 0;
+
+var _radioGroup = _interopRequireDefault(require("./radioGroup"));
+
+var _radio = _interopRequireDefault(require("./radio"));
+
+class RadioWithGroup extends _radio.default {}
+
+exports.RadioWithGroup = RadioWithGroup;
+RadioWithGroup.Group = _radioGroup.default;
+var _default = RadioWithGroup;
+exports.default = _default;

package/lib/cjs/radio/radio.d.ts

@@ -0,0 +1,79 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { RadioAdapter } from '@douyinfe/semi-foundation/lib/cjs/radio/radioFoundation';
+import { RadioChangeEvent } from '@douyinfe/semi-foundation/lib/cjs/radio/radioInnerFoundation';
+import { strings } from '@douyinfe/semi-foundation/lib/cjs/radio/constants';
+import '@douyinfe/semi-foundation/lib/cjs/radio/radio.css';
+import BaseComponent from '../_base/baseComponent';
+import RadioInner from './radioInner';
+import { RadioContextValue, RadioMode } from './context';
+export declare type RadioDisplayMode = 'vertical' | '';
+export declare type RadioType = typeof strings.TYPE_DEFAULT | typeof strings.TYPE_BUTTON | typeof strings.TYPE_CARD | typeof strings.TYPE_PURECARD;
+export declare type RadioProps = {
+    autoFocus?: boolean;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    value?: any;
+    disabled?: boolean;
+    prefixCls?: string;
+    displayMode?: RadioDisplayMode;
+    onChange?: (e: RadioChangeEvent) => void;
+    onMouseEnter?: (e: React.MouseEvent<HTMLLabelElement>) => void;
+    onMouseLeave?: (e: React.MouseEvent<HTMLLabelElement>) => void;
+    mode?: RadioMode;
+    extra?: React.ReactNode;
+    style?: React.CSSProperties;
+    className?: string;
+    addonStyle?: React.CSSProperties;
+    addonClassName?: string;
+    type?: RadioType;
+};
+export interface RadioState {
+    hover?: boolean;
+}
+export { RadioChangeEvent };
+declare class Radio extends BaseComponent<RadioProps, RadioState> {
+    static contextType: React.Context<RadioContextValue>;
+    static propTypes: {
+        autoFocus: PropTypes.Requireable<boolean>;
+        checked: PropTypes.Requireable<boolean>;
+        defaultChecked: PropTypes.Requireable<boolean>;
+        value: PropTypes.Requireable<any>;
+        style: PropTypes.Requireable<object>;
+        className: PropTypes.Requireable<string>;
+        disabled: PropTypes.Requireable<boolean>;
+        prefixCls: PropTypes.Requireable<string>;
+        displayMode: PropTypes.Requireable<RadioDisplayMode>;
+        onChange: PropTypes.Requireable<(...args: any[]) => any>;
+        onMouseEnter: PropTypes.Requireable<(...args: any[]) => any>;
+        onMouseLeave: PropTypes.Requireable<(...args: any[]) => any>;
+        mode: PropTypes.Requireable<"" | "advanced">;
+        extra: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        addonStyle: PropTypes.Requireable<object>;
+        addonClassName: PropTypes.Requireable<string>;
+        type: PropTypes.Requireable<"default" | "button" | "card" | "pureCard">;
+    };
+    static defaultProps: Partial<RadioProps>;
+    radioEntity: RadioInner;
+    context: RadioContextValue;
+    constructor(props: RadioProps);
+    get adapter(): RadioAdapter;
+    isInGroup(): {
+        value?: any;
+        isButtonRadio?: any;
+        disabled?: boolean;
+        prefixCls?: string;
+        name?: string;
+        onChange?: (e: RadioChangeEvent) => void;
+        buttonSize?: "small" | "middle" | "large";
+        isCardRadio?: boolean;
+        isPureCardRadio?: boolean;
+    };
+    focus(): void;
+    blur(): void;
+    onChange: (e: RadioChangeEvent) => void;
+    handleMouseEnter: (e: React.MouseEvent<HTMLLabelElement>) => void;
+    handleMouseLeave: (e: React.MouseEvent<HTMLLabelElement>) => void;
+    render(): JSX.Element;
+}
+export default Radio;

package/lib/cjs/radio/radio.js

@@ -0,0 +1,225 @@
+"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 _concat = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/concat"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _lodashEs = require("lodash-es");
+
+var _radioFoundation = _interopRequireDefault(require("@douyinfe/semi-foundation/lib/cjs/radio/radioFoundation"));
+
+var _constants = require("@douyinfe/semi-foundation/lib/cjs/radio/constants");
+
+require("@douyinfe/semi-foundation/lib/cjs/radio/radio.css");
+
+var _baseComponent = _interopRequireDefault(require("../_base/baseComponent"));
+
+var _radioInner = _interopRequireDefault(require("./radioInner"));
+
+var _context4 = _interopRequireDefault(require("./context"));
+
+/* eslint-disable prefer-destructuring */
+class Radio extends _baseComponent.default {
+  constructor(props) {
+    super(props);
+
+    this.onChange = e => {
+      const {
+        onChange
+      } = this.props;
+
+      if (this.isInGroup()) {
+        const {
+          radioGroup
+        } = this.context;
+        radioGroup.onChange && radioGroup.onChange(e);
+      }
+
+      onChange && onChange(e);
+    };
+
+    this.handleMouseEnter = e => {
+      this.props.onMouseEnter(e);
+      this.foundation.setHover(true);
+    };
+
+    this.handleMouseLeave = e => {
+      this.props.onMouseLeave(e);
+      this.foundation.setHover(false);
+    };
+
+    this.state = {
+      hover: false
+    };
+    this.foundation = new _radioFoundation.default(this.adapter);
+    this.radioEntity = null;
+  }
+
+  get adapter() {
+    return (0, _assign.default)((0, _assign.default)({}, super.adapter), {
+      setHover: hover => {
+        this.setState({
+          hover
+        });
+      }
+    });
+  }
+
+  isInGroup() {
+    // eslint-disable-next-line react/destructuring-assignment
+    return this.context && this.context.radioGroup;
+  }
+
+  focus() {
+    this.radioEntity.focus();
+  }
+
+  blur() {
+    this.radioEntity.blur();
+  }
+
+  render() {
+    var _context, _context2, _context3;
+
+    const {
+      addonClassName,
+      addonStyle,
+      checked,
+      disabled,
+      style,
+      className,
+      prefixCls,
+      displayMode,
+      children,
+      extra,
+      mode,
+      type,
+      value: propValue
+    } = this.props;
+    let realChecked, isDisabled, realMode, isButtonRadioGroup, isCardRadioGroup, isPureCardRadioGroup, isButtonRadioComponent, buttonSize, realPrefixCls;
+    const isHover = this.state.hover;
+    let props = {};
+
+    if (this.isInGroup()) {
+      realChecked = this.context.radioGroup.value === propValue;
+      isDisabled = disabled || this.context.radioGroup.disabled;
+      realMode = this.context.mode;
+      isButtonRadioGroup = this.context.radioGroup.isButtonRadio;
+      isCardRadioGroup = this.context.radioGroup.isCardRadio;
+      isPureCardRadioGroup = this.context.radioGroup.isPureCardRadio;
+      buttonSize = this.context.radioGroup.buttonSize;
+      realPrefixCls = prefixCls || this.context.radioGroup.prefixCls;
+      props = {
+        checked: realChecked,
+        disabled: isDisabled
+      };
+    } else {
+      realChecked = checked;
+      isDisabled = disabled;
+      realMode = mode;
+      isButtonRadioComponent = type === 'button';
+      realPrefixCls = prefixCls;
+    }
+
+    const isButtonRadio = typeof isButtonRadioGroup === 'undefined' ? isButtonRadioComponent : isButtonRadioGroup;
+    const prefix = realPrefixCls || _constants.radioClasses.PREFIX;
+    const wrapper = (0, _classnames.default)(prefix, {
+      ["".concat(prefix, "-disabled")]: isDisabled,
+      ["".concat(prefix, "-checked")]: realChecked,
+      [(0, _concat.default)(_context = "".concat(prefix, "-")).call(_context, displayMode)]: Boolean(displayMode),
+      ["".concat(prefix, "-buttonRadioComponent")]: isButtonRadioComponent,
+      ["".concat(prefix, "-buttonRadioGroup")]: isButtonRadioGroup,
+      [(0, _concat.default)(_context2 = "".concat(prefix, "-buttonRadioGroup-")).call(_context2, buttonSize)]: isButtonRadioGroup && buttonSize,
+      ["".concat(prefix, "-cardRadioGroup")]: isCardRadioGroup,
+      ["".concat(prefix, "-cardRadioGroup_disabled")]: isDisabled && isCardRadioGroup,
+      ["".concat(prefix, "-cardRadioGroup_checked")]: isCardRadioGroup && realChecked && !isDisabled,
+      ["".concat(prefix, "-cardRadioGroup_hover")]: isCardRadioGroup && !realChecked && isHover && !isDisabled,
+      [className]: Boolean(className)
+    });
+    const name = this.isInGroup() && this.context.radioGroup.name;
+    const addonCls = (0, _classnames.default)({
+      ["".concat(prefix, "-addon")]: !isButtonRadio,
+      ["".concat(prefix, "-addon-buttonRadio")]: isButtonRadio,
+      ["".concat(prefix, "-addon-buttonRadio-checked")]: isButtonRadio && realChecked,
+      ["".concat(prefix, "-addon-buttonRadio-disabled")]: isButtonRadio && isDisabled,
+      ["".concat(prefix, "-addon-buttonRadio-hover")]: isButtonRadio && !realChecked && !isDisabled && isHover,
+      [(0, _concat.default)(_context3 = "".concat(prefix, "-addon-buttonRadio-")).call(_context3, buttonSize)]: isButtonRadio && buttonSize
+    }, addonClassName);
+
+    const renderContent = () => /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, children ? /*#__PURE__*/_react.default.createElement("span", {
+      className: addonCls,
+      style: addonStyle
+    }, children) : null, extra && !isButtonRadio ? /*#__PURE__*/_react.default.createElement("div", {
+      className: "".concat(prefix, "-extra")
+    }, extra) : null);
+
+    return /*#__PURE__*/_react.default.createElement("label", {
+      style: style,
+      className: wrapper,
+      onMouseEnter: this.handleMouseEnter,
+      onMouseLeave: this.handleMouseLeave
+    }, /*#__PURE__*/_react.default.createElement(_radioInner.default, (0, _assign.default)({}, this.props, props, {
+      mode: realMode,
+      name: name,
+      isButtonRadio: isButtonRadio,
+      isPureCardRadioGroup: isPureCardRadioGroup,
+      onChange: this.onChange,
+      ref: ref => {
+        this.radioEntity = ref;
+      }
+    })), isCardRadioGroup ? /*#__PURE__*/_react.default.createElement("div", {
+      className: "".concat(prefix, "-isCardRadioGroup_content")
+    }, renderContent()) : renderContent());
+  }
+
+}
+
+Radio.contextType = _context4.default;
+Radio.propTypes = {
+  autoFocus: _propTypes.default.bool,
+  checked: _propTypes.default.bool,
+  defaultChecked: _propTypes.default.bool,
+  value: _propTypes.default.any,
+  style: _propTypes.default.object,
+  className: _propTypes.default.string,
+  disabled: _propTypes.default.bool,
+  prefixCls: _propTypes.default.string,
+  displayMode: _propTypes.default.oneOf(['vertical', '']),
+  onChange: _propTypes.default.func,
+  onMouseEnter: _propTypes.default.func,
+  onMouseLeave: _propTypes.default.func,
+  mode: _propTypes.default.oneOf(_constants.strings.MODE),
+  extra: _propTypes.default.node,
+  addonStyle: _propTypes.default.object,
+  addonClassName: _propTypes.default.string,
+  type: _propTypes.default.oneOf([_constants.strings.TYPE_DEFAULT, _constants.strings.TYPE_BUTTON, _constants.strings.TYPE_CARD, _constants.strings.TYPE_PURECARD]) // Button style type
+
+};
+Radio.defaultProps = {
+  autoFocus: false,
+  defaultChecked: false,
+  value: undefined,
+  style: undefined,
+  onMouseEnter: _lodashEs.noop,
+  onMouseLeave: _lodashEs.noop,
+  mode: '',
+  type: 'default'
+};
+var _default = Radio;
+exports.default = _default;