@fmdevui/fm-dev 1.0.113 → 1.0.114

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/graph/forceLayout.js

@@ -0,0 +1,124 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var forceHelper = require('./forceHelper.js');
+var simpleLayoutHelper = require('./simpleLayoutHelper.js');
+var circularLayoutHelper = require('./circularLayoutHelper.js');
+var number = require('../../util/number.js');
+var vector = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/vector.js');
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var multipleGraphEdgeHelper = require('../helper/multipleGraphEdgeHelper.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') {
+        simpleLayoutHelper.simpleLayout(graphSeries);
+      } else if (initLayout === 'circular') {
+        circularLayoutHelper.circularLayout(graphSeries, 'value');
+      }
+      var nodeDataExtent_1 = nodeData_1.getDataExtent('value');
+      var edgeDataExtent_1 = edgeData.getDataExtent('value');
+      // let edgeDataExtent = edgeData.getDataExtent('value');
+      var repulsion = forceModel.get('repulsion');
+      var edgeLength = forceModel.get('edgeLength');
+      var repulsionArr_1 = util.isArray(repulsion) ? repulsion : [repulsion, repulsion];
+      var edgeLengthArr_1 = util.isArray(edgeLength) ? edgeLength : [edgeLength, edgeLength];
+      // Larger value has smaller length
+      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 = number.linearMap(value, nodeDataExtent_1, repulsionArr_1);
+        if (isNaN(rep)) {
+          rep = (repulsionArr_1[0] + repulsionArr_1[1]) / 2;
+        }
+        return {
+          w: rep,
+          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 = number.linearMap(value, edgeDataExtent_1, edgeLengthArr_1);
+        if (isNaN(d)) {
+          d = (edgeLengthArr_1[0] + edgeLengthArr_1[1]) / 2;
+        }
+        var edgeModel = edge.getModel();
+        var curveness = util.retrieve3(edge.getModel().get(['lineStyle', 'curveness']), -multipleGraphEdgeHelper.getCurvenessForEdge(edge, graphSeries, idx, true), 0);
+        return {
+          n1: nodes_1[edge.node1.dataIndex],
+          n2: nodes_1[edge.node2.dataIndex],
+          d: d,
+          curveness: curveness,
+          ignoreForceLayout: edgeModel.get('ignoreForceLayout')
+        };
+      });
+      // let coordSys = graphSeries.coordinateSystem;
+      var rect = coordSys.getBoundingRect();
+      var forceInstance = forceHelper.forceLayout(nodes_1, edges, {
+        rect: rect,
+        gravity: forceModel.get('gravity'),
+        friction: forceModel.get('friction')
+      });
+      forceInstance.beforeStep(function (nodes, edges) {
+        for (var i = 0, l = nodes.length; i < l; i++) {
+          if (nodes[i].fixed) {
+            // Write back to layout instance
+            vector.copy(nodes[i].p, graph_1.getNodeByIndex(i).getLayout());
+          }
+        }
+      });
+      forceInstance.afterStep(function (nodes, edges, 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 = edges.length; i < l; i++) {
+          var e = edges[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] || [];
+          vector.copy(points[0], p1);
+          vector.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;
+      // Step to get the layout
+      forceInstance.step();
+    } else {
+      // Remove prev injected forceLayout instance
+      graphSeries.forceLayout = null;
+    }
+  });
+}
+
+exports.default = graphForceLayout;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/graph/graphHelper.js

@@ -0,0 +1,66 @@
+'use strict';
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+
+
+/**
+ * AUTO-GENERATED FILE. DO NOT MODIFY.
+ */
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+function getNodeGlobalScale(seriesModel) {
+  var coordSys = seriesModel.coordinateSystem;
+  if (coordSys.type !== 'view') {
+    return 1;
+  }
+  var nodeScaleRatio = seriesModel.option.nodeScaleRatio;
+  var groupZoom = coordSys.scaleX;
+  // Scale node when zoom changes
+  var roamZoom = coordSys.getZoom();
+  var nodeScale = (roamZoom - 1) * nodeScaleRatio + 1;
+  return nodeScale / groupZoom;
+}
+function getSymbolSize(node) {
+  var symbolSize = node.getVisual('symbolSize');
+  if (symbolSize instanceof Array) {
+    symbolSize = (symbolSize[0] + symbolSize[1]) / 2;
+  }
+  return +symbolSize;
+}
+
+exports.getNodeGlobalScale = getNodeGlobalScale;
+exports.getSymbolSize = getSymbolSize;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/graph/install.js

@@ -0,0 +1,67 @@
+'use strict';
+
+var categoryFilter = require('./categoryFilter.js');
+var categoryVisual = require('./categoryVisual.js');
+var edgeVisual = require('./edgeVisual.js');
+var simpleLayout = require('./simpleLayout.js');
+var circularLayout = require('./circularLayout.js');
+var forceLayout = require('./forceLayout.js');
+var createView = require('./createView.js');
+var View = require('../../coord/View.js');
+var GraphView = require('./GraphView.js');
+var GraphSeries = require('./GraphSeries.js');
+var roamHelper = require('../../component/helper/roamHelper.js');
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+
+function install(registers) {
+  registers.registerChartView(GraphView.default);
+  registers.registerSeriesModel(GraphSeries.default);
+  registers.registerProcessor(categoryFilter.default);
+  registers.registerVisual(categoryVisual.default);
+  registers.registerVisual(edgeVisual.default);
+  registers.registerLayout(simpleLayout.default);
+  registers.registerLayout(registers.PRIORITY.VISUAL.POST_CHART_LAYOUT, circularLayout.default);
+  registers.registerLayout(forceLayout.default);
+  registers.registerCoordinateSystem('graphView', {
+    dimensions: View.default.dimensions,
+    create: createView.default
+  });
+  // Register legacy focus actions
+  registers.registerAction({
+    type: 'focusNodeAdjacency',
+    event: 'focusNodeAdjacency',
+    update: 'series:focusNodeAdjacency'
+  }, util.noop);
+  registers.registerAction({
+    type: 'unfocusNodeAdjacency',
+    event: 'unfocusNodeAdjacency',
+    update: 'series:unfocusNodeAdjacency'
+  }, util.noop);
+  // Register roam action.
+  registers.registerAction({
+    type: 'graphRoam',
+    event: 'graphRoam',
+    update: 'none'
+  }, function (payload, ecModel, api) {
+    ecModel.eachComponent({
+      mainType: 'series',
+      query: payload
+    }, function (seriesModel) {
+      var graphView = api.getViewOfSeriesModel(seriesModel);
+      if (graphView) {
+        if (payload.dx != null && payload.dy != null) {
+          graphView.updateViewOnPan(seriesModel, api, payload);
+        }
+        if (payload.zoom != null && payload.originX != null && payload.originY != null) {
+          graphView.updateViewOnZoom(seriesModel, api, payload);
+        }
+      }
+      var coordSys = seriesModel.coordinateSystem;
+      var res = roamHelper.updateCenterAndZoomInAction(coordSys, payload, seriesModel.get('scaleLimit'));
+      seriesModel.setCenter && seriesModel.setCenter(res.center);
+      seriesModel.setZoom && seriesModel.setZoom(res.zoom);
+    });
+  });
+}
+
+exports.install = install;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/graph/simpleLayout.js

@@ -0,0 +1,42 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var simpleLayoutHelper = require('./simpleLayoutHelper.js');
+
+function graphSimpleLayout(ecModel, api) {
+  ecModel.eachSeriesByType('graph', function (seriesModel) {
+    var layout = seriesModel.get('layout');
+    var coordSys = seriesModel.coordinateSystem;
+    if (coordSys && coordSys.type !== 'view') {
+      var data_1 = seriesModel.getData();
+      var dimensions_1 = [];
+      util.each(coordSys.dimensions, function (coordDim) {
+        dimensions_1 = dimensions_1.concat(data_1.mapDimensionsAll(coordDim));
+      });
+      for (var dataIndex = 0; dataIndex < data_1.count(); dataIndex++) {
+        var value = [];
+        var hasValue = false;
+        for (var i = 0; i < dimensions_1.length; i++) {
+          var val = data_1.get(dimensions_1[i], dataIndex);
+          if (!isNaN(val)) {
+            hasValue = true;
+          }
+          value.push(val);
+        }
+        if (hasValue) {
+          data_1.setItemLayout(dataIndex, coordSys.dataToPoint(value));
+        } else {
+          // Also {Array.<number>}, not undefined to avoid if...else... statement
+          data_1.setItemLayout(dataIndex, [NaN, NaN]);
+        }
+      }
+      simpleLayoutHelper.simpleLayoutEdge(data_1.graph, seriesModel);
+    } else if (!layout || layout === 'none') {
+      simpleLayoutHelper.simpleLayout(seriesModel);
+    }
+  });
+}
+
+exports.default = graphSimpleLayout;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/graph/simpleLayoutHelper.js

@@ -0,0 +1,33 @@
+'use strict';
+
+var vector = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/vector.js');
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var multipleGraphEdgeHelper = require('../helper/multipleGraphEdgeHelper.js');
+
+function simpleLayout(seriesModel) {
+  var coordSys = seriesModel.coordinateSystem;
+  if (coordSys && coordSys.type !== 'view') {
+    return;
+  }
+  var graph = seriesModel.getGraph();
+  graph.eachNode(function (node) {
+    var model = node.getModel();
+    node.setLayout([+model.get('x'), +model.get('y')]);
+  });
+  simpleLayoutEdge(graph, seriesModel);
+}
+function simpleLayoutEdge(graph, seriesModel) {
+  graph.eachEdge(function (edge, index) {
+    var curveness = util.retrieve3(edge.getModel().get(['lineStyle', 'curveness']), -multipleGraphEdgeHelper.getCurvenessForEdge(edge, seriesModel, index, true), 0);
+    var p1 = vector.clone(edge.node1.getLayout());
+    var p2 = vector.clone(edge.node2.getLayout());
+    var points = [p1, p2];
+    if (+curveness) {
+      points.push([(p1[0] + p2[0]) / 2 - (p1[1] - p2[1]) * curveness, (p1[1] + p2[1]) / 2 - (p2[0] - p1[0]) * curveness]);
+    }
+    edge.setLayout(points);
+  });
+}
+
+exports.simpleLayout = simpleLayout;
+exports.simpleLayoutEdge = simpleLayoutEdge;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/heatmap/HeatmapLayer.js

@@ -0,0 +1,129 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var platform = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/platform.js');
+var tokens = require('../../visual/tokens.js');
+
+var GRADIENT_LEVELS = 256;
+var HeatmapLayer = /** @class */function () {
+  function HeatmapLayer() {
+    this.blurSize = 30;
+    this.pointSize = 20;
+    this.maxOpacity = 1;
+    this.minOpacity = 0;
+    this._gradientPixels = {
+      inRange: null,
+      outOfRange: null
+    };
+    var canvas = platform.platformApi.createCanvas();
+    this.canvas = canvas;
+  }
+  /**
+   * Renders Heatmap and returns the rendered canvas
+   * @param data array of data, each has x, y, value
+   * @param width canvas width
+   * @param height canvas height
+   */
+  HeatmapLayer.prototype.update = function (data, width, height, normalize, colorFunc, isInRange) {
+    var brush = this._getBrush();
+    var gradientInRange = this._getGradient(colorFunc, 'inRange');
+    var gradientOutOfRange = this._getGradient(colorFunc, 'outOfRange');
+    var r = this.pointSize + this.blurSize;
+    var canvas = this.canvas;
+    var ctx = canvas.getContext('2d');
+    var len = data.length;
+    canvas.width = width;
+    canvas.height = height;
+    for (var i = 0; i < len; ++i) {
+      var p = data[i];
+      var x = p[0];
+      var y = p[1];
+      var value = p[2];
+      // calculate alpha using value
+      var alpha = normalize(value);
+      // draw with the circle brush with alpha
+      ctx.globalAlpha = alpha;
+      ctx.drawImage(brush, x - r, y - r);
+    }
+    if (!canvas.width || !canvas.height) {
+      // Avoid "Uncaught DOMException: Failed to execute 'getImageData' on
+      // 'CanvasRenderingContext2D': The source height is 0."
+      return canvas;
+    }
+    // colorize the canvas using alpha value and set with gradient
+    var imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+    var pixels = imageData.data;
+    var offset = 0;
+    var pixelLen = pixels.length;
+    var minOpacity = this.minOpacity;
+    var maxOpacity = this.maxOpacity;
+    var diffOpacity = maxOpacity - minOpacity;
+    while (offset < pixelLen) {
+      var alpha = pixels[offset + 3] / 256;
+      var gradientOffset = Math.floor(alpha * (GRADIENT_LEVELS - 1)) * 4;
+      // Simple optimize to ignore the empty data
+      if (alpha > 0) {
+        var gradient = isInRange(alpha) ? gradientInRange : gradientOutOfRange;
+        // Any alpha > 0 will be mapped to [minOpacity, maxOpacity]
+        alpha > 0 && (alpha = alpha * diffOpacity + minOpacity);
+        pixels[offset++] = gradient[gradientOffset];
+        pixels[offset++] = gradient[gradientOffset + 1];
+        pixels[offset++] = gradient[gradientOffset + 2];
+        pixels[offset++] = gradient[gradientOffset + 3] * alpha * 256;
+      } else {
+        offset += 4;
+      }
+    }
+    ctx.putImageData(imageData, 0, 0);
+    return canvas;
+  };
+  /**
+   * get canvas of a black circle brush used for canvas to draw later
+   */
+  HeatmapLayer.prototype._getBrush = function () {
+    var brushCanvas = this._brushCanvas || (this._brushCanvas = platform.platformApi.createCanvas());
+    // set brush size
+    var r = this.pointSize + this.blurSize;
+    var d = r * 2;
+    brushCanvas.width = d;
+    brushCanvas.height = d;
+    var ctx = brushCanvas.getContext('2d');
+    ctx.clearRect(0, 0, d, d);
+    // in order to render shadow without the distinct circle,
+    // draw the distinct circle in an invisible place,
+    // and use shadowOffset to draw shadow in the center of the canvas
+    ctx.shadowOffsetX = d;
+    ctx.shadowBlur = this.blurSize;
+    // draw the shadow in black, and use alpha and shadow blur to generate
+    // color in color map
+    ctx.shadowColor = tokens.default.color.neutral99;
+    // draw circle in the left to the canvas
+    ctx.beginPath();
+    ctx.arc(-r, r, this.pointSize, 0, Math.PI * 2, true);
+    ctx.closePath();
+    ctx.fill();
+    return brushCanvas;
+  };
+  /**
+   * get gradient color map
+   * @private
+   */
+  HeatmapLayer.prototype._getGradient = function (colorFunc, state) {
+    var gradientPixels = this._gradientPixels;
+    var pixelsSingleState = gradientPixels[state] || (gradientPixels[state] = new Uint8ClampedArray(256 * 4));
+    var color = [0, 0, 0, 0];
+    var off = 0;
+    for (var i = 0; i < 256; i++) {
+      colorFunc[state](i / 255, true, color);
+      pixelsSingleState[off++] = color[0];
+      pixelsSingleState[off++] = color[1];
+      pixelsSingleState[off++] = color[2];
+      pixelsSingleState[off++] = color[3];
+    }
+    return pixelsSingleState;
+  };
+  return HeatmapLayer;
+}();
+
+exports.default = HeatmapLayer;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/chart/heatmap/HeatmapSeries.js

@@ -0,0 +1,53 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js');
+var Series = require('../../model/Series.js');
+var createSeriesData = require('../helper/createSeriesData.js');
+var CoordinateSystem = require('../../core/CoordinateSystem.js');
+var tokens = require('../../visual/tokens.js');
+
+var HeatmapSeriesModel = /** @class */function (_super) {
+  tslib_es6.__extends(HeatmapSeriesModel, _super);
+  function HeatmapSeriesModel() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = HeatmapSeriesModel.type;
+    return _this;
+  }
+  HeatmapSeriesModel.prototype.getInitialData = function (option, ecModel) {
+    return createSeriesData.default(null, this, {
+      generateCoord: 'value'
+    });
+  };
+  HeatmapSeriesModel.prototype.preventIncremental = function () {
+    var coordSysCreator = CoordinateSystem.default.get(this.get('coordinateSystem'));
+    if (coordSysCreator && coordSysCreator.dimensions) {
+      return coordSysCreator.dimensions[0] === 'lng' && coordSysCreator.dimensions[1] === 'lat';
+    }
+  };
+  HeatmapSeriesModel.type = 'series.heatmap';
+  HeatmapSeriesModel.dependencies = ['grid', 'geo', 'calendar', 'matrix'];
+  HeatmapSeriesModel.defaultOption = {
+    coordinateSystem: 'cartesian2d',
+    // zlevel: 0,
+    z: 2,
+    // Cartesian coordinate system
+    // xAxisIndex: 0,
+    // yAxisIndex: 0,
+    // Geo coordinate system
+    geoIndex: 0,
+    blurSize: 30,
+    pointSize: 20,
+    maxOpacity: 1,
+    minOpacity: 0,
+    select: {
+      itemStyle: {
+        borderColor: tokens.default.color.primary
+      }
+    }
+  };
+  return HeatmapSeriesModel;
+}(Series.default);
+
+exports.default = HeatmapSeriesModel;