@fmdevui/fm-dev 1.0.113 → 1.0.114

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/axisPointer/modelHelper.js

@@ -0,0 +1,262 @@
+'use strict';
+
+var Model = require('../../model/Model.js');
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+
+// Build axisPointerModel, mergin tooltip.axisPointer model for each axis.
+// allAxesInfo should be updated when setOption performed.
+function collect(ecModel, api) {
+  var result = {
+    /**
+     * key: makeKey(axis.model)
+     * value: {
+     *      axis,
+     *      coordSys,
+     *      axisPointerModel,
+     *      triggerTooltip,
+     *      triggerEmphasis,
+     *      involveSeries,
+     *      snap,
+     *      seriesModels,
+     *      seriesDataCount
+     * }
+     */
+    axesInfo: {},
+    seriesInvolved: false,
+    /**
+     * key: makeKey(coordSys.model)
+     * value: Object: key makeKey(axis.model), value: axisInfo
+     */
+    coordSysAxesInfo: {},
+    coordSysMap: {}
+  };
+  collectAxesInfo(result, ecModel, api);
+  // Check seriesInvolved for performance, in case too many series in some chart.
+  result.seriesInvolved && collectSeriesInfo(result, ecModel);
+  return result;
+}
+function collectAxesInfo(result, ecModel, api) {
+  var globalTooltipModel = ecModel.getComponent('tooltip');
+  var globalAxisPointerModel = ecModel.getComponent('axisPointer');
+  // links can only be set on global.
+  var linksOption = globalAxisPointerModel.get('link', true) || [];
+  var linkGroups = [];
+  // Collect axes info.
+  util.each(api.getCoordinateSystems(), function (coordSys) {
+    // Some coordinate system do not support axes, like geo.
+    if (!coordSys.axisPointerEnabled) {
+      return;
+    }
+    var coordSysKey = makeKey(coordSys.model);
+    var axesInfoInCoordSys = result.coordSysAxesInfo[coordSysKey] = {};
+    result.coordSysMap[coordSysKey] = coordSys;
+    // Set tooltip (like 'cross') is a convenient way to show axisPointer
+    // for user. So we enable setting tooltip on coordSys model.
+    var coordSysModel = coordSys.model;
+    var baseTooltipModel = coordSysModel.getModel('tooltip', globalTooltipModel);
+    util.each(coordSys.getAxes(), util.curry(saveTooltipAxisInfo, false, null));
+    // If axis tooltip used, choose tooltip axis for each coordSys.
+    // Notice this case: coordSys is `grid` but not `cartesian2D` here.
+    if (coordSys.getTooltipAxes && globalTooltipModel
+    // If tooltip.showContent is set as false, tooltip will not
+    // show but axisPointer will show as normal.
+    && baseTooltipModel.get('show')) {
+      // Compatible with previous logic. But series.tooltip.trigger: 'axis'
+      // or series.data[n].tooltip.trigger: 'axis' are not support any more.
+      var triggerAxis = baseTooltipModel.get('trigger') === 'axis';
+      var cross = baseTooltipModel.get(['axisPointer', 'type']) === 'cross';
+      var tooltipAxes = coordSys.getTooltipAxes(baseTooltipModel.get(['axisPointer', 'axis']));
+      if (triggerAxis || cross) {
+        util.each(tooltipAxes.baseAxes, util.curry(saveTooltipAxisInfo, cross ? 'cross' : true, triggerAxis));
+      }
+      if (cross) {
+        util.each(tooltipAxes.otherAxes, util.curry(saveTooltipAxisInfo, 'cross', false));
+      }
+    }
+    // fromTooltip: true | false | 'cross'
+    // triggerTooltip: true | false | null
+    function saveTooltipAxisInfo(fromTooltip, triggerTooltip, axis) {
+      var axisPointerModel = axis.model.getModel('axisPointer', globalAxisPointerModel);
+      var axisPointerShow = axisPointerModel.get('show');
+      if (!axisPointerShow || axisPointerShow === 'auto' && !fromTooltip && !isHandleTrigger(axisPointerModel)) {
+        return;
+      }
+      if (triggerTooltip == null) {
+        triggerTooltip = axisPointerModel.get('triggerTooltip');
+      }
+      axisPointerModel = fromTooltip ? makeAxisPointerModel(axis, baseTooltipModel, globalAxisPointerModel, ecModel, fromTooltip, triggerTooltip) : axisPointerModel;
+      var snap = axisPointerModel.get('snap');
+      var triggerEmphasis = axisPointerModel.get('triggerEmphasis');
+      var axisKey = makeKey(axis.model);
+      var involveSeries = triggerTooltip || snap || axis.type === 'category';
+      // If result.axesInfo[key] exist, override it (tooltip has higher priority).
+      var axisInfo = result.axesInfo[axisKey] = {
+        key: axisKey,
+        axis: axis,
+        coordSys: coordSys,
+        axisPointerModel: axisPointerModel,
+        triggerTooltip: triggerTooltip,
+        triggerEmphasis: triggerEmphasis,
+        involveSeries: involveSeries,
+        snap: snap,
+        useHandle: isHandleTrigger(axisPointerModel),
+        seriesModels: [],
+        linkGroup: null
+      };
+      axesInfoInCoordSys[axisKey] = axisInfo;
+      result.seriesInvolved = result.seriesInvolved || involveSeries;
+      var groupIndex = getLinkGroupIndex(linksOption, axis);
+      if (groupIndex != null) {
+        var linkGroup = linkGroups[groupIndex] || (linkGroups[groupIndex] = {
+          axesInfo: {}
+        });
+        linkGroup.axesInfo[axisKey] = axisInfo;
+        linkGroup.mapper = linksOption[groupIndex].mapper;
+        axisInfo.linkGroup = linkGroup;
+      }
+    }
+  });
+}
+function makeAxisPointerModel(axis, baseTooltipModel, globalAxisPointerModel, ecModel, fromTooltip, triggerTooltip) {
+  var tooltipAxisPointerModel = baseTooltipModel.getModel('axisPointer');
+  var fields = ['type', 'snap', 'lineStyle', 'shadowStyle', 'label', 'animation', 'animationDurationUpdate', 'animationEasingUpdate', 'z'];
+  var volatileOption = {};
+  util.each(fields, function (field) {
+    volatileOption[field] = util.clone(tooltipAxisPointerModel.get(field));
+  });
+  // category axis do not auto snap, otherwise some tick that do not
+  // has value can not be hovered. value/time/log axis default snap if
+  // triggered from tooltip and trigger tooltip.
+  volatileOption.snap = axis.type !== 'category' && !!triggerTooltip;
+  // Compatible with previous behavior, tooltip axis does not show label by default.
+  // Only these properties can be overridden from tooltip to axisPointer.
+  if (tooltipAxisPointerModel.get('type') === 'cross') {
+    volatileOption.type = 'line';
+  }
+  var labelOption = volatileOption.label || (volatileOption.label = {});
+  // Follow the convention, do not show label when triggered by tooltip by default.
+  labelOption.show == null && (labelOption.show = false);
+  if (fromTooltip === 'cross') {
+    // When 'cross', both axes show labels.
+    var tooltipAxisPointerLabelShow = tooltipAxisPointerModel.get(['label', 'show']);
+    labelOption.show = tooltipAxisPointerLabelShow != null ? tooltipAxisPointerLabelShow : true;
+    // If triggerTooltip, this is a base axis, which should better not use cross style
+    // (cross style is dashed by default)
+    if (!triggerTooltip) {
+      var crossStyle = volatileOption.lineStyle = tooltipAxisPointerModel.get('crossStyle');
+      crossStyle && util.defaults(labelOption, crossStyle.textStyle);
+    }
+  }
+  return axis.model.getModel('axisPointer', new Model.default(volatileOption, globalAxisPointerModel, ecModel));
+}
+function collectSeriesInfo(result, ecModel) {
+  // Prepare data for axis trigger
+  ecModel.eachSeries(function (seriesModel) {
+    // Notice this case: this coordSys is `cartesian2D` but not `grid`.
+    var coordSys = seriesModel.coordinateSystem;
+    var seriesTooltipTrigger = seriesModel.get(['tooltip', 'trigger'], true);
+    var seriesTooltipShow = seriesModel.get(['tooltip', 'show'], true);
+    if (!coordSys || !coordSys.model // PENDING: radar do not have a model.
+    || seriesTooltipTrigger === 'none' || seriesTooltipTrigger === false || seriesTooltipTrigger === 'item' || seriesTooltipShow === false || seriesModel.get(['axisPointer', 'show'], true) === false) {
+      return;
+    }
+    util.each(result.coordSysAxesInfo[makeKey(coordSys.model)], function (axisInfo) {
+      var axis = axisInfo.axis;
+      if (coordSys.getAxis(axis.dim) === axis) {
+        axisInfo.seriesModels.push(seriesModel);
+        axisInfo.seriesDataCount == null && (axisInfo.seriesDataCount = 0);
+        axisInfo.seriesDataCount += seriesModel.getData().count();
+      }
+    });
+  });
+}
+/**
+ * For example:
+ * {
+ *     axisPointer: {
+ *         links: [{
+ *             xAxisIndex: [2, 4],
+ *             yAxisIndex: 'all'
+ *         }, {
+ *             xAxisId: ['a5', 'a7'],
+ *             xAxisName: 'xxx'
+ *         }]
+ *     }
+ * }
+ */
+function getLinkGroupIndex(linksOption, axis) {
+  var axisModel = axis.model;
+  var dim = axis.dim;
+  for (var i = 0; i < linksOption.length; i++) {
+    var linkOption = linksOption[i] || {};
+    if (checkPropInLink(linkOption[dim + 'AxisId'], axisModel.id) || checkPropInLink(linkOption[dim + 'AxisIndex'], axisModel.componentIndex) || checkPropInLink(linkOption[dim + 'AxisName'], axisModel.name)) {
+      return i;
+    }
+  }
+}
+function checkPropInLink(linkPropValue, axisPropValue) {
+  return linkPropValue === 'all' || util.isArray(linkPropValue) && util.indexOf(linkPropValue, axisPropValue) >= 0 || linkPropValue === axisPropValue;
+}
+function fixValue(axisModel) {
+  var axisInfo = getAxisInfo(axisModel);
+  if (!axisInfo) {
+    return;
+  }
+  var axisPointerModel = axisInfo.axisPointerModel;
+  var scale = axisInfo.axis.scale;
+  var option = axisPointerModel.option;
+  var status = axisPointerModel.get('status');
+  var value = axisPointerModel.get('value');
+  // Parse init value for category and time axis.
+  if (value != null) {
+    value = scale.parse(value);
+  }
+  var useHandle = isHandleTrigger(axisPointerModel);
+  // If `handle` used, `axisPointer` will always be displayed, so value
+  // and status should be initialized.
+  if (status == null) {
+    option.status = useHandle ? 'show' : 'hide';
+  }
+  var extent = scale.getExtent().slice();
+  extent[0] > extent[1] && extent.reverse();
+  if (
+  // Pick a value on axis when initializing.
+  value == null
+  // If both `handle` and `dataZoom` are used, value may be out of axis extent,
+  // where we should re-pick a value to keep `handle` displaying normally.
+  || value > extent[1]) {
+    // Make handle displayed on the end of the axis when init, which looks better.
+    value = extent[1];
+  }
+  if (value < extent[0]) {
+    value = extent[0];
+  }
+  option.value = value;
+  if (useHandle) {
+    option.status = axisInfo.axis.scale.isBlank() ? 'hide' : 'show';
+  }
+}
+function getAxisInfo(axisModel) {
+  var coordSysAxesInfo = (axisModel.ecModel.getComponent('axisPointer') || {}).coordSysAxesInfo;
+  return coordSysAxesInfo && coordSysAxesInfo.axesInfo[makeKey(axisModel)];
+}
+function getAxisPointerModel(axisModel) {
+  var axisInfo = getAxisInfo(axisModel);
+  return axisInfo && axisInfo.axisPointerModel;
+}
+function isHandleTrigger(axisPointerModel) {
+  return !!axisPointerModel.get(['handle', 'show']);
+}
+/**
+ * @param {module:echarts/model/Model} model
+ * @return {string} unique key
+ */
+function makeKey(model) {
+  return model.type + '||' + model.id;
+}
+
+exports.collect = collect;
+exports.fixValue = fixValue;
+exports.getAxisInfo = getAxisInfo;
+exports.getAxisPointerModel = getAxisPointerModel;
+exports.makeKey = makeKey;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/axisPointer/viewHelper.js

@@ -0,0 +1,163 @@
+'use strict';
+
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var graphic = require('../../util/graphic.js');
+var text = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/contain/text.js');
+var format = require('../../util/format.js');
+var matrix = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/matrix.js');
+var axisHelper = require('../../coord/axisHelper.js');
+var AxisBuilder = require('../axis/AxisBuilder.js');
+var labelStyle = require('../../label/labelStyle.js');
+
+function buildElStyle(axisPointerModel) {
+  var axisPointerType = axisPointerModel.get('type');
+  var styleModel = axisPointerModel.getModel(axisPointerType + 'Style');
+  var style;
+  if (axisPointerType === 'line') {
+    style = styleModel.getLineStyle();
+    style.fill = null;
+  } else if (axisPointerType === 'shadow') {
+    style = styleModel.getAreaStyle();
+    style.stroke = null;
+  }
+  return style;
+}
+/**
+ * @param {Function} labelPos {align, verticalAlign, position}
+ */
+function buildLabelElOption(elOption, axisModel, axisPointerModel, api, labelPos) {
+  var value = axisPointerModel.get('value');
+  var text$1 = getValueLabel(value, axisModel.axis, axisModel.ecModel, axisPointerModel.get('seriesDataIndices'), {
+    precision: axisPointerModel.get(['label', 'precision']),
+    formatter: axisPointerModel.get(['label', 'formatter'])
+  });
+  var labelModel = axisPointerModel.getModel('label');
+  var paddings = format.normalizeCssArray(labelModel.get('padding') || 0);
+  var font = labelModel.getFont();
+  var textRect = text.getBoundingRect(text$1, font);
+  var position = labelPos.position;
+  var width = textRect.width + paddings[1] + paddings[3];
+  var height = textRect.height + paddings[0] + paddings[2];
+  // Adjust by align.
+  var align = labelPos.align;
+  align === 'right' && (position[0] -= width);
+  align === 'center' && (position[0] -= width / 2);
+  var verticalAlign = labelPos.verticalAlign;
+  verticalAlign === 'bottom' && (position[1] -= height);
+  verticalAlign === 'middle' && (position[1] -= height / 2);
+  // Not overflow ec container
+  confineInContainer(position, width, height, api);
+  var bgColor = labelModel.get('backgroundColor');
+  if (!bgColor || bgColor === 'auto') {
+    bgColor = axisModel.get(['axisLine', 'lineStyle', 'color']);
+  }
+  elOption.label = {
+    // shape: {x: 0, y: 0, width: width, height: height, r: labelModel.get('borderRadius')},
+    x: position[0],
+    y: position[1],
+    style: labelStyle.createTextStyle(labelModel, {
+      text: text$1,
+      font: font,
+      fill: labelModel.getTextColor(),
+      padding: paddings,
+      backgroundColor: bgColor
+    }),
+    // Label should be over axisPointer.
+    z2: 10
+  };
+}
+// Do not overflow ec container
+function confineInContainer(position, width, height, api) {
+  var viewWidth = api.getWidth();
+  var viewHeight = api.getHeight();
+  position[0] = Math.min(position[0] + width, viewWidth) - width;
+  position[1] = Math.min(position[1] + height, viewHeight) - height;
+  position[0] = Math.max(position[0], 0);
+  position[1] = Math.max(position[1], 0);
+}
+function getValueLabel(value, axis, ecModel, seriesDataIndices, opt) {
+  value = axis.scale.parse(value);
+  var text = axis.scale.getLabel({
+    value: value
+  }, {
+    // If `precision` is set, width can be fixed (like '12.00500'), which
+    // helps to debounce when when moving label.
+    precision: opt.precision
+  });
+  var formatter = opt.formatter;
+  if (formatter) {
+    var params_1 = {
+      value: axisHelper.getAxisRawValue(axis, {
+        value: value
+      }),
+      axisDimension: axis.dim,
+      axisIndex: axis.index,
+      seriesData: []
+    };
+    util.each(seriesDataIndices, function (idxItem) {
+      var series = ecModel.getSeriesByIndex(idxItem.seriesIndex);
+      var dataIndex = idxItem.dataIndexInside;
+      var dataParams = series && series.getDataParams(dataIndex);
+      dataParams && params_1.seriesData.push(dataParams);
+    });
+    if (util.isString(formatter)) {
+      text = formatter.replace('{value}', text);
+    } else if (util.isFunction(formatter)) {
+      text = formatter(params_1);
+    }
+  }
+  return text;
+}
+function getTransformedPosition(axis, value, layoutInfo) {
+  var transform = matrix.create();
+  matrix.rotate(transform, transform, layoutInfo.rotation);
+  matrix.translate(transform, transform, layoutInfo.position);
+  return graphic.applyTransform([axis.dataToCoord(value), (layoutInfo.labelOffset || 0) + (layoutInfo.labelDirection || 1) * (layoutInfo.labelMargin || 0)], transform);
+}
+function buildCartesianSingleLabelElOption(value, elOption, layoutInfo, axisModel, axisPointerModel, api) {
+  var textLayout = AxisBuilder.default.innerTextLayout(layoutInfo.rotation, 0, layoutInfo.labelDirection);
+  layoutInfo.labelMargin = axisPointerModel.get(['label', 'margin']);
+  buildLabelElOption(elOption, axisModel, axisPointerModel, api, {
+    position: getTransformedPosition(axisModel.axis, value, layoutInfo),
+    align: textLayout.textAlign,
+    verticalAlign: textLayout.textVerticalAlign
+  });
+}
+function makeLineShape(p1, p2, xDimIndex) {
+  xDimIndex = xDimIndex || 0;
+  return {
+    x1: p1[xDimIndex],
+    y1: p1[1 - xDimIndex],
+    x2: p2[xDimIndex],
+    y2: p2[1 - xDimIndex]
+  };
+}
+function makeRectShape(xy, wh, xDimIndex) {
+  xDimIndex = xDimIndex || 0;
+  return {
+    x: xy[xDimIndex],
+    y: xy[1 - xDimIndex],
+    width: wh[xDimIndex],
+    height: wh[1 - xDimIndex]
+  };
+}
+function makeSectorShape(cx, cy, r0, r, startAngle, endAngle) {
+  return {
+    cx: cx,
+    cy: cy,
+    r0: r0,
+    r: r,
+    startAngle: startAngle,
+    endAngle: endAngle,
+    clockwise: true
+  };
+}
+
+exports.buildCartesianSingleLabelElOption = buildCartesianSingleLabelElOption;
+exports.buildElStyle = buildElStyle;
+exports.buildLabelElOption = buildLabelElOption;
+exports.getTransformedPosition = getTransformedPosition;
+exports.getValueLabel = getValueLabel;
+exports.makeLineShape = makeLineShape;
+exports.makeRectShape = makeRectShape;
+exports.makeSectorShape = makeSectorShape;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/brush/BrushModel.js

@@ -0,0 +1,100 @@
+'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 visualSolution = require('../../visual/visualSolution.js');
+var Model = require('../../model/Model.js');
+var Component = require('../../model/Component.js');
+var tokens = require('../../visual/tokens.js');
+
+var BrushModel = /** @class */function (_super) {
+  tslib_es6.__extends(BrushModel, _super);
+  function BrushModel() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = BrushModel.type;
+    /**
+     * @readOnly
+     */
+    _this.areas = [];
+    /**
+     * Current brush painting area settings.
+     * @readOnly
+     */
+    _this.brushOption = {};
+    return _this;
+  }
+  BrushModel.prototype.optionUpdated = function (newOption, isInit) {
+    var thisOption = this.option;
+    !isInit && visualSolution.replaceVisualOption(thisOption, newOption, ['inBrush', 'outOfBrush']);
+    var inBrush = thisOption.inBrush = thisOption.inBrush || {};
+    // Always give default visual, consider setOption at the second time.
+    thisOption.outOfBrush = thisOption.outOfBrush || {
+      color: this.option.defaultOutOfBrushColor
+    };
+    if (!inBrush.hasOwnProperty('liftZ')) {
+      // Bigger than the highlight z lift, otherwise it will
+      // be effected by the highlight z when brush.
+      inBrush.liftZ = 5;
+    }
+  };
+  /**
+   * If `areas` is null/undefined, range state remain.
+   */
+  BrushModel.prototype.setAreas = function (areas) {
+    if (process.env.NODE_ENV !== 'production') {
+      util.assert(util.isArray(areas));
+      util.each(areas, function (area) {
+        util.assert(area.brushType, 'Illegal areas');
+      });
+    }
+    // If areas is null/undefined, range state remain.
+    // This helps user to dispatchAction({type: 'brush'}) with no areas
+    // set but just want to get the current brush select info from a `brush` event.
+    if (!areas) {
+      return;
+    }
+    this.areas = util.map(areas, function (area) {
+      return generateBrushOption(this.option, area);
+    }, this);
+  };
+  /**
+   * Set the current painting brush option.
+   */
+  BrushModel.prototype.setBrushOption = function (brushOption) {
+    this.brushOption = generateBrushOption(this.option, brushOption);
+    this.brushType = this.brushOption.brushType;
+  };
+  BrushModel.type = 'brush';
+  BrushModel.dependencies = ['geo', 'grid', 'xAxis', 'yAxis', 'parallel', 'series'];
+  BrushModel.defaultOption = {
+    seriesIndex: 'all',
+    brushType: 'rect',
+    brushMode: 'single',
+    transformable: true,
+    brushStyle: {
+      borderWidth: 1,
+      color: tokens.default.color.backgroundTint,
+      borderColor: tokens.default.color.borderTint
+    },
+    throttleType: 'fixRate',
+    throttleDelay: 0,
+    removeOnClick: true,
+    z: 10000,
+    defaultOutOfBrushColor: tokens.default.color.disabled
+  };
+  return BrushModel;
+}(Component.default);
+function generateBrushOption(option, brushOption) {
+  return util.merge({
+    brushType: option.brushType,
+    brushMode: option.brushMode,
+    transformable: option.transformable,
+    brushStyle: new Model.default(option.brushStyle).getItemStyle(),
+    removeOnClick: option.removeOnClick,
+    z: option.z
+  }, brushOption, true);
+}
+
+exports.default = BrushModel;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/brush/BrushView.js

@@ -0,0 +1,74 @@
+'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 BrushController = require('../helper/BrushController.js');
+var visualEncoding = require('./visualEncoding.js');
+var Component = require('../../view/Component.js');
+
+var BrushView = /** @class */function (_super) {
+  tslib_es6.__extends(BrushView, _super);
+  function BrushView() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = BrushView.type;
+    return _this;
+  }
+  BrushView.prototype.init = function (ecModel, api) {
+    this.ecModel = ecModel;
+    this.api = api;
+    this.model;
+    (this._brushController = new BrushController.default(api.getZr())).on('brush', util.bind(this._onBrush, this)).mount();
+  };
+  BrushView.prototype.render = function (brushModel, ecModel, api, payload) {
+    this.model = brushModel;
+    this._updateController(brushModel, ecModel, api, payload);
+  };
+  BrushView.prototype.updateTransform = function (brushModel, ecModel, api, payload) {
+    // PENDING: `updateTransform` is a little tricky, whose layout need
+    // to be calculate mandatorily and other stages will not be performed.
+    // Take care the correctness of the logic. See #11754 .
+    visualEncoding.layoutCovers(ecModel);
+    this._updateController(brushModel, ecModel, api, payload);
+  };
+  BrushView.prototype.updateVisual = function (brushModel, ecModel, api, payload) {
+    this.updateTransform(brushModel, ecModel, api, payload);
+  };
+  BrushView.prototype.updateView = function (brushModel, ecModel, api, payload) {
+    this._updateController(brushModel, ecModel, api, payload);
+  };
+  BrushView.prototype._updateController = function (brushModel, ecModel, api, payload) {
+    // Do not update controller when drawing.
+    (!payload || payload.$from !== brushModel.id) && this._brushController.setPanels(brushModel.brushTargetManager.makePanelOpts(api)).enableBrush(brushModel.brushOption).updateCovers(brushModel.areas.slice());
+  };
+  // updateLayout: updateController,
+  // updateVisual: updateController,
+  BrushView.prototype.dispose = function () {
+    this._brushController.dispose();
+  };
+  BrushView.prototype._onBrush = function (eventParam) {
+    var modelId = this.model.id;
+    var areas = this.model.brushTargetManager.setOutputRanges(eventParam.areas, this.ecModel);
+    // Action is not dispatched on drag end, because the drag end
+    // emits the same params with the last drag move event, and
+    // may have some delay when using touch pad, which makes
+    // animation not smooth (when using debounce).
+    (!eventParam.isEnd || eventParam.removeOnClick) && this.api.dispatchAction({
+      type: 'brush',
+      brushId: modelId,
+      areas: util.clone(areas),
+      $from: modelId
+    });
+    eventParam.isEnd && this.api.dispatchAction({
+      type: 'brushEnd',
+      brushId: modelId,
+      areas: util.clone(areas),
+      $from: modelId
+    });
+  };
+  BrushView.type = 'brush';
+  return BrushView;
+}(Component.default);
+
+exports.default = BrushView;

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

@@ -0,0 +1,62 @@
+'use strict';
+
+var preprocessor = require('./preprocessor.js');
+var BrushView = require('./BrushView.js');
+var BrushModel = require('./BrushModel.js');
+var visualEncoding = require('./visualEncoding.js');
+var Brush = require('../toolbox/feature/Brush.js');
+var featureManager = require('../toolbox/featureManager.js');
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+
+function install(registers) {
+  registers.registerComponentView(BrushView.default);
+  registers.registerComponentModel(BrushModel.default);
+  registers.registerPreprocessor(preprocessor.default);
+  registers.registerVisual(registers.PRIORITY.VISUAL.BRUSH, visualEncoding.default);
+  registers.registerAction({
+    type: 'brush',
+    event: 'brush',
+    update: 'updateVisual'
+  }, function (payload, ecModel) {
+    ecModel.eachComponent({
+      mainType: 'brush',
+      query: payload
+    }, function (brushModel) {
+      brushModel.setAreas(payload.areas);
+    });
+  });
+  /**
+   * payload: {
+   *      brushComponents: [
+   *          {
+   *              brushId,
+   *              brushIndex,
+   *              brushName,
+   *              series: [
+   *                  {
+   *                      seriesId,
+   *                      seriesIndex,
+   *                      seriesName,
+   *                      rawIndices: [21, 34, ...]
+   *                  },
+   *                  ...
+   *              ]
+   *          },
+   *          ...
+   *      ]
+   * }
+   */
+  registers.registerAction({
+    type: 'brushSelect',
+    event: 'brushSelected',
+    update: 'none'
+  }, util.noop);
+  registers.registerAction({
+    type: 'brushEnd',
+    event: 'brushEnd',
+    update: 'none'
+  }, util.noop);
+  featureManager.registerFeature('brush', Brush.default);
+}
+
+exports.install = install;