You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1160 lines
42 KiB
1160 lines
42 KiB
"use strict";
|
|
(self["webpackChunk"] = self["webpackChunk"] || []).push([[93948],{
|
|
|
|
/***/ 93948:
|
|
/*!*************************************************************************!*\
|
|
!*** ./node_modules/_antd@5.9.0@antd/es/progress/index.js + 13 modules ***!
|
|
\*************************************************************************/
|
|
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
// EXPORTS
|
|
__webpack_require__.d(__webpack_exports__, {
|
|
Z: function() { return /* binding */ es_progress; }
|
|
});
|
|
|
|
// EXTERNAL MODULE: ./node_modules/_react@17.0.2@react/index.js
|
|
var _react_17_0_2_react = __webpack_require__(59301);
|
|
// EXTERNAL MODULE: ./node_modules/_@ant-design_icons@5.6.1@@ant-design/icons/es/icons/CheckCircleFilled.js + 1 modules
|
|
var CheckCircleFilled = __webpack_require__(29679);
|
|
// EXTERNAL MODULE: ./node_modules/_@ant-design_icons@5.6.1@@ant-design/icons/es/icons/CheckOutlined.js + 1 modules
|
|
var CheckOutlined = __webpack_require__(40001);
|
|
// EXTERNAL MODULE: ./node_modules/_@ant-design_icons@5.6.1@@ant-design/icons/es/icons/CloseCircleFilled.js + 1 modules
|
|
var CloseCircleFilled = __webpack_require__(19248);
|
|
// EXTERNAL MODULE: ./node_modules/_@ant-design_icons@5.6.1@@ant-design/icons/es/icons/CloseOutlined.js + 1 modules
|
|
var CloseOutlined = __webpack_require__(99267);
|
|
// EXTERNAL MODULE: ./node_modules/_classnames@2.5.1@classnames/index.js
|
|
var _classnames_2_5_1_classnames = __webpack_require__(92310);
|
|
var _classnames_2_5_1_classnames_default = /*#__PURE__*/__webpack_require__.n(_classnames_2_5_1_classnames);
|
|
// EXTERNAL MODULE: ./node_modules/_rc-util@5.44.4@rc-util/es/omit.js
|
|
var omit = __webpack_require__(2738);
|
|
// EXTERNAL MODULE: ./node_modules/_antd@5.9.0@antd/es/config-provider/context.js
|
|
var context = __webpack_require__(36355);
|
|
// EXTERNAL MODULE: ./node_modules/_@babel_runtime@7.27.6@@babel/runtime/helpers/esm/extends.js
|
|
var esm_extends = __webpack_require__(14809);
|
|
// EXTERNAL MODULE: ./node_modules/_@babel_runtime@7.27.6@@babel/runtime/helpers/esm/objectSpread2.js
|
|
var objectSpread2 = __webpack_require__(20439);
|
|
// EXTERNAL MODULE: ./node_modules/_@babel_runtime@7.27.6@@babel/runtime/helpers/esm/objectWithoutProperties.js
|
|
var objectWithoutProperties = __webpack_require__(62646);
|
|
;// CONCATENATED MODULE: ./node_modules/_rc-progress@3.5.1@rc-progress/es/common.js
|
|
|
|
var defaultProps = {
|
|
percent: 0,
|
|
prefixCls: 'rc-progress',
|
|
strokeColor: '#2db7f5',
|
|
strokeLinecap: 'round',
|
|
strokeWidth: 1,
|
|
trailColor: '#D9D9D9',
|
|
trailWidth: 1,
|
|
gapPosition: 'bottom'
|
|
};
|
|
var useTransitionDuration = function useTransitionDuration() {
|
|
var pathsRef = (0,_react_17_0_2_react.useRef)([]);
|
|
var prevTimeStamp = (0,_react_17_0_2_react.useRef)(null);
|
|
(0,_react_17_0_2_react.useEffect)(function () {
|
|
var now = Date.now();
|
|
var updated = false;
|
|
pathsRef.current.forEach(function (path) {
|
|
if (!path) {
|
|
return;
|
|
}
|
|
updated = true;
|
|
var pathStyle = path.style;
|
|
pathStyle.transitionDuration = '.3s, .3s, .3s, .06s';
|
|
if (prevTimeStamp.current && now - prevTimeStamp.current < 100) {
|
|
pathStyle.transitionDuration = '0s, 0s';
|
|
}
|
|
});
|
|
if (updated) {
|
|
prevTimeStamp.current = Date.now();
|
|
}
|
|
});
|
|
return pathsRef.current;
|
|
};
|
|
;// CONCATENATED MODULE: ./node_modules/_rc-progress@3.5.1@rc-progress/es/Line.js
|
|
|
|
|
|
|
|
var _excluded = ["className", "percent", "prefixCls", "strokeColor", "strokeLinecap", "strokeWidth", "style", "trailColor", "trailWidth", "transition"];
|
|
|
|
|
|
|
|
var Line = function Line(props) {
|
|
var _defaultProps$props = (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, defaultProps), props),
|
|
className = _defaultProps$props.className,
|
|
percent = _defaultProps$props.percent,
|
|
prefixCls = _defaultProps$props.prefixCls,
|
|
strokeColor = _defaultProps$props.strokeColor,
|
|
strokeLinecap = _defaultProps$props.strokeLinecap,
|
|
strokeWidth = _defaultProps$props.strokeWidth,
|
|
style = _defaultProps$props.style,
|
|
trailColor = _defaultProps$props.trailColor,
|
|
trailWidth = _defaultProps$props.trailWidth,
|
|
transition = _defaultProps$props.transition,
|
|
restProps = (0,objectWithoutProperties/* default */.Z)(_defaultProps$props, _excluded);
|
|
// eslint-disable-next-line no-param-reassign
|
|
delete restProps.gapPosition;
|
|
var percentList = Array.isArray(percent) ? percent : [percent];
|
|
var strokeColorList = Array.isArray(strokeColor) ? strokeColor : [strokeColor];
|
|
var paths = useTransitionDuration();
|
|
var center = strokeWidth / 2;
|
|
var right = 100 - strokeWidth / 2;
|
|
var pathString = "M ".concat(strokeLinecap === 'round' ? center : 0, ",").concat(center, "\n L ").concat(strokeLinecap === 'round' ? right : 100, ",").concat(center);
|
|
var viewBoxString = "0 0 100 ".concat(strokeWidth);
|
|
var stackPtg = 0;
|
|
return /*#__PURE__*/_react_17_0_2_react.createElement("svg", (0,esm_extends/* default */.Z)({
|
|
className: _classnames_2_5_1_classnames_default()("".concat(prefixCls, "-line"), className),
|
|
viewBox: viewBoxString,
|
|
preserveAspectRatio: "none",
|
|
style: style
|
|
}, restProps), /*#__PURE__*/_react_17_0_2_react.createElement("path", {
|
|
className: "".concat(prefixCls, "-line-trail"),
|
|
d: pathString,
|
|
strokeLinecap: strokeLinecap,
|
|
stroke: trailColor,
|
|
strokeWidth: trailWidth || strokeWidth,
|
|
fillOpacity: "0"
|
|
}), percentList.map(function (ptg, index) {
|
|
var dashPercent = 1;
|
|
switch (strokeLinecap) {
|
|
case 'round':
|
|
dashPercent = 1 - strokeWidth / 100;
|
|
break;
|
|
case 'square':
|
|
dashPercent = 1 - strokeWidth / 2 / 100;
|
|
break;
|
|
default:
|
|
dashPercent = 1;
|
|
break;
|
|
}
|
|
var pathStyle = {
|
|
strokeDasharray: "".concat(ptg * dashPercent, "px, 100px"),
|
|
strokeDashoffset: "-".concat(stackPtg, "px"),
|
|
transition: transition || 'stroke-dashoffset 0.3s ease 0s, stroke-dasharray .3s ease 0s, stroke 0.3s linear'
|
|
};
|
|
var color = strokeColorList[index] || strokeColorList[strokeColorList.length - 1];
|
|
stackPtg += ptg;
|
|
return /*#__PURE__*/_react_17_0_2_react.createElement("path", {
|
|
key: index,
|
|
className: "".concat(prefixCls, "-line-path"),
|
|
d: pathString,
|
|
strokeLinecap: strokeLinecap,
|
|
stroke: color,
|
|
strokeWidth: strokeWidth,
|
|
fillOpacity: "0",
|
|
ref: function ref(elem) {
|
|
// https://reactjs.org/docs/refs-and-the-dom.html#callback-refs
|
|
// React will call the ref callback with the DOM element when the component mounts,
|
|
// and call it with `null` when it unmounts.
|
|
// Refs are guaranteed to be up-to-date before componentDidMount or componentDidUpdate fires.
|
|
paths[index] = elem;
|
|
},
|
|
style: pathStyle
|
|
});
|
|
}));
|
|
};
|
|
if (false) {}
|
|
/* harmony default export */ var es_Line = (Line);
|
|
// EXTERNAL MODULE: ./node_modules/_@babel_runtime@7.27.6@@babel/runtime/helpers/esm/typeof.js
|
|
var esm_typeof = __webpack_require__(93664);
|
|
// EXTERNAL MODULE: ./node_modules/_@babel_runtime@7.27.6@@babel/runtime/helpers/esm/slicedToArray.js + 1 modules
|
|
var slicedToArray = __webpack_require__(50298);
|
|
// EXTERNAL MODULE: ./node_modules/_rc-util@5.44.4@rc-util/es/Dom/canUseDom.js
|
|
var canUseDom = __webpack_require__(47273);
|
|
;// CONCATENATED MODULE: ./node_modules/_rc-progress@3.5.1@rc-progress/es/hooks/useId.js
|
|
|
|
|
|
|
|
var uuid = 0;
|
|
/** Is client side and not jsdom */
|
|
var isBrowserClient = true && (0,canUseDom/* default */.Z)();
|
|
/** Get unique id for accessibility usage */
|
|
function getUUID() {
|
|
var retId;
|
|
// Test never reach
|
|
/* istanbul ignore if */
|
|
if (isBrowserClient) {
|
|
retId = uuid;
|
|
uuid += 1;
|
|
} else {
|
|
retId = 'TEST_OR_SSR';
|
|
}
|
|
return retId;
|
|
}
|
|
/* harmony default export */ var useId = (function (id) {
|
|
// Inner id for accessibility usage. Only work in client side
|
|
var _React$useState = _react_17_0_2_react.useState(),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
innerId = _React$useState2[0],
|
|
setInnerId = _React$useState2[1];
|
|
_react_17_0_2_react.useEffect(function () {
|
|
setInnerId("rc_progress_".concat(getUUID()));
|
|
}, []);
|
|
return id || innerId;
|
|
});
|
|
;// CONCATENATED MODULE: ./node_modules/_rc-progress@3.5.1@rc-progress/es/Circle/PtgCircle.js
|
|
|
|
|
|
var Block = function Block(_ref) {
|
|
var bg = _ref.bg,
|
|
children = _ref.children;
|
|
return /*#__PURE__*/_react_17_0_2_react.createElement("div", {
|
|
style: {
|
|
width: '100%',
|
|
height: '100%',
|
|
background: bg
|
|
}
|
|
}, children);
|
|
};
|
|
function getPtgColors(color, scale) {
|
|
return Object.keys(color).map(function (key) {
|
|
var parsedKey = parseFloat(key);
|
|
var ptgKey = "".concat(Math.floor(parsedKey * scale), "%");
|
|
return "".concat(color[key], " ").concat(ptgKey);
|
|
});
|
|
}
|
|
var PtgCircle = /*#__PURE__*/_react_17_0_2_react.forwardRef(function (props, ref) {
|
|
var prefixCls = props.prefixCls,
|
|
color = props.color,
|
|
gradientId = props.gradientId,
|
|
radius = props.radius,
|
|
circleStyleForStack = props.style,
|
|
ptg = props.ptg,
|
|
strokeLinecap = props.strokeLinecap,
|
|
strokeWidth = props.strokeWidth,
|
|
size = props.size,
|
|
gapDegree = props.gapDegree;
|
|
var isGradient = color && (0,esm_typeof/* default */.Z)(color) === 'object';
|
|
var stroke = isGradient ? "#FFF" : undefined;
|
|
// ========================== Circle ==========================
|
|
var halfSize = size / 2;
|
|
var circleNode = /*#__PURE__*/_react_17_0_2_react.createElement("circle", {
|
|
className: "".concat(prefixCls, "-circle-path"),
|
|
r: radius,
|
|
cx: halfSize,
|
|
cy: halfSize,
|
|
stroke: stroke,
|
|
strokeLinecap: strokeLinecap,
|
|
strokeWidth: strokeWidth,
|
|
opacity: ptg === 0 ? 0 : 1,
|
|
style: circleStyleForStack,
|
|
ref: ref
|
|
});
|
|
// ========================== Render ==========================
|
|
if (!isGradient) {
|
|
return circleNode;
|
|
}
|
|
var maskId = "".concat(gradientId, "-conic");
|
|
var fromDeg = gapDegree ? "".concat(180 + gapDegree / 2, "deg") : '0deg';
|
|
var conicColors = getPtgColors(color, (360 - gapDegree) / 360);
|
|
var linearColors = getPtgColors(color, 1);
|
|
var conicColorBg = "conic-gradient(from ".concat(fromDeg, ", ").concat(conicColors.join(', '), ")");
|
|
var linearColorBg = "linear-gradient(to ".concat(gapDegree ? 'bottom' : 'top', ", ").concat(linearColors.join(', '), ")");
|
|
return /*#__PURE__*/_react_17_0_2_react.createElement(_react_17_0_2_react.Fragment, null, /*#__PURE__*/_react_17_0_2_react.createElement("mask", {
|
|
id: maskId
|
|
}, circleNode), /*#__PURE__*/_react_17_0_2_react.createElement("foreignObject", {
|
|
x: 0,
|
|
y: 0,
|
|
width: size,
|
|
height: size,
|
|
mask: "url(#".concat(maskId, ")")
|
|
}, /*#__PURE__*/_react_17_0_2_react.createElement(Block, {
|
|
bg: linearColorBg
|
|
}, /*#__PURE__*/_react_17_0_2_react.createElement(Block, {
|
|
bg: conicColorBg
|
|
}))));
|
|
});
|
|
if (false) {}
|
|
/* harmony default export */ var Circle_PtgCircle = (PtgCircle);
|
|
;// CONCATENATED MODULE: ./node_modules/_rc-progress@3.5.1@rc-progress/es/Circle/util.js
|
|
var VIEW_BOX_SIZE = 100;
|
|
var getCircleStyle = function getCircleStyle(perimeter, perimeterWithoutGap, offset, percent, rotateDeg, gapDegree, gapPosition, strokeColor, strokeLinecap, strokeWidth) {
|
|
var stepSpace = arguments.length > 10 && arguments[10] !== undefined ? arguments[10] : 0;
|
|
var offsetDeg = offset / 100 * 360 * ((360 - gapDegree) / 360);
|
|
var positionDeg = gapDegree === 0 ? 0 : {
|
|
bottom: 0,
|
|
top: 180,
|
|
left: 90,
|
|
right: -90
|
|
}[gapPosition];
|
|
var strokeDashoffset = (100 - percent) / 100 * perimeterWithoutGap;
|
|
// Fix percent accuracy when strokeLinecap is round
|
|
// https://github.com/ant-design/ant-design/issues/35009
|
|
if (strokeLinecap === 'round' && percent !== 100) {
|
|
strokeDashoffset += strokeWidth / 2;
|
|
// when percent is small enough (<= 1%), keep smallest value to avoid it's disappearance
|
|
if (strokeDashoffset >= perimeterWithoutGap) {
|
|
strokeDashoffset = perimeterWithoutGap - 0.01;
|
|
}
|
|
}
|
|
var halfSize = VIEW_BOX_SIZE / 2;
|
|
return {
|
|
stroke: typeof strokeColor === 'string' ? strokeColor : undefined,
|
|
strokeDasharray: "".concat(perimeterWithoutGap, "px ").concat(perimeter),
|
|
strokeDashoffset: strokeDashoffset + stepSpace,
|
|
transform: "rotate(".concat(rotateDeg + offsetDeg + positionDeg, "deg)"),
|
|
transformOrigin: "".concat(halfSize, "px ").concat(halfSize, "px"),
|
|
transition: 'stroke-dashoffset .3s ease 0s, stroke-dasharray .3s ease 0s, stroke .3s, stroke-width .06s ease .3s, opacity .3s ease 0s',
|
|
fillOpacity: 0
|
|
};
|
|
};
|
|
;// CONCATENATED MODULE: ./node_modules/_rc-progress@3.5.1@rc-progress/es/Circle/index.js
|
|
|
|
|
|
|
|
|
|
var Circle_excluded = ["id", "prefixCls", "steps", "strokeWidth", "trailWidth", "gapDegree", "gapPosition", "trailColor", "strokeLinecap", "style", "className", "strokeColor", "percent"];
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function toArray(value) {
|
|
var mergedValue = value !== null && value !== void 0 ? value : [];
|
|
return Array.isArray(mergedValue) ? mergedValue : [mergedValue];
|
|
}
|
|
var Circle = function Circle(props) {
|
|
var _defaultProps$props = (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, defaultProps), props),
|
|
id = _defaultProps$props.id,
|
|
prefixCls = _defaultProps$props.prefixCls,
|
|
steps = _defaultProps$props.steps,
|
|
strokeWidth = _defaultProps$props.strokeWidth,
|
|
trailWidth = _defaultProps$props.trailWidth,
|
|
_defaultProps$props$g = _defaultProps$props.gapDegree,
|
|
gapDegree = _defaultProps$props$g === void 0 ? 0 : _defaultProps$props$g,
|
|
gapPosition = _defaultProps$props.gapPosition,
|
|
trailColor = _defaultProps$props.trailColor,
|
|
strokeLinecap = _defaultProps$props.strokeLinecap,
|
|
style = _defaultProps$props.style,
|
|
className = _defaultProps$props.className,
|
|
strokeColor = _defaultProps$props.strokeColor,
|
|
percent = _defaultProps$props.percent,
|
|
restProps = (0,objectWithoutProperties/* default */.Z)(_defaultProps$props, Circle_excluded);
|
|
var halfSize = VIEW_BOX_SIZE / 2;
|
|
var mergedId = useId(id);
|
|
var gradientId = "".concat(mergedId, "-gradient");
|
|
var radius = halfSize - strokeWidth / 2;
|
|
var perimeter = Math.PI * 2 * radius;
|
|
var rotateDeg = gapDegree > 0 ? 90 + gapDegree / 2 : -90;
|
|
var perimeterWithoutGap = perimeter * ((360 - gapDegree) / 360);
|
|
var _ref = (0,esm_typeof/* default */.Z)(steps) === 'object' ? steps : {
|
|
count: steps,
|
|
space: 2
|
|
},
|
|
stepCount = _ref.count,
|
|
stepSpace = _ref.space;
|
|
var percentList = toArray(percent);
|
|
var strokeColorList = toArray(strokeColor);
|
|
var gradient = strokeColorList.find(function (color) {
|
|
return color && (0,esm_typeof/* default */.Z)(color) === 'object';
|
|
});
|
|
var isConicGradient = gradient && (0,esm_typeof/* default */.Z)(gradient) === 'object';
|
|
var mergedStrokeLinecap = isConicGradient ? 'butt' : strokeLinecap;
|
|
var circleStyle = getCircleStyle(perimeter, perimeterWithoutGap, 0, 100, rotateDeg, gapDegree, gapPosition, trailColor, mergedStrokeLinecap, strokeWidth);
|
|
var paths = useTransitionDuration();
|
|
var getStokeList = function getStokeList() {
|
|
var stackPtg = 0;
|
|
return percentList.map(function (ptg, index) {
|
|
var color = strokeColorList[index] || strokeColorList[strokeColorList.length - 1];
|
|
var circleStyleForStack = getCircleStyle(perimeter, perimeterWithoutGap, stackPtg, ptg, rotateDeg, gapDegree, gapPosition, color, mergedStrokeLinecap, strokeWidth);
|
|
stackPtg += ptg;
|
|
return /*#__PURE__*/_react_17_0_2_react.createElement(Circle_PtgCircle, {
|
|
key: index,
|
|
color: color,
|
|
ptg: ptg,
|
|
radius: radius,
|
|
prefixCls: prefixCls,
|
|
gradientId: gradientId,
|
|
style: circleStyleForStack,
|
|
strokeLinecap: mergedStrokeLinecap,
|
|
strokeWidth: strokeWidth,
|
|
gapDegree: gapDegree,
|
|
ref: function ref(elem) {
|
|
// https://reactjs.org/docs/refs-and-the-dom.html#callback-refs
|
|
// React will call the ref callback with the DOM element when the component mounts,
|
|
// and call it with `null` when it unmounts.
|
|
// Refs are guaranteed to be up-to-date before componentDidMount or componentDidUpdate fires.
|
|
paths[index] = elem;
|
|
},
|
|
size: VIEW_BOX_SIZE
|
|
});
|
|
}).reverse();
|
|
};
|
|
var getStepStokeList = function getStepStokeList() {
|
|
// only show the first percent when pass steps
|
|
var current = Math.round(stepCount * (percentList[0] / 100));
|
|
var stepPtg = 100 / stepCount;
|
|
var stackPtg = 0;
|
|
return new Array(stepCount).fill(null).map(function (_, index) {
|
|
var color = index <= current - 1 ? strokeColorList[0] : trailColor;
|
|
var stroke = color && (0,esm_typeof/* default */.Z)(color) === 'object' ? "url(#".concat(gradientId, ")") : undefined;
|
|
var circleStyleForStack = getCircleStyle(perimeter, perimeterWithoutGap, stackPtg, stepPtg, rotateDeg, gapDegree, gapPosition, color, 'butt', strokeWidth, stepSpace);
|
|
stackPtg += (perimeterWithoutGap - circleStyleForStack.strokeDashoffset + stepSpace) * 100 / perimeterWithoutGap;
|
|
return /*#__PURE__*/_react_17_0_2_react.createElement("circle", {
|
|
key: index,
|
|
className: "".concat(prefixCls, "-circle-path"),
|
|
r: radius,
|
|
cx: halfSize,
|
|
cy: halfSize,
|
|
stroke: stroke,
|
|
strokeWidth: strokeWidth,
|
|
opacity: 1,
|
|
style: circleStyleForStack,
|
|
ref: function ref(elem) {
|
|
paths[index] = elem;
|
|
}
|
|
});
|
|
});
|
|
};
|
|
return /*#__PURE__*/_react_17_0_2_react.createElement("svg", (0,esm_extends/* default */.Z)({
|
|
className: _classnames_2_5_1_classnames_default()("".concat(prefixCls, "-circle"), className),
|
|
viewBox: "0 0 ".concat(VIEW_BOX_SIZE, " ").concat(VIEW_BOX_SIZE),
|
|
style: style,
|
|
id: id,
|
|
role: "presentation"
|
|
}, restProps), !stepCount && /*#__PURE__*/_react_17_0_2_react.createElement("circle", {
|
|
className: "".concat(prefixCls, "-circle-trail"),
|
|
r: radius,
|
|
cx: halfSize,
|
|
cy: halfSize,
|
|
stroke: trailColor,
|
|
strokeLinecap: mergedStrokeLinecap,
|
|
strokeWidth: trailWidth || strokeWidth,
|
|
style: circleStyle
|
|
}), stepCount ? getStepStokeList() : getStokeList());
|
|
};
|
|
if (false) {}
|
|
/* harmony default export */ var es_Circle = (Circle);
|
|
;// CONCATENATED MODULE: ./node_modules/_rc-progress@3.5.1@rc-progress/es/index.js
|
|
|
|
|
|
|
|
/* harmony default export */ var es = ({
|
|
Line: es_Line,
|
|
Circle: es_Circle
|
|
});
|
|
// EXTERNAL MODULE: ./node_modules/_antd@5.9.0@antd/es/tooltip/index.js + 3 modules
|
|
var tooltip = __webpack_require__(6848);
|
|
// EXTERNAL MODULE: ./node_modules/_@ant-design_colors@7.2.1@@ant-design/colors/es/index.js + 4 modules
|
|
var colors_es = __webpack_require__(30071);
|
|
;// CONCATENATED MODULE: ./node_modules/_antd@5.9.0@antd/es/progress/utils.js
|
|
|
|
|
|
function validProgress(progress) {
|
|
if (!progress || progress < 0) {
|
|
return 0;
|
|
}
|
|
if (progress > 100) {
|
|
return 100;
|
|
}
|
|
return progress;
|
|
}
|
|
function getSuccessPercent(_ref) {
|
|
let {
|
|
success,
|
|
successPercent
|
|
} = _ref;
|
|
let percent = successPercent;
|
|
/** @deprecated Use `percent` instead */
|
|
if (success && 'progress' in success) {
|
|
false ? 0 : void 0;
|
|
percent = success.progress;
|
|
}
|
|
if (success && 'percent' in success) {
|
|
percent = success.percent;
|
|
}
|
|
return percent;
|
|
}
|
|
const getPercentage = _ref2 => {
|
|
let {
|
|
percent,
|
|
success,
|
|
successPercent
|
|
} = _ref2;
|
|
const realSuccessPercent = validProgress(getSuccessPercent({
|
|
success,
|
|
successPercent
|
|
}));
|
|
return [realSuccessPercent, validProgress(validProgress(percent) - realSuccessPercent)];
|
|
};
|
|
const getStrokeColor = _ref3 => {
|
|
let {
|
|
success = {},
|
|
strokeColor
|
|
} = _ref3;
|
|
const {
|
|
strokeColor: successColor
|
|
} = success;
|
|
return [successColor || colors_es.presetPrimaryColors.green, strokeColor || null];
|
|
};
|
|
const getSize = (size, type, extra) => {
|
|
var _a, _b, _c, _d;
|
|
let width = -1;
|
|
let height = -1;
|
|
if (type === 'step') {
|
|
const steps = extra.steps;
|
|
const strokeWidth = extra.strokeWidth;
|
|
if (typeof size === 'string' || typeof size === 'undefined') {
|
|
width = size === 'small' ? 2 : 14;
|
|
height = strokeWidth !== null && strokeWidth !== void 0 ? strokeWidth : 8;
|
|
} else if (typeof size === 'number') {
|
|
[width, height] = [size, size];
|
|
} else {
|
|
[width = 14, height = 8] = size;
|
|
}
|
|
width *= steps;
|
|
} else if (type === 'line') {
|
|
const strokeWidth = extra === null || extra === void 0 ? void 0 : extra.strokeWidth;
|
|
if (typeof size === 'string' || typeof size === 'undefined') {
|
|
height = strokeWidth || (size === 'small' ? 6 : 8);
|
|
} else if (typeof size === 'number') {
|
|
[width, height] = [size, size];
|
|
} else {
|
|
[width = -1, height = 8] = size;
|
|
}
|
|
} else if (type === 'circle' || type === 'dashboard') {
|
|
if (typeof size === 'string' || typeof size === 'undefined') {
|
|
[width, height] = size === 'small' ? [60, 60] : [120, 120];
|
|
} else if (typeof size === 'number') {
|
|
[width, height] = [size, size];
|
|
} else {
|
|
if (false) {}
|
|
width = (_b = (_a = size[0]) !== null && _a !== void 0 ? _a : size[1]) !== null && _b !== void 0 ? _b : 120;
|
|
height = (_d = (_c = size[0]) !== null && _c !== void 0 ? _c : size[1]) !== null && _d !== void 0 ? _d : 120;
|
|
}
|
|
}
|
|
return [width, height];
|
|
};
|
|
;// CONCATENATED MODULE: ./node_modules/_antd@5.9.0@antd/es/progress/Circle.js
|
|
"use client";
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const CIRCLE_MIN_STROKE_WIDTH = 3;
|
|
const getMinPercent = width => CIRCLE_MIN_STROKE_WIDTH / width * 100;
|
|
const Circle_Circle = props => {
|
|
const {
|
|
prefixCls,
|
|
trailColor = null,
|
|
strokeLinecap = 'round',
|
|
gapPosition,
|
|
gapDegree,
|
|
width: originWidth = 120,
|
|
type,
|
|
children,
|
|
success,
|
|
size = originWidth
|
|
} = props;
|
|
const [width, height] = getSize(size, 'circle');
|
|
let {
|
|
strokeWidth
|
|
} = props;
|
|
if (strokeWidth === undefined) {
|
|
strokeWidth = Math.max(getMinPercent(width), 6);
|
|
}
|
|
const circleStyle = {
|
|
width,
|
|
height,
|
|
fontSize: width * 0.15 + 6
|
|
};
|
|
const realGapDegree = _react_17_0_2_react.useMemo(() => {
|
|
// Support gapDeg = 0 when type = 'dashboard'
|
|
if (gapDegree || gapDegree === 0) {
|
|
return gapDegree;
|
|
}
|
|
if (type === 'dashboard') {
|
|
return 75;
|
|
}
|
|
return undefined;
|
|
}, [gapDegree, type]);
|
|
const gapPos = gapPosition || type === 'dashboard' && 'bottom' || undefined;
|
|
// using className to style stroke color
|
|
const isGradient = Object.prototype.toString.call(props.strokeColor) === '[object Object]';
|
|
const strokeColor = getStrokeColor({
|
|
success,
|
|
strokeColor: props.strokeColor
|
|
});
|
|
const wrapperClassName = _classnames_2_5_1_classnames_default()(`${prefixCls}-inner`, {
|
|
[`${prefixCls}-circle-gradient`]: isGradient
|
|
});
|
|
const circleContent = /*#__PURE__*/_react_17_0_2_react.createElement(es_Circle, {
|
|
percent: getPercentage(props),
|
|
strokeWidth: strokeWidth,
|
|
trailWidth: strokeWidth,
|
|
strokeColor: strokeColor,
|
|
strokeLinecap: strokeLinecap,
|
|
trailColor: trailColor,
|
|
prefixCls: prefixCls,
|
|
gapDegree: realGapDegree,
|
|
gapPosition: gapPos
|
|
});
|
|
return /*#__PURE__*/_react_17_0_2_react.createElement("div", {
|
|
className: wrapperClassName,
|
|
style: circleStyle
|
|
}, width <= 20 ? /*#__PURE__*/_react_17_0_2_react.createElement(tooltip/* default */.Z, {
|
|
title: children
|
|
}, /*#__PURE__*/_react_17_0_2_react.createElement("span", null, circleContent)) : /*#__PURE__*/_react_17_0_2_react.createElement(_react_17_0_2_react.Fragment, null, circleContent, children));
|
|
};
|
|
/* harmony default export */ var progress_Circle = (Circle_Circle);
|
|
;// CONCATENATED MODULE: ./node_modules/_antd@5.9.0@antd/es/progress/Line.js
|
|
"use client";
|
|
|
|
var __rest = undefined && undefined.__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;
|
|
};
|
|
|
|
|
|
|
|
|
|
/**
|
|
* @example
|
|
* {
|
|
* "0%": "#afc163",
|
|
* "75%": "#009900",
|
|
* "50%": "green", // ====> '#afc163 0%, #66FF00 25%, #00CC00 50%, #009900 75%, #ffffff 100%'
|
|
* "25%": "#66FF00",
|
|
* "100%": "#ffffff"
|
|
* }
|
|
*/
|
|
const sortGradient = gradients => {
|
|
let tempArr = [];
|
|
Object.keys(gradients).forEach(key => {
|
|
const formattedKey = parseFloat(key.replace(/%/g, ''));
|
|
if (!isNaN(formattedKey)) {
|
|
tempArr.push({
|
|
key: formattedKey,
|
|
value: gradients[key]
|
|
});
|
|
}
|
|
});
|
|
tempArr = tempArr.sort((a, b) => a.key - b.key);
|
|
return tempArr.map(_ref => {
|
|
let {
|
|
key,
|
|
value
|
|
} = _ref;
|
|
return `${value} ${key}%`;
|
|
}).join(', ');
|
|
};
|
|
/**
|
|
* 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.
|
|
*
|
|
* @example
|
|
* {
|
|
* "0%": "#afc163",
|
|
* "25%": "#66FF00",
|
|
* "50%": "#00CC00", // ====> linear-gradient(to right, #afc163 0%, #66FF00 25%,
|
|
* "75%": "#009900", // #00CC00 50%, #009900 75%, #ffffff 100%)
|
|
* "100%": "#ffffff"
|
|
* }
|
|
*/
|
|
const handleGradient = (strokeColor, directionConfig) => {
|
|
const {
|
|
from = colors_es.presetPrimaryColors.blue,
|
|
to = colors_es.presetPrimaryColors.blue,
|
|
direction = directionConfig === 'rtl' ? 'to left' : 'to right'
|
|
} = strokeColor,
|
|
rest = __rest(strokeColor, ["from", "to", "direction"]);
|
|
if (Object.keys(rest).length !== 0) {
|
|
const sortedGradients = sortGradient(rest);
|
|
return {
|
|
backgroundImage: `linear-gradient(${direction}, ${sortedGradients})`
|
|
};
|
|
}
|
|
return {
|
|
backgroundImage: `linear-gradient(${direction}, ${from}, ${to})`
|
|
};
|
|
};
|
|
const Line_Line = props => {
|
|
const {
|
|
prefixCls,
|
|
direction: directionConfig,
|
|
percent,
|
|
size,
|
|
strokeWidth,
|
|
strokeColor,
|
|
strokeLinecap = 'round',
|
|
children,
|
|
trailColor = null,
|
|
success
|
|
} = props;
|
|
const backgroundProps = strokeColor && typeof strokeColor !== 'string' ? handleGradient(strokeColor, directionConfig) : {
|
|
backgroundColor: strokeColor
|
|
};
|
|
const borderRadius = strokeLinecap === 'square' || strokeLinecap === 'butt' ? 0 : undefined;
|
|
const trailStyle = {
|
|
backgroundColor: trailColor || undefined,
|
|
borderRadius
|
|
};
|
|
const mergedSize = size !== null && size !== void 0 ? size : [-1, strokeWidth || (size === 'small' ? 6 : 8)];
|
|
const [width, height] = getSize(mergedSize, 'line', {
|
|
strokeWidth
|
|
});
|
|
if (false) {}
|
|
const percentStyle = Object.assign({
|
|
width: `${validProgress(percent)}%`,
|
|
height,
|
|
borderRadius
|
|
}, backgroundProps);
|
|
const successPercent = getSuccessPercent(props);
|
|
const successPercentStyle = {
|
|
width: `${validProgress(successPercent)}%`,
|
|
height,
|
|
borderRadius,
|
|
backgroundColor: success === null || success === void 0 ? void 0 : success.strokeColor
|
|
};
|
|
const outerStyle = {
|
|
width: width < 0 ? '100%' : width,
|
|
height
|
|
};
|
|
return /*#__PURE__*/_react_17_0_2_react.createElement(_react_17_0_2_react.Fragment, null, /*#__PURE__*/_react_17_0_2_react.createElement("div", {
|
|
className: `${prefixCls}-outer`,
|
|
style: outerStyle
|
|
}, /*#__PURE__*/_react_17_0_2_react.createElement("div", {
|
|
className: `${prefixCls}-inner`,
|
|
style: trailStyle
|
|
}, /*#__PURE__*/_react_17_0_2_react.createElement("div", {
|
|
className: `${prefixCls}-bg`,
|
|
style: percentStyle
|
|
}), successPercent !== undefined ? /*#__PURE__*/_react_17_0_2_react.createElement("div", {
|
|
className: `${prefixCls}-success-bg`,
|
|
style: successPercentStyle
|
|
}) : null)), children);
|
|
};
|
|
/* harmony default export */ var progress_Line = (Line_Line);
|
|
;// CONCATENATED MODULE: ./node_modules/_antd@5.9.0@antd/es/progress/Steps.js
|
|
"use client";
|
|
|
|
|
|
|
|
|
|
const Steps = props => {
|
|
const {
|
|
size,
|
|
steps,
|
|
percent = 0,
|
|
strokeWidth = 8,
|
|
strokeColor,
|
|
trailColor = null,
|
|
prefixCls,
|
|
children
|
|
} = props;
|
|
const current = Math.round(steps * (percent / 100));
|
|
const stepWidth = size === 'small' ? 2 : 14;
|
|
const mergedSize = size !== null && size !== void 0 ? size : [stepWidth, strokeWidth];
|
|
const [width, height] = getSize(mergedSize, 'step', {
|
|
steps,
|
|
strokeWidth
|
|
});
|
|
const unitWidth = width / steps;
|
|
const styledSteps = new Array(steps);
|
|
for (let i = 0; i < steps; i++) {
|
|
const color = Array.isArray(strokeColor) ? strokeColor[i] : strokeColor;
|
|
styledSteps[i] = /*#__PURE__*/_react_17_0_2_react.createElement("div", {
|
|
key: i,
|
|
className: _classnames_2_5_1_classnames_default()(`${prefixCls}-steps-item`, {
|
|
[`${prefixCls}-steps-item-active`]: i <= current - 1
|
|
}),
|
|
style: {
|
|
backgroundColor: i <= current - 1 ? color : trailColor,
|
|
width: unitWidth,
|
|
height
|
|
}
|
|
});
|
|
}
|
|
return /*#__PURE__*/_react_17_0_2_react.createElement("div", {
|
|
className: `${prefixCls}-steps-outer`
|
|
}, styledSteps, children);
|
|
};
|
|
/* harmony default export */ var progress_Steps = (Steps);
|
|
// EXTERNAL MODULE: ./node_modules/_@ant-design_cssinjs@1.24.0@@ant-design/cssinjs/es/index.js + 39 modules
|
|
var cssinjs_es = __webpack_require__(36237);
|
|
// EXTERNAL MODULE: ./node_modules/_antd@5.9.0@antd/es/style/index.js
|
|
var style = __webpack_require__(17313);
|
|
// EXTERNAL MODULE: ./node_modules/_antd@5.9.0@antd/es/theme/util/genComponentStyleHook.js
|
|
var genComponentStyleHook = __webpack_require__(83116);
|
|
// EXTERNAL MODULE: ./node_modules/_antd@5.9.0@antd/es/theme/util/statistic.js
|
|
var statistic = __webpack_require__(37613);
|
|
;// CONCATENATED MODULE: ./node_modules/_antd@5.9.0@antd/es/progress/style/index.js
|
|
"use client";
|
|
|
|
|
|
|
|
|
|
const genAntProgressActive = isRtl => {
|
|
const direction = isRtl ? '100%' : '-100%';
|
|
return new cssinjs_es.Keyframes(`antProgress${isRtl ? 'RTL' : 'LTR'}Active`, {
|
|
'0%': {
|
|
transform: `translateX(${direction}) scaleX(0)`,
|
|
opacity: 0.1
|
|
},
|
|
'20%': {
|
|
transform: `translateX(${direction}) scaleX(0)`,
|
|
opacity: 0.5
|
|
},
|
|
to: {
|
|
transform: 'translateX(0) scaleX(1)',
|
|
opacity: 0
|
|
}
|
|
});
|
|
};
|
|
const genBaseStyle = token => {
|
|
const {
|
|
componentCls: progressCls,
|
|
iconCls: iconPrefixCls
|
|
} = token;
|
|
return {
|
|
[progressCls]: Object.assign(Object.assign({}, (0,style/* resetComponent */.Wf)(token)), {
|
|
display: 'inline-block',
|
|
'&-rtl': {
|
|
direction: 'rtl'
|
|
},
|
|
'&-line': {
|
|
position: 'relative',
|
|
width: '100%',
|
|
fontSize: token.fontSize,
|
|
marginInlineEnd: token.marginXS,
|
|
marginBottom: token.marginXS
|
|
},
|
|
[`${progressCls}-outer`]: {
|
|
display: 'inline-block',
|
|
width: '100%'
|
|
},
|
|
[`&${progressCls}-show-info`]: {
|
|
[`${progressCls}-outer`]: {
|
|
marginInlineEnd: `calc(-2em - ${token.marginXS}px)`,
|
|
paddingInlineEnd: `calc(2em + ${token.paddingXS}px)`
|
|
}
|
|
},
|
|
[`${progressCls}-inner`]: {
|
|
position: 'relative',
|
|
display: 'inline-block',
|
|
width: '100%',
|
|
overflow: 'hidden',
|
|
verticalAlign: 'middle',
|
|
backgroundColor: token.remainingColor,
|
|
borderRadius: token.lineBorderRadius
|
|
},
|
|
[`${progressCls}-inner:not(${progressCls}-circle-gradient)`]: {
|
|
[`${progressCls}-circle-path`]: {
|
|
stroke: token.defaultColor
|
|
}
|
|
},
|
|
[`${progressCls}-success-bg, ${progressCls}-bg`]: {
|
|
position: 'relative',
|
|
backgroundColor: token.defaultColor,
|
|
borderRadius: token.lineBorderRadius,
|
|
transition: `all ${token.motionDurationSlow} ${token.motionEaseInOutCirc}`
|
|
},
|
|
[`${progressCls}-success-bg`]: {
|
|
position: 'absolute',
|
|
insetBlockStart: 0,
|
|
insetInlineStart: 0,
|
|
backgroundColor: token.colorSuccess
|
|
},
|
|
[`${progressCls}-text`]: {
|
|
display: 'inline-block',
|
|
width: '2em',
|
|
marginInlineStart: token.marginXS,
|
|
color: token.colorText,
|
|
lineHeight: 1,
|
|
whiteSpace: 'nowrap',
|
|
textAlign: 'start',
|
|
verticalAlign: 'middle',
|
|
wordBreak: 'normal',
|
|
[iconPrefixCls]: {
|
|
fontSize: token.fontSize
|
|
}
|
|
},
|
|
[`&${progressCls}-status-active`]: {
|
|
[`${progressCls}-bg::before`]: {
|
|
position: 'absolute',
|
|
inset: 0,
|
|
backgroundColor: token.colorBgContainer,
|
|
borderRadius: token.lineBorderRadius,
|
|
opacity: 0,
|
|
animationName: genAntProgressActive(),
|
|
animationDuration: token.progressActiveMotionDuration,
|
|
animationTimingFunction: token.motionEaseOutQuint,
|
|
animationIterationCount: 'infinite',
|
|
content: '""'
|
|
}
|
|
},
|
|
[`&${progressCls}-rtl${progressCls}-status-active`]: {
|
|
[`${progressCls}-bg::before`]: {
|
|
animationName: genAntProgressActive(true)
|
|
}
|
|
},
|
|
[`&${progressCls}-status-exception`]: {
|
|
[`${progressCls}-bg`]: {
|
|
backgroundColor: token.colorError
|
|
},
|
|
[`${progressCls}-text`]: {
|
|
color: token.colorError
|
|
}
|
|
},
|
|
[`&${progressCls}-status-exception ${progressCls}-inner:not(${progressCls}-circle-gradient)`]: {
|
|
[`${progressCls}-circle-path`]: {
|
|
stroke: token.colorError
|
|
}
|
|
},
|
|
[`&${progressCls}-status-success`]: {
|
|
[`${progressCls}-bg`]: {
|
|
backgroundColor: token.colorSuccess
|
|
},
|
|
[`${progressCls}-text`]: {
|
|
color: token.colorSuccess
|
|
}
|
|
},
|
|
[`&${progressCls}-status-success ${progressCls}-inner:not(${progressCls}-circle-gradient)`]: {
|
|
[`${progressCls}-circle-path`]: {
|
|
stroke: token.colorSuccess
|
|
}
|
|
}
|
|
})
|
|
};
|
|
};
|
|
const genCircleStyle = token => {
|
|
const {
|
|
componentCls: progressCls,
|
|
iconCls: iconPrefixCls
|
|
} = token;
|
|
return {
|
|
[progressCls]: {
|
|
[`${progressCls}-circle-trail`]: {
|
|
stroke: token.remainingColor
|
|
},
|
|
[`&${progressCls}-circle ${progressCls}-inner`]: {
|
|
position: 'relative',
|
|
lineHeight: 1,
|
|
backgroundColor: 'transparent'
|
|
},
|
|
[`&${progressCls}-circle ${progressCls}-text`]: {
|
|
position: 'absolute',
|
|
insetBlockStart: '50%',
|
|
insetInlineStart: 0,
|
|
width: '100%',
|
|
margin: 0,
|
|
padding: 0,
|
|
color: token.circleTextColor,
|
|
fontSize: token.circleTextFontSize,
|
|
lineHeight: 1,
|
|
whiteSpace: 'normal',
|
|
textAlign: 'center',
|
|
transform: 'translateY(-50%)',
|
|
[iconPrefixCls]: {
|
|
fontSize: `${token.fontSize / token.fontSizeSM}em`
|
|
}
|
|
},
|
|
[`${progressCls}-circle&-status-exception`]: {
|
|
[`${progressCls}-text`]: {
|
|
color: token.colorError
|
|
}
|
|
},
|
|
[`${progressCls}-circle&-status-success`]: {
|
|
[`${progressCls}-text`]: {
|
|
color: token.colorSuccess
|
|
}
|
|
}
|
|
},
|
|
[`${progressCls}-inline-circle`]: {
|
|
lineHeight: 1,
|
|
[`${progressCls}-inner`]: {
|
|
verticalAlign: 'bottom'
|
|
}
|
|
}
|
|
};
|
|
};
|
|
const genStepStyle = token => {
|
|
const {
|
|
componentCls: progressCls
|
|
} = token;
|
|
return {
|
|
[progressCls]: {
|
|
[`${progressCls}-steps`]: {
|
|
display: 'inline-block',
|
|
'&-outer': {
|
|
display: 'flex',
|
|
flexDirection: 'row',
|
|
alignItems: 'center'
|
|
},
|
|
'&-item': {
|
|
flexShrink: 0,
|
|
minWidth: token.progressStepMinWidth,
|
|
marginInlineEnd: token.progressStepMarginInlineEnd,
|
|
backgroundColor: token.remainingColor,
|
|
transition: `all ${token.motionDurationSlow}`,
|
|
'&-active': {
|
|
backgroundColor: token.defaultColor
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
};
|
|
const genSmallLine = token => {
|
|
const {
|
|
componentCls: progressCls,
|
|
iconCls: iconPrefixCls
|
|
} = token;
|
|
return {
|
|
[progressCls]: {
|
|
[`${progressCls}-small&-line, ${progressCls}-small&-line ${progressCls}-text ${iconPrefixCls}`]: {
|
|
fontSize: token.fontSizeSM
|
|
}
|
|
}
|
|
};
|
|
};
|
|
/* harmony default export */ var progress_style = ((0,genComponentStyleHook/* default */.Z)('Progress', token => {
|
|
const progressStepMarginInlineEnd = token.marginXXS / 2;
|
|
const progressToken = (0,statistic/* merge */.TS)(token, {
|
|
progressStepMarginInlineEnd,
|
|
progressStepMinWidth: progressStepMarginInlineEnd,
|
|
progressActiveMotionDuration: '2.4s'
|
|
});
|
|
return [genBaseStyle(progressToken), genCircleStyle(progressToken), genStepStyle(progressToken), genSmallLine(progressToken)];
|
|
}, token => ({
|
|
circleTextColor: token.colorText,
|
|
defaultColor: token.colorInfo,
|
|
remainingColor: token.colorFillSecondary,
|
|
lineBorderRadius: 100,
|
|
circleTextFontSize: '1em'
|
|
})));
|
|
;// CONCATENATED MODULE: ./node_modules/_antd@5.9.0@antd/es/progress/progress.js
|
|
"use client";
|
|
|
|
var progress_rest = undefined && undefined.__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;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const ProgressTypes = (/* unused pure expression or super */ null && (['line', 'circle', 'dashboard']));
|
|
const ProgressStatuses = ['normal', 'exception', 'active', 'success'];
|
|
const Progress = /*#__PURE__*/_react_17_0_2_react.forwardRef((props, ref) => {
|
|
const {
|
|
prefixCls: customizePrefixCls,
|
|
className,
|
|
rootClassName,
|
|
steps,
|
|
strokeColor,
|
|
percent = 0,
|
|
size = 'default',
|
|
showInfo = true,
|
|
type = 'line',
|
|
status,
|
|
format,
|
|
style
|
|
} = props,
|
|
restProps = progress_rest(props, ["prefixCls", "className", "rootClassName", "steps", "strokeColor", "percent", "size", "showInfo", "type", "status", "format", "style"]);
|
|
const percentNumber = _react_17_0_2_react.useMemo(() => {
|
|
var _a, _b;
|
|
const successPercent = getSuccessPercent(props);
|
|
return parseInt(successPercent !== undefined ? (_a = successPercent !== null && successPercent !== void 0 ? successPercent : 0) === null || _a === void 0 ? void 0 : _a.toString() : (_b = percent !== null && percent !== void 0 ? percent : 0) === null || _b === void 0 ? void 0 : _b.toString(), 10);
|
|
}, [percent, props.success, props.successPercent]);
|
|
const progressStatus = _react_17_0_2_react.useMemo(() => {
|
|
if (!ProgressStatuses.includes(status) && percentNumber >= 100) {
|
|
return 'success';
|
|
}
|
|
return status || 'normal';
|
|
}, [status, percentNumber]);
|
|
const {
|
|
getPrefixCls,
|
|
direction,
|
|
progress: progressStyle
|
|
} = _react_17_0_2_react.useContext(context/* ConfigContext */.E_);
|
|
const prefixCls = getPrefixCls('progress', customizePrefixCls);
|
|
const [wrapSSR, hashId] = progress_style(prefixCls);
|
|
const progressInfo = _react_17_0_2_react.useMemo(() => {
|
|
if (!showInfo) {
|
|
return null;
|
|
}
|
|
const successPercent = getSuccessPercent(props);
|
|
let text;
|
|
const textFormatter = format || (number => `${number}%`);
|
|
const isLineType = type === 'line';
|
|
if (format || progressStatus !== 'exception' && progressStatus !== 'success') {
|
|
text = textFormatter(validProgress(percent), validProgress(successPercent));
|
|
} else if (progressStatus === 'exception') {
|
|
text = isLineType ? /*#__PURE__*/_react_17_0_2_react.createElement(CloseCircleFilled/* default */.Z, null) : /*#__PURE__*/_react_17_0_2_react.createElement(CloseOutlined/* default */.Z, null);
|
|
} else if (progressStatus === 'success') {
|
|
text = isLineType ? /*#__PURE__*/_react_17_0_2_react.createElement(CheckCircleFilled/* default */.Z, null) : /*#__PURE__*/_react_17_0_2_react.createElement(CheckOutlined/* default */.Z, null);
|
|
}
|
|
return /*#__PURE__*/_react_17_0_2_react.createElement("span", {
|
|
className: `${prefixCls}-text`,
|
|
title: typeof text === 'string' ? text : undefined
|
|
}, text);
|
|
}, [showInfo, percent, percentNumber, progressStatus, type, prefixCls, format]);
|
|
if (false) {}
|
|
const strokeColorNotArray = Array.isArray(strokeColor) ? strokeColor[0] : strokeColor;
|
|
const strokeColorNotGradient = typeof strokeColor === 'string' || Array.isArray(strokeColor) ? strokeColor : undefined;
|
|
let progress;
|
|
// Render progress shape
|
|
if (type === 'line') {
|
|
progress = steps ? /*#__PURE__*/_react_17_0_2_react.createElement(progress_Steps, Object.assign({}, props, {
|
|
strokeColor: strokeColorNotGradient,
|
|
prefixCls: prefixCls,
|
|
steps: steps
|
|
}), progressInfo) : /*#__PURE__*/_react_17_0_2_react.createElement(progress_Line, Object.assign({}, props, {
|
|
strokeColor: strokeColorNotArray,
|
|
prefixCls: prefixCls,
|
|
direction: direction
|
|
}), progressInfo);
|
|
} else if (type === 'circle' || type === 'dashboard') {
|
|
progress = /*#__PURE__*/_react_17_0_2_react.createElement(progress_Circle, Object.assign({}, props, {
|
|
strokeColor: strokeColorNotArray,
|
|
prefixCls: prefixCls,
|
|
progressStatus: progressStatus
|
|
}), progressInfo);
|
|
}
|
|
const classString = _classnames_2_5_1_classnames_default()(prefixCls, `${prefixCls}-status-${progressStatus}`, `${prefixCls}-${type === 'dashboard' && 'circle' || steps && 'steps' || type}`, {
|
|
[`${prefixCls}-inline-circle`]: type === 'circle' && getSize(size, 'circle')[0] <= 20,
|
|
[`${prefixCls}-show-info`]: showInfo,
|
|
[`${prefixCls}-${size}`]: typeof size === 'string',
|
|
[`${prefixCls}-rtl`]: direction === 'rtl'
|
|
}, progressStyle === null || progressStyle === void 0 ? void 0 : progressStyle.className, className, rootClassName, hashId);
|
|
return wrapSSR( /*#__PURE__*/_react_17_0_2_react.createElement("div", Object.assign({
|
|
ref: ref,
|
|
style: Object.assign(Object.assign({}, progressStyle === null || progressStyle === void 0 ? void 0 : progressStyle.style), style),
|
|
className: classString,
|
|
role: "progressbar",
|
|
"aria-valuenow": percentNumber
|
|
}, (0,omit/* default */.Z)(restProps, ['trailColor', 'strokeWidth', 'width', 'gapDegree', 'gapPosition', 'strokeLinecap', 'success', 'successPercent'])), progress));
|
|
});
|
|
if (false) {}
|
|
/* harmony default export */ var progress = (Progress);
|
|
;// CONCATENATED MODULE: ./node_modules/_antd@5.9.0@antd/es/progress/index.js
|
|
"use client";
|
|
|
|
|
|
/* harmony default export */ var es_progress = (progress);
|
|
|
|
/***/ })
|
|
|
|
}]); |