@hsu-react/ui 0.0.1

package/es/components/Chart/Pie/Pie3D/_utils/label.js

@@ -0,0 +1,273 @@
+// 估算标签的宽度和高度（基于文本长度和字体大小）
+var estimateLabelSize = function estimateLabelSize(text) {
+  var fontSize = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 14;
+  var padding = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 5;
+  // 简单估算：每个字符约占用 fontSize * 0.6 的宽度
+  var estimatedWidth = text.length * fontSize * 0.6 + padding * 2;
+  var estimatedHeight = fontSize + padding * 2;
+  return {
+    width: estimatedWidth,
+    height: estimatedHeight
+  };
+};
+
+// 检测两个矩形是否重叠
+var isOverlapping = function isOverlapping(rect1, rect2) {
+  return rect1.x < rect2.x + rect2.width && rect1.x + rect1.width > rect2.x && rect1.y < rect2.y + rect2.height && rect1.y + rect1.height > rect2.y;
+};
+
+// 调整标签位置以避免重叠
+var adjustLabelPositions = function adjustLabelPositions(labelPoints, labelTextStyle) {
+  var fontSize = labelTextStyle.fontSize || 14;
+  var padding = Array.isArray(labelTextStyle.padding) ? labelTextStyle.padding[0] || 5 : labelTextStyle.padding || 5;
+
+  // 将标签尺寸转换为3D坐标系的单位
+  // 假设字体大小和padding的单位需要转换为3D坐标系的相对单位
+  // 3D坐标系的范围大约是-1到1，所以需要适当的缩放
+  var scaleFactor = 0.01; // 将像素单位转换为3D坐标单位
+
+  // 创建标签矩形数组（在2D投影平面上，使用x和y坐标）
+  var labelRects = labelPoints === null || labelPoints === void 0 ? void 0 : labelPoints.map(function (point) {
+    var size = estimateLabelSize(point.text, fontSize, padding);
+    // 将像素尺寸转换为3D坐标单位
+    var width3D = size.width * scaleFactor;
+    var height3D = size.height * scaleFactor;
+    return {
+      x: point.x - width3D / 2,
+      y: point.y - height3D / 2,
+      width: width3D,
+      height: height3D,
+      index: 0 // 将在循环中设置
+    };
+  });
+
+  // 设置索引
+  labelRects === null || labelRects === void 0 || labelRects.forEach(function (rect, index) {
+    rect.index = index;
+  });
+
+  // 保存原始坐标
+  labelPoints === null || labelPoints === void 0 || labelPoints.forEach(function (point) {
+    point.originalY = point.y;
+  });
+
+  // 检测并调整重叠的标签
+  var minSpacing = fontSize * scaleFactor * 0.3; // 最小间距（3D坐标单位）
+  var hasOverlap = true;
+  var iterations = 0;
+  var maxIterations = 100; // 最大迭代次数
+
+  while (hasOverlap && iterations < maxIterations) {
+    hasOverlap = false;
+    iterations++;
+    for (var i = 0; i < labelRects.length; i++) {
+      for (var j = i + 1; j < labelRects.length; j++) {
+        if (isOverlapping(labelRects[i], labelRects[j])) {
+          hasOverlap = true;
+
+          // 计算两个标签的中心点
+          var center1X = labelRects[i].x + labelRects[i].width / 2;
+          var center1Y = labelRects[i].y + labelRects[i].height / 2;
+          var center2X = labelRects[j].x + labelRects[j].width / 2;
+          var center2Y = labelRects[j].y + labelRects[j].height / 2;
+
+          // 计算x和y方向的距离
+          var distanceX = Math.abs(center1X - center2X);
+          var distanceY = Math.abs(center1Y - center2Y);
+
+          // 计算需要的距离
+          var requiredDistanceX = (labelRects[i].width + labelRects[j].width) / 2 + minSpacing;
+          var requiredDistanceY = (labelRects[i].height + labelRects[j].height) / 2 + minSpacing;
+
+          // 根据重叠情况调整位置
+          var originalY1 = labelPoints[i].originalY || labelPoints[i].y;
+          var originalY2 = labelPoints[j].originalY || labelPoints[j].y;
+          var originalX1 = labelPoints[i].x;
+          var originalX2 = labelPoints[j].x;
+
+          // 优先调整y方向（垂直方向），因为这是最常见的重叠情况
+          if (distanceY < requiredDistanceY) {
+            var adjustmentY = (requiredDistanceY - distanceY) / 2 + minSpacing * 0.5;
+            if (originalY1 < originalY2) {
+              labelPoints[i].y -= adjustmentY;
+              labelPoints[j].y += adjustmentY;
+            } else {
+              labelPoints[i].y += adjustmentY;
+              labelPoints[j].y -= adjustmentY;
+            }
+          }
+
+          // 如果x方向也很接近，稍微调整x方向
+          if (distanceX < requiredDistanceX * 0.9) {
+            var adjustmentX = (requiredDistanceX - distanceX) / 2 * 0.5;
+            if (originalX1 < originalX2) {
+              labelPoints[i].x -= adjustmentX;
+              labelPoints[j].x += adjustmentX;
+            } else {
+              labelPoints[i].x += adjustmentX;
+              labelPoints[j].x -= adjustmentX;
+            }
+          }
+
+          // 更新矩形位置
+          var size1 = estimateLabelSize(labelPoints[i].text, fontSize, padding);
+          var size2 = estimateLabelSize(labelPoints[j].text, fontSize, padding);
+          labelRects[i].x = labelPoints[i].x - size1.width * scaleFactor / 2;
+          labelRects[i].y = labelPoints[i].y - size1.height * scaleFactor / 2;
+          labelRects[j].x = labelPoints[j].x - size2.width * scaleFactor / 2;
+          labelRects[j].y = labelPoints[j].y - size2.height * scaleFactor / 2;
+        }
+      }
+    }
+  }
+  return labelPoints;
+};
+var calculateLabelPoints = function calculateLabelPoints(series, label, maxValue, minHeight, maxHeight, autoRotate, yOffset, alpha, colorPalette) {
+  var labelLines = [];
+  var labelPoints = [];
+  var effectiveYOffset = autoRotate ? 0 : yOffset;
+  var sumValue = series.reduce(function (sum, s) {
+    return sum + s.pieData.value;
+  }, 0);
+  for (var i = 0; i < series.length; i += 1) {
+    var _series$i$itemStyle, _series$i$pieData$ite;
+    var midRatio = (series[i].pieData.startRatio + series[i].pieData.endRatio) / 2;
+    var midRadian = midRatio * Math.PI * 2;
+    var heightRatio = series[i].pieData.value / maxValue;
+    var height = minHeight + (maxHeight - minHeight) * heightRatio;
+    var zTop = height * 0.1;
+    var zBottom = -height * 0.1;
+    var startRadius = 1;
+    var startY = Math.sin(midRadian) * startRadius + effectiveYOffset;
+    var startZ = void 0;
+    var midHeightIncrease = void 0;
+    var midPoint = void 0;
+    var endPoint = void 0;
+    if (autoRotate) {
+      startZ = zTop;
+      midHeightIncrease = 1;
+      var midDistance = label.distance || 1;
+      midPoint = [Math.cos(midRadian) * (startRadius + midDistance * 0.2), Math.sin(midRadian) * (startRadius + midDistance * 0.2), startZ + midHeightIncrease];
+      var horizontalDistance = midDistance * 0.4;
+      endPoint = [Math.cos(midRadian) * (startRadius + midDistance * 0.2 + horizontalDistance), Math.sin(midRadian) * (startRadius + midDistance * 0.2 + horizontalDistance), midPoint[2]];
+    } else {
+      var threshold = -1 + alpha / 90;
+      var isFrontSide = startY < threshold;
+      if (isFrontSide) {
+        startZ = (zTop + zBottom) / 2;
+        midHeightIncrease = -1;
+      } else {
+        startZ = zTop;
+        midHeightIncrease = 1;
+      }
+      var _midDistance = 1;
+      midPoint = [Math.cos(midRadian) * (startRadius + _midDistance * 0.1), Math.sin(midRadian) * (startRadius + _midDistance * 0.5) + effectiveYOffset, startZ + midHeightIncrease];
+      var isLeftSide = Math.cos(midRadian) < 0;
+      var _horizontalDistance = _midDistance * 0.6;
+      endPoint = [midPoint[0] + (isLeftSide ? -_horizontalDistance : _horizontalDistance), midPoint[1], midPoint[2]];
+    }
+    var startPoint = [Math.cos(midRadian) * startRadius, startY, startZ];
+    var sectorColor = ((_series$i$itemStyle = series[i].itemStyle) === null || _series$i$itemStyle === void 0 ? void 0 : _series$i$itemStyle.color) || ((_series$i$pieData$ite = series[i].pieData.itemStyle) === null || _series$i$pieData$ite === void 0 ? void 0 : _series$i$pieData$ite.color) || colorPalette[i % colorPalette.length];
+    labelLines.push({
+      coords: [startPoint, midPoint, endPoint],
+      name: series[i].name,
+      color: sectorColor
+    });
+    var percent = (series[i].pieData.value / sumValue * 100).toFixed(1);
+    var labelText = "";
+    if (label.formatter) {
+      labelText = label.formatter({
+        name: series[i].name,
+        value: series[i].pieData.value,
+        percent: parseFloat(percent)
+      });
+    } else {
+      labelText = "".concat(series[i].name, " ").concat(percent, "%");
+    }
+    labelPoints.push({
+      x: endPoint[0],
+      y: endPoint[1],
+      z: endPoint[2],
+      text: labelText,
+      name: series[i].name,
+      color: sectorColor
+    });
+  }
+
+  // 调整标签位置以避免重叠
+  var labelTextStyle = label.textStyle || {};
+  // 处理 padding 可能是数组的情况
+  var adjustedTextStyle = {
+    fontSize: labelTextStyle.fontSize,
+    padding: Array.isArray(labelTextStyle.padding) ? labelTextStyle.padding[0] || 5 : labelTextStyle.padding || 5
+  };
+  var adjustedPoints = adjustLabelPositions(labelPoints, adjustedTextStyle);
+
+  // 更新标签线的终点和中间点位置以匹配调整后的标签位置
+  adjustedPoints === null || adjustedPoints === void 0 || adjustedPoints.forEach(function (point, index) {
+    if (labelLines[index]) {
+      var originalEndPoint = labelLines[index].coords[2];
+      var originalMidPoint = labelLines[index].coords[1];
+
+      // 更新终点
+      labelLines[index].coords[2] = [point.x, point.y, point.z];
+
+      // 如果y坐标发生了变化，调整中间点的y坐标以保持线条平滑
+      var yDiff = point.y - originalEndPoint[1];
+      if (Math.abs(yDiff) > 0.001) {
+        // 调整中间点的y坐标，使其在起点和终点之间平滑过渡
+        var midY = originalMidPoint[1] + yDiff * 0.5; // 中间点跟随终点移动，但幅度较小
+        labelLines[index].coords[1] = [originalMidPoint[0], midY, originalMidPoint[2]];
+      }
+    }
+  });
+  return {
+    lines: labelLines,
+    points: adjustedPoints
+  };
+};
+export var createLabelSeries = function createLabelSeries(series, label, maxValue, minHeight, maxHeight, autoRotate, yOffset, alpha, colorPalette) {
+  if (!(label !== null && label !== void 0 && label.show)) {
+    return [];
+  }
+  var _calculateLabelPoints = calculateLabelPoints(series, label, maxValue, minHeight, maxHeight, autoRotate, yOffset, alpha, colorPalette),
+    lines = _calculateLabelPoints.lines,
+    points = _calculateLabelPoints.points;
+  var labelSeries = [];
+  var labelTextStyle = label.textStyle || {};
+  lines === null || lines === void 0 || lines.forEach(function (line) {
+    var _label$lineStyle, _label$lineStyle2;
+    labelSeries.push({
+      type: "line3D",
+      coordinateSystem: "cartesian3D",
+      data: line.coords,
+      lineStyle: {
+        width: label.hideLine ? 0 : ((_label$lineStyle = label.lineStyle) === null || _label$lineStyle === void 0 ? void 0 : _label$lineStyle.width) || 1,
+        color: ((_label$lineStyle2 = label.lineStyle) === null || _label$lineStyle2 === void 0 ? void 0 : _label$lineStyle2.color) || line.color || "#fff"
+      },
+      silent: true
+    });
+  });
+  points === null || points === void 0 || points.forEach(function (point) {
+    labelSeries.push({
+      type: "scatter3D",
+      data: [[point.x, point.y, point.z, point.text, point.name]],
+      symbolSize: 0,
+      label: {
+        show: true,
+        position: "top",
+        formatter: function formatter(params) {
+          var dataArray = (params === null || params === void 0 ? void 0 : params.value) || [];
+          return (dataArray === null || dataArray === void 0 ? void 0 : dataArray[3]) || "";
+        },
+        textStyle: {
+          color: labelTextStyle.color || point.color || "#fff",
+          fontSize: labelTextStyle.fontSize || 14,
+          padding: labelTextStyle.padding || 5
+        }
+      },
+      silent: true
+    });
+  });
+  return labelSeries;
+};

package/es/components/Chart/Pie/Pie3D/_utils/option.d.ts

@@ -0,0 +1,20 @@
+import * as echarts from "echarts";
+import { ChartsOption } from "../../..";
+import type { Pie3DDataItem, SeriesItem, LabelConfig } from "..";
+export declare const getPie3DOption: (data: Pie3DDataItem[], config: {
+    internalDiameterRatio: number;
+    tooltip?: unknown;
+    alpha: number;
+    beta: number;
+    autoRotate: boolean;
+    distance: number;
+    coreOption: ChartsOption;
+    optionRef: React.MutableRefObject<ChartsOption | null>;
+    minHeight?: number;
+    maxHeight?: number;
+    yOffset?: number;
+    label?: LabelConfig;
+    enableMouseControl?: boolean;
+}) => echarts.EChartsOption & {
+    series: SeriesItem[];
+};

package/es/components/Chart/Pie/Pie3D/_utils/option.js

@@ -0,0 +1,103 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+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(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(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 _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+import chartTooltipFormatter from "../../../chartUtils/chartTooltipFormatter";
+import { calculateK, createSeries } from "./series";
+import { createLabelSeries } from "./label";
+var DEFAULT_COLORS = ["#5470c6", "#91cc75", "#fac858", "#ee6666", "#73c0de", "#3ba272", "#fc8452", "#9a60b4", "#ea7ccc"];
+export var getPie3DOption = function getPie3DOption(data, config) {
+  var internalDiameterRatio = config.internalDiameterRatio,
+    tooltip = config.tooltip,
+    alpha = config.alpha,
+    beta = config.beta,
+    autoRotate = config.autoRotate,
+    distance = config.distance,
+    coreOption = config.coreOption,
+    optionRef = config.optionRef,
+    _config$minHeight = config.minHeight,
+    minHeight = _config$minHeight === void 0 ? 10 : _config$minHeight,
+    _config$maxHeight = config.maxHeight,
+    maxHeight = _config$maxHeight === void 0 ? 35 : _config$maxHeight,
+    _config$yOffset = config.yOffset,
+    yOffset = _config$yOffset === void 0 ? 0 : _config$yOffset,
+    label = config.label,
+    _config$enableMouseCo = config.enableMouseControl,
+    enableMouseControl = _config$enableMouseCo === void 0 ? false : _config$enableMouseCo;
+  var k = calculateK(internalDiameterRatio);
+  var effectiveYOffset = autoRotate ? 0 : yOffset;
+  var series = createSeries(data, k, minHeight, maxHeight, effectiveYOffset);
+  var maxValue = data.length ? Math.max.apply(Math, _toConsumableArray(data.map(function (item) {
+    return item.value;
+  }))) : 0;
+  var colorPalette = coreOption.color || DEFAULT_COLORS;
+  var labelSeries = label !== null && label !== void 0 && label.show ? createLabelSeries(series, label, maxValue, minHeight, maxHeight, autoRotate, yOffset, alpha, colorPalette) : [];
+  var tooltipConfig = tooltip || {};
+  var option = _objectSpread(_objectSpread({}, coreOption), {}, {
+    color: colorPalette,
+    tooltip: _objectSpread({
+      formatter: function formatter(params) {
+        var param = params;
+        if (param.seriesName !== "mouseoutSeries" && optionRef.current && typeof param.seriesIndex === "number") {
+          var currentOption = optionRef.current;
+          return chartTooltipFormatter({
+            params: _objectSpread(_objectSpread({}, params), {}, {
+              value: currentOption.series[param.seriesIndex].pieData.value,
+              color: param.color,
+              name: param.seriesName
+            })
+          });
+        }
+        return "";
+      }
+    }, tooltipConfig),
+    xAxis3D: {
+      min: -1,
+      max: 1
+    },
+    yAxis3D: {
+      min: -1,
+      max: 1
+    },
+    zAxis3D: {
+      min: -1,
+      max: 1
+    },
+    grid3D: {
+      show: false,
+      boxHeight: 20,
+      top: "-5%",
+      viewControl: {
+        alpha: alpha,
+        beta: beta,
+        rotateSensitivity: enableMouseControl ? 1 : 0,
+        zoomSensitivity: enableMouseControl ? 1 : 0,
+        panSensitivity: enableMouseControl ? 1 : 0,
+        autoRotate: autoRotate,
+        distance: distance
+      },
+      postEffect: {
+        enable: autoRotate ? false : true,
+        bloom: {
+          enable: true,
+          bloomIntensity: 0.1
+        },
+        SSAO: {
+          enable: true,
+          quality: "medium",
+          radius: 2
+        }
+      }
+    },
+    series: [].concat(_toConsumableArray(series), _toConsumableArray(labelSeries))
+  });
+  return option;
+};

package/es/components/Chart/Pie/Pie3D/_utils/parametricEquation.d.ts

@@ -0,0 +1,15 @@
+export declare const getParametricEquation: (startRatio: number, endRatio: number, isSelected: boolean, isHovered: boolean, k: number, h: number, yOffset?: number) => {
+    u: {
+        min: number;
+        max: number;
+        step: number;
+    };
+    v: {
+        min: number;
+        max: number;
+        step: number;
+    };
+    x(u: number, v: number): number;
+    y(u: number, v: number): number;
+    z(u: number, v: number): number;
+};

package/es/components/Chart/Pie/Pie3D/_utils/parametricEquation.js

@@ -0,0 +1,53 @@
+export var getParametricEquation = function getParametricEquation(startRatio, endRatio, isSelected, isHovered, k, h) {
+  var yOffset = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : 0;
+  var midRatio = (startRatio + endRatio) / 2;
+  var startRadian = startRatio * Math.PI * 2;
+  var endRadian = endRatio * Math.PI * 2;
+  var midRadian = midRatio * Math.PI * 2;
+  var selected = isSelected;
+  if (startRatio === 0 && endRatio === 1) {
+    selected = false;
+  }
+  var offsetX = selected ? Math.cos(midRadian) * 0.1 : 0;
+  var offsetY = selected ? Math.sin(midRadian) * 0.1 : 0;
+  var hoverRate = isHovered ? 1.05 : 1;
+  return {
+    u: {
+      min: -Math.PI,
+      max: Math.PI * 3,
+      step: Math.PI / 32
+    },
+    v: {
+      min: 0,
+      max: Math.PI * 2,
+      step: Math.PI / 64
+    },
+    x: function x(u, v) {
+      if (u < startRadian) {
+        return offsetX + Math.cos(startRadian) * (1 + Math.cos(v) * k) * hoverRate;
+      }
+      if (u > endRadian) {
+        return offsetX + Math.cos(endRadian) * (1 + Math.cos(v) * k) * hoverRate;
+      }
+      return offsetX + Math.cos(u) * (1 + Math.cos(v) * k) * hoverRate;
+    },
+    y: function y(u, v) {
+      if (u < startRadian) {
+        return offsetY + Math.sin(startRadian) * (1 + Math.cos(v) * k) * hoverRate + yOffset;
+      }
+      if (u > endRadian) {
+        return offsetY + Math.sin(endRadian) * (1 + Math.cos(v) * k) * hoverRate + yOffset;
+      }
+      return offsetY + Math.sin(u) * (1 + Math.cos(v) * k) * hoverRate + yOffset;
+    },
+    z: function z(u, v) {
+      if (u < -Math.PI * 0.5) {
+        return Math.sin(u);
+      }
+      if (u > Math.PI * 2.5) {
+        return Math.sin(u) * h * 0.1;
+      }
+      return Math.sin(v) > 0 ? 1 * h * 0.1 : -1;
+    }
+  };
+};

package/es/components/Chart/Pie/Pie3D/_utils/series.d.ts

@@ -0,0 +1,3 @@
+import type { Pie3DDataItem, SeriesItem } from "..";
+export declare const calculateK: (internalDiameterRatio: number) => number;
+export declare const createSeries: (data: Pie3DDataItem[], k: number, minHeight: number, maxHeight: number, effectiveYOffset: number) => SeriesItem[];

package/es/components/Chart/Pie/Pie3D/_utils/series.js

@@ -0,0 +1,60 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+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(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(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); }
+import { getParametricEquation } from "./parametricEquation";
+export var calculateK = function calculateK(internalDiameterRatio) {
+  if (typeof internalDiameterRatio === "undefined") {
+    return 1 / 3;
+  }
+  return internalDiameterRatio === 0 ? 1 : (1 - internalDiameterRatio) / (1 + internalDiameterRatio);
+};
+export var createSeries = function createSeries(data, k, minHeight, maxHeight, effectiveYOffset) {
+  var series = [];
+  var sumValue = 0;
+  var startValue = 0;
+  var endValue = 0;
+  for (var i = 0; i < data.length; i += 1) {
+    sumValue += data[i].value;
+    var seriesItem = {
+      name: data[i].name || "series".concat(i),
+      type: "surface",
+      parametric: true,
+      wireframe: {
+        show: false
+      },
+      pieData: _objectSpread({}, data[i]),
+      pieStatus: {
+        selected: false,
+        hovered: false,
+        k: k
+      }
+    };
+    if (data[i].itemStyle) {
+      seriesItem.itemStyle = _objectSpread({}, data[i].itemStyle);
+    }
+    series.push(seriesItem);
+  }
+  var maxValue = data.length ? Math.max.apply(Math, _toConsumableArray(data.map(function (item) {
+    return item.value;
+  }))) : 0;
+  var safeMaxValue = maxValue > 0 ? maxValue : 1;
+  for (var _i = 0; _i < series.length; _i += 1) {
+    endValue = startValue + series[_i].pieData.value;
+    series[_i].pieData.startRatio = startValue / sumValue;
+    series[_i].pieData.endRatio = endValue / sumValue;
+    var heightRatio = series[_i].pieData.value / safeMaxValue;
+    var height = minHeight + (maxHeight - minHeight) * heightRatio;
+    series[_i].parametricEquation = getParametricEquation(series[_i].pieData.startRatio, series[_i].pieData.endRatio, false, false, k, height, effectiveYOffset);
+    startValue = endValue;
+  }
+  return series;
+};

package/es/components/Chart/Pie/Pie3D/index.d.ts

@@ -0,0 +1,86 @@
+import * as echarts from "echarts";
+import "echarts-gl";
+import React from "react";
+import { ChartCommonProps } from "../..";
+export interface Pie3DDataItem {
+    name: string;
+    value: number;
+    itemStyle?: {
+        color?: string;
+        opacity?: number;
+    };
+}
+export interface LabelConfig {
+    show?: boolean;
+    distance?: number;
+    formatter?: (params: {
+        name: string;
+        value: number;
+        percent: number;
+    }) => string;
+    hideLine?: boolean;
+    lineStyle?: {
+        color?: string;
+        width?: number;
+    };
+    textStyle?: {
+        color?: string;
+        fontSize?: number;
+        padding?: number | number[];
+    };
+}
+export interface ChartPie3DProps extends Omit<ChartCommonProps, "series"> {
+    pieData: Pie3DDataItem[];
+    internalDiameterRatio?: number;
+    autoRotate?: boolean;
+    distance?: number;
+    alpha?: number;
+    beta?: number;
+    hoverHeightIncrement?: number;
+    minHeight?: number;
+    maxHeight?: number;
+    yOffset?: number;
+    label?: LabelConfig;
+    enableMouseControl?: boolean;
+    onChart?: (chart: echarts.EChartsType) => void;
+    onClick?: (event: echarts.ECElementEvent) => void;
+}
+export interface PieStatus {
+    selected: boolean;
+    hovered: boolean;
+    k: number;
+}
+export interface SeriesItem {
+    name: string;
+    type: "surface";
+    parametric: boolean;
+    wireframe: {
+        show: boolean;
+    };
+    itemStyle?: {
+        color?: string;
+        opacity?: number;
+    };
+    pieData: Pie3DDataItem & {
+        startRatio?: number;
+        endRatio?: number;
+    };
+    pieStatus: PieStatus;
+    parametricEquation?: {
+        u: {
+            min: number;
+            max: number;
+            step: number;
+        };
+        v: {
+            min: number;
+            max: number;
+            step: number;
+        };
+        x: (u: number, v: number) => number;
+        y: (u: number, v: number) => number;
+        z: (u: number, v: number) => number;
+    };
+}
+declare const ChartPie3D: React.FC<ChartPie3DProps>;
+export default ChartPie3D;