office-viewer 0.3.11 → 0.3.13

package/esm/node_modules/echarts/lib/component/marker/MarkPointModel.js

@@ -0,0 +1,41 @@
+import { __extends } from 'tslib';
+import MarkerModel from './MarkerModel.js';
+
+var MarkPointModel = /** @class */function (_super) {
+  __extends(MarkPointModel, _super);
+  function MarkPointModel() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = MarkPointModel.type;
+    return _this;
+  }
+  MarkPointModel.prototype.createMarkerModelFromSeries = function (markerOpt, masterMarkerModel, ecModel) {
+    return new MarkPointModel(markerOpt, masterMarkerModel, ecModel);
+  };
+  MarkPointModel.type = 'markPoint';
+  MarkPointModel.defaultOption = {
+    // zlevel: 0,
+    z: 5,
+    symbol: 'pin',
+    symbolSize: 50,
+    // symbolRotate: 0,
+    // symbolOffset: [0, 0]
+    tooltip: {
+      trigger: 'item'
+    },
+    label: {
+      show: true,
+      position: 'inside'
+    },
+    itemStyle: {
+      borderWidth: 2
+    },
+    emphasis: {
+      label: {
+        show: true
+      }
+    }
+  };
+  return MarkPointModel;
+}(MarkerModel);
+
+export { MarkPointModel as default };

package/esm/node_modules/echarts/lib/component/marker/MarkPointView.js

@@ -0,0 +1,150 @@
+import { __extends } from 'tslib';
+import SymbolDraw from '../../chart/helper/SymbolDraw.js';
+import { parsePercent } from '../../util/number.js';
+import SeriesData from '../../data/SeriesData.js';
+import { dataTransform, dataFilter, createMarkerDimValueGetter } from './markerHelper.js';
+import MarkerView from './MarkerView.js';
+import MarkerModel from './MarkerModel.js';
+import { isFunction, map, extend, curry, filter } from '../../../../zrender/lib/core/util.js';
+import { getECData } from '../../util/innerStore.js';
+import { getVisualFromData } from '../../visual/helper.js';
+
+function updateMarkerLayout(mpData, seriesModel, api) {
+  var coordSys = seriesModel.coordinateSystem;
+  mpData.each(function (idx) {
+    var itemModel = mpData.getItemModel(idx);
+    var point;
+    var xPx = parsePercent(itemModel.get('x'), api.getWidth());
+    var yPx = parsePercent(itemModel.get('y'), api.getHeight());
+    if (!isNaN(xPx) && !isNaN(yPx)) {
+      point = [xPx, yPx];
+    }
+    // Chart like bar may have there own marker positioning logic
+    else if (seriesModel.getMarkerPosition) {
+      // Use the getMarkerPosition
+      point = seriesModel.getMarkerPosition(mpData.getValues(mpData.dimensions, idx));
+    } else if (coordSys) {
+      var x = mpData.get(coordSys.dimensions[0], idx);
+      var y = mpData.get(coordSys.dimensions[1], idx);
+      point = coordSys.dataToPoint([x, y]);
+    }
+    // Use x, y if has any
+    if (!isNaN(xPx)) {
+      point[0] = xPx;
+    }
+    if (!isNaN(yPx)) {
+      point[1] = yPx;
+    }
+    mpData.setItemLayout(idx, point);
+  });
+}
+var MarkPointView = /** @class */function (_super) {
+  __extends(MarkPointView, _super);
+  function MarkPointView() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = MarkPointView.type;
+    return _this;
+  }
+  MarkPointView.prototype.updateTransform = function (markPointModel, ecModel, api) {
+    ecModel.eachSeries(function (seriesModel) {
+      var mpModel = MarkerModel.getMarkerModelFromSeries(seriesModel, 'markPoint');
+      if (mpModel) {
+        updateMarkerLayout(mpModel.getData(), seriesModel, api);
+        this.markerGroupMap.get(seriesModel.id).updateLayout();
+      }
+    }, this);
+  };
+  MarkPointView.prototype.renderSeries = function (seriesModel, mpModel, ecModel, api) {
+    var coordSys = seriesModel.coordinateSystem;
+    var seriesId = seriesModel.id;
+    var seriesData = seriesModel.getData();
+    var symbolDrawMap = this.markerGroupMap;
+    var symbolDraw = symbolDrawMap.get(seriesId) || symbolDrawMap.set(seriesId, new SymbolDraw());
+    var mpData = createData(coordSys, seriesModel, mpModel);
+    // FIXME
+    mpModel.setData(mpData);
+    updateMarkerLayout(mpModel.getData(), seriesModel, api);
+    mpData.each(function (idx) {
+      var itemModel = mpData.getItemModel(idx);
+      var symbol = itemModel.getShallow('symbol');
+      var symbolSize = itemModel.getShallow('symbolSize');
+      var symbolRotate = itemModel.getShallow('symbolRotate');
+      var symbolOffset = itemModel.getShallow('symbolOffset');
+      var symbolKeepAspect = itemModel.getShallow('symbolKeepAspect');
+      // TODO: refactor needed: single data item should not support callback function
+      if (isFunction(symbol) || isFunction(symbolSize) || isFunction(symbolRotate) || isFunction(symbolOffset)) {
+        var rawIdx = mpModel.getRawValue(idx);
+        var dataParams = mpModel.getDataParams(idx);
+        if (isFunction(symbol)) {
+          symbol = symbol(rawIdx, dataParams);
+        }
+        if (isFunction(symbolSize)) {
+          // FIXME 这里不兼容 ECharts 2.x，2.x 貌似参数是整个数据？
+          symbolSize = symbolSize(rawIdx, dataParams);
+        }
+        if (isFunction(symbolRotate)) {
+          symbolRotate = symbolRotate(rawIdx, dataParams);
+        }
+        if (isFunction(symbolOffset)) {
+          symbolOffset = symbolOffset(rawIdx, dataParams);
+        }
+      }
+      var style = itemModel.getModel('itemStyle').getItemStyle();
+      var color = getVisualFromData(seriesData, 'color');
+      if (!style.fill) {
+        style.fill = color;
+      }
+      mpData.setItemVisual(idx, {
+        symbol: symbol,
+        symbolSize: symbolSize,
+        symbolRotate: symbolRotate,
+        symbolOffset: symbolOffset,
+        symbolKeepAspect: symbolKeepAspect,
+        style: style
+      });
+    });
+    // TODO Text are wrong
+    symbolDraw.updateData(mpData);
+    this.group.add(symbolDraw.group);
+    // Set host model for tooltip
+    // FIXME
+    mpData.eachItemGraphicEl(function (el) {
+      el.traverse(function (child) {
+        getECData(child).dataModel = mpModel;
+      });
+    });
+    this.markKeep(symbolDraw);
+    symbolDraw.group.silent = mpModel.get('silent') || seriesModel.get('silent');
+  };
+  MarkPointView.type = 'markPoint';
+  return MarkPointView;
+}(MarkerView);
+function createData(coordSys, seriesModel, mpModel) {
+  var coordDimsInfos;
+  if (coordSys) {
+    coordDimsInfos = map(coordSys && coordSys.dimensions, function (coordDim) {
+      var info = seriesModel.getData().getDimensionInfo(seriesModel.getData().mapDimension(coordDim)) || {};
+      // In map series data don't have lng and lat dimension. Fallback to same with coordSys
+      return extend(extend({}, info), {
+        name: coordDim,
+        // DON'T use ordinalMeta to parse and collect ordinal.
+        ordinalMeta: null
+      });
+    });
+  } else {
+    coordDimsInfos = [{
+      name: 'value',
+      type: 'float'
+    }];
+  }
+  var mpData = new SeriesData(coordDimsInfos, mpModel);
+  var dataOpt = map(mpModel.get('data'), curry(dataTransform, seriesModel));
+  if (coordSys) {
+    dataOpt = filter(dataOpt, curry(dataFilter, coordSys));
+  }
+  var dimValueGetter = createMarkerDimValueGetter(!!coordSys, coordDimsInfos);
+  mpData.initData(dataOpt, null, dimValueGetter);
+  return mpData;
+}
+
+export { MarkPointView as default };

package/esm/node_modules/echarts/lib/component/marker/MarkerModel.js

@@ -0,0 +1,125 @@
+import { __extends } from 'tslib';
+import { each, extend, mixin } from '../../../../zrender/lib/core/util.js';
+import env from '../../../../zrender/lib/core/env.js';
+import { DataFormatMixin } from '../../model/mixin/dataFormat.js';
+import ComponentModel from '../../model/Component.js';
+import { defaultEmphasis, makeInner } from '../../util/model.js';
+import { createTooltipMarkup } from '../tooltip/tooltipMarkup.js';
+
+function fillLabel(opt) {
+  defaultEmphasis(opt, 'label', ['show']);
+}
+// { [componentType]: MarkerModel }
+var inner = makeInner();
+var MarkerModel = /** @class */function (_super) {
+  __extends(MarkerModel, _super);
+  function MarkerModel() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = MarkerModel.type;
+    /**
+     * If marker model is created by self from series
+     */
+    _this.createdBySelf = false;
+    return _this;
+  }
+  /**
+   * @overrite
+   */
+  MarkerModel.prototype.init = function (option, parentModel, ecModel) {
+    if (process.env.NODE_ENV !== 'production') {
+      if (this.type === 'marker') {
+        throw new Error('Marker component is abstract component. Use markLine, markPoint, markArea instead.');
+      }
+    }
+    this.mergeDefaultAndTheme(option, ecModel);
+    this._mergeOption(option, ecModel, false, true);
+  };
+  MarkerModel.prototype.isAnimationEnabled = function () {
+    if (env.node) {
+      return false;
+    }
+    var hostSeries = this.__hostSeries;
+    return this.getShallow('animation') && hostSeries && hostSeries.isAnimationEnabled();
+  };
+  /**
+   * @overrite
+   */
+  MarkerModel.prototype.mergeOption = function (newOpt, ecModel) {
+    this._mergeOption(newOpt, ecModel, false, false);
+  };
+  MarkerModel.prototype._mergeOption = function (newOpt, ecModel, createdBySelf, isInit) {
+    var componentType = this.mainType;
+    if (!createdBySelf) {
+      ecModel.eachSeries(function (seriesModel) {
+        // mainType can be markPoint, markLine, markArea
+        var markerOpt = seriesModel.get(this.mainType, true);
+        var markerModel = inner(seriesModel)[componentType];
+        if (!markerOpt || !markerOpt.data) {
+          inner(seriesModel)[componentType] = null;
+          return;
+        }
+        if (!markerModel) {
+          if (isInit) {
+            // Default label emphasis `position` and `show`
+            fillLabel(markerOpt);
+          }
+          each(markerOpt.data, function (item) {
+            // FIXME Overwrite fillLabel method ?
+            if (item instanceof Array) {
+              fillLabel(item[0]);
+              fillLabel(item[1]);
+            } else {
+              fillLabel(item);
+            }
+          });
+          markerModel = this.createMarkerModelFromSeries(markerOpt, this, ecModel);
+          // markerModel = new ImplementedMarkerModel(
+          //     markerOpt, this, ecModel
+          // );
+          extend(markerModel, {
+            mainType: this.mainType,
+            // Use the same series index and name
+            seriesIndex: seriesModel.seriesIndex,
+            name: seriesModel.name,
+            createdBySelf: true
+          });
+          markerModel.__hostSeries = seriesModel;
+        } else {
+          markerModel._mergeOption(markerOpt, ecModel, true);
+        }
+        inner(seriesModel)[componentType] = markerModel;
+      }, this);
+    }
+  };
+  MarkerModel.prototype.formatTooltip = function (dataIndex, multipleSeries, dataType) {
+    var data = this.getData();
+    var value = this.getRawValue(dataIndex);
+    var itemName = data.getName(dataIndex);
+    return createTooltipMarkup('section', {
+      header: this.name,
+      blocks: [createTooltipMarkup('nameValue', {
+        name: itemName,
+        value: value,
+        noName: !itemName,
+        noValue: value == null
+      })]
+    });
+  };
+  MarkerModel.prototype.getData = function () {
+    return this._data;
+  };
+  MarkerModel.prototype.setData = function (data) {
+    this._data = data;
+  };
+  MarkerModel.getMarkerModelFromSeries = function (seriesModel,
+  // Support three types of markers. Strict check.
+  componentType) {
+    return inner(seriesModel)[componentType];
+  };
+  MarkerModel.type = 'marker';
+  MarkerModel.dependencies = ['series', 'grid', 'polar', 'geo'];
+  return MarkerModel;
+}(ComponentModel);
+mixin(MarkerModel, DataFormatMixin.prototype);
+
+export { MarkerModel as default };

package/esm/node_modules/echarts/lib/component/marker/MarkerView.js

@@ -0,0 +1,54 @@
+import { __extends } from 'tslib';
+import ComponentView from '../../view/Component.js';
+import { createHashMap, each } from '../../../../zrender/lib/core/util.js';
+import MarkerModel from './MarkerModel.js';
+import { makeInner } from '../../util/model.js';
+import { enterBlur, leaveBlur } from '../../util/states.js';
+
+var inner = makeInner();
+var MarkerView = /** @class */function (_super) {
+  __extends(MarkerView, _super);
+  function MarkerView() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = MarkerView.type;
+    return _this;
+  }
+  MarkerView.prototype.init = function () {
+    this.markerGroupMap = createHashMap();
+  };
+  MarkerView.prototype.render = function (markerModel, ecModel, api) {
+    var _this = this;
+    var markerGroupMap = this.markerGroupMap;
+    markerGroupMap.each(function (item) {
+      inner(item).keep = false;
+    });
+    ecModel.eachSeries(function (seriesModel) {
+      var markerModel = MarkerModel.getMarkerModelFromSeries(seriesModel, _this.type);
+      markerModel && _this.renderSeries(seriesModel, markerModel, ecModel, api);
+    });
+    markerGroupMap.each(function (item) {
+      !inner(item).keep && _this.group.remove(item.group);
+    });
+  };
+  MarkerView.prototype.markKeep = function (drawGroup) {
+    inner(drawGroup).keep = true;
+  };
+  MarkerView.prototype.toggleBlurSeries = function (seriesModelList, isBlur) {
+    var _this = this;
+    each(seriesModelList, function (seriesModel) {
+      var markerModel = MarkerModel.getMarkerModelFromSeries(seriesModel, _this.type);
+      if (markerModel) {
+        var data = markerModel.getData();
+        data.eachItemGraphicEl(function (el) {
+          if (el) {
+            isBlur ? enterBlur(el) : leaveBlur(el);
+          }
+        });
+      }
+    });
+  };
+  MarkerView.type = 'marker';
+  return MarkerView;
+}(ComponentView);
+
+export { MarkerView as default };

package/esm/node_modules/echarts/lib/component/marker/checkMarkerInSeries.js

@@ -0,0 +1,16 @@
+import { isArray } from '../../../../zrender/lib/core/util.js';
+
+function checkMarkerInSeries(seriesOpts, markerType) {
+  if (!seriesOpts) {
+    return false;
+  }
+  var seriesOptArr = isArray(seriesOpts) ? seriesOpts : [seriesOpts];
+  for (var idx = 0; idx < seriesOptArr.length; idx++) {
+    if (seriesOptArr[idx] && seriesOptArr[idx][markerType]) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export { checkMarkerInSeries as default };

package/esm/node_modules/echarts/lib/component/marker/installMarkArea.js

@@ -0,0 +1,16 @@
+import checkMarkerInSeries from './checkMarkerInSeries.js';
+import MarkAreaModel from './MarkAreaModel.js';
+import MarkAreaView from './MarkAreaView.js';
+
+function install(registers) {
+  registers.registerComponentModel(MarkAreaModel);
+  registers.registerComponentView(MarkAreaView);
+  registers.registerPreprocessor(function (opt) {
+    if (checkMarkerInSeries(opt.series, 'markArea')) {
+      // Make sure markArea component is enabled
+      opt.markArea = opt.markArea || {};
+    }
+  });
+}
+
+export { install };

package/esm/node_modules/echarts/lib/component/marker/installMarkLine.js

@@ -0,0 +1,16 @@
+import checkMarkerInSeries from './checkMarkerInSeries.js';
+import MarkLineModel from './MarkLineModel.js';
+import MarkLineView from './MarkLineView.js';
+
+function install(registers) {
+  registers.registerComponentModel(MarkLineModel);
+  registers.registerComponentView(MarkLineView);
+  registers.registerPreprocessor(function (opt) {
+    if (checkMarkerInSeries(opt.series, 'markLine')) {
+      // Make sure markLine component is enabled
+      opt.markLine = opt.markLine || {};
+    }
+  });
+}
+
+export { install };

package/esm/node_modules/echarts/lib/component/marker/installMarkPoint.js

@@ -0,0 +1,16 @@
+import checkMarkerInSeries from './checkMarkerInSeries.js';
+import MarkPointModel from './MarkPointModel.js';
+import MarkPointView from './MarkPointView.js';
+
+function install(registers) {
+  registers.registerComponentModel(MarkPointModel);
+  registers.registerComponentView(MarkPointView);
+  registers.registerPreprocessor(function (opt) {
+    if (checkMarkerInSeries(opt.series, 'markPoint')) {
+      // Make sure markPoint component is enabled
+      opt.markPoint = opt.markPoint || {};
+    }
+  });
+}
+
+export { install };

package/esm/node_modules/echarts/lib/component/marker/markerHelper.js

@@ -0,0 +1,148 @@
+import { getPrecision } from '../../util/number.js';
+import { isDimensionStacked } from '../../data/helper/dataStackHelper.js';
+import { curry, isArray, clone, indexOf } from '../../../../zrender/lib/core/util.js';
+import { parseDataValue } from '../../data/helper/dataValueHelper.js';
+
+function hasXOrY(item) {
+  return !(isNaN(parseFloat(item.x)) && isNaN(parseFloat(item.y)));
+}
+function hasXAndY(item) {
+  return !isNaN(parseFloat(item.x)) && !isNaN(parseFloat(item.y));
+}
+function markerTypeCalculatorWithExtent(markerType, data, otherDataDim, targetDataDim, otherCoordIndex, targetCoordIndex) {
+  var coordArr = [];
+  var stacked = isDimensionStacked(data, targetDataDim /* , otherDataDim */);
+  var calcDataDim = stacked ? data.getCalculationInfo('stackResultDimension') : targetDataDim;
+  var value = numCalculate(data, calcDataDim, markerType);
+  var dataIndex = data.indicesOfNearest(calcDataDim, value)[0];
+  coordArr[otherCoordIndex] = data.get(otherDataDim, dataIndex);
+  coordArr[targetCoordIndex] = data.get(calcDataDim, dataIndex);
+  var coordArrValue = data.get(targetDataDim, dataIndex);
+  // Make it simple, do not visit all stacked value to count precision.
+  var precision = getPrecision(data.get(targetDataDim, dataIndex));
+  precision = Math.min(precision, 20);
+  if (precision >= 0) {
+    coordArr[targetCoordIndex] = +coordArr[targetCoordIndex].toFixed(precision);
+  }
+  return [coordArr, coordArrValue];
+}
+// TODO Specified percent
+var markerTypeCalculator = {
+  min: curry(markerTypeCalculatorWithExtent, 'min'),
+  max: curry(markerTypeCalculatorWithExtent, 'max'),
+  average: curry(markerTypeCalculatorWithExtent, 'average'),
+  median: curry(markerTypeCalculatorWithExtent, 'median')
+};
+/**
+ * Transform markPoint data item to format used in List by do the following
+ * 1. Calculate statistic like `max`, `min`, `average`
+ * 2. Convert `item.xAxis`, `item.yAxis` to `item.coord` array
+ */
+function dataTransform(seriesModel, item) {
+  if (!item) {
+    return;
+  }
+  var data = seriesModel.getData();
+  var coordSys = seriesModel.coordinateSystem;
+  var dims = coordSys && coordSys.dimensions;
+  // 1. If not specify the position with pixel directly
+  // 2. If `coord` is not a data array. Which uses `xAxis`,
+  // `yAxis` to specify the coord on each dimension
+  // parseFloat first because item.x and item.y can be percent string like '20%'
+  if (!hasXAndY(item) && !isArray(item.coord) && isArray(dims)) {
+    var axisInfo = getAxisInfo(item, data, coordSys, seriesModel);
+    // Clone the option
+    // Transform the properties xAxis, yAxis, radiusAxis, angleAxis, geoCoord to value
+    item = clone(item);
+    if (item.type && markerTypeCalculator[item.type] && axisInfo.baseAxis && axisInfo.valueAxis) {
+      var otherCoordIndex = indexOf(dims, axisInfo.baseAxis.dim);
+      var targetCoordIndex = indexOf(dims, axisInfo.valueAxis.dim);
+      var coordInfo = markerTypeCalculator[item.type](data, axisInfo.baseDataDim, axisInfo.valueDataDim, otherCoordIndex, targetCoordIndex);
+      item.coord = coordInfo[0];
+      // Force to use the value of calculated value.
+      // let item use the value without stack.
+      item.value = coordInfo[1];
+    } else {
+      // FIXME Only has one of xAxis and yAxis.
+      item.coord = [item.xAxis != null ? item.xAxis : item.radiusAxis, item.yAxis != null ? item.yAxis : item.angleAxis];
+    }
+  }
+  // x y is provided
+  if (item.coord == null || !isArray(dims)) {
+    item.coord = [];
+  } else {
+    // Each coord support max, min, average
+    var coord = item.coord;
+    for (var i = 0; i < 2; i++) {
+      if (markerTypeCalculator[coord[i]]) {
+        coord[i] = numCalculate(data, data.mapDimension(dims[i]), coord[i]);
+      }
+    }
+  }
+  return item;
+}
+function getAxisInfo(item, data, coordSys, seriesModel) {
+  var ret = {};
+  if (item.valueIndex != null || item.valueDim != null) {
+    ret.valueDataDim = item.valueIndex != null ? data.getDimension(item.valueIndex) : item.valueDim;
+    ret.valueAxis = coordSys.getAxis(dataDimToCoordDim(seriesModel, ret.valueDataDim));
+    ret.baseAxis = coordSys.getOtherAxis(ret.valueAxis);
+    ret.baseDataDim = data.mapDimension(ret.baseAxis.dim);
+  } else {
+    ret.baseAxis = seriesModel.getBaseAxis();
+    ret.valueAxis = coordSys.getOtherAxis(ret.baseAxis);
+    ret.baseDataDim = data.mapDimension(ret.baseAxis.dim);
+    ret.valueDataDim = data.mapDimension(ret.valueAxis.dim);
+  }
+  return ret;
+}
+function dataDimToCoordDim(seriesModel, dataDim) {
+  var dimItem = seriesModel.getData().getDimensionInfo(dataDim);
+  return dimItem && dimItem.coordDim;
+}
+/**
+ * Filter data which is out of coordinateSystem range
+ * [dataFilter description]
+ */
+function dataFilter(
+// Currently only polar and cartesian has containData.
+coordSys, item) {
+  // Always return true if there is no coordSys
+  return coordSys && coordSys.containData && item.coord && !hasXOrY(item) ? coordSys.containData(item.coord) : true;
+}
+function zoneFilter(
+// Currently only polar and cartesian has containData.
+coordSys, item1, item2) {
+  // Always return true if there is no coordSys
+  return coordSys && coordSys.containZone && item1.coord && item2.coord && !hasXOrY(item1) && !hasXOrY(item2) ? coordSys.containZone(item1.coord, item2.coord) : true;
+}
+function createMarkerDimValueGetter(inCoordSys, dims) {
+  return inCoordSys ? function (item, dimName, dataIndex, dimIndex) {
+    var rawVal = dimIndex < 2
+    // x, y, radius, angle
+    ? item.coord && item.coord[dimIndex] : item.value;
+    return parseDataValue(rawVal, dims[dimIndex]);
+  } : function (item, dimName, dataIndex, dimIndex) {
+    return parseDataValue(item.value, dims[dimIndex]);
+  };
+}
+function numCalculate(data, valueDataDim, type) {
+  if (type === 'average') {
+    var sum_1 = 0;
+    var count_1 = 0;
+    data.each(valueDataDim, function (val, idx) {
+      if (!isNaN(val)) {
+        sum_1 += val;
+        count_1++;
+      }
+    });
+    return sum_1 / count_1;
+  } else if (type === 'median') {
+    return data.getMedian(valueDataDim);
+  } else {
+    // max & min
+    return data.getDataExtent(valueDataDim)[type === 'max' ? 1 : 0];
+  }
+}
+
+export { createMarkerDimValueGetter, dataFilter, dataTransform, getAxisInfo, numCalculate, zoneFilter };

package/esm/node_modules/echarts/lib/component/parallel/ParallelView.js

@@ -0,0 +1,96 @@
+import { __extends } from 'tslib';
+import ComponentView from '../../view/Component.js';
+import { each, bind, extend } from '../../../../zrender/lib/core/util.js';
+import { createOrUpdate, clear } from '../../util/throttle.js';
+
+var CLICK_THRESHOLD = 5; // > 4
+var ParallelView = /** @class */function (_super) {
+  __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 = {};
+      each(handlers, function (handler, eventName) {
+        api.getZr().on(eventName, this._handlers[eventName] = bind(handler, this));
+      }, this);
+    }
+    createOrUpdate(this, '_throttledDispatchExpand', parallelModel.get('axisExpandRate'), 'fixRate');
+  };
+  ParallelView.prototype.dispose = function (ecModel, api) {
+    clear(this, '_throttledDispatchExpand');
+    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(extend({
+      type: 'parallelAxisExpand'
+    }, opt));
+  };
+  ParallelView.type = 'parallel';
+  return ParallelView;
+}(ComponentView);
+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;
+}
+
+export { ParallelView as default };