@fmdevui/fm-dev 1.0.113 → 1.0.115

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/helper/multipleGraphEdgeHelper.js

@@ -0,0 +1,189 @@
+'use strict';
+
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+
+var KEY_DELIMITER = '-->';
+/**
+ * params handler
+ * @param {module:echarts/model/SeriesModel} seriesModel
+ * @returns {*}
+ */
+var getAutoCurvenessParams = function (seriesModel) {
+  return seriesModel.get('autoCurveness') || null;
+};
+/**
+ * Generate a list of edge curvatures, 20 is the default
+ * @param {module:echarts/model/SeriesModel} seriesModel
+ * @param {number} appendLength
+ * @return  20 => [0, -0.2, 0.2, -0.4, 0.4, -0.6, 0.6, -0.8, 0.8, -1, 1, -1.2, 1.2, -1.4, 1.4, -1.6, 1.6, -1.8, 1.8, -2]
+ */
+var createCurveness = function (seriesModel, appendLength) {
+  var autoCurvenessParmas = getAutoCurvenessParams(seriesModel);
+  var length = 20;
+  var curvenessList = [];
+  // handler the function set
+  if (util.isNumber(autoCurvenessParmas)) {
+    length = autoCurvenessParmas;
+  } else if (util.isArray(autoCurvenessParmas)) {
+    seriesModel.__curvenessList = autoCurvenessParmas;
+    return;
+  }
+  // append length
+  if (appendLength > length) {
+    length = appendLength;
+  }
+  // make sure the length is even
+  var len = length % 2 ? length + 2 : length + 3;
+  curvenessList = [];
+  for (var i = 0; i < len; i++) {
+    curvenessList.push((i % 2 ? i + 1 : i) / 10 * (i % 2 ? -1 : 1));
+  }
+  seriesModel.__curvenessList = curvenessList;
+};
+/**
+ * Create different cache key data in the positive and negative directions, in order to set the curvature later
+ * @param {number|string|module:echarts/data/Graph.Node} n1
+ * @param {number|string|module:echarts/data/Graph.Node} n2
+ * @param {module:echarts/model/SeriesModel} seriesModel
+ * @returns {string} key
+ */
+var getKeyOfEdges = function (n1, n2, seriesModel) {
+  var source = [n1.id, n1.dataIndex].join('.');
+  var target = [n2.id, n2.dataIndex].join('.');
+  return [seriesModel.uid, source, target].join(KEY_DELIMITER);
+};
+/**
+ * get opposite key
+ * @param {string} key
+ * @returns {string}
+ */
+var getOppositeKey = function (key) {
+  var keys = key.split(KEY_DELIMITER);
+  return [keys[0], keys[2], keys[1]].join(KEY_DELIMITER);
+};
+/**
+ * get edgeMap with key
+ * @param edge
+ * @param {module:echarts/model/SeriesModel} seriesModel
+ */
+var getEdgeFromMap = function (edge, seriesModel) {
+  var key = getKeyOfEdges(edge.node1, edge.node2, seriesModel);
+  return seriesModel.__edgeMap[key];
+};
+/**
+ * calculate all cases total length
+ * @param edge
+ * @param seriesModel
+ * @returns {number}
+ */
+var getTotalLengthBetweenNodes = function (edge, seriesModel) {
+  var len = getEdgeMapLengthWithKey(getKeyOfEdges(edge.node1, edge.node2, seriesModel), seriesModel);
+  var lenV = getEdgeMapLengthWithKey(getKeyOfEdges(edge.node2, edge.node1, seriesModel), seriesModel);
+  return len + lenV;
+};
+/**
+ *
+ * @param key
+ */
+var getEdgeMapLengthWithKey = function (key, seriesModel) {
+  var edgeMap = seriesModel.__edgeMap;
+  return edgeMap[key] ? edgeMap[key].length : 0;
+};
+/**
+ * Count the number of edges between the same two points, used to obtain the curvature table and the parity of the edge
+ * @see /graph/GraphSeries.js@getInitialData
+ * @param {module:echarts/model/SeriesModel} seriesModel
+ */
+function initCurvenessList(seriesModel) {
+  if (!getAutoCurvenessParams(seriesModel)) {
+    return;
+  }
+  seriesModel.__curvenessList = [];
+  seriesModel.__edgeMap = {};
+  // calc the array of curveness List
+  createCurveness(seriesModel);
+}
+/**
+ * set edgeMap with key
+ * @param {number|string|module:echarts/data/Graph.Node} n1
+ * @param {number|string|module:echarts/data/Graph.Node} n2
+ * @param {module:echarts/model/SeriesModel} seriesModel
+ * @param {number} index
+ */
+function createEdgeMapForCurveness(n1, n2, seriesModel, index) {
+  if (!getAutoCurvenessParams(seriesModel)) {
+    return;
+  }
+  var key = getKeyOfEdges(n1, n2, seriesModel);
+  var edgeMap = seriesModel.__edgeMap;
+  var oppositeEdges = edgeMap[getOppositeKey(key)];
+  // set direction
+  if (edgeMap[key] && !oppositeEdges) {
+    edgeMap[key].isForward = true;
+  } else if (oppositeEdges && edgeMap[key]) {
+    oppositeEdges.isForward = true;
+    edgeMap[key].isForward = false;
+  }
+  edgeMap[key] = edgeMap[key] || [];
+  edgeMap[key].push(index);
+}
+/**
+ * get curvature for edge
+ * @param edge
+ * @param {module:echarts/model/SeriesModel} seriesModel
+ * @param index
+ */
+function getCurvenessForEdge(edge, seriesModel, index, needReverse) {
+  var autoCurvenessParams = getAutoCurvenessParams(seriesModel);
+  var isArrayParam = util.isArray(autoCurvenessParams);
+  if (!autoCurvenessParams) {
+    return null;
+  }
+  var edgeArray = getEdgeFromMap(edge, seriesModel);
+  if (!edgeArray) {
+    return null;
+  }
+  var edgeIndex = -1;
+  for (var i = 0; i < edgeArray.length; i++) {
+    if (edgeArray[i] === index) {
+      edgeIndex = i;
+      break;
+    }
+  }
+  // if totalLen is Longer createCurveness
+  var totalLen = getTotalLengthBetweenNodes(edge, seriesModel);
+  createCurveness(seriesModel, totalLen);
+  edge.lineStyle = edge.lineStyle || {};
+  // if is opposite edge, must set curvenss to opposite number
+  var curKey = getKeyOfEdges(edge.node1, edge.node2, seriesModel);
+  var curvenessList = seriesModel.__curvenessList;
+  // if pass array no need parity
+  var parityCorrection = isArrayParam ? 0 : totalLen % 2 ? 0 : 1;
+  if (!edgeArray.isForward) {
+    // the opposite edge show outside
+    var oppositeKey = getOppositeKey(curKey);
+    var len = getEdgeMapLengthWithKey(oppositeKey, seriesModel);
+    var resValue = curvenessList[edgeIndex + len + parityCorrection];
+    // isNeedReverse, simple, force type need reverse the curveness in the junction of the forword and the opposite
+    if (needReverse) {
+      // set as array may make the parity handle with the len of opposite
+      if (isArrayParam) {
+        if (autoCurvenessParams && autoCurvenessParams[0] === 0) {
+          return (len + parityCorrection) % 2 ? resValue : -resValue;
+        } else {
+          return ((len % 2 ? 0 : 1) + parityCorrection) % 2 ? resValue : -resValue;
+        }
+      } else {
+        return (len + parityCorrection) % 2 ? resValue : -resValue;
+      }
+    } else {
+      return curvenessList[edgeIndex + len + parityCorrection];
+    }
+  } else {
+    return curvenessList[parityCorrection + edgeIndex];
+  }
+}
+
+exports.createEdgeMapForCurveness = createEdgeMapForCurveness;
+exports.getCurvenessForEdge = getCurvenessForEdge;
+exports.initCurvenessList = initCurvenessList;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/helper/sectorHelper.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var text = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/contain/text.js');
+
+function getSectorCornerRadius(model, shape, zeroIfNull) {
+  var cornerRadius = model.get('borderRadius');
+  if (cornerRadius == null) {
+    return zeroIfNull ? {
+      cornerRadius: 0
+    } : null;
+  }
+  if (!util.isArray(cornerRadius)) {
+    cornerRadius = [cornerRadius, cornerRadius, cornerRadius, cornerRadius];
+  }
+  var dr = Math.abs(shape.r || 0 - shape.r0 || 0);
+  return {
+    cornerRadius: util.map(cornerRadius, function (cr) {
+      return text.parsePercent(cr, dr);
+    })
+  };
+}
+
+exports.getSectorCornerRadius = getSectorCornerRadius;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/helper/treeHelper.js

@@ -0,0 +1,57 @@
+'use strict';
+
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+
+function retrieveTargetInfo(payload, validPayloadTypes, seriesModel) {
+  if (payload && util.indexOf(validPayloadTypes, payload.type) >= 0) {
+    var root = seriesModel.getData().tree.root;
+    var targetNode = payload.targetNode;
+    if (util.isString(targetNode)) {
+      targetNode = root.getNodeById(targetNode);
+    }
+    if (targetNode && root.contains(targetNode)) {
+      return {
+        node: targetNode
+      };
+    }
+    var targetNodeId = payload.targetNodeId;
+    if (targetNodeId != null && (targetNode = root.getNodeById(targetNodeId))) {
+      return {
+        node: targetNode
+      };
+    }
+  }
+}
+// Not includes the given node at the last item.
+function getPathToRoot(node) {
+  var path = [];
+  while (node) {
+    node = node.parentNode;
+    node && path.push(node);
+  }
+  return path.reverse();
+}
+function aboveViewRoot(viewRoot, node) {
+  var viewPath = getPathToRoot(viewRoot);
+  return util.indexOf(viewPath, node) >= 0;
+}
+// From root to the input node (the input node will be included).
+function wrapTreePathInfo(node, seriesModel) {
+  var treePathInfo = [];
+  while (node) {
+    var nodeDataIndex = node.dataIndex;
+    treePathInfo.push({
+      name: node.name,
+      dataIndex: nodeDataIndex,
+      value: seriesModel.getRawValue(nodeDataIndex)
+    });
+    node = node.parentNode;
+  }
+  treePathInfo.reverse();
+  return treePathInfo;
+}
+
+exports.aboveViewRoot = aboveViewRoot;
+exports.getPathToRoot = getPathToRoot;
+exports.retrieveTargetInfo = retrieveTargetInfo;
+exports.wrapTreePathInfo = wrapTreePathInfo;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/helper/whiskerBoxCommon.js

@@ -0,0 +1,106 @@
+'use strict';
+
+var createSeriesDataSimply = require('./createSeriesDataSimply.js');
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var dimensionHelper = require('../../data/helper/dimensionHelper.js');
+var sourceHelper = require('../../data/helper/sourceHelper.js');
+
+var WhiskerBoxCommonMixin = /** @class */function () {
+  function WhiskerBoxCommonMixin() {}
+  /**
+   * @private
+   */
+  WhiskerBoxCommonMixin.prototype._hasEncodeRule = function (key) {
+    var encodeRules = this.getEncode();
+    return encodeRules && encodeRules.get(key) != null;
+  };
+  /**
+   * @override
+   */
+  WhiskerBoxCommonMixin.prototype.getInitialData = function (option, ecModel) {
+    // When both types of xAxis and yAxis are 'value', layout is
+    // needed to be specified by user. Otherwise, layout can be
+    // judged by which axis is category.
+    var ordinalMeta;
+    var xAxisModel = ecModel.getComponent('xAxis', this.get('xAxisIndex'));
+    var yAxisModel = ecModel.getComponent('yAxis', this.get('yAxisIndex'));
+    var xAxisType = xAxisModel.get('type');
+    var yAxisType = yAxisModel.get('type');
+    var addOrdinal;
+    // FIXME
+    // Consider time axis.
+    if (xAxisType === 'category') {
+      option.layout = 'horizontal';
+      ordinalMeta = xAxisModel.getOrdinalMeta();
+      addOrdinal = !this._hasEncodeRule('x');
+    } else if (yAxisType === 'category') {
+      option.layout = 'vertical';
+      ordinalMeta = yAxisModel.getOrdinalMeta();
+      addOrdinal = !this._hasEncodeRule('y');
+    } else {
+      option.layout = option.layout || 'horizontal';
+    }
+    var coordDims = ['x', 'y'];
+    var baseAxisDimIndex = option.layout === 'horizontal' ? 0 : 1;
+    var baseAxisDim = this._baseAxisDim = coordDims[baseAxisDimIndex];
+    var otherAxisDim = coordDims[1 - baseAxisDimIndex];
+    var axisModels = [xAxisModel, yAxisModel];
+    var baseAxisType = axisModels[baseAxisDimIndex].get('type');
+    var otherAxisType = axisModels[1 - baseAxisDimIndex].get('type');
+    var data = option.data;
+    // Clone a new data for next setOption({}) usage.
+    // Avoid modifying current data will affect further update.
+    if (data && addOrdinal) {
+      var newOptionData_1 = [];
+      util.each(data, function (item, index) {
+        var newItem;
+        if (util.isArray(item)) {
+          newItem = item.slice();
+          // Modify current using data.
+          item.unshift(index);
+        } else if (util.isArray(item.value)) {
+          newItem = util.extend({}, item);
+          newItem.value = newItem.value.slice();
+          // Modify current using data.
+          item.value.unshift(index);
+        } else {
+          newItem = item;
+        }
+        newOptionData_1.push(newItem);
+      });
+      option.data = newOptionData_1;
+    }
+    var defaultValueDimensions = this.defaultValueDimensions;
+    var coordDimensions = [{
+      name: baseAxisDim,
+      type: dimensionHelper.getDimensionTypeByAxis(baseAxisType),
+      ordinalMeta: ordinalMeta,
+      otherDims: {
+        tooltip: false,
+        itemName: 0
+      },
+      dimsDef: ['base']
+    }, {
+      name: otherAxisDim,
+      type: dimensionHelper.getDimensionTypeByAxis(otherAxisType),
+      dimsDef: defaultValueDimensions.slice()
+    }];
+    return createSeriesDataSimply.default(this, {
+      coordDimensions: coordDimensions,
+      dimensionsCount: defaultValueDimensions.length + 1,
+      encodeDefaulter: util.curry(sourceHelper.makeSeriesEncodeForAxisCoordSys, coordDimensions, this)
+    });
+  };
+  /**
+   * If horizontal, base axis is x, otherwise y.
+   * @override
+   */
+  WhiskerBoxCommonMixin.prototype.getBaseAxis = function () {
+    var dim = this._baseAxisDim;
+    return this.ecModel.getComponent(dim + 'Axis', this.get(dim + 'AxisIndex')).axis;
+  };
+  return WhiskerBoxCommonMixin;
+}();
+;
+
+exports.WhiskerBoxCommonMixin = WhiskerBoxCommonMixin;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/line/LineSeries.js

@@ -0,0 +1,117 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js');
+var createSeriesData = require('../helper/createSeriesData.js');
+var Series = require('../../model/Series.js');
+var symbol = require('../../util/symbol.js');
+require('../../util/graphic.js');
+var tokens = require('../../visual/tokens.js');
+var Group = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/Group.js');
+
+var LineSeriesModel = /** @class */function (_super) {
+  tslib_es6.__extends(LineSeriesModel, _super);
+  function LineSeriesModel() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = LineSeriesModel.type;
+    _this.hasSymbolVisual = true;
+    return _this;
+  }
+  LineSeriesModel.prototype.getInitialData = function (option) {
+    if (process.env.NODE_ENV !== 'production') {
+      var coordSys = option.coordinateSystem;
+      if (coordSys !== 'polar' && coordSys !== 'cartesian2d') {
+        throw new Error('Line not support coordinateSystem besides cartesian and polar');
+      }
+    }
+    return createSeriesData.default(null, this, {
+      useEncodeDefaulter: true
+    });
+  };
+  LineSeriesModel.prototype.getLegendIcon = function (opt) {
+    var group = new Group.default();
+    var line = symbol.createSymbol('line', 0, opt.itemHeight / 2, opt.itemWidth, 0, opt.lineStyle.stroke, false);
+    group.add(line);
+    line.setStyle(opt.lineStyle);
+    var visualType = this.getData().getVisual('symbol');
+    var visualRotate = this.getData().getVisual('symbolRotate');
+    var symbolType = visualType === 'none' ? 'circle' : visualType;
+    // Symbol size is 80% when there is a line
+    var size = opt.itemHeight * 0.8;
+    var symbol$1 = symbol.createSymbol(symbolType, (opt.itemWidth - size) / 2, (opt.itemHeight - size) / 2, size, size, opt.itemStyle.fill);
+    group.add(symbol$1);
+    symbol$1.setStyle(opt.itemStyle);
+    var symbolRotate = opt.iconRotate === 'inherit' ? visualRotate : opt.iconRotate || 0;
+    symbol$1.rotation = symbolRotate * Math.PI / 180;
+    symbol$1.setOrigin([opt.itemWidth / 2, opt.itemHeight / 2]);
+    if (symbolType.indexOf('empty') > -1) {
+      symbol$1.style.stroke = symbol$1.style.fill;
+      symbol$1.style.fill = tokens.default.color.neutral00;
+      symbol$1.style.lineWidth = 2;
+    }
+    return group;
+  };
+  LineSeriesModel.type = 'series.line';
+  LineSeriesModel.dependencies = ['grid', 'polar'];
+  LineSeriesModel.defaultOption = {
+    // zlevel: 0,
+    z: 3,
+    coordinateSystem: 'cartesian2d',
+    legendHoverLink: true,
+    clip: true,
+    label: {
+      position: 'top'
+    },
+    // itemStyle: {
+    // },
+    endLabel: {
+      show: false,
+      valueAnimation: true,
+      distance: 8
+    },
+    lineStyle: {
+      width: 2,
+      type: 'solid'
+    },
+    emphasis: {
+      scale: true
+    },
+    // areaStyle: {
+    // origin of areaStyle. Valid values:
+    // `'auto'/null/undefined`: from axisLine to data
+    // `'start'`: from min to data
+    // `'end'`: from data to max
+    // origin: 'auto'
+    // },
+    // false, 'start', 'end', 'middle'
+    step: false,
+    // Disabled if step is true
+    smooth: false,
+    smoothMonotone: null,
+    symbol: 'emptyCircle',
+    symbolSize: 6,
+    symbolRotate: null,
+    showSymbol: true,
+    // `false`: follow the label interval strategy.
+    // `true`: show all symbols.
+    // `'auto'`: If possible, show all symbols, otherwise
+    //           follow the label interval strategy.
+    showAllSymbol: 'auto',
+    // Whether to connect break point.
+    connectNulls: false,
+    // Sampling for large data. Can be: 'average', 'max', 'min', 'sum', 'lttb'.
+    sampling: 'none',
+    animationEasing: 'linear',
+    // Disable progressive
+    progressive: 0,
+    hoverLayerThreshold: Infinity,
+    universalTransition: {
+      divideShape: 'clone'
+    },
+    triggerLineEvent: false
+  };
+  return LineSeriesModel;
+}(Series.default);
+
+exports.default = LineSeriesModel;