Index: node_modules/recharts/lib/polar/Pie.js =================================================================== --- node_modules/recharts/lib/polar/Pie.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/recharts/lib/polar/Pie.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,641 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.Pie = Pie; +exports.computePieSectors = computePieSectors; +exports.defaultPieProps = void 0; +var _react = _interopRequireWildcard(require("react")); +var React = _react; +var _get = _interopRequireDefault(require("es-toolkit/compat/get")); +var _clsx = require("clsx"); +var _pieSelectors = require("../state/selectors/pieSelectors"); +var _hooks = require("../state/hooks"); +var _Layer = require("../container/Layer"); +var _Curve = require("../shape/Curve"); +var _Text = require("../component/Text"); +var _Cell = require("../component/Cell"); +var _ReactUtils = require("../util/ReactUtils"); +var _PolarUtils = require("../util/PolarUtils"); +var _DataUtils = require("../util/DataUtils"); +var _ChartUtils = require("../util/ChartUtils"); +var _types = require("../util/types"); +var _ActiveShapeUtils = require("../util/ActiveShapeUtils"); +var _tooltipContext = require("../context/tooltipContext"); +var _SetTooltipEntrySettings = require("../state/SetTooltipEntrySettings"); +var _tooltipSelectors = require("../state/selectors/tooltipSelectors"); +var _SetLegendPayload = require("../state/SetLegendPayload"); +var _Constants = require("../util/Constants"); +var _useAnimationId = require("../util/useAnimationId"); +var _resolveDefaultProps = require("../util/resolveDefaultProps"); +var _RegisterGraphicalItemId = require("../context/RegisterGraphicalItemId"); +var _SetGraphicalItem = require("../state/SetGraphicalItem"); +var _svgPropertiesNoEvents = require("../util/svgPropertiesNoEvents"); +var _JavascriptAnimate = require("../animation/JavascriptAnimate"); +var _LabelList = require("../component/LabelList"); +var _ZIndexLayer = require("../zIndex/ZIndexLayer"); +var _DefaultZIndexes = require("../zIndex/DefaultZIndexes"); +var _getClassNameFromUnknown = require("../util/getClassNameFromUnknown"); +var _excluded = ["key"], + _excluded2 = ["onMouseEnter", "onClick", "onMouseLeave"], + _excluded3 = ["id"], + _excluded4 = ["id"]; +function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } +function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); } +function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; } +function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } +function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; } +function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; } +function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } +function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); } +function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; } +function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; } +/** + * The `label` prop in Pie accepts a variety of alternatives. + */ + +/** + * We spread the data object into the sector data item, + * so we can't really know what is going to be inside. + * + * This type represents our best effort, but it all depends on the input data + * and what is inside of it. + * + * https://github.com/recharts/recharts/issues/6380 + * https://github.com/recharts/recharts/discussions/6375 + */ + +/** + * Internal props, combination of external props + defaultProps + private Recharts state + */ + +function SetPiePayloadLegend(props) { + var cells = (0, _react.useMemo)(() => (0, _ReactUtils.findAllByType)(props.children, _Cell.Cell), [props.children]); + var legendPayload = (0, _hooks.useAppSelector)(state => (0, _pieSelectors.selectPieLegend)(state, props.id, cells)); + if (legendPayload == null) { + return null; + } + return /*#__PURE__*/React.createElement(_SetLegendPayload.SetPolarLegendPayload, { + legendPayload: legendPayload + }); +} +var SetPieTooltipEntrySettings = /*#__PURE__*/React.memo(_ref => { + var { + dataKey, + nameKey, + sectors, + stroke, + strokeWidth, + fill, + name, + hide, + tooltipType, + id + } = _ref; + var tooltipEntrySettings = { + dataDefinedOnItem: sectors.map(p => p.tooltipPayload), + getPosition: index => { + var _sectors$Number; + return (_sectors$Number = sectors[Number(index)]) === null || _sectors$Number === void 0 ? void 0 : _sectors$Number.tooltipPosition; + }, + settings: { + stroke, + strokeWidth, + fill, + dataKey, + nameKey, + name: (0, _ChartUtils.getTooltipNameProp)(name, dataKey), + hide, + type: tooltipType, + color: fill, + unit: '', + // why doesn't Pie support unit? + graphicalItemId: id + } + }; + return /*#__PURE__*/React.createElement(_SetTooltipEntrySettings.SetTooltipEntrySettings, { + tooltipEntrySettings: tooltipEntrySettings + }); +}); +var getTextAnchor = (x, cx) => { + if (x > cx) { + return 'start'; + } + if (x < cx) { + return 'end'; + } + return 'middle'; +}; +var getOuterRadius = (dataPoint, outerRadius, maxPieRadius) => { + if (typeof outerRadius === 'function') { + return (0, _DataUtils.getPercentValue)(outerRadius(dataPoint), maxPieRadius, maxPieRadius * 0.8); + } + return (0, _DataUtils.getPercentValue)(outerRadius, maxPieRadius, maxPieRadius * 0.8); +}; +var parseCoordinateOfPie = (pieSettings, offset, dataPoint) => { + var { + top, + left, + width, + height + } = offset; + var maxPieRadius = (0, _PolarUtils.getMaxRadius)(width, height); + var cx = left + (0, _DataUtils.getPercentValue)(pieSettings.cx, width, width / 2); + var cy = top + (0, _DataUtils.getPercentValue)(pieSettings.cy, height, height / 2); + var innerRadius = (0, _DataUtils.getPercentValue)(pieSettings.innerRadius, maxPieRadius, 0); + var outerRadius = getOuterRadius(dataPoint, pieSettings.outerRadius, maxPieRadius); + var maxRadius = pieSettings.maxRadius || Math.sqrt(width * width + height * height) / 2; + return { + cx, + cy, + innerRadius, + outerRadius, + maxRadius + }; +}; +var parseDeltaAngle = (startAngle, endAngle) => { + var sign = (0, _DataUtils.mathSign)(endAngle - startAngle); + var deltaAngle = Math.min(Math.abs(endAngle - startAngle), 360); + return sign * deltaAngle; +}; +var renderLabelLineItem = (option, props) => { + if (/*#__PURE__*/React.isValidElement(option)) { + // @ts-expect-error we can't know if the type of props matches the element + return /*#__PURE__*/React.cloneElement(option, props); + } + if (typeof option === 'function') { + return option(props); + } + var className = (0, _clsx.clsx)('recharts-pie-label-line', typeof option !== 'boolean' ? option.className : ''); + // React doesn't like it when we spread a key property onto an element + var { + key + } = props, + otherProps = _objectWithoutProperties(props, _excluded); + return /*#__PURE__*/React.createElement(_Curve.Curve, _extends({}, otherProps, { + type: "linear", + className: className + })); +}; +var renderLabelItem = (option, props, value) => { + if (/*#__PURE__*/React.isValidElement(option)) { + // @ts-expect-error element cloning is not typed + return /*#__PURE__*/React.cloneElement(option, props); + } + var label = value; + if (typeof option === 'function') { + label = option(props); + if (/*#__PURE__*/React.isValidElement(label)) { + return label; + } + } + var className = (0, _clsx.clsx)('recharts-pie-label-text', (0, _getClassNameFromUnknown.getClassNameFromUnknown)(option)); + return /*#__PURE__*/React.createElement(_Text.Text, _extends({}, props, { + alignmentBaseline: "middle", + className: className + }), label); +}; +function PieLabels(_ref2) { + var { + sectors, + props, + showLabels + } = _ref2; + var { + label, + labelLine, + dataKey + } = props; + if (!showLabels || !label || !sectors) { + return null; + } + var pieProps = (0, _svgPropertiesNoEvents.svgPropertiesNoEvents)(props); + var customLabelProps = (0, _svgPropertiesNoEvents.svgPropertiesNoEventsFromUnknown)(label); + var customLabelLineProps = (0, _svgPropertiesNoEvents.svgPropertiesNoEventsFromUnknown)(labelLine); + var offsetRadius = typeof label === 'object' && 'offsetRadius' in label && typeof label.offsetRadius === 'number' && label.offsetRadius || 20; + var labels = sectors.map((entry, i) => { + var midAngle = (entry.startAngle + entry.endAngle) / 2; + var endPoint = (0, _PolarUtils.polarToCartesian)(entry.cx, entry.cy, entry.outerRadius + offsetRadius, midAngle); + var labelProps = _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, pieProps), entry), {}, { + // @ts-expect-error customLabelProps is contributing unknown props + stroke: 'none' + }, customLabelProps), {}, { + index: i, + textAnchor: getTextAnchor(endPoint.x, entry.cx) + }, endPoint); + var lineProps = _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, pieProps), entry), {}, { + // @ts-expect-error customLabelLineProps is contributing unknown props + fill: 'none', + // @ts-expect-error customLabelLineProps is contributing unknown props + stroke: entry.fill + }, customLabelLineProps), {}, { + index: i, + points: [(0, _PolarUtils.polarToCartesian)(entry.cx, entry.cy, entry.outerRadius, midAngle), endPoint], + key: 'line' + }); + return /*#__PURE__*/React.createElement(_ZIndexLayer.ZIndexLayer, { + zIndex: _DefaultZIndexes.DefaultZIndexes.label, + key: "label-".concat(entry.startAngle, "-").concat(entry.endAngle, "-").concat(entry.midAngle, "-").concat(i) + }, /*#__PURE__*/React.createElement(_Layer.Layer, null, labelLine && renderLabelLineItem(labelLine, lineProps), renderLabelItem(label, labelProps, (0, _ChartUtils.getValueByDataKey)(entry, dataKey)))); + }); + return /*#__PURE__*/React.createElement(_Layer.Layer, { + className: "recharts-pie-labels" + }, labels); +} +function PieLabelList(_ref3) { + var { + sectors, + props, + showLabels + } = _ref3; + var { + label + } = props; + if (typeof label === 'object' && label != null && 'position' in label) { + return /*#__PURE__*/React.createElement(_LabelList.LabelListFromLabelProp, { + label: label + }); + } + return /*#__PURE__*/React.createElement(PieLabels, { + sectors: sectors, + props: props, + showLabels: showLabels + }); +} +function PieSectors(props) { + var { + sectors, + activeShape, + inactiveShape: inactiveShapeProp, + allOtherPieProps, + shape, + id + } = props; + var activeIndex = (0, _hooks.useAppSelector)(_tooltipSelectors.selectActiveTooltipIndex); + var activeDataKey = (0, _hooks.useAppSelector)(_tooltipSelectors.selectActiveTooltipDataKey); + var activeGraphicalItemId = (0, _hooks.useAppSelector)(_tooltipSelectors.selectActiveTooltipGraphicalItemId); + var { + onMouseEnter: onMouseEnterFromProps, + onClick: onItemClickFromProps, + onMouseLeave: onMouseLeaveFromProps + } = allOtherPieProps, + restOfAllOtherProps = _objectWithoutProperties(allOtherPieProps, _excluded2); + var onMouseEnterFromContext = (0, _tooltipContext.useMouseEnterItemDispatch)(onMouseEnterFromProps, allOtherPieProps.dataKey, id); + var onMouseLeaveFromContext = (0, _tooltipContext.useMouseLeaveItemDispatch)(onMouseLeaveFromProps); + var onClickFromContext = (0, _tooltipContext.useMouseClickItemDispatch)(onItemClickFromProps, allOtherPieProps.dataKey, id); + if (sectors == null || sectors.length === 0) { + return null; + } + return /*#__PURE__*/React.createElement(React.Fragment, null, sectors.map((entry, i) => { + if ((entry === null || entry === void 0 ? void 0 : entry.startAngle) === 0 && (entry === null || entry === void 0 ? void 0 : entry.endAngle) === 0 && sectors.length !== 1) return null; + + // For Pie charts, when multiple Pies share the same dataKey, we need to ensure only the hovered Pie's sector is active. + // We do this by checking if the active graphical item ID matches this Pie's ID. + var graphicalItemMatches = activeGraphicalItemId == null || activeGraphicalItemId === id; + var isActive = String(i) === activeIndex && (activeDataKey == null || allOtherPieProps.dataKey === activeDataKey) && graphicalItemMatches; + var inactiveShape = activeIndex ? inactiveShapeProp : null; + var sectorOptions = activeShape && isActive ? activeShape : inactiveShape; + var sectorProps = _objectSpread(_objectSpread({}, entry), {}, { + stroke: entry.stroke, + tabIndex: -1, + [_Constants.DATA_ITEM_INDEX_ATTRIBUTE_NAME]: i, + [_Constants.DATA_ITEM_GRAPHICAL_ITEM_ID_ATTRIBUTE_NAME]: id + }); + return /*#__PURE__*/React.createElement(_Layer.Layer, _extends({ + key: "sector-".concat(entry === null || entry === void 0 ? void 0 : entry.startAngle, "-").concat(entry === null || entry === void 0 ? void 0 : entry.endAngle, "-").concat(entry.midAngle, "-").concat(i), + tabIndex: -1, + className: "recharts-pie-sector" + }, (0, _types.adaptEventsOfChild)(restOfAllOtherProps, entry, i), { + // @ts-expect-error the types need a bit of attention + onMouseEnter: onMouseEnterFromContext(entry, i) + // @ts-expect-error the types need a bit of attention + , + onMouseLeave: onMouseLeaveFromContext(entry, i) + // @ts-expect-error the types need a bit of attention + , + onClick: onClickFromContext(entry, i) + }), /*#__PURE__*/React.createElement(_ActiveShapeUtils.Shape, _extends({ + option: shape !== null && shape !== void 0 ? shape : sectorOptions, + index: i, + shapeType: "sector", + isActive: isActive + }, sectorProps))); + })); +} +function computePieSectors(_ref4) { + var _pieSettings$paddingA; + var { + pieSettings, + displayedData, + cells, + offset + } = _ref4; + var { + cornerRadius, + startAngle, + endAngle, + dataKey, + nameKey, + tooltipType + } = pieSettings; + var minAngle = Math.abs(pieSettings.minAngle); + var deltaAngle = parseDeltaAngle(startAngle, endAngle); + var absDeltaAngle = Math.abs(deltaAngle); + var paddingAngle = displayedData.length <= 1 ? 0 : (_pieSettings$paddingA = pieSettings.paddingAngle) !== null && _pieSettings$paddingA !== void 0 ? _pieSettings$paddingA : 0; + var notZeroItemCount = displayedData.filter(entry => (0, _ChartUtils.getValueByDataKey)(entry, dataKey, 0) !== 0).length; + var totalPaddingAngle = (absDeltaAngle >= 360 ? notZeroItemCount : notZeroItemCount - 1) * paddingAngle; + var realTotalAngle = absDeltaAngle - notZeroItemCount * minAngle - totalPaddingAngle; + var sum = displayedData.reduce((result, entry) => { + var val = (0, _ChartUtils.getValueByDataKey)(entry, dataKey, 0); + return result + ((0, _DataUtils.isNumber)(val) ? val : 0); + }, 0); + var sectors; + if (sum > 0) { + var prev; + sectors = displayedData.map((entry, i) => { + // @ts-expect-error getValueByDataKey does not validate the output type + var val = (0, _ChartUtils.getValueByDataKey)(entry, dataKey, 0); + // @ts-expect-error getValueByDataKey does not validate the output type + var name = (0, _ChartUtils.getValueByDataKey)(entry, nameKey, i); + var coordinate = parseCoordinateOfPie(pieSettings, offset, entry); + var percent = ((0, _DataUtils.isNumber)(val) ? val : 0) / sum; + var tempStartAngle; + + // @ts-expect-error can't spread unknown + var entryWithCellInfo = _objectSpread(_objectSpread({}, entry), cells && cells[i] && cells[i].props); + if (i) { + tempStartAngle = prev.endAngle + (0, _DataUtils.mathSign)(deltaAngle) * paddingAngle * (val !== 0 ? 1 : 0); + } else { + tempStartAngle = startAngle; + } + var tempEndAngle = tempStartAngle + (0, _DataUtils.mathSign)(deltaAngle) * ((val !== 0 ? minAngle : 0) + percent * realTotalAngle); + var midAngle = (tempStartAngle + tempEndAngle) / 2; + var middleRadius = (coordinate.innerRadius + coordinate.outerRadius) / 2; + var tooltipPayload = [{ + name, + value: val, + payload: entryWithCellInfo, + dataKey, + type: tooltipType, + graphicalItemId: pieSettings.id + }]; + var tooltipPosition = (0, _PolarUtils.polarToCartesian)(coordinate.cx, coordinate.cy, middleRadius, midAngle); + prev = _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, pieSettings.presentationProps), {}, { + percent, + cornerRadius: typeof cornerRadius === 'string' ? parseFloat(cornerRadius) : cornerRadius, + name, + tooltipPayload, + midAngle, + middleRadius, + tooltipPosition + }, entryWithCellInfo), coordinate), {}, { + value: val, + dataKey, + startAngle: tempStartAngle, + endAngle: tempEndAngle, + payload: entryWithCellInfo, + paddingAngle: (0, _DataUtils.mathSign)(deltaAngle) * paddingAngle + }); + return prev; + }); + } + return sectors; +} +function PieLabelListProvider(_ref5) { + var { + showLabels, + sectors, + children + } = _ref5; + var labelListEntries = (0, _react.useMemo)(() => { + if (!showLabels || !sectors) { + return []; + } + return sectors.map(entry => ({ + value: entry.value, + payload: entry.payload, + clockWise: false, + parentViewBox: undefined, + viewBox: { + cx: entry.cx, + cy: entry.cy, + innerRadius: entry.innerRadius, + outerRadius: entry.outerRadius, + startAngle: entry.startAngle, + endAngle: entry.endAngle, + clockWise: false + }, + fill: entry.fill + })); + }, [sectors, showLabels]); + return /*#__PURE__*/React.createElement(_LabelList.PolarLabelListContextProvider, { + value: showLabels ? labelListEntries : undefined + }, children); +} +function SectorsWithAnimation(_ref6) { + var { + props, + previousSectorsRef, + id + } = _ref6; + var { + sectors, + isAnimationActive, + animationBegin, + animationDuration, + animationEasing, + activeShape, + inactiveShape, + onAnimationStart, + onAnimationEnd + } = props; + var animationId = (0, _useAnimationId.useAnimationId)(props, 'recharts-pie-'); + var prevSectors = previousSectorsRef.current; + var [isAnimating, setIsAnimating] = (0, _react.useState)(false); + var handleAnimationEnd = (0, _react.useCallback)(() => { + if (typeof onAnimationEnd === 'function') { + onAnimationEnd(); + } + setIsAnimating(false); + }, [onAnimationEnd]); + var handleAnimationStart = (0, _react.useCallback)(() => { + if (typeof onAnimationStart === 'function') { + onAnimationStart(); + } + setIsAnimating(true); + }, [onAnimationStart]); + return /*#__PURE__*/React.createElement(PieLabelListProvider, { + showLabels: !isAnimating, + sectors: sectors + }, /*#__PURE__*/React.createElement(_JavascriptAnimate.JavascriptAnimate, { + animationId: animationId, + begin: animationBegin, + duration: animationDuration, + isActive: isAnimationActive, + easing: animationEasing, + onAnimationStart: handleAnimationStart, + onAnimationEnd: handleAnimationEnd, + key: animationId + }, t => { + var _first$startAngle; + var stepData = []; + var first = sectors && sectors[0]; + var curAngle = (_first$startAngle = first === null || first === void 0 ? void 0 : first.startAngle) !== null && _first$startAngle !== void 0 ? _first$startAngle : 0; + sectors === null || sectors === void 0 || sectors.forEach((entry, index) => { + var prev = prevSectors && prevSectors[index]; + var paddingAngle = index > 0 ? (0, _get.default)(entry, 'paddingAngle', 0) : 0; + if (prev) { + var angle = (0, _DataUtils.interpolate)(prev.endAngle - prev.startAngle, entry.endAngle - entry.startAngle, t); + var latest = _objectSpread(_objectSpread({}, entry), {}, { + startAngle: curAngle + paddingAngle, + endAngle: curAngle + angle + paddingAngle + }); + stepData.push(latest); + curAngle = latest.endAngle; + } else { + var { + endAngle, + startAngle + } = entry; + var deltaAngle = (0, _DataUtils.interpolate)(0, endAngle - startAngle, t); + var _latest = _objectSpread(_objectSpread({}, entry), {}, { + startAngle: curAngle + paddingAngle, + endAngle: curAngle + deltaAngle + paddingAngle + }); + stepData.push(_latest); + curAngle = _latest.endAngle; + } + }); + + // eslint-disable-next-line no-param-reassign + previousSectorsRef.current = stepData; + return /*#__PURE__*/React.createElement(_Layer.Layer, null, /*#__PURE__*/React.createElement(PieSectors, { + sectors: stepData, + activeShape: activeShape, + inactiveShape: inactiveShape, + allOtherPieProps: props, + shape: props.shape, + id: id + })); + }), /*#__PURE__*/React.createElement(PieLabelList, { + showLabels: !isAnimating, + sectors: sectors, + props: props + }), props.children); +} +var defaultPieProps = exports.defaultPieProps = { + animationBegin: 400, + animationDuration: 1500, + animationEasing: 'ease', + cx: '50%', + cy: '50%', + dataKey: 'value', + endAngle: 360, + fill: '#808080', + hide: false, + innerRadius: 0, + isAnimationActive: 'auto', + label: false, + labelLine: true, + legendType: 'rect', + minAngle: 0, + nameKey: 'name', + outerRadius: '80%', + paddingAngle: 0, + rootTabIndex: 0, + startAngle: 0, + stroke: '#fff', + zIndex: _DefaultZIndexes.DefaultZIndexes.area +}; +function PieImpl(props) { + var { + id + } = props, + propsWithoutId = _objectWithoutProperties(props, _excluded3); + var { + hide, + className, + rootTabIndex + } = props; + var cells = (0, _react.useMemo)(() => (0, _ReactUtils.findAllByType)(props.children, _Cell.Cell), [props.children]); + var sectors = (0, _hooks.useAppSelector)(state => (0, _pieSelectors.selectPieSectors)(state, id, cells)); + var previousSectorsRef = (0, _react.useRef)(null); + var layerClass = (0, _clsx.clsx)('recharts-pie', className); + if (hide || sectors == null) { + previousSectorsRef.current = null; + return /*#__PURE__*/React.createElement(_Layer.Layer, { + tabIndex: rootTabIndex, + className: layerClass + }); + } + return /*#__PURE__*/React.createElement(_ZIndexLayer.ZIndexLayer, { + zIndex: props.zIndex + }, /*#__PURE__*/React.createElement(SetPieTooltipEntrySettings, { + dataKey: props.dataKey, + nameKey: props.nameKey, + sectors: sectors, + stroke: props.stroke, + strokeWidth: props.strokeWidth, + fill: props.fill, + name: props.name, + hide: props.hide, + tooltipType: props.tooltipType, + id: id + }), /*#__PURE__*/React.createElement(_Layer.Layer, { + tabIndex: rootTabIndex, + className: layerClass + }, /*#__PURE__*/React.createElement(SectorsWithAnimation, { + props: _objectSpread(_objectSpread({}, propsWithoutId), {}, { + sectors + }), + previousSectorsRef: previousSectorsRef, + id: id + }))); +} +/** + * @consumes PolarChartContext + * @provides LabelListContext + * @provides CellReader + */ +function Pie(outsideProps) { + var props = (0, _resolveDefaultProps.resolveDefaultProps)(outsideProps, defaultPieProps); + var { + id: externalId + } = props, + propsWithoutId = _objectWithoutProperties(props, _excluded4); + var presentationProps = (0, _svgPropertiesNoEvents.svgPropertiesNoEvents)(propsWithoutId); + return /*#__PURE__*/React.createElement(_RegisterGraphicalItemId.RegisterGraphicalItemId, { + id: externalId, + type: "pie" + }, id => /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(_SetGraphicalItem.SetPolarGraphicalItem, { + type: "pie", + id: id, + data: propsWithoutId.data, + dataKey: propsWithoutId.dataKey, + hide: propsWithoutId.hide, + angleAxisId: 0, + radiusAxisId: 0, + name: propsWithoutId.name, + nameKey: propsWithoutId.nameKey, + tooltipType: propsWithoutId.tooltipType, + legendType: propsWithoutId.legendType, + fill: propsWithoutId.fill, + cx: propsWithoutId.cx, + cy: propsWithoutId.cy, + startAngle: propsWithoutId.startAngle, + endAngle: propsWithoutId.endAngle, + paddingAngle: propsWithoutId.paddingAngle, + minAngle: propsWithoutId.minAngle, + innerRadius: propsWithoutId.innerRadius, + outerRadius: propsWithoutId.outerRadius, + cornerRadius: propsWithoutId.cornerRadius, + presentationProps: presentationProps, + maxRadius: props.maxRadius + }), /*#__PURE__*/React.createElement(SetPiePayloadLegend, _extends({}, propsWithoutId, { + id: id + })), /*#__PURE__*/React.createElement(PieImpl, _extends({}, propsWithoutId, { + id: id + })))); +} +Pie.displayName = 'Pie'; Index: node_modules/recharts/lib/polar/PolarAngleAxis.js =================================================================== --- node_modules/recharts/lib/polar/PolarAngleAxis.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/recharts/lib/polar/PolarAngleAxis.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,287 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.PolarAngleAxis = PolarAngleAxis; +exports.PolarAngleAxisWrapper = void 0; +var _react = _interopRequireWildcard(require("react")); +var React = _react; +var _clsx = require("clsx"); +var _Layer = require("../container/Layer"); +var _Dot = require("../shape/Dot"); +var _Polygon = require("../shape/Polygon"); +var _Text = require("../component/Text"); +var _types = require("../util/types"); +var _PolarUtils = require("../util/PolarUtils"); +var _polarAxisSlice = require("../state/polarAxisSlice"); +var _hooks = require("../state/hooks"); +var _polarScaleSelectors = require("../state/selectors/polarScaleSelectors"); +var _polarAxisSelectors = require("../state/selectors/polarAxisSelectors"); +var _defaultPolarAngleAxisProps = require("./defaultPolarAngleAxisProps"); +var _PanoramaContext = require("../context/PanoramaContext"); +var _svgPropertiesNoEvents = require("../util/svgPropertiesNoEvents"); +var _resolveDefaultProps = require("../util/resolveDefaultProps"); +var _ZIndexLayer = require("../zIndex/ZIndexLayer"); +var _chartLayoutContext = require("../context/chartLayoutContext"); +var _DataUtils = require("../util/DataUtils"); +var _getAxisTypeBasedOnLayout = require("../util/getAxisTypeBasedOnLayout"); +var _getClassNameFromUnknown = require("../util/getClassNameFromUnknown"); +var _excluded = ["children", "type"]; +function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); } +function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); } +function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; } +function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } +function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; } +function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; } +function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } +function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; } +function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; } +var eps = 1e-5; +var COS_45 = Math.cos((0, _PolarUtils.degreeToRadian)(45)); +var AXIS_TYPE = 'angleAxis'; +function SetAngleAxisSettings(props) { + var dispatch = (0, _hooks.useAppDispatch)(); + var layout = (0, _chartLayoutContext.usePolarChartLayout)(); + var settings = (0, _react.useMemo)(() => { + var { + children, + type: typeFromProps + } = props, + rest = _objectWithoutProperties(props, _excluded); + var evaluatedType = (0, _getAxisTypeBasedOnLayout.getAxisTypeBasedOnLayout)(layout, 'angleAxis', typeFromProps); + if (evaluatedType == null) { + return undefined; + } + return _objectSpread(_objectSpread({}, rest), {}, { + type: evaluatedType + }); + }, [props, layout]); + var synchronizedSettings = (0, _hooks.useAppSelector)(state => (0, _polarAxisSelectors.selectAngleAxis)(state, settings === null || settings === void 0 ? void 0 : settings.id)); + var settingsAreSynchronized = settings === synchronizedSettings; + (0, _react.useEffect)(() => { + if (settings == null) { + return _DataUtils.noop; + } + dispatch((0, _polarAxisSlice.addAngleAxis)(settings)); + return () => { + dispatch((0, _polarAxisSlice.removeAngleAxis)(settings)); + }; + }, [dispatch, settings]); + if (settingsAreSynchronized) { + return props.children; + } + return null; +} + +/** + * Calculate the coordinate of line endpoint + * @param data The data if there are ticks + * @param props axis settings + * @return (x1, y1): The point close to text, + * (x2, y2): The point close to axis + */ +var getTickLineCoord = (data, props) => { + var { + cx, + cy, + radius, + orientation, + tickSize + } = props; + var tickLineSize = tickSize || 8; + var p1 = (0, _PolarUtils.polarToCartesian)(cx, cy, radius, data.coordinate); + var p2 = (0, _PolarUtils.polarToCartesian)(cx, cy, radius + (orientation === 'inner' ? -1 : 1) * tickLineSize, data.coordinate); + return { + x1: p1.x, + y1: p1.y, + x2: p2.x, + y2: p2.y + }; +}; + +/** + * Get the text-anchor of each tick + * @param data Data of ticks + * @param orientation of the axis ticks + * @return text-anchor + */ +var getTickTextAnchor = (data, orientation) => { + var cos = Math.cos((0, _PolarUtils.degreeToRadian)(-data.coordinate)); + if (cos > eps) { + return orientation === 'outer' ? 'start' : 'end'; + } + if (cos < -eps) { + return orientation === 'outer' ? 'end' : 'start'; + } + return 'middle'; +}; + +/** + * Get the text vertical anchor of each tick + * @param data Data of a tick + * @return text vertical anchor + */ +var getTickTextVerticalAnchor = data => { + var cos = Math.cos((0, _PolarUtils.degreeToRadian)(-data.coordinate)); + var sin = Math.sin((0, _PolarUtils.degreeToRadian)(-data.coordinate)); + + // handle top and bottom sectors: 90±45deg and 270±45deg + if (Math.abs(cos) <= COS_45) { + // sin > 0: top sector, sin < 0: bottom sector + return sin > 0 ? 'start' : 'end'; + } + return 'middle'; +}; +var AxisLine = props => { + var { + cx, + cy, + radius, + axisLineType, + axisLine, + ticks + } = props; + if (!axisLine) { + return null; + } + var axisLineProps = _objectSpread(_objectSpread({}, (0, _svgPropertiesNoEvents.svgPropertiesNoEvents)(props)), {}, { + fill: 'none' + }, (0, _svgPropertiesNoEvents.svgPropertiesNoEvents)(axisLine)); + if (axisLineType === 'circle') { + // @ts-expect-error wrong SVG element type + return /*#__PURE__*/React.createElement(_Dot.Dot, _extends({ + className: "recharts-polar-angle-axis-line" + }, axisLineProps, { + cx: cx, + cy: cy, + r: radius + })); + } + var points = ticks.map(entry => (0, _PolarUtils.polarToCartesian)(cx, cy, radius, entry.coordinate)); + + // @ts-expect-error wrong SVG element type + return /*#__PURE__*/React.createElement(_Polygon.Polygon, _extends({ + className: "recharts-polar-angle-axis-line" + }, axisLineProps, { + points: points + })); +}; +var TickItemText = _ref => { + var { + tick, + tickProps, + value + } = _ref; + if (!tick) { + return null; + } + if (/*#__PURE__*/React.isValidElement(tick)) { + return /*#__PURE__*/React.cloneElement(tick, tickProps); + } + if (typeof tick === 'function') { + return tick(tickProps); + } + return /*#__PURE__*/React.createElement(_Text.Text, _extends({}, tickProps, { + className: "recharts-polar-angle-axis-tick-value" + }), value); +}; +var Ticks = props => { + var { + tick, + tickLine, + tickFormatter, + stroke, + ticks + } = props; + var axisProps = (0, _svgPropertiesNoEvents.svgPropertiesNoEvents)(props); + var customTickProps = (0, _svgPropertiesNoEvents.svgPropertiesNoEventsFromUnknown)(tick); + var tickLineProps = _objectSpread(_objectSpread({}, axisProps), {}, { + fill: 'none' + }, (0, _svgPropertiesNoEvents.svgPropertiesNoEvents)(tickLine)); + var items = ticks.map((entry, i) => { + var lineCoord = getTickLineCoord(entry, props); + var textAnchor = getTickTextAnchor(entry, props.orientation); + var verticalAnchor = getTickTextVerticalAnchor(entry); + var tickProps = _objectSpread(_objectSpread(_objectSpread({}, axisProps), {}, { + // @ts-expect-error customTickProps is contributing unknown props + textAnchor, + verticalAnchor, + // @ts-expect-error customTickProps is contributing unknown props + stroke: 'none', + // @ts-expect-error customTickProps is contributing unknown props + fill: stroke + }, customTickProps), {}, { + index: i, + payload: entry, + x: lineCoord.x2, + y: lineCoord.y2 + }); + return /*#__PURE__*/React.createElement(_Layer.Layer, _extends({ + className: (0, _clsx.clsx)('recharts-polar-angle-axis-tick', (0, _getClassNameFromUnknown.getClassNameFromUnknown)(tick)), + key: "tick-".concat(entry.coordinate) + }, (0, _types.adaptEventsOfChild)(props, entry, i)), tickLine && /*#__PURE__*/React.createElement("line", _extends({ + className: "recharts-polar-angle-axis-tick-line" + }, tickLineProps, lineCoord)), /*#__PURE__*/React.createElement(TickItemText, { + tick: tick, + tickProps: tickProps, + value: tickFormatter ? tickFormatter(entry.value, i) : entry.value + })); + }); + return /*#__PURE__*/React.createElement(_Layer.Layer, { + className: "recharts-polar-angle-axis-ticks" + }, items); +}; +var PolarAngleAxisWrapper = defaultsAndInputs => { + var { + angleAxisId + } = defaultsAndInputs; + var viewBox = (0, _hooks.useAppSelector)(_polarAxisSelectors.selectPolarViewBox); + var scale = (0, _hooks.useAppSelector)(state => (0, _polarScaleSelectors.selectPolarAxisScale)(state, 'angleAxis', angleAxisId)); + var isPanorama = (0, _PanoramaContext.useIsPanorama)(); + var ticks = (0, _hooks.useAppSelector)(state => (0, _polarScaleSelectors.selectPolarAngleAxisTicks)(state, 'angleAxis', angleAxisId, isPanorama)); + if (viewBox == null || !ticks || !ticks.length || scale == null) { + return null; + } + var props = _objectSpread(_objectSpread(_objectSpread({}, defaultsAndInputs), {}, { + scale + }, viewBox), {}, { + radius: viewBox.outerRadius, + ticks + }); + return /*#__PURE__*/React.createElement(_ZIndexLayer.ZIndexLayer, { + zIndex: props.zIndex + }, /*#__PURE__*/React.createElement(_Layer.Layer, { + className: (0, _clsx.clsx)('recharts-polar-angle-axis', AXIS_TYPE, props.className) + }, /*#__PURE__*/React.createElement(AxisLine, props), /*#__PURE__*/React.createElement(Ticks, props))); +}; + +/** + * @provides PolarLabelContext + * @consumes PolarViewBoxContext + */ +exports.PolarAngleAxisWrapper = PolarAngleAxisWrapper; +function PolarAngleAxis(outsideProps) { + var props = (0, _resolveDefaultProps.resolveDefaultProps)(outsideProps, _defaultPolarAngleAxisProps.defaultPolarAngleAxisProps); + return /*#__PURE__*/React.createElement(SetAngleAxisSettings, { + id: props.angleAxisId, + scale: props.scale, + type: props.type, + dataKey: props.dataKey, + unit: undefined, + name: props.name, + allowDuplicatedCategory: false // Ignoring the prop on purpose because axis calculation behaves as if it was false and Tooltip requires it to be true. + , + allowDataOverflow: false, + reversed: props.reversed, + includeHidden: false, + allowDecimals: props.allowDecimals, + tickCount: props.tickCount + // @ts-expect-error the type does not match. Is RadiusAxis really expecting what it says? + , + ticks: props.ticks, + tick: props.tick, + domain: props.domain + }, /*#__PURE__*/React.createElement(PolarAngleAxisWrapper, props)); +} +PolarAngleAxis.displayName = 'PolarAngleAxis'; Index: node_modules/recharts/lib/polar/PolarGrid.js =================================================================== --- node_modules/recharts/lib/polar/PolarGrid.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/recharts/lib/polar/PolarGrid.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,216 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.defaultPolarGridProps = exports.PolarGrid = void 0; +var _clsx = require("clsx"); +var React = _interopRequireWildcard(require("react")); +var _PolarUtils = require("../util/PolarUtils"); +var _hooks = require("../state/hooks"); +var _polarGridSelectors = require("../state/selectors/polarGridSelectors"); +var _polarAxisSelectors = require("../state/selectors/polarAxisSelectors"); +var _svgPropertiesNoEvents = require("../util/svgPropertiesNoEvents"); +var _ZIndexLayer = require("../zIndex/ZIndexLayer"); +var _DefaultZIndexes = require("../zIndex/DefaultZIndexes"); +var _resolveDefaultProps2 = require("../util/resolveDefaultProps"); +var _excluded = ["gridType", "radialLines", "angleAxisId", "radiusAxisId", "cx", "cy", "innerRadius", "outerRadius", "polarAngles", "polarRadius", "zIndex"]; +function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); } +function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; } +function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; } +function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); } +function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; } +function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } +function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; } +function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; } +function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } +var getPolygonPath = (radius, cx, cy, polarAngles) => { + var path = ''; + polarAngles.forEach((angle, i) => { + var point = (0, _PolarUtils.polarToCartesian)(cx, cy, radius, angle); + if (i) { + path += "L ".concat(point.x, ",").concat(point.y); + } else { + path += "M ".concat(point.x, ",").concat(point.y); + } + }); + path += 'Z'; + return path; +}; + +// Draw axis of radial line +var PolarAngles = props => { + var { + cx, + cy, + innerRadius, + outerRadius, + polarAngles, + radialLines + } = props; + if (!polarAngles || !polarAngles.length || !radialLines) { + return null; + } + var polarAnglesProps = _objectSpread({ + stroke: '#ccc' + }, (0, _svgPropertiesNoEvents.svgPropertiesNoEvents)(props)); + return /*#__PURE__*/React.createElement("g", { + className: "recharts-polar-grid-angle" + }, polarAngles.map(entry => { + var start = (0, _PolarUtils.polarToCartesian)(cx, cy, innerRadius, entry); + var end = (0, _PolarUtils.polarToCartesian)(cx, cy, outerRadius, entry); + return /*#__PURE__*/React.createElement("line", _extends({ + key: "line-".concat(entry) + }, polarAnglesProps, { + x1: start.x, + y1: start.y, + x2: end.x, + y2: end.y + })); + })); +}; + +// Draw concentric circles +var ConcentricCircle = props => { + var { + cx, + cy, + radius + } = props; + var concentricCircleProps = _objectSpread({ + stroke: '#ccc', + fill: 'none' + }, (0, _svgPropertiesNoEvents.svgPropertiesNoEvents)(props)); + return ( + /*#__PURE__*/ + // @ts-expect-error wrong SVG element type + React.createElement("circle", _extends({}, concentricCircleProps, { + className: (0, _clsx.clsx)('recharts-polar-grid-concentric-circle', props.className), + cx: cx, + cy: cy, + r: radius + })) + ); +}; + +// Draw concentric polygons +var ConcentricPolygon = props => { + var { + radius + } = props; + var concentricPolygonProps = _objectSpread({ + stroke: '#ccc', + fill: 'none' + }, (0, _svgPropertiesNoEvents.svgPropertiesNoEvents)(props)); + return /*#__PURE__*/React.createElement("path", _extends({}, concentricPolygonProps, { + className: (0, _clsx.clsx)('recharts-polar-grid-concentric-polygon', props.className), + d: getPolygonPath(radius, props.cx, props.cy, props.polarAngles) + })); +}; + +// Draw concentric axis +var ConcentricGridPath = props => { + var { + polarRadius, + gridType + } = props; + if (!polarRadius || !polarRadius.length) { + return null; + } + var maxPolarRadius = Math.max(...polarRadius); + var renderBackground = props.fill && props.fill !== 'none'; + return /*#__PURE__*/React.createElement("g", { + className: "recharts-polar-grid-concentric" + }, renderBackground && gridType === 'circle' && /*#__PURE__*/React.createElement(ConcentricCircle, _extends({}, props, { + radius: maxPolarRadius + })), renderBackground && gridType !== 'circle' && /*#__PURE__*/React.createElement(ConcentricPolygon, _extends({}, props, { + radius: maxPolarRadius + })), polarRadius.map((entry, i) => { + var key = i; + if (gridType === 'circle') { + return /*#__PURE__*/React.createElement(ConcentricCircle, _extends({ + key: key + }, props, { + fill: "none", + radius: entry + })); + } + return /*#__PURE__*/React.createElement(ConcentricPolygon, _extends({ + key: key + }, props, { + fill: "none", + radius: entry + })); + })); +}; +var defaultPolarGridProps = exports.defaultPolarGridProps = { + angleAxisId: 0, + radiusAxisId: 0, + gridType: 'polygon', + radialLines: true, + zIndex: _DefaultZIndexes.DefaultZIndexes.grid +}; + +/** + * @consumes PolarViewBoxContext + */ +var PolarGrid = outsideProps => { + var _ref, _polarViewBox$cx, _ref2, _polarViewBox$cy, _ref3, _polarViewBox$innerRa, _ref4, _polarViewBox$outerRa; + var _resolveDefaultProps = (0, _resolveDefaultProps2.resolveDefaultProps)(outsideProps, defaultPolarGridProps), + { + gridType, + radialLines, + angleAxisId, + radiusAxisId, + cx: cxFromOutside, + cy: cyFromOutside, + innerRadius: innerRadiusFromOutside, + outerRadius: outerRadiusFromOutside, + polarAngles: polarAnglesInput, + polarRadius: polarRadiusInput, + zIndex + } = _resolveDefaultProps, + inputs = _objectWithoutProperties(_resolveDefaultProps, _excluded); + var polarViewBox = (0, _hooks.useAppSelector)(_polarAxisSelectors.selectPolarViewBox); + var polarAnglesFromRedux = (0, _hooks.useAppSelector)(state => (0, _polarGridSelectors.selectPolarGridAngles)(state, angleAxisId)); + var polarRadiiFromRedux = (0, _hooks.useAppSelector)(state => (0, _polarGridSelectors.selectPolarGridRadii)(state, radiusAxisId)); + var polarAngles = Array.isArray(polarAnglesInput) ? polarAnglesInput : polarAnglesFromRedux; + var polarRadius = Array.isArray(polarRadiusInput) ? polarRadiusInput : polarRadiiFromRedux; + if (polarAngles == null || polarRadius == null) { + return null; + } + var props = _objectSpread({ + cx: (_ref = (_polarViewBox$cx = polarViewBox === null || polarViewBox === void 0 ? void 0 : polarViewBox.cx) !== null && _polarViewBox$cx !== void 0 ? _polarViewBox$cx : cxFromOutside) !== null && _ref !== void 0 ? _ref : 0, + cy: (_ref2 = (_polarViewBox$cy = polarViewBox === null || polarViewBox === void 0 ? void 0 : polarViewBox.cy) !== null && _polarViewBox$cy !== void 0 ? _polarViewBox$cy : cyFromOutside) !== null && _ref2 !== void 0 ? _ref2 : 0, + innerRadius: (_ref3 = (_polarViewBox$innerRa = polarViewBox === null || polarViewBox === void 0 ? void 0 : polarViewBox.innerRadius) !== null && _polarViewBox$innerRa !== void 0 ? _polarViewBox$innerRa : innerRadiusFromOutside) !== null && _ref3 !== void 0 ? _ref3 : 0, + outerRadius: (_ref4 = (_polarViewBox$outerRa = polarViewBox === null || polarViewBox === void 0 ? void 0 : polarViewBox.outerRadius) !== null && _polarViewBox$outerRa !== void 0 ? _polarViewBox$outerRa : outerRadiusFromOutside) !== null && _ref4 !== void 0 ? _ref4 : 0, + polarAngles, + polarRadius, + zIndex + }, inputs); + var { + outerRadius + } = props; + if (outerRadius <= 0) { + return null; + } + return /*#__PURE__*/React.createElement(_ZIndexLayer.ZIndexLayer, { + zIndex: props.zIndex + }, /*#__PURE__*/React.createElement("g", { + className: "recharts-polar-grid" + }, /*#__PURE__*/React.createElement(ConcentricGridPath, _extends({ + gridType: gridType, + radialLines: radialLines + }, props, { + polarAngles: polarAngles, + polarRadius: polarRadius + })), /*#__PURE__*/React.createElement(PolarAngles, _extends({ + gridType: gridType, + radialLines: radialLines + }, props, { + polarAngles: polarAngles, + polarRadius: polarRadius + })))); +}; +exports.PolarGrid = PolarGrid; +PolarGrid.displayName = 'PolarGrid'; Index: node_modules/recharts/lib/polar/PolarRadiusAxis.js =================================================================== --- node_modules/recharts/lib/polar/PolarRadiusAxis.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/recharts/lib/polar/PolarRadiusAxis.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,238 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.PolarRadiusAxis = PolarRadiusAxis; +exports.PolarRadiusAxisWrapper = void 0; +var _react = _interopRequireWildcard(require("react")); +var React = _react; +var _maxBy = _interopRequireDefault(require("es-toolkit/compat/maxBy")); +var _minBy = _interopRequireDefault(require("es-toolkit/compat/minBy")); +var _clsx = require("clsx"); +var _Text = require("../component/Text"); +var _Label = require("../component/Label"); +var _Layer = require("../container/Layer"); +var _PolarUtils = require("../util/PolarUtils"); +var _types = require("../util/types"); +var _polarAxisSlice = require("../state/polarAxisSlice"); +var _hooks = require("../state/hooks"); +var _polarScaleSelectors = require("../state/selectors/polarScaleSelectors"); +var _polarAxisSelectors = require("../state/selectors/polarAxisSelectors"); +var _defaultPolarRadiusAxisProps = require("./defaultPolarRadiusAxisProps"); +var _svgPropertiesNoEvents = require("../util/svgPropertiesNoEvents"); +var _resolveDefaultProps = require("../util/resolveDefaultProps"); +var _ZIndexLayer = require("../zIndex/ZIndexLayer"); +var _chartLayoutContext = require("../context/chartLayoutContext"); +var _DataUtils = require("../util/DataUtils"); +var _getAxisTypeBasedOnLayout = require("../util/getAxisTypeBasedOnLayout"); +var _getClassNameFromUnknown = require("../util/getClassNameFromUnknown"); +var _excluded = ["type"], + _excluded2 = ["cx", "cy", "angle", "axisLine"], + _excluded3 = ["angle", "tickFormatter", "stroke", "tick"]; +function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } +function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); } +function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); } +function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; } +function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } +function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; } +function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; } +function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } +function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; } +function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; } +var AXIS_TYPE = 'radiusAxis'; +function SetRadiusAxisSettings(props) { + var dispatch = (0, _hooks.useAppDispatch)(); + var layout = (0, _chartLayoutContext.usePolarChartLayout)(); + var settings = (0, _react.useMemo)(() => { + var { + type: typeFromProps + } = props, + rest = _objectWithoutProperties(props, _excluded); + var evaluatedType = (0, _getAxisTypeBasedOnLayout.getAxisTypeBasedOnLayout)(layout, 'radiusAxis', typeFromProps); + if (evaluatedType == null) { + return undefined; + } + return _objectSpread(_objectSpread({}, rest), {}, { + type: evaluatedType + }); + }, [props, layout]); + (0, _react.useEffect)(() => { + if (settings == null) { + return _DataUtils.noop; + } + dispatch((0, _polarAxisSlice.addRadiusAxis)(settings)); + return () => { + dispatch((0, _polarAxisSlice.removeRadiusAxis)(settings)); + }; + }, [dispatch, settings]); + return null; +} + +/** + * Calculate the coordinate of tick + * @param coordinate The radius of tick + * @param angle from props + * @param cx from chart + * @param cy from chart + * @return (x, y) + */ +var getTickValueCoord = (_ref, angle, cx, cy) => { + var { + coordinate + } = _ref; + return (0, _PolarUtils.polarToCartesian)(cx, cy, coordinate, angle); +}; +var getTickTextAnchor = orientation => { + var textAnchor; + switch (orientation) { + case 'left': + textAnchor = 'end'; + break; + case 'right': + textAnchor = 'start'; + break; + default: + textAnchor = 'middle'; + break; + } + return textAnchor; +}; +var getViewBox = (angle, cx, cy, ticks) => { + var maxRadiusTick = (0, _maxBy.default)(ticks, entry => entry.coordinate || 0); + var minRadiusTick = (0, _minBy.default)(ticks, entry => entry.coordinate || 0); + return { + cx, + cy, + startAngle: angle, + endAngle: angle, + innerRadius: (minRadiusTick === null || minRadiusTick === void 0 ? void 0 : minRadiusTick.coordinate) || 0, + outerRadius: (maxRadiusTick === null || maxRadiusTick === void 0 ? void 0 : maxRadiusTick.coordinate) || 0, + clockWise: false + }; +}; +var renderAxisLine = (props, ticks) => { + var { + cx, + cy, + angle, + axisLine + } = props, + others = _objectWithoutProperties(props, _excluded2); + var extent = ticks.reduce((result, entry) => [Math.min(result[0], entry.coordinate), Math.max(result[1], entry.coordinate)], [Infinity, -Infinity]); + var point0 = (0, _PolarUtils.polarToCartesian)(cx, cy, extent[0], angle); + var point1 = (0, _PolarUtils.polarToCartesian)(cx, cy, extent[1], angle); + var axisLineProps = _objectSpread(_objectSpread(_objectSpread({}, (0, _svgPropertiesNoEvents.svgPropertiesNoEvents)(others)), {}, { + fill: 'none' + }, (0, _svgPropertiesNoEvents.svgPropertiesNoEvents)(axisLine)), {}, { + x1: point0.x, + y1: point0.y, + x2: point1.x, + y2: point1.y + }); + + // @ts-expect-error wrong SVG element type + return /*#__PURE__*/React.createElement("line", _extends({ + className: "recharts-polar-radius-axis-line" + }, axisLineProps)); +}; +var renderTickItem = (option, tickProps, value) => { + var tickItem; + if (/*#__PURE__*/React.isValidElement(option)) { + tickItem = /*#__PURE__*/React.cloneElement(option, tickProps); + } else if (typeof option === 'function') { + tickItem = option(tickProps); + } else { + tickItem = /*#__PURE__*/React.createElement(_Text.Text, _extends({}, tickProps, { + className: "recharts-polar-radius-axis-tick-value" + }), value); + } + return tickItem; +}; +var renderTicks = (props, ticks) => { + var { + angle, + tickFormatter, + stroke, + tick + } = props, + others = _objectWithoutProperties(props, _excluded3); + var textAnchor = getTickTextAnchor(props.orientation); + var axisProps = (0, _svgPropertiesNoEvents.svgPropertiesNoEvents)(others); + var customTickProps = (0, _svgPropertiesNoEvents.svgPropertiesNoEventsFromUnknown)(tick); + var items = ticks.map((entry, i) => { + var coord = getTickValueCoord(entry, props.angle, props.cx, props.cy); + var tickProps = _objectSpread(_objectSpread(_objectSpread(_objectSpread({ + textAnchor, + transform: "rotate(".concat(90 - angle, ", ").concat(coord.x, ", ").concat(coord.y, ")") + }, axisProps), {}, { + stroke: 'none', + fill: stroke + }, customTickProps), {}, { + index: i + }, coord), {}, { + payload: entry + }); + return /*#__PURE__*/React.createElement(_Layer.Layer, _extends({ + className: (0, _clsx.clsx)('recharts-polar-radius-axis-tick', (0, _getClassNameFromUnknown.getClassNameFromUnknown)(tick)), + key: "tick-".concat(entry.coordinate) + }, (0, _types.adaptEventsOfChild)(props, entry, i)), renderTickItem(tick, tickProps, tickFormatter ? tickFormatter(entry.value, i) : entry.value)); + }); + return /*#__PURE__*/React.createElement(_Layer.Layer, { + className: "recharts-polar-radius-axis-ticks" + }, items); +}; +var PolarRadiusAxisWrapper = defaultsAndInputs => { + var { + radiusAxisId + } = defaultsAndInputs; + var viewBox = (0, _hooks.useAppSelector)(_polarAxisSelectors.selectPolarViewBox); + var scale = (0, _hooks.useAppSelector)(state => (0, _polarScaleSelectors.selectPolarAxisScale)(state, 'radiusAxis', radiusAxisId)); + var ticks = (0, _hooks.useAppSelector)(state => (0, _polarScaleSelectors.selectPolarAxisTicks)(state, 'radiusAxis', radiusAxisId, false)); + if (viewBox == null || !ticks || !ticks.length || scale == null) { + return null; + } + var props = _objectSpread(_objectSpread({}, defaultsAndInputs), {}, { + scale + }, viewBox); + var { + tick, + axisLine + } = props; + return /*#__PURE__*/React.createElement(_ZIndexLayer.ZIndexLayer, { + zIndex: props.zIndex + }, /*#__PURE__*/React.createElement(_Layer.Layer, { + className: (0, _clsx.clsx)('recharts-polar-radius-axis', AXIS_TYPE, props.className) + }, axisLine && renderAxisLine(props, ticks), tick && renderTicks(props, ticks), /*#__PURE__*/React.createElement(_Label.PolarLabelContextProvider, getViewBox(props.angle, props.cx, props.cy, ticks), /*#__PURE__*/React.createElement(_Label.PolarLabelFromLabelProp, { + label: props.label + }), props.children))); +}; + +/** + * @provides PolarLabelContext + * @consumes PolarViewBoxContext + */ +exports.PolarRadiusAxisWrapper = PolarRadiusAxisWrapper; +function PolarRadiusAxis(outsideProps) { + var props = (0, _resolveDefaultProps.resolveDefaultProps)(outsideProps, _defaultPolarRadiusAxisProps.defaultPolarRadiusAxisProps); + return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(SetRadiusAxisSettings, { + domain: props.domain, + id: props.radiusAxisId, + scale: props.scale, + type: props.type, + dataKey: props.dataKey, + unit: undefined, + name: props.name, + allowDuplicatedCategory: props.allowDuplicatedCategory, + allowDataOverflow: props.allowDataOverflow, + reversed: props.reversed, + includeHidden: props.includeHidden, + allowDecimals: props.allowDecimals + // @ts-expect-error the type does not match. Is RadiusAxis really expecting what it says? + , + ticks: props.ticks, + tickCount: props.tickCount, + tick: props.tick + }), /*#__PURE__*/React.createElement(PolarRadiusAxisWrapper, props)); +} +PolarRadiusAxis.displayName = 'PolarRadiusAxis'; Index: node_modules/recharts/lib/polar/Radar.js =================================================================== --- node_modules/recharts/lib/polar/Radar.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/recharts/lib/polar/Radar.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,461 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.Radar = Radar; +exports.computeRadarPoints = computeRadarPoints; +exports.defaultRadarProps = void 0; +var _react = _interopRequireWildcard(require("react")); +var React = _react; +var _last = _interopRequireDefault(require("es-toolkit/compat/last")); +var _clsx = require("clsx"); +var _DataUtils = require("../util/DataUtils"); +var _PolarUtils = require("../util/PolarUtils"); +var _ChartUtils = require("../util/ChartUtils"); +var _Polygon = require("../shape/Polygon"); +var _Layer = require("../container/Layer"); +var _LabelList = require("../component/LabelList"); +var _Dots = require("../component/Dots"); +var _ActivePoints = require("../component/ActivePoints"); +var _SetTooltipEntrySettings = require("../state/SetTooltipEntrySettings"); +var _radarSelectors = require("../state/selectors/radarSelectors"); +var _hooks = require("../state/hooks"); +var _PanoramaContext = require("../context/PanoramaContext"); +var _SetLegendPayload = require("../state/SetLegendPayload"); +var _useAnimationId = require("../util/useAnimationId"); +var _RegisterGraphicalItemId = require("../context/RegisterGraphicalItemId"); +var _SetGraphicalItem = require("../state/SetGraphicalItem"); +var _svgPropertiesNoEvents = require("../util/svgPropertiesNoEvents"); +var _JavascriptAnimate = require("../animation/JavascriptAnimate"); +var _svgPropertiesAndEvents = require("../util/svgPropertiesAndEvents"); +var _resolveDefaultProps = require("../util/resolveDefaultProps"); +var _ZIndexLayer = require("../zIndex/ZIndexLayer"); +var _DefaultZIndexes = require("../zIndex/DefaultZIndexes"); +var _excluded = ["id"]; +function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } +function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); } +function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); } +function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; } +function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } +function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; } +function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; } +function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } +function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; } +function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; } +function getLegendItemColor(stroke, fill) { + return stroke && stroke !== 'none' ? stroke : fill; +} +var computeLegendPayloadFromRadarSectors = props => { + var { + dataKey, + name, + stroke, + fill, + legendType, + hide + } = props; + return [{ + inactive: hide, + dataKey, + type: legendType, + color: getLegendItemColor(stroke, fill), + value: (0, _ChartUtils.getTooltipNameProp)(name, dataKey), + payload: props + }]; +}; +var SetRadarTooltipEntrySettings = /*#__PURE__*/React.memo(_ref => { + var { + dataKey, + stroke, + strokeWidth, + fill, + name, + hide, + tooltipType, + id + } = _ref; + var tooltipEntrySettings = { + /* + * I suppose this here _could_ return props.points + * because while Radar does not support item tooltip mode, it _could_ support it. + * But when I actually do return the points here, a defaultIndex test starts failing. + * So, undefined it is. + */ + dataDefinedOnItem: undefined, + getPosition: _DataUtils.noop, + settings: { + stroke, + strokeWidth, + fill, + nameKey: undefined, + // RadarChart does not have nameKey unfortunately + dataKey, + name: (0, _ChartUtils.getTooltipNameProp)(name, dataKey), + hide, + type: tooltipType, + color: getLegendItemColor(stroke, fill), + unit: '', + // why doesn't Radar support unit? + graphicalItemId: id + } + }; + return /*#__PURE__*/React.createElement(_SetTooltipEntrySettings.SetTooltipEntrySettings, { + tooltipEntrySettings: tooltipEntrySettings + }); +}); +function RadarDotsWrapper(_ref2) { + var { + points, + props + } = _ref2; + var { + dot, + dataKey + } = props; + var { + id + } = props, + propsWithoutId = _objectWithoutProperties(props, _excluded); + var baseProps = (0, _svgPropertiesNoEvents.svgPropertiesNoEvents)(propsWithoutId); + return /*#__PURE__*/React.createElement(_Dots.Dots, { + points: points, + dot: dot, + className: "recharts-radar-dots", + dotClassName: "recharts-radar-dot", + dataKey: dataKey, + baseProps: baseProps + }); +} +function computeRadarPoints(_ref3) { + var { + radiusAxis, + angleAxis, + displayedData, + dataKey, + bandSize + } = _ref3; + var { + cx, + cy + } = angleAxis; + var isRange = false; + var points = []; + var angleBandSize = angleAxis.type !== 'number' ? bandSize !== null && bandSize !== void 0 ? bandSize : 0 : 0; + displayedData.forEach((entry, i) => { + var _angleAxis$scale$map, _radiusAxis$scale$map; + var name = (0, _ChartUtils.getValueByDataKey)(entry, angleAxis.dataKey, i); + var value = (0, _ChartUtils.getValueByDataKey)(entry, dataKey); + var angle = ((_angleAxis$scale$map = angleAxis.scale.map(name)) !== null && _angleAxis$scale$map !== void 0 ? _angleAxis$scale$map : 0) + angleBandSize; + var pointValue = Array.isArray(value) ? (0, _last.default)(value) : value; + var radius = (0, _DataUtils.isNullish)(pointValue) ? 0 : (_radiusAxis$scale$map = radiusAxis.scale.map(pointValue)) !== null && _radiusAxis$scale$map !== void 0 ? _radiusAxis$scale$map : 0; + if (Array.isArray(value) && value.length >= 2) { + isRange = true; + } + points.push(_objectSpread(_objectSpread({}, (0, _PolarUtils.polarToCartesian)(cx, cy, radius, angle)), {}, { + // @ts-expect-error getValueByDataKey does not validate the output type + name, + // @ts-expect-error getValueByDataKey does not validate the output type + value, + cx, + cy, + radius, + angle, + payload: entry + })); + }); + var baseLinePoints = []; + if (isRange) { + points.forEach(point => { + if (Array.isArray(point.value)) { + var _radiusAxis$scale$map2; + var baseValue = point.value[0]; + var radius = (0, _DataUtils.isNullish)(baseValue) ? 0 : (_radiusAxis$scale$map2 = radiusAxis.scale.map(baseValue)) !== null && _radiusAxis$scale$map2 !== void 0 ? _radiusAxis$scale$map2 : 0; + baseLinePoints.push(_objectSpread(_objectSpread({}, point), {}, { + radius + }, (0, _PolarUtils.polarToCartesian)(cx, cy, radius, point.angle))); + } else { + baseLinePoints.push(point); + } + }); + } + return { + points, + isRange, + baseLinePoints + }; +} +function RadarLabelListProvider(_ref4) { + var { + showLabels, + points, + children + } = _ref4; + /* + * Radar provides a Cartesian label list context. Do we want to also provide a polar label list context? + * That way, users can choose to use polar positions for the Radar labels. + */ + // const labelListEntries: ReadonlyArray = points.map( + // (point): PolarLabelListEntry => ({ + // value: point.value, + // payload: point.payload, + // parentViewBox: undefined, + // clockWise: false, + // viewBox: { + // cx: point.cx, + // cy: point.cy, + // innerRadius: point.radius, + // outerRadius: point.radius, + // startAngle: point.angle, + // endAngle: point.angle, + // clockWise: false, + // }, + // }), + // ); + + var labelListEntries = points.map(point => { + var _point$value; + var viewBox = { + x: point.x, + y: point.y, + width: 0, + lowerWidth: 0, + upperWidth: 0, + height: 0 + }; + return _objectSpread(_objectSpread({}, viewBox), {}, { + value: (_point$value = point.value) !== null && _point$value !== void 0 ? _point$value : '', + payload: point.payload, + parentViewBox: undefined, + viewBox, + fill: undefined + }); + }); + return /*#__PURE__*/React.createElement(_LabelList.CartesianLabelListContextProvider, { + value: showLabels ? labelListEntries : undefined + }, children); +} +function StaticPolygon(_ref5) { + var { + points, + baseLinePoints, + props + } = _ref5; + if (points == null) { + return null; + } + var { + shape, + isRange, + connectNulls + } = props; + var handleMouseEnter = e => { + var { + onMouseEnter + } = props; + if (onMouseEnter) { + onMouseEnter(props, e); + } + }; + var handleMouseLeave = e => { + var { + onMouseLeave + } = props; + if (onMouseLeave) { + onMouseLeave(props, e); + } + }; + var radar; + if (/*#__PURE__*/React.isValidElement(shape)) { + radar = /*#__PURE__*/React.cloneElement(shape, _objectSpread(_objectSpread({}, props), {}, { + points + })); + } else if (typeof shape === 'function') { + radar = shape(_objectSpread(_objectSpread({}, props), {}, { + points + })); + } else { + radar = /*#__PURE__*/React.createElement(_Polygon.Polygon, _extends({}, (0, _svgPropertiesAndEvents.svgPropertiesAndEvents)(props), { + onMouseEnter: handleMouseEnter, + onMouseLeave: handleMouseLeave, + points: points, + baseLinePoints: isRange ? baseLinePoints : undefined, + connectNulls: connectNulls + })); + } + return /*#__PURE__*/React.createElement(_Layer.Layer, { + className: "recharts-radar-polygon" + }, radar, /*#__PURE__*/React.createElement(RadarDotsWrapper, { + props: props, + points: points + })); +} +var interpolatePolarPoint = (prevPoints, prevPointsDiffFactor, t) => (entry, index) => { + var prev = prevPoints && prevPoints[Math.floor(index * prevPointsDiffFactor)]; + if (prev) { + return _objectSpread(_objectSpread({}, entry), {}, { + x: (0, _DataUtils.interpolate)(prev.x, entry.x, t), + y: (0, _DataUtils.interpolate)(prev.y, entry.y, t) + }); + } + return _objectSpread(_objectSpread({}, entry), {}, { + x: (0, _DataUtils.interpolate)(entry.cx, entry.x, t), + y: (0, _DataUtils.interpolate)(entry.cy, entry.y, t) + }); +}; +function PolygonWithAnimation(_ref6) { + var { + props, + previousPointsRef, + previousBaseLinePointsRef + } = _ref6; + var { + points, + baseLinePoints, + isAnimationActive, + animationBegin, + animationDuration, + animationEasing, + onAnimationEnd, + onAnimationStart + } = props; + var prevPoints = previousPointsRef.current; + var prevBaseLinePoints = previousBaseLinePointsRef.current; + var prevPointsDiffFactor = prevPoints ? prevPoints.length / points.length : 1; + var prevBaseLinePointsDiffFactor = prevBaseLinePoints ? prevBaseLinePoints.length / baseLinePoints.length : 1; + var animationId = (0, _useAnimationId.useAnimationId)(props, 'recharts-radar-'); + var [isAnimating, setIsAnimating] = (0, _react.useState)(false); + var showLabels = !isAnimating; + var handleAnimationEnd = (0, _react.useCallback)(() => { + if (typeof onAnimationEnd === 'function') { + onAnimationEnd(); + } + setIsAnimating(false); + }, [onAnimationEnd]); + var handleAnimationStart = (0, _react.useCallback)(() => { + if (typeof onAnimationStart === 'function') { + onAnimationStart(); + } + setIsAnimating(true); + }, [onAnimationStart]); + return /*#__PURE__*/React.createElement(RadarLabelListProvider, { + showLabels: showLabels, + points: points + }, /*#__PURE__*/React.createElement(_JavascriptAnimate.JavascriptAnimate, { + animationId: animationId, + begin: animationBegin, + duration: animationDuration, + isActive: isAnimationActive, + easing: animationEasing, + key: "radar-".concat(animationId), + onAnimationEnd: handleAnimationEnd, + onAnimationStart: handleAnimationStart + }, t => { + var stepData = t === 1 ? points : points.map(interpolatePolarPoint(prevPoints, prevPointsDiffFactor, t)); + var stepBaseLinePoints = t === 1 ? baseLinePoints : baseLinePoints === null || baseLinePoints === void 0 ? void 0 : baseLinePoints.map(interpolatePolarPoint(prevBaseLinePoints, prevBaseLinePointsDiffFactor, t)); + if (t > 0) { + // eslint-disable-next-line no-param-reassign + previousPointsRef.current = stepData; + // eslint-disable-next-line no-param-reassign + previousBaseLinePointsRef.current = stepBaseLinePoints; + } + return /*#__PURE__*/React.createElement(StaticPolygon, { + points: stepData, + baseLinePoints: stepBaseLinePoints, + props: props + }); + }), /*#__PURE__*/React.createElement(_LabelList.LabelListFromLabelProp, { + label: props.label + }), props.children); +} +function RenderPolygon(props) { + var previousPointsRef = (0, _react.useRef)(undefined); + var previousBaseLinePointsRef = (0, _react.useRef)(undefined); + return /*#__PURE__*/React.createElement(PolygonWithAnimation, { + props: props, + previousPointsRef: previousPointsRef, + previousBaseLinePointsRef: previousBaseLinePointsRef + }); +} +var defaultRadarProps = exports.defaultRadarProps = { + activeDot: true, + angleAxisId: 0, + animationBegin: 0, + animationDuration: 1500, + animationEasing: 'ease', + dot: false, + hide: false, + isAnimationActive: 'auto', + label: false, + legendType: 'rect', + radiusAxisId: 0, + zIndex: _DefaultZIndexes.DefaultZIndexes.area +}; +function RadarWithState(props) { + var { + hide, + className, + points + } = props; + if (hide) { + return null; + } + var layerClass = (0, _clsx.clsx)('recharts-radar', className); + return /*#__PURE__*/React.createElement(_ZIndexLayer.ZIndexLayer, { + zIndex: props.zIndex + }, /*#__PURE__*/React.createElement(_Layer.Layer, { + className: layerClass + }, /*#__PURE__*/React.createElement(RenderPolygon, props)), /*#__PURE__*/React.createElement(_ActivePoints.ActivePoints, { + points: points, + mainColor: getLegendItemColor(props.stroke, props.fill), + itemDataKey: props.dataKey, + activeDot: props.activeDot + })); +} +function RadarImpl(props) { + var isPanorama = (0, _PanoramaContext.useIsPanorama)(); + var radarPoints = (0, _hooks.useAppSelector)(state => (0, _radarSelectors.selectRadarPoints)(state, props.radiusAxisId, props.angleAxisId, isPanorama, props.id)); + if ((radarPoints === null || radarPoints === void 0 ? void 0 : radarPoints.points) == null) { + return null; + } + return /*#__PURE__*/React.createElement(RadarWithState, _extends({}, props, { + points: radarPoints === null || radarPoints === void 0 ? void 0 : radarPoints.points, + baseLinePoints: radarPoints === null || radarPoints === void 0 ? void 0 : radarPoints.baseLinePoints, + isRange: radarPoints === null || radarPoints === void 0 ? void 0 : radarPoints.isRange + })); +} + +/** + * @consumes PolarChartContext + * @provides LabelListContext + */ +function Radar(outsideProps) { + var props = (0, _resolveDefaultProps.resolveDefaultProps)(outsideProps, defaultRadarProps); + return /*#__PURE__*/React.createElement(_RegisterGraphicalItemId.RegisterGraphicalItemId, { + id: props.id, + type: "radar" + }, id => /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(_SetGraphicalItem.SetPolarGraphicalItem, { + type: "radar", + id: id, + data: undefined // Radar does not have data prop, why? + , + dataKey: props.dataKey, + hide: props.hide, + angleAxisId: props.angleAxisId, + radiusAxisId: props.radiusAxisId + }), /*#__PURE__*/React.createElement(_SetLegendPayload.SetPolarLegendPayload, { + legendPayload: computeLegendPayloadFromRadarSectors(props) + }), /*#__PURE__*/React.createElement(SetRadarTooltipEntrySettings, { + dataKey: props.dataKey, + stroke: props.stroke, + strokeWidth: props.strokeWidth, + fill: props.fill, + name: props.name, + hide: props.hide, + tooltipType: props.tooltipType, + id: id + }), /*#__PURE__*/React.createElement(RadarImpl, _extends({}, props, { + id: id + })))); +} +Radar.displayName = 'Radar'; Index: node_modules/recharts/lib/polar/RadialBar.js =================================================================== --- node_modules/recharts/lib/polar/RadialBar.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/recharts/lib/polar/RadialBar.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,486 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.RadialBar = RadialBar; +exports.computeRadialBarDataItems = computeRadialBarDataItems; +exports.defaultRadialBarProps = void 0; +var _react = _interopRequireWildcard(require("react")); +var React = _react; +var _clsx = require("clsx"); +var _RadialBarUtils = require("../util/RadialBarUtils"); +var _Layer = require("../container/Layer"); +var _ReactUtils = require("../util/ReactUtils"); +var _LabelList = require("../component/LabelList"); +var _Cell = require("../component/Cell"); +var _DataUtils = require("../util/DataUtils"); +var _ChartUtils = require("../util/ChartUtils"); +var _types = require("../util/types"); +var _tooltipContext = require("../context/tooltipContext"); +var _SetTooltipEntrySettings = require("../state/SetTooltipEntrySettings"); +var _radialBarSelectors = require("../state/selectors/radialBarSelectors"); +var _hooks = require("../state/hooks"); +var _tooltipSelectors = require("../state/selectors/tooltipSelectors"); +var _SetLegendPayload = require("../state/SetLegendPayload"); +var _useAnimationId = require("../util/useAnimationId"); +var _RegisterGraphicalItemId = require("../context/RegisterGraphicalItemId"); +var _SetGraphicalItem = require("../state/SetGraphicalItem"); +var _svgPropertiesNoEvents = require("../util/svgPropertiesNoEvents"); +var _JavascriptAnimate = require("../animation/JavascriptAnimate"); +var _resolveDefaultProps = require("../util/resolveDefaultProps"); +var _ZIndexLayer = require("../zIndex/ZIndexLayer"); +var _DefaultZIndexes = require("../zIndex/DefaultZIndexes"); +var _getZIndexFromUnknown = require("../zIndex/getZIndexFromUnknown"); +var _excluded = ["shape", "activeShape", "cornerRadius", "id"], + _excluded2 = ["onMouseEnter", "onClick", "onMouseLeave"], + _excluded3 = ["value", "background"]; +function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); } +function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); } +function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; } +function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } +function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; } +function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; } +function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } +function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; } +function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; } +var STABLE_EMPTY_ARRAY = []; +function RadialBarLabelListProvider(_ref) { + var { + showLabels, + sectors, + children + } = _ref; + var labelListEntries = sectors.map(sector => ({ + value: sector.value, + payload: sector.payload, + parentViewBox: undefined, + clockWise: false, + viewBox: { + cx: sector.cx, + cy: sector.cy, + innerRadius: sector.innerRadius, + outerRadius: sector.outerRadius, + startAngle: sector.startAngle, + endAngle: sector.endAngle, + clockWise: false + }, + fill: sector.fill + })); + return /*#__PURE__*/React.createElement(_LabelList.PolarLabelListContextProvider, { + value: showLabels ? labelListEntries : undefined + }, children); +} +function RadialBarSectors(_ref2) { + var { + sectors, + allOtherRadialBarProps, + showLabels + } = _ref2; + var { + shape, + activeShape, + cornerRadius, + id + } = allOtherRadialBarProps, + others = _objectWithoutProperties(allOtherRadialBarProps, _excluded); + var baseProps = (0, _svgPropertiesNoEvents.svgPropertiesNoEvents)(others); + var activeIndex = (0, _hooks.useAppSelector)(_tooltipSelectors.selectActiveTooltipIndex); + var { + onMouseEnter: onMouseEnterFromProps, + onClick: onItemClickFromProps, + onMouseLeave: onMouseLeaveFromProps + } = allOtherRadialBarProps, + restOfAllOtherProps = _objectWithoutProperties(allOtherRadialBarProps, _excluded2); + var onMouseEnterFromContext = (0, _tooltipContext.useMouseEnterItemDispatch)(onMouseEnterFromProps, allOtherRadialBarProps.dataKey, id); + var onMouseLeaveFromContext = (0, _tooltipContext.useMouseLeaveItemDispatch)(onMouseLeaveFromProps); + var onClickFromContext = (0, _tooltipContext.useMouseClickItemDispatch)(onItemClickFromProps, allOtherRadialBarProps.dataKey, id); + if (sectors == null) { + return null; + } + return /*#__PURE__*/React.createElement(RadialBarLabelListProvider, { + showLabels: showLabels, + sectors: sectors + }, sectors.map((entry, i) => { + var isActive = activeShape && activeIndex === String(i); + // @ts-expect-error the types need a bit of attention + var onMouseEnter = onMouseEnterFromContext(entry, i); + // @ts-expect-error the types need a bit of attention + var onMouseLeave = onMouseLeaveFromContext(entry, i); + // @ts-expect-error the types need a bit of attention + var onClick = onClickFromContext(entry, i); + var radialBarSectorProps = _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, baseProps), {}, { + cornerRadius: (0, _RadialBarUtils.parseCornerRadius)(cornerRadius) + }, entry), (0, _types.adaptEventsOfChild)(restOfAllOtherProps, entry, i)), {}, { + onMouseEnter, + onMouseLeave, + onClick, + className: "recharts-radial-bar-sector ".concat(entry.className), + forceCornerRadius: others.forceCornerRadius, + cornerIsExternal: others.cornerIsExternal, + isActive, + option: isActive ? activeShape : shape + }); + if (isActive) { + return /*#__PURE__*/React.createElement(_ZIndexLayer.ZIndexLayer, { + zIndex: _DefaultZIndexes.DefaultZIndexes.activeBar, + key: "sector-".concat(entry.cx, "-").concat(entry.cy, "-").concat(entry.innerRadius, "-").concat(entry.outerRadius, "-").concat(entry.startAngle, "-").concat(entry.endAngle, "-").concat(i) + }, /*#__PURE__*/React.createElement(_RadialBarUtils.RadialBarSector, radialBarSectorProps)); + } + return /*#__PURE__*/React.createElement(_RadialBarUtils.RadialBarSector, _extends({ + key: "sector-".concat(entry.cx, "-").concat(entry.cy, "-").concat(entry.innerRadius, "-").concat(entry.outerRadius, "-").concat(entry.startAngle, "-").concat(entry.endAngle, "-").concat(i) + }, radialBarSectorProps)); + }), /*#__PURE__*/React.createElement(_LabelList.LabelListFromLabelProp, { + label: allOtherRadialBarProps.label + }), allOtherRadialBarProps.children); +} +function SectorsWithAnimation(_ref3) { + var { + props, + previousSectorsRef + } = _ref3; + var { + sectors, + isAnimationActive, + animationBegin, + animationDuration, + animationEasing, + onAnimationEnd, + onAnimationStart + } = props; + var animationId = (0, _useAnimationId.useAnimationId)(props, 'recharts-radialbar-'); + var prevData = previousSectorsRef.current; + var [isAnimating, setIsAnimating] = (0, _react.useState)(false); + var handleAnimationEnd = (0, _react.useCallback)(() => { + if (typeof onAnimationEnd === 'function') { + onAnimationEnd(); + } + setIsAnimating(false); + }, [onAnimationEnd]); + var handleAnimationStart = (0, _react.useCallback)(() => { + if (typeof onAnimationStart === 'function') { + onAnimationStart(); + } + setIsAnimating(true); + }, [onAnimationStart]); + return /*#__PURE__*/React.createElement(_JavascriptAnimate.JavascriptAnimate, { + animationId: animationId, + begin: animationBegin, + duration: animationDuration, + isActive: isAnimationActive, + easing: animationEasing, + onAnimationStart: handleAnimationStart, + onAnimationEnd: handleAnimationEnd, + key: animationId + }, t => { + var stepData = t === 1 ? sectors : (sectors !== null && sectors !== void 0 ? sectors : STABLE_EMPTY_ARRAY).map((entry, index) => { + var prev = prevData && prevData[index]; + if (prev) { + return _objectSpread(_objectSpread({}, entry), {}, { + startAngle: (0, _DataUtils.interpolate)(prev.startAngle, entry.startAngle, t), + endAngle: (0, _DataUtils.interpolate)(prev.endAngle, entry.endAngle, t) + }); + } + var { + endAngle, + startAngle + } = entry; + return _objectSpread(_objectSpread({}, entry), {}, { + endAngle: (0, _DataUtils.interpolate)(startAngle, endAngle, t) + }); + }); + if (t > 0) { + // eslint-disable-next-line no-param-reassign + previousSectorsRef.current = stepData !== null && stepData !== void 0 ? stepData : null; + } + return /*#__PURE__*/React.createElement(_Layer.Layer, null, /*#__PURE__*/React.createElement(RadialBarSectors, { + sectors: stepData !== null && stepData !== void 0 ? stepData : STABLE_EMPTY_ARRAY, + allOtherRadialBarProps: props, + showLabels: !isAnimating + })); + }); +} +function RenderSectors(props) { + var previousSectorsRef = (0, _react.useRef)(null); + return /*#__PURE__*/React.createElement(SectorsWithAnimation, { + props: props, + previousSectorsRef: previousSectorsRef + }); +} +function SetRadialBarPayloadLegend(props) { + var legendPayload = (0, _hooks.useAppSelector)(state => (0, _radialBarSelectors.selectRadialBarLegendPayload)(state, props.legendType)); + return /*#__PURE__*/React.createElement(_SetLegendPayload.SetPolarLegendPayload, { + legendPayload: legendPayload !== null && legendPayload !== void 0 ? legendPayload : [] + }); +} +var SetRadialBarTooltipEntrySettings = /*#__PURE__*/React.memo(_ref4 => { + var { + dataKey, + sectors, + stroke, + strokeWidth, + name, + hide, + fill, + tooltipType, + id + } = _ref4; + var tooltipEntrySettings = { + dataDefinedOnItem: sectors, + getPosition: _DataUtils.noop, + settings: { + graphicalItemId: id, + stroke, + strokeWidth, + fill, + nameKey: undefined, + // RadialBar does not have nameKey, why? + dataKey, + name: (0, _ChartUtils.getTooltipNameProp)(name, dataKey), + hide, + type: tooltipType, + color: fill, + unit: '' // Why does RadialBar not support unit? + } + }; + return /*#__PURE__*/React.createElement(_SetTooltipEntrySettings.SetTooltipEntrySettings, { + tooltipEntrySettings: tooltipEntrySettings + }); +}); +class RadialBarWithState extends _react.PureComponent { + renderBackground(sectors) { + if (sectors == null) { + return null; + } + var { + cornerRadius + } = this.props; + var backgroundProps = (0, _svgPropertiesNoEvents.svgPropertiesNoEventsFromUnknown)(this.props.background); + return /*#__PURE__*/React.createElement(_ZIndexLayer.ZIndexLayer, { + zIndex: (0, _getZIndexFromUnknown.getZIndexFromUnknown)(this.props.background, _DefaultZIndexes.DefaultZIndexes.barBackground) + }, sectors.map((entry, i) => { + var { + value, + background + } = entry, + rest = _objectWithoutProperties(entry, _excluded3); + if (!background) { + return null; + } + var props = _objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread({ + cornerRadius: (0, _RadialBarUtils.parseCornerRadius)(cornerRadius) + }, rest), {}, { + // @ts-expect-error backgroundProps is contributing unknown props + fill: '#eee' + }, background), backgroundProps), (0, _types.adaptEventsOfChild)(this.props, entry, i)), {}, { + index: i, + className: (0, _clsx.clsx)('recharts-radial-bar-background-sector', String(backgroundProps === null || backgroundProps === void 0 ? void 0 : backgroundProps.className)), + option: background, + isActive: false + }); + return /*#__PURE__*/React.createElement(_RadialBarUtils.RadialBarSector, _extends({ + key: "background-".concat(rest.cx, "-").concat(rest.cy, "-").concat(rest.innerRadius, "-").concat(rest.outerRadius, "-").concat(rest.startAngle, "-").concat(rest.endAngle, "-").concat(i) + }, props)); + })); + } + render() { + var { + hide, + sectors, + className, + background + } = this.props; + if (hide) { + return null; + } + var layerClass = (0, _clsx.clsx)('recharts-area', className); + return /*#__PURE__*/React.createElement(_ZIndexLayer.ZIndexLayer, { + zIndex: this.props.zIndex + }, /*#__PURE__*/React.createElement(_Layer.Layer, { + className: layerClass + }, background && /*#__PURE__*/React.createElement(_Layer.Layer, { + className: "recharts-radial-bar-background" + }, this.renderBackground(sectors)), /*#__PURE__*/React.createElement(_Layer.Layer, { + className: "recharts-radial-bar-sectors" + }, /*#__PURE__*/React.createElement(RenderSectors, this.props)))); + } +} +function RadialBarImpl(props) { + var _useAppSelector; + var cells = (0, _ReactUtils.findAllByType)(props.children, _Cell.Cell); + var radialBarSettings = { + data: undefined, + hide: false, + id: props.id, + dataKey: props.dataKey, + minPointSize: props.minPointSize, + stackId: (0, _ChartUtils.getNormalizedStackId)(props.stackId), + maxBarSize: props.maxBarSize, + barSize: props.barSize, + type: 'radialBar', + angleAxisId: props.angleAxisId, + radiusAxisId: props.radiusAxisId + }; + var sectors = (_useAppSelector = (0, _hooks.useAppSelector)(state => (0, _radialBarSelectors.selectRadialBarSectors)(state, props.radiusAxisId, props.angleAxisId, radialBarSettings, cells))) !== null && _useAppSelector !== void 0 ? _useAppSelector : STABLE_EMPTY_ARRAY; + return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(SetRadialBarTooltipEntrySettings, { + dataKey: props.dataKey, + sectors: sectors, + stroke: props.stroke, + strokeWidth: props.strokeWidth, + name: props.name, + hide: props.hide, + fill: props.fill, + tooltipType: props.tooltipType, + id: props.id + }), /*#__PURE__*/React.createElement(RadialBarWithState, _extends({}, props, { + sectors: sectors + }))); +} +var defaultRadialBarProps = exports.defaultRadialBarProps = { + angleAxisId: 0, + animationBegin: 0, + animationDuration: 1500, + animationEasing: 'ease', + background: false, + cornerIsExternal: false, + cornerRadius: 0, + forceCornerRadius: false, + hide: false, + isAnimationActive: 'auto', + label: false, + legendType: 'rect', + minPointSize: 0, + radiusAxisId: 0, + zIndex: _DefaultZIndexes.DefaultZIndexes.bar +}; +function computeRadialBarDataItems(_ref5) { + var { + displayedData, + stackedData, + dataStartIndex, + stackedDomain, + dataKey, + baseValue, + layout, + radiusAxis, + radiusAxisTicks, + bandSize, + pos, + angleAxis, + minPointSize, + cx, + cy, + angleAxisTicks, + cells, + startAngle: rootStartAngle, + endAngle: rootEndAngle + } = _ref5; + if (angleAxisTicks == null || radiusAxisTicks == null) { + return STABLE_EMPTY_ARRAY; + } + return (displayedData !== null && displayedData !== void 0 ? displayedData : []).map((entry, index) => { + var value, innerRadius, outerRadius, startAngle, endAngle, backgroundSector; + if (stackedData) { + // @ts-expect-error truncateByDomain expects only numerical domain, but it can received categorical domain too + value = (0, _ChartUtils.truncateByDomain)(stackedData[dataStartIndex + index], stackedDomain); + } else { + value = (0, _ChartUtils.getValueByDataKey)(entry, dataKey); + if (!Array.isArray(value)) { + value = [baseValue, value]; + } + } + if (layout === 'radial') { + var _angleAxis$scale$map, _angleAxis$scale$map2; + startAngle = (_angleAxis$scale$map = angleAxis.scale.map(value[0])) !== null && _angleAxis$scale$map !== void 0 ? _angleAxis$scale$map : rootStartAngle; + endAngle = (_angleAxis$scale$map2 = angleAxis.scale.map(value[1])) !== null && _angleAxis$scale$map2 !== void 0 ? _angleAxis$scale$map2 : rootEndAngle; + innerRadius = (0, _ChartUtils.getCateCoordinateOfBar)({ + axis: radiusAxis, + ticks: radiusAxisTicks, + bandSize, + offset: pos.offset, + entry, + index + }); + if (innerRadius != null && endAngle != null && startAngle != null) { + outerRadius = innerRadius + pos.size; + var deltaAngle = endAngle - startAngle; + if (Math.abs(minPointSize) > 0 && Math.abs(deltaAngle) < Math.abs(minPointSize)) { + var delta = (0, _DataUtils.mathSign)(deltaAngle || minPointSize) * (Math.abs(minPointSize) - Math.abs(deltaAngle)); + endAngle += delta; + } + backgroundSector = { + background: { + cx, + cy, + innerRadius, + outerRadius, + startAngle: rootStartAngle, + endAngle: rootEndAngle + } + }; + } + } else { + innerRadius = radiusAxis.scale.map(value[0]); + outerRadius = radiusAxis.scale.map(value[1]); + startAngle = (0, _ChartUtils.getCateCoordinateOfBar)({ + axis: angleAxis, + ticks: angleAxisTicks, + bandSize, + offset: pos.offset, + entry, + index + }); + if (innerRadius != null && outerRadius != null && startAngle != null) { + endAngle = startAngle + pos.size; + var deltaRadius = outerRadius - innerRadius; + if (Math.abs(minPointSize) > 0 && Math.abs(deltaRadius) < Math.abs(minPointSize)) { + var _delta = (0, _DataUtils.mathSign)(deltaRadius || minPointSize) * (Math.abs(minPointSize) - Math.abs(deltaRadius)); + outerRadius += _delta; + } + } + } + return _objectSpread(_objectSpread(_objectSpread({}, entry), backgroundSector), {}, { + payload: entry, + value: stackedData ? value : value[1], + cx, + cy, + innerRadius, + outerRadius, + startAngle, + // @ts-expect-error endAngle is used before assigned (?) + endAngle + }, cells && cells[index] && cells[index].props); + }); +} + +/** + * @consumes PolarChartContext + * @provides LabelListContext + * @provides CellReader + */ +function RadialBar(outsideProps) { + var props = (0, _resolveDefaultProps.resolveDefaultProps)(outsideProps, defaultRadialBarProps); + return /*#__PURE__*/React.createElement(_RegisterGraphicalItemId.RegisterGraphicalItemId, { + id: props.id, + type: "radialBar" + }, id => { + var _props$hide, _props$angleAxisId, _props$radiusAxisId; + return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(_SetGraphicalItem.SetPolarGraphicalItem, { + type: "radialBar", + id: id, + data: undefined // why does RadialBar not allow data defined on the item? + , + dataKey: props.dataKey, + hide: (_props$hide = props.hide) !== null && _props$hide !== void 0 ? _props$hide : defaultRadialBarProps.hide, + angleAxisId: (_props$angleAxisId = props.angleAxisId) !== null && _props$angleAxisId !== void 0 ? _props$angleAxisId : defaultRadialBarProps.angleAxisId, + radiusAxisId: (_props$radiusAxisId = props.radiusAxisId) !== null && _props$radiusAxisId !== void 0 ? _props$radiusAxisId : defaultRadialBarProps.radiusAxisId, + stackId: (0, _ChartUtils.getNormalizedStackId)(props.stackId), + barSize: props.barSize, + minPointSize: props.minPointSize, + maxBarSize: props.maxBarSize + }), /*#__PURE__*/React.createElement(SetRadialBarPayloadLegend, props), /*#__PURE__*/React.createElement(RadialBarImpl, _extends({}, props, { + id: id + }))); + }); +} +RadialBar.displayName = 'RadialBar'; Index: node_modules/recharts/lib/polar/defaultPolarAngleAxisProps.js =================================================================== --- node_modules/recharts/lib/polar/defaultPolarAngleAxisProps.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/recharts/lib/polar/defaultPolarAngleAxisProps.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,30 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.defaultPolarAngleAxisProps = void 0; +var _DefaultZIndexes = require("../zIndex/DefaultZIndexes"); +var defaultPolarAngleAxisProps = exports.defaultPolarAngleAxisProps = { + allowDecimals: false, + allowDuplicatedCategory: true, + // if I set this to false then Tooltip synchronisation stops working in Radar, wtf + allowDataOverflow: false, + angle: 0, + angleAxisId: 0, + axisLine: true, + axisLineType: 'polygon', + cx: 0, + cy: 0, + hide: false, + includeHidden: false, + label: false, + orientation: 'outer', + reversed: false, + scale: 'auto', + tick: true, + tickLine: true, + tickSize: 8, + type: 'auto', + zIndex: _DefaultZIndexes.DefaultZIndexes.axis +}; Index: node_modules/recharts/lib/polar/defaultPolarRadiusAxisProps.js =================================================================== --- node_modules/recharts/lib/polar/defaultPolarRadiusAxisProps.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) +++ node_modules/recharts/lib/polar/defaultPolarRadiusAxisProps.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521) @@ -0,0 +1,27 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.defaultPolarRadiusAxisProps = void 0; +var _DefaultZIndexes = require("../zIndex/DefaultZIndexes"); +var defaultPolarRadiusAxisProps = exports.defaultPolarRadiusAxisProps = { + allowDataOverflow: false, + allowDecimals: false, + allowDuplicatedCategory: true, + angle: 0, + axisLine: true, + includeHidden: false, + hide: false, + label: false, + orientation: 'right', + radiusAxisId: 0, + reversed: false, + scale: 'auto', + stroke: '#ccc', + tick: true, + tickCount: 5, + tickLine: true, + type: 'auto', + zIndex: _DefaultZIndexes.DefaultZIndexes.axis +};