Latest updates from IceHrmPro

web/node_modules/antd/es/radio/context.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+import { RadioGroupContextProps } from './interface';
+declare const RadioGroupContext: React.Context<RadioGroupContextProps | null>;
+export declare const RadioGroupContextProvider: React.Provider<RadioGroupContextProps | null>;
+export default RadioGroupContext;

web/node_modules/antd/es/radio/context.js

@@ -0,0 +1,4 @@
+import * as React from 'react';
+var RadioGroupContext = React.createContext(null);
+export var RadioGroupContextProvider = RadioGroupContext.Provider;
+export default RadioGroupContext;

web/node_modules/antd/es/radio/group.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { RadioGroupProps, RadioGroupState, RadioChangeEvent, RadioGroupButtonStyle } from './interface';
+import { ConfigConsumerProps } from '../config-provider';
+declare class RadioGroup extends React.PureComponent<RadioGroupProps, RadioGroupState> {
+    static defaultProps: {
+        buttonStyle: RadioGroupButtonStyle;
+    };
+    static getDerivedStateFromProps(nextProps: RadioGroupProps, prevState: RadioGroupState): Partial<RadioGroupState>;
+    constructor(props: RadioGroupProps);
+    onRadioChange: (ev: RadioChangeEvent) => void;
+    renderGroup: ({ getPrefixCls, direction }: ConfigConsumerProps) => JSX.Element;
+    render(): JSX.Element;
+}
+export default RadioGroup;

web/node_modules/antd/es/radio/group.js

@@ -0,0 +1,189 @@
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+import * as React from 'react';
+import classNames from 'classnames';
+import Radio from './radio';
+import { ConfigConsumer } from '../config-provider';
+import SizeContext from '../config-provider/SizeContext';
+import { RadioGroupContextProvider } from './context';
+
+function getCheckedValue(children) {
+  var value = null;
+  var matched = false;
+  React.Children.forEach(children, function (radio) {
+    if (radio && radio.props && radio.props.checked) {
+      value = radio.props.value;
+      matched = true;
+    }
+  });
+  return matched ? {
+    value: value
+  } : undefined;
+}
+
+var RadioGroup = /*#__PURE__*/function (_React$PureComponent) {
+  _inherits(RadioGroup, _React$PureComponent);
+
+  var _super = _createSuper(RadioGroup);
+
+  function RadioGroup(props) {
+    var _this;
+
+    _classCallCheck(this, RadioGroup);
+
+    _this = _super.call(this, props);
+
+    _this.onRadioChange = function (ev) {
+      var lastValue = _this.state.value;
+      var value = ev.target.value;
+
+      if (!('value' in _this.props)) {
+        _this.setState({
+          value: value
+        });
+      }
+
+      var onChange = _this.props.onChange;
+
+      if (onChange && value !== lastValue) {
+        onChange(ev);
+      }
+    };
+
+    _this.renderGroup = function (_ref) {
+      var getPrefixCls = _ref.getPrefixCls,
+          direction = _ref.direction;
+
+      var _assertThisInitialize = _assertThisInitialized(_this),
+          props = _assertThisInitialize.props;
+
+      var customizePrefixCls = props.prefixCls,
+          _props$className = props.className,
+          className = _props$className === void 0 ? '' : _props$className,
+          options = props.options,
+          buttonStyle = props.buttonStyle,
+          customizeSize = props.size;
+      var prefixCls = getPrefixCls('radio', customizePrefixCls);
+      var groupPrefixCls = "".concat(prefixCls, "-group");
+      var children = props.children; // 如果存在 options, 优先使用
+
+      if (options && options.length > 0) {
+        children = options.map(function (option) {
+          if (typeof option === 'string') {
+            // 此处类型自动推导为 string
+            return /*#__PURE__*/React.createElement(Radio, {
+              key: option,
+              prefixCls: prefixCls,
+              disabled: _this.props.disabled,
+              value: option,
+              checked: _this.state.value === option
+            }, option);
+          } // 此处类型自动推导为 { label: string value: string }
+
+
+          return /*#__PURE__*/React.createElement(Radio, {
+            key: "radio-group-value-options-".concat(option.value),
+            prefixCls: prefixCls,
+            disabled: option.disabled || _this.props.disabled,
+            value: option.value,
+            checked: _this.state.value === option.value,
+            style: option.style
+          }, option.label);
+        });
+      }
+
+      return /*#__PURE__*/React.createElement(SizeContext.Consumer, null, function (size) {
+        var _classNames;
+
+        var mergedSize = customizeSize || size;
+        var classString = classNames(groupPrefixCls, "".concat(groupPrefixCls, "-").concat(buttonStyle), (_classNames = {}, _defineProperty(_classNames, "".concat(groupPrefixCls, "-").concat(mergedSize), mergedSize), _defineProperty(_classNames, "".concat(groupPrefixCls, "-rtl"), direction === 'rtl'), _classNames), className);
+        return /*#__PURE__*/React.createElement("div", {
+          className: classString,
+          style: props.style,
+          onMouseEnter: props.onMouseEnter,
+          onMouseLeave: props.onMouseLeave,
+          id: props.id
+        }, children);
+      });
+    };
+
+    var value;
+
+    if (props.value !== undefined) {
+      value = props.value;
+    } else if (props.defaultValue !== undefined) {
+      value = props.defaultValue;
+    } else {
+      var checkedValue = getCheckedValue(props.children);
+      value = checkedValue && checkedValue.value;
+    }
+
+    _this.state = {
+      value: value,
+      prevPropValue: props.value
+    };
+    return _this;
+  }
+
+  _createClass(RadioGroup, [{
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement(RadioGroupContextProvider, {
+        value: {
+          onChange: this.onRadioChange,
+          value: this.state.value,
+          disabled: this.props.disabled,
+          name: this.props.name
+        }
+      }, /*#__PURE__*/React.createElement(ConfigConsumer, null, this.renderGroup));
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(nextProps, prevState) {
+      var newState = {
+        prevPropValue: nextProps.value
+      };
+
+      if (nextProps.value !== undefined || prevState.prevPropValue !== nextProps.value) {
+        newState.value = nextProps.value;
+      } else {
+        var checkedValue = getCheckedValue(nextProps.children);
+
+        if (checkedValue) {
+          newState.value = checkedValue.value;
+        }
+      }
+
+      return newState;
+    }
+  }]);
+
+  return RadioGroup;
+}(React.PureComponent);
+
+RadioGroup.defaultProps = {
+  buttonStyle: 'outline'
+};
+export default RadioGroup;

web/node_modules/antd/es/radio/index.d.ts

@@ -0,0 +1,6 @@
+import Radio from './radio';
+import Group from './group';
+import Button from './radioButton';
+export * from './interface';
+export { Button, Group };
+export default Radio;

web/node_modules/antd/es/radio/index.js

@@ -0,0 +1,7 @@
+import Radio from './radio';
+import Group from './group';
+import Button from './radioButton';
+Radio.Button = Button;
+Radio.Group = Group;
+export { Button, Group };
+export default Radio;

web/node_modules/antd/es/radio/interface.d.ts

@@ -0,0 +1,37 @@
+import * as React from 'react';
+import { AbstractCheckboxGroupProps } from '../checkbox/Group';
+import { AbstractCheckboxProps } from '../checkbox/Checkbox';
+import { SizeType } from '../config-provider/SizeContext';
+export declare type RadioGroupButtonStyle = 'outline' | 'solid';
+export interface RadioGroupProps extends AbstractCheckboxGroupProps {
+    defaultValue?: any;
+    value?: any;
+    onChange?: (e: RadioChangeEvent) => void;
+    size?: SizeType;
+    onMouseEnter?: React.MouseEventHandler<HTMLDivElement>;
+    onMouseLeave?: React.MouseEventHandler<HTMLDivElement>;
+    name?: string;
+    children?: React.ReactNode;
+    id?: string;
+    buttonStyle?: RadioGroupButtonStyle;
+}
+export interface RadioGroupState {
+    value: any;
+    prevPropValue: any;
+}
+export interface RadioGroupContextProps {
+    onChange: (e: RadioChangeEvent) => void;
+    value: any;
+    disabled?: boolean;
+    name?: string;
+}
+export declare type RadioProps = AbstractCheckboxProps<RadioChangeEvent>;
+export interface RadioChangeEventTarget extends RadioProps {
+    checked: boolean;
+}
+export interface RadioChangeEvent {
+    target: RadioChangeEventTarget;
+    stopPropagation: () => void;
+    preventDefault: () => void;
+    nativeEvent: MouseEvent;
+}

web/node_modules/antd/es/radio/radio.d.ts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import RadioGroup from './group';
+import RadioButton from './radioButton';
+import { RadioProps, RadioChangeEvent } from './interface';
+import { ConfigConsumerProps } from '../config-provider';
+export default class Radio extends React.PureComponent<RadioProps, {}> {
+    static Group: typeof RadioGroup;
+    static Button: typeof RadioButton;
+    static defaultProps: {
+        type: string;
+    };
+    static contextType: React.Context<import("./interface").RadioGroupContextProps | null>;
+    private rcCheckbox;
+    saveCheckbox: (node: any) => void;
+    onChange: (e: RadioChangeEvent) => void;
+    focus(): void;
+    blur(): void;
+    renderRadio: ({ getPrefixCls, direction }: ConfigConsumerProps) => JSX.Element;
+    render(): JSX.Element;
+}

web/node_modules/antd/es/radio/radio.js

@@ -0,0 +1,144 @@
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+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 * as React from 'react';
+import RcCheckbox from 'rc-checkbox';
+import classNames from 'classnames';
+import { ConfigConsumer } from '../config-provider';
+import RadioGroupContext from './context';
+
+var Radio = /*#__PURE__*/function (_React$PureComponent) {
+  _inherits(Radio, _React$PureComponent);
+
+  var _super = _createSuper(Radio);
+
+  function Radio() {
+    var _this;
+
+    _classCallCheck(this, Radio);
+
+    _this = _super.apply(this, arguments);
+
+    _this.saveCheckbox = function (node) {
+      _this.rcCheckbox = node;
+    };
+
+    _this.onChange = function (e) {
+      var _a;
+
+      if (_this.props.onChange) {
+        _this.props.onChange(e);
+      }
+
+      if ((_a = _this.context) === null || _a === void 0 ? void 0 : _a.onChange) {
+        _this.context.onChange(e);
+      }
+    };
+
+    _this.renderRadio = function (_ref) {
+      var _classNames;
+
+      var getPrefixCls = _ref.getPrefixCls,
+          direction = _ref.direction;
+
+      var _assertThisInitialize = _assertThisInitialized(_this),
+          props = _assertThisInitialize.props,
+          context = _assertThisInitialize.context;
+
+      var customizePrefixCls = props.prefixCls,
+          className = props.className,
+          children = props.children,
+          style = props.style,
+          restProps = __rest(props, ["prefixCls", "className", "children", "style"]);
+
+      var prefixCls = getPrefixCls('radio', customizePrefixCls);
+
+      var radioProps = _extends({}, restProps);
+
+      if (context) {
+        radioProps.name = context.name;
+        radioProps.onChange = _this.onChange;
+        radioProps.checked = props.value === context.value;
+        radioProps.disabled = props.disabled || context.disabled;
+      }
+
+      var wrapperClassString = classNames(className, (_classNames = {}, _defineProperty(_classNames, "".concat(prefixCls, "-wrapper"), true), _defineProperty(_classNames, "".concat(prefixCls, "-wrapper-checked"), radioProps.checked), _defineProperty(_classNames, "".concat(prefixCls, "-wrapper-disabled"), radioProps.disabled), _defineProperty(_classNames, "".concat(prefixCls, "-wrapper-rtl"), direction === 'rtl'), _classNames));
+      return (
+        /*#__PURE__*/
+        // eslint-disable-next-line jsx-a11y/label-has-associated-control
+        React.createElement("label", {
+          className: wrapperClassString,
+          style: style,
+          onMouseEnter: props.onMouseEnter,
+          onMouseLeave: props.onMouseLeave
+        }, /*#__PURE__*/React.createElement(RcCheckbox, _extends({}, radioProps, {
+          prefixCls: prefixCls,
+          ref: _this.saveCheckbox
+        })), children !== undefined ? /*#__PURE__*/React.createElement("span", null, children) : null)
+      );
+    };
+
+    return _this;
+  }
+
+  _createClass(Radio, [{
+    key: "focus",
+    value: function focus() {
+      this.rcCheckbox.focus();
+    }
+  }, {
+    key: "blur",
+    value: function blur() {
+      this.rcCheckbox.blur();
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement(ConfigConsumer, null, this.renderRadio);
+    }
+  }]);
+
+  return Radio;
+}(React.PureComponent);
+
+export { Radio as default };
+Radio.defaultProps = {
+  type: 'radio'
+};
+Radio.contextType = RadioGroupContext;

web/node_modules/antd/es/radio/radioButton.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+import { RadioChangeEvent } from './interface';
+import { AbstractCheckboxProps } from '../checkbox/Checkbox';
+export declare type RadioButtonProps = AbstractCheckboxProps<RadioChangeEvent>;
+declare const _default: React.ForwardRefExoticComponent<RadioButtonProps & React.RefAttributes<any>>;
+export default _default;

web/node_modules/antd/es/radio/radioButton.js

@@ -0,0 +1,45 @@
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.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 * as React from 'react';
+import Radio from './radio';
+import { ConfigConsumer } from '../config-provider';
+import RadioGroupContext from './context';
+
+var RadioButton = function RadioButton(props, ref) {
+  var radioGroupContext = React.useContext(RadioGroupContext);
+  return /*#__PURE__*/React.createElement(ConfigConsumer, null, function (_ref) {
+    var getPrefixCls = _ref.getPrefixCls;
+
+    var customizePrefixCls = props.prefixCls,
+        radioProps = __rest(props, ["prefixCls"]);
+
+    var prefixCls = getPrefixCls('radio-button', customizePrefixCls);
+
+    if (radioGroupContext) {
+      radioProps.checked = props.value === radioGroupContext.value;
+      radioProps.disabled = props.disabled || radioGroupContext.disabled;
+    }
+
+    return /*#__PURE__*/React.createElement(Radio, _extends({
+      prefixCls: prefixCls
+    }, radioProps, {
+      type: "radio",
+      ref: ref
+    }));
+  });
+};
+
+export default React.forwardRef(RadioButton);

web/node_modules/antd/es/radio/style/css.js

@@ -0,0 +1,2 @@
+import '../../style/index.css';
+import './index.css';

web/node_modules/antd/es/radio/style/index.css

@@ -0,0 +1,370 @@
+/* stylelint-disable at-rule-empty-line-before,at-rule-name-space-after,at-rule-no-unknown */
+/* stylelint-disable no-duplicate-selectors */
+/* stylelint-disable */
+/* stylelint-disable declaration-bang-space-before,no-duplicate-selectors,string-no-newline */
+.ant-radio-group {
+  -webkit-box-sizing: border-box;
+          box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+  color: rgba(0, 0, 0, 0.65);
+  font-size: 14px;
+  font-variant: tabular-nums;
+  line-height: 1.5715;
+  list-style: none;
+  -webkit-font-feature-settings: 'tnum';
+          font-feature-settings: 'tnum';
+  display: inline-block;
+  line-height: unset;
+}
+.ant-radio-group .ant-badge-count {
+  z-index: 1;
+}
+.ant-radio-group > .ant-badge:not(:first-child) > .ant-radio-button-wrapper {
+  border-left: none;
+}
+.ant-radio-wrapper {
+  -webkit-box-sizing: border-box;
+          box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+  color: rgba(0, 0, 0, 0.65);
+  font-size: 14px;
+  font-variant: tabular-nums;
+  line-height: 1.5715;
+  list-style: none;
+  -webkit-font-feature-settings: 'tnum';
+          font-feature-settings: 'tnum';
+  position: relative;
+  display: inline-block;
+  margin-right: 8px;
+  white-space: nowrap;
+  cursor: pointer;
+}
+.ant-radio {
+  -webkit-box-sizing: border-box;
+          box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+  color: rgba(0, 0, 0, 0.65);
+  font-size: 14px;
+  font-variant: tabular-nums;
+  line-height: 1.5715;
+  list-style: none;
+  -webkit-font-feature-settings: 'tnum';
+          font-feature-settings: 'tnum';
+  position: relative;
+  display: inline-block;
+  line-height: 1;
+  white-space: nowrap;
+  vertical-align: sub;
+  outline: none;
+  cursor: pointer;
+}
+.ant-radio-wrapper:hover .ant-radio,
+.ant-radio:hover .ant-radio-inner,
+.ant-radio-input:focus + .ant-radio-inner {
+  border-color: #1890ff;
+}
+.ant-radio-input:focus + .ant-radio-inner {
+  -webkit-box-shadow: 0 0 0 3px rgba(24, 144, 255, 0.08);
+          box-shadow: 0 0 0 3px rgba(24, 144, 255, 0.08);
+}
+.ant-radio-checked::after {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  border: 1px solid #1890ff;
+  border-radius: 50%;
+  visibility: hidden;
+  -webkit-animation: antRadioEffect 0.36s ease-in-out;
+          animation: antRadioEffect 0.36s ease-in-out;
+  -webkit-animation-fill-mode: both;
+          animation-fill-mode: both;
+  content: '';
+}
+.ant-radio:hover::after,
+.ant-radio-wrapper:hover .ant-radio::after {
+  visibility: visible;
+}
+.ant-radio-inner {
+  position: relative;
+  top: 0;
+  left: 0;
+  display: block;
+  width: 16px;
+  height: 16px;
+  background-color: #fff;
+  border-color: #d9d9d9;
+  border-style: solid;
+  border-width: 1px;
+  border-radius: 100px;
+  -webkit-transition: all 0.3s;
+  transition: all 0.3s;
+}
+.ant-radio-inner::after {
+  position: absolute;
+  top: 3px;
+  left: 3px;
+  display: table;
+  width: 8px;
+  height: 8px;
+  background-color: #1890ff;
+  border-top: 0;
+  border-left: 0;
+  border-radius: 8px;
+  -webkit-transform: scale(0);
+          transform: scale(0);
+  opacity: 0;
+  -webkit-transition: all 0.3s cubic-bezier(0.78, 0.14, 0.15, 0.86);
+  transition: all 0.3s cubic-bezier(0.78, 0.14, 0.15, 0.86);
+  content: ' ';
+}
+.ant-radio-input {
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  z-index: 1;
+  cursor: pointer;
+  opacity: 0;
+}
+.ant-radio-checked .ant-radio-inner {
+  border-color: #1890ff;
+}
+.ant-radio-checked .ant-radio-inner::after {
+  -webkit-transform: scale(1);
+          transform: scale(1);
+  opacity: 1;
+  -webkit-transition: all 0.3s cubic-bezier(0.78, 0.14, 0.15, 0.86);
+  transition: all 0.3s cubic-bezier(0.78, 0.14, 0.15, 0.86);
+}
+.ant-radio-disabled .ant-radio-inner {
+  background-color: #f5f5f5;
+  border-color: #d9d9d9 !important;
+  cursor: not-allowed;
+}
+.ant-radio-disabled .ant-radio-inner::after {
+  background-color: rgba(0, 0, 0, 0.2);
+}
+.ant-radio-disabled .ant-radio-input {
+  cursor: not-allowed;
+}
+.ant-radio-disabled + span {
+  color: rgba(0, 0, 0, 0.25);
+  cursor: not-allowed;
+}
+span.ant-radio + * {
+  padding-right: 8px;
+  padding-left: 8px;
+}
+.ant-radio-button-wrapper {
+  position: relative;
+  display: inline-block;
+  height: 32px;
+  margin: 0;
+  padding: 0 15px;
+  color: rgba(0, 0, 0, 0.65);
+  line-height: 30px;
+  background: #fff;
+  border: 1px solid #d9d9d9;
+  border-top-width: 1.02px;
+  border-left-width: 0;
+  cursor: pointer;
+  -webkit-transition: color 0.3s, background 0.3s, border-color 0.3s, -webkit-box-shadow 0.3s;
+  transition: color 0.3s, background 0.3s, border-color 0.3s, -webkit-box-shadow 0.3s;
+  transition: color 0.3s, background 0.3s, border-color 0.3s, box-shadow 0.3s;
+  transition: color 0.3s, background 0.3s, border-color 0.3s, box-shadow 0.3s, -webkit-box-shadow 0.3s;
+}
+.ant-radio-button-wrapper a {
+  color: rgba(0, 0, 0, 0.65);
+}
+.ant-radio-button-wrapper > .ant-radio-button {
+  display: block;
+  width: 0;
+  height: 0;
+  margin-left: 0;
+}
+.ant-radio-group-large .ant-radio-button-wrapper {
+  height: 40px;
+  font-size: 16px;
+  line-height: 38px;
+}
+.ant-radio-group-small .ant-radio-button-wrapper {
+  height: 24px;
+  padding: 0 7px;
+  line-height: 22px;
+}
+.ant-radio-button-wrapper:not(:first-child)::before {
+  position: absolute;
+  top: -1px;
+  left: -1px;
+  display: block;
+  -webkit-box-sizing: content-box;
+          box-sizing: content-box;
+  width: 1px;
+  height: 100%;
+  padding: 1px 0;
+  background-color: #d9d9d9;
+  -webkit-transition: background-color 0.3s;
+  transition: background-color 0.3s;
+  content: '';
+}
+.ant-radio-button-wrapper:first-child {
+  border-left: 1px solid #d9d9d9;
+  border-radius: 2px 0 0 2px;
+}
+.ant-radio-button-wrapper:last-child {
+  border-radius: 0 2px 2px 0;
+}
+.ant-radio-button-wrapper:first-child:last-child {
+  border-radius: 2px;
+}
+.ant-radio-button-wrapper:hover {
+  position: relative;
+  color: #1890ff;
+}
+.ant-radio-button-wrapper:focus-within {
+  -webkit-box-shadow: 0 0 0 3px rgba(24, 144, 255, 0.08);
+          box-shadow: 0 0 0 3px rgba(24, 144, 255, 0.08);
+}
+.ant-radio-button-wrapper .ant-radio-inner,
+.ant-radio-button-wrapper input[type='checkbox'],
+.ant-radio-button-wrapper input[type='radio'] {
+  width: 0;
+  height: 0;
+  opacity: 0;
+  pointer-events: none;
+}
+.ant-radio-button-wrapper-checked:not(.ant-radio-button-wrapper-disabled) {
+  z-index: 1;
+  color: #1890ff;
+  background: #fff;
+  border-color: #1890ff;
+}
+.ant-radio-button-wrapper-checked:not(.ant-radio-button-wrapper-disabled)::before {
+  background-color: #1890ff;
+}
+.ant-radio-button-wrapper-checked:not(.ant-radio-button-wrapper-disabled):first-child {
+  border-color: #1890ff;
+}
+.ant-radio-button-wrapper-checked:not(.ant-radio-button-wrapper-disabled):hover {
+  color: #40a9ff;
+  border-color: #40a9ff;
+}
+.ant-radio-button-wrapper-checked:not(.ant-radio-button-wrapper-disabled):hover::before {
+  background-color: #40a9ff;
+}
+.ant-radio-button-wrapper-checked:not(.ant-radio-button-wrapper-disabled):active {
+  color: #096dd9;
+  border-color: #096dd9;
+}
+.ant-radio-button-wrapper-checked:not(.ant-radio-button-wrapper-disabled):active::before {
+  background-color: #096dd9;
+}
+.ant-radio-button-wrapper-checked:not(.ant-radio-button-wrapper-disabled):focus-within {
+  -webkit-box-shadow: 0 0 0 3px rgba(24, 144, 255, 0.08);
+          box-shadow: 0 0 0 3px rgba(24, 144, 255, 0.08);
+}
+.ant-radio-group-solid .ant-radio-button-wrapper-checked:not(.ant-radio-button-wrapper-disabled) {
+  color: #fff;
+  background: #1890ff;
+  border-color: #1890ff;
+}
+.ant-radio-group-solid .ant-radio-button-wrapper-checked:not(.ant-radio-button-wrapper-disabled):hover {
+  color: #fff;
+  background: #40a9ff;
+  border-color: #40a9ff;
+}
+.ant-radio-group-solid .ant-radio-button-wrapper-checked:not(.ant-radio-button-wrapper-disabled):active {
+  color: #fff;
+  background: #096dd9;
+  border-color: #096dd9;
+}
+.ant-radio-group-solid .ant-radio-button-wrapper-checked:not(.ant-radio-button-wrapper-disabled):focus-within {
+  -webkit-box-shadow: 0 0 0 3px rgba(24, 144, 255, 0.08);
+          box-shadow: 0 0 0 3px rgba(24, 144, 255, 0.08);
+}
+.ant-radio-button-wrapper-disabled {
+  color: rgba(0, 0, 0, 0.25);
+  background-color: #f5f5f5;
+  border-color: #d9d9d9;
+  cursor: not-allowed;
+}
+.ant-radio-button-wrapper-disabled:first-child,
+.ant-radio-button-wrapper-disabled:hover {
+  color: rgba(0, 0, 0, 0.25);
+  background-color: #f5f5f5;
+  border-color: #d9d9d9;
+}
+.ant-radio-button-wrapper-disabled:first-child {
+  border-left-color: #d9d9d9;
+}
+.ant-radio-button-wrapper-disabled.ant-radio-button-wrapper-checked {
+  color: #fff;
+  background-color: #e6e6e6;
+  border-color: #d9d9d9;
+  -webkit-box-shadow: none;
+          box-shadow: none;
+}
+@-webkit-keyframes antRadioEffect {
+  0% {
+    -webkit-transform: scale(1);
+            transform: scale(1);
+    opacity: 0.5;
+  }
+  100% {
+    -webkit-transform: scale(1.6);
+            transform: scale(1.6);
+    opacity: 0;
+  }
+}
+@keyframes antRadioEffect {
+  0% {
+    -webkit-transform: scale(1);
+            transform: scale(1);
+    opacity: 0.5;
+  }
+  100% {
+    -webkit-transform: scale(1.6);
+            transform: scale(1.6);
+    opacity: 0;
+  }
+}
+@supports (-moz-appearance: meterbar) and (background-blend-mode: difference, normal) {
+  .ant-radio {
+    vertical-align: text-bottom;
+  }
+}
+.ant-radio-group.ant-radio-group-rtl {
+  direction: rtl;
+}
+.ant-radio-wrapper.ant-radio-wrapper-rtl {
+  margin-right: 0;
+  margin-left: 8px;
+  direction: rtl;
+}
+.ant-radio-button-wrapper.ant-radio-button-wrapper-rtl {
+  border-right-width: 0;
+  border-left-width: 1px;
+}
+.ant-radio-button-wrapper.ant-radio-button-wrapper-rtl.ant-radio-button-wrapper:not(:first-child)::before {
+  right: -1px;
+  left: 0;
+}
+.ant-radio-button-wrapper.ant-radio-button-wrapper-rtl.ant-radio-button-wrapper:first-child {
+  border-right: 1px solid #d9d9d9;
+  border-radius: 0 2px 2px 0;
+}
+.ant-radio-button-wrapper-checked:not([class*=' ant-radio-button-wrapper-disabled']).ant-radio-button-wrapper:first-child {
+  border-right-color: #40a9ff;
+}
+.ant-radio-button-wrapper.ant-radio-button-wrapper-rtl.ant-radio-button-wrapper:last-child {
+  border-radius: 2px 0 0 2px;
+}
+.ant-radio-button-wrapper.ant-radio-button-wrapper-rtl.ant-radio-button-wrapper-disabled:first-child {
+  border-right-color: #d9d9d9;
+}

web/node_modules/antd/es/radio/style/index.d.ts

@@ -0,0 +1,2 @@
+import '../../style/index.less';
+import './index.less';

web/node_modules/antd/es/radio/style/index.js

@@ -0,0 +1,2 @@
+import '../../style/index.less';
+import './index.less';

web/node_modules/antd/es/radio/style/index.less

@@ -0,0 +1,344 @@
+@import '../../style/themes/index';
+@import '../../style/mixins/index';
+
+@radio-prefix-cls: ~'@{ant-prefix}-radio';
+@radio-group-prefix-cls: ~'@{radio-prefix-cls}-group';
+@radio-inner-prefix-cls: ~'@{radio-prefix-cls}-inner';
+@radio-duration: 0.3s;
+@radio-focus-shadow: 0 0 0 3px fade(@radio-dot-color, 8%);
+@radio-button-focus-shadow: @radio-focus-shadow;
+
+.@{radio-group-prefix-cls} {
+  .reset-component;
+
+  display: inline-block;
+  line-height: unset;
+
+  .@{ant-prefix}-badge-count {
+    z-index: 1;
+  }
+
+  > .@{ant-prefix}-badge:not(:first-child) > .@{radio-prefix-cls}-button-wrapper {
+    border-left: none;
+  }
+}
+
+// 一般状态
+.@{radio-prefix-cls}-wrapper {
+  .reset-component;
+
+  position: relative;
+  display: inline-block;
+  margin-right: 8px;
+  white-space: nowrap;
+  cursor: pointer;
+}
+
+.@{radio-prefix-cls} {
+  .reset-component;
+
+  position: relative;
+  display: inline-block;
+  line-height: 1;
+  white-space: nowrap;
+  vertical-align: sub;
+  outline: none;
+  cursor: pointer;
+
+  .@{radio-prefix-cls}-wrapper:hover &,
+  &:hover .@{radio-inner-prefix-cls},
+  &-input:focus + .@{radio-inner-prefix-cls} {
+    border-color: @radio-dot-color;
+  }
+
+  &-input:focus + .@{radio-inner-prefix-cls} {
+    box-shadow: @radio-focus-shadow;
+  }
+
+  &-checked::after {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    border: 1px solid @radio-dot-color;
+    border-radius: 50%;
+    visibility: hidden;
+    animation: antRadioEffect 0.36s ease-in-out;
+    animation-fill-mode: both;
+    content: '';
+  }
+
+  &:hover::after,
+  .@{radio-prefix-cls}-wrapper:hover &::after {
+    visibility: visible;
+  }
+
+  &-inner {
+    &::after {
+      @radio-dot-size: @radio-size - 8px;
+
+      position: absolute;
+      top: (@radio-size - @radio-dot-size) / 2 - 1px;
+      left: (@radio-size - @radio-dot-size) / 2 - 1px;
+      display: table;
+      width: @radio-dot-size;
+      height: @radio-dot-size;
+      background-color: @radio-dot-color;
+      border-top: 0;
+      border-left: 0;
+      border-radius: @radio-dot-size;
+      transform: scale(0);
+      opacity: 0;
+      transition: all @radio-duration @ease-in-out-circ;
+      content: ' ';
+    }
+
+    position: relative;
+    top: 0;
+    left: 0;
+    display: block;
+    width: @radio-size;
+    height: @radio-size;
+    background-color: @radio-button-bg;
+    border-color: @border-color-base;
+    border-style: solid;
+    border-width: 1px;
+    border-radius: 100px;
+    transition: all @radio-duration;
+  }
+
+  &-input {
+    position: absolute;
+    top: 0;
+    right: 0;
+    bottom: 0;
+    left: 0;
+    z-index: 1;
+    cursor: pointer;
+    opacity: 0;
+  }
+}
+
+// 选中状态
+.@{radio-prefix-cls}-checked {
+  .@{radio-inner-prefix-cls} {
+    border-color: @radio-dot-color;
+    &::after {
+      transform: scale(1);
+      opacity: 1;
+      transition: all @radio-duration @ease-in-out-circ;
+    }
+  }
+}
+
+.@{radio-prefix-cls}-disabled {
+  .@{radio-inner-prefix-cls} {
+    background-color: @input-disabled-bg;
+    border-color: @border-color-base !important;
+    cursor: not-allowed;
+    &::after {
+      background-color: @radio-dot-disabled-color;
+    }
+  }
+
+  .@{radio-prefix-cls}-input {
+    cursor: not-allowed;
+  }
+
+  & + span {
+    color: @disabled-color;
+    cursor: not-allowed;
+  }
+}
+
+span.@{radio-prefix-cls} + * {
+  padding-right: 8px;
+  padding-left: 8px;
+}
+
+.@{radio-prefix-cls}-button-wrapper {
+  position: relative;
+  display: inline-block;
+  height: @btn-height-base;
+  margin: 0;
+  padding: 0 @padding-md - 1px;
+  color: @radio-button-color;
+  line-height: @btn-height-base - 2px;
+  background: @radio-button-bg;
+  border: @border-width-base @border-style-base @border-color-base;
+  // strange align fix for chrome but works
+  // https://gw.alipayobjects.com/zos/rmsportal/VFTfKXJuogBAXcvfAUWJ.gif
+  border-top-width: @border-width-base + 0.02px;
+  border-left-width: 0;
+  cursor: pointer;
+  transition: color 0.3s, background 0.3s, border-color 0.3s, box-shadow 0.3s;
+
+  a {
+    color: @radio-button-color;
+  }
+
+  > .@{radio-prefix-cls}-button {
+    display: block;
+    width: 0;
+    height: 0;
+    margin-left: 0;
+  }
+
+  .@{radio-group-prefix-cls}-large & {
+    height: @input-height-lg;
+    font-size: @font-size-lg;
+    line-height: @input-height-lg - 2px;
+  }
+
+  .@{radio-group-prefix-cls}-small & {
+    height: @input-height-sm;
+    padding: 0 @control-padding-horizontal-sm - 1px;
+    line-height: @input-height-sm - 2px;
+  }
+
+  &:not(:first-child) {
+    &::before {
+      position: absolute;
+      top: @border-width-base * -1;
+      left: -1px;
+      display: block;
+      box-sizing: content-box;
+      width: 1px;
+      height: 100%;
+      padding: @border-width-base 0;
+      background-color: @border-color-base;
+      transition: background-color 0.3s;
+      content: '';
+    }
+  }
+
+  &:first-child {
+    border-left: @border-width-base @border-style-base @border-color-base;
+    border-radius: @border-radius-base 0 0 @border-radius-base;
+  }
+
+  &:last-child {
+    border-radius: 0 @border-radius-base @border-radius-base 0;
+  }
+
+  &:first-child:last-child {
+    border-radius: @border-radius-base;
+  }
+
+  &:hover {
+    position: relative;
+    color: @radio-dot-color;
+  }
+
+  &:focus-within {
+    box-shadow: @radio-button-focus-shadow;
+  }
+
+  .@{radio-prefix-cls}-inner,
+  input[type='checkbox'],
+  input[type='radio'] {
+    width: 0;
+    height: 0;
+    opacity: 0;
+    pointer-events: none;
+  }
+
+  &-checked:not(&-disabled) {
+    z-index: 1;
+    color: @radio-dot-color;
+    background: @radio-button-checked-bg;
+    border-color: @radio-dot-color;
+
+    &::before {
+      background-color: @radio-dot-color;
+    }
+
+    &:first-child {
+      border-color: @radio-dot-color;
+    }
+
+    &:hover {
+      color: @radio-button-hover-color;
+      border-color: @radio-button-hover-color;
+      &::before {
+        background-color: @radio-button-hover-color;
+      }
+    }
+
+    &:active {
+      color: @radio-button-active-color;
+      border-color: @radio-button-active-color;
+      &::before {
+        background-color: @radio-button-active-color;
+      }
+    }
+
+    &:focus-within {
+      box-shadow: @radio-button-focus-shadow;
+    }
+  }
+
+  .@{radio-group-prefix-cls}-solid &-checked:not(&-disabled) {
+    color: @radio-solid-checked-color;
+    background: @radio-dot-color;
+    border-color: @radio-dot-color;
+    &:hover {
+      color: @radio-solid-checked-color;
+      background: @radio-button-hover-color;
+      border-color: @radio-button-hover-color;
+    }
+    &:active {
+      color: @radio-solid-checked-color;
+      background: @radio-button-active-color;
+      border-color: @radio-button-active-color;
+    }
+    &:focus-within {
+      box-shadow: @radio-button-focus-shadow;
+    }
+  }
+
+  &-disabled {
+    color: @disabled-color;
+    background-color: @input-disabled-bg;
+    border-color: @border-color-base;
+    cursor: not-allowed;
+
+    &:first-child,
+    &:hover {
+      color: @disabled-color;
+      background-color: @input-disabled-bg;
+      border-color: @border-color-base;
+    }
+    &:first-child {
+      border-left-color: @border-color-base;
+    }
+  }
+
+  &-disabled&-checked {
+    color: @radio-disabled-button-checked-color;
+    background-color: @radio-disabled-button-checked-bg;
+    border-color: @border-color-base;
+    box-shadow: none;
+  }
+}
+
+@keyframes antRadioEffect {
+  0% {
+    transform: scale(1);
+    opacity: 0.5;
+  }
+  100% {
+    transform: scale(1.6);
+    opacity: 0;
+  }
+}
+
+// Firefox hack
+@supports (-moz-appearance: meterbar) and (background-blend-mode: difference, normal) {
+  .@{radio-prefix-cls} {
+    vertical-align: text-bottom;
+  }
+}
+
+@import './rtl';

web/node_modules/antd/es/radio/style/rtl.less

@@ -0,0 +1,61 @@
+@import '../../style/themes/index';
+@import '../../style/mixins/index';
+
+@radio-prefix-cls: ~'@{ant-prefix}-radio';
+@radio-group-prefix-cls: ~'@{radio-prefix-cls}-group';
+@radio-prefix-cls-button-wrapper: ~'@{radio-prefix-cls}-button-wrapper';
+
+.@{radio-group-prefix-cls} {
+  &&-rtl {
+    direction: rtl;
+  }
+}
+
+// 一般状态
+.@{radio-prefix-cls}-wrapper {
+  &&-rtl {
+    margin-right: 0;
+    margin-left: 8px;
+    direction: rtl;
+  }
+}
+
+.@{radio-prefix-cls-button-wrapper} {
+  &&-rtl {
+    border-right-width: 0;
+    border-left-width: @border-width-base;
+  }
+
+  &:not(:first-child) {
+    &::before {
+      .@{radio-prefix-cls-button-wrapper}.@{radio-prefix-cls-button-wrapper}-rtl& {
+        right: -1px;
+        left: 0;
+      }
+    }
+  }
+
+  &:first-child {
+    .@{radio-prefix-cls-button-wrapper}.@{radio-prefix-cls-button-wrapper}-rtl& {
+      border-right: @border-width-base @border-style-base @border-color-base;
+      border-radius: 0 @border-radius-base @border-radius-base 0;
+    }
+    .@{radio-prefix-cls-button-wrapper}-checked:not([class*=~"' @{radio-prefix-cls}-button-wrapper-disabled'"])& {
+      border-right-color: @radio-button-hover-color;
+    }
+  }
+
+  &:last-child {
+    .@{radio-prefix-cls-button-wrapper}.@{radio-prefix-cls-button-wrapper}-rtl& {
+      border-radius: @border-radius-base 0 0 @border-radius-base;
+    }
+  }
+
+  &-disabled {
+    &:first-child {
+      .@{radio-prefix-cls-button-wrapper}.@{radio-prefix-cls-button-wrapper}-rtl& {
+        border-right-color: @border-color-base;
+      }
+    }
+  }
+}