office-viewer 0.3.11 → 0.3.13

package/esm/node_modules/echarts/lib/coord/calendar/CalendarModel.js

@@ -0,0 +1,118 @@
+import { __extends } from 'tslib';
+import { isArray, map } from '../../../../zrender/lib/core/util.js';
+import ComponentModel from '../../model/Component.js';
+import { getLayoutParams, sizeCalculable, mergeLayoutParam } from '../../util/layout.js';
+
+var CalendarModel = /** @class */function (_super) {
+  __extends(CalendarModel, _super);
+  function CalendarModel() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = CalendarModel.type;
+    return _this;
+  }
+  /**
+   * @override
+   */
+  CalendarModel.prototype.init = function (option, parentModel, ecModel) {
+    var inputPositionParams = getLayoutParams(option);
+    _super.prototype.init.apply(this, arguments);
+    mergeAndNormalizeLayoutParams(option, inputPositionParams);
+  };
+  /**
+   * @override
+   */
+  CalendarModel.prototype.mergeOption = function (option) {
+    _super.prototype.mergeOption.apply(this, arguments);
+    mergeAndNormalizeLayoutParams(this.option, option);
+  };
+  CalendarModel.prototype.getCellSize = function () {
+    // Has been normalized
+    return this.option.cellSize;
+  };
+  CalendarModel.type = 'calendar';
+  CalendarModel.defaultOption = {
+    // zlevel: 0,
+    z: 2,
+    left: 80,
+    top: 60,
+    cellSize: 20,
+    // horizontal vertical
+    orient: 'horizontal',
+    // month separate line style
+    splitLine: {
+      show: true,
+      lineStyle: {
+        color: '#000',
+        width: 1,
+        type: 'solid'
+      }
+    },
+    // rect style  temporarily unused emphasis
+    itemStyle: {
+      color: '#fff',
+      borderWidth: 1,
+      borderColor: '#ccc'
+    },
+    // week text style
+    dayLabel: {
+      show: true,
+      firstDay: 0,
+      // start end
+      position: 'start',
+      margin: '50%',
+      color: '#000'
+    },
+    // month text style
+    monthLabel: {
+      show: true,
+      // start end
+      position: 'start',
+      margin: 5,
+      // center or left
+      align: 'center',
+      formatter: null,
+      color: '#000'
+    },
+    // year text style
+    yearLabel: {
+      show: true,
+      // top bottom left right
+      position: null,
+      margin: 30,
+      formatter: null,
+      color: '#ccc',
+      fontFamily: 'sans-serif',
+      fontWeight: 'bolder',
+      fontSize: 20
+    }
+  };
+  return CalendarModel;
+}(ComponentModel);
+function mergeAndNormalizeLayoutParams(target, raw) {
+  // Normalize cellSize
+  var cellSize = target.cellSize;
+  var cellSizeArr;
+  if (!isArray(cellSize)) {
+    cellSizeArr = target.cellSize = [cellSize, cellSize];
+  } else {
+    cellSizeArr = cellSize;
+  }
+  if (cellSizeArr.length === 1) {
+    cellSizeArr[1] = cellSizeArr[0];
+  }
+  var ignoreSize = map([0, 1], function (hvIdx) {
+    // If user have set `width` or both `left` and `right`, cellSizeArr
+    // will be automatically set to 'auto', otherwise the default
+    // setting of cellSizeArr will make `width` setting not work.
+    if (sizeCalculable(raw, hvIdx)) {
+      cellSizeArr[hvIdx] = 'auto';
+    }
+    return cellSizeArr[hvIdx] != null && cellSizeArr[hvIdx] !== 'auto';
+  });
+  mergeLayoutParam(target, raw, {
+    type: 'box',
+    ignoreSize: ignoreSize
+  });
+}
+
+export { CalendarModel as default };

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

@@ -0,0 +1,70 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+
+
+/**
+ * AUTO-GENERATED FILE. DO NOT MODIFY.
+ */
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+function calendarPrepareCustom(coordSys) {
+  var rect = coordSys.getRect();
+  var rangeInfo = coordSys.getRangeInfo();
+  return {
+    coordSys: {
+      type: 'calendar',
+      x: rect.x,
+      y: rect.y,
+      width: rect.width,
+      height: rect.height,
+      cellWidth: coordSys.getCellWidth(),
+      cellHeight: coordSys.getCellHeight(),
+      rangeInfo: {
+        start: rangeInfo.start,
+        end: rangeInfo.end,
+        weeks: rangeInfo.weeks,
+        dayCount: rangeInfo.allDay
+      }
+    },
+    api: {
+      coord: function (data, clamp) {
+        return coordSys.dataToPoint(data, clamp);
+      }
+    }
+  };
+}
+
+export { calendarPrepareCustom as default };

package/esm/node_modules/echarts/lib/coord/cartesian/Axis2D.js

@@ -0,0 +1,53 @@
+import { __extends } from 'tslib';
+import Axis from '../Axis.js';
+
+var Axis2D = /** @class */function (_super) {
+  __extends(Axis2D, _super);
+  function Axis2D(dim, scale, coordExtent, axisType, position) {
+    var _this = _super.call(this, dim, scale, coordExtent) || this;
+    /**
+     * Index of axis, can be used as key
+     * Injected outside.
+     */
+    _this.index = 0;
+    _this.type = axisType || 'value';
+    _this.position = position || 'bottom';
+    return _this;
+  }
+  Axis2D.prototype.isHorizontal = function () {
+    var position = this.position;
+    return position === 'top' || position === 'bottom';
+  };
+  /**
+   * Each item cooresponds to this.getExtent(), which
+   * means globalExtent[0] may greater than globalExtent[1],
+   * unless `asc` is input.
+   *
+   * @param {boolean} [asc]
+   * @return {Array.<number>}
+   */
+  Axis2D.prototype.getGlobalExtent = function (asc) {
+    var ret = this.getExtent();
+    ret[0] = this.toGlobalCoord(ret[0]);
+    ret[1] = this.toGlobalCoord(ret[1]);
+    asc && ret[0] > ret[1] && ret.reverse();
+    return ret;
+  };
+  Axis2D.prototype.pointToData = function (point, clamp) {
+    return this.coordToData(this.toLocalCoord(point[this.dim === 'x' ? 0 : 1]), clamp);
+  };
+  /**
+   * Set ordinalSortInfo
+   * @param info new OrdinalSortInfo
+   */
+  Axis2D.prototype.setCategorySortInfo = function (info) {
+    if (this.type !== 'category') {
+      return false;
+    }
+    this.model.option.categorySortInfo = info;
+    this.scale.setSortInfo(info);
+  };
+  return Axis2D;
+}(Axis);
+
+export { Axis2D as default };

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

@@ -0,0 +1,20 @@
+import { __extends } from 'tslib';
+import { mixin } from '../../../../zrender/lib/core/util.js';
+import ComponentModel from '../../model/Component.js';
+import { AxisModelCommonMixin } from '../axisModelCommonMixin.js';
+import { SINGLE_REFERRING } from '../../util/model.js';
+
+var CartesianAxisModel = /** @class */function (_super) {
+  __extends(CartesianAxisModel, _super);
+  function CartesianAxisModel() {
+    return _super !== null && _super.apply(this, arguments) || this;
+  }
+  CartesianAxisModel.prototype.getCoordSysModel = function () {
+    return this.getReferringComponents('grid', SINGLE_REFERRING).models[0];
+  };
+  CartesianAxisModel.type = 'cartesian2dAxis';
+  return CartesianAxisModel;
+}(ComponentModel);
+mixin(CartesianAxisModel, AxisModelCommonMixin);
+
+export { CartesianAxisModel, CartesianAxisModel as default };

package/esm/node_modules/echarts/lib/coord/cartesian/Cartesian.js

@@ -0,0 +1,32 @@
+import { map, filter } from '../../../../zrender/lib/core/util.js';
+
+var Cartesian = /** @class */function () {
+  function Cartesian(name) {
+    this.type = 'cartesian';
+    this._dimList = [];
+    this._axes = {};
+    this.name = name || '';
+  }
+  Cartesian.prototype.getAxis = function (dim) {
+    return this._axes[dim];
+  };
+  Cartesian.prototype.getAxes = function () {
+    return map(this._dimList, function (dim) {
+      return this._axes[dim];
+    }, this);
+  };
+  Cartesian.prototype.getAxesByScale = function (scaleType) {
+    scaleType = scaleType.toLowerCase();
+    return filter(this.getAxes(), function (axis) {
+      return axis.scale.type === scaleType;
+    });
+  };
+  Cartesian.prototype.addAxis = function (axis) {
+    var dim = axis.dim;
+    this._axes[dim] = axis;
+    this._dimList.push(dim);
+  };
+  return Cartesian;
+}();
+
+export { Cartesian as default };

package/esm/node_modules/echarts/lib/coord/cartesian/Cartesian2D.js

@@ -0,0 +1,127 @@
+import { __extends } from 'tslib';
+import BoundingRect from '../../../../zrender/lib/core/BoundingRect.js';
+import Cartesian from './Cartesian.js';
+import { invert } from '../../../../zrender/lib/core/matrix.js';
+import { applyTransform } from '../../../../zrender/lib/core/vector.js';
+
+var cartesian2DDimensions = ['x', 'y'];
+function canCalculateAffineTransform(scale) {
+  return scale.type === 'interval' || scale.type === 'time';
+}
+var Cartesian2D = /** @class */function (_super) {
+  __extends(Cartesian2D, _super);
+  function Cartesian2D() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = 'cartesian2d';
+    _this.dimensions = cartesian2DDimensions;
+    return _this;
+  }
+  /**
+   * Calculate an affine transform matrix if two axes are time or value.
+   * It's mainly for accelartion on the large time series data.
+   */
+  Cartesian2D.prototype.calcAffineTransform = function () {
+    this._transform = this._invTransform = null;
+    var xAxisScale = this.getAxis('x').scale;
+    var yAxisScale = this.getAxis('y').scale;
+    if (!canCalculateAffineTransform(xAxisScale) || !canCalculateAffineTransform(yAxisScale)) {
+      return;
+    }
+    var xScaleExtent = xAxisScale.getExtent();
+    var yScaleExtent = yAxisScale.getExtent();
+    var start = this.dataToPoint([xScaleExtent[0], yScaleExtent[0]]);
+    var end = this.dataToPoint([xScaleExtent[1], yScaleExtent[1]]);
+    var xScaleSpan = xScaleExtent[1] - xScaleExtent[0];
+    var yScaleSpan = yScaleExtent[1] - yScaleExtent[0];
+    if (!xScaleSpan || !yScaleSpan) {
+      return;
+    }
+    // Accelerate data to point calculation on the special large time series data.
+    var scaleX = (end[0] - start[0]) / xScaleSpan;
+    var scaleY = (end[1] - start[1]) / yScaleSpan;
+    var translateX = start[0] - xScaleExtent[0] * scaleX;
+    var translateY = start[1] - yScaleExtent[0] * scaleY;
+    var m = this._transform = [scaleX, 0, 0, scaleY, translateX, translateY];
+    this._invTransform = invert([], m);
+  };
+  /**
+   * Base axis will be used on stacking.
+   */
+  Cartesian2D.prototype.getBaseAxis = function () {
+    return this.getAxesByScale('ordinal')[0] || this.getAxesByScale('time')[0] || this.getAxis('x');
+  };
+  Cartesian2D.prototype.containPoint = function (point) {
+    var axisX = this.getAxis('x');
+    var axisY = this.getAxis('y');
+    return axisX.contain(axisX.toLocalCoord(point[0])) && axisY.contain(axisY.toLocalCoord(point[1]));
+  };
+  Cartesian2D.prototype.containData = function (data) {
+    return this.getAxis('x').containData(data[0]) && this.getAxis('y').containData(data[1]);
+  };
+  Cartesian2D.prototype.containZone = function (data1, data2) {
+    var zoneDiag1 = this.dataToPoint(data1);
+    var zoneDiag2 = this.dataToPoint(data2);
+    var area = this.getArea();
+    var zone = new BoundingRect(zoneDiag1[0], zoneDiag1[1], zoneDiag2[0] - zoneDiag1[0], zoneDiag2[1] - zoneDiag1[1]);
+    return area.intersect(zone);
+  };
+  Cartesian2D.prototype.dataToPoint = function (data, clamp, out) {
+    out = out || [];
+    var xVal = data[0];
+    var yVal = data[1];
+    // Fast path
+    if (this._transform
+    // It's supported that if data is like `[Inifity, 123]`, where only Y pixel calculated.
+    && xVal != null && isFinite(xVal) && yVal != null && isFinite(yVal)) {
+      return applyTransform(out, data, this._transform);
+    }
+    var xAxis = this.getAxis('x');
+    var yAxis = this.getAxis('y');
+    out[0] = xAxis.toGlobalCoord(xAxis.dataToCoord(xVal, clamp));
+    out[1] = yAxis.toGlobalCoord(yAxis.dataToCoord(yVal, clamp));
+    return out;
+  };
+  Cartesian2D.prototype.clampData = function (data, out) {
+    var xScale = this.getAxis('x').scale;
+    var yScale = this.getAxis('y').scale;
+    var xAxisExtent = xScale.getExtent();
+    var yAxisExtent = yScale.getExtent();
+    var x = xScale.parse(data[0]);
+    var y = yScale.parse(data[1]);
+    out = out || [];
+    out[0] = Math.min(Math.max(Math.min(xAxisExtent[0], xAxisExtent[1]), x), Math.max(xAxisExtent[0], xAxisExtent[1]));
+    out[1] = Math.min(Math.max(Math.min(yAxisExtent[0], yAxisExtent[1]), y), Math.max(yAxisExtent[0], yAxisExtent[1]));
+    return out;
+  };
+  Cartesian2D.prototype.pointToData = function (point, clamp) {
+    var out = [];
+    if (this._invTransform) {
+      return applyTransform(out, point, this._invTransform);
+    }
+    var xAxis = this.getAxis('x');
+    var yAxis = this.getAxis('y');
+    out[0] = xAxis.coordToData(xAxis.toLocalCoord(point[0]), clamp);
+    out[1] = yAxis.coordToData(yAxis.toLocalCoord(point[1]), clamp);
+    return out;
+  };
+  Cartesian2D.prototype.getOtherAxis = function (axis) {
+    return this.getAxis(axis.dim === 'x' ? 'y' : 'x');
+  };
+  /**
+   * Get rect area of cartesian.
+   * Area will have a contain function to determine if a point is in the coordinate system.
+   */
+  Cartesian2D.prototype.getArea = function (tolerance) {
+    tolerance = tolerance || 0;
+    var xExtent = this.getAxis('x').getGlobalExtent();
+    var yExtent = this.getAxis('y').getGlobalExtent();
+    var x = Math.min(xExtent[0], xExtent[1]) - tolerance;
+    var y = Math.min(yExtent[0], yExtent[1]) - tolerance;
+    var width = Math.max(xExtent[0], xExtent[1]) - x + tolerance;
+    var height = Math.max(yExtent[0], yExtent[1]) - y + tolerance;
+    return new BoundingRect(x, y, width, height);
+  };
+  return Cartesian2D;
+}(Cartesian);
+
+export { cartesian2DDimensions, Cartesian2D as default };