@fmdevui/fm-dev 1.0.113 → 1.0.114

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/sankey/sankeyLayout.mjs

@@ -0,0 +1,441 @@
+import { filter, each } from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+import { groupData } from '../../util/model.mjs';
+import { createBoxLayoutReference, getLayoutRect } from '../../util/layout.mjs';
+
+function sankeyLayout(ecModel, api) {
+  ecModel.eachSeriesByType('sankey', function (seriesModel) {
+    var nodeWidth = seriesModel.get('nodeWidth');
+    var nodeGap = seriesModel.get('nodeGap');
+    var refContainer = createBoxLayoutReference(seriesModel, api).refContainer;
+    var layoutInfo = getLayoutRect(seriesModel.getBoxLayoutParams(), refContainer);
+    seriesModel.layoutInfo = layoutInfo;
+    var width = layoutInfo.width;
+    var height = layoutInfo.height;
+    var graph = seriesModel.getGraph();
+    var nodes = graph.nodes;
+    var edges = graph.edges;
+    computeNodeValues(nodes);
+    var filteredNodes = filter(nodes, function (node) {
+      return node.getLayout().value === 0;
+    });
+    var iterations = filteredNodes.length !== 0 ? 0 : seriesModel.get('layoutIterations');
+    var orient = seriesModel.get('orient');
+    var nodeAlign = seriesModel.get('nodeAlign');
+    layoutSankey(nodes, edges, nodeWidth, nodeGap, width, height, iterations, orient, nodeAlign);
+  });
+}
+function layoutSankey(nodes, edges, nodeWidth, nodeGap, width, height, iterations, orient, nodeAlign) {
+  computeNodeBreadths(nodes, edges, nodeWidth, width, height, orient, nodeAlign);
+  computeNodeDepths(nodes, edges, height, width, nodeGap, iterations, orient);
+  computeEdgeDepths(nodes, orient);
+}
+/**
+ * Compute the value of each node by summing the associated edge's value
+ */
+function computeNodeValues(nodes) {
+  each(nodes, function (node) {
+    var value1 = sum(node.outEdges, getEdgeValue);
+    var value2 = sum(node.inEdges, getEdgeValue);
+    var nodeRawValue = node.getValue() || 0;
+    var value = Math.max(value1, value2, nodeRawValue);
+    node.setLayout({
+      value: value
+    }, true);
+  });
+}
+/**
+ * Compute the x-position for each node.
+ *
+ * Here we use Kahn algorithm to detect cycle when we traverse
+ * the node to computer the initial x position.
+ */
+function computeNodeBreadths(nodes, edges, nodeWidth, width, height, orient, nodeAlign) {
+  // Used to mark whether the edge is deleted. if it is deleted,
+  // the value is 0, otherwise it is 1.
+  var remainEdges = [];
+  // Storage each node's indegree.
+  var indegreeArr = [];
+  // Used to storage the node with indegree is equal to 0.
+  var zeroIndegrees = [];
+  var nextTargetNode = [];
+  var x = 0;
+  // let kx = 0;
+  for (var i = 0; i < edges.length; i++) {
+    remainEdges[i] = 1;
+  }
+  for (var i = 0; i < nodes.length; i++) {
+    indegreeArr[i] = nodes[i].inEdges.length;
+    if (indegreeArr[i] === 0) {
+      zeroIndegrees.push(nodes[i]);
+    }
+  }
+  var maxNodeDepth = -1;
+  // Traversing nodes using topological sorting to calculate the
+  // horizontal(if orient === 'horizontal') or vertical(if orient === 'vertical')
+  // position of the nodes.
+  while (zeroIndegrees.length) {
+    for (var idx = 0; idx < zeroIndegrees.length; idx++) {
+      var node = zeroIndegrees[idx];
+      var item = node.hostGraph.data.getRawDataItem(node.dataIndex);
+      var isItemDepth = item.depth != null && item.depth >= 0;
+      if (isItemDepth && item.depth > maxNodeDepth) {
+        maxNodeDepth = item.depth;
+      }
+      node.setLayout({
+        depth: isItemDepth ? item.depth : x
+      }, true);
+      orient === 'vertical' ? node.setLayout({
+        dy: nodeWidth
+      }, true) : node.setLayout({
+        dx: nodeWidth
+      }, true);
+      for (var edgeIdx = 0; edgeIdx < node.outEdges.length; edgeIdx++) {
+        var edge = node.outEdges[edgeIdx];
+        var indexEdge = edges.indexOf(edge);
+        remainEdges[indexEdge] = 0;
+        var targetNode = edge.node2;
+        var nodeIndex = nodes.indexOf(targetNode);
+        if (--indegreeArr[nodeIndex] === 0 && nextTargetNode.indexOf(targetNode) < 0) {
+          nextTargetNode.push(targetNode);
+        }
+      }
+    }
+    ++x;
+    zeroIndegrees = nextTargetNode;
+    nextTargetNode = [];
+  }
+  for (var i = 0; i < remainEdges.length; i++) {
+    if (remainEdges[i] === 1) {
+      throw new Error('Sankey is a DAG, the original data has cycle!');
+    }
+  }
+  var maxDepth = maxNodeDepth > x - 1 ? maxNodeDepth : x - 1;
+  if (nodeAlign && nodeAlign !== 'left') {
+    adjustNodeWithNodeAlign(nodes, nodeAlign, orient, maxDepth);
+  }
+  var kx = orient === 'vertical' ? (height - nodeWidth) / maxDepth : (width - nodeWidth) / maxDepth;
+  scaleNodeBreadths(nodes, kx, orient);
+}
+function isNodeDepth(node) {
+  var item = node.hostGraph.data.getRawDataItem(node.dataIndex);
+  return item.depth != null && item.depth >= 0;
+}
+function adjustNodeWithNodeAlign(nodes, nodeAlign, orient, maxDepth) {
+  if (nodeAlign === 'right') {
+    var nextSourceNode = [];
+    var remainNodes = nodes;
+    var nodeHeight = 0;
+    while (remainNodes.length) {
+      for (var i = 0; i < remainNodes.length; i++) {
+        var node = remainNodes[i];
+        node.setLayout({
+          skNodeHeight: nodeHeight
+        }, true);
+        for (var j = 0; j < node.inEdges.length; j++) {
+          var edge = node.inEdges[j];
+          if (nextSourceNode.indexOf(edge.node1) < 0) {
+            nextSourceNode.push(edge.node1);
+          }
+        }
+      }
+      remainNodes = nextSourceNode;
+      nextSourceNode = [];
+      ++nodeHeight;
+    }
+    each(nodes, function (node) {
+      if (!isNodeDepth(node)) {
+        node.setLayout({
+          depth: Math.max(0, maxDepth - node.getLayout().skNodeHeight)
+        }, true);
+      }
+    });
+  } else if (nodeAlign === 'justify') {
+    moveSinksRight(nodes, maxDepth);
+  }
+}
+/**
+ * All the node without outEgdes are assigned maximum x-position and
+ *     be aligned in the last column.
+ *
+ * @param nodes.  node of sankey view.
+ * @param maxDepth.  use to assign to node without outEdges as x-position.
+ */
+function moveSinksRight(nodes, maxDepth) {
+  each(nodes, function (node) {
+    if (!isNodeDepth(node) && !node.outEdges.length) {
+      node.setLayout({
+        depth: maxDepth
+      }, true);
+    }
+  });
+}
+/**
+ * Scale node x-position to the width
+ *
+ * @param nodes  node of sankey view
+ * @param kx   multiple used to scale nodes
+ */
+function scaleNodeBreadths(nodes, kx, orient) {
+  each(nodes, function (node) {
+    var nodeDepth = node.getLayout().depth * kx;
+    orient === 'vertical' ? node.setLayout({
+      y: nodeDepth
+    }, true) : node.setLayout({
+      x: nodeDepth
+    }, true);
+  });
+}
+/**
+ * Using Gauss-Seidel iterations method to compute the node depth(y-position)
+ *
+ * @param nodes  node of sankey view
+ * @param edges  edge of sankey view
+ * @param height  the whole height of the area to draw the view
+ * @param nodeGap  the vertical distance between two nodes
+ *     in the same column.
+ * @param iterations  the number of iterations for the algorithm
+ */
+function computeNodeDepths(nodes, edges, height, width, nodeGap, iterations, orient) {
+  var nodesByBreadth = prepareNodesByBreadth(nodes, orient);
+  initializeNodeDepth(nodesByBreadth, edges, height, width, nodeGap, orient);
+  resolveCollisions(nodesByBreadth, nodeGap, height, width, orient);
+  for (var alpha = 1; iterations > 0; iterations--) {
+    // 0.99 is a experience parameter, ensure that each iterations of
+    // changes as small as possible.
+    alpha *= 0.99;
+    relaxRightToLeft(nodesByBreadth, alpha, orient);
+    resolveCollisions(nodesByBreadth, nodeGap, height, width, orient);
+    relaxLeftToRight(nodesByBreadth, alpha, orient);
+    resolveCollisions(nodesByBreadth, nodeGap, height, width, orient);
+  }
+}
+function prepareNodesByBreadth(nodes, orient) {
+  var nodesByBreadth = [];
+  var keyAttr = orient === 'vertical' ? 'y' : 'x';
+  var groupResult = groupData(nodes, function (node) {
+    return node.getLayout()[keyAttr];
+  });
+  groupResult.keys.sort(function (a, b) {
+    return a - b;
+  });
+  each(groupResult.keys, function (key) {
+    nodesByBreadth.push(groupResult.buckets.get(key));
+  });
+  return nodesByBreadth;
+}
+/**
+ * Compute the original y-position for each node
+ */
+function initializeNodeDepth(nodesByBreadth, edges, height, width, nodeGap, orient) {
+  var minKy = Infinity;
+  each(nodesByBreadth, function (nodes) {
+    var n = nodes.length;
+    var sum = 0;
+    each(nodes, function (node) {
+      sum += node.getLayout().value;
+    });
+    var ky = orient === 'vertical' ? (width - (n - 1) * nodeGap) / sum : (height - (n - 1) * nodeGap) / sum;
+    if (ky < minKy) {
+      minKy = ky;
+    }
+  });
+  each(nodesByBreadth, function (nodes) {
+    each(nodes, function (node, i) {
+      var nodeDy = node.getLayout().value * minKy;
+      if (orient === 'vertical') {
+        node.setLayout({
+          x: i
+        }, true);
+        node.setLayout({
+          dx: nodeDy
+        }, true);
+      } else {
+        node.setLayout({
+          y: i
+        }, true);
+        node.setLayout({
+          dy: nodeDy
+        }, true);
+      }
+    });
+  });
+  each(edges, function (edge) {
+    var edgeDy = +edge.getValue() * minKy;
+    edge.setLayout({
+      dy: edgeDy
+    }, true);
+  });
+}
+/**
+ * Resolve the collision of initialized depth (y-position)
+ */
+function resolveCollisions(nodesByBreadth, nodeGap, height, width, orient) {
+  var keyAttr = orient === 'vertical' ? 'x' : 'y';
+  each(nodesByBreadth, function (nodes) {
+    nodes.sort(function (a, b) {
+      return a.getLayout()[keyAttr] - b.getLayout()[keyAttr];
+    });
+    var nodeX;
+    var node;
+    var dy;
+    var y0 = 0;
+    var n = nodes.length;
+    var nodeDyAttr = orient === 'vertical' ? 'dx' : 'dy';
+    for (var i = 0; i < n; i++) {
+      node = nodes[i];
+      dy = y0 - node.getLayout()[keyAttr];
+      if (dy > 0) {
+        nodeX = node.getLayout()[keyAttr] + dy;
+        orient === 'vertical' ? node.setLayout({
+          x: nodeX
+        }, true) : node.setLayout({
+          y: nodeX
+        }, true);
+      }
+      y0 = node.getLayout()[keyAttr] + node.getLayout()[nodeDyAttr] + nodeGap;
+    }
+    var viewWidth = orient === 'vertical' ? width : height;
+    // If the bottommost node goes outside the bounds, push it back up
+    dy = y0 - nodeGap - viewWidth;
+    if (dy > 0) {
+      nodeX = node.getLayout()[keyAttr] - dy;
+      orient === 'vertical' ? node.setLayout({
+        x: nodeX
+      }, true) : node.setLayout({
+        y: nodeX
+      }, true);
+      y0 = nodeX;
+      for (var i = n - 2; i >= 0; --i) {
+        node = nodes[i];
+        dy = node.getLayout()[keyAttr] + node.getLayout()[nodeDyAttr] + nodeGap - y0;
+        if (dy > 0) {
+          nodeX = node.getLayout()[keyAttr] - dy;
+          orient === 'vertical' ? node.setLayout({
+            x: nodeX
+          }, true) : node.setLayout({
+            y: nodeX
+          }, true);
+        }
+        y0 = node.getLayout()[keyAttr];
+      }
+    }
+  });
+}
+/**
+ * Change the y-position of the nodes, except most the right side nodes
+ * @param nodesByBreadth
+ * @param alpha  parameter used to adjust the nodes y-position
+ */
+function relaxRightToLeft(nodesByBreadth, alpha, orient) {
+  each(nodesByBreadth.slice().reverse(), function (nodes) {
+    each(nodes, function (node) {
+      if (node.outEdges.length) {
+        var y = sum(node.outEdges, weightedTarget, orient) / sum(node.outEdges, getEdgeValue);
+        if (isNaN(y)) {
+          var len = node.outEdges.length;
+          y = len ? sum(node.outEdges, centerTarget, orient) / len : 0;
+        }
+        if (orient === 'vertical') {
+          var nodeX = node.getLayout().x + (y - center(node, orient)) * alpha;
+          node.setLayout({
+            x: nodeX
+          }, true);
+        } else {
+          var nodeY = node.getLayout().y + (y - center(node, orient)) * alpha;
+          node.setLayout({
+            y: nodeY
+          }, true);
+        }
+      }
+    });
+  });
+}
+function weightedTarget(edge, orient) {
+  return center(edge.node2, orient) * edge.getValue();
+}
+function centerTarget(edge, orient) {
+  return center(edge.node2, orient);
+}
+function weightedSource(edge, orient) {
+  return center(edge.node1, orient) * edge.getValue();
+}
+function centerSource(edge, orient) {
+  return center(edge.node1, orient);
+}
+function center(node, orient) {
+  return orient === 'vertical' ? node.getLayout().x + node.getLayout().dx / 2 : node.getLayout().y + node.getLayout().dy / 2;
+}
+function getEdgeValue(edge) {
+  return edge.getValue();
+}
+function sum(array, cb, orient) {
+  var sum = 0;
+  var len = array.length;
+  var i = -1;
+  while (++i < len) {
+    var value = +cb(array[i], orient);
+    if (!isNaN(value)) {
+      sum += value;
+    }
+  }
+  return sum;
+}
+/**
+ * Change the y-position of the nodes, except most the left side nodes
+ */
+function relaxLeftToRight(nodesByBreadth, alpha, orient) {
+  each(nodesByBreadth, function (nodes) {
+    each(nodes, function (node) {
+      if (node.inEdges.length) {
+        var y = sum(node.inEdges, weightedSource, orient) / sum(node.inEdges, getEdgeValue);
+        if (isNaN(y)) {
+          var len = node.inEdges.length;
+          y = len ? sum(node.inEdges, centerSource, orient) / len : 0;
+        }
+        if (orient === 'vertical') {
+          var nodeX = node.getLayout().x + (y - center(node, orient)) * alpha;
+          node.setLayout({
+            x: nodeX
+          }, true);
+        } else {
+          var nodeY = node.getLayout().y + (y - center(node, orient)) * alpha;
+          node.setLayout({
+            y: nodeY
+          }, true);
+        }
+      }
+    });
+  });
+}
+/**
+ * Compute the depth(y-position) of each edge
+ */
+function computeEdgeDepths(nodes, orient) {
+  var keyAttr = orient === 'vertical' ? 'x' : 'y';
+  each(nodes, function (node) {
+    node.outEdges.sort(function (a, b) {
+      return a.node2.getLayout()[keyAttr] - b.node2.getLayout()[keyAttr];
+    });
+    node.inEdges.sort(function (a, b) {
+      return a.node1.getLayout()[keyAttr] - b.node1.getLayout()[keyAttr];
+    });
+  });
+  each(nodes, function (node) {
+    var sy = 0;
+    var ty = 0;
+    each(node.outEdges, function (edge) {
+      edge.setLayout({
+        sy: sy
+      }, true);
+      sy += edge.getLayout().dy;
+    });
+    each(node.inEdges, function (edge) {
+      edge.setLayout({
+        ty: ty
+      }, true);
+      ty += edge.getLayout().dy;
+    });
+  });
+}
+
+export { sankeyLayout as default };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/sankey/sankeyVisual.mjs

@@ -0,0 +1,52 @@
+import { each } from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+import VisualMapping from '../../visual/VisualMapping.mjs';
+
+function sankeyVisual(ecModel) {
+  ecModel.eachSeriesByType('sankey', function (seriesModel) {
+    var graph = seriesModel.getGraph();
+    var nodes = graph.nodes;
+    var edges = graph.edges;
+    if (nodes.length) {
+      var minValue_1 = Infinity;
+      var maxValue_1 = -Infinity;
+      each(nodes, function (node) {
+        var nodeValue = node.getLayout().value;
+        if (nodeValue < minValue_1) {
+          minValue_1 = nodeValue;
+        }
+        if (nodeValue > maxValue_1) {
+          maxValue_1 = nodeValue;
+        }
+      });
+      each(nodes, function (node) {
+        var mapping = new VisualMapping({
+          type: 'color',
+          mappingMethod: 'linear',
+          dataExtent: [minValue_1, maxValue_1],
+          visual: seriesModel.get('color')
+        });
+        var mapValueToColor = mapping.mapValueToVisual(node.getLayout().value);
+        var customColor = node.getModel().get(['itemStyle', 'color']);
+        if (customColor != null) {
+          node.setVisual('color', customColor);
+          node.setVisual('style', {
+            fill: customColor
+          });
+        } else {
+          node.setVisual('color', mapValueToColor);
+          node.setVisual('style', {
+            fill: mapValueToColor
+          });
+        }
+      });
+    }
+    if (edges.length) {
+      each(edges, function (edge) {
+        var edgeStyle = edge.getModel().get('lineStyle');
+        edge.setVisual('style', edgeStyle);
+      });
+    }
+  });
+}
+
+export { sankeyVisual as default };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/scatter/ScatterSeries.mjs

@@ -0,0 +1,78 @@
+import { __extends } from '../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs';
+import createSeriesData from '../helper/createSeriesData.mjs';
+import SeriesModel from '../../model/Series.mjs';
+import tokens from '../../visual/tokens.mjs';
+
+var ScatterSeriesModel = /** @class */function (_super) {
+  __extends(ScatterSeriesModel, _super);
+  function ScatterSeriesModel() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = ScatterSeriesModel.type;
+    _this.hasSymbolVisual = true;
+    return _this;
+  }
+  ScatterSeriesModel.prototype.getInitialData = function (option, ecModel) {
+    return createSeriesData(null, this, {
+      useEncodeDefaulter: true
+    });
+  };
+  ScatterSeriesModel.prototype.getProgressive = function () {
+    var progressive = this.option.progressive;
+    if (progressive == null) {
+      // PENDING
+      return this.option.large ? 5e3 : this.get('progressive');
+    }
+    return progressive;
+  };
+  ScatterSeriesModel.prototype.getProgressiveThreshold = function () {
+    var progressiveThreshold = this.option.progressiveThreshold;
+    if (progressiveThreshold == null) {
+      // PENDING
+      return this.option.large ? 1e4 : this.get('progressiveThreshold');
+    }
+    return progressiveThreshold;
+  };
+  ScatterSeriesModel.prototype.brushSelector = function (dataIndex, data, selectors) {
+    return selectors.point(data.getItemLayout(dataIndex));
+  };
+  ScatterSeriesModel.prototype.getZLevelKey = function () {
+    // Each progressive series has individual key.
+    return this.getData().count() > this.getProgressiveThreshold() ? this.id : '';
+  };
+  ScatterSeriesModel.type = 'series.scatter';
+  ScatterSeriesModel.dependencies = ['grid', 'polar', 'geo', 'singleAxis', 'calendar', 'matrix'];
+  ScatterSeriesModel.defaultOption = {
+    coordinateSystem: 'cartesian2d',
+    // zlevel: 0,
+    z: 2,
+    legendHoverLink: true,
+    symbolSize: 10,
+    // symbolRotate: null,  // 图形旋转控制
+    large: false,
+    // Available when large is true
+    largeThreshold: 2000,
+    // cursor: null,
+    itemStyle: {
+      opacity: 0.8
+      // color: 各异
+    },
+    emphasis: {
+      scale: true
+    },
+    // If clip the overflow graphics
+    // Works on cartesian / polar series
+    clip: true,
+    select: {
+      itemStyle: {
+        borderColor: tokens.color.primary
+      }
+    },
+    universalTransition: {
+      divideShape: 'clone'
+    }
+    // progressive: null
+  };
+  return ScatterSeriesModel;
+}(SeriesModel);
+
+export { ScatterSeriesModel as default };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/scatter/ScatterView.mjs

@@ -0,0 +1,92 @@
+import { __extends } from '../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs';
+import SymbolDraw from '../helper/SymbolDraw.mjs';
+import LargeSymbolDraw from '../helper/LargeSymbolDraw.mjs';
+import pointsLayout from '../../layout/points.mjs';
+import ChartView from '../../view/Chart.mjs';
+
+var ScatterView = /** @class */function (_super) {
+  __extends(ScatterView, _super);
+  function ScatterView() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = ScatterView.type;
+    return _this;
+  }
+  ScatterView.prototype.render = function (seriesModel, ecModel, api) {
+    var data = seriesModel.getData();
+    var symbolDraw = this._updateSymbolDraw(data, seriesModel);
+    symbolDraw.updateData(data, {
+      // TODO
+      // If this parameter should be a shape or a bounding volume
+      // shape will be more general.
+      // But bounding volume like bounding rect will be much faster in the contain calculation
+      clipShape: this._getClipShape(seriesModel)
+    });
+    this._finished = true;
+  };
+  ScatterView.prototype.incrementalPrepareRender = function (seriesModel, ecModel, api) {
+    var data = seriesModel.getData();
+    var symbolDraw = this._updateSymbolDraw(data, seriesModel);
+    symbolDraw.incrementalPrepareUpdate(data);
+    this._finished = false;
+  };
+  ScatterView.prototype.incrementalRender = function (taskParams, seriesModel, ecModel) {
+    this._symbolDraw.incrementalUpdate(taskParams, seriesModel.getData(), {
+      clipShape: this._getClipShape(seriesModel)
+    });
+    this._finished = taskParams.end === seriesModel.getData().count();
+  };
+  ScatterView.prototype.updateTransform = function (seriesModel, ecModel, api) {
+    var data = seriesModel.getData();
+    // Must mark group dirty and make sure the incremental layer will be cleared
+    // PENDING
+    this.group.dirty();
+    if (!this._finished || data.count() > 1e4) {
+      return {
+        update: true
+      };
+    } else {
+      var res = pointsLayout('').reset(seriesModel, ecModel, api);
+      if (res.progress) {
+        res.progress({
+          start: 0,
+          end: data.count(),
+          count: data.count()
+        }, data);
+      }
+      this._symbolDraw.updateLayout(data);
+    }
+  };
+  ScatterView.prototype.eachRendered = function (cb) {
+    this._symbolDraw && this._symbolDraw.eachRendered(cb);
+  };
+  ScatterView.prototype._getClipShape = function (seriesModel) {
+    if (!seriesModel.get('clip', true)) {
+      return;
+    }
+    var coordSys = seriesModel.coordinateSystem;
+    // PENDING make `0.1` configurable, for example, `clipTolerance`?
+    return coordSys && coordSys.getArea && coordSys.getArea(.1);
+  };
+  ScatterView.prototype._updateSymbolDraw = function (data, seriesModel) {
+    var symbolDraw = this._symbolDraw;
+    var pipelineContext = seriesModel.pipelineContext;
+    var isLargeDraw = pipelineContext.large;
+    if (!symbolDraw || isLargeDraw !== this._isLargeDraw) {
+      symbolDraw && symbolDraw.remove();
+      symbolDraw = this._symbolDraw = isLargeDraw ? new LargeSymbolDraw() : new SymbolDraw();
+      this._isLargeDraw = isLargeDraw;
+      this.group.removeAll();
+    }
+    this.group.add(symbolDraw.group);
+    return symbolDraw;
+  };
+  ScatterView.prototype.remove = function (ecModel, api) {
+    this._symbolDraw && this._symbolDraw.remove(true);
+    this._symbolDraw = null;
+  };
+  ScatterView.prototype.dispose = function () {};
+  ScatterView.type = 'scatter';
+  return ScatterView;
+}(ChartView);
+
+export { ScatterView as default };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/scatter/install.mjs

@@ -0,0 +1,19 @@
+import { use } from '../../extension.mjs';
+import ScatterSeriesModel from './ScatterSeries.mjs';
+import ScatterView from './ScatterView.mjs';
+import { install as install$1 } from '../../component/grid/installSimple.mjs';
+import pointsLayout from '../../layout/points.mjs';
+import jitterLayout from './jitterLayout.mjs';
+
+function install(registers) {
+  // In case developer forget to include grid component
+  use(install$1);
+  registers.registerSeriesModel(ScatterSeriesModel);
+  registers.registerChartView(ScatterView);
+  registers.registerLayout(pointsLayout('scatter'));
+}
+function installScatterJitter(registers) {
+  registers.registerLayout(registers.PRIORITY.VISUAL.POST_CHART_LAYOUT, jitterLayout);
+}
+
+export { install, installScatterJitter };