@autobest-ui/components 2.9.2 → 2.10.1-alpha.0

package/esm/input-phone/format.js

@@ -0,0 +1,81 @@
+import { isBlank } from '@autobest-ui/utils';
+/**
+ * 按照给定的模板（111-222-333）格式化数字形式电话号码（111222333）
+ * @param value
+ * @param format
+ * @param placeholder
+ */
+export function getPhoneFormat(value, format, placeholder) {
+  var defaultValueArr = getNumberValue(value).split('');
+  return format.replace(/\d/g, function () {
+    return defaultValueArr.shift() || placeholder;
+  });
+}
+/**
+ * 删除字符串中非数字内容
+ * @param value
+ */
+export function getNumberValue(value) {
+  if (isBlank(value)) {
+    return '';
+  }
+  return value.replace(/[^\d]/g, '');
+}
+export function getFirstCursorPosition(value, format, placeholder) {
+  if (isBlank(value)) {
+    return format.search(/\d/);
+  }
+  var match;
+  while ((match = new RegExp(placeholder, 'g').exec(value)) !== null) {
+    if (match[0] !== format[match.index]) {
+      return match.index;
+    }
+  }
+  return value.length;
+}
+function getDifferIndex(value, prevValue) {
+  for (var i = 0, l = Math.max(value.length, prevValue.length); i < l; i++) {
+    if (value[i] !== prevValue[i]) {
+      return i;
+    }
+  }
+  return prevValue.length;
+}
+function getSlice(str, start, end) {
+  if (!end) {
+    return str.slice(start);
+  }
+  return str.slice(start, end);
+}
+export function getUpdatedValue(_a) {
+  var value = _a.value,
+    prevValue = _a.prevValue,
+    format = _a.format,
+    selectionEnd = _a.selectionEnd,
+    placeholder = _a.placeholder;
+  if (isBlank(value)) {
+    return {
+      value: getPhoneFormat('', format, placeholder),
+      cursorPosition: getFirstCursorPosition('', format, placeholder)
+    };
+  }
+  var lastCursorIndex = (value.length - selectionEnd) * -1;
+  var differIndex = getDifferIndex(getSlice(value, 0, lastCursorIndex), getSlice(prevValue, 0, lastCursorIndex));
+  var differNumberArr = getNumberValue(getSlice(value, differIndex, lastCursorIndex)).split('');
+  var cursorPosition = differIndex;
+  var endIndex = format.length + lastCursorIndex;
+  var formatValue = format.replace(/\d/g, function (_match, index) {
+    if (index < differIndex) {
+      return prevValue[index];
+    }
+    if (!differNumberArr.length) {
+      return index >= endIndex ? prevValue[index] : placeholder;
+    }
+    cursorPosition = index + 1;
+    return differNumberArr.shift();
+  });
+  return {
+    value: formatValue,
+    cursorPosition: cursorPosition
+  };
+}

package/esm/input-phone/index.d.ts

@@ -0,0 +1,65 @@
+import React from 'react';
+import { InputProps } from '../input/Input';
+export interface InputPhoneProps extends Omit<InputProps<string>, 'onFocus' | 'onBlur' | 'onChange'> {
+    /**
+     * 输入框是否可以操作
+     */
+    disabled?: boolean;
+    /**
+     * 号码显示格式，以任意数字代替需要填入的数字位置
+     * 默认为(111)111-1111，表示会显示(xxx)xxx-xxxx格式的号码
+     */
+    format?: string;
+    /**
+     * 数字未填时的留空字符，默认为_
+     */
+    placeholderChar?: string;
+    /**
+     * 获得焦点的回调函数
+     * formatValue: 显示在输入框中的格式化后的电话号码
+     * phoneValue: 纯数字电话号码
+     */
+    onFocus?: (formatValue: string, phoneValue: string, name?: string) => void;
+    /**
+     * 失去焦点的回调函数
+     * formatValue: 显示在输入框中的格式化后的电话号码
+     * phoneValue: 纯数字电话号码
+     */
+    onBlur?: (formatValue: string, phoneValue: string, name?: string) => void;
+    /**
+     * 值修改后的回调函数，用于修改value属性
+     * formatValue: 显示在输入框中的格式化后的电话号码
+     * phoneValue: 纯数字电话号码
+     */
+    onChange?: (formatValue: string, phoneValue: string, name?: string) => void;
+}
+interface InputPhoneState {
+    formatValue: string;
+}
+interface InputPhonePropsWithRef extends InputPhoneProps {
+    /**
+     * 此属性可以忽略， storybook问题
+     */
+    upperRef: React.Ref<HTMLInputElement>;
+}
+export declare class InputPhoneNotRef extends React.Component<InputPhonePropsWithRef, InputPhoneState> {
+    prefixCls: string;
+    inputRef: React.RefObject<HTMLInputElement>;
+    prevFormatValue: string;
+    static defaultProps: {
+        defaultValue: string;
+        format: string;
+        placeholderChar: string;
+    };
+    constructor(props: InputPhonePropsWithRef);
+    static getDerivedStateFromProps(nextProps: InputPhoneProps, prevState: InputPhoneState): {
+        formatValue: any;
+    };
+    setInputCursor: (cursorPosition: any, timeout?: number) => void;
+    onFocus: (inputValue: string, name?: string) => void;
+    onBlur: (inputValue: string, name?: string) => void;
+    onChange: (inputValue: string, name?: string) => void;
+    render(): JSX.Element;
+}
+declare const InputPhone: React.ForwardRefExoticComponent<InputPhoneProps & React.RefAttributes<HTMLInputElement>>;
+export default InputPhone;

package/esm/input-phone/index.js

@@ -0,0 +1,190 @@
+var __extends = this && this.__extends || function () {
+  var _extendStatics = function extendStatics(d, b) {
+    _extendStatics = Object.setPrototypeOf || {
+      __proto__: []
+    } instanceof Array && function (d, b) {
+      d.__proto__ = b;
+    } || function (d, b) {
+      for (var p in b) {
+        if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
+      }
+    };
+    return _extendStatics(d, b);
+  };
+  return function (d, b) {
+    if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    _extendStatics(d, b);
+    function __() {
+      this.constructor = d;
+    }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  };
+}();
+var __assign = this && this.__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s) {
+        if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+      }
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+  for (var p in s) {
+    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  }
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+import React from 'react';
+import classNames from 'classnames';
+import { composeRef } from '@autobest-ui/components';
+import { isBlank } from '@autobest-ui/utils';
+import Input from '../input/Input';
+import { getFirstCursorPosition, getNumberValue, getPhoneFormat, getUpdatedValue } from './format';
+var InputPhoneNotRef = /** @class */function (_super) {
+  __extends(InputPhoneNotRef, _super);
+  function InputPhoneNotRef(props) {
+    var _this = _super.call(this, props) || this;
+    _this.prefixCls = 'ab-input-phone';
+    _this.inputRef = /*#__PURE__*/React.createRef();
+    _this.setInputCursor = function (cursorPosition, timeout) {
+      if (!_this.inputRef.current) {
+        return;
+      }
+      if (timeout) {
+        setTimeout(function () {
+          _this.inputRef.current.setSelectionRange(cursorPosition, cursorPosition);
+        }, timeout);
+        return;
+      }
+      _this.inputRef.current.setSelectionRange(cursorPosition, cursorPosition);
+    };
+    _this.onFocus = function (inputValue, name) {
+      var _a = _this.props,
+        onFocus = _a.onFocus,
+        format = _a.format,
+        placeholderChar = _a.placeholderChar;
+      var formatValue = inputValue;
+      if (onFocus) {
+        onFocus(formatValue, getNumberValue(formatValue), name);
+      }
+      if (isBlank(inputValue)) {
+        formatValue = getPhoneFormat('', format, placeholderChar);
+        _this.setState({
+          formatValue: formatValue
+        }, function () {
+          _this.setInputCursor(getFirstCursorPosition('', format, placeholderChar), 50);
+        });
+        return;
+      }
+      _this.setInputCursor(getFirstCursorPosition(inputValue, format, placeholderChar), 50);
+    };
+    _this.onBlur = function (inputValue, name) {
+      if (_this.props.disabled) {
+        return;
+      }
+      var formatValue = _this.state.formatValue;
+      var _a = _this.props,
+        format = _a.format,
+        placeholderChar = _a.placeholderChar,
+        onBlur = _a.onBlur;
+      if (formatValue === getPhoneFormat('', format, placeholderChar)) {
+        _this.setState({
+          formatValue: ''
+        });
+        if (onBlur) {
+          onBlur('', '', name);
+        }
+        return;
+      }
+      if (onBlur) {
+        onBlur(inputValue, getNumberValue(inputValue), name);
+      }
+    };
+    _this.onChange = function (inputValue, name) {
+      if (_this.props.disabled || !_this.inputRef.current) {
+        return;
+      }
+      var _a = _this.props,
+        format = _a.format,
+        onChange = _a.onChange,
+        placeholderChar = _a.placeholderChar;
+      var _b = getUpdatedValue({
+          value: inputValue,
+          prevValue: _this.prevFormatValue,
+          format: format,
+          selectionEnd: _this.inputRef.current.selectionEnd,
+          placeholder: placeholderChar
+        }),
+        formatValue = _b.value,
+        cursorPosition = _b.cursorPosition;
+      _this.prevFormatValue = formatValue;
+      _this.setState({
+        formatValue: formatValue
+      }, function () {
+        _this.setInputCursor(cursorPosition);
+      });
+      if (onChange) {
+        onChange(formatValue, getNumberValue(formatValue), name);
+      }
+    };
+    var defaultValue = props.defaultValue,
+      format = props.format,
+      placeholderChar = props.placeholderChar;
+    _this.prevFormatValue = getPhoneFormat(defaultValue, format, placeholderChar);
+    _this.state = {
+      formatValue: isBlank(defaultValue) ? '' : _this.prevFormatValue
+    };
+    return _this;
+  }
+  InputPhoneNotRef.getDerivedStateFromProps = function (nextProps, prevState) {
+    if ('value' in nextProps) {
+      if (nextProps.value !== prevState.formatValue && (
+      // 兼容外部传入空string/null的情况， 只有当一个值非空时，才会重新重置State信息
+      !isBlank(nextProps.value) || !isBlank(prevState.formatValue))) {
+        return {
+          formatValue: getPhoneFormat(nextProps.value, nextProps.format, nextProps.placeholderChar)
+        };
+      }
+    }
+    return null;
+  };
+  InputPhoneNotRef.prototype.render = function () {
+    var cls = this.prefixCls;
+    var _a = this.props,
+      upperRef = _a.upperRef,
+      className = _a.className,
+      format = _a.format,
+      resetProps = __rest(_a, ["upperRef", "className", "format"]);
+    var formatValue = this.state.formatValue;
+    return /*#__PURE__*/React.createElement(Input, __assign({
+      ref: composeRef(this.inputRef, upperRef),
+      className: classNames(cls, className)
+    }, resetProps, {
+      value: formatValue,
+      onChange: this.onChange,
+      onBlur: this.onBlur,
+      onFocus: this.onFocus
+    }));
+  };
+  InputPhoneNotRef.defaultProps = {
+    defaultValue: '',
+    format: '(111)111-1111',
+    placeholderChar: '_'
+  };
+  return InputPhoneNotRef;
+}(React.Component);
+export { InputPhoneNotRef };
+var InputPhone = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  return /*#__PURE__*/React.createElement(InputPhoneNotRef, __assign({}, props, {
+    upperRef: ref
+  }));
+});
+export default InputPhone;

package/esm/input-phone/style/index.css

@@ -0,0 +1 @@
+.ab-input{display:flex;align-items:center;border:1px solid #ccc;overflow:hidden;position:relative;border-radius:.04rem;padding:.04rem}.ab-input-prefix,.ab-input-suffix{padding-left:.04rem;padding-right:.04rem}.ab-input.ab-input-enter,.ab-input.ab-input-focus{border-color:#348fee}.ab-input.ab-input-focus{box-shadow:0 0 4px #348fee}.ab-input.ab-input-disabled .ab-input-control{cursor:not-allowed}.ab-input-control{appearance:none;display:block;outline:0;border:none;width:100%;height:100%;padding:.02rem;background-color:transparent;font-size:inherit}

package/esm/modal/index.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { AddListenerEventHandler } from '@autobest-ui/utils';
+import { AddListenerEventRemoveHandler } from '@autobest-ui/utils';
 declare type PrevPopupSize = {
     width: number;
     height: number;
@@ -92,8 +92,8 @@ declare class Modal extends React.Component<ModalProps, ModalStates> {
         maskClosable: boolean;
         hiddenScroll: boolean;
     };
-    clickOutsideHandler: AddListenerEventHandler | null;
-    touchOutsideHandler: AddListenerEventHandler | null;
+    clickOutsideHandler: AddListenerEventRemoveHandler;
+    touchOutsideHandler: AddListenerEventRemoveHandler;
     popupTimer: any;
     affixTimer: any;
     popupRef: React.RefObject<HTMLDivElement>;

package/esm/modal/index.js

@@ -258,11 +258,11 @@ var Modal = /** @class */function (_super) {
   Modal.prototype.clearOutsideHandler = function () {
     this.clearPopupTimer();
     if (this.clickOutsideHandler) {
-      this.clickOutsideHandler.remove();
+      this.clickOutsideHandler();
       this.clickOutsideHandler = null;
     }
     if (this.touchOutsideHandler) {
-      this.touchOutsideHandler.remove();
+      this.touchOutsideHandler();
       this.touchOutsideHandler = null;
     }
   };

package/esm/move/index.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { AddListenerEventHandler } from '@autobest-ui/utils';
+import { AddListenerEventRemoveHandler } from '@autobest-ui/utils';
 import { Position } from './utils';
 export interface MoveProps {
     /**
@@ -82,11 +82,11 @@ declare class Move extends React.Component<MoveProps> {
     isTouchScale: boolean;
     isForceUpdatePlacement: boolean;
     moveRef: React.RefObject<HTMLElement>;
-    resizeHandler: AddListenerEventHandler | null;
-    startHandler: AddListenerEventHandler | null;
-    mousewheelHandler: AddListenerEventHandler | null;
-    moveHandler: AddListenerEventHandler | null;
-    endHandler: AddListenerEventHandler | null;
+    resizeHandler: AddListenerEventRemoveHandler;
+    startHandler: AddListenerEventRemoveHandler;
+    mousewheelHandler: AddListenerEventRemoveHandler;
+    moveHandler: AddListenerEventRemoveHandler;
+    endHandler: AddListenerEventRemoveHandler;
     updateTimer: any;
     componentDidMount(): void;
     componentDidUpdate(prevProps?: MoveProps): void;

package/esm/move/index.js

@@ -310,26 +310,26 @@ var Move = /** @class */function (_super) {
   Move.prototype.componentWillUnmount = function () {
     clearTimeout(this.updateTimer);
     if (this.startHandler) {
-      this.startHandler.remove();
+      this.startHandler();
       this.startHandler = null;
     }
     if (this.mousewheelHandler) {
-      this.mousewheelHandler.remove();
+      this.mousewheelHandler();
       this.mousewheelHandler = null;
     }
     if (this.resizeHandler) {
-      this.resizeHandler.remove();
+      this.resizeHandler();
       this.resizeHandler = null;
     }
     this.clearHandler();
   };
   Move.prototype.clearHandler = function () {
     if (this.moveHandler) {
-      this.moveHandler.remove();
+      this.moveHandler();
       this.moveHandler = null;
     }
     if (this.endHandler) {
-      this.endHandler.remove();
+      this.endHandler();
       this.endHandler = null;
     }
   };

package/esm/popover/index.d.ts

@@ -32,7 +32,7 @@ export interface PopoverProps extends Pick<TriggerProps, Exclude<keyof TriggerPr
 }
 export declare type PopoverPlacement = TriggerPlacement;
 export declare type PopoverTriggerType = TriggerType;
-declare function Popover({ theme, innerClassName, closeClassName, arrowClassName, hiddenClose, tip, closeIcon, ...extraProps }: PopoverProps): JSX.Element;
+declare function Popover({ theme, innerClassName, closeClassName, arrowClassName, hiddenClose, tip, closeIcon, maxHeight, ...extraProps }: PopoverProps): JSX.Element;
 declare namespace Popover {
     var defaultProps: {
         hiddenClose: boolean;

package/esm/popover/index.js

@@ -22,6 +22,7 @@ var __rest = this && this.__rest || function (s, e) {
 };
 import React from 'react';
 import classNames from 'classnames';
+import { isBlank } from '@autobest-ui/utils';
 import Trigger from '../trigger';
 var prefixCls = 'ab-popover';
 function Popover(_a) {
@@ -33,7 +34,8 @@ function Popover(_a) {
     hiddenClose = _a.hiddenClose,
     tip = _a.tip,
     closeIcon = _a.closeIcon,
-    extraProps = __rest(_a, ["theme", "innerClassName", "closeClassName", "arrowClassName", "hiddenClose", "tip", "closeIcon"]);
+    maxHeight = _a.maxHeight,
+    extraProps = __rest(_a, ["theme", "innerClassName", "closeClassName", "arrowClassName", "hiddenClose", "tip", "closeIcon", "maxHeight"]);
   var triggerEl = React.useRef(null);
   var _c = React.useState({}),
     arrowStyle = _c[0],
@@ -71,7 +73,10 @@ function Popover(_a) {
       className: classNames("".concat(cls, "-arrow"), arrowClassName),
       style: arrowStyle
     }), /*#__PURE__*/React.createElement("div", {
-      className: innerClass
+      className: innerClass,
+      style: !isBlank(maxHeight) ? {
+        maxHeight: "".concat(maxHeight, "px")
+      } : undefined
     }, tip));
   }
   return /*#__PURE__*/React.createElement(Trigger, __assign({}, extraProps, {

package/esm/radio/Radio.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+import { RadioProps } from './interface';
+declare const Radio: FC<RadioProps>;
+export default Radio;

package/esm/radio/Radio.js

@@ -0,0 +1,80 @@
+var __assign = this && this.__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s) {
+        if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+      }
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+import classNames from 'classnames';
+import React, { useContext, useEffect, useState } from 'react';
+import { isEmptyObject } from '@autobest-ui/utils';
+import RadioGroupContext from './context';
+var cls = 'ab-radio';
+var Radio = function Radio(props) {
+  var _a;
+  var _b = props.checked,
+    propsChecked = _b === void 0 ? false : _b,
+    name = props.name,
+    onChange = props.onChange,
+    children = props.children,
+    disabled = props.disabled,
+    value = props.value,
+    className = props.className;
+  var _c = useState(propsChecked),
+    checked = _c[0],
+    setChecked = _c[1];
+  var groupContext = useContext(RadioGroupContext);
+  var mergedProps = isEmptyObject(groupContext) ? {
+    name: name,
+    disabled: disabled
+  } : {
+    name: groupContext.name,
+    disabled: 'disabled' in props ? disabled : groupContext.disabled
+  };
+  if ('checked' in props && propsChecked !== checked) {
+    setChecked(propsChecked);
+  }
+  useEffect(function () {
+    // radioGroup
+    if ('value' in groupContext) {
+      setChecked(groupContext.value === value);
+    }
+  }, [groupContext, value]);
+  var onRadioChange = function onRadioChange(e) {
+    if (mergedProps.disabled) {
+      return;
+    }
+    if (onChange) {
+      onChange(e, mergedProps.name);
+      return;
+    }
+    // radioGroup
+    if (groupContext.onChange) {
+      groupContext.onChange(e.target.value, mergedProps.name);
+      return;
+    }
+    setChecked(!checked);
+  };
+  var onClick = function onClick(e) {
+    e.stopPropagation();
+  };
+  return /*#__PURE__*/React.createElement("label", {
+    onClick: onClick,
+    className: classNames(cls, (_a = {}, _a["".concat(cls, "-disabled")] = mergedProps.disabled, _a["".concat(cls, "-checked")] = checked, _a), groupContext.className, className)
+  }, /*#__PURE__*/React.createElement("input", __assign({
+    type: "radio",
+    checked: checked,
+    value: value,
+    onChange: onRadioChange
+  }, mergedProps)), /*#__PURE__*/React.createElement("span", {
+    className: "".concat(cls, "-control")
+  }), /*#__PURE__*/React.createElement("span", {
+    className: "".concat(cls, "-child")
+  }, children));
+};
+export default Radio;

package/esm/radio/RadioGroup.d.ts

@@ -0,0 +1,16 @@
+import { Component } from 'react';
+import { RadioGroupProps, RadioValue } from './interface';
+interface RadioGroupState {
+    value: RadioValue;
+}
+declare class RadioGroup extends Component<RadioGroupProps, RadioGroupState> {
+    constructor(props: any);
+    static getDerivedStateFromProps(nextProps: RadioGroupProps, prevState: RadioGroupState): {
+        value: RadioValue;
+    };
+    onRadioChange: (v: RadioValue, n: string) => void;
+    renderRadioGroup: () => JSX.Element;
+    renderRadioList: () => JSX.Element;
+    render(): JSX.Element;
+}
+export default RadioGroup;

package/esm/radio/RadioGroup.js

@@ -0,0 +1,106 @@
+var __extends = this && this.__extends || function () {
+  var _extendStatics = function extendStatics(d, b) {
+    _extendStatics = Object.setPrototypeOf || {
+      __proto__: []
+    } instanceof Array && function (d, b) {
+      d.__proto__ = b;
+    } || function (d, b) {
+      for (var p in b) {
+        if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
+      }
+    };
+    return _extendStatics(d, b);
+  };
+  return function (d, b) {
+    if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    _extendStatics(d, b);
+    function __() {
+      this.constructor = d;
+    }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  };
+}();
+import React, { Component, Fragment } from 'react';
+import { isEmptyArray, isUndef } from '@autobest-ui/utils';
+import { RadioGroupContextProvider } from './context';
+import Radio from './Radio';
+var cls = 'ab-radio';
+function getRadioProp(radioProp, radioGroupProp) {
+  return isUndef(radioProp) ? radioGroupProp : radioProp;
+}
+var RadioGroup = /** @class */function (_super) {
+  __extends(RadioGroup, _super);
+  function RadioGroup(props) {
+    var _this = _super.call(this, props) || this;
+    _this.onRadioChange = function (v, n) {
+      var onChange = _this.props.onChange;
+      if (onChange) {
+        onChange(v, n);
+        return;
+      }
+      _this.setState({
+        value: v
+      });
+    };
+    _this.renderRadioGroup = function () {
+      var _a = _this.props,
+        name = _a.name,
+        children = _a.children,
+        disabled = _a.disabled;
+      var value = _this.state.value;
+      return /*#__PURE__*/React.createElement(RadioGroupContextProvider, {
+        value: {
+          name: name,
+          value: value,
+          disabled: disabled,
+          onChange: _this.onRadioChange,
+          className: "".concat(cls, "-item")
+        }
+      }, children);
+    };
+    _this.renderRadioList = function () {
+      var _a = _this.props,
+        name = _a.name,
+        options = _a.options,
+        disabled = _a.disabled;
+      var value = _this.state.value;
+      if (isEmptyArray(options)) {
+        return null;
+      }
+      return /*#__PURE__*/React.createElement(Fragment, null, options.map(function (item) {
+        return /*#__PURE__*/React.createElement(Radio, {
+          key: item.value,
+          className: "".concat(cls, "-item"),
+          name: name,
+          value: item.value,
+          disabled: getRadioProp(item.disabled, disabled),
+          checked: value === item.value,
+          onChange: function onChange(e, n) {
+            return _this.onRadioChange(e.target.value, n);
+          }
+        }, item.name);
+      }));
+    };
+    _this.state = {
+      value: props.defaultValue
+    };
+    return _this;
+  }
+  RadioGroup.getDerivedStateFromProps = function (nextProps, prevState) {
+    if ('value' in nextProps && nextProps.value !== prevState.value) {
+      return {
+        value: nextProps.value
+      };
+    }
+    return null;
+  };
+  RadioGroup.prototype.render = function () {
+    var _a = this.props.direction,
+      direction = _a === void 0 ? 'horizontal' : _a;
+    return /*#__PURE__*/React.createElement("div", {
+      className: "".concat(cls, "-group-").concat(direction)
+    }, 'options' in this.props ? this.renderRadioList() : this.renderRadioGroup());
+  };
+  return RadioGroup;
+}(Component);
+export default RadioGroup;