@fecp/mobile 1.0.78 → 1.1.0

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/legend/ScrollableLegendView.mjs

@@ -0,0 +1,313 @@
+import { __extends } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs";
+import { isArray, bind, clone, retrieve2, each, isString } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { createIcon } from "../../util/graphic.mjs";
+import { box } from "../../util/layout.mjs";
+import LegendView from "./LegendView.mjs";
+import Group$1 from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/Group.mjs";
+import ZRText from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/Text.mjs";
+import Rect from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Rect.mjs";
+import { updateProps } from "../../animation/basicTransition.mjs";
+var Group = Group$1;
+var WH = ["width", "height"];
+var XY = ["x", "y"];
+var ScrollableLegendView = (
+  /** @class */
+  function(_super) {
+    __extends(ScrollableLegendView2, _super);
+    function ScrollableLegendView2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = ScrollableLegendView2.type;
+      _this.newlineDisabled = true;
+      _this._currentIndex = 0;
+      return _this;
+    }
+    ScrollableLegendView2.prototype.init = function() {
+      _super.prototype.init.call(this);
+      this.group.add(this._containerGroup = new Group());
+      this._containerGroup.add(this.getContentGroup());
+      this.group.add(this._controllerGroup = new Group());
+    };
+    ScrollableLegendView2.prototype.resetInner = function() {
+      _super.prototype.resetInner.call(this);
+      this._controllerGroup.removeAll();
+      this._containerGroup.removeClipPath();
+      this._containerGroup.__rectSize = null;
+    };
+    ScrollableLegendView2.prototype.renderInner = function(itemAlign, legendModel, ecModel, api, selector, orient, selectorPosition) {
+      var self = this;
+      _super.prototype.renderInner.call(this, itemAlign, legendModel, ecModel, api, selector, orient, selectorPosition);
+      var controllerGroup = this._controllerGroup;
+      var pageIconSize = legendModel.get("pageIconSize", true);
+      var pageIconSizeArr = isArray(pageIconSize) ? pageIconSize : [pageIconSize, pageIconSize];
+      createPageButton("pagePrev", 0);
+      var pageTextStyleModel = legendModel.getModel("pageTextStyle");
+      controllerGroup.add(new ZRText({
+        name: "pageText",
+        style: {
+          // Placeholder to calculate a proper layout.
+          text: "xx/xx",
+          fill: pageTextStyleModel.getTextColor(),
+          font: pageTextStyleModel.getFont(),
+          verticalAlign: "middle",
+          align: "center"
+        },
+        silent: true
+      }));
+      createPageButton("pageNext", 1);
+      function createPageButton(name, iconIdx) {
+        var pageDataIndexName = name + "DataIndex";
+        var icon = createIcon(legendModel.get("pageIcons", true)[legendModel.getOrient().name][iconIdx], {
+          // Buttons will be created in each render, so we do not need
+          // to worry about avoiding using legendModel kept in scope.
+          onclick: bind(self._pageGo, self, pageDataIndexName, legendModel, api)
+        }, {
+          x: -pageIconSizeArr[0] / 2,
+          y: -pageIconSizeArr[1] / 2,
+          width: pageIconSizeArr[0],
+          height: pageIconSizeArr[1]
+        });
+        icon.name = name;
+        controllerGroup.add(icon);
+      }
+    };
+    ScrollableLegendView2.prototype.layoutInner = function(legendModel, itemAlign, maxSize, isFirstRender, selector, selectorPosition) {
+      var selectorGroup = this.getSelectorGroup();
+      var orientIdx = legendModel.getOrient().index;
+      var wh = WH[orientIdx];
+      var xy = XY[orientIdx];
+      var hw = WH[1 - orientIdx];
+      var yx = XY[1 - orientIdx];
+      selector && box(
+        // Buttons in selectorGroup always layout horizontally
+        "horizontal",
+        selectorGroup,
+        legendModel.get("selectorItemGap", true)
+      );
+      var selectorButtonGap = legendModel.get("selectorButtonGap", true);
+      var selectorRect = selectorGroup.getBoundingRect();
+      var selectorPos = [-selectorRect.x, -selectorRect.y];
+      var processMaxSize = clone(maxSize);
+      selector && (processMaxSize[wh] = maxSize[wh] - selectorRect[wh] - selectorButtonGap);
+      var mainRect = this._layoutContentAndController(legendModel, isFirstRender, processMaxSize, orientIdx, wh, hw, yx, xy);
+      if (selector) {
+        if (selectorPosition === "end") {
+          selectorPos[orientIdx] += mainRect[wh] + selectorButtonGap;
+        } else {
+          var offset = selectorRect[wh] + selectorButtonGap;
+          selectorPos[orientIdx] -= offset;
+          mainRect[xy] -= offset;
+        }
+        mainRect[wh] += selectorRect[wh] + selectorButtonGap;
+        selectorPos[1 - orientIdx] += mainRect[yx] + mainRect[hw] / 2 - selectorRect[hw] / 2;
+        mainRect[hw] = Math.max(mainRect[hw], selectorRect[hw]);
+        mainRect[yx] = Math.min(mainRect[yx], selectorRect[yx] + selectorPos[1 - orientIdx]);
+        selectorGroup.x = selectorPos[0];
+        selectorGroup.y = selectorPos[1];
+        selectorGroup.markRedraw();
+      }
+      return mainRect;
+    };
+    ScrollableLegendView2.prototype._layoutContentAndController = function(legendModel, isFirstRender, maxSize, orientIdx, wh, hw, yx, xy) {
+      var contentGroup = this.getContentGroup();
+      var containerGroup = this._containerGroup;
+      var controllerGroup = this._controllerGroup;
+      box(legendModel.get("orient"), contentGroup, legendModel.get("itemGap"), !orientIdx ? null : maxSize.width, orientIdx ? null : maxSize.height);
+      box(
+        // Buttons in controller are layout always horizontally.
+        "horizontal",
+        controllerGroup,
+        legendModel.get("pageButtonItemGap", true)
+      );
+      var contentRect = contentGroup.getBoundingRect();
+      var controllerRect = controllerGroup.getBoundingRect();
+      var showController = this._showController = contentRect[wh] > maxSize[wh];
+      var contentPos = [-contentRect.x, -contentRect.y];
+      if (!isFirstRender) {
+        contentPos[orientIdx] = contentGroup[xy];
+      }
+      var containerPos = [0, 0];
+      var controllerPos = [-controllerRect.x, -controllerRect.y];
+      var pageButtonGap = retrieve2(legendModel.get("pageButtonGap", true), legendModel.get("itemGap", true));
+      if (showController) {
+        var pageButtonPosition = legendModel.get("pageButtonPosition", true);
+        if (pageButtonPosition === "end") {
+          controllerPos[orientIdx] += maxSize[wh] - controllerRect[wh];
+        } else {
+          containerPos[orientIdx] += controllerRect[wh] + pageButtonGap;
+        }
+      }
+      controllerPos[1 - orientIdx] += contentRect[hw] / 2 - controllerRect[hw] / 2;
+      contentGroup.setPosition(contentPos);
+      containerGroup.setPosition(containerPos);
+      controllerGroup.setPosition(controllerPos);
+      var mainRect = {
+        x: 0,
+        y: 0
+      };
+      mainRect[wh] = showController ? maxSize[wh] : contentRect[wh];
+      mainRect[hw] = Math.max(contentRect[hw], controllerRect[hw]);
+      mainRect[yx] = Math.min(0, controllerRect[yx] + controllerPos[1 - orientIdx]);
+      containerGroup.__rectSize = maxSize[wh];
+      if (showController) {
+        var clipShape = {
+          x: 0,
+          y: 0
+        };
+        clipShape[wh] = Math.max(maxSize[wh] - controllerRect[wh] - pageButtonGap, 0);
+        clipShape[hw] = mainRect[hw];
+        containerGroup.setClipPath(new Rect({
+          shape: clipShape
+        }));
+        containerGroup.__rectSize = clipShape[wh];
+      } else {
+        controllerGroup.eachChild(function(child) {
+          child.attr({
+            invisible: true,
+            silent: true
+          });
+        });
+      }
+      var pageInfo = this._getPageInfo(legendModel);
+      pageInfo.pageIndex != null && updateProps(
+        contentGroup,
+        {
+          x: pageInfo.contentPosition[0],
+          y: pageInfo.contentPosition[1]
+        },
+        // When switch from "show controller" to "not show controller", view should be
+        // updated immediately without animation, otherwise causes weird effect.
+        showController ? legendModel : null
+      );
+      this._updatePageInfoView(legendModel, pageInfo);
+      return mainRect;
+    };
+    ScrollableLegendView2.prototype._pageGo = function(to, legendModel, api) {
+      var scrollDataIndex = this._getPageInfo(legendModel)[to];
+      scrollDataIndex != null && api.dispatchAction({
+        type: "legendScroll",
+        scrollDataIndex,
+        legendId: legendModel.id
+      });
+    };
+    ScrollableLegendView2.prototype._updatePageInfoView = function(legendModel, pageInfo) {
+      var controllerGroup = this._controllerGroup;
+      each(["pagePrev", "pageNext"], function(name) {
+        var key = name + "DataIndex";
+        var canJump = pageInfo[key] != null;
+        var icon = controllerGroup.childOfName(name);
+        if (icon) {
+          icon.setStyle("fill", canJump ? legendModel.get("pageIconColor", true) : legendModel.get("pageIconInactiveColor", true));
+          icon.cursor = canJump ? "pointer" : "default";
+        }
+      });
+      var pageText = controllerGroup.childOfName("pageText");
+      var pageFormatter = legendModel.get("pageFormatter");
+      var pageIndex = pageInfo.pageIndex;
+      var current = pageIndex != null ? pageIndex + 1 : 0;
+      var total = pageInfo.pageCount;
+      pageText && pageFormatter && pageText.setStyle("text", isString(pageFormatter) ? pageFormatter.replace("{current}", current == null ? "" : current + "").replace("{total}", total == null ? "" : total + "") : pageFormatter({
+        current,
+        total
+      }));
+    };
+    ScrollableLegendView2.prototype._getPageInfo = function(legendModel) {
+      var scrollDataIndex = legendModel.get("scrollDataIndex", true);
+      var contentGroup = this.getContentGroup();
+      var containerRectSize = this._containerGroup.__rectSize;
+      var orientIdx = legendModel.getOrient().index;
+      var wh = WH[orientIdx];
+      var xy = XY[orientIdx];
+      var targetItemIndex = this._findTargetItemIndex(scrollDataIndex);
+      var children = contentGroup.children();
+      var targetItem = children[targetItemIndex];
+      var itemCount = children.length;
+      var pCount = !itemCount ? 0 : 1;
+      var result = {
+        contentPosition: [contentGroup.x, contentGroup.y],
+        pageCount: pCount,
+        pageIndex: pCount - 1,
+        pagePrevDataIndex: null,
+        pageNextDataIndex: null
+      };
+      if (!targetItem) {
+        return result;
+      }
+      var targetItemInfo = getItemInfo(targetItem);
+      result.contentPosition[orientIdx] = -targetItemInfo.s;
+      for (var i = targetItemIndex + 1, winStartItemInfo = targetItemInfo, winEndItemInfo = targetItemInfo, currItemInfo = null; i <= itemCount; ++i) {
+        currItemInfo = getItemInfo(children[i]);
+        if (
+          // Half of the last item is out of the window.
+          !currItemInfo && winEndItemInfo.e > winStartItemInfo.s + containerRectSize || currItemInfo && !intersect(currItemInfo, winStartItemInfo.s)
+        ) {
+          if (winEndItemInfo.i > winStartItemInfo.i) {
+            winStartItemInfo = winEndItemInfo;
+          } else {
+            winStartItemInfo = currItemInfo;
+          }
+          if (winStartItemInfo) {
+            if (result.pageNextDataIndex == null) {
+              result.pageNextDataIndex = winStartItemInfo.i;
+            }
+            ++result.pageCount;
+          }
+        }
+        winEndItemInfo = currItemInfo;
+      }
+      for (var i = targetItemIndex - 1, winStartItemInfo = targetItemInfo, winEndItemInfo = targetItemInfo, currItemInfo = null; i >= -1; --i) {
+        currItemInfo = getItemInfo(children[i]);
+        if (
+          // If the the end item does not intersect with the window started
+          // from the current item, a page can be settled.
+          (!currItemInfo || !intersect(winEndItemInfo, currItemInfo.s)) && winStartItemInfo.i < winEndItemInfo.i
+        ) {
+          winEndItemInfo = winStartItemInfo;
+          if (result.pagePrevDataIndex == null) {
+            result.pagePrevDataIndex = winStartItemInfo.i;
+          }
+          ++result.pageCount;
+          ++result.pageIndex;
+        }
+        winStartItemInfo = currItemInfo;
+      }
+      return result;
+      function getItemInfo(el) {
+        if (el) {
+          var itemRect = el.getBoundingRect();
+          var start = itemRect[xy] + el[xy];
+          return {
+            s: start,
+            e: start + itemRect[wh],
+            i: el.__legendDataIndex
+          };
+        }
+      }
+      function intersect(itemInfo, winStart) {
+        return itemInfo.e >= winStart && itemInfo.s <= winStart + containerRectSize;
+      }
+    };
+    ScrollableLegendView2.prototype._findTargetItemIndex = function(targetDataIndex) {
+      if (!this._showController) {
+        return 0;
+      }
+      var index;
+      var contentGroup = this.getContentGroup();
+      var defaultIndex;
+      contentGroup.eachChild(function(child, idx) {
+        var legendDataIdx = child.__legendDataIndex;
+        if (defaultIndex == null && legendDataIdx != null) {
+          defaultIndex = idx;
+        }
+        if (legendDataIdx === targetDataIndex) {
+          index = idx;
+        }
+      });
+      return index != null ? index : defaultIndex;
+    };
+    ScrollableLegendView2.type = "legend.scroll";
+    return ScrollableLegendView2;
+  }(LegendView)
+);
+export {
+  ScrollableLegendView as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/legend/install.mjs

@@ -0,0 +1,10 @@
+import { use } from "../../extension.mjs";
+import { install as install$1 } from "./installLegendPlain.mjs";
+import { install as install$2 } from "./installLegendScroll.mjs";
+function install(registers) {
+  use(install$1);
+  use(install$2);
+}
+export {
+  install
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/legend/installLegendPlain.mjs

@@ -0,0 +1,16 @@
+import LegendModel from "./LegendModel.mjs";
+import LegendView from "./LegendView.mjs";
+import legendFilter from "./legendFilter.mjs";
+import { installLegendAction } from "./legendAction.mjs";
+function install(registers) {
+  registers.registerComponentModel(LegendModel);
+  registers.registerComponentView(LegendView);
+  registers.registerProcessor(registers.PRIORITY.PROCESSOR.SERIES_FILTER, legendFilter);
+  registers.registerSubTypeDefaulter("legend", function() {
+    return "plain";
+  });
+  installLegendAction(registers);
+}
+export {
+  install
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/legend/installLegendScroll.mjs

@@ -0,0 +1,14 @@
+import { use } from "../../extension.mjs";
+import { install as install$1 } from "./installLegendPlain.mjs";
+import ScrollableLegendModel from "./ScrollableLegendModel.mjs";
+import ScrollableLegendView from "./ScrollableLegendView.mjs";
+import installScrollableLegendAction from "./scrollableLegendAction.mjs";
+function install(registers) {
+  use(install$1);
+  registers.registerComponentModel(ScrollableLegendModel);
+  registers.registerComponentView(ScrollableLegendView);
+  installScrollableLegendAction(registers);
+}
+export {
+  install
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/legend/legendAction.mjs

@@ -0,0 +1,59 @@
+import { curry, each, hasOwn } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+function legendSelectActionHandler(methodName, payload, ecModel) {
+  var isAllSelect = methodName === "allSelect" || methodName === "inverseSelect";
+  var selectedMap = {};
+  var actionLegendIndices = [];
+  ecModel.eachComponent({
+    mainType: "legend",
+    query: payload
+  }, function(legendModel) {
+    if (isAllSelect) {
+      legendModel[methodName]();
+    } else {
+      legendModel[methodName](payload.name);
+    }
+    makeSelectedMap(legendModel, selectedMap);
+    actionLegendIndices.push(legendModel.componentIndex);
+  });
+  var allSelectedMap = {};
+  ecModel.eachComponent("legend", function(legendModel) {
+    each(selectedMap, function(isSelected, name) {
+      legendModel[isSelected ? "select" : "unSelect"](name);
+    });
+    makeSelectedMap(legendModel, allSelectedMap);
+  });
+  return isAllSelect ? {
+    selected: allSelectedMap,
+    // return legendIndex array to tell the developers which legends are allSelect / inverseSelect
+    legendIndex: actionLegendIndices
+  } : {
+    name: payload.name,
+    selected: allSelectedMap
+  };
+}
+function makeSelectedMap(legendModel, out) {
+  var selectedMap = out || {};
+  each(legendModel.getData(), function(model) {
+    var name = model.get("name");
+    if (name === "\n" || name === "") {
+      return;
+    }
+    var isItemSelected = legendModel.isSelected(name);
+    if (hasOwn(selectedMap, name)) {
+      selectedMap[name] = selectedMap[name] && isItemSelected;
+    } else {
+      selectedMap[name] = isItemSelected;
+    }
+  });
+  return selectedMap;
+}
+function installLegendAction(registers) {
+  registers.registerAction("legendToggleSelect", "legendselectchanged", curry(legendSelectActionHandler, "toggleSelected"));
+  registers.registerAction("legendAllSelect", "legendselectall", curry(legendSelectActionHandler, "allSelect"));
+  registers.registerAction("legendInverseSelect", "legendinverseselect", curry(legendSelectActionHandler, "inverseSelect"));
+  registers.registerAction("legendSelect", "legendselected", curry(legendSelectActionHandler, "select"));
+  registers.registerAction("legendUnSelect", "legendunselected", curry(legendSelectActionHandler, "unSelect"));
+}
+export {
+  installLegendAction
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/legend/legendFilter.mjs

@@ -0,0 +1,18 @@
+function legendFilter(ecModel) {
+  var legendModels = ecModel.findComponents({
+    mainType: "legend"
+  });
+  if (legendModels && legendModels.length) {
+    ecModel.filterSeries(function(series) {
+      for (var i = 0; i < legendModels.length; i++) {
+        if (!legendModels[i].isSelected(series.name)) {
+          return false;
+        }
+      }
+      return true;
+    });
+  }
+}
+export {
+  legendFilter as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/legend/scrollableLegendAction.mjs

@@ -0,0 +1,15 @@
+function installScrollableLegendAction(registers) {
+  registers.registerAction("legendScroll", "legendscroll", function(payload, ecModel) {
+    var scrollDataIndex = payload.scrollDataIndex;
+    scrollDataIndex != null && ecModel.eachComponent({
+      mainType: "legend",
+      subType: "scroll",
+      query: payload
+    }, function(legendModel) {
+      legendModel.setScrollDataIndex(scrollDataIndex);
+    });
+  });
+}
+export {
+  installScrollableLegendAction as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/radar/RadarView.mjs

@@ -0,0 +1,161 @@
+import { __extends } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs";
+import { map, each, isArray, defaults } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import AxisBuilder from "../axis/AxisBuilder.mjs";
+import { mergePath } from "../../util/graphic.mjs";
+import ComponentView from "../../view/Component.mjs";
+import Circle from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Circle.mjs";
+import Ring from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Ring.mjs";
+import Polyline from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Polyline.mjs";
+import Polygon from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Polygon.mjs";
+var axisBuilderAttrs = ["axisLine", "axisTickLabel", "axisName"];
+var RadarView = (
+  /** @class */
+  function(_super) {
+    __extends(RadarView2, _super);
+    function RadarView2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = RadarView2.type;
+      return _this;
+    }
+    RadarView2.prototype.render = function(radarModel, ecModel, api) {
+      var group = this.group;
+      group.removeAll();
+      this._buildAxes(radarModel);
+      this._buildSplitLineAndArea(radarModel);
+    };
+    RadarView2.prototype._buildAxes = function(radarModel) {
+      var radar = radarModel.coordinateSystem;
+      var indicatorAxes = radar.getIndicatorAxes();
+      var axisBuilders = map(indicatorAxes, function(indicatorAxis) {
+        var axisName = indicatorAxis.model.get("showName") ? indicatorAxis.name : "";
+        var axisBuilder = new AxisBuilder(indicatorAxis.model, {
+          axisName,
+          position: [radar.cx, radar.cy],
+          rotation: indicatorAxis.angle,
+          labelDirection: -1,
+          tickDirection: -1,
+          nameDirection: 1
+        });
+        return axisBuilder;
+      });
+      each(axisBuilders, function(axisBuilder) {
+        each(axisBuilderAttrs, axisBuilder.add, axisBuilder);
+        this.group.add(axisBuilder.getGroup());
+      }, this);
+    };
+    RadarView2.prototype._buildSplitLineAndArea = function(radarModel) {
+      var radar = radarModel.coordinateSystem;
+      var indicatorAxes = radar.getIndicatorAxes();
+      if (!indicatorAxes.length) {
+        return;
+      }
+      var shape = radarModel.get("shape");
+      var splitLineModel = radarModel.getModel("splitLine");
+      var splitAreaModel = radarModel.getModel("splitArea");
+      var lineStyleModel = splitLineModel.getModel("lineStyle");
+      var areaStyleModel = splitAreaModel.getModel("areaStyle");
+      var showSplitLine = splitLineModel.get("show");
+      var showSplitArea = splitAreaModel.get("show");
+      var splitLineColors = lineStyleModel.get("color");
+      var splitAreaColors = areaStyleModel.get("color");
+      var splitLineColorsArr = isArray(splitLineColors) ? splitLineColors : [splitLineColors];
+      var splitAreaColorsArr = isArray(splitAreaColors) ? splitAreaColors : [splitAreaColors];
+      var splitLines = [];
+      var splitAreas = [];
+      function getColorIndex(areaOrLine, areaOrLineColorList, idx) {
+        var colorIndex2 = idx % areaOrLineColorList.length;
+        areaOrLine[colorIndex2] = areaOrLine[colorIndex2] || [];
+        return colorIndex2;
+      }
+      if (shape === "circle") {
+        var ticksRadius = indicatorAxes[0].getTicksCoords();
+        var cx = radar.cx;
+        var cy = radar.cy;
+        for (var i = 0; i < ticksRadius.length; i++) {
+          if (showSplitLine) {
+            var colorIndex = getColorIndex(splitLines, splitLineColorsArr, i);
+            splitLines[colorIndex].push(new Circle({
+              shape: {
+                cx,
+                cy,
+                r: ticksRadius[i].coord
+              }
+            }));
+          }
+          if (showSplitArea && i < ticksRadius.length - 1) {
+            var colorIndex = getColorIndex(splitAreas, splitAreaColorsArr, i);
+            splitAreas[colorIndex].push(new Ring({
+              shape: {
+                cx,
+                cy,
+                r0: ticksRadius[i].coord,
+                r: ticksRadius[i + 1].coord
+              }
+            }));
+          }
+        }
+      } else {
+        var realSplitNumber_1;
+        var axesTicksPoints = map(indicatorAxes, function(indicatorAxis, idx) {
+          var ticksCoords = indicatorAxis.getTicksCoords();
+          realSplitNumber_1 = realSplitNumber_1 == null ? ticksCoords.length - 1 : Math.min(ticksCoords.length - 1, realSplitNumber_1);
+          return map(ticksCoords, function(tickCoord) {
+            return radar.coordToPoint(tickCoord.coord, idx);
+          });
+        });
+        var prevPoints = [];
+        for (var i = 0; i <= realSplitNumber_1; i++) {
+          var points = [];
+          for (var j = 0; j < indicatorAxes.length; j++) {
+            points.push(axesTicksPoints[j][i]);
+          }
+          if (points[0]) {
+            points.push(points[0].slice());
+          }
+          if (showSplitLine) {
+            var colorIndex = getColorIndex(splitLines, splitLineColorsArr, i);
+            splitLines[colorIndex].push(new Polyline({
+              shape: {
+                points
+              }
+            }));
+          }
+          if (showSplitArea && prevPoints) {
+            var colorIndex = getColorIndex(splitAreas, splitAreaColorsArr, i - 1);
+            splitAreas[colorIndex].push(new Polygon({
+              shape: {
+                points: points.concat(prevPoints)
+              }
+            }));
+          }
+          prevPoints = points.slice().reverse();
+        }
+      }
+      var lineStyle = lineStyleModel.getLineStyle();
+      var areaStyle = areaStyleModel.getAreaStyle();
+      each(splitAreas, function(splitAreas2, idx) {
+        this.group.add(mergePath(splitAreas2, {
+          style: defaults({
+            stroke: "none",
+            fill: splitAreaColorsArr[idx % splitAreaColorsArr.length]
+          }, areaStyle),
+          silent: true
+        }));
+      }, this);
+      each(splitLines, function(splitLines2, idx) {
+        this.group.add(mergePath(splitLines2, {
+          style: defaults({
+            fill: "none",
+            stroke: splitLineColorsArr[idx % splitLineColorsArr.length]
+          }, lineStyle),
+          silent: true
+        }));
+      }, this);
+    };
+    RadarView2.type = "radar";
+    return RadarView2;
+  }(ComponentView)
+);
+export {
+  RadarView as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/radar/install.mjs

@@ -0,0 +1,21 @@
+import RadarModel from "../../coord/radar/RadarModel.mjs";
+import RadarView from "./RadarView.mjs";
+import Radar from "../../coord/radar/Radar.mjs";
+function install(registers) {
+  registers.registerCoordinateSystem("radar", Radar);
+  registers.registerComponentModel(RadarModel);
+  registers.registerComponentView(RadarView);
+  registers.registerVisual({
+    seriesType: "radar",
+    reset: function(seriesModel) {
+      var data = seriesModel.getData();
+      data.each(function(idx) {
+        data.setItemVisual(idx, "legendIcon", "roundRect");
+      });
+      data.setVisual("legendIcon", "roundRect");
+    }
+  });
+}
+export {
+  install
+};