Latest updates from IceHrmPro

web/node_modules/antd/es/progress/Circle.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import { ProgressProps } from './progress';
+interface CircleProps extends ProgressProps {
+    prefixCls: string;
+    children: React.ReactNode;
+    progressStatus: string;
+}
+declare const Circle: React.FC<CircleProps>;
+export default Circle;

web/node_modules/antd/es/progress/Circle.js

@@ -0,0 +1,80 @@
+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; }
+
+import * as React from 'react';
+import { Circle as RCCircle } from 'rc-progress';
+import classNames from 'classnames';
+import { validProgress } from './utils';
+
+function getPercentage(_ref) {
+  var percent = _ref.percent,
+      successPercent = _ref.successPercent;
+  var ptg = validProgress(percent);
+
+  if (!successPercent) {
+    return ptg;
+  }
+
+  var successPtg = validProgress(successPercent);
+  return [successPercent, validProgress(ptg - successPtg)];
+}
+
+function getStrokeColor(_ref2) {
+  var successPercent = _ref2.successPercent,
+      strokeColor = _ref2.strokeColor;
+  var color = strokeColor || null;
+
+  if (!successPercent) {
+    return color;
+  }
+
+  return [null, color];
+}
+
+var Circle = function Circle(props) {
+  var prefixCls = props.prefixCls,
+      width = props.width,
+      strokeWidth = props.strokeWidth,
+      trailColor = props.trailColor,
+      strokeLinecap = props.strokeLinecap,
+      gapPosition = props.gapPosition,
+      gapDegree = props.gapDegree,
+      type = props.type,
+      children = props.children;
+  var circleSize = width || 120;
+  var circleStyle = {
+    width: circleSize,
+    height: circleSize,
+    fontSize: circleSize * 0.15 + 6
+  };
+  var circleWidth = strokeWidth || 6;
+  var gapPos = gapPosition || type === 'dashboard' && 'bottom' || 'top'; // Support gapDeg = 0 when type = 'dashboard'
+
+  var gapDeg;
+
+  if (gapDegree || gapDegree === 0) {
+    gapDeg = gapDegree;
+  } else if (type === 'dashboard') {
+    gapDeg = 75;
+  } // using className to style stroke color
+
+
+  var strokeColor = getStrokeColor(props);
+  var isGradient = Object.prototype.toString.call(strokeColor) === '[object Object]';
+  var wrapperClassName = classNames("".concat(prefixCls, "-inner"), _defineProperty({}, "".concat(prefixCls, "-circle-gradient"), isGradient));
+  return /*#__PURE__*/React.createElement("div", {
+    className: wrapperClassName,
+    style: circleStyle
+  }, /*#__PURE__*/React.createElement(RCCircle, {
+    percent: getPercentage(props),
+    strokeWidth: circleWidth,
+    trailWidth: circleWidth,
+    strokeColor: strokeColor,
+    strokeLinecap: strokeLinecap,
+    trailColor: trailColor,
+    prefixCls: prefixCls,
+    gapDegree: gapDeg,
+    gapPosition: gapPos
+  }), children);
+};
+
+export default Circle;

web/node_modules/antd/es/progress/Line.d.ts

@@ -0,0 +1,36 @@
+import * as React from 'react';
+import { ProgressGradient, ProgressProps, StringGradients } from './progress';
+interface LineProps extends ProgressProps {
+    prefixCls: string;
+    children: React.ReactNode;
+}
+/**
+ * {
+ *   '0%': '#afc163',
+ *   '75%': '#009900',
+ *   '50%': 'green',     ====>     '#afc163 0%, #66FF00 25%, #00CC00 50%, #009900 75%, #ffffff 100%'
+ *   '25%': '#66FF00',
+ *   '100%': '#ffffff'
+ * }
+ */
+export declare const sortGradient: (gradients: StringGradients) => string;
+/**
+ * {
+ *   '0%': '#afc163',
+ *   '25%': '#66FF00',
+ *   '50%': '#00CC00',     ====>  linear-gradient(to right, #afc163 0%, #66FF00 25%,
+ *   '75%': '#009900',              #00CC00 50%, #009900 75%, #ffffff 100%)
+ *   '100%': '#ffffff'
+ * }
+ *
+ * Then this man came to realize the truth:
+ * Besides six pence, there is the moon.
+ * Besides bread and butter, there is the bug.
+ * And...
+ * Besides women, there is the code.
+ */
+export declare const handleGradient: (strokeColor: ProgressGradient) => {
+    backgroundImage: string;
+};
+declare const Line: React.FC<LineProps>;
+export default Line;

web/node_modules/antd/es/progress/Line.js

@@ -0,0 +1,140 @@
+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 { validProgress } from './utils';
+/**
+ * {
+ *   '0%': '#afc163',
+ *   '75%': '#009900',
+ *   '50%': 'green',     ====>     '#afc163 0%, #66FF00 25%, #00CC00 50%, #009900 75%, #ffffff 100%'
+ *   '25%': '#66FF00',
+ *   '100%': '#ffffff'
+ * }
+ */
+
+export var sortGradient = function sortGradient(gradients) {
+  var tempArr = [];
+  Object.keys(gradients).forEach(function (key) {
+    var formattedKey = parseFloat(key.replace(/%/g, ''));
+
+    if (!isNaN(formattedKey)) {
+      tempArr.push({
+        key: formattedKey,
+        value: gradients[key]
+      });
+    }
+  });
+  tempArr = tempArr.sort(function (a, b) {
+    return a.key - b.key;
+  });
+  return tempArr.map(function (_ref) {
+    var key = _ref.key,
+        value = _ref.value;
+    return "".concat(value, " ").concat(key, "%");
+  }).join(', ');
+};
+/**
+ * {
+ *   '0%': '#afc163',
+ *   '25%': '#66FF00',
+ *   '50%': '#00CC00',     ====>  linear-gradient(to right, #afc163 0%, #66FF00 25%,
+ *   '75%': '#009900',              #00CC00 50%, #009900 75%, #ffffff 100%)
+ *   '100%': '#ffffff'
+ * }
+ *
+ * Then this man came to realize the truth:
+ * Besides six pence, there is the moon.
+ * Besides bread and butter, there is the bug.
+ * And...
+ * Besides women, there is the code.
+ */
+
+export var handleGradient = function handleGradient(strokeColor) {
+  var _strokeColor$from = strokeColor.from,
+      from = _strokeColor$from === void 0 ? '#1890ff' : _strokeColor$from,
+      _strokeColor$to = strokeColor.to,
+      to = _strokeColor$to === void 0 ? '#1890ff' : _strokeColor$to,
+      _strokeColor$directio = strokeColor.direction,
+      direction = _strokeColor$directio === void 0 ? 'to right' : _strokeColor$directio,
+      rest = __rest(strokeColor, ["from", "to", "direction"]);
+
+  if (Object.keys(rest).length !== 0) {
+    var sortedGradients = sortGradient(rest);
+    return {
+      backgroundImage: "linear-gradient(".concat(direction, ", ").concat(sortedGradients, ")")
+    };
+  }
+
+  return {
+    backgroundImage: "linear-gradient(".concat(direction, ", ").concat(from, ", ").concat(to, ")")
+  };
+};
+
+var Line = function Line(props) {
+  var prefixCls = props.prefixCls,
+      percent = props.percent,
+      successPercent = props.successPercent,
+      strokeWidth = props.strokeWidth,
+      size = props.size,
+      strokeColor = props.strokeColor,
+      strokeLinecap = props.strokeLinecap,
+      children = props.children,
+      trailColor = props.trailColor;
+  var backgroundProps;
+
+  if (strokeColor && typeof strokeColor !== 'string') {
+    backgroundProps = handleGradient(strokeColor);
+  } else {
+    backgroundProps = {
+      background: strokeColor
+    };
+  }
+
+  var trailStyle;
+
+  if (trailColor && typeof trailColor === 'string') {
+    trailStyle = {
+      backgroundColor: trailColor
+    };
+  }
+
+  var percentStyle = _extends({
+    width: "".concat(validProgress(percent), "%"),
+    height: strokeWidth || (size === 'small' ? 6 : 8),
+    borderRadius: strokeLinecap === 'square' ? 0 : ''
+  }, backgroundProps);
+
+  var successPercentStyle = {
+    width: "".concat(validProgress(successPercent), "%"),
+    height: strokeWidth || (size === 'small' ? 6 : 8),
+    borderRadius: strokeLinecap === 'square' ? 0 : ''
+  };
+  var successSegment = successPercent !== undefined ? /*#__PURE__*/React.createElement("div", {
+    className: "".concat(prefixCls, "-success-bg"),
+    style: successPercentStyle
+  }) : null;
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("div", {
+    className: "".concat(prefixCls, "-outer")
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "".concat(prefixCls, "-inner"),
+    style: trailStyle
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "".concat(prefixCls, "-bg"),
+    style: percentStyle
+  }), successSegment)), children);
+};
+
+export default Line;

web/node_modules/antd/es/progress/Steps.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { ProgressProps, ProgressSize } from './progress';
+interface StepsProps extends ProgressProps {
+    steps: number;
+    size?: ProgressSize;
+}
+declare const Steps: React.FC<StepsProps>;
+export default Steps;

web/node_modules/antd/es/progress/Steps.js

@@ -0,0 +1,47 @@
+import * as React from 'react';
+
+var Steps = function Steps(props) {
+  var _props$size = props.size,
+      size = _props$size === void 0 ? 'default' : _props$size,
+      steps = props.steps,
+      _props$percent = props.percent,
+      percent = _props$percent === void 0 ? 0 : _props$percent,
+      _props$strokeWidth = props.strokeWidth,
+      strokeWidth = _props$strokeWidth === void 0 ? 8 : _props$strokeWidth,
+      strokeColor = props.strokeColor,
+      prefixCls = props.prefixCls,
+      children = props.children;
+
+  var getStyledSteps = function getStyledSteps() {
+    var current = Math.floor(steps * (percent / 100));
+    var stepWidth = size === 'small' ? 2 : 14;
+    var styleSteps = [];
+
+    for (var i = 0; i < steps; i++) {
+      var color = void 0;
+
+      if (i <= current - 1) {
+        color = strokeColor;
+      }
+
+      var stepStyle = {
+        backgroundColor: "".concat(color),
+        width: "".concat(stepWidth, "px"),
+        height: "".concat(strokeWidth, "px")
+      };
+      styleSteps.push( /*#__PURE__*/React.createElement("div", {
+        key: i,
+        className: "".concat(prefixCls, "-steps-item"),
+        style: stepStyle
+      }));
+    }
+
+    return styleSteps;
+  };
+
+  return /*#__PURE__*/React.createElement("div", {
+    className: "".concat(prefixCls, "-steps-outer")
+  }, getStyledSteps(), children);
+};
+
+export default Steps;

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

@@ -0,0 +1,3 @@
+import Progress from './progress';
+export { ProgressProps } from './progress';
+export default Progress;

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

@@ -0,0 +1,2 @@
+import Progress from './progress';
+export default Progress;

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

@@ -0,0 +1,53 @@
+import * as React from 'react';
+import { ConfigConsumerProps } from '../config-provider';
+declare const ProgressTypes: ["line", "circle", "dashboard"];
+export declare type ProgressType = typeof ProgressTypes[number];
+declare const ProgressStatuses: ["normal", "exception", "active", "success"];
+export declare type ProgressSize = 'default' | 'small';
+export declare type StringGradients = {
+    [percentage: string]: string;
+};
+declare type FromToGradients = {
+    from: string;
+    to: string;
+};
+export declare type ProgressGradient = {
+    direction?: string;
+} & (StringGradients | FromToGradients);
+export interface ProgressProps {
+    prefixCls?: string;
+    className?: string;
+    type?: ProgressType;
+    percent?: number;
+    successPercent?: number;
+    format?: (percent?: number, successPercent?: number) => React.ReactNode;
+    status?: typeof ProgressStatuses[number];
+    showInfo?: boolean;
+    strokeWidth?: number;
+    strokeLinecap?: 'butt' | 'square' | 'round';
+    strokeColor?: string | ProgressGradient;
+    trailColor?: string;
+    width?: number;
+    style?: React.CSSProperties;
+    gapDegree?: number;
+    gapPosition?: 'top' | 'bottom' | 'left' | 'right';
+    size?: ProgressSize;
+    steps?: number;
+}
+export default class Progress extends React.Component<ProgressProps> {
+    static defaultProps: {
+        type: "circle" | "line" | "dashboard" | undefined;
+        percent: number;
+        showInfo: boolean;
+        trailColor: null;
+        size: "small" | "default" | undefined;
+        gapDegree: undefined;
+        strokeLinecap: "round" | "butt" | "square" | undefined;
+    };
+    getPercentNumber(): number;
+    getProgressStatus(): "success" | "normal" | "active" | "exception";
+    renderProcessInfo(prefixCls: string, progressStatus: typeof ProgressStatuses[number]): JSX.Element | null;
+    renderProgress: ({ getPrefixCls, direction }: ConfigConsumerProps) => JSX.Element;
+    render(): JSX.Element;
+}
+export {};

web/node_modules/antd/es/progress/progress.js

@@ -0,0 +1,187 @@
+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 classNames from 'classnames';
+import omit from 'omit.js';
+import CloseOutlined from '@ant-design/icons/CloseOutlined';
+import CheckOutlined from '@ant-design/icons/CheckOutlined';
+import CheckCircleFilled from '@ant-design/icons/CheckCircleFilled';
+import CloseCircleFilled from '@ant-design/icons/CloseCircleFilled';
+import { ConfigConsumer } from '../config-provider';
+import { tuple } from '../_util/type';
+import Line from './Line';
+import Circle from './Circle';
+import Steps from './Steps';
+import { validProgress } from './utils';
+var ProgressTypes = tuple('line', 'circle', 'dashboard');
+var ProgressStatuses = tuple('normal', 'exception', 'active', 'success');
+
+var Progress = /*#__PURE__*/function (_React$Component) {
+  _inherits(Progress, _React$Component);
+
+  var _super = _createSuper(Progress);
+
+  function Progress() {
+    var _this;
+
+    _classCallCheck(this, Progress);
+
+    _this = _super.apply(this, arguments);
+
+    _this.renderProgress = function (_ref) {
+      var _classNames;
+
+      var getPrefixCls = _ref.getPrefixCls,
+          direction = _ref.direction;
+
+      var _assertThisInitialize = _assertThisInitialized(_this),
+          props = _assertThisInitialize.props;
+
+      var customizePrefixCls = props.prefixCls,
+          className = props.className,
+          size = props.size,
+          type = props.type,
+          steps = props.steps,
+          showInfo = props.showInfo,
+          restProps = __rest(props, ["prefixCls", "className", "size", "type", "steps", "showInfo"]);
+
+      var prefixCls = getPrefixCls('progress', customizePrefixCls);
+
+      var progressStatus = _this.getProgressStatus();
+
+      var progressInfo = _this.renderProcessInfo(prefixCls, progressStatus);
+
+      var progress; // Render progress shape
+
+      if (type === 'line') {
+        progress = steps ? /*#__PURE__*/React.createElement(Steps, _extends({}, _this.props, {
+          prefixCls: prefixCls,
+          steps: steps
+        }), progressInfo) : /*#__PURE__*/React.createElement(Line, _extends({}, _this.props, {
+          prefixCls: prefixCls
+        }), progressInfo);
+      } else if (type === 'circle' || type === 'dashboard') {
+        progress = /*#__PURE__*/React.createElement(Circle, _extends({}, _this.props, {
+          prefixCls: prefixCls,
+          progressStatus: progressStatus
+        }), progressInfo);
+      }
+
+      var classString = classNames(prefixCls, (_classNames = {}, _defineProperty(_classNames, "".concat(prefixCls, "-").concat(type === 'dashboard' && 'circle' || steps && 'steps' || type), true), _defineProperty(_classNames, "".concat(prefixCls, "-status-").concat(progressStatus), true), _defineProperty(_classNames, "".concat(prefixCls, "-show-info"), showInfo), _defineProperty(_classNames, "".concat(prefixCls, "-").concat(size), size), _defineProperty(_classNames, "".concat(prefixCls, "-rtl"), direction === 'rtl'), _classNames), className);
+      return /*#__PURE__*/React.createElement("div", _extends({}, omit(restProps, ['status', 'format', 'trailColor', 'successPercent', 'strokeWidth', 'width', 'gapDegree', 'gapPosition', 'strokeColor', 'strokeLinecap', 'percent', 'steps']), {
+        className: classString
+      }), progress);
+    };
+
+    return _this;
+  }
+
+  _createClass(Progress, [{
+    key: "getPercentNumber",
+    value: function getPercentNumber() {
+      var _this$props = this.props,
+          successPercent = _this$props.successPercent,
+          _this$props$percent = _this$props.percent,
+          percent = _this$props$percent === void 0 ? 0 : _this$props$percent;
+      return parseInt(successPercent !== undefined ? successPercent.toString() : percent.toString(), 10);
+    }
+  }, {
+    key: "getProgressStatus",
+    value: function getProgressStatus() {
+      var status = this.props.status;
+
+      if (ProgressStatuses.indexOf(status) < 0 && this.getPercentNumber() >= 100) {
+        return 'success';
+      }
+
+      return status || 'normal';
+    }
+  }, {
+    key: "renderProcessInfo",
+    value: function renderProcessInfo(prefixCls, progressStatus) {
+      var _this$props2 = this.props,
+          showInfo = _this$props2.showInfo,
+          format = _this$props2.format,
+          type = _this$props2.type,
+          percent = _this$props2.percent,
+          successPercent = _this$props2.successPercent;
+      if (!showInfo) return null;
+      var text;
+
+      var textFormatter = format || function (percentNumber) {
+        return "".concat(percentNumber, "%");
+      };
+
+      var isLineType = type === 'line';
+
+      if (format || progressStatus !== 'exception' && progressStatus !== 'success') {
+        text = textFormatter(validProgress(percent), validProgress(successPercent));
+      } else if (progressStatus === 'exception') {
+        text = isLineType ? /*#__PURE__*/React.createElement(CloseCircleFilled, null) : /*#__PURE__*/React.createElement(CloseOutlined, null);
+      } else if (progressStatus === 'success') {
+        text = isLineType ? /*#__PURE__*/React.createElement(CheckCircleFilled, null) : /*#__PURE__*/React.createElement(CheckOutlined, null);
+      }
+
+      return /*#__PURE__*/React.createElement("span", {
+        className: "".concat(prefixCls, "-text"),
+        title: typeof text === 'string' ? text : undefined
+      }, text);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement(ConfigConsumer, null, this.renderProgress);
+    }
+  }]);
+
+  return Progress;
+}(React.Component);
+
+export { Progress as default };
+Progress.defaultProps = {
+  type: 'line',
+  percent: 0,
+  showInfo: true,
+  // null for different theme definition
+  trailColor: null,
+  size: 'default',
+  gapDegree: undefined,
+  strokeLinecap: 'round'
+};

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

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

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

@@ -0,0 +1,213 @@
+/* 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-progress {
+  -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;
+}
+.ant-progress-line {
+  position: relative;
+  width: 100%;
+  font-size: 14px;
+}
+.ant-progress-steps {
+  display: inline-block;
+}
+.ant-progress-steps-outer {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-orient: horizontal;
+  -webkit-box-direction: normal;
+      -ms-flex-direction: row;
+          flex-direction: row;
+  -webkit-box-align: center;
+      -ms-flex-align: center;
+          align-items: center;
+}
+.ant-progress-steps-item {
+  -ms-flex-negative: 0;
+      flex-shrink: 0;
+  min-width: 2px;
+  margin-right: 2px;
+  background: #f3f3f3;
+}
+.ant-progress-small.ant-progress-line,
+.ant-progress-small.ant-progress-line .ant-progress-text .anticon {
+  font-size: 12px;
+}
+.ant-progress-outer {
+  display: inline-block;
+  width: 100%;
+  margin-right: 0;
+  padding-right: 0;
+}
+.ant-progress-show-info .ant-progress-outer {
+  margin-right: calc(-2em - 8px);
+  padding-right: calc(2em + 8px);
+}
+.ant-progress-inner {
+  position: relative;
+  display: inline-block;
+  width: 100%;
+  overflow: hidden;
+  vertical-align: middle;
+  background-color: #f5f5f5;
+  border-radius: 100px;
+}
+.ant-progress-circle-trail {
+  stroke: #f5f5f5;
+}
+.ant-progress-circle-path {
+  -webkit-animation: ant-progress-appear 0.3s;
+          animation: ant-progress-appear 0.3s;
+}
+.ant-progress-inner:not(.ant-progress-circle-gradient) .ant-progress-circle-path {
+  stroke: #1890ff;
+}
+.ant-progress-success-bg,
+.ant-progress-bg {
+  position: relative;
+  background-color: #1890ff;
+  border-radius: 100px;
+  -webkit-transition: all 0.4s cubic-bezier(0.08, 0.82, 0.17, 1) 0s;
+  transition: all 0.4s cubic-bezier(0.08, 0.82, 0.17, 1) 0s;
+}
+.ant-progress-success-bg {
+  position: absolute;
+  top: 0;
+  left: 0;
+  background-color: #52c41a;
+}
+.ant-progress-text {
+  display: inline-block;
+  width: 2em;
+  margin-left: 8px;
+  color: rgba(0, 0, 0, 0.45);
+  font-size: 1em;
+  line-height: 1;
+  white-space: nowrap;
+  text-align: left;
+  vertical-align: middle;
+  word-break: normal;
+}
+.ant-progress-text .anticon {
+  font-size: 14px;
+}
+.ant-progress-status-active .ant-progress-bg::before {
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  background: #fff;
+  border-radius: 10px;
+  opacity: 0;
+  -webkit-animation: ant-progress-active 2.4s cubic-bezier(0.23, 1, 0.32, 1) infinite;
+          animation: ant-progress-active 2.4s cubic-bezier(0.23, 1, 0.32, 1) infinite;
+  content: '';
+}
+.ant-progress-status-exception .ant-progress-bg {
+  background-color: #ff4d4f;
+}
+.ant-progress-status-exception .ant-progress-text {
+  color: #ff4d4f;
+}
+.ant-progress-status-exception .ant-progress-inner:not(.ant-progress-circle-gradient) .ant-progress-circle-path {
+  stroke: #ff4d4f;
+}
+.ant-progress-status-success .ant-progress-bg {
+  background-color: #52c41a;
+}
+.ant-progress-status-success .ant-progress-text {
+  color: #52c41a;
+}
+.ant-progress-status-success .ant-progress-inner:not(.ant-progress-circle-gradient) .ant-progress-circle-path {
+  stroke: #52c41a;
+}
+.ant-progress-circle .ant-progress-inner {
+  position: relative;
+  line-height: 1;
+  background-color: transparent;
+}
+.ant-progress-circle .ant-progress-text {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  width: 100%;
+  margin: 0;
+  padding: 0;
+  color: rgba(0, 0, 0, 0.65);
+  line-height: 1;
+  white-space: normal;
+  text-align: center;
+  -webkit-transform: translate(-50%, -50%);
+          transform: translate(-50%, -50%);
+}
+.ant-progress-circle .ant-progress-text .anticon {
+  font-size: 1.16666667em;
+}
+.ant-progress-circle.ant-progress-status-exception .ant-progress-text {
+  color: #ff4d4f;
+}
+.ant-progress-circle.ant-progress-status-success .ant-progress-text {
+  color: #52c41a;
+}
+@-webkit-keyframes ant-progress-active {
+  0% {
+    width: 0;
+    opacity: 0.1;
+  }
+  20% {
+    width: 0;
+    opacity: 0.5;
+  }
+  100% {
+    width: 100%;
+    opacity: 0;
+  }
+}
+@keyframes ant-progress-active {
+  0% {
+    width: 0;
+    opacity: 0.1;
+  }
+  20% {
+    width: 0;
+    opacity: 0.5;
+  }
+  100% {
+    width: 100%;
+    opacity: 0;
+  }
+}
+.ant-progress-rtl {
+  direction: rtl;
+}
+.ant-progress-rtl.ant-progress-show-info .ant-progress-outer {
+  margin-right: 0;
+  margin-left: calc(-2em - 8px);
+  padding-right: 0;
+  padding-left: calc(2em + 8px);
+}
+.ant-progress-rtl .ant-progress-success-bg {
+  right: 0;
+  left: auto;
+}
+.ant-progress-rtl.ant-progress-line .ant-progress-text,
+.ant-progress-rtl.ant-progress-steps .ant-progress-text {
+  margin-right: 8px;
+  margin-left: 0;
+  text-align: right;
+}

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

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

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

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

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

@@ -0,0 +1,199 @@
+@import '../../style/themes/index';
+@import '../../style/mixins/index';
+
+@progress-prefix-cls: ~'@{ant-prefix}-progress';
+
+.@{progress-prefix-cls} {
+  .reset-component;
+
+  display: inline-block;
+
+  &-line {
+    position: relative;
+    width: 100%;
+    font-size: @font-size-base;
+  }
+
+  &-steps {
+    display: inline-block;
+    &-outer {
+      display: flex;
+      flex-direction: row;
+      align-items: center;
+    }
+    &-item {
+      flex-shrink: 0;
+      min-width: 2px;
+      margin-right: 2px;
+      background: @progress-steps-item-bg;
+    }
+  }
+
+  &-small&-line,
+  &-small&-line &-text .@{iconfont-css-prefix} {
+    font-size: @font-size-sm;
+  }
+
+  &-outer {
+    display: inline-block;
+    width: 100%;
+    margin-right: 0;
+    padding-right: 0;
+    .@{progress-prefix-cls}-show-info & {
+      margin-right: ~'calc(-2em - 8px)';
+      padding-right: ~'calc(2em + 8px)';
+    }
+  }
+
+  &-inner {
+    position: relative;
+    display: inline-block;
+    width: 100%;
+    overflow: hidden;
+    vertical-align: middle;
+    background-color: @progress-remaining-color;
+    border-radius: @progress-radius;
+  }
+
+  &-circle-trail {
+    stroke: @progress-remaining-color;
+  }
+
+  &-circle-path {
+    animation: ~'@{ant-prefix}-progress-appear' 0.3s;
+  }
+
+  &-inner:not(.@{ant-prefix}-progress-circle-gradient) {
+    .@{ant-prefix}-progress-circle-path {
+      stroke: @progress-default-color;
+    }
+  }
+
+  &-success-bg,
+  &-bg {
+    position: relative;
+    background-color: @progress-default-color;
+    border-radius: @progress-radius;
+    transition: all 0.4s @ease-out-circ 0s;
+  }
+
+  &-success-bg {
+    position: absolute;
+    top: 0;
+    left: 0;
+    background-color: @success-color;
+  }
+
+  &-text {
+    display: inline-block;
+    width: 2em;
+    margin-left: 8px;
+    color: @text-color-secondary;
+    font-size: 1em;
+    line-height: 1;
+    white-space: nowrap;
+    text-align: left;
+    vertical-align: middle;
+    word-break: normal;
+    .@{iconfont-css-prefix} {
+      font-size: @font-size-base;
+    }
+  }
+
+  &-status-active {
+    .@{progress-prefix-cls}-bg::before {
+      position: absolute;
+      top: 0;
+      right: 0;
+      bottom: 0;
+      left: 0;
+      background: @component-background;
+      border-radius: 10px;
+      opacity: 0;
+      animation: ~'@{ant-prefix}-progress-active' 2.4s @ease-out-quint infinite;
+      content: '';
+    }
+  }
+
+  &-status-exception {
+    .@{progress-prefix-cls}-bg {
+      background-color: @error-color;
+    }
+    .@{progress-prefix-cls}-text {
+      color: @error-color;
+    }
+  }
+
+  &-status-exception &-inner:not(.@{progress-prefix-cls}-circle-gradient) {
+    .@{progress-prefix-cls}-circle-path {
+      stroke: @error-color;
+    }
+  }
+
+  &-status-success {
+    .@{progress-prefix-cls}-bg {
+      background-color: @success-color;
+    }
+    .@{progress-prefix-cls}-text {
+      color: @success-color;
+    }
+  }
+
+  &-status-success &-inner:not(.@{progress-prefix-cls}-circle-gradient) {
+    .@{progress-prefix-cls}-circle-path {
+      stroke: @success-color;
+    }
+  }
+
+  &-circle &-inner {
+    position: relative;
+    line-height: 1;
+    background-color: transparent;
+  }
+
+  &-circle &-text {
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    width: 100%;
+    margin: 0;
+    padding: 0;
+    color: @progress-text-color;
+    line-height: 1;
+    white-space: normal;
+    text-align: center;
+    transform: translate(-50%, -50%);
+
+    .@{iconfont-css-prefix} {
+      font-size: 14 / 12em;
+    }
+  }
+
+  &-circle&-status-exception {
+    .@{progress-prefix-cls}-text {
+      color: @error-color;
+    }
+  }
+  &-circle&-status-success {
+    .@{progress-prefix-cls}-text {
+      color: @success-color;
+    }
+  }
+}
+
+@keyframes ~"@{ant-prefix}-progress-active" {
+  0% {
+    width: 0;
+    opacity: 0.1;
+  }
+  20% {
+    width: 0;
+    opacity: 0.5;
+  }
+  100% {
+    width: 100%;
+    opacity: 0;
+  }
+}
+
+@import './rtl';

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

@@ -0,0 +1,37 @@
+@import '../../style/themes/index';
+@import '../../style/mixins/index';
+
+@progress-prefix-cls: ~'@{ant-prefix}-progress';
+
+.@{progress-prefix-cls} {
+  &-rtl {
+    direction: rtl;
+  }
+
+  &-outer {
+    .@{progress-prefix-cls}-show-info & {
+      .@{progress-prefix-cls}-rtl& {
+        margin-right: 0;
+        margin-left: ~'calc(-2em - 8px)';
+        padding-right: 0;
+        padding-left: ~'calc(2em + 8px)';
+      }
+    }
+  }
+
+  &-success-bg {
+    .@{progress-prefix-cls}-rtl & {
+      right: 0;
+      left: auto;
+    }
+  }
+
+  &-line &-text,
+  &-steps &-text {
+    .@{progress-prefix-cls}-rtl& {
+      margin-right: 8px;
+      margin-left: 0;
+      text-align: right;
+    }
+  }
+}

web/node_modules/antd/es/progress/utils.d.ts

@@ -0,0 +1 @@
+export declare function validProgress(progress: number | undefined): number;

web/node_modules/antd/es/progress/utils.js

@@ -0,0 +1,12 @@
+// eslint-disable-next-line import/prefer-default-export
+export function validProgress(progress) {
+  if (!progress || progress < 0) {
+    return 0;
+  }
+
+  if (progress > 100) {
+    return 100;
+  }
+
+  return progress;
+}