sun-card-design 1.1.33 → 1.1.35

package/dist/pc/sun-card-design-pc.es1821.js

@@ -1,11 +1,229 @@
-import { circularLayout } from "./sun-card-design-pc.es2067.js";
-function graphCircularLayout(ecModel) {
-  ecModel.eachSeriesByType("graph", function(seriesModel) {
-    if (seriesModel.get("layout") === "circular") {
-      circularLayout(seriesModel, "symbolSize");
+import { __extends } from "./sun-card-design-pc.es1726.js";
+import SeriesData from "./sun-card-design-pc.es2059.js";
+import { each, map, extend } from "./sun-card-design-pc.es931.js";
+import { defaultEmphasis } from "./sun-card-design-pc.es1738.js";
+import Model from "./sun-card-design-pc.es1766.js";
+import createGraphFromNodeEdge from "./sun-card-design-pc.es2060.js";
+import LegendVisualProvider from "./sun-card-design-pc.es2036.js";
+import SeriesModel from "./sun-card-design-pc.es930.js";
+import { createTooltipMarkup } from "./sun-card-design-pc.es2027.js";
+import { defaultSeriesFormatTooltip } from "./sun-card-design-pc.es1771.js";
+import { initCurvenessList, createEdgeMapForCurveness } from "./sun-card-design-pc.es2055.js";
+var GraphSeriesModel = (
+  /** @class */
+  (function(_super) {
+    __extends(GraphSeriesModel2, _super);
+    function GraphSeriesModel2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = GraphSeriesModel2.type;
+      _this.hasSymbolVisual = true;
+      return _this;
     }
-  });
-}
+    GraphSeriesModel2.prototype.init = function(option) {
+      _super.prototype.init.apply(this, arguments);
+      var self = this;
+      function getCategoriesData() {
+        return self._categoriesData;
+      }
+      this.legendVisualProvider = new LegendVisualProvider(getCategoriesData, getCategoriesData);
+      this.fillDataTextStyle(option.edges || option.links);
+      this._updateCategoriesData();
+    };
+    GraphSeriesModel2.prototype.mergeOption = function(option) {
+      _super.prototype.mergeOption.apply(this, arguments);
+      this.fillDataTextStyle(option.edges || option.links);
+      this._updateCategoriesData();
+    };
+    GraphSeriesModel2.prototype.mergeDefaultAndTheme = function(option) {
+      _super.prototype.mergeDefaultAndTheme.apply(this, arguments);
+      defaultEmphasis(option, "edgeLabel", ["show"]);
+    };
+    GraphSeriesModel2.prototype.getInitialData = function(option, ecModel) {
+      var edges = option.edges || option.links || [];
+      var nodes = option.data || option.nodes || [];
+      var self = this;
+      if (nodes && edges) {
+        initCurvenessList(this);
+        var graph = createGraphFromNodeEdge(nodes, edges, this, true, beforeLink);
+        each(graph.edges, function(edge) {
+          createEdgeMapForCurveness(edge.node1, edge.node2, this, edge.dataIndex);
+        }, this);
+        return graph.data;
+      }
+      function beforeLink(nodeData, edgeData) {
+        nodeData.wrapMethod("getItemModel", function(model) {
+          var categoriesModels = self._categoriesModels;
+          var categoryIdx = model.getShallow("category");
+          var categoryModel = categoriesModels[categoryIdx];
+          if (categoryModel) {
+            categoryModel.parentModel = model.parentModel;
+            model.parentModel = categoryModel;
+          }
+          return model;
+        });
+        var oldGetModel = Model.prototype.getModel;
+        function newGetModel(path, parentModel) {
+          var model = oldGetModel.call(this, path, parentModel);
+          model.resolveParentPath = resolveParentPath;
+          return model;
+        }
+        edgeData.wrapMethod("getItemModel", function(model) {
+          model.resolveParentPath = resolveParentPath;
+          model.getModel = newGetModel;
+          return model;
+        });
+        function resolveParentPath(pathArr) {
+          if (pathArr && (pathArr[0] === "label" || pathArr[1] === "label")) {
+            var newPathArr = pathArr.slice();
+            if (pathArr[0] === "label") {
+              newPathArr[0] = "edgeLabel";
+            } else if (pathArr[1] === "label") {
+              newPathArr[1] = "edgeLabel";
+            }
+            return newPathArr;
+          }
+          return pathArr;
+        }
+      }
+    };
+    GraphSeriesModel2.prototype.getGraph = function() {
+      return this.getData().graph;
+    };
+    GraphSeriesModel2.prototype.getEdgeData = function() {
+      return this.getGraph().edgeData;
+    };
+    GraphSeriesModel2.prototype.getCategoriesData = function() {
+      return this._categoriesData;
+    };
+    GraphSeriesModel2.prototype.formatTooltip = function(dataIndex, multipleSeries, dataType) {
+      if (dataType === "edge") {
+        var nodeData = this.getData();
+        var params = this.getDataParams(dataIndex, dataType);
+        var edge = nodeData.graph.getEdgeByIndex(dataIndex);
+        var sourceName = nodeData.getName(edge.node1.dataIndex);
+        var targetName = nodeData.getName(edge.node2.dataIndex);
+        var nameArr = [];
+        sourceName != null && nameArr.push(sourceName);
+        targetName != null && nameArr.push(targetName);
+        return createTooltipMarkup("nameValue", {
+          name: nameArr.join(" > "),
+          value: params.value,
+          noValue: params.value == null
+        });
+      }
+      var nodeMarkup = defaultSeriesFormatTooltip({
+        series: this,
+        dataIndex,
+        multipleSeries
+      });
+      return nodeMarkup;
+    };
+    GraphSeriesModel2.prototype._updateCategoriesData = function() {
+      var categories = map(this.option.categories || [], function(category) {
+        return category.value != null ? category : extend({
+          value: 0
+        }, category);
+      });
+      var categoriesData = new SeriesData(["value"], this);
+      categoriesData.initData(categories);
+      this._categoriesData = categoriesData;
+      this._categoriesModels = categoriesData.mapArray(function(idx) {
+        return categoriesData.getItemModel(idx);
+      });
+    };
+    GraphSeriesModel2.prototype.setZoom = function(zoom) {
+      this.option.zoom = zoom;
+    };
+    GraphSeriesModel2.prototype.setCenter = function(center) {
+      this.option.center = center;
+    };
+    GraphSeriesModel2.prototype.isAnimationEnabled = function() {
+      return _super.prototype.isAnimationEnabled.call(this) && !(this.get("layout") === "force" && this.get(["force", "layoutAnimation"]));
+    };
+    GraphSeriesModel2.type = "series.graph";
+    GraphSeriesModel2.dependencies = ["grid", "polar", "geo", "singleAxis", "calendar"];
+    GraphSeriesModel2.defaultOption = {
+      // zlevel: 0,
+      z: 2,
+      coordinateSystem: "view",
+      // Default option for all coordinate systems
+      // xAxisIndex: 0,
+      // yAxisIndex: 0,
+      // polarIndex: 0,
+      // geoIndex: 0,
+      legendHoverLink: true,
+      layout: null,
+      // Configuration of circular layout
+      circular: {
+        rotateLabel: false
+      },
+      // Configuration of force directed layout
+      force: {
+        initLayout: null,
+        // Node repulsion. Can be an array to represent range.
+        repulsion: [0, 50],
+        gravity: 0.1,
+        // Initial friction
+        friction: 0.6,
+        // Edge length. Can be an array to represent range.
+        edgeLength: 30,
+        layoutAnimation: true
+      },
+      left: "center",
+      top: "center",
+      // right: null,
+      // bottom: null,
+      // width: '80%',
+      // height: '80%',
+      symbol: "circle",
+      symbolSize: 10,
+      edgeSymbol: ["none", "none"],
+      edgeSymbolSize: 10,
+      edgeLabel: {
+        position: "middle",
+        distance: 5
+      },
+      draggable: false,
+      roam: false,
+      // Default on center of graph
+      center: null,
+      zoom: 1,
+      // Symbol size scale ratio in roam
+      nodeScaleRatio: 0.6,
+      // cursor: null,
+      // categories: [],
+      // data: []
+      // Or
+      // nodes: []
+      //
+      // links: []
+      // Or
+      // edges: []
+      label: {
+        show: false,
+        formatter: "{b}"
+      },
+      itemStyle: {},
+      lineStyle: {
+        color: "#aaa",
+        width: 1,
+        opacity: 0.5
+      },
+      emphasis: {
+        scale: true,
+        label: {
+          show: true
+        }
+      },
+      select: {
+        itemStyle: {
+          borderColor: "#212121"
+        }
+      }
+    };
+    return GraphSeriesModel2;
+  })(SeriesModel)
+);
 export {
-  graphCircularLayout as default
+  GraphSeriesModel as default
 };

package/dist/pc/sun-card-design-pc.es1822.js

@@ -1,114 +1,37 @@
-import { forceLayout } from "./sun-card-design-pc.es2068.js";
-import { simpleLayout } from "./sun-card-design-pc.es2066.js";
-import { circularLayout } from "./sun-card-design-pc.es2067.js";
-import { linearMap } from "./sun-card-design-pc.es1979.js";
-import { copy } from "./sun-card-design-pc.es1982.js";
-import { isArray, retrieve3 } from "./sun-card-design-pc.es932.js";
-import { getCurvenessForEdge } from "./sun-card-design-pc.es2069.js";
-function graphForceLayout(ecModel) {
-  ecModel.eachSeriesByType("graph", function(graphSeries) {
-    var coordSys = graphSeries.coordinateSystem;
-    if (coordSys && coordSys.type !== "view") {
-      return;
-    }
-    if (graphSeries.get("layout") === "force") {
-      var preservedPoints_1 = graphSeries.preservedPoints || {};
-      var graph_1 = graphSeries.getGraph();
-      var nodeData_1 = graph_1.data;
-      var edgeData = graph_1.edgeData;
-      var forceModel = graphSeries.getModel("force");
-      var initLayout = forceModel.get("initLayout");
-      if (graphSeries.preservedPoints) {
-        nodeData_1.each(function(idx) {
-          var id = nodeData_1.getId(idx);
-          nodeData_1.setItemLayout(idx, preservedPoints_1[id] || [NaN, NaN]);
-        });
-      } else if (!initLayout || initLayout === "none") {
-        simpleLayout(graphSeries);
-      } else if (initLayout === "circular") {
-        circularLayout(graphSeries, "value");
-      }
-      var nodeDataExtent_1 = nodeData_1.getDataExtent("value");
-      var edgeDataExtent_1 = edgeData.getDataExtent("value");
-      var repulsion = forceModel.get("repulsion");
-      var edgeLength = forceModel.get("edgeLength");
-      var repulsionArr_1 = isArray(repulsion) ? repulsion : [repulsion, repulsion];
-      var edgeLengthArr_1 = isArray(edgeLength) ? edgeLength : [edgeLength, edgeLength];
-      edgeLengthArr_1 = [edgeLengthArr_1[1], edgeLengthArr_1[0]];
-      var nodes_1 = nodeData_1.mapArray("value", function(value, idx) {
-        var point = nodeData_1.getItemLayout(idx);
-        var rep = linearMap(value, nodeDataExtent_1, repulsionArr_1);
-        if (isNaN(rep)) {
-          rep = (repulsionArr_1[0] + repulsionArr_1[1]) / 2;
-        }
-        return {
-          w: rep,
-          rep,
-          fixed: nodeData_1.getItemModel(idx).get("fixed"),
-          p: !point || isNaN(point[0]) || isNaN(point[1]) ? null : point
-        };
-      });
-      var edges = edgeData.mapArray("value", function(value, idx) {
-        var edge = graph_1.getEdgeByIndex(idx);
-        var d = linearMap(value, edgeDataExtent_1, edgeLengthArr_1);
-        if (isNaN(d)) {
-          d = (edgeLengthArr_1[0] + edgeLengthArr_1[1]) / 2;
-        }
-        var edgeModel = edge.getModel();
-        var curveness = retrieve3(edge.getModel().get(["lineStyle", "curveness"]), -getCurvenessForEdge(edge, graphSeries, idx, true), 0);
-        return {
-          n1: nodes_1[edge.node1.dataIndex],
-          n2: nodes_1[edge.node2.dataIndex],
-          d,
-          curveness,
-          ignoreForceLayout: edgeModel.get("ignoreForceLayout")
-        };
-      });
-      var rect = coordSys.getBoundingRect();
-      var forceInstance = forceLayout(nodes_1, edges, {
-        rect,
-        gravity: forceModel.get("gravity"),
-        friction: forceModel.get("friction")
-      });
-      forceInstance.beforeStep(function(nodes, edges2) {
-        for (var i = 0, l = nodes.length; i < l; i++) {
-          if (nodes[i].fixed) {
-            copy(nodes[i].p, graph_1.getNodeByIndex(i).getLayout());
-          }
-        }
-      });
-      forceInstance.afterStep(function(nodes, edges2, stopped) {
-        for (var i = 0, l = nodes.length; i < l; i++) {
-          if (!nodes[i].fixed) {
-            graph_1.getNodeByIndex(i).setLayout(nodes[i].p);
-          }
-          preservedPoints_1[nodeData_1.getId(i)] = nodes[i].p;
-        }
-        for (var i = 0, l = edges2.length; i < l; i++) {
-          var e = edges2[i];
-          var edge = graph_1.getEdgeByIndex(i);
-          var p1 = e.n1.p;
-          var p2 = e.n2.p;
-          var points = edge.getLayout();
-          points = points ? points.slice() : [];
-          points[0] = points[0] || [];
-          points[1] = points[1] || [];
-          copy(points[0], p1);
-          copy(points[1], p2);
-          if (+e.curveness) {
-            points[2] = [(p1[0] + p2[0]) / 2 - (p1[1] - p2[1]) * e.curveness, (p1[1] + p2[1]) / 2 - (p2[0] - p1[0]) * e.curveness];
-          }
-          edge.setLayout(points);
-        }
-      });
-      graphSeries.forceLayout = forceInstance;
-      graphSeries.preservedPoints = preservedPoints_1;
-      forceInstance.step();
-    } else {
-      graphSeries.forceLayout = null;
+function getCenterCoord(view, point) {
+  return view.pointToProjected ? view.pointToProjected(point) : view.pointToData(point);
+}
+function updateCenterAndZoom(view, payload, zoomLimit, api) {
+  var previousZoom = view.getZoom();
+  var center = view.getCenter();
+  var zoom = payload.zoom;
+  var point = view.projectedToPoint ? view.projectedToPoint(center) : view.dataToPoint(center);
+  if (payload.dx != null && payload.dy != null) {
+    point[0] -= payload.dx;
+    point[1] -= payload.dy;
+    view.setCenter(getCenterCoord(view, point), api);
+  }
+  if (zoom != null) {
+    if (zoomLimit) {
+      var zoomMin = zoomLimit.min || 0;
+      var zoomMax = zoomLimit.max || Infinity;
+      zoom = Math.max(Math.min(previousZoom * zoom, zoomMax), zoomMin) / previousZoom;
     }
-  });
+    view.scaleX *= zoom;
+    view.scaleY *= zoom;
+    var fixX = (payload.originX - view.x) * (zoom - 1);
+    var fixY = (payload.originY - view.y) * (zoom - 1);
+    view.x -= fixX;
+    view.y -= fixY;
+    view.updateTransform();
+    view.setCenter(getCenterCoord(view, point), api);
+    view.setZoom(zoom * previousZoom);
+  }
+  return {
+    center: view.getCenter(),
+    zoom: view.getZoom()
+  };
 }
 export {
-  graphForceLayout as default
+  updateCenterAndZoom
 };