office-viewer 0.3.11 → 0.3.13

package/esm/node_modules/echarts/lib/coord/scaleRawExtentInfo.js

@@ -0,0 +1,199 @@
+import { isFunction, isArray, assert, eqNaN } from '../../../zrender/lib/core/util.js';
+import { parsePercent } from '../../../zrender/lib/contain/text.js';
+
+var ScaleRawExtentInfo = /** @class */function () {
+  function ScaleRawExtentInfo(scale, model,
+  // Usually: data extent from all series on this axis.
+  originalExtent) {
+    this._prepareParams(scale, model, originalExtent);
+  }
+  /**
+   * Parameters depending on outside (like model, user callback)
+   * are prepared and fixed here.
+   */
+  ScaleRawExtentInfo.prototype._prepareParams = function (scale, model,
+  // Usually: data extent from all series on this axis.
+  dataExtent) {
+    if (dataExtent[1] < dataExtent[0]) {
+      dataExtent = [NaN, NaN];
+    }
+    this._dataMin = dataExtent[0];
+    this._dataMax = dataExtent[1];
+    var isOrdinal = this._isOrdinal = scale.type === 'ordinal';
+    this._needCrossZero = scale.type === 'interval' && model.getNeedCrossZero && model.getNeedCrossZero();
+    var modelMinRaw = this._modelMinRaw = model.get('min', true);
+    if (isFunction(modelMinRaw)) {
+      // This callback always provides users the full data extent (before data is filtered).
+      this._modelMinNum = parseAxisModelMinMax(scale, modelMinRaw({
+        min: dataExtent[0],
+        max: dataExtent[1]
+      }));
+    } else if (modelMinRaw !== 'dataMin') {
+      this._modelMinNum = parseAxisModelMinMax(scale, modelMinRaw);
+    }
+    var modelMaxRaw = this._modelMaxRaw = model.get('max', true);
+    if (isFunction(modelMaxRaw)) {
+      // This callback always provides users the full data extent (before data is filtered).
+      this._modelMaxNum = parseAxisModelMinMax(scale, modelMaxRaw({
+        min: dataExtent[0],
+        max: dataExtent[1]
+      }));
+    } else if (modelMaxRaw !== 'dataMax') {
+      this._modelMaxNum = parseAxisModelMinMax(scale, modelMaxRaw);
+    }
+    if (isOrdinal) {
+      // FIXME: there is a flaw here: if there is no "block" data processor like `dataZoom`,
+      // and progressive rendering is using, here the category result might just only contain
+      // the processed chunk rather than the entire result.
+      this._axisDataLen = model.getCategories().length;
+    } else {
+      var boundaryGap = model.get('boundaryGap');
+      var boundaryGapArr = isArray(boundaryGap) ? boundaryGap : [boundaryGap || 0, boundaryGap || 0];
+      if (typeof boundaryGapArr[0] === 'boolean' || typeof boundaryGapArr[1] === 'boolean') {
+        if (process.env.NODE_ENV !== 'production') {
+          console.warn('Boolean type for boundaryGap is only ' + 'allowed for ordinal axis. Please use string in ' + 'percentage instead, e.g., "20%". Currently, ' + 'boundaryGap is set to be 0.');
+        }
+        this._boundaryGapInner = [0, 0];
+      } else {
+        this._boundaryGapInner = [parsePercent(boundaryGapArr[0], 1), parsePercent(boundaryGapArr[1], 1)];
+      }
+    }
+  };
+  /**
+   * Calculate extent by prepared parameters.
+   * This method has no external dependency and can be called duplicatedly,
+   * getting the same result.
+   * If parameters changed, should call this method to recalcuate.
+   */
+  ScaleRawExtentInfo.prototype.calculate = function () {
+    // Notice: When min/max is not set (that is, when there are null/undefined,
+    // which is the most common case), these cases should be ensured:
+    // (1) For 'ordinal', show all axis.data.
+    // (2) For others:
+    //      + `boundaryGap` is applied (if min/max set, boundaryGap is
+    //      disabled).
+    //      + If `needCrossZero`, min/max should be zero, otherwise, min/max should
+    //      be the result that originalExtent enlarged by boundaryGap.
+    // (3) If no data, it should be ensured that `scale.setBlank` is set.
+    var isOrdinal = this._isOrdinal;
+    var dataMin = this._dataMin;
+    var dataMax = this._dataMax;
+    var axisDataLen = this._axisDataLen;
+    var boundaryGapInner = this._boundaryGapInner;
+    var span = !isOrdinal ? dataMax - dataMin || Math.abs(dataMin) : null;
+    // Currently if a `'value'` axis model min is specified as 'dataMin'/'dataMax',
+    // `boundaryGap` will not be used. It's the different from specifying as `null`/`undefined`.
+    var min = this._modelMinRaw === 'dataMin' ? dataMin : this._modelMinNum;
+    var max = this._modelMaxRaw === 'dataMax' ? dataMax : this._modelMaxNum;
+    // If `_modelMinNum`/`_modelMaxNum` is `null`/`undefined`, should not be fixed.
+    var minFixed = min != null;
+    var maxFixed = max != null;
+    if (min == null) {
+      min = isOrdinal ? axisDataLen ? 0 : NaN : dataMin - boundaryGapInner[0] * span;
+    }
+    if (max == null) {
+      max = isOrdinal ? axisDataLen ? axisDataLen - 1 : NaN : dataMax + boundaryGapInner[1] * span;
+    }
+    (min == null || !isFinite(min)) && (min = NaN);
+    (max == null || !isFinite(max)) && (max = NaN);
+    var isBlank = eqNaN(min) || eqNaN(max) || isOrdinal && !axisDataLen;
+    // If data extent modified, need to recalculated to ensure cross zero.
+    if (this._needCrossZero) {
+      // Axis is over zero and min is not set
+      if (min > 0 && max > 0 && !minFixed) {
+        min = 0;
+        // minFixed = true;
+      }
+      // Axis is under zero and max is not set
+      if (min < 0 && max < 0 && !maxFixed) {
+        max = 0;
+        // maxFixed = true;
+      }
+      // PENDING:
+      // When `needCrossZero` and all data is positive/negative, should it be ensured
+      // that the results processed by boundaryGap are positive/negative?
+      // If so, here `minFixed`/`maxFixed` need to be set.
+    }
+
+    var determinedMin = this._determinedMin;
+    var determinedMax = this._determinedMax;
+    if (determinedMin != null) {
+      min = determinedMin;
+      minFixed = true;
+    }
+    if (determinedMax != null) {
+      max = determinedMax;
+      maxFixed = true;
+    }
+    // Ensure min/max be finite number or NaN here. (not to be null/undefined)
+    // `NaN` means min/max axis is blank.
+    return {
+      min: min,
+      max: max,
+      minFixed: minFixed,
+      maxFixed: maxFixed,
+      isBlank: isBlank
+    };
+  };
+  ScaleRawExtentInfo.prototype.modifyDataMinMax = function (minMaxName, val) {
+    if (process.env.NODE_ENV !== 'production') {
+      assert(!this.frozen);
+    }
+    this[DATA_MIN_MAX_ATTR[minMaxName]] = val;
+  };
+  ScaleRawExtentInfo.prototype.setDeterminedMinMax = function (minMaxName, val) {
+    var attr = DETERMINED_MIN_MAX_ATTR[minMaxName];
+    if (process.env.NODE_ENV !== 'production') {
+      assert(!this.frozen
+      // Earse them usually means logic flaw.
+      && this[attr] == null);
+    }
+    this[attr] = val;
+  };
+  ScaleRawExtentInfo.prototype.freeze = function () {
+    // @ts-ignore
+    this.frozen = true;
+  };
+  return ScaleRawExtentInfo;
+}();
+var DETERMINED_MIN_MAX_ATTR = {
+  min: '_determinedMin',
+  max: '_determinedMax'
+};
+var DATA_MIN_MAX_ATTR = {
+  min: '_dataMin',
+  max: '_dataMax'
+};
+/**
+ * Get scale min max and related info only depends on model settings.
+ * This method can be called after coordinate system created.
+ * For example, in data processing stage.
+ *
+ * Scale extent info probably be required multiple times during a workflow.
+ * For example:
+ * (1) `dataZoom` depends it to get the axis extent in "100%" state.
+ * (2) `processor/extentCalculator` depends it to make sure whether axis extent is specified.
+ * (3) `coordSys.update` use it to finally decide the scale extent.
+ * But the callback of `min`/`max` should not be called multiple times.
+ * The code below should not be implemented repeatedly either.
+ * So we cache the result in the scale instance, which will be recreated at the beginning
+ * of the workflow (because `scale` instance will be recreated each round of the workflow).
+ */
+function ensureScaleRawExtentInfo(scale, model,
+// Usually: data extent from all series on this axis.
+originalExtent) {
+  // Do not permit to recreate.
+  var rawExtentInfo = scale.rawExtentInfo;
+  if (rawExtentInfo) {
+    return rawExtentInfo;
+  }
+  rawExtentInfo = new ScaleRawExtentInfo(scale, model, originalExtent);
+  // @ts-ignore
+  scale.rawExtentInfo = rawExtentInfo;
+  return rawExtentInfo;
+}
+function parseAxisModelMinMax(scale, minMax) {
+  return minMax == null ? null : eqNaN(minMax) ? NaN : scale.parse(minMax);
+}
+
+export { ScaleRawExtentInfo, ensureScaleRawExtentInfo, parseAxisModelMinMax };

package/esm/node_modules/echarts/lib/coord/single/AxisModel.js

@@ -0,0 +1,62 @@
+import { __extends } from 'tslib';
+import ComponentModel from '../../model/Component.js';
+import { AxisModelCommonMixin } from '../axisModelCommonMixin.js';
+import { mixin } from '../../../../zrender/lib/core/util.js';
+
+var SingleAxisModel = /** @class */function (_super) {
+  __extends(SingleAxisModel, _super);
+  function SingleAxisModel() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = SingleAxisModel.type;
+    return _this;
+  }
+  SingleAxisModel.prototype.getCoordSysModel = function () {
+    return this;
+  };
+  SingleAxisModel.type = 'singleAxis';
+  SingleAxisModel.layoutMode = 'box';
+  SingleAxisModel.defaultOption = {
+    left: '5%',
+    top: '5%',
+    right: '5%',
+    bottom: '5%',
+    type: 'value',
+    position: 'bottom',
+    orient: 'horizontal',
+    axisLine: {
+      show: true,
+      lineStyle: {
+        width: 1,
+        type: 'solid'
+      }
+    },
+    // Single coordinate system and single axis is the,
+    // which is used as the parent tooltip model.
+    // same model, so we set default tooltip show as true.
+    tooltip: {
+      show: true
+    },
+    axisTick: {
+      show: true,
+      length: 6,
+      lineStyle: {
+        width: 1
+      }
+    },
+    axisLabel: {
+      show: true,
+      interval: 'auto'
+    },
+    splitLine: {
+      show: true,
+      lineStyle: {
+        type: 'dashed',
+        opacity: 0.2
+      }
+    }
+  };
+  return SingleAxisModel;
+}(ComponentModel);
+mixin(SingleAxisModel, AxisModelCommonMixin.prototype);
+
+export { SingleAxisModel as default };

package/esm/node_modules/echarts/lib/coord/single/Single.js

@@ -0,0 +1,166 @@
+import SingleAxis from './SingleAxis.js';
+import { createScaleByModel, niceScaleExtent } from '../axisHelper.js';
+import { getLayoutRect } from '../../util/layout.js';
+import { each } from '../../../../zrender/lib/core/util.js';
+
+var singleDimensions = ['single'];
+/**
+ * Create a single coordinates system.
+ */
+var Single = /** @class */function () {
+  function Single(axisModel, ecModel, api) {
+    this.type = 'single';
+    this.dimension = 'single';
+    /**
+     * Add it just for draw tooltip.
+     */
+    this.dimensions = singleDimensions;
+    this.axisPointerEnabled = true;
+    this.model = axisModel;
+    this._init(axisModel, ecModel, api);
+  }
+  /**
+   * Initialize single coordinate system.
+   */
+  Single.prototype._init = function (axisModel, ecModel, api) {
+    var dim = this.dimension;
+    var axis = new SingleAxis(dim, createScaleByModel(axisModel), [0, 0], axisModel.get('type'), axisModel.get('position'));
+    var isCategory = axis.type === 'category';
+    axis.onBand = isCategory && axisModel.get('boundaryGap');
+    axis.inverse = axisModel.get('inverse');
+    axis.orient = axisModel.get('orient');
+    axisModel.axis = axis;
+    axis.model = axisModel;
+    axis.coordinateSystem = this;
+    this._axis = axis;
+  };
+  /**
+   * Update axis scale after data processed
+   */
+  Single.prototype.update = function (ecModel, api) {
+    ecModel.eachSeries(function (seriesModel) {
+      if (seriesModel.coordinateSystem === this) {
+        var data_1 = seriesModel.getData();
+        each(data_1.mapDimensionsAll(this.dimension), function (dim) {
+          this._axis.scale.unionExtentFromData(data_1, dim);
+        }, this);
+        niceScaleExtent(this._axis.scale, this._axis.model);
+      }
+    }, this);
+  };
+  /**
+   * Resize the single coordinate system.
+   */
+  Single.prototype.resize = function (axisModel, api) {
+    this._rect = getLayoutRect({
+      left: axisModel.get('left'),
+      top: axisModel.get('top'),
+      right: axisModel.get('right'),
+      bottom: axisModel.get('bottom'),
+      width: axisModel.get('width'),
+      height: axisModel.get('height')
+    }, {
+      width: api.getWidth(),
+      height: api.getHeight()
+    });
+    this._adjustAxis();
+  };
+  Single.prototype.getRect = function () {
+    return this._rect;
+  };
+  Single.prototype._adjustAxis = function () {
+    var rect = this._rect;
+    var axis = this._axis;
+    var isHorizontal = axis.isHorizontal();
+    var extent = isHorizontal ? [0, rect.width] : [0, rect.height];
+    var idx = axis.inverse ? 1 : 0;
+    axis.setExtent(extent[idx], extent[1 - idx]);
+    this._updateAxisTransform(axis, isHorizontal ? rect.x : rect.y);
+  };
+  Single.prototype._updateAxisTransform = function (axis, coordBase) {
+    var axisExtent = axis.getExtent();
+    var extentSum = axisExtent[0] + axisExtent[1];
+    var isHorizontal = axis.isHorizontal();
+    axis.toGlobalCoord = isHorizontal ? function (coord) {
+      return coord + coordBase;
+    } : function (coord) {
+      return extentSum - coord + coordBase;
+    };
+    axis.toLocalCoord = isHorizontal ? function (coord) {
+      return coord - coordBase;
+    } : function (coord) {
+      return extentSum - coord + coordBase;
+    };
+  };
+  /**
+   * Get axis.
+   */
+  Single.prototype.getAxis = function () {
+    return this._axis;
+  };
+  /**
+   * Get axis, add it just for draw tooltip.
+   */
+  Single.prototype.getBaseAxis = function () {
+    return this._axis;
+  };
+  Single.prototype.getAxes = function () {
+    return [this._axis];
+  };
+  Single.prototype.getTooltipAxes = function () {
+    return {
+      baseAxes: [this.getAxis()],
+      // Empty otherAxes
+      otherAxes: []
+    };
+  };
+  /**
+   * If contain point.
+   */
+  Single.prototype.containPoint = function (point) {
+    var rect = this.getRect();
+    var axis = this.getAxis();
+    var orient = axis.orient;
+    if (orient === 'horizontal') {
+      return axis.contain(axis.toLocalCoord(point[0])) && point[1] >= rect.y && point[1] <= rect.y + rect.height;
+    } else {
+      return axis.contain(axis.toLocalCoord(point[1])) && point[0] >= rect.y && point[0] <= rect.y + rect.height;
+    }
+  };
+  Single.prototype.pointToData = function (point) {
+    var axis = this.getAxis();
+    return [axis.coordToData(axis.toLocalCoord(point[axis.orient === 'horizontal' ? 0 : 1]))];
+  };
+  /**
+   * Convert the series data to concrete point.
+   * Can be [val] | val
+   */
+  Single.prototype.dataToPoint = function (val) {
+    var axis = this.getAxis();
+    var rect = this.getRect();
+    var pt = [];
+    var idx = axis.orient === 'horizontal' ? 0 : 1;
+    if (val instanceof Array) {
+      val = val[0];
+    }
+    pt[idx] = axis.toGlobalCoord(axis.dataToCoord(+val));
+    pt[1 - idx] = idx === 0 ? rect.y + rect.height / 2 : rect.x + rect.width / 2;
+    return pt;
+  };
+  Single.prototype.convertToPixel = function (ecModel, finder, value) {
+    var coordSys = getCoordSys(finder);
+    return coordSys === this ? this.dataToPoint(value) : null;
+  };
+  Single.prototype.convertFromPixel = function (ecModel, finder, pixel) {
+    var coordSys = getCoordSys(finder);
+    return coordSys === this ? this.pointToData(pixel) : null;
+  };
+  return Single;
+}();
+function getCoordSys(finder) {
+  var seriesModel = finder.seriesModel;
+  var singleModel = finder.singleAxisModel;
+  return singleModel && singleModel.coordinateSystem || seriesModel && seriesModel.coordinateSystem;
+}
+
+export { Single as default, singleDimensions };

package/esm/node_modules/echarts/lib/coord/single/SingleAxis.js

@@ -0,0 +1,25 @@
+import { __extends } from 'tslib';
+import Axis from '../Axis.js';
+
+var SingleAxis = /** @class */function (_super) {
+  __extends(SingleAxis, _super);
+  function SingleAxis(dim, scale, coordExtent, axisType, position) {
+    var _this = _super.call(this, dim, scale, coordExtent) || this;
+    _this.type = axisType || 'value';
+    _this.position = position || 'bottom';
+    return _this;
+  }
+  /**
+   * Judge the orient of the axis.
+   */
+  SingleAxis.prototype.isHorizontal = function () {
+    var position = this.position;
+    return position === 'top' || position === 'bottom';
+  };
+  SingleAxis.prototype.pointToData = function (point, clamp) {
+    return this.coordinateSystem.pointToData(point)[0];
+  };
+  return SingleAxis;
+}(Axis);
+
+export { SingleAxis as default };

package/esm/node_modules/echarts/lib/coord/single/prepareCustom.js

@@ -0,0 +1,30 @@
+import { bind } from '../../../../zrender/lib/core/util.js';
+
+function dataToCoordSize(dataSize, dataItem) {
+  // dataItem is necessary in log axis.
+  var axis = this.getAxis();
+  var val = dataItem instanceof Array ? dataItem[0] : dataItem;
+  var halfSize = (dataSize instanceof Array ? dataSize[0] : dataSize) / 2;
+  return axis.type === 'category' ? axis.getBandWidth() : Math.abs(axis.dataToCoord(val - halfSize) - axis.dataToCoord(val + halfSize));
+}
+function singlePrepareCustom(coordSys) {
+  var rect = coordSys.getRect();
+  return {
+    coordSys: {
+      type: 'singleAxis',
+      x: rect.x,
+      y: rect.y,
+      width: rect.width,
+      height: rect.height
+    },
+    api: {
+      coord: function (val) {
+        // do not provide "out" param
+        return coordSys.dataToPoint(val);
+      },
+      size: bind(dataToCoordSize, coordSys)
+    }
+  };
+}
+
+export { singlePrepareCustom as default };

package/esm/node_modules/echarts/lib/coord/single/singleAxisHelper.js

@@ -0,0 +1,48 @@
+import { retrieve } from '../../../../zrender/lib/core/util.js';
+
+function layout(axisModel, opt) {
+  opt = opt || {};
+  var single = axisModel.coordinateSystem;
+  var axis = axisModel.axis;
+  var layout = {};
+  var axisPosition = axis.position;
+  var orient = axis.orient;
+  var rect = single.getRect();
+  var rectBound = [rect.x, rect.x + rect.width, rect.y, rect.y + rect.height];
+  var positionMap = {
+    horizontal: {
+      top: rectBound[2],
+      bottom: rectBound[3]
+    },
+    vertical: {
+      left: rectBound[0],
+      right: rectBound[1]
+    }
+  };
+  layout.position = [orient === 'vertical' ? positionMap.vertical[axisPosition] : rectBound[0], orient === 'horizontal' ? positionMap.horizontal[axisPosition] : rectBound[3]];
+  var r = {
+    horizontal: 0,
+    vertical: 1
+  };
+  layout.rotation = Math.PI / 2 * r[orient];
+  var directionMap = {
+    top: -1,
+    bottom: 1,
+    right: 1,
+    left: -1
+  };
+  layout.labelDirection = layout.tickDirection = layout.nameDirection = directionMap[axisPosition];
+  if (axisModel.get(['axisTick', 'inside'])) {
+    layout.tickDirection = -layout.tickDirection;
+  }
+  if (retrieve(opt.labelInside, axisModel.get(['axisLabel', 'inside']))) {
+    layout.labelDirection = -layout.labelDirection;
+  }
+  var labelRotation = opt.rotate;
+  labelRotation == null && (labelRotation = axisModel.get(['axisLabel', 'rotate']));
+  layout.labelRotation = axisPosition === 'top' ? -labelRotation : labelRotation;
+  layout.z2 = 1;
+  return layout;
+}
+
+export { layout };

package/esm/node_modules/echarts/lib/coord/single/singleCreator.js

@@ -0,0 +1,29 @@
+import Single, { singleDimensions } from './Single.js';
+import { SINGLE_REFERRING } from '../../util/model.js';
+
+/**
+ * Create single coordinate system and inject it into seriesModel.
+ */
+function create(ecModel, api) {
+  var singles = [];
+  ecModel.eachComponent('singleAxis', function (axisModel, idx) {
+    var single = new Single(axisModel, ecModel, api);
+    single.name = 'single_' + idx;
+    single.resize(axisModel, api);
+    axisModel.coordinateSystem = single;
+    singles.push(single);
+  });
+  ecModel.eachSeries(function (seriesModel) {
+    if (seriesModel.get('coordinateSystem') === 'singleAxis') {
+      var singleAxisModel = seriesModel.getReferringComponents('singleAxis', SINGLE_REFERRING).models[0];
+      seriesModel.coordinateSystem = singleAxisModel && singleAxisModel.coordinateSystem;
+    }
+  });
+  return singles;
+}
+var singleCreator = {
+  create: create,
+  dimensions: singleDimensions
+};
+
+export { singleCreator as default };

package/esm/node_modules/echarts/lib/core/CoordinateSystem.js

@@ -0,0 +1,33 @@
+import { each } from '../../../zrender/lib/core/util.js';
+
+var coordinateSystemCreators = {};
+var CoordinateSystemManager = /** @class */function () {
+  function CoordinateSystemManager() {
+    this._coordinateSystems = [];
+  }
+  CoordinateSystemManager.prototype.create = function (ecModel, api) {
+    var coordinateSystems = [];
+    each(coordinateSystemCreators, function (creator, type) {
+      var list = creator.create(ecModel, api);
+      coordinateSystems = coordinateSystems.concat(list || []);
+    });
+    this._coordinateSystems = coordinateSystems;
+  };
+  CoordinateSystemManager.prototype.update = function (ecModel, api) {
+    each(this._coordinateSystems, function (coordSys) {
+      coordSys.update && coordSys.update(ecModel, api);
+    });
+  };
+  CoordinateSystemManager.prototype.getCoordinateSystems = function () {
+    return this._coordinateSystems.slice();
+  };
+  CoordinateSystemManager.register = function (type, creator) {
+    coordinateSystemCreators[type] = creator;
+  };
+  CoordinateSystemManager.get = function (type) {
+    return coordinateSystemCreators[type];
+  };
+  return CoordinateSystemManager;
+}();
+
+export { CoordinateSystemManager as default };

package/esm/node_modules/echarts/lib/core/ExtensionAPI.js

@@ -0,0 +1,18 @@
+import { each, bind } from '../../../zrender/lib/core/util.js';
+
+var availableMethods = ['getDom', 'getZr', 'getWidth', 'getHeight', 'getDevicePixelRatio', 'dispatchAction', 'isSSR', 'isDisposed', 'on', 'off', 'getDataURL', 'getConnectedDataURL',
+// 'getModel',
+'getOption',
+// 'getViewOfComponentModel',
+// 'getViewOfSeriesModel',
+'getId', 'updateLabelLayout'];
+var ExtensionAPI = /** @class */function () {
+  function ExtensionAPI(ecInstance) {
+    each(availableMethods, function (methodName) {
+      this[methodName] = bind(ecInstance[methodName], ecInstance);
+    }, this);
+  }
+  return ExtensionAPI;
+}();
+
+export { ExtensionAPI as default };