@fmdevui/fm-dev 1.0.113 → 1.0.115

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/visualMap/VisualMapModel.js

@@ -0,0 +1,381 @@
+'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 visualDefault = require('../../visual/visualDefault.js');
+var VisualMapping = require('../../visual/VisualMapping.js');
+var visualSolution = require('../../visual/visualSolution.js');
+var model = require('../../util/model.js');
+var number = require('../../util/number.js');
+var Component = require('../../model/Component.js');
+var tokens = require('../../visual/tokens.js');
+
+var mapVisual = VisualMapping.default.mapVisual;
+var eachVisual = VisualMapping.default.eachVisual;
+var isArray = util.isArray;
+var each = util.each;
+var asc = number.asc;
+var linearMap = number.linearMap;
+var VisualMapModel = /** @class */function (_super) {
+  tslib_es6.__extends(VisualMapModel, _super);
+  function VisualMapModel() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = VisualMapModel.type;
+    _this.stateList = ['inRange', 'outOfRange'];
+    _this.replacableOptionKeys = ['inRange', 'outOfRange', 'target', 'controller', 'color'];
+    _this.layoutMode = {
+      type: 'box',
+      ignoreSize: true
+    };
+    /**
+     * [lowerBound, upperBound]
+     */
+    _this.dataBound = [-Infinity, Infinity];
+    _this.targetVisuals = {};
+    _this.controllerVisuals = {};
+    return _this;
+  }
+  VisualMapModel.prototype.init = function (option, parentModel, ecModel) {
+    this.mergeDefaultAndTheme(option, ecModel);
+  };
+  /**
+   * @protected
+   */
+  VisualMapModel.prototype.optionUpdated = function (newOption, isInit) {
+    var thisOption = this.option;
+    !isInit && visualSolution.replaceVisualOption(thisOption, newOption, this.replacableOptionKeys);
+    this.textStyleModel = this.getModel('textStyle');
+    this.resetItemSize();
+    this.completeVisualOption();
+  };
+  /**
+   * @protected
+   */
+  VisualMapModel.prototype.resetVisual = function (supplementVisualOption) {
+    var stateList = this.stateList;
+    supplementVisualOption = util.bind(supplementVisualOption, this);
+    this.controllerVisuals = visualSolution.createVisualMappings(this.option.controller, stateList, supplementVisualOption);
+    this.targetVisuals = visualSolution.createVisualMappings(this.option.target, stateList, supplementVisualOption);
+  };
+  /**
+   * @public
+   */
+  VisualMapModel.prototype.getItemSymbol = function () {
+    return null;
+  };
+  /**
+   * @return An array of series indices.
+   */
+  VisualMapModel.prototype.getTargetSeriesIndices = function () {
+    var optionSeriesId = this.option.seriesId;
+    var optionSeriesIndex = this.option.seriesIndex;
+    if (optionSeriesIndex == null && optionSeriesId == null) {
+      optionSeriesIndex = 'all';
+    }
+    var seriesModels = model.queryReferringComponents(this.ecModel, 'series', {
+      index: optionSeriesIndex,
+      id: optionSeriesId
+    }, {
+      useDefault: false,
+      enableAll: true,
+      enableNone: false
+    }).models;
+    return util.map(seriesModels, function (seriesModel) {
+      return seriesModel.componentIndex;
+    });
+  };
+  /**
+   * @public
+   */
+  VisualMapModel.prototype.eachTargetSeries = function (callback, context) {
+    util.each(this.getTargetSeriesIndices(), function (seriesIndex) {
+      var seriesModel = this.ecModel.getSeriesByIndex(seriesIndex);
+      if (seriesModel) {
+        callback.call(context, seriesModel);
+      }
+    }, this);
+  };
+  /**
+   * @pubilc
+   */
+  VisualMapModel.prototype.isTargetSeries = function (seriesModel) {
+    var is = false;
+    this.eachTargetSeries(function (model) {
+      model === seriesModel && (is = true);
+    });
+    return is;
+  };
+  /**
+   * @example
+   * this.formatValueText(someVal); // format single numeric value to text.
+   * this.formatValueText(someVal, true); // format single category value to text.
+   * this.formatValueText([min, max]); // format numeric min-max to text.
+   * this.formatValueText([this.dataBound[0], max]); // using data lower bound.
+   * this.formatValueText([min, this.dataBound[1]]); // using data upper bound.
+   *
+   * @param value Real value, or this.dataBound[0 or 1].
+   * @param isCategory Only available when value is number.
+   * @param edgeSymbols Open-close symbol when value is interval.
+   * @protected
+   */
+  VisualMapModel.prototype.formatValueText = function (value, isCategory, edgeSymbols) {
+    var option = this.option;
+    var precision = option.precision;
+    var dataBound = this.dataBound;
+    var formatter = option.formatter;
+    var isMinMax;
+    edgeSymbols = edgeSymbols || ['<', '>'];
+    if (util.isArray(value)) {
+      value = value.slice();
+      isMinMax = true;
+    }
+    var textValue = isCategory ? value // Value is string when isCategory
+    : isMinMax ? [toFixed(value[0]), toFixed(value[1])] : toFixed(value);
+    if (util.isString(formatter)) {
+      return formatter.replace('{value}', isMinMax ? textValue[0] : textValue).replace('{value2}', isMinMax ? textValue[1] : textValue);
+    } else if (util.isFunction(formatter)) {
+      return isMinMax ? formatter(value[0], value[1]) : formatter(value);
+    }
+    if (isMinMax) {
+      if (value[0] === dataBound[0]) {
+        return edgeSymbols[0] + ' ' + textValue[1];
+      } else if (value[1] === dataBound[1]) {
+        return edgeSymbols[1] + ' ' + textValue[0];
+      } else {
+        return textValue[0] + ' - ' + textValue[1];
+      }
+    } else {
+      // Format single value (includes category case).
+      return textValue;
+    }
+    function toFixed(val) {
+      return val === dataBound[0] ? 'min' : val === dataBound[1] ? 'max' : (+val).toFixed(Math.min(precision, 20));
+    }
+  };
+  /**
+   * @protected
+   */
+  VisualMapModel.prototype.resetExtent = function () {
+    var thisOption = this.option;
+    // Can not calculate data extent by data here.
+    // Because series and data may be modified in processing stage.
+    // So we do not support the feature "auto min/max".
+    var extent = asc([thisOption.min, thisOption.max]);
+    this._dataExtent = extent;
+  };
+  /**
+   * PENDING:
+   * delete this method if no outer usage.
+   *
+   * Return  Concrete dimension. If null/undefined is returned, no dimension is used.
+   */
+  // getDataDimension(data: SeriesData) {
+  //     const optDim = this.option.dimension;
+  //     if (optDim != null) {
+  //         return data.getDimension(optDim);
+  //     }
+  //     const dimNames = data.dimensions;
+  //     for (let i = dimNames.length - 1; i >= 0; i--) {
+  //         const dimName = dimNames[i];
+  //         const dimInfo = data.getDimensionInfo(dimName);
+  //         if (!dimInfo.isCalculationCoord) {
+  //             return dimName;
+  //         }
+  //     }
+  // }
+  VisualMapModel.prototype.getDataDimensionIndex = function (data) {
+    var optDim = this.option.dimension;
+    if (optDim != null) {
+      return data.getDimensionIndex(optDim);
+    }
+    var dimNames = data.dimensions;
+    for (var i = dimNames.length - 1; i >= 0; i--) {
+      var dimName = dimNames[i];
+      var dimInfo = data.getDimensionInfo(dimName);
+      if (!dimInfo.isCalculationCoord) {
+        return dimInfo.storeDimIndex;
+      }
+    }
+  };
+  VisualMapModel.prototype.getExtent = function () {
+    return this._dataExtent.slice();
+  };
+  VisualMapModel.prototype.completeVisualOption = function () {
+    var ecModel = this.ecModel;
+    var thisOption = this.option;
+    var base = {
+      inRange: thisOption.inRange,
+      outOfRange: thisOption.outOfRange
+    };
+    var target = thisOption.target || (thisOption.target = {});
+    var controller = thisOption.controller || (thisOption.controller = {});
+    util.merge(target, base); // Do not override
+    util.merge(controller, base); // Do not override
+    var isCategory = this.isCategory();
+    completeSingle.call(this, target);
+    completeSingle.call(this, controller);
+    completeInactive.call(this, target, 'inRange', 'outOfRange');
+    // completeInactive.call(this, target, 'outOfRange', 'inRange');
+    completeController.call(this, controller);
+    function completeSingle(base) {
+      // Compatible with ec2 dataRange.color.
+      // The mapping order of dataRange.color is: [high value, ..., low value]
+      // whereas inRange.color and outOfRange.color is [low value, ..., high value]
+      // Notice: ec2 has no inverse.
+      if (isArray(thisOption.color)
+      // If there has been inRange: {symbol: ...}, adding color is a mistake.
+      // So adding color only when no inRange defined.
+      && !base.inRange) {
+        base.inRange = {
+          color: thisOption.color.slice().reverse()
+        };
+      }
+      // Compatible with previous logic, always give a default color, otherwise
+      // simple config with no inRange and outOfRange will not work.
+      // Originally we use visualMap.color as the default color, but setOption at
+      // the second time the default color will be erased. So we change to use
+      // constant DEFAULT_COLOR.
+      // If user do not want the default color, set inRange: {color: null}.
+      base.inRange = base.inRange || {
+        color: ecModel.get('gradientColor')
+      };
+    }
+    function completeInactive(base, stateExist, stateAbsent) {
+      var optExist = base[stateExist];
+      var optAbsent = base[stateAbsent];
+      if (optExist && !optAbsent) {
+        optAbsent = base[stateAbsent] = {};
+        each(optExist, function (visualData, visualType) {
+          if (!VisualMapping.default.isValidType(visualType)) {
+            return;
+          }
+          var defa = visualDefault.default.get(visualType, 'inactive', isCategory);
+          if (defa != null) {
+            optAbsent[visualType] = defa;
+            // Compatibable with ec2:
+            // Only inactive color to rgba(0,0,0,0) can not
+            // make label transparent, so use opacity also.
+            if (visualType === 'color' && !optAbsent.hasOwnProperty('opacity') && !optAbsent.hasOwnProperty('colorAlpha')) {
+              optAbsent.opacity = [0, 0];
+            }
+          }
+        });
+      }
+    }
+    function completeController(controller) {
+      var symbolExists = (controller.inRange || {}).symbol || (controller.outOfRange || {}).symbol;
+      var symbolSizeExists = (controller.inRange || {}).symbolSize || (controller.outOfRange || {}).symbolSize;
+      var inactiveColor = this.get('inactiveColor');
+      var itemSymbol = this.getItemSymbol();
+      var defaultSymbol = itemSymbol || 'roundRect';
+      each(this.stateList, function (state) {
+        var itemSize = this.itemSize;
+        var visuals = controller[state];
+        // Set inactive color for controller if no other color
+        // attr (like colorAlpha) specified.
+        if (!visuals) {
+          visuals = controller[state] = {
+            color: isCategory ? inactiveColor : [inactiveColor]
+          };
+        }
+        // Consistent symbol and symbolSize if not specified.
+        if (visuals.symbol == null) {
+          visuals.symbol = symbolExists && util.clone(symbolExists) || (isCategory ? defaultSymbol : [defaultSymbol]);
+        }
+        if (visuals.symbolSize == null) {
+          visuals.symbolSize = symbolSizeExists && util.clone(symbolSizeExists) || (isCategory ? itemSize[0] : [itemSize[0], itemSize[0]]);
+        }
+        // Filter none
+        visuals.symbol = mapVisual(visuals.symbol, function (symbol) {
+          return symbol === 'none' ? defaultSymbol : symbol;
+        });
+        // Normalize symbolSize
+        var symbolSize = visuals.symbolSize;
+        if (symbolSize != null) {
+          var max_1 = -Infinity;
+          // symbolSize can be object when categories defined.
+          eachVisual(symbolSize, function (value) {
+            value > max_1 && (max_1 = value);
+          });
+          visuals.symbolSize = mapVisual(symbolSize, function (value) {
+            return linearMap(value, [0, max_1], [0, itemSize[0]], true);
+          });
+        }
+      }, this);
+    }
+  };
+  VisualMapModel.prototype.resetItemSize = function () {
+    this.itemSize = [parseFloat(this.get('itemWidth')), parseFloat(this.get('itemHeight'))];
+  };
+  VisualMapModel.prototype.isCategory = function () {
+    return !!this.option.categories;
+  };
+  /**
+   * @public
+   * @abstract
+   */
+  VisualMapModel.prototype.setSelected = function (selected) {};
+  VisualMapModel.prototype.getSelected = function () {
+    return null;
+  };
+  /**
+   * @public
+   * @abstract
+   */
+  VisualMapModel.prototype.getValueState = function (value) {
+    return null;
+  };
+  /**
+   * FIXME
+   * Do not publish to thirt-part-dev temporarily
+   * util the interface is stable. (Should it return
+   * a function but not visual meta?)
+   *
+   * @pubilc
+   * @abstract
+   * @param getColorVisual
+   *        params: value, valueState
+   *        return: color
+   * @return {Object} visualMeta
+   *        should includes {stops, outerColors}
+   *        outerColor means [colorBeyondMinValue, colorBeyondMaxValue]
+   */
+  VisualMapModel.prototype.getVisualMeta = function (getColorVisual) {
+    return null;
+  };
+  VisualMapModel.type = 'visualMap';
+  VisualMapModel.dependencies = ['series'];
+  VisualMapModel.defaultOption = {
+    show: true,
+    // zlevel: 0,
+    z: 4,
+    // seriesIndex: 'all',
+    min: 0,
+    max: 200,
+    left: 0,
+    right: null,
+    top: null,
+    bottom: 0,
+    itemWidth: null,
+    itemHeight: null,
+    inverse: false,
+    orient: 'vertical',
+    backgroundColor: tokens.default.color.transparent,
+    borderColor: tokens.default.color.borderTint,
+    contentColor: tokens.default.color.theme[0],
+    inactiveColor: tokens.default.color.disabled,
+    borderWidth: 0,
+    padding: tokens.default.size.m,
+    // 接受数组分别设定上右下左边距，同css
+    textGap: 10,
+    precision: 0,
+    textStyle: {
+      color: tokens.default.color.secondary // 值域文字颜色
+    }
+  };
+  return VisualMapModel;
+}(Component.default);
+
+exports.default = VisualMapModel;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/visualMap/VisualMapView.js

@@ -0,0 +1,116 @@
+'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');
+require('../../util/graphic.js');
+var format = require('../../util/format.js');
+var layout = require('../../util/layout.js');
+var VisualMapping = require('../../visual/VisualMapping.js');
+var Component = require('../../view/Component.js');
+var Rect = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/shape/Rect.js');
+
+var VisualMapView = /** @class */function (_super) {
+  tslib_es6.__extends(VisualMapView, _super);
+  function VisualMapView() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = VisualMapView.type;
+    _this.autoPositionValues = {
+      left: 1,
+      right: 1,
+      top: 1,
+      bottom: 1
+    };
+    return _this;
+  }
+  VisualMapView.prototype.init = function (ecModel, api) {
+    this.ecModel = ecModel;
+    this.api = api;
+  };
+  /**
+   * @protected
+   */
+  VisualMapView.prototype.render = function (visualMapModel, ecModel, api, payload // TODO: TYPE
+  ) {
+    this.visualMapModel = visualMapModel;
+    if (visualMapModel.get('show') === false) {
+      this.group.removeAll();
+      return;
+    }
+    this.doRender(visualMapModel, ecModel, api, payload);
+  };
+  /**
+   * @protected
+   */
+  VisualMapView.prototype.renderBackground = function (group) {
+    var visualMapModel = this.visualMapModel;
+    var padding = format.normalizeCssArray(visualMapModel.get('padding') || 0);
+    var rect = group.getBoundingRect();
+    group.add(new Rect.default({
+      z2: -1,
+      silent: true,
+      shape: {
+        x: rect.x - padding[3],
+        y: rect.y - padding[0],
+        width: rect.width + padding[3] + padding[1],
+        height: rect.height + padding[0] + padding[2]
+      },
+      style: {
+        fill: visualMapModel.get('backgroundColor'),
+        stroke: visualMapModel.get('borderColor'),
+        lineWidth: visualMapModel.get('borderWidth')
+      }
+    }));
+  };
+  /**
+   * @protected
+   * @param targetValue can be Infinity or -Infinity
+   * @param visualCluster Only can be 'color' 'opacity' 'symbol' 'symbolSize'
+   * @param opts
+   * @param opts.forceState Specify state, instead of using getValueState method.
+   * @param opts.convertOpacityToAlpha For color gradient in controller widget.
+   * @return {*} Visual value.
+   */
+  VisualMapView.prototype.getControllerVisual = function (targetValue, visualCluster, opts) {
+    opts = opts || {};
+    var forceState = opts.forceState;
+    var visualMapModel = this.visualMapModel;
+    var visualObj = {};
+    // Default values.
+    if (visualCluster === 'color') {
+      var defaultColor = visualMapModel.get('contentColor');
+      visualObj.color = defaultColor;
+    }
+    function getter(key) {
+      return visualObj[key];
+    }
+    function setter(key, value) {
+      visualObj[key] = value;
+    }
+    var mappings = visualMapModel.controllerVisuals[forceState || visualMapModel.getValueState(targetValue)];
+    var visualTypes = VisualMapping.default.prepareVisualTypes(mappings);
+    util.each(visualTypes, function (type) {
+      var visualMapping = mappings[type];
+      if (opts.convertOpacityToAlpha && type === 'opacity') {
+        type = 'colorAlpha';
+        visualMapping = mappings.__alphaForOpacity;
+      }
+      if (VisualMapping.default.dependsOn(type, visualCluster)) {
+        visualMapping && visualMapping.applyVisual(targetValue, getter, setter);
+      }
+    });
+    return visualObj[visualCluster];
+  };
+  VisualMapView.prototype.positionGroup = function (group) {
+    var model = this.visualMapModel;
+    var api = this.api;
+    var refContainer = layout.createBoxLayoutReference(model, api).refContainer;
+    layout.positionElement(group, model.getBoxLayoutParams(), refContainer);
+  };
+  VisualMapView.prototype.doRender = function (visualMapModel, ecModel, api, payload) {};
+  VisualMapView.type = 'visualMap';
+  return VisualMapView;
+}(Component.default);
+
+exports.default = VisualMapView;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/visualMap/helper.js

@@ -0,0 +1,53 @@
+'use strict';
+
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var layout = require('../../util/layout.js');
+
+var paramsSet = [['left', 'right', 'width'], ['top', 'bottom', 'height']];
+/**
+ * @param visualMapModel
+ * @param api
+ * @param itemSize always [short, long]
+ * @return {string} 'left' or 'right' or 'top' or 'bottom'
+ */
+function getItemAlign(visualMapModel, api, itemSize) {
+  var modelOption = visualMapModel.option;
+  var itemAlign = modelOption.align;
+  if (itemAlign != null && itemAlign !== 'auto') {
+    return itemAlign;
+  }
+  // Auto decision align.
+  var ecSize = {
+    width: api.getWidth(),
+    height: api.getHeight()
+  };
+  var realIndex = modelOption.orient === 'horizontal' ? 1 : 0;
+  var reals = paramsSet[realIndex];
+  var fakeValue = [0, null, 10];
+  var layoutInput = {};
+  for (var i = 0; i < 3; i++) {
+    layoutInput[paramsSet[1 - realIndex][i]] = fakeValue[i];
+    layoutInput[reals[i]] = i === 2 ? itemSize[0] : modelOption[reals[i]];
+  }
+  var rParam = [['x', 'width', 3], ['y', 'height', 0]][realIndex];
+  var rect = layout.getLayoutRect(layoutInput, ecSize, modelOption.padding);
+  return reals[(rect.margin[rParam[2]] || 0) + rect[rParam[0]] + rect[rParam[1]] * 0.5 < ecSize[rParam[1]] * 0.5 ? 0 : 1];
+}
+/**
+ * Prepare dataIndex for outside usage, where dataIndex means rawIndex, and
+ * dataIndexInside means filtered index.
+ */
+// TODO: TYPE more specified payload types.
+function makeHighDownBatch(batch, visualMapModel) {
+  util.each(batch || [], function (batchItem) {
+    if (batchItem.dataIndex != null) {
+      batchItem.dataIndexInside = batchItem.dataIndex;
+      batchItem.dataIndex = null;
+    }
+    batchItem.highlightKey = 'visualMap' + (visualMapModel ? visualMapModel.componentIndex : '');
+  });
+  return batch;
+}
+
+exports.getItemAlign = getItemAlign;
+exports.makeHighDownBatch = makeHighDownBatch;

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

@@ -0,0 +1,14 @@
+'use strict';
+
+var extension = require('../../extension.js');
+var installVisualMapContinuous = require('./installVisualMapContinuous.js');
+var installVisualMapPiecewise = require('./installVisualMapPiecewise.js');
+
+function install(registers) {
+  extension.use(installVisualMapContinuous.install);
+  extension.use(installVisualMapPiecewise.install);
+  // Do not install './dataZoomSelect',
+  // since it only work for toolbox dataZoom.
+}
+
+exports.install = install;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/visualMap/installCommon.js

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var visualMapAction = require('./visualMapAction.js');
+var visualEncoding = require('./visualEncoding.js');
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var preprocessor = require('./preprocessor.js');
+
+var installed = false;
+function installCommon(registers) {
+  if (installed) {
+    return;
+  }
+  installed = true;
+  registers.registerSubTypeDefaulter('visualMap', function (option) {
+    // Compatible with ec2, when splitNumber === 0, continuous visualMap will be used.
+    return !option.categories && (!(option.pieces ? option.pieces.length > 0 : option.splitNumber > 0) || option.calculable) ? 'continuous' : 'piecewise';
+  });
+  registers.registerAction(visualMapAction.visualMapActionInfo, visualMapAction.visualMapActionHander);
+  util.each(visualEncoding.visualMapEncodingHandlers, function (handler) {
+    registers.registerVisual(registers.PRIORITY.VISUAL.COMPONENT, handler);
+  });
+  registers.registerPreprocessor(preprocessor.default);
+}
+
+exports.default = installCommon;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/visualMap/installVisualMapContinuous.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var ContinuousModel = require('./ContinuousModel.js');
+var ContinuousView = require('./ContinuousView.js');
+var installCommon = require('./installCommon.js');
+
+function install(registers) {
+  registers.registerComponentModel(ContinuousModel.default);
+  registers.registerComponentView(ContinuousView.default);
+  installCommon.default(registers);
+}
+
+exports.install = install;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/visualMap/installVisualMapPiecewise.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var PiecewiseModel = require('./PiecewiseModel.js');
+var PiecewiseView = require('./PiecewiseView.js');
+var installCommon = require('./installCommon.js');
+
+function install(registers) {
+  registers.registerComponentModel(PiecewiseModel.default);
+  registers.registerComponentView(PiecewiseView.default);
+  installCommon.default(registers);
+}
+
+exports.install = install;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/visualMap/preprocessor.js

@@ -0,0 +1,41 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+
+var each = util.each;
+function visualMapPreprocessor(option) {
+  var visualMap = option && option.visualMap;
+  if (!util.isArray(visualMap)) {
+    visualMap = visualMap ? [visualMap] : [];
+  }
+  each(visualMap, function (opt) {
+    if (!opt) {
+      return;
+    }
+    // rename splitList to pieces
+    if (has(opt, 'splitList') && !has(opt, 'pieces')) {
+      opt.pieces = opt.splitList;
+      delete opt.splitList;
+    }
+    var pieces = opt.pieces;
+    if (pieces && util.isArray(pieces)) {
+      each(pieces, function (piece) {
+        if (util.isObject(piece)) {
+          if (has(piece, 'start') && !has(piece, 'min')) {
+            piece.min = piece.start;
+          }
+          if (has(piece, 'end') && !has(piece, 'max')) {
+            piece.max = piece.end;
+          }
+        }
+      });
+    }
+  });
+}
+function has(obj, name) {
+  return obj && obj.hasOwnProperty && obj.hasOwnProperty(name);
+}
+
+exports.default = visualMapPreprocessor;