@fmdevui/fm-dev 1.0.113 → 1.0.114

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/themeRiver/themeRiverLayout.mjs

@@ -0,0 +1,117 @@
+import { map } from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+import { parsePercent } from '../../util/number.mjs';
+
+function themeRiverLayout(ecModel, api) {
+  ecModel.eachSeriesByType('themeRiver', function (seriesModel) {
+    var data = seriesModel.getData();
+    var single = seriesModel.coordinateSystem;
+    var layoutInfo = {};
+    // use the axis boundingRect for view
+    var rect = single.getRect();
+    layoutInfo.rect = rect;
+    var boundaryGap = seriesModel.get('boundaryGap');
+    var axis = single.getAxis();
+    layoutInfo.boundaryGap = boundaryGap;
+    if (axis.orient === 'horizontal') {
+      boundaryGap[0] = parsePercent(boundaryGap[0], rect.height);
+      boundaryGap[1] = parsePercent(boundaryGap[1], rect.height);
+      var height = rect.height - boundaryGap[0] - boundaryGap[1];
+      doThemeRiverLayout(data, seriesModel, height);
+    } else {
+      boundaryGap[0] = parsePercent(boundaryGap[0], rect.width);
+      boundaryGap[1] = parsePercent(boundaryGap[1], rect.width);
+      var width = rect.width - boundaryGap[0] - boundaryGap[1];
+      doThemeRiverLayout(data, seriesModel, width);
+    }
+    data.setLayout('layoutInfo', layoutInfo);
+  });
+}
+/**
+ * The layout information about themeriver
+ *
+ * @param data  data in the series
+ * @param seriesModel  the model object of themeRiver series
+ * @param height  value used to compute every series height
+ */
+function doThemeRiverLayout(data, seriesModel, height) {
+  if (!data.count()) {
+    return;
+  }
+  var coordSys = seriesModel.coordinateSystem;
+  // the data in each layer are organized into a series.
+  var layerSeries = seriesModel.getLayerSeries();
+  // the points in each layer.
+  var timeDim = data.mapDimension('single');
+  var valueDim = data.mapDimension('value');
+  var layerPoints = map(layerSeries, function (singleLayer) {
+    return map(singleLayer.indices, function (idx) {
+      var pt = coordSys.dataToPoint(data.get(timeDim, idx));
+      pt[1] = data.get(valueDim, idx);
+      return pt;
+    });
+  });
+  var base = computeBaseline(layerPoints);
+  var baseLine = base.y0;
+  var ky = height / base.max;
+  // set layout information for each item.
+  var n = layerSeries.length;
+  var m = layerSeries[0].indices.length;
+  var baseY0;
+  for (var j = 0; j < m; ++j) {
+    baseY0 = baseLine[j] * ky;
+    data.setItemLayout(layerSeries[0].indices[j], {
+      layerIndex: 0,
+      x: layerPoints[0][j][0],
+      y0: baseY0,
+      y: layerPoints[0][j][1] * ky
+    });
+    for (var i = 1; i < n; ++i) {
+      baseY0 += layerPoints[i - 1][j][1] * ky;
+      data.setItemLayout(layerSeries[i].indices[j], {
+        layerIndex: i,
+        x: layerPoints[i][j][0],
+        y0: baseY0,
+        y: layerPoints[i][j][1] * ky
+      });
+    }
+  }
+}
+/**
+ * Compute the baseLine of the rawdata
+ * Inspired by Lee Byron's paper Stacked Graphs - Geometry & Aesthetics
+ *
+ * @param  data  the points in each layer
+ */
+function computeBaseline(data) {
+  var layerNum = data.length;
+  var pointNum = data[0].length;
+  var sums = [];
+  var y0 = [];
+  var max = 0;
+  for (var i = 0; i < pointNum; ++i) {
+    var temp = 0;
+    for (var j = 0; j < layerNum; ++j) {
+      temp += data[j][i][1];
+    }
+    if (temp > max) {
+      max = temp;
+    }
+    sums.push(temp);
+  }
+  for (var k = 0; k < pointNum; ++k) {
+    y0[k] = (max - sums[k]) / 2;
+  }
+  max = 0;
+  for (var l = 0; l < pointNum; ++l) {
+    var sum = sums[l] + y0[l];
+    if (sum > max) {
+      max = sum;
+    }
+  }
+  return {
+    y0: y0,
+    max: max
+  };
+}
+
+export { themeRiverLayout as default };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/tree/TreeSeries.mjs

@@ -0,0 +1,150 @@
+import { __extends } from '../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs';
+import SeriesModel from '../../model/Series.mjs';
+import Tree from '../../data/Tree.mjs';
+import Model from '../../model/Model.mjs';
+import { createTooltipMarkup } from '../../component/tooltip/tooltipMarkup.mjs';
+import { wrapTreePathInfo } from '../helper/treeHelper.mjs';
+import tokens from '../../visual/tokens.mjs';
+
+var TreeSeriesModel = /** @class */function (_super) {
+  __extends(TreeSeriesModel, _super);
+  function TreeSeriesModel() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.hasSymbolVisual = true;
+    // Do it self.
+    _this.ignoreStyleOnData = true;
+    return _this;
+  }
+  /**
+   * Init a tree data structure from data in option series
+   */
+  TreeSeriesModel.prototype.getInitialData = function (option) {
+    // create a virtual root
+    var root = {
+      name: option.name,
+      children: option.data
+    };
+    var leaves = option.leaves || {};
+    var leavesModel = new Model(leaves, this, this.ecModel);
+    var tree = Tree.createTree(root, this, beforeLink);
+    function beforeLink(nodeData) {
+      nodeData.wrapMethod('getItemModel', function (model, idx) {
+        var node = tree.getNodeByDataIndex(idx);
+        if (!(node && node.children.length && node.isExpand)) {
+          model.parentModel = leavesModel;
+        }
+        return model;
+      });
+    }
+    var treeDepth = 0;
+    tree.eachNode('preorder', function (node) {
+      if (node.depth > treeDepth) {
+        treeDepth = node.depth;
+      }
+    });
+    var expandAndCollapse = option.expandAndCollapse;
+    var expandTreeDepth = expandAndCollapse && option.initialTreeDepth >= 0 ? option.initialTreeDepth : treeDepth;
+    tree.root.eachNode('preorder', function (node) {
+      var item = node.hostTree.data.getRawDataItem(node.dataIndex);
+      // Add item.collapsed != null, because users can collapse node original in the series.data.
+      node.isExpand = item && item.collapsed != null ? !item.collapsed : node.depth <= expandTreeDepth;
+    });
+    return tree.data;
+  };
+  /**
+   * Make the configuration 'orient' backward compatibly, with 'horizontal = LR', 'vertical = TB'.
+   * @returns {string} orient
+   */
+  TreeSeriesModel.prototype.getOrient = function () {
+    var orient = this.get('orient');
+    if (orient === 'horizontal') {
+      orient = 'LR';
+    } else if (orient === 'vertical') {
+      orient = 'TB';
+    }
+    return orient;
+  };
+  TreeSeriesModel.prototype.setZoom = function (zoom) {
+    this.option.zoom = zoom;
+  };
+  TreeSeriesModel.prototype.setCenter = function (center) {
+    this.option.center = center;
+  };
+  TreeSeriesModel.prototype.formatTooltip = function (dataIndex, multipleSeries, dataType) {
+    var tree = this.getData().tree;
+    var realRoot = tree.root.children[0];
+    var node = tree.getNodeByDataIndex(dataIndex);
+    var value = node.getValue();
+    var name = node.name;
+    while (node && node !== realRoot) {
+      name = node.parentNode.name + '.' + name;
+      node = node.parentNode;
+    }
+    return createTooltipMarkup('nameValue', {
+      name: name,
+      value: value,
+      noValue: isNaN(value) || value == null
+    });
+  };
+  // Add tree path to tooltip param
+  TreeSeriesModel.prototype.getDataParams = function (dataIndex) {
+    var params = _super.prototype.getDataParams.apply(this, arguments);
+    var node = this.getData().tree.getNodeByDataIndex(dataIndex);
+    params.treeAncestors = wrapTreePathInfo(node, this);
+    params.collapsed = !node.isExpand;
+    return params;
+  };
+  TreeSeriesModel.type = 'series.tree';
+  // can support the position parameters 'left', 'top','right','bottom', 'width',
+  // 'height' in the setOption() with 'merge' mode normal.
+  TreeSeriesModel.layoutMode = 'box';
+  TreeSeriesModel.defaultOption = {
+    // zlevel: 0,
+    z: 2,
+    // `coordinateSystem` can be declared as 'matrix', 'calendar',
+    //  which provides box layout container.
+    coordinateSystemUsage: 'box',
+    // the position of the whole view
+    left: '12%',
+    top: '12%',
+    right: '12%',
+    bottom: '12%',
+    // the layout of the tree, two value can be selected, 'orthogonal' or 'radial'
+    layout: 'orthogonal',
+    // value can be 'polyline'
+    edgeShape: 'curve',
+    edgeForkPosition: '50%',
+    // true | false | 'move' | 'scale', see module:component/helper/RoamController.
+    roam: false,
+    roamTrigger: 'global',
+    // Symbol size scale ratio in roam
+    nodeScaleRatio: 0.4,
+    // Default on center of graph
+    center: null,
+    zoom: 1,
+    orient: 'LR',
+    symbol: 'emptyCircle',
+    symbolSize: 7,
+    expandAndCollapse: true,
+    initialTreeDepth: 2,
+    lineStyle: {
+      color: tokens.color.borderTint,
+      width: 1.5,
+      curveness: 0.5
+    },
+    itemStyle: {
+      color: 'lightsteelblue',
+      // borderColor: '#c23531',
+      borderWidth: 1.5
+    },
+    label: {
+      show: true
+    },
+    animationEasing: 'linear',
+    animationDuration: 700,
+    animationDurationUpdate: 500
+  };
+  return TreeSeriesModel;
+}(SeriesModel);
+
+export { TreeSeriesModel as default };