@fmdevui/fm-dev 1.0.112 → 1.0.114

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/parallel/ParallelView.js

@@ -0,0 +1,99 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js');
+var Component = require('../../view/Component.js');
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var throttle = require('../../util/throttle.js');
+
+var CLICK_THRESHOLD = 5; // > 4
+var ParallelView = /** @class */function (_super) {
+  tslib_es6.__extends(ParallelView, _super);
+  function ParallelView() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = ParallelView.type;
+    return _this;
+  }
+  ParallelView.prototype.render = function (parallelModel, ecModel, api) {
+    this._model = parallelModel;
+    this._api = api;
+    if (!this._handlers) {
+      this._handlers = {};
+      util.each(handlers, function (handler, eventName) {
+        api.getZr().on(eventName, this._handlers[eventName] = util.bind(handler, this));
+      }, this);
+    }
+    throttle.createOrUpdate(this, '_throttledDispatchExpand', parallelModel.get('axisExpandRate'), 'fixRate');
+  };
+  ParallelView.prototype.dispose = function (ecModel, api) {
+    throttle.clear(this, '_throttledDispatchExpand');
+    util.each(this._handlers, function (handler, eventName) {
+      api.getZr().off(eventName, handler);
+    });
+    this._handlers = null;
+  };
+  /**
+   * @internal
+   * @param {Object} [opt] If null, cancel the last action triggering for debounce.
+   */
+  ParallelView.prototype._throttledDispatchExpand = function (opt) {
+    this._dispatchExpand(opt);
+  };
+  /**
+   * @internal
+   */
+  ParallelView.prototype._dispatchExpand = function (opt) {
+    opt && this._api.dispatchAction(util.extend({
+      type: 'parallelAxisExpand'
+    }, opt));
+  };
+  ParallelView.type = 'parallel';
+  return ParallelView;
+}(Component.default);
+var handlers = {
+  mousedown: function (e) {
+    if (checkTrigger(this, 'click')) {
+      this._mouseDownPoint = [e.offsetX, e.offsetY];
+    }
+  },
+  mouseup: function (e) {
+    var mouseDownPoint = this._mouseDownPoint;
+    if (checkTrigger(this, 'click') && mouseDownPoint) {
+      var point = [e.offsetX, e.offsetY];
+      var dist = Math.pow(mouseDownPoint[0] - point[0], 2) + Math.pow(mouseDownPoint[1] - point[1], 2);
+      if (dist > CLICK_THRESHOLD) {
+        return;
+      }
+      var result = this._model.coordinateSystem.getSlidedAxisExpandWindow([e.offsetX, e.offsetY]);
+      result.behavior !== 'none' && this._dispatchExpand({
+        axisExpandWindow: result.axisExpandWindow
+      });
+    }
+    this._mouseDownPoint = null;
+  },
+  mousemove: function (e) {
+    // Should do nothing when brushing.
+    if (this._mouseDownPoint || !checkTrigger(this, 'mousemove')) {
+      return;
+    }
+    var model = this._model;
+    var result = model.coordinateSystem.getSlidedAxisExpandWindow([e.offsetX, e.offsetY]);
+    var behavior = result.behavior;
+    behavior === 'jump' && this._throttledDispatchExpand.debounceNextCall(model.get('axisExpandDebounce'));
+    this._throttledDispatchExpand(behavior === 'none' ? null // Cancel the last trigger, in case that mouse slide out of the area quickly.
+    : {
+      axisExpandWindow: result.axisExpandWindow,
+      // Jumping uses animation, and sliding suppresses animation.
+      animation: behavior === 'jump' ? null : {
+        duration: 0 // Disable animation.
+      }
+    });
+  }
+};
+function checkTrigger(view, triggerOn) {
+  var model = view._model;
+  return model.get('axisExpandable') && model.get('axisExpandTriggerOn') === triggerOn;
+}
+
+exports.default = ParallelView;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/parallel/install.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var parallelPreprocessor = require('../../coord/parallel/parallelPreprocessor.js');
+var ParallelView = require('./ParallelView.js');
+var ParallelModel = require('../../coord/parallel/ParallelModel.js');
+var parallelCreator = require('../../coord/parallel/parallelCreator.js');
+var axisModelCreator = require('../../coord/axisModelCreator.js');
+var AxisModel = require('../../coord/parallel/AxisModel.js');
+var ParallelAxisView = require('../axis/ParallelAxisView.js');
+var parallelAxisAction = require('../axis/parallelAxisAction.js');
+
+var defaultAxisOption = {
+  type: 'value',
+  areaSelectStyle: {
+    width: 20,
+    borderWidth: 1,
+    borderColor: 'rgba(160,197,232)',
+    color: 'rgba(160,197,232)',
+    opacity: 0.3
+  },
+  realtime: true,
+  z: 10
+};
+function install(registers) {
+  registers.registerComponentView(ParallelView.default);
+  registers.registerComponentModel(ParallelModel.default);
+  registers.registerCoordinateSystem('parallel', parallelCreator.default);
+  registers.registerPreprocessor(parallelPreprocessor.default);
+  registers.registerComponentModel(AxisModel.default);
+  registers.registerComponentView(ParallelAxisView.default);
+  axisModelCreator.default(registers, 'parallel', AxisModel.default, defaultAxisOption);
+  parallelAxisAction.installParallelActions(registers);
+}
+
+exports.install = install;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/polar/install.js

@@ -0,0 +1,53 @@
+'use strict';
+
+var tslib_es6 = require('../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js');
+var extension = require('../../extension.js');
+var AxisView = require('../axis/AxisView.js');
+var PolarAxisPointer = require('../axisPointer/PolarAxisPointer.js');
+var install$1 = require('../axisPointer/install.js');
+var PolarModel = require('../../coord/polar/PolarModel.js');
+var axisModelCreator = require('../../coord/axisModelCreator.js');
+var AxisModel = require('../../coord/polar/AxisModel.js');
+var polarCreator = require('../../coord/polar/polarCreator.js');
+var AngleAxisView = require('../axis/AngleAxisView.js');
+var RadiusAxisView = require('../axis/RadiusAxisView.js');
+var Component = require('../../view/Component.js');
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var barPolar = require('../../layout/barPolar.js');
+
+var angleAxisExtraOption = {
+  startAngle: 90,
+  clockwise: true,
+  splitNumber: 12,
+  axisLabel: {
+    rotate: 0
+  }
+};
+var radiusAxisExtraOption = {
+  splitNumber: 5
+};
+var PolarView = /** @class */function (_super) {
+  tslib_es6.__extends(PolarView, _super);
+  function PolarView() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = PolarView.type;
+    return _this;
+  }
+  PolarView.type = 'polar';
+  return PolarView;
+}(Component.default);
+function install(registers) {
+  extension.use(install$1.install);
+  AxisView.default.registerAxisPointerClass('PolarAxisPointer', PolarAxisPointer.default);
+  registers.registerCoordinateSystem('polar', polarCreator.default);
+  registers.registerComponentModel(PolarModel.default);
+  registers.registerComponentView(PolarView);
+  // Model and view for angleAxis and radiusAxis
+  axisModelCreator.default(registers, 'angle', AxisModel.AngleAxisModel, angleAxisExtraOption);
+  axisModelCreator.default(registers, 'radius', AxisModel.RadiusAxisModel, radiusAxisExtraOption);
+  registers.registerComponentView(AngleAxisView.default);
+  registers.registerComponentView(RadiusAxisView.default);
+  registers.registerLayout(util.curry(barPolar.default, 'bar'));
+}
+
+exports.install = install;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/radar/RadarView.js

@@ -0,0 +1,169 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js');
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var AxisBuilder = require('../axis/AxisBuilder.js');
+var graphic = require('../../util/graphic.js');
+var Component = require('../../view/Component.js');
+var Circle = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/shape/Circle.js');
+var Ring = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/shape/Ring.js');
+var Polyline = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/shape/Polyline.js');
+var Polygon = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/shape/Polygon.js');
+
+var RadarView = /** @class */function (_super) {
+  tslib_es6.__extends(RadarView, _super);
+  function RadarView() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = RadarView.type;
+    return _this;
+  }
+  RadarView.prototype.render = function (radarModel, ecModel, api) {
+    var group = this.group;
+    group.removeAll();
+    this._buildAxes(radarModel, api);
+    this._buildSplitLineAndArea(radarModel);
+  };
+  RadarView.prototype._buildAxes = function (radarModel, api) {
+    var radar = radarModel.coordinateSystem;
+    var indicatorAxes = radar.getIndicatorAxes();
+    var axisBuilders = util.map(indicatorAxes, function (indicatorAxis) {
+      var axisName = indicatorAxis.model.get('showName') ? indicatorAxis.name : ''; // hide name
+      var axisBuilder = new AxisBuilder.default(indicatorAxis.model, api, {
+        axisName: axisName,
+        position: [radar.cx, radar.cy],
+        rotation: indicatorAxis.angle,
+        labelDirection: -1,
+        tickDirection: -1,
+        nameDirection: 1
+      });
+      return axisBuilder;
+    });
+    util.each(axisBuilders, function (axisBuilder) {
+      axisBuilder.build();
+      this.group.add(axisBuilder.group);
+    }, this);
+  };
+  RadarView.prototype._buildSplitLineAndArea = function (radarModel) {
+    var radar = radarModel.coordinateSystem;
+    var indicatorAxes = radar.getIndicatorAxes();
+    if (!indicatorAxes.length) {
+      return;
+    }
+    var shape = radarModel.get('shape');
+    var splitLineModel = radarModel.getModel('splitLine');
+    var splitAreaModel = radarModel.getModel('splitArea');
+    var lineStyleModel = splitLineModel.getModel('lineStyle');
+    var areaStyleModel = splitAreaModel.getModel('areaStyle');
+    var showSplitLine = splitLineModel.get('show');
+    var showSplitArea = splitAreaModel.get('show');
+    var splitLineColors = lineStyleModel.get('color');
+    var splitAreaColors = areaStyleModel.get('color');
+    var splitLineColorsArr = util.isArray(splitLineColors) ? splitLineColors : [splitLineColors];
+    var splitAreaColorsArr = util.isArray(splitAreaColors) ? splitAreaColors : [splitAreaColors];
+    var splitLines = [];
+    var splitAreas = [];
+    function getColorIndex(areaOrLine, areaOrLineColorList, idx) {
+      var colorIndex = idx % areaOrLineColorList.length;
+      areaOrLine[colorIndex] = areaOrLine[colorIndex] || [];
+      return colorIndex;
+    }
+    if (shape === 'circle') {
+      var ticksRadius = indicatorAxes[0].getTicksCoords();
+      var cx = radar.cx;
+      var cy = radar.cy;
+      for (var i = 0; i < ticksRadius.length; i++) {
+        if (showSplitLine) {
+          var colorIndex = getColorIndex(splitLines, splitLineColorsArr, i);
+          splitLines[colorIndex].push(new Circle.default({
+            shape: {
+              cx: cx,
+              cy: cy,
+              r: ticksRadius[i].coord
+            }
+          }));
+        }
+        if (showSplitArea && i < ticksRadius.length - 1) {
+          var colorIndex = getColorIndex(splitAreas, splitAreaColorsArr, i);
+          splitAreas[colorIndex].push(new Ring.default({
+            shape: {
+              cx: cx,
+              cy: cy,
+              r0: ticksRadius[i].coord,
+              r: ticksRadius[i + 1].coord
+            }
+          }));
+        }
+      }
+    }
+    // Polyyon
+    else {
+      var realSplitNumber_1;
+      var axesTicksPoints = util.map(indicatorAxes, function (indicatorAxis, idx) {
+        var ticksCoords = indicatorAxis.getTicksCoords();
+        realSplitNumber_1 = realSplitNumber_1 == null ? ticksCoords.length - 1 : Math.min(ticksCoords.length - 1, realSplitNumber_1);
+        return util.map(ticksCoords, function (tickCoord) {
+          return radar.coordToPoint(tickCoord.coord, idx);
+        });
+      });
+      var prevPoints = [];
+      for (var i = 0; i <= realSplitNumber_1; i++) {
+        var points = [];
+        for (var j = 0; j < indicatorAxes.length; j++) {
+          points.push(axesTicksPoints[j][i]);
+        }
+        // Close
+        if (points[0]) {
+          points.push(points[0].slice());
+        } else {
+          if (process.env.NODE_ENV !== 'production') {
+            console.error('Can\'t draw value axis ' + i);
+          }
+        }
+        if (showSplitLine) {
+          var colorIndex = getColorIndex(splitLines, splitLineColorsArr, i);
+          splitLines[colorIndex].push(new Polyline.default({
+            shape: {
+              points: points
+            }
+          }));
+        }
+        if (showSplitArea && prevPoints) {
+          var colorIndex = getColorIndex(splitAreas, splitAreaColorsArr, i - 1);
+          splitAreas[colorIndex].push(new Polygon.default({
+            shape: {
+              points: points.concat(prevPoints)
+            }
+          }));
+        }
+        prevPoints = points.slice().reverse();
+      }
+    }
+    var lineStyle = lineStyleModel.getLineStyle();
+    var areaStyle = areaStyleModel.getAreaStyle();
+    // Add splitArea before splitLine
+    util.each(splitAreas, function (splitAreas, idx) {
+      this.group.add(graphic.mergePath(splitAreas, {
+        style: util.defaults({
+          stroke: 'none',
+          fill: splitAreaColorsArr[idx % splitAreaColorsArr.length]
+        }, areaStyle),
+        silent: true
+      }));
+    }, this);
+    util.each(splitLines, function (splitLines, idx) {
+      this.group.add(graphic.mergePath(splitLines, {
+        style: util.defaults({
+          fill: 'none',
+          stroke: splitLineColorsArr[idx % splitLineColorsArr.length]
+        }, lineStyle),
+        silent: true
+      }));
+    }, this);
+  };
+  RadarView.type = 'radar';
+  return RadarView;
+}(Component.default);
+
+exports.default = RadarView;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/radar/install.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var RadarModel = require('../../coord/radar/RadarModel.js');
+var RadarView = require('./RadarView.js');
+var Radar = require('../../coord/radar/Radar.js');
+
+function install(registers) {
+  registers.registerCoordinateSystem('radar', Radar.default);
+  registers.registerComponentModel(RadarModel.default);
+  registers.registerComponentView(RadarView.default);
+  registers.registerVisual({
+    seriesType: 'radar',
+    reset: function (seriesModel) {
+      var data = seriesModel.getData();
+      // itemVisual symbol is for selected data
+      data.each(function (idx) {
+        data.setItemVisual(idx, 'legendIcon', 'roundRect');
+      });
+      // visual is for unselected data
+      data.setVisual('legendIcon', 'roundRect');
+    }
+  });
+}
+
+exports.install = install;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/singleAxis/install.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var tslib_es6 = require('../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js');
+var extension = require('../../extension.js');
+var Component = require('../../view/Component.js');
+var SingleAxisView = require('../axis/SingleAxisView.js');
+var axisModelCreator = require('../../coord/axisModelCreator.js');
+var AxisModel = require('../../coord/single/AxisModel.js');
+var singleCreator = require('../../coord/single/singleCreator.js');
+var install$1 = require('../axisPointer/install.js');
+var AxisView = require('../axis/AxisView.js');
+var SingleAxisPointer = require('../axisPointer/SingleAxisPointer.js');
+
+var SingleView = /** @class */function (_super) {
+  tslib_es6.__extends(SingleView, _super);
+  function SingleView() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = SingleView.type;
+    return _this;
+  }
+  SingleView.type = 'single';
+  return SingleView;
+}(Component.default);
+function install(registers) {
+  extension.use(install$1.install);
+  AxisView.default.registerAxisPointerClass('SingleAxisPointer', SingleAxisPointer.default);
+  registers.registerComponentView(SingleView);
+  // Axis
+  registers.registerComponentView(SingleAxisView.default);
+  registers.registerComponentModel(AxisModel.default);
+  axisModelCreator.default(registers, 'single', AxisModel.default, AxisModel.default.defaultOption);
+  registers.registerCoordinateSystem('single', singleCreator.default);
+}
+
+exports.install = install;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/thumbnail/ThumbnailBridgeImpl.js

@@ -0,0 +1,44 @@
+'use strict';
+
+var graphic = require('../../util/graphic.js');
+
+/**
+ * [CAVEAT]: the call order of `ThumbnailView['render']` and other
+ *  `ChartView['render']/ComponentView['render']` is not guaranteed.
+ */
+var ThumbnailBridgeImpl = /** @class */function () {
+  function ThumbnailBridgeImpl(thumbnailModel) {
+    this._thumbnailModel = thumbnailModel;
+  }
+  ThumbnailBridgeImpl.prototype.reset = function (api) {
+    this._renderVersion = api.getMainProcessVersion();
+  };
+  ThumbnailBridgeImpl.prototype.renderContent = function (opt) {
+    var thumbnailView = opt.api.getViewOfComponentModel(this._thumbnailModel);
+    if (!thumbnailView) {
+      return;
+    }
+    opt.group.silent = true;
+    thumbnailView.renderContent({
+      group: opt.group,
+      targetTrans: opt.targetTrans,
+      z2Range: graphic.calcZ2Range(opt.group),
+      roamType: opt.roamType,
+      viewportRect: opt.viewportRect,
+      renderVersion: this._renderVersion
+    });
+  };
+  ThumbnailBridgeImpl.prototype.updateWindow = function (targetTrans, api) {
+    var thumbnailView = api.getViewOfComponentModel(this._thumbnailModel);
+    if (!thumbnailView) {
+      return;
+    }
+    thumbnailView.updateWindow({
+      targetTrans: targetTrans,
+      renderVersion: this._renderVersion
+    });
+  };
+  return ThumbnailBridgeImpl;
+}();
+
+exports.ThumbnailBridgeImpl = ThumbnailBridgeImpl;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/thumbnail/ThumbnailModel.js

@@ -0,0 +1,96 @@
+'use strict';
+
+var tslib_es6 = require('../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js');
+var Component = require('../../model/Component.js');
+var log = require('../../util/log.js');
+var tokens = require('../../visual/tokens.js');
+var thumbnailBridge = require('../helper/thumbnailBridge.js');
+var ThumbnailBridgeImpl = require('./ThumbnailBridgeImpl.js');
+
+var ThumbnailModel = /** @class */function (_super) {
+  tslib_es6.__extends(ThumbnailModel, _super);
+  function ThumbnailModel() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = ThumbnailModel.type;
+    _this.preventAutoZ = true;
+    return _this;
+  }
+  ThumbnailModel.prototype.optionUpdated = function (newCptOption, isInit) {
+    this._updateBridge();
+  };
+  ThumbnailModel.prototype._updateBridge = function () {
+    var bridge = this._birdge = this._birdge || new ThumbnailBridgeImpl.ThumbnailBridgeImpl(this);
+    // Clear all, in case of option changed.
+    this._target = null;
+    this.ecModel.eachSeries(function (series) {
+      thumbnailBridge.injectThumbnailBridge(series, null);
+    });
+    if (this.shouldShow()) {
+      var target = this.getTarget();
+      // If a component is targeted by more than one thumbnails, simply only the last one works.
+      thumbnailBridge.injectThumbnailBridge(target.baseMapProvider, bridge);
+    }
+  };
+  ThumbnailModel.prototype.shouldShow = function () {
+    return this.getShallow('show', true);
+  };
+  ThumbnailModel.prototype.getBridge = function () {
+    return this._birdge;
+  };
+  ThumbnailModel.prototype.getTarget = function () {
+    if (this._target) {
+      return this._target;
+    }
+    // Find by `seriesId`/`seriesIndex`.
+    var series = this.getReferringComponents('series', {
+      useDefault: false,
+      enableAll: false,
+      enableNone: false
+    }).models[0];
+    if (series) {
+      if (series.subType !== 'graph') {
+        series = null;
+        if (process.env.NODE_ENV !== 'production') {
+          log.error("series." + series.subType + " is not supported in thumbnail.", true);
+        }
+      }
+    } else {
+      // If no xxxId and xxxIndex specified, find the first series.graph. If other components,
+      // such as geo, is supported in future, the default stretagy may be extended.
+      series = this.ecModel.queryComponents({
+        mainType: 'series',
+        subType: 'graph'
+      })[0];
+    }
+    this._target = {
+      baseMapProvider: series
+    };
+    return this._target;
+  };
+  ThumbnailModel.type = 'thumbnail';
+  ThumbnailModel.layoutMode = 'box';
+  // All the supported components should be added here.
+  ThumbnailModel.dependencies = ['series', 'geo'];
+  ThumbnailModel.defaultOption = {
+    show: true,
+    right: 1,
+    bottom: 1,
+    height: '25%',
+    width: '25%',
+    itemStyle: {
+      // Use echarts option.backgorundColor by default.
+      borderColor: tokens.default.color.border,
+      borderWidth: 2
+    },
+    windowStyle: {
+      borderWidth: 1,
+      color: tokens.default.color.neutral30,
+      borderColor: tokens.default.color.neutral40,
+      opacity: 0.3
+    },
+    z: 10
+  };
+  return ThumbnailModel;
+}(Component.default);
+
+exports.ThumbnailModel = ThumbnailModel;