sun-card-design 1.1.32 → 1.1.34

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

@@ -1,18 +1,23 @@
-import { isString } from "./sun-card-design-pc.es930.js";
-function parseXML(svg) {
-  if (isString(svg)) {
-    var parser = new DOMParser();
-    svg = parser.parseFromString(svg, "text/xml");
+function containStroke(x0, y0, x1, y1, lineWidth, x, y) {
+  if (lineWidth === 0) {
+    return false;
   }
-  var svgNode = svg;
-  if (svgNode.nodeType === 9) {
-    svgNode = svgNode.firstChild;
+  var _l = lineWidth;
+  var _a = 0;
+  var _b = x0;
+  if (y > y0 + _l && y > y1 + _l || y < y0 - _l && y < y1 - _l || x > x0 + _l && x > x1 + _l || x < x0 - _l && x < x1 - _l) {
+    return false;
   }
-  while (svgNode.nodeName.toLowerCase() !== "svg" || svgNode.nodeType !== 1) {
-    svgNode = svgNode.nextSibling;
+  if (x0 !== x1) {
+    _a = (y0 - y1) / (x0 - x1);
+    _b = (x0 * y1 - x1 * y0) / (x0 - x1);
+  } else {
+    return Math.abs(x - x0) <= _l / 2;
   }
-  return svgNode;
+  var tmp = _a * x - y + _b;
+  var _s = tmp * tmp / (_a * _a + 1);
+  return _s <= _l / 2 * _l / 2;
 }
 export {
-  parseXML
+  containStroke
 };

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

@@ -1,31 +1,15 @@
-import { map } from "./sun-card-design-pc.es930.js";
-import { GeoJSONRegion } from "./sun-card-design-pc.es2021.js";
-var geoCoord = [126, 25];
-var nanhaiName = "南海诸岛";
-var points = [[[0, 3.5], [7, 11.2], [15, 11.9], [30, 7], [42, 0.7], [52, 0.7], [56, 7.7], [59, 0.7], [64, 0.7], [64, 0], [5, 0], [0, 3.5]], [[13, 16.1], [19, 14.7], [16, 21.7], [11, 23.1], [13, 16.1]], [[12, 32.2], [14, 38.5], [15, 38.5], [13, 32.2], [12, 32.2]], [[16, 47.6], [12, 53.2], [13, 53.2], [18, 47.6], [16, 47.6]], [[6, 64.4], [8, 70], [9, 70], [8, 64.4], [6, 64.4]], [[23, 82.6], [29, 79.8], [30, 79.8], [25, 82.6], [23, 82.6]], [[37, 70.7], [43, 62.3], [44, 62.3], [39, 70.7], [37, 70.7]], [[48, 51.1], [51, 45.5], [53, 45.5], [50, 51.1], [48, 51.1]], [[51, 35], [51, 28.7], [53, 28.7], [53, 35], [51, 35]], [[52, 22.4], [55, 17.5], [56, 17.5], [53, 22.4], [52, 22.4]], [[58, 12.6], [62, 7], [63, 7], [60, 12.6], [58, 12.6]], [[0, 3.5], [0, 93.1], [64, 93.1], [64, 0], [63, 0], [63, 92.4], [1, 92.4], [1, 3.5], [0, 3.5]]];
-for (var i = 0; i < points.length; i++) {
-  for (var k = 0; k < points[i].length; k++) {
-    points[i][k][0] /= 10.5;
-    points[i][k][1] /= -10.5 / 0.75;
-    points[i][k][0] += geoCoord[0];
-    points[i][k][1] += geoCoord[1];
+import { cubicProjectPoint } from "./sun-card-design-pc.es2167.js";
+function containStroke(x0, y0, x1, y1, x2, y2, x3, y3, lineWidth, x, y) {
+  if (lineWidth === 0) {
+    return false;
   }
-}
-function fixNanhai(mapType, regions) {
-  if (mapType === "china") {
-    for (var i = 0; i < regions.length; i++) {
-      if (regions[i].name === nanhaiName) {
-        return;
-      }
-    }
-    regions.push(new GeoJSONRegion(nanhaiName, map(points, function(exterior) {
-      return {
-        type: "polygon",
-        exterior
-      };
-    }), geoCoord));
+  var _l = lineWidth;
+  if (y > y0 + _l && y > y1 + _l && y > y2 + _l && y > y3 + _l || y < y0 - _l && y < y1 - _l && y < y2 - _l && y < y3 - _l || x > x0 + _l && x > x1 + _l && x > x2 + _l && x > x3 + _l || x < x0 - _l && x < x1 - _l && x < x2 - _l && x < x3 - _l) {
+    return false;
   }
+  var d = cubicProjectPoint(x0, y0, x1, y1, x2, y2, x3, y3, x, y, null);
+  return d <= _l / 2;
 }
 export {
-  fixNanhai as default
+  containStroke
 };

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

@@ -1,23 +1,15 @@
-var coordsOffsetMap = {
-  "南海诸岛": [32, 80],
-  // 全国
-  "广东": [0, -10],
-  "香港": [10, 5],
-  "澳门": [-10, 10],
-  // '北京': [-10, 0],
-  "天津": [5, 5]
-};
-function fixTextCoords(mapType, region) {
-  if (mapType === "china") {
-    var coordFix = coordsOffsetMap[region.name];
-    if (coordFix) {
-      var cp = region.getCenter();
-      cp[0] += coordFix[0] / 10.5;
-      cp[1] += -coordFix[1] / (10.5 / 0.75);
-      region.setCenter(cp);
-    }
+import { quadraticProjectPoint } from "./sun-card-design-pc.es2167.js";
+function containStroke(x0, y0, x1, y1, x2, y2, lineWidth, x, y) {
+  if (lineWidth === 0) {
+    return false;
+  }
+  var _l = lineWidth;
+  if (y > y0 + _l && y > y1 + _l && y > y2 + _l || y < y0 - _l && y < y1 - _l && y < y2 - _l || x > x0 + _l && x > x1 + _l && x > x2 + _l || x < x0 - _l && x < x1 - _l && x < x2 - _l) {
+    return false;
   }
+  var d = quadraticProjectPoint(x0, y0, x1, y1, x2, y2, x, y, null);
+  return d <= _l / 2;
 }
 export {
-  fixTextCoords as default
+  containStroke
 };

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

@@ -1,6 +1,6 @@
 import { createVNode } from "vue";
-import CloudSyncOutlined$1 from "./sun-card-design-pc.es1076.js";
-import Icon from "./sun-card-design-pc.es934.js";
+import CloudSyncOutlined$1 from "./sun-card-design-pc.es1131.js";
+import Icon from "./sun-card-design-pc.es989.js";
 function _objectSpread(target) {
   for (var i = 1; i < arguments.length; i++) {
     var source = arguments[i] != null ? Object(arguments[i]) : {};

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

@@ -1,12 +1,36 @@
-var points = [[[123.45165252685547, 25.73527164402261], [123.49731445312499, 25.73527164402261], [123.49731445312499, 25.750734064600884], [123.45165252685547, 25.750734064600884], [123.45165252685547, 25.73527164402261]]];
-function fixDiaoyuIsland(mapType, region) {
-  if (mapType === "china" && region.name === "台湾") {
-    region.geometries.push({
-      type: "polygon",
-      exterior: points[0]
-    });
+import { normalizeRadian } from "./sun-card-design-pc.es2031.js";
+var PI2 = Math.PI * 2;
+function containStroke(cx, cy, r, startAngle, endAngle, anticlockwise, lineWidth, x, y) {
+  if (lineWidth === 0) {
+    return false;
   }
+  var _l = lineWidth;
+  x -= cx;
+  y -= cy;
+  var d = Math.sqrt(x * x + y * y);
+  if (d - _l > r || d + _l < r) {
+    return false;
+  }
+  if (Math.abs(startAngle - endAngle) % PI2 < 1e-4) {
+    return true;
+  }
+  if (anticlockwise) {
+    var tmp = startAngle;
+    startAngle = normalizeRadian(endAngle);
+    endAngle = normalizeRadian(tmp);
+  } else {
+    startAngle = normalizeRadian(startAngle);
+    endAngle = normalizeRadian(endAngle);
+  }
+  if (startAngle > endAngle) {
+    endAngle += PI2;
+  }
+  var angle = Math.atan2(y, x);
+  if (angle < 0) {
+    angle += PI2;
+  }
+  return angle >= startAngle && angle <= endAngle || angle + PI2 >= startAngle && angle + PI2 <= endAngle;
 }
 export {
-  fixDiaoyuIsland as default
+  containStroke
 };

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

@@ -1,21 +1,18 @@
-import { __extends } from "./sun-card-design-pc.es1725.js";
-import Axis from "./sun-card-design-pc.es2024.js";
-var ParallelAxis = (
-  /** @class */
-  (function(_super) {
-    __extends(ParallelAxis2, _super);
-    function ParallelAxis2(dim, scale, coordExtent, axisType, axisIndex) {
-      var _this = _super.call(this, dim, scale, coordExtent) || this;
-      _this.type = axisType || "value";
-      _this.axisIndex = axisIndex;
-      return _this;
-    }
-    ParallelAxis2.prototype.isHorizontal = function() {
-      return this.coordinateSystem.getModel().get("layout") !== "horizontal";
-    };
-    return ParallelAxis2;
-  })(Axis)
-);
+function windingLine(x0, y0, x1, y1, x, y) {
+  if (y > y0 && y > y1 || y < y0 && y < y1) {
+    return 0;
+  }
+  if (y1 === y0) {
+    return 0;
+  }
+  var t = (y - y0) / (y1 - y0);
+  var dir = y1 < y0 ? 1 : -1;
+  if (t === 1 || t === 0) {
+    dir = y1 < y0 ? 0.5 : -0.5;
+  }
+  var x_ = t * (x1 - x0) + x0;
+  return x_ === x ? Infinity : x_ > x ? dir : 0;
+}
 export {
-  ParallelAxis as default
+  windingLine as default
 };

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

@@ -1,30 +1,355 @@
-import { registerAction } from "./sun-card-design-pc.es60.js";
-import { noop } from "./sun-card-design-pc.es930.js";
-var ATTR = "\0_ec_interaction_mutex";
-function take(zr, resourceKey, userKey) {
-  var store = getStore(zr);
-  store[resourceKey] = userKey;
+import { isNumber, mixin, createHashMap } from "./sun-card-design-pc.es930.js";
+function generateNodeKey(id) {
+  return "_EC_" + id;
 }
-function release(zr, resourceKey, userKey) {
-  var store = getStore(zr);
-  var uKey = store[resourceKey];
-  if (uKey === userKey) {
-    store[resourceKey] = null;
-  }
+var Graph = (
+  /** @class */
+  (function() {
+    function Graph2(directed) {
+      this.type = "graph";
+      this.nodes = [];
+      this.edges = [];
+      this._nodesMap = {};
+      this._edgesMap = {};
+      this._directed = directed || false;
+    }
+    Graph2.prototype.isDirected = function() {
+      return this._directed;
+    };
+    Graph2.prototype.addNode = function(id, dataIndex) {
+      id = id == null ? "" + dataIndex : "" + id;
+      var nodesMap = this._nodesMap;
+      if (nodesMap[generateNodeKey(id)]) {
+        if (process.env.NODE_ENV !== "production") {
+          console.error("Graph nodes have duplicate name or id");
+        }
+        return;
+      }
+      var node = new GraphNode(id, dataIndex);
+      node.hostGraph = this;
+      this.nodes.push(node);
+      nodesMap[generateNodeKey(id)] = node;
+      return node;
+    };
+    Graph2.prototype.getNodeByIndex = function(dataIndex) {
+      var rawIdx = this.data.getRawIndex(dataIndex);
+      return this.nodes[rawIdx];
+    };
+    Graph2.prototype.getNodeById = function(id) {
+      return this._nodesMap[generateNodeKey(id)];
+    };
+    Graph2.prototype.addEdge = function(n1, n2, dataIndex) {
+      var nodesMap = this._nodesMap;
+      var edgesMap = this._edgesMap;
+      if (isNumber(n1)) {
+        n1 = this.nodes[n1];
+      }
+      if (isNumber(n2)) {
+        n2 = this.nodes[n2];
+      }
+      if (!(n1 instanceof GraphNode)) {
+        n1 = nodesMap[generateNodeKey(n1)];
+      }
+      if (!(n2 instanceof GraphNode)) {
+        n2 = nodesMap[generateNodeKey(n2)];
+      }
+      if (!n1 || !n2) {
+        return;
+      }
+      var key = n1.id + "-" + n2.id;
+      var edge = new GraphEdge(n1, n2, dataIndex);
+      edge.hostGraph = this;
+      if (this._directed) {
+        n1.outEdges.push(edge);
+        n2.inEdges.push(edge);
+      }
+      n1.edges.push(edge);
+      if (n1 !== n2) {
+        n2.edges.push(edge);
+      }
+      this.edges.push(edge);
+      edgesMap[key] = edge;
+      return edge;
+    };
+    Graph2.prototype.getEdgeByIndex = function(dataIndex) {
+      var rawIdx = this.edgeData.getRawIndex(dataIndex);
+      return this.edges[rawIdx];
+    };
+    Graph2.prototype.getEdge = function(n1, n2) {
+      if (n1 instanceof GraphNode) {
+        n1 = n1.id;
+      }
+      if (n2 instanceof GraphNode) {
+        n2 = n2.id;
+      }
+      var edgesMap = this._edgesMap;
+      if (this._directed) {
+        return edgesMap[n1 + "-" + n2];
+      } else {
+        return edgesMap[n1 + "-" + n2] || edgesMap[n2 + "-" + n1];
+      }
+    };
+    Graph2.prototype.eachNode = function(cb, context) {
+      var nodes = this.nodes;
+      var len = nodes.length;
+      for (var i = 0; i < len; i++) {
+        if (nodes[i].dataIndex >= 0) {
+          cb.call(context, nodes[i], i);
+        }
+      }
+    };
+    Graph2.prototype.eachEdge = function(cb, context) {
+      var edges = this.edges;
+      var len = edges.length;
+      for (var i = 0; i < len; i++) {
+        if (edges[i].dataIndex >= 0 && edges[i].node1.dataIndex >= 0 && edges[i].node2.dataIndex >= 0) {
+          cb.call(context, edges[i], i);
+        }
+      }
+    };
+    Graph2.prototype.breadthFirstTraverse = function(cb, startNode, direction, context) {
+      if (!(startNode instanceof GraphNode)) {
+        startNode = this._nodesMap[generateNodeKey(startNode)];
+      }
+      if (!startNode) {
+        return;
+      }
+      var edgeType = direction === "out" ? "outEdges" : direction === "in" ? "inEdges" : "edges";
+      for (var i = 0; i < this.nodes.length; i++) {
+        this.nodes[i].__visited = false;
+      }
+      if (cb.call(context, startNode, null)) {
+        return;
+      }
+      var queue = [startNode];
+      while (queue.length) {
+        var currentNode = queue.shift();
+        var edges = currentNode[edgeType];
+        for (var i = 0; i < edges.length; i++) {
+          var e = edges[i];
+          var otherNode = e.node1 === currentNode ? e.node2 : e.node1;
+          if (!otherNode.__visited) {
+            if (cb.call(context, otherNode, currentNode)) {
+              return;
+            }
+            queue.push(otherNode);
+            otherNode.__visited = true;
+          }
+        }
+      }
+    };
+    Graph2.prototype.update = function() {
+      var data = this.data;
+      var edgeData = this.edgeData;
+      var nodes = this.nodes;
+      var edges = this.edges;
+      for (var i = 0, len = nodes.length; i < len; i++) {
+        nodes[i].dataIndex = -1;
+      }
+      for (var i = 0, len = data.count(); i < len; i++) {
+        nodes[data.getRawIndex(i)].dataIndex = i;
+      }
+      edgeData.filterSelf(function(idx) {
+        var edge = edges[edgeData.getRawIndex(idx)];
+        return edge.node1.dataIndex >= 0 && edge.node2.dataIndex >= 0;
+      });
+      for (var i = 0, len = edges.length; i < len; i++) {
+        edges[i].dataIndex = -1;
+      }
+      for (var i = 0, len = edgeData.count(); i < len; i++) {
+        edges[edgeData.getRawIndex(i)].dataIndex = i;
+      }
+    };
+    Graph2.prototype.clone = function() {
+      var graph = new Graph2(this._directed);
+      var nodes = this.nodes;
+      var edges = this.edges;
+      for (var i = 0; i < nodes.length; i++) {
+        graph.addNode(nodes[i].id, nodes[i].dataIndex);
+      }
+      for (var i = 0; i < edges.length; i++) {
+        var e = edges[i];
+        graph.addEdge(e.node1.id, e.node2.id, e.dataIndex);
+      }
+      return graph;
+    };
+    return Graph2;
+  })()
+);
+var GraphNode = (
+  /** @class */
+  (function() {
+    function GraphNode2(id, dataIndex) {
+      this.inEdges = [];
+      this.outEdges = [];
+      this.edges = [];
+      this.dataIndex = -1;
+      this.id = id == null ? "" : id;
+      this.dataIndex = dataIndex == null ? -1 : dataIndex;
+    }
+    GraphNode2.prototype.degree = function() {
+      return this.edges.length;
+    };
+    GraphNode2.prototype.inDegree = function() {
+      return this.inEdges.length;
+    };
+    GraphNode2.prototype.outDegree = function() {
+      return this.outEdges.length;
+    };
+    GraphNode2.prototype.getModel = function(path) {
+      if (this.dataIndex < 0) {
+        return;
+      }
+      var graph = this.hostGraph;
+      var itemModel = graph.data.getItemModel(this.dataIndex);
+      return itemModel.getModel(path);
+    };
+    GraphNode2.prototype.getAdjacentDataIndices = function() {
+      var dataIndices = {
+        edge: [],
+        node: []
+      };
+      for (var i = 0; i < this.edges.length; i++) {
+        var adjacentEdge = this.edges[i];
+        if (adjacentEdge.dataIndex < 0) {
+          continue;
+        }
+        dataIndices.edge.push(adjacentEdge.dataIndex);
+        dataIndices.node.push(adjacentEdge.node1.dataIndex, adjacentEdge.node2.dataIndex);
+      }
+      return dataIndices;
+    };
+    GraphNode2.prototype.getTrajectoryDataIndices = function() {
+      var connectedEdgesMap = createHashMap();
+      var connectedNodesMap = createHashMap();
+      for (var i = 0; i < this.edges.length; i++) {
+        var adjacentEdge = this.edges[i];
+        if (adjacentEdge.dataIndex < 0) {
+          continue;
+        }
+        connectedEdgesMap.set(adjacentEdge.dataIndex, true);
+        var sourceNodesQueue = [adjacentEdge.node1];
+        var targetNodesQueue = [adjacentEdge.node2];
+        var nodeIteratorIndex = 0;
+        while (nodeIteratorIndex < sourceNodesQueue.length) {
+          var sourceNode = sourceNodesQueue[nodeIteratorIndex];
+          nodeIteratorIndex++;
+          connectedNodesMap.set(sourceNode.dataIndex, true);
+          for (var j = 0; j < sourceNode.inEdges.length; j++) {
+            connectedEdgesMap.set(sourceNode.inEdges[j].dataIndex, true);
+            sourceNodesQueue.push(sourceNode.inEdges[j].node1);
+          }
+        }
+        nodeIteratorIndex = 0;
+        while (nodeIteratorIndex < targetNodesQueue.length) {
+          var targetNode = targetNodesQueue[nodeIteratorIndex];
+          nodeIteratorIndex++;
+          connectedNodesMap.set(targetNode.dataIndex, true);
+          for (var j = 0; j < targetNode.outEdges.length; j++) {
+            connectedEdgesMap.set(targetNode.outEdges[j].dataIndex, true);
+            targetNodesQueue.push(targetNode.outEdges[j].node2);
+          }
+        }
+      }
+      return {
+        edge: connectedEdgesMap.keys(),
+        node: connectedNodesMap.keys()
+      };
+    };
+    return GraphNode2;
+  })()
+);
+var GraphEdge = (
+  /** @class */
+  (function() {
+    function GraphEdge2(n1, n2, dataIndex) {
+      this.dataIndex = -1;
+      this.node1 = n1;
+      this.node2 = n2;
+      this.dataIndex = dataIndex == null ? -1 : dataIndex;
+    }
+    GraphEdge2.prototype.getModel = function(path) {
+      if (this.dataIndex < 0) {
+        return;
+      }
+      var graph = this.hostGraph;
+      var itemModel = graph.edgeData.getItemModel(this.dataIndex);
+      return itemModel.getModel(path);
+    };
+    GraphEdge2.prototype.getAdjacentDataIndices = function() {
+      return {
+        edge: [this.dataIndex],
+        node: [this.node1.dataIndex, this.node2.dataIndex]
+      };
+    };
+    GraphEdge2.prototype.getTrajectoryDataIndices = function() {
+      var connectedEdgesMap = createHashMap();
+      var connectedNodesMap = createHashMap();
+      connectedEdgesMap.set(this.dataIndex, true);
+      var sourceNodes = [this.node1];
+      var targetNodes = [this.node2];
+      var nodeIteratorIndex = 0;
+      while (nodeIteratorIndex < sourceNodes.length) {
+        var sourceNode = sourceNodes[nodeIteratorIndex];
+        nodeIteratorIndex++;
+        connectedNodesMap.set(sourceNode.dataIndex, true);
+        for (var j = 0; j < sourceNode.inEdges.length; j++) {
+          connectedEdgesMap.set(sourceNode.inEdges[j].dataIndex, true);
+          sourceNodes.push(sourceNode.inEdges[j].node1);
+        }
+      }
+      nodeIteratorIndex = 0;
+      while (nodeIteratorIndex < targetNodes.length) {
+        var targetNode = targetNodes[nodeIteratorIndex];
+        nodeIteratorIndex++;
+        connectedNodesMap.set(targetNode.dataIndex, true);
+        for (var j = 0; j < targetNode.outEdges.length; j++) {
+          connectedEdgesMap.set(targetNode.outEdges[j].dataIndex, true);
+          targetNodes.push(targetNode.outEdges[j].node2);
+        }
+      }
+      return {
+        edge: connectedEdgesMap.keys(),
+        node: connectedNodesMap.keys()
+      };
+    };
+    return GraphEdge2;
+  })()
+);
+function createGraphDataProxyMixin(hostName, dataName) {
+  return {
+    /**
+     * @param Default 'value'. can be 'a', 'b', 'c', 'd', 'e'.
+     */
+    getValue: function(dimension) {
+      var data = this[hostName][dataName];
+      return data.getStore().get(data.getDimensionIndex(dimension || "value"), this.dataIndex);
+    },
+    // TODO: TYPE stricter type.
+    setVisual: function(key, value) {
+      this.dataIndex >= 0 && this[hostName][dataName].setItemVisual(this.dataIndex, key, value);
+    },
+    getVisual: function(key) {
+      return this[hostName][dataName].getItemVisual(this.dataIndex, key);
+    },
+    setLayout: function(layout, merge) {
+      this.dataIndex >= 0 && this[hostName][dataName].setItemLayout(this.dataIndex, layout, merge);
+    },
+    getLayout: function() {
+      return this[hostName][dataName].getItemLayout(this.dataIndex);
+    },
+    getGraphicEl: function() {
+      return this[hostName][dataName].getItemGraphicEl(this.dataIndex);
+    },
+    getRawIndex: function() {
+      return this[hostName][dataName].getRawIndex(this.dataIndex);
+    }
+  };
 }
-function isTaken(zr, resourceKey) {
-  return !!getStore(zr)[resourceKey];
-}
-function getStore(zr) {
-  return zr[ATTR] || (zr[ATTR] = {});
-}
-registerAction({
-  type: "takeGlobalCursor",
-  event: "globalCursorTaken",
-  update: "update"
-}, noop);
+mixin(GraphNode, createGraphDataProxyMixin("hostGraph", "data"));
+mixin(GraphEdge, createGraphDataProxyMixin("hostGraph", "edgeData"));
 export {
-  isTaken,
-  release,
-  take
+  GraphEdge,
+  GraphNode,
+  Graph as default
 };

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

@@ -1,25 +1,73 @@
-import { __extends } from "./sun-card-design-pc.es1725.js";
-import Axis from "./sun-card-design-pc.es2024.js";
-var SingleAxis = (
+import { __extends } from "./sun-card-design-pc.es935.js";
+import { normalize } from "./sun-card-design-pc.es1978.js";
+import Line from "./sun-card-design-pc.es1986.js";
+import BezierCurve from "./sun-card-design-pc.es1987.js";
+import Path from "./sun-card-design-pc.es968.js";
+var straightLineProto = Line.prototype;
+var bezierCurveProto = BezierCurve.prototype;
+var StraightLineShape = (
+  /** @class */
+  /* @__PURE__ */ (function() {
+    function StraightLineShape2() {
+      this.x1 = 0;
+      this.y1 = 0;
+      this.x2 = 0;
+      this.y2 = 0;
+      this.percent = 1;
+    }
+    return StraightLineShape2;
+  })()
+);
+(function(_super) {
+  __extends(CurveShape, _super);
+  function CurveShape() {
+    return _super !== null && _super.apply(this, arguments) || this;
+  }
+  return CurveShape;
+})(StraightLineShape);
+function isStraightLine(shape) {
+  return isNaN(+shape.cpx1) || isNaN(+shape.cpy1);
+}
+var ECLinePath = (
   /** @class */
   (function(_super) {
-    __extends(SingleAxis2, _super);
-    function SingleAxis2(dim, scale, coordExtent, axisType, position) {
-      var _this = _super.call(this, dim, scale, coordExtent) || this;
-      _this.type = axisType || "value";
-      _this.position = position || "bottom";
+    __extends(ECLinePath2, _super);
+    function ECLinePath2(opts) {
+      var _this = _super.call(this, opts) || this;
+      _this.type = "ec-line";
       return _this;
     }
-    SingleAxis2.prototype.isHorizontal = function() {
-      var position = this.position;
-      return position === "top" || position === "bottom";
+    ECLinePath2.prototype.getDefaultStyle = function() {
+      return {
+        stroke: "#000",
+        fill: null
+      };
+    };
+    ECLinePath2.prototype.getDefaultShape = function() {
+      return new StraightLineShape();
+    };
+    ECLinePath2.prototype.buildPath = function(ctx, shape) {
+      if (isStraightLine(shape)) {
+        straightLineProto.buildPath.call(this, ctx, shape);
+      } else {
+        bezierCurveProto.buildPath.call(this, ctx, shape);
+      }
+    };
+    ECLinePath2.prototype.pointAt = function(t) {
+      if (isStraightLine(this.shape)) {
+        return straightLineProto.pointAt.call(this, t);
+      } else {
+        return bezierCurveProto.pointAt.call(this, t);
+      }
     };
-    SingleAxis2.prototype.pointToData = function(point, clamp) {
-      return this.coordinateSystem.pointToData(point)[0];
+    ECLinePath2.prototype.tangentAt = function(t) {
+      var shape = this.shape;
+      var p = isStraightLine(shape) ? [shape.x2 - shape.x1, shape.y2 - shape.y1] : bezierCurveProto.tangentAt.call(this, t);
+      return normalize(p, p);
     };
-    return SingleAxis2;
-  })(Axis)
+    return ECLinePath2;
+  })(Path)
 );
 export {
-  SingleAxis as default
+  ECLinePath as default
 };