@fecp/mobile 1.0.78 → 1.1.0

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/chart/helper/Symbol.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const tslib_es6 = require("../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js");
+const symbol = require("../../util/symbol.js");
+const innerStore = require("../../util/innerStore.js");
+const states = require("../../util/states.js");
+const labelHelper = require("./labelHelper.js");
+const util = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const labelStyle = require("../../label/labelStyle.js");
+const Image = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/Image.js");
+const basicTransition = require("../../animation/basicTransition.js");
+const Group = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/Group.js");
+var Symbol$1 = (
+  /** @class */
+  function(_super) {
+    tslib_es6.__extends(Symbol2, _super);
+    function Symbol2(data, idx, seriesScope, opts) {
+      var _this = _super.call(this) || this;
+      _this.updateData(data, idx, seriesScope, opts);
+      return _this;
+    }
+    Symbol2.prototype._createSymbol = function(symbolType, data, idx, symbolSize, keepAspect) {
+      this.removeAll();
+      var symbolPath = symbol.createSymbol(symbolType, -1, -1, 2, 2, null, keepAspect);
+      symbolPath.attr({
+        z2: 100,
+        culling: true,
+        scaleX: symbolSize[0] / 2,
+        scaleY: symbolSize[1] / 2
+      });
+      symbolPath.drift = driftSymbol;
+      this._symbolType = symbolType;
+      this.add(symbolPath);
+    };
+    Symbol2.prototype.stopSymbolAnimation = function(toLastFrame) {
+      this.childAt(0).stopAnimation(null, toLastFrame);
+    };
+    Symbol2.prototype.getSymbolType = function() {
+      return this._symbolType;
+    };
+    Symbol2.prototype.getSymbolPath = function() {
+      return this.childAt(0);
+    };
+    Symbol2.prototype.highlight = function() {
+      states.enterEmphasis(this.childAt(0));
+    };
+    Symbol2.prototype.downplay = function() {
+      states.leaveEmphasis(this.childAt(0));
+    };
+    Symbol2.prototype.setZ = function(zlevel, z) {
+      var symbolPath = this.childAt(0);
+      symbolPath.zlevel = zlevel;
+      symbolPath.z = z;
+    };
+    Symbol2.prototype.setDraggable = function(draggable, hasCursorOption) {
+      var symbolPath = this.childAt(0);
+      symbolPath.draggable = draggable;
+      symbolPath.cursor = !hasCursorOption && draggable ? "move" : symbolPath.cursor;
+    };
+    Symbol2.prototype.updateData = function(data, idx, seriesScope, opts) {
+      this.silent = false;
+      var symbolType = data.getItemVisual(idx, "symbol") || "circle";
+      var seriesModel = data.hostModel;
+      var symbolSize = Symbol2.getSymbolSize(data, idx);
+      var isInit = symbolType !== this._symbolType;
+      var disableAnimation = opts && opts.disableAnimation;
+      if (isInit) {
+        var keepAspect = data.getItemVisual(idx, "symbolKeepAspect");
+        this._createSymbol(symbolType, data, idx, symbolSize, keepAspect);
+      } else {
+        var symbolPath = this.childAt(0);
+        symbolPath.silent = false;
+        var target = {
+          scaleX: symbolSize[0] / 2,
+          scaleY: symbolSize[1] / 2
+        };
+        disableAnimation ? symbolPath.attr(target) : basicTransition.updateProps(symbolPath, target, seriesModel, idx);
+        basicTransition.saveOldStyle(symbolPath);
+      }
+      this._updateCommon(data, idx, symbolSize, seriesScope, opts);
+      if (isInit) {
+        var symbolPath = this.childAt(0);
+        if (!disableAnimation) {
+          var target = {
+            scaleX: this._sizeX,
+            scaleY: this._sizeY,
+            style: {
+              // Always fadeIn. Because it has fadeOut animation when symbol is removed..
+              opacity: symbolPath.style.opacity
+            }
+          };
+          symbolPath.scaleX = symbolPath.scaleY = 0;
+          symbolPath.style.opacity = 0;
+          basicTransition.initProps(symbolPath, target, seriesModel, idx);
+        }
+      }
+      if (disableAnimation) {
+        this.childAt(0).stopAnimation("leave");
+      }
+    };
+    Symbol2.prototype._updateCommon = function(data, idx, symbolSize, seriesScope, opts) {
+      var symbolPath = this.childAt(0);
+      var seriesModel = data.hostModel;
+      var emphasisItemStyle;
+      var blurItemStyle;
+      var selectItemStyle;
+      var focus;
+      var blurScope;
+      var emphasisDisabled;
+      var labelStatesModels;
+      var hoverScale;
+      var cursorStyle;
+      if (seriesScope) {
+        emphasisItemStyle = seriesScope.emphasisItemStyle;
+        blurItemStyle = seriesScope.blurItemStyle;
+        selectItemStyle = seriesScope.selectItemStyle;
+        focus = seriesScope.focus;
+        blurScope = seriesScope.blurScope;
+        labelStatesModels = seriesScope.labelStatesModels;
+        hoverScale = seriesScope.hoverScale;
+        cursorStyle = seriesScope.cursorStyle;
+        emphasisDisabled = seriesScope.emphasisDisabled;
+      }
+      if (!seriesScope || data.hasItemOption) {
+        var itemModel = seriesScope && seriesScope.itemModel ? seriesScope.itemModel : data.getItemModel(idx);
+        var emphasisModel = itemModel.getModel("emphasis");
+        emphasisItemStyle = emphasisModel.getModel("itemStyle").getItemStyle();
+        selectItemStyle = itemModel.getModel(["select", "itemStyle"]).getItemStyle();
+        blurItemStyle = itemModel.getModel(["blur", "itemStyle"]).getItemStyle();
+        focus = emphasisModel.get("focus");
+        blurScope = emphasisModel.get("blurScope");
+        emphasisDisabled = emphasisModel.get("disabled");
+        labelStatesModels = labelStyle.getLabelStatesModels(itemModel);
+        hoverScale = emphasisModel.getShallow("scale");
+        cursorStyle = itemModel.getShallow("cursor");
+      }
+      var symbolRotate = data.getItemVisual(idx, "symbolRotate");
+      symbolPath.attr("rotation", (symbolRotate || 0) * Math.PI / 180 || 0);
+      var symbolOffset = symbol.normalizeSymbolOffset(data.getItemVisual(idx, "symbolOffset"), symbolSize);
+      if (symbolOffset) {
+        symbolPath.x = symbolOffset[0];
+        symbolPath.y = symbolOffset[1];
+      }
+      cursorStyle && symbolPath.attr("cursor", cursorStyle);
+      var symbolStyle = data.getItemVisual(idx, "style");
+      var visualColor = symbolStyle.fill;
+      if (symbolPath instanceof Image.default) {
+        var pathStyle = symbolPath.style;
+        symbolPath.useStyle(util.extend({
+          // TODO other properties like x, y ?
+          image: pathStyle.image,
+          x: pathStyle.x,
+          y: pathStyle.y,
+          width: pathStyle.width,
+          height: pathStyle.height
+        }, symbolStyle));
+      } else {
+        if (symbolPath.__isEmptyBrush) {
+          symbolPath.useStyle(util.extend({}, symbolStyle));
+        } else {
+          symbolPath.useStyle(symbolStyle);
+        }
+        symbolPath.style.decal = null;
+        symbolPath.setColor(visualColor, opts && opts.symbolInnerColor);
+        symbolPath.style.strokeNoScale = true;
+      }
+      var liftZ = data.getItemVisual(idx, "liftZ");
+      var z2Origin = this._z2;
+      if (liftZ != null) {
+        if (z2Origin == null) {
+          this._z2 = symbolPath.z2;
+          symbolPath.z2 += liftZ;
+        }
+      } else if (z2Origin != null) {
+        symbolPath.z2 = z2Origin;
+        this._z2 = null;
+      }
+      var useNameLabel = opts && opts.useNameLabel;
+      labelStyle.setLabelStyle(symbolPath, labelStatesModels, {
+        labelFetcher: seriesModel,
+        labelDataIndex: idx,
+        defaultText: getLabelDefaultText,
+        inheritColor: visualColor,
+        defaultOpacity: symbolStyle.opacity
+      });
+      function getLabelDefaultText(idx2) {
+        return useNameLabel ? data.getName(idx2) : labelHelper.getDefaultLabel(data, idx2);
+      }
+      this._sizeX = symbolSize[0] / 2;
+      this._sizeY = symbolSize[1] / 2;
+      var emphasisState = symbolPath.ensureState("emphasis");
+      emphasisState.style = emphasisItemStyle;
+      symbolPath.ensureState("select").style = selectItemStyle;
+      symbolPath.ensureState("blur").style = blurItemStyle;
+      var scaleRatio = hoverScale == null || hoverScale === true ? Math.max(1.1, 3 / this._sizeY) : isFinite(hoverScale) && hoverScale > 0 ? +hoverScale : 1;
+      emphasisState.scaleX = this._sizeX * scaleRatio;
+      emphasisState.scaleY = this._sizeY * scaleRatio;
+      this.setSymbolScale(1);
+      states.toggleHoverEmphasis(this, focus, blurScope, emphasisDisabled);
+    };
+    Symbol2.prototype.setSymbolScale = function(scale) {
+      this.scaleX = this.scaleY = scale;
+    };
+    Symbol2.prototype.fadeOut = function(cb, seriesModel, opt) {
+      var symbolPath = this.childAt(0);
+      var dataIndex = innerStore.getECData(this).dataIndex;
+      var animationOpt = opt && opt.animation;
+      this.silent = symbolPath.silent = true;
+      if (opt && opt.fadeLabel) {
+        var textContent = symbolPath.getTextContent();
+        if (textContent) {
+          basicTransition.removeElement(textContent, {
+            style: {
+              opacity: 0
+            }
+          }, seriesModel, {
+            dataIndex,
+            removeOpt: animationOpt,
+            cb: function() {
+              symbolPath.removeTextContent();
+            }
+          });
+        }
+      } else {
+        symbolPath.removeTextContent();
+      }
+      basicTransition.removeElement(symbolPath, {
+        style: {
+          opacity: 0
+        },
+        scaleX: 0,
+        scaleY: 0
+      }, seriesModel, {
+        dataIndex,
+        cb,
+        removeOpt: animationOpt
+      });
+    };
+    Symbol2.getSymbolSize = function(data, idx) {
+      return symbol.normalizeSymbolSize(data.getItemVisual(idx, "symbolSize"));
+    };
+    return Symbol2;
+  }(Group.default)
+);
+function driftSymbol(dx, dy) {
+  this.parent.drift(dx, dy);
+}
+exports.default = Symbol$1;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/chart/helper/SymbolDraw.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const graphic = require("../../util/graphic.js");
+const Symbol$1 = require("./Symbol.js");
+const util = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const labelStyle = require("../../label/labelStyle.js");
+const Group = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/Group.js");
+const basicTransition = require("../../animation/basicTransition.js");
+function symbolNeedsDraw(data, point, idx, opt) {
+  return point && !isNaN(point[0]) && !isNaN(point[1]) && !(opt.isIgnore && opt.isIgnore(idx)) && !(opt.clipShape && !opt.clipShape.contain(point[0], point[1])) && data.getItemVisual(idx, "symbol") !== "none";
+}
+function normalizeUpdateOpt(opt) {
+  if (opt != null && !util.isObject(opt)) {
+    opt = {
+      isIgnore: opt
+    };
+  }
+  return opt || {};
+}
+function makeSeriesScope(data) {
+  var seriesModel = data.hostModel;
+  var emphasisModel = seriesModel.getModel("emphasis");
+  return {
+    emphasisItemStyle: emphasisModel.getModel("itemStyle").getItemStyle(),
+    blurItemStyle: seriesModel.getModel(["blur", "itemStyle"]).getItemStyle(),
+    selectItemStyle: seriesModel.getModel(["select", "itemStyle"]).getItemStyle(),
+    focus: emphasisModel.get("focus"),
+    blurScope: emphasisModel.get("blurScope"),
+    emphasisDisabled: emphasisModel.get("disabled"),
+    hoverScale: emphasisModel.get("scale"),
+    labelStatesModels: labelStyle.getLabelStatesModels(seriesModel),
+    cursorStyle: seriesModel.get("cursor")
+  };
+}
+var SymbolDraw = (
+  /** @class */
+  function() {
+    function SymbolDraw2(SymbolCtor) {
+      this.group = new Group.default();
+      this._SymbolCtor = SymbolCtor || Symbol$1.default;
+    }
+    SymbolDraw2.prototype.updateData = function(data, opt) {
+      this._progressiveEls = null;
+      opt = normalizeUpdateOpt(opt);
+      var group = this.group;
+      var seriesModel = data.hostModel;
+      var oldData = this._data;
+      var SymbolCtor = this._SymbolCtor;
+      var disableAnimation = opt.disableAnimation;
+      var seriesScope = makeSeriesScope(data);
+      var symbolUpdateOpt = {
+        disableAnimation
+      };
+      var getSymbolPoint = opt.getSymbolPoint || function(idx) {
+        return data.getItemLayout(idx);
+      };
+      if (!oldData) {
+        group.removeAll();
+      }
+      data.diff(oldData).add(function(newIdx) {
+        var point = getSymbolPoint(newIdx);
+        if (symbolNeedsDraw(data, point, newIdx, opt)) {
+          var symbolEl = new SymbolCtor(data, newIdx, seriesScope, symbolUpdateOpt);
+          symbolEl.setPosition(point);
+          data.setItemGraphicEl(newIdx, symbolEl);
+          group.add(symbolEl);
+        }
+      }).update(function(newIdx, oldIdx) {
+        var symbolEl = oldData.getItemGraphicEl(oldIdx);
+        var point = getSymbolPoint(newIdx);
+        if (!symbolNeedsDraw(data, point, newIdx, opt)) {
+          group.remove(symbolEl);
+          return;
+        }
+        var newSymbolType = data.getItemVisual(newIdx, "symbol") || "circle";
+        var oldSymbolType = symbolEl && symbolEl.getSymbolType && symbolEl.getSymbolType();
+        if (!symbolEl || oldSymbolType && oldSymbolType !== newSymbolType) {
+          group.remove(symbolEl);
+          symbolEl = new SymbolCtor(data, newIdx, seriesScope, symbolUpdateOpt);
+          symbolEl.setPosition(point);
+        } else {
+          symbolEl.updateData(data, newIdx, seriesScope, symbolUpdateOpt);
+          var target = {
+            x: point[0],
+            y: point[1]
+          };
+          disableAnimation ? symbolEl.attr(target) : basicTransition.updateProps(symbolEl, target, seriesModel);
+        }
+        group.add(symbolEl);
+        data.setItemGraphicEl(newIdx, symbolEl);
+      }).remove(function(oldIdx) {
+        var el = oldData.getItemGraphicEl(oldIdx);
+        el && el.fadeOut(function() {
+          group.remove(el);
+        }, seriesModel);
+      }).execute();
+      this._getSymbolPoint = getSymbolPoint;
+      this._data = data;
+    };
+    SymbolDraw2.prototype.updateLayout = function() {
+      var _this = this;
+      var data = this._data;
+      if (data) {
+        data.eachItemGraphicEl(function(el, idx) {
+          var point = _this._getSymbolPoint(idx);
+          el.setPosition(point);
+          el.markRedraw();
+        });
+      }
+    };
+    SymbolDraw2.prototype.incrementalPrepareUpdate = function(data) {
+      this._seriesScope = makeSeriesScope(data);
+      this._data = null;
+      this.group.removeAll();
+    };
+    SymbolDraw2.prototype.incrementalUpdate = function(taskParams, data, opt) {
+      this._progressiveEls = [];
+      opt = normalizeUpdateOpt(opt);
+      function updateIncrementalAndHover(el2) {
+        if (!el2.isGroup) {
+          el2.incremental = true;
+          el2.ensureState("emphasis").hoverLayer = true;
+        }
+      }
+      for (var idx = taskParams.start; idx < taskParams.end; idx++) {
+        var point = data.getItemLayout(idx);
+        if (symbolNeedsDraw(data, point, idx, opt)) {
+          var el = new this._SymbolCtor(data, idx, this._seriesScope);
+          el.traverse(updateIncrementalAndHover);
+          el.setPosition(point);
+          this.group.add(el);
+          data.setItemGraphicEl(idx, el);
+          this._progressiveEls.push(el);
+        }
+      }
+    };
+    SymbolDraw2.prototype.eachRendered = function(cb) {
+      graphic.traverseElements(this._progressiveEls || this.group, cb);
+    };
+    SymbolDraw2.prototype.remove = function(enableAnimation) {
+      var group = this.group;
+      var data = this._data;
+      if (data && enableAnimation) {
+        data.eachItemGraphicEl(function(el) {
+          el.fadeOut(function() {
+            group.remove(el);
+          }, data.hostModel);
+        });
+      } else {
+        group.removeAll();
+      }
+    };
+    return SymbolDraw2;
+  }()
+);
+exports.default = SymbolDraw;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/chart/helper/createClipPathFromCoordSys.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const number = require("../../util/number.js");
+const util = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const Rect = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Rect.js");
+const Sector = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/shape/Sector.js");
+const basicTransition = require("../../animation/basicTransition.js");
+function createGridClipPath(cartesian, hasAnimation, seriesModel, done, during) {
+  var rect = cartesian.getArea();
+  var x = rect.x;
+  var y = rect.y;
+  var width = rect.width;
+  var height = rect.height;
+  var lineWidth = seriesModel.get(["lineStyle", "width"]) || 0;
+  x -= lineWidth / 2;
+  y -= lineWidth / 2;
+  width += lineWidth;
+  height += lineWidth;
+  width = Math.ceil(width);
+  if (x !== Math.floor(x)) {
+    x = Math.floor(x);
+    width++;
+  }
+  var clipPath = new Rect.default({
+    shape: {
+      x,
+      y,
+      width,
+      height
+    }
+  });
+  if (hasAnimation) {
+    var baseAxis = cartesian.getBaseAxis();
+    var isHorizontal = baseAxis.isHorizontal();
+    var isAxisInversed = baseAxis.inverse;
+    if (isHorizontal) {
+      if (isAxisInversed) {
+        clipPath.shape.x += width;
+      }
+      clipPath.shape.width = 0;
+    } else {
+      if (!isAxisInversed) {
+        clipPath.shape.y += height;
+      }
+      clipPath.shape.height = 0;
+    }
+    var duringCb = util.isFunction(during) ? function(percent) {
+      during(percent, clipPath);
+    } : null;
+    basicTransition.initProps(clipPath, {
+      shape: {
+        width,
+        height,
+        x,
+        y
+      }
+    }, seriesModel, null, done, duringCb);
+  }
+  return clipPath;
+}
+function createPolarClipPath(polar, hasAnimation, seriesModel) {
+  var sectorArea = polar.getArea();
+  var r0 = number.round(sectorArea.r0, 1);
+  var r = number.round(sectorArea.r, 1);
+  var clipPath = new Sector.default({
+    shape: {
+      cx: number.round(polar.cx, 1),
+      cy: number.round(polar.cy, 1),
+      r0,
+      r,
+      startAngle: sectorArea.startAngle,
+      endAngle: sectorArea.endAngle,
+      clockwise: sectorArea.clockwise
+    }
+  });
+  if (hasAnimation) {
+    var isRadial = polar.getBaseAxis().dim === "angle";
+    if (isRadial) {
+      clipPath.shape.endAngle = sectorArea.startAngle;
+    } else {
+      clipPath.shape.r = r0;
+    }
+    basicTransition.initProps(clipPath, {
+      shape: {
+        endAngle: sectorArea.endAngle,
+        r
+      }
+    }, seriesModel);
+  }
+  return clipPath;
+}
+function createClipPath(coordSys, hasAnimation, seriesModel, done, during) {
+  if (!coordSys) {
+    return null;
+  } else if (coordSys.type === "polar") {
+    return createPolarClipPath(coordSys, hasAnimation, seriesModel);
+  } else if (coordSys.type === "cartesian2d") {
+    return createGridClipPath(coordSys, hasAnimation, seriesModel, done, during);
+  }
+  return null;
+}
+exports.createClipPath = createClipPath;
+exports.createGridClipPath = createGridClipPath;
+exports.createPolarClipPath = createPolarClipPath;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/chart/helper/createRenderPlanner.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const model = require("../../util/model.js");
+function createRenderPlanner() {
+  var inner = model.makeInner();
+  return function(seriesModel) {
+    var fields = inner(seriesModel);
+    var pipelineContext = seriesModel.pipelineContext;
+    var originalLarge = !!fields.large;
+    var originalProgressive = !!fields.progressiveRender;
+    var large = fields.large = !!(pipelineContext && pipelineContext.large);
+    var progressive = fields.progressiveRender = !!(pipelineContext && pipelineContext.progressiveRender);
+    return !!(originalLarge !== large || originalProgressive !== progressive) && "reset";
+  };
+}
+exports.default = createRenderPlanner;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/chart/helper/createSeriesData.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const util = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const SeriesData = require("../../data/SeriesData.js");
+const createDimensions = require("../../data/helper/createDimensions.js");
+const dimensionHelper = require("../../data/helper/dimensionHelper.js");
+const model = require("../../util/model.js");
+const CoordinateSystem = require("../../core/CoordinateSystem.js");
+const referHelper = require("../../model/referHelper.js");
+const dataStackHelper = require("../../data/helper/dataStackHelper.js");
+const sourceHelper = require("../../data/helper/sourceHelper.js");
+const types = require("../../util/types.js");
+function getCoordSysDimDefs(seriesModel, coordSysInfo) {
+  var coordSysName = seriesModel.get("coordinateSystem");
+  var registeredCoordSys = CoordinateSystem.default.get(coordSysName);
+  var coordSysDimDefs;
+  if (coordSysInfo && coordSysInfo.coordSysDims) {
+    coordSysDimDefs = util.map(coordSysInfo.coordSysDims, function(dim) {
+      var dimInfo = {
+        name: dim
+      };
+      var axisModel = coordSysInfo.axisMap.get(dim);
+      if (axisModel) {
+        var axisType = axisModel.get("type");
+        dimInfo.type = dimensionHelper.getDimensionTypeByAxis(axisType);
+      }
+      return dimInfo;
+    });
+  }
+  if (!coordSysDimDefs) {
+    coordSysDimDefs = registeredCoordSys && (registeredCoordSys.getDimensionsInfo ? registeredCoordSys.getDimensionsInfo() : registeredCoordSys.dimensions.slice()) || ["x", "y"];
+  }
+  return coordSysDimDefs;
+}
+function injectOrdinalMeta(dimInfoList, createInvertedIndices, coordSysInfo) {
+  var firstCategoryDimIndex;
+  var hasNameEncode;
+  coordSysInfo && util.each(dimInfoList, function(dimInfo, dimIndex) {
+    var coordDim = dimInfo.coordDim;
+    var categoryAxisModel = coordSysInfo.categoryAxisMap.get(coordDim);
+    if (categoryAxisModel) {
+      if (firstCategoryDimIndex == null) {
+        firstCategoryDimIndex = dimIndex;
+      }
+      dimInfo.ordinalMeta = categoryAxisModel.getOrdinalMeta();
+      if (createInvertedIndices) {
+        dimInfo.createInvertedIndices = true;
+      }
+    }
+    if (dimInfo.otherDims.itemName != null) {
+      hasNameEncode = true;
+    }
+  });
+  if (!hasNameEncode && firstCategoryDimIndex != null) {
+    dimInfoList[firstCategoryDimIndex].otherDims.itemName = 0;
+  }
+  return firstCategoryDimIndex;
+}
+function createSeriesData(sourceRaw, seriesModel, opt) {
+  opt = opt || {};
+  var sourceManager = seriesModel.getSourceManager();
+  var source;
+  var isOriginalSource = false;
+  {
+    source = sourceManager.getSource();
+    isOriginalSource = source.sourceFormat === types.SOURCE_FORMAT_ORIGINAL;
+  }
+  var coordSysInfo = referHelper.getCoordSysInfoBySeries(seriesModel);
+  var coordSysDimDefs = getCoordSysDimDefs(seriesModel, coordSysInfo);
+  var useEncodeDefaulter = opt.useEncodeDefaulter;
+  var encodeDefaulter = util.isFunction(useEncodeDefaulter) ? useEncodeDefaulter : useEncodeDefaulter ? util.curry(sourceHelper.makeSeriesEncodeForAxisCoordSys, coordSysDimDefs, seriesModel) : null;
+  var createDimensionOptions = {
+    coordDimensions: coordSysDimDefs,
+    generateCoord: opt.generateCoord,
+    encodeDefine: seriesModel.getEncode(),
+    encodeDefaulter,
+    canOmitUnusedDimensions: !isOriginalSource
+  };
+  var schema = createDimensions.default(source, createDimensionOptions);
+  var firstCategoryDimIndex = injectOrdinalMeta(schema.dimensions, opt.createInvertedIndices, coordSysInfo);
+  var store = !isOriginalSource ? sourceManager.getSharedDataStore(schema) : null;
+  var stackCalculationInfo = dataStackHelper.enableDataStack(seriesModel, {
+    schema,
+    store
+  });
+  var data = new SeriesData.default(schema, seriesModel);
+  data.setCalculationInfo(stackCalculationInfo);
+  var dimValueGetter = firstCategoryDimIndex != null && isNeedCompleteOrdinalData(source) ? function(itemOpt, dimName, dataIndex, dimIndex) {
+    return dimIndex === firstCategoryDimIndex ? dataIndex : this.defaultDimValueGetter(itemOpt, dimName, dataIndex, dimIndex);
+  } : null;
+  data.hasItemOption = false;
+  data.initData(
+    // Try to reuse the data store in sourceManager if using dataset.
+    isOriginalSource ? source : store,
+    null,
+    dimValueGetter
+  );
+  return data;
+}
+function isNeedCompleteOrdinalData(source) {
+  if (source.sourceFormat === types.SOURCE_FORMAT_ORIGINAL) {
+    var sampleItem = firstDataNotNull(source.data || []);
+    return !util.isArray(model.getDataItemValue(sampleItem));
+  }
+}
+function firstDataNotNull(arr) {
+  var i = 0;
+  while (i < arr.length && arr[i] == null) {
+    i++;
+  }
+  return arr[i];
+}
+exports.default = createSeriesData;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/chart/helper/createSeriesDataSimply.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const createDimensions = require("../../data/helper/createDimensions.js");
+const SeriesData = require("../../data/SeriesData.js");
+const util = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+function createSeriesDataSimply(seriesModel, opt, nameList) {
+  opt = util.isArray(opt) && {
+    coordDimensions: opt
+  } || util.extend({
+    encodeDefine: seriesModel.getEncode()
+  }, opt);
+  var source = seriesModel.getSource();
+  var dimensions = createDimensions.default(source, opt).dimensions;
+  var list = new SeriesData.default(dimensions, seriesModel);
+  list.initData(source, nameList);
+  return list;
+}
+exports.default = createSeriesDataSimply;