office-viewer 0.3.11 → 0.3.13

package/esm/node_modules/echarts/lib/scale/Interval.js

@@ -0,0 +1,226 @@
+import { __extends } from 'tslib';
+import { getPrecision, round } from '../util/number.js';
+import { addCommas } from '../util/format.js';
+import Scale from './Scale.js';
+import { contain, normalize, scale, getIntervalPrecision, intervalScaleNiceTicks } from './helper.js';
+
+var roundNumber = round;
+var IntervalScale = /** @class */function (_super) {
+  __extends(IntervalScale, _super);
+  function IntervalScale() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = 'interval';
+    // Step is calculated in adjustExtent.
+    _this._interval = 0;
+    _this._intervalPrecision = 2;
+    return _this;
+  }
+  IntervalScale.prototype.parse = function (val) {
+    return val;
+  };
+  IntervalScale.prototype.contain = function (val) {
+    return contain(val, this._extent);
+  };
+  IntervalScale.prototype.normalize = function (val) {
+    return normalize(val, this._extent);
+  };
+  IntervalScale.prototype.scale = function (val) {
+    return scale(val, this._extent);
+  };
+  IntervalScale.prototype.setExtent = function (start, end) {
+    var thisExtent = this._extent;
+    // start,end may be a Number like '25',so...
+    if (!isNaN(start)) {
+      thisExtent[0] = parseFloat(start);
+    }
+    if (!isNaN(end)) {
+      thisExtent[1] = parseFloat(end);
+    }
+  };
+  IntervalScale.prototype.unionExtent = function (other) {
+    var extent = this._extent;
+    other[0] < extent[0] && (extent[0] = other[0]);
+    other[1] > extent[1] && (extent[1] = other[1]);
+    // unionExtent may called by it's sub classes
+    this.setExtent(extent[0], extent[1]);
+  };
+  IntervalScale.prototype.getInterval = function () {
+    return this._interval;
+  };
+  IntervalScale.prototype.setInterval = function (interval) {
+    this._interval = interval;
+    // Dropped auto calculated niceExtent and use user-set extent.
+    // We assume user wants to set both interval, min, max to get a better result.
+    this._niceExtent = this._extent.slice();
+    this._intervalPrecision = getIntervalPrecision(interval);
+  };
+  /**
+   * @param expandToNicedExtent Whether expand the ticks to niced extent.
+   */
+  IntervalScale.prototype.getTicks = function (expandToNicedExtent) {
+    var interval = this._interval;
+    var extent = this._extent;
+    var niceTickExtent = this._niceExtent;
+    var intervalPrecision = this._intervalPrecision;
+    var ticks = [];
+    // If interval is 0, return [];
+    if (!interval) {
+      return ticks;
+    }
+    // Consider this case: using dataZoom toolbox, zoom and zoom.
+    var safeLimit = 10000;
+    if (extent[0] < niceTickExtent[0]) {
+      if (expandToNicedExtent) {
+        ticks.push({
+          value: roundNumber(niceTickExtent[0] - interval, intervalPrecision)
+        });
+      } else {
+        ticks.push({
+          value: extent[0]
+        });
+      }
+    }
+    var tick = niceTickExtent[0];
+    while (tick <= niceTickExtent[1]) {
+      ticks.push({
+        value: tick
+      });
+      // Avoid rounding error
+      tick = roundNumber(tick + interval, intervalPrecision);
+      if (tick === ticks[ticks.length - 1].value) {
+        // Consider out of safe float point, e.g.,
+        // -3711126.9907707 + 2e-10 === -3711126.9907707
+        break;
+      }
+      if (ticks.length > safeLimit) {
+        return [];
+      }
+    }
+    // Consider this case: the last item of ticks is smaller
+    // than niceTickExtent[1] and niceTickExtent[1] === extent[1].
+    var lastNiceTick = ticks.length ? ticks[ticks.length - 1].value : niceTickExtent[1];
+    if (extent[1] > lastNiceTick) {
+      if (expandToNicedExtent) {
+        ticks.push({
+          value: roundNumber(lastNiceTick + interval, intervalPrecision)
+        });
+      } else {
+        ticks.push({
+          value: extent[1]
+        });
+      }
+    }
+    return ticks;
+  };
+  IntervalScale.prototype.getMinorTicks = function (splitNumber) {
+    var ticks = this.getTicks(true);
+    var minorTicks = [];
+    var extent = this.getExtent();
+    for (var i = 1; i < ticks.length; i++) {
+      var nextTick = ticks[i];
+      var prevTick = ticks[i - 1];
+      var count = 0;
+      var minorTicksGroup = [];
+      var interval = nextTick.value - prevTick.value;
+      var minorInterval = interval / splitNumber;
+      while (count < splitNumber - 1) {
+        var minorTick = roundNumber(prevTick.value + (count + 1) * minorInterval);
+        // For the first and last interval. The count may be less than splitNumber.
+        if (minorTick > extent[0] && minorTick < extent[1]) {
+          minorTicksGroup.push(minorTick);
+        }
+        count++;
+      }
+      minorTicks.push(minorTicksGroup);
+    }
+    return minorTicks;
+  };
+  /**
+   * @param opt.precision If 'auto', use nice presision.
+   * @param opt.pad returns 1.50 but not 1.5 if precision is 2.
+   */
+  IntervalScale.prototype.getLabel = function (data, opt) {
+    if (data == null) {
+      return '';
+    }
+    var precision = opt && opt.precision;
+    if (precision == null) {
+      precision = getPrecision(data.value) || 0;
+    } else if (precision === 'auto') {
+      // Should be more precise then tick.
+      precision = this._intervalPrecision;
+    }
+    // (1) If `precision` is set, 12.005 should be display as '12.00500'.
+    // (2) Use roundNumber (toFixed) to avoid scientific notation like '3.5e-7'.
+    var dataNum = roundNumber(data.value, precision, true);
+    return addCommas(dataNum);
+  };
+  /**
+   * @param splitNumber By default `5`.
+   */
+  IntervalScale.prototype.calcNiceTicks = function (splitNumber, minInterval, maxInterval) {
+    splitNumber = splitNumber || 5;
+    var extent = this._extent;
+    var span = extent[1] - extent[0];
+    if (!isFinite(span)) {
+      return;
+    }
+    // User may set axis min 0 and data are all negative
+    // FIXME If it needs to reverse ?
+    if (span < 0) {
+      span = -span;
+      extent.reverse();
+    }
+    var result = intervalScaleNiceTicks(extent, splitNumber, minInterval, maxInterval);
+    this._intervalPrecision = result.intervalPrecision;
+    this._interval = result.interval;
+    this._niceExtent = result.niceTickExtent;
+  };
+  IntervalScale.prototype.calcNiceExtent = function (opt) {
+    var extent = this._extent;
+    // If extent start and end are same, expand them
+    if (extent[0] === extent[1]) {
+      if (extent[0] !== 0) {
+        // Expand extent
+        // Note that extents can be both negative. See #13154
+        var expandSize = Math.abs(extent[0]);
+        // In the fowllowing case
+        //      Axis has been fixed max 100
+        //      Plus data are all 100 and axis extent are [100, 100].
+        // Extend to the both side will cause expanded max is larger than fixed max.
+        // So only expand to the smaller side.
+        if (!opt.fixMax) {
+          extent[1] += expandSize / 2;
+          extent[0] -= expandSize / 2;
+        } else {
+          extent[0] -= expandSize / 2;
+        }
+      } else {
+        extent[1] = 1;
+      }
+    }
+    var span = extent[1] - extent[0];
+    // If there are no data and extent are [Infinity, -Infinity]
+    if (!isFinite(span)) {
+      extent[0] = 0;
+      extent[1] = 1;
+    }
+    this.calcNiceTicks(opt.splitNumber, opt.minInterval, opt.maxInterval);
+    // let extent = this._extent;
+    var interval = this._interval;
+    if (!opt.fixMin) {
+      extent[0] = roundNumber(Math.floor(extent[0] / interval) * interval);
+    }
+    if (!opt.fixMax) {
+      extent[1] = roundNumber(Math.ceil(extent[1] / interval) * interval);
+    }
+  };
+  IntervalScale.prototype.setNiceExtent = function (min, max) {
+    this._niceExtent = [min, max];
+  };
+  IntervalScale.type = 'interval';
+  return IntervalScale;
+}(Scale);
+Scale.registerClass(IntervalScale);
+
+export { IntervalScale as default };

package/esm/node_modules/echarts/lib/scale/Log.js

@@ -0,0 +1,136 @@
+import { __extends } from 'tslib';
+import { map } from '../../../zrender/lib/core/util.js';
+import Scale from './Scale.js';
+import { round, quantity, getPrecision } from '../util/number.js';
+import { contain, normalize, scale } from './helper.js';
+import IntervalScale from './Interval.js';
+
+var scaleProto = Scale.prototype;
+// FIXME:TS refactor: not good to call it directly with `this`?
+var intervalScaleProto = IntervalScale.prototype;
+var roundingErrorFix = round;
+var mathFloor = Math.floor;
+var mathCeil = Math.ceil;
+var mathPow = Math.pow;
+var mathLog = Math.log;
+var LogScale = /** @class */function (_super) {
+  __extends(LogScale, _super);
+  function LogScale() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = 'log';
+    _this.base = 10;
+    _this._originalScale = new IntervalScale();
+    // FIXME:TS actually used by `IntervalScale`
+    _this._interval = 0;
+    return _this;
+  }
+  /**
+   * @param Whether expand the ticks to niced extent.
+   */
+  LogScale.prototype.getTicks = function (expandToNicedExtent) {
+    var originalScale = this._originalScale;
+    var extent = this._extent;
+    var originalExtent = originalScale.getExtent();
+    var ticks = intervalScaleProto.getTicks.call(this, expandToNicedExtent);
+    return map(ticks, function (tick) {
+      var val = tick.value;
+      var powVal = round(mathPow(this.base, val));
+      // Fix #4158
+      powVal = val === extent[0] && this._fixMin ? fixRoundingError(powVal, originalExtent[0]) : powVal;
+      powVal = val === extent[1] && this._fixMax ? fixRoundingError(powVal, originalExtent[1]) : powVal;
+      return {
+        value: powVal
+      };
+    }, this);
+  };
+  LogScale.prototype.setExtent = function (start, end) {
+    var base = mathLog(this.base);
+    // log(-Infinity) is NaN, so safe guard here
+    start = mathLog(Math.max(0, start)) / base;
+    end = mathLog(Math.max(0, end)) / base;
+    intervalScaleProto.setExtent.call(this, start, end);
+  };
+  /**
+   * @return {number} end
+   */
+  LogScale.prototype.getExtent = function () {
+    var base = this.base;
+    var extent = scaleProto.getExtent.call(this);
+    extent[0] = mathPow(base, extent[0]);
+    extent[1] = mathPow(base, extent[1]);
+    // Fix #4158
+    var originalScale = this._originalScale;
+    var originalExtent = originalScale.getExtent();
+    this._fixMin && (extent[0] = fixRoundingError(extent[0], originalExtent[0]));
+    this._fixMax && (extent[1] = fixRoundingError(extent[1], originalExtent[1]));
+    return extent;
+  };
+  LogScale.prototype.unionExtent = function (extent) {
+    this._originalScale.unionExtent(extent);
+    var base = this.base;
+    extent[0] = mathLog(extent[0]) / mathLog(base);
+    extent[1] = mathLog(extent[1]) / mathLog(base);
+    scaleProto.unionExtent.call(this, extent);
+  };
+  LogScale.prototype.unionExtentFromData = function (data, dim) {
+    // TODO
+    // filter value that <= 0
+    this.unionExtent(data.getApproximateExtent(dim));
+  };
+  /**
+   * Update interval and extent of intervals for nice ticks
+   * @param approxTickNum default 10 Given approx tick number
+   */
+  LogScale.prototype.calcNiceTicks = function (approxTickNum) {
+    approxTickNum = approxTickNum || 10;
+    var extent = this._extent;
+    var span = extent[1] - extent[0];
+    if (span === Infinity || span <= 0) {
+      return;
+    }
+    var interval = quantity(span);
+    var err = approxTickNum / span * interval;
+    // Filter ticks to get closer to the desired count.
+    if (err <= 0.5) {
+      interval *= 10;
+    }
+    // Interval should be integer
+    while (!isNaN(interval) && Math.abs(interval) < 1 && Math.abs(interval) > 0) {
+      interval *= 10;
+    }
+    var niceExtent = [round(mathCeil(extent[0] / interval) * interval), round(mathFloor(extent[1] / interval) * interval)];
+    this._interval = interval;
+    this._niceExtent = niceExtent;
+  };
+  LogScale.prototype.calcNiceExtent = function (opt) {
+    intervalScaleProto.calcNiceExtent.call(this, opt);
+    this._fixMin = opt.fixMin;
+    this._fixMax = opt.fixMax;
+  };
+  LogScale.prototype.parse = function (val) {
+    return val;
+  };
+  LogScale.prototype.contain = function (val) {
+    val = mathLog(val) / mathLog(this.base);
+    return contain(val, this._extent);
+  };
+  LogScale.prototype.normalize = function (val) {
+    val = mathLog(val) / mathLog(this.base);
+    return normalize(val, this._extent);
+  };
+  LogScale.prototype.scale = function (val) {
+    val = scale(val, this._extent);
+    return mathPow(this.base, val);
+  };
+  LogScale.type = 'log';
+  return LogScale;
+}(Scale);
+var proto = LogScale.prototype;
+proto.getMinorTicks = intervalScaleProto.getMinorTicks;
+proto.getLabel = intervalScaleProto.getLabel;
+function fixRoundingError(val, originalVal) {
+  return roundingErrorFix(val, getPrecision(originalVal));
+}
+Scale.registerClass(LogScale);
+
+export { LogScale as default };

package/esm/node_modules/echarts/lib/scale/Ordinal.js

@@ -0,0 +1,167 @@
+import { __extends } from 'tslib';
+import Scale from './Scale.js';
+import OrdinalMeta from '../data/OrdinalMeta.js';
+import { contain, normalize, scale } from './helper.js';
+import { isArray, map, isObject, isString } from '../../../zrender/lib/core/util.js';
+
+var OrdinalScale = /** @class */function (_super) {
+  __extends(OrdinalScale, _super);
+  function OrdinalScale(setting) {
+    var _this = _super.call(this, setting) || this;
+    _this.type = 'ordinal';
+    var ordinalMeta = _this.getSetting('ordinalMeta');
+    // Caution: Should not use instanceof, consider ec-extensions using
+    // import approach to get OrdinalMeta class.
+    if (!ordinalMeta) {
+      ordinalMeta = new OrdinalMeta({});
+    }
+    if (isArray(ordinalMeta)) {
+      ordinalMeta = new OrdinalMeta({
+        categories: map(ordinalMeta, function (item) {
+          return isObject(item) ? item.value : item;
+        })
+      });
+    }
+    _this._ordinalMeta = ordinalMeta;
+    _this._extent = _this.getSetting('extent') || [0, ordinalMeta.categories.length - 1];
+    return _this;
+  }
+  OrdinalScale.prototype.parse = function (val) {
+    // Caution: Math.round(null) will return `0` rather than `NaN`
+    if (val == null) {
+      return NaN;
+    }
+    return isString(val) ? this._ordinalMeta.getOrdinal(val)
+    // val might be float.
+    : Math.round(val);
+  };
+  OrdinalScale.prototype.contain = function (rank) {
+    rank = this.parse(rank);
+    return contain(rank, this._extent) && this._ordinalMeta.categories[rank] != null;
+  };
+  /**
+   * Normalize given rank or name to linear [0, 1]
+   * @param val raw ordinal number.
+   * @return normalized value in [0, 1].
+   */
+  OrdinalScale.prototype.normalize = function (val) {
+    val = this._getTickNumber(this.parse(val));
+    return normalize(val, this._extent);
+  };
+  /**
+   * @param val normalized value in [0, 1].
+   * @return raw ordinal number.
+   */
+  OrdinalScale.prototype.scale = function (val) {
+    val = Math.round(scale(val, this._extent));
+    return this.getRawOrdinalNumber(val);
+  };
+  OrdinalScale.prototype.getTicks = function () {
+    var ticks = [];
+    var extent = this._extent;
+    var rank = extent[0];
+    while (rank <= extent[1]) {
+      ticks.push({
+        value: rank
+      });
+      rank++;
+    }
+    return ticks;
+  };
+  OrdinalScale.prototype.getMinorTicks = function (splitNumber) {
+    // Not support.
+    return;
+  };
+  /**
+   * @see `Ordinal['_ordinalNumbersByTick']`
+   */
+  OrdinalScale.prototype.setSortInfo = function (info) {
+    if (info == null) {
+      this._ordinalNumbersByTick = this._ticksByOrdinalNumber = null;
+      return;
+    }
+    var infoOrdinalNumbers = info.ordinalNumbers;
+    var ordinalsByTick = this._ordinalNumbersByTick = [];
+    var ticksByOrdinal = this._ticksByOrdinalNumber = [];
+    // Unnecessary support negative tick in `realtimeSort`.
+    var tickNum = 0;
+    var allCategoryLen = this._ordinalMeta.categories.length;
+    for (var len = Math.min(allCategoryLen, infoOrdinalNumbers.length); tickNum < len; ++tickNum) {
+      var ordinalNumber = infoOrdinalNumbers[tickNum];
+      ordinalsByTick[tickNum] = ordinalNumber;
+      ticksByOrdinal[ordinalNumber] = tickNum;
+    }
+    // Handle that `series.data` only covers part of the `axis.category.data`.
+    var unusedOrdinal = 0;
+    for (; tickNum < allCategoryLen; ++tickNum) {
+      while (ticksByOrdinal[unusedOrdinal] != null) {
+        unusedOrdinal++;
+      }
+      ordinalsByTick.push(unusedOrdinal);
+      ticksByOrdinal[unusedOrdinal] = tickNum;
+    }
+  };
+  OrdinalScale.prototype._getTickNumber = function (ordinal) {
+    var ticksByOrdinalNumber = this._ticksByOrdinalNumber;
+    // also support ordinal out of range of `ordinalMeta.categories.length`,
+    // where ordinal numbers are used as tick value directly.
+    return ticksByOrdinalNumber && ordinal >= 0 && ordinal < ticksByOrdinalNumber.length ? ticksByOrdinalNumber[ordinal] : ordinal;
+  };
+  /**
+   * @usage
+   * ```js
+   * const ordinalNumber = ordinalScale.getRawOrdinalNumber(tickVal);
+   *
+   * // case0
+   * const rawOrdinalValue = axisModel.getCategories()[ordinalNumber];
+   * // case1
+   * const rawOrdinalValue = this._ordinalMeta.categories[ordinalNumber];
+   * // case2
+   * const coord = axis.dataToCoord(ordinalNumber);
+   * ```
+   *
+   * @param {OrdinalNumber} tickNumber index of display
+   */
+  OrdinalScale.prototype.getRawOrdinalNumber = function (tickNumber) {
+    var ordinalNumbersByTick = this._ordinalNumbersByTick;
+    // tickNumber may be out of range, e.g., when axis max is larger than `ordinalMeta.categories.length`.,
+    // where ordinal numbers are used as tick value directly.
+    return ordinalNumbersByTick && tickNumber >= 0 && tickNumber < ordinalNumbersByTick.length ? ordinalNumbersByTick[tickNumber] : tickNumber;
+  };
+  /**
+   * Get item on tick
+   */
+  OrdinalScale.prototype.getLabel = function (tick) {
+    if (!this.isBlank()) {
+      var ordinalNumber = this.getRawOrdinalNumber(tick.value);
+      var cateogry = this._ordinalMeta.categories[ordinalNumber];
+      // Note that if no data, ordinalMeta.categories is an empty array.
+      // Return empty if it's not exist.
+      return cateogry == null ? '' : cateogry + '';
+    }
+  };
+  OrdinalScale.prototype.count = function () {
+    return this._extent[1] - this._extent[0] + 1;
+  };
+  OrdinalScale.prototype.unionExtentFromData = function (data, dim) {
+    this.unionExtent(data.getApproximateExtent(dim));
+  };
+  /**
+   * @override
+   * If value is in extent range
+   */
+  OrdinalScale.prototype.isInExtentRange = function (value) {
+    value = this._getTickNumber(value);
+    return this._extent[0] <= value && this._extent[1] >= value;
+  };
+  OrdinalScale.prototype.getOrdinalMeta = function () {
+    return this._ordinalMeta;
+  };
+  OrdinalScale.prototype.calcNiceTicks = function () {};
+  OrdinalScale.prototype.calcNiceExtent = function () {};
+  OrdinalScale.type = 'ordinal';
+  return OrdinalScale;
+}(Scale);
+Scale.registerClass(OrdinalScale);
+
+export { OrdinalScale as default };

package/esm/node_modules/echarts/lib/scale/Scale.js

@@ -0,0 +1,71 @@
+import { enableClassManagement } from '../util/clazz.js';
+
+var Scale = /** @class */function () {
+  function Scale(setting) {
+    this._setting = setting || {};
+    this._extent = [Infinity, -Infinity];
+  }
+  Scale.prototype.getSetting = function (name) {
+    return this._setting[name];
+  };
+  /**
+   * Set extent from data
+   */
+  Scale.prototype.unionExtent = function (other) {
+    var extent = this._extent;
+    other[0] < extent[0] && (extent[0] = other[0]);
+    other[1] > extent[1] && (extent[1] = other[1]);
+    // not setExtent because in log axis it may transformed to power
+    // this.setExtent(extent[0], extent[1]);
+  };
+  /**
+   * Set extent from data
+   */
+  Scale.prototype.unionExtentFromData = function (data, dim) {
+    this.unionExtent(data.getApproximateExtent(dim));
+  };
+  /**
+   * Get extent
+   *
+   * Extent is always in increase order.
+   */
+  Scale.prototype.getExtent = function () {
+    return this._extent.slice();
+  };
+  /**
+   * Set extent
+   */
+  Scale.prototype.setExtent = function (start, end) {
+    var thisExtent = this._extent;
+    if (!isNaN(start)) {
+      thisExtent[0] = start;
+    }
+    if (!isNaN(end)) {
+      thisExtent[1] = end;
+    }
+  };
+  /**
+   * If value is in extent range
+   */
+  Scale.prototype.isInExtentRange = function (value) {
+    return this._extent[0] <= value && this._extent[1] >= value;
+  };
+  /**
+   * When axis extent depends on data and no data exists,
+   * axis ticks should not be drawn, which is named 'blank'.
+   */
+  Scale.prototype.isBlank = function () {
+    return this._isBlank;
+  };
+  /**
+   * When axis extent depends on data and no data exists,
+   * axis ticks should not be drawn, which is named 'blank'.
+   */
+  Scale.prototype.setBlank = function (isBlank) {
+    this._isBlank = isBlank;
+  };
+  return Scale;
+}();
+enableClassManagement(Scale);
+
+export { Scale as default };