@fmdevui/fm-dev 1.0.112 → 1.0.114

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/candlestick/CandlestickView.mjs

@@ -0,0 +1,300 @@
+import { __extends } from '../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs';
+import { each, map } from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+import ChartView from '../../view/Chart.mjs';
+import { traverseElements } from '../../util/graphic.mjs';
+import { setStatesStylesFromModel, toggleHoverEmphasis } from '../../util/states.mjs';
+import Path from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/Path.mjs';
+import { createClipPath } from '../helper/createClipPathFromCoordSys.mjs';
+import { initProps, updateProps, saveOldStyle } from '../../animation/basicTransition.mjs';
+import { getColor, getBorderColor } from './candlestickVisual.mjs';
+
+var SKIP_PROPS = ['color', 'borderColor'];
+var CandlestickView = /** @class */function (_super) {
+  __extends(CandlestickView, _super);
+  function CandlestickView() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = CandlestickView.type;
+    return _this;
+  }
+  CandlestickView.prototype.render = function (seriesModel, ecModel, api) {
+    // If there is clipPath created in large mode. Remove it.
+    this.group.removeClipPath();
+    // Clear previously rendered progressive elements.
+    this._progressiveEls = null;
+    this._updateDrawMode(seriesModel);
+    this._isLargeDraw ? this._renderLarge(seriesModel) : this._renderNormal(seriesModel);
+  };
+  CandlestickView.prototype.incrementalPrepareRender = function (seriesModel, ecModel, api) {
+    this._clear();
+    this._updateDrawMode(seriesModel);
+  };
+  CandlestickView.prototype.incrementalRender = function (params, seriesModel, ecModel, api) {
+    this._progressiveEls = [];
+    this._isLargeDraw ? this._incrementalRenderLarge(params, seriesModel) : this._incrementalRenderNormal(params, seriesModel);
+  };
+  CandlestickView.prototype.eachRendered = function (cb) {
+    traverseElements(this._progressiveEls || this.group, cb);
+  };
+  CandlestickView.prototype._updateDrawMode = function (seriesModel) {
+    var isLargeDraw = seriesModel.pipelineContext.large;
+    if (this._isLargeDraw == null || isLargeDraw !== this._isLargeDraw) {
+      this._isLargeDraw = isLargeDraw;
+      this._clear();
+    }
+  };
+  CandlestickView.prototype._renderNormal = function (seriesModel) {
+    var data = seriesModel.getData();
+    var oldData = this._data;
+    var group = this.group;
+    var isSimpleBox = data.getLayout('isSimpleBox');
+    var needsClip = seriesModel.get('clip', true);
+    var coord = seriesModel.coordinateSystem;
+    var clipArea = coord.getArea && coord.getArea();
+    // There is no old data only when first rendering or switching from
+    // stream mode to normal mode, where previous elements should be removed.
+    if (!this._data) {
+      group.removeAll();
+    }
+    data.diff(oldData).add(function (newIdx) {
+      if (data.hasValue(newIdx)) {
+        var itemLayout = data.getItemLayout(newIdx);
+        if (needsClip && isNormalBoxClipped(clipArea, itemLayout)) {
+          return;
+        }
+        var el = createNormalBox(itemLayout, newIdx, true);
+        initProps(el, {
+          shape: {
+            points: itemLayout.ends
+          }
+        }, seriesModel, newIdx);
+        setBoxCommon(el, data, newIdx, isSimpleBox);
+        group.add(el);
+        data.setItemGraphicEl(newIdx, el);
+      }
+    }).update(function (newIdx, oldIdx) {
+      var el = oldData.getItemGraphicEl(oldIdx);
+      // Empty data
+      if (!data.hasValue(newIdx)) {
+        group.remove(el);
+        return;
+      }
+      var itemLayout = data.getItemLayout(newIdx);
+      if (needsClip && isNormalBoxClipped(clipArea, itemLayout)) {
+        group.remove(el);
+        return;
+      }
+      if (!el) {
+        el = createNormalBox(itemLayout, newIdx);
+      } else {
+        updateProps(el, {
+          shape: {
+            points: itemLayout.ends
+          }
+        }, seriesModel, newIdx);
+        saveOldStyle(el);
+      }
+      setBoxCommon(el, data, newIdx, isSimpleBox);
+      group.add(el);
+      data.setItemGraphicEl(newIdx, el);
+    }).remove(function (oldIdx) {
+      var el = oldData.getItemGraphicEl(oldIdx);
+      el && group.remove(el);
+    }).execute();
+    this._data = data;
+  };
+  CandlestickView.prototype._renderLarge = function (seriesModel) {
+    this._clear();
+    createLarge(seriesModel, this.group);
+    var clipPath = seriesModel.get('clip', true) ? createClipPath(seriesModel.coordinateSystem, false, seriesModel) : null;
+    if (clipPath) {
+      this.group.setClipPath(clipPath);
+    } else {
+      this.group.removeClipPath();
+    }
+  };
+  CandlestickView.prototype._incrementalRenderNormal = function (params, seriesModel) {
+    var data = seriesModel.getData();
+    var isSimpleBox = data.getLayout('isSimpleBox');
+    var dataIndex;
+    while ((dataIndex = params.next()) != null) {
+      var itemLayout = data.getItemLayout(dataIndex);
+      var el = createNormalBox(itemLayout, dataIndex);
+      setBoxCommon(el, data, dataIndex, isSimpleBox);
+      el.incremental = true;
+      this.group.add(el);
+      this._progressiveEls.push(el);
+    }
+  };
+  CandlestickView.prototype._incrementalRenderLarge = function (params, seriesModel) {
+    createLarge(seriesModel, this.group, this._progressiveEls, true);
+  };
+  CandlestickView.prototype.remove = function (ecModel) {
+    this._clear();
+  };
+  CandlestickView.prototype._clear = function () {
+    this.group.removeAll();
+    this._data = null;
+  };
+  CandlestickView.type = 'candlestick';
+  return CandlestickView;
+}(ChartView);
+var NormalBoxPathShape = /** @class */function () {
+  function NormalBoxPathShape() {}
+  return NormalBoxPathShape;
+}();
+var NormalBoxPath = /** @class */function (_super) {
+  __extends(NormalBoxPath, _super);
+  function NormalBoxPath(opts) {
+    var _this = _super.call(this, opts) || this;
+    _this.type = 'normalCandlestickBox';
+    return _this;
+  }
+  NormalBoxPath.prototype.getDefaultShape = function () {
+    return new NormalBoxPathShape();
+  };
+  NormalBoxPath.prototype.buildPath = function (ctx, shape) {
+    var ends = shape.points;
+    if (this.__simpleBox) {
+      ctx.moveTo(ends[4][0], ends[4][1]);
+      ctx.lineTo(ends[6][0], ends[6][1]);
+    } else {
+      ctx.moveTo(ends[0][0], ends[0][1]);
+      ctx.lineTo(ends[1][0], ends[1][1]);
+      ctx.lineTo(ends[2][0], ends[2][1]);
+      ctx.lineTo(ends[3][0], ends[3][1]);
+      ctx.closePath();
+      ctx.moveTo(ends[4][0], ends[4][1]);
+      ctx.lineTo(ends[5][0], ends[5][1]);
+      ctx.moveTo(ends[6][0], ends[6][1]);
+      ctx.lineTo(ends[7][0], ends[7][1]);
+    }
+  };
+  return NormalBoxPath;
+}(Path);
+function createNormalBox(itemLayout, dataIndex, isInit) {
+  var ends = itemLayout.ends;
+  return new NormalBoxPath({
+    shape: {
+      points: isInit ? transInit(ends, itemLayout) : ends
+    },
+    z2: 100
+  });
+}
+function isNormalBoxClipped(clipArea, itemLayout) {
+  var clipped = true;
+  for (var i = 0; i < itemLayout.ends.length; i++) {
+    // If any point are in the region.
+    if (clipArea.contain(itemLayout.ends[i][0], itemLayout.ends[i][1])) {
+      clipped = false;
+      break;
+    }
+  }
+  return clipped;
+}
+function setBoxCommon(el, data, dataIndex, isSimpleBox) {
+  var itemModel = data.getItemModel(dataIndex);
+  el.useStyle(data.getItemVisual(dataIndex, 'style'));
+  el.style.strokeNoScale = true;
+  el.__simpleBox = isSimpleBox;
+  setStatesStylesFromModel(el, itemModel);
+  var sign = data.getItemLayout(dataIndex).sign;
+  each(el.states, function (state, stateName) {
+    var stateModel = itemModel.getModel(stateName);
+    var color = getColor(sign, stateModel);
+    var borderColor = getBorderColor(sign, stateModel) || color;
+    var stateStyle = state.style || (state.style = {});
+    color && (stateStyle.fill = color);
+    borderColor && (stateStyle.stroke = borderColor);
+  });
+  var emphasisModel = itemModel.getModel('emphasis');
+  toggleHoverEmphasis(el, emphasisModel.get('focus'), emphasisModel.get('blurScope'), emphasisModel.get('disabled'));
+}
+function transInit(points, itemLayout) {
+  return map(points, function (point) {
+    point = point.slice();
+    point[1] = itemLayout.initBaseline;
+    return point;
+  });
+}
+var LargeBoxPathShape = /** @class */function () {
+  function LargeBoxPathShape() {}
+  return LargeBoxPathShape;
+}();
+var LargeBoxPath = /** @class */function (_super) {
+  __extends(LargeBoxPath, _super);
+  function LargeBoxPath(opts) {
+    var _this = _super.call(this, opts) || this;
+    _this.type = 'largeCandlestickBox';
+    return _this;
+  }
+  LargeBoxPath.prototype.getDefaultShape = function () {
+    return new LargeBoxPathShape();
+  };
+  LargeBoxPath.prototype.buildPath = function (ctx, shape) {
+    // Drawing lines is more efficient than drawing
+    // a whole line or drawing rects.
+    var points = shape.points;
+    for (var i = 0; i < points.length;) {
+      if (this.__sign === points[i++]) {
+        var x = points[i++];
+        ctx.moveTo(x, points[i++]);
+        ctx.lineTo(x, points[i++]);
+      } else {
+        i += 3;
+      }
+    }
+  };
+  return LargeBoxPath;
+}(Path);
+function createLarge(seriesModel, group, progressiveEls, incremental) {
+  var data = seriesModel.getData();
+  var largePoints = data.getLayout('largePoints');
+  var elP = new LargeBoxPath({
+    shape: {
+      points: largePoints
+    },
+    __sign: 1,
+    ignoreCoarsePointer: true
+  });
+  group.add(elP);
+  var elN = new LargeBoxPath({
+    shape: {
+      points: largePoints
+    },
+    __sign: -1,
+    ignoreCoarsePointer: true
+  });
+  group.add(elN);
+  var elDoji = new LargeBoxPath({
+    shape: {
+      points: largePoints
+    },
+    __sign: 0,
+    ignoreCoarsePointer: true
+  });
+  group.add(elDoji);
+  setLargeStyle(1, elP, seriesModel, data);
+  setLargeStyle(-1, elN, seriesModel, data);
+  setLargeStyle(0, elDoji, seriesModel, data);
+  if (incremental) {
+    elP.incremental = true;
+    elN.incremental = true;
+  }
+  if (progressiveEls) {
+    progressiveEls.push(elP, elN);
+  }
+}
+function setLargeStyle(sign, el, seriesModel, data) {
+  // TODO put in visual?
+  var borderColor = getBorderColor(sign, seriesModel)
+  // Use color for border color by default.
+  || getColor(sign, seriesModel);
+  // Color must be excluded.
+  // Because symbol provide setColor individually to set fill and stroke
+  var itemStyle = seriesModel.getModel('itemStyle').getItemStyle(SKIP_PROPS);
+  el.useStyle(itemStyle);
+  el.style.fill = null;
+  el.style.stroke = borderColor;
+}
+
+export { CandlestickView as default };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/candlestick/candlestickLayout.mjs

@@ -0,0 +1,163 @@
+import { subPixelOptimize } from '../../util/graphic.mjs';
+import createRenderPlanner from '../helper/createRenderPlanner.mjs';
+import { parsePercent } from '../../util/number.mjs';
+import { map, retrieve2 } from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+import { createFloat32Array } from '../../util/vendor.mjs';
+
+var candlestickLayout = {
+  seriesType: 'candlestick',
+  plan: createRenderPlanner(),
+  reset: function (seriesModel) {
+    var coordSys = seriesModel.coordinateSystem;
+    var data = seriesModel.getData();
+    var candleWidth = calculateCandleWidth(seriesModel, data);
+    var cDimIdx = 0;
+    var vDimIdx = 1;
+    var coordDims = ['x', 'y'];
+    var cDimI = data.getDimensionIndex(data.mapDimension(coordDims[cDimIdx]));
+    var vDimsI = map(data.mapDimensionsAll(coordDims[vDimIdx]), data.getDimensionIndex, data);
+    var openDimI = vDimsI[0];
+    var closeDimI = vDimsI[1];
+    var lowestDimI = vDimsI[2];
+    var highestDimI = vDimsI[3];
+    data.setLayout({
+      candleWidth: candleWidth,
+      // The value is experimented visually.
+      isSimpleBox: candleWidth <= 1.3
+    });
+    if (cDimI < 0 || vDimsI.length < 4) {
+      return;
+    }
+    return {
+      progress: seriesModel.pipelineContext.large ? largeProgress : normalProgress
+    };
+    function normalProgress(params, data) {
+      var dataIndex;
+      var store = data.getStore();
+      while ((dataIndex = params.next()) != null) {
+        var axisDimVal = store.get(cDimI, dataIndex);
+        var openVal = store.get(openDimI, dataIndex);
+        var closeVal = store.get(closeDimI, dataIndex);
+        var lowestVal = store.get(lowestDimI, dataIndex);
+        var highestVal = store.get(highestDimI, dataIndex);
+        var ocLow = Math.min(openVal, closeVal);
+        var ocHigh = Math.max(openVal, closeVal);
+        var ocLowPoint = getPoint(ocLow, axisDimVal);
+        var ocHighPoint = getPoint(ocHigh, axisDimVal);
+        var lowestPoint = getPoint(lowestVal, axisDimVal);
+        var highestPoint = getPoint(highestVal, axisDimVal);
+        var ends = [];
+        addBodyEnd(ends, ocHighPoint, 0);
+        addBodyEnd(ends, ocLowPoint, 1);
+        ends.push(subPixelOptimizePoint(highestPoint), subPixelOptimizePoint(ocHighPoint), subPixelOptimizePoint(lowestPoint), subPixelOptimizePoint(ocLowPoint));
+        var itemModel = data.getItemModel(dataIndex);
+        var hasDojiColor = !!itemModel.get(['itemStyle', 'borderColorDoji']);
+        data.setItemLayout(dataIndex, {
+          sign: getSign(store, dataIndex, openVal, closeVal, closeDimI, hasDojiColor),
+          initBaseline: openVal > closeVal ? ocHighPoint[vDimIdx] : ocLowPoint[vDimIdx],
+          ends: ends,
+          brushRect: makeBrushRect(lowestVal, highestVal, axisDimVal)
+        });
+      }
+      function getPoint(val, axisDimVal) {
+        var p = [];
+        p[cDimIdx] = axisDimVal;
+        p[vDimIdx] = val;
+        return isNaN(axisDimVal) || isNaN(val) ? [NaN, NaN] : coordSys.dataToPoint(p);
+      }
+      function addBodyEnd(ends, point, start) {
+        var point1 = point.slice();
+        var point2 = point.slice();
+        point1[cDimIdx] = subPixelOptimize(point1[cDimIdx] + candleWidth / 2, 1, false);
+        point2[cDimIdx] = subPixelOptimize(point2[cDimIdx] - candleWidth / 2, 1, true);
+        start ? ends.push(point1, point2) : ends.push(point2, point1);
+      }
+      function makeBrushRect(lowestVal, highestVal, axisDimVal) {
+        var pmin = getPoint(lowestVal, axisDimVal);
+        var pmax = getPoint(highestVal, axisDimVal);
+        pmin[cDimIdx] -= candleWidth / 2;
+        pmax[cDimIdx] -= candleWidth / 2;
+        return {
+          x: pmin[0],
+          y: pmin[1],
+          width: vDimIdx ? candleWidth : pmax[0] - pmin[0],
+          height: vDimIdx ? pmax[1] - pmin[1] : candleWidth
+        };
+      }
+      function subPixelOptimizePoint(point) {
+        point[cDimIdx] = subPixelOptimize(point[cDimIdx], 1);
+        return point;
+      }
+    }
+    function largeProgress(params, data) {
+      // Structure: [sign, x, yhigh, ylow, sign, x, yhigh, ylow, ...]
+      var points = createFloat32Array(params.count * 4);
+      var offset = 0;
+      var point;
+      var tmpIn = [];
+      var tmpOut = [];
+      var dataIndex;
+      var store = data.getStore();
+      var hasDojiColor = !!seriesModel.get(['itemStyle', 'borderColorDoji']);
+      while ((dataIndex = params.next()) != null) {
+        var axisDimVal = store.get(cDimI, dataIndex);
+        var openVal = store.get(openDimI, dataIndex);
+        var closeVal = store.get(closeDimI, dataIndex);
+        var lowestVal = store.get(lowestDimI, dataIndex);
+        var highestVal = store.get(highestDimI, dataIndex);
+        if (isNaN(axisDimVal) || isNaN(lowestVal) || isNaN(highestVal)) {
+          points[offset++] = NaN;
+          offset += 3;
+          continue;
+        }
+        points[offset++] = getSign(store, dataIndex, openVal, closeVal, closeDimI, hasDojiColor);
+        tmpIn[cDimIdx] = axisDimVal;
+        tmpIn[vDimIdx] = lowestVal;
+        point = coordSys.dataToPoint(tmpIn, null, tmpOut);
+        points[offset++] = point ? point[0] : NaN;
+        points[offset++] = point ? point[1] : NaN;
+        tmpIn[vDimIdx] = highestVal;
+        point = coordSys.dataToPoint(tmpIn, null, tmpOut);
+        points[offset++] = point ? point[1] : NaN;
+      }
+      data.setLayout('largePoints', points);
+    }
+  }
+};
+/**
+ * Get the sign of a single data.
+ *
+ * @returns 0 for doji with hasDojiColor: true,
+ *          1 for positive,
+ *          -1 for negative.
+ */
+function getSign(store, dataIndex, openVal, closeVal, closeDimI, hasDojiColor) {
+  var sign;
+  if (openVal > closeVal) {
+    sign = -1;
+  } else if (openVal < closeVal) {
+    sign = 1;
+  } else {
+    sign = hasDojiColor
+    // When doji color is set, use it instead of color/color0.
+    ? 0 : dataIndex > 0
+    // If close === open, compare with close of last record
+    ? store.get(closeDimI, dataIndex - 1) <= closeVal ? 1 : -1
+    // No record of previous, set to be positive
+    : 1;
+  }
+  return sign;
+}
+function calculateCandleWidth(seriesModel, data) {
+  var baseAxis = seriesModel.getBaseAxis();
+  var extent;
+  var bandWidth = baseAxis.type === 'category' ? baseAxis.getBandWidth() : (extent = baseAxis.getExtent(), Math.abs(extent[1] - extent[0]) / data.count());
+  var barMaxWidth = parsePercent(retrieve2(seriesModel.get('barMaxWidth'), bandWidth), bandWidth);
+  var barMinWidth = parsePercent(retrieve2(seriesModel.get('barMinWidth'), 1), bandWidth);
+  var barWidth = seriesModel.get('barWidth');
+  return barWidth != null ? parsePercent(barWidth, bandWidth)
+  // Put max outer to ensure bar visible in spite of overlap.
+  : Math.max(Math.min(bandWidth / 2, barMaxWidth), barMinWidth);
+}
+
+export { candlestickLayout as default };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/candlestick/candlestickVisual.mjs

@@ -0,0 +1,43 @@
+import createRenderPlanner from '../helper/createRenderPlanner.mjs';
+import { extend } from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+
+var positiveBorderColorQuery = ['itemStyle', 'borderColor'];
+var negativeBorderColorQuery = ['itemStyle', 'borderColor0'];
+var dojiBorderColorQuery = ['itemStyle', 'borderColorDoji'];
+var positiveColorQuery = ['itemStyle', 'color'];
+var negativeColorQuery = ['itemStyle', 'color0'];
+function getColor(sign, model) {
+  return model.get(sign > 0 ? positiveColorQuery : negativeColorQuery);
+}
+function getBorderColor(sign, model) {
+  return model.get(sign === 0 ? dojiBorderColorQuery : sign > 0 ? positiveBorderColorQuery : negativeBorderColorQuery);
+}
+var candlestickVisual = {
+  seriesType: 'candlestick',
+  plan: createRenderPlanner(),
+  // For legend.
+  performRawSeries: true,
+  reset: function (seriesModel, ecModel) {
+    // Only visible series has each data be visual encoded
+    if (ecModel.isSeriesFiltered(seriesModel)) {
+      return;
+    }
+    var isLargeRender = seriesModel.pipelineContext.large;
+    return !isLargeRender && {
+      progress: function (params, data) {
+        var dataIndex;
+        while ((dataIndex = params.next()) != null) {
+          var itemModel = data.getItemModel(dataIndex);
+          var sign = data.getItemLayout(dataIndex).sign;
+          var style = itemModel.getItemStyle();
+          style.fill = getColor(sign, itemModel);
+          style.stroke = getBorderColor(sign, itemModel) || style.fill;
+          var existsStyle = data.ensureUniqueItemVisual(dataIndex, 'style');
+          extend(existsStyle, style);
+        }
+      }
+    };
+  }
+};
+
+export { candlestickVisual as default, getBorderColor, getColor };

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

@@ -0,0 +1,15 @@
+import CandlestickView from './CandlestickView.mjs';
+import CandlestickSeriesModel from './CandlestickSeries.mjs';
+import candlestickPreprocessor from './preprocessor.mjs';
+import candlestickVisual from './candlestickVisual.mjs';
+import candlestickLayout from './candlestickLayout.mjs';
+
+function install(registers) {
+  registers.registerChartView(CandlestickView);
+  registers.registerSeriesModel(CandlestickSeriesModel);
+  registers.registerPreprocessor(candlestickPreprocessor);
+  registers.registerVisual(candlestickVisual);
+  registers.registerLayout(candlestickLayout);
+}
+
+export { install };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/candlestick/preprocessor.mjs

@@ -0,0 +1,15 @@
+import { isArray, each, isObject } from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+
+function candlestickPreprocessor(option) {
+  if (!option || !isArray(option.series)) {
+    return;
+  }
+  // Translate 'k' to 'candlestick'.
+  each(option.series, function (seriesItem) {
+    if (isObject(seriesItem) && seriesItem.type === 'k') {
+      seriesItem.type = 'candlestick';
+    }
+  });
+}
+
+export { candlestickPreprocessor as default };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/chord/ChordEdge.mjs

@@ -0,0 +1,126 @@
+import { __extends } from '../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs';
+import { extend, isString } from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+import '../../util/graphic.mjs';
+import { getSectorCornerRadius } from '../helper/sectorHelper.mjs';
+import { saveOldStyle, updateProps } from '../../animation/basicTransition.mjs';
+import { toggleHoverEmphasis, setStatesStylesFromModel } from '../../util/states.mjs';
+import { getECData } from '../../util/innerStore.mjs';
+import Path from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/Path.mjs';
+import LinearGradient from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/LinearGradient.mjs';
+
+var ChordPathShape = /** @class */function () {
+  function ChordPathShape() {
+    // Souce node, two points forming an arc
+    this.s1 = [0, 0];
+    this.s2 = [0, 0];
+    this.sStartAngle = 0;
+    this.sEndAngle = 0;
+    // Target node, two points forming an arc
+    this.t1 = [0, 0];
+    this.t2 = [0, 0];
+    this.tStartAngle = 0;
+    this.tEndAngle = 0;
+    this.cx = 0;
+    this.cy = 0;
+    // series.r0 of ChordSeries
+    this.r = 0;
+    this.clockwise = true;
+  }
+  return ChordPathShape;
+}();
+var ChordEdge = /** @class */function (_super) {
+  __extends(ChordEdge, _super);
+  function ChordEdge(nodeData, edgeData, edgeIdx, startAngle) {
+    var _this = _super.call(this) || this;
+    getECData(_this).dataType = 'edge';
+    _this.updateData(nodeData, edgeData, edgeIdx, startAngle, true);
+    return _this;
+  }
+  ChordEdge.prototype.buildPath = function (ctx, shape) {
+    // Start from n11
+    ctx.moveTo(shape.s1[0], shape.s1[1]);
+    var ratio = 0.7;
+    var clockwise = shape.clockwise;
+    // Draw the arc from n11 to n12
+    ctx.arc(shape.cx, shape.cy, shape.r, shape.sStartAngle, shape.sEndAngle, !clockwise);
+    // Bezier curve to cp1 and then to n21
+    ctx.bezierCurveTo((shape.cx - shape.s2[0]) * ratio + shape.s2[0], (shape.cy - shape.s2[1]) * ratio + shape.s2[1], (shape.cx - shape.t1[0]) * ratio + shape.t1[0], (shape.cy - shape.t1[1]) * ratio + shape.t1[1], shape.t1[0], shape.t1[1]);
+    // Draw the arc from n21 to n22
+    ctx.arc(shape.cx, shape.cy, shape.r, shape.tStartAngle, shape.tEndAngle, !clockwise);
+    // Bezier curve back to cp2 and then to n11
+    ctx.bezierCurveTo((shape.cx - shape.t2[0]) * ratio + shape.t2[0], (shape.cy - shape.t2[1]) * ratio + shape.t2[1], (shape.cx - shape.s1[0]) * ratio + shape.s1[0], (shape.cy - shape.s1[1]) * ratio + shape.s1[1], shape.s1[0], shape.s1[1]);
+    ctx.closePath();
+  };
+  ChordEdge.prototype.updateData = function (nodeData, edgeData, edgeIdx, startAngle, firstCreate) {
+    var seriesModel = nodeData.hostModel;
+    var edge = edgeData.graph.getEdgeByIndex(edgeIdx);
+    var layout = edge.getLayout();
+    var itemModel = edge.node1.getModel();
+    var edgeModel = edgeData.getItemModel(edge.dataIndex);
+    var lineStyle = edgeModel.getModel('lineStyle');
+    var emphasisModel = edgeModel.getModel('emphasis');
+    var focus = emphasisModel.get('focus');
+    var shape = extend(getSectorCornerRadius(itemModel.getModel('itemStyle'), layout, true), layout);
+    var el = this;
+    // Ignore NaN data.
+    if (isNaN(shape.sStartAngle) || isNaN(shape.tStartAngle)) {
+      // Use NaN shape to avoid drawing shape.
+      el.setShape(shape);
+      return;
+    }
+    if (firstCreate) {
+      el.setShape(shape);
+      applyEdgeFill(el, edge, nodeData, lineStyle);
+    } else {
+      saveOldStyle(el);
+      applyEdgeFill(el, edge, nodeData, lineStyle);
+      updateProps(el, {
+        shape: shape
+      }, seriesModel, edgeIdx);
+    }
+    toggleHoverEmphasis(this, focus === 'adjacency' ? edge.getAdjacentDataIndices() : focus, emphasisModel.get('blurScope'), emphasisModel.get('disabled'));
+    setStatesStylesFromModel(el, edgeModel, 'lineStyle');
+    edgeData.setItemGraphicEl(edge.dataIndex, el);
+  };
+  return ChordEdge;
+}(Path);
+function applyEdgeFill(edgeShape, edge, nodeData, lineStyleModel) {
+  var node1 = edge.node1;
+  var node2 = edge.node2;
+  var edgeStyle = edgeShape.style;
+  edgeShape.setStyle(lineStyleModel.getLineStyle());
+  var color = lineStyleModel.get('color');
+  switch (color) {
+    case 'source':
+      // TODO: use visual and node1.getVisual('color');
+      edgeStyle.fill = nodeData.getItemVisual(node1.dataIndex, 'style').fill;
+      edgeStyle.decal = node1.getVisual('style').decal;
+      break;
+    case 'target':
+      edgeStyle.fill = nodeData.getItemVisual(node2.dataIndex, 'style').fill;
+      edgeStyle.decal = node2.getVisual('style').decal;
+      break;
+    case 'gradient':
+      var sourceColor = nodeData.getItemVisual(node1.dataIndex, 'style').fill;
+      var targetColor = nodeData.getItemVisual(node2.dataIndex, 'style').fill;
+      if (isString(sourceColor) && isString(targetColor)) {
+        // Gradient direction is perpendicular to the mid-angles
+        // of source and target nodes.
+        var shape = edgeShape.shape;
+        var sMidX = (shape.s1[0] + shape.s2[0]) / 2;
+        var sMidY = (shape.s1[1] + shape.s2[1]) / 2;
+        var tMidX = (shape.t1[0] + shape.t2[0]) / 2;
+        var tMidY = (shape.t1[1] + shape.t2[1]) / 2;
+        edgeStyle.fill = new LinearGradient(sMidX, sMidY, tMidX, tMidY, [{
+          offset: 0,
+          color: sourceColor
+        }, {
+          offset: 1,
+          color: targetColor
+        }], true);
+      }
+      break;
+  }
+}
+
+export { ChordEdge, ChordPathShape };