office-viewer 0.3.11 → 0.3.13

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

@@ -0,0 +1,132 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var BoundingRect = require('../../../../zrender/lib/core/BoundingRect.js');
+var Cartesian = require('./Cartesian.js');
+var matrix = require('../../../../zrender/lib/core/matrix.js');
+var vector = require('../../../../zrender/lib/core/vector.js');
+
+var cartesian2DDimensions = ['x', 'y'];
+function canCalculateAffineTransform(scale) {
+  return scale.type === 'interval' || scale.type === 'time';
+}
+var Cartesian2D = /** @class */function (_super) {
+  tslib.__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 = matrix.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["default"](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 vector.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 vector.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["default"](x, y, width, height);
+  };
+  return Cartesian2D;
+}(Cartesian["default"]);
+
+exports.cartesian2DDimensions = cartesian2DDimensions;
+exports["default"] = Cartesian2D;

package/lib/node_modules/echarts/lib/coord/cartesian/Grid.js

@@ -0,0 +1,450 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../zrender/lib/core/util.js');
+var layout = require('../../util/layout.js');
+var axisHelper = require('../axisHelper.js');
+var Cartesian2D = require('./Cartesian2D.js');
+var Axis2D = require('./Axis2D.js');
+var model = require('../../util/model.js');
+var cartesianAxisHelper = require('./cartesianAxisHelper.js');
+var helper = require('../../scale/helper.js');
+var axisAlignTicks = require('../axisAlignTicks.js');
+
+var Grid = /** @class */function () {
+  function Grid(gridModel, ecModel, api) {
+    // FIXME:TS where used (different from registered type 'cartesian2d')?
+    this.type = 'grid';
+    this._coordsMap = {};
+    this._coordsList = [];
+    this._axesMap = {};
+    this._axesList = [];
+    this.axisPointerEnabled = true;
+    this.dimensions = Cartesian2D.cartesian2DDimensions;
+    this._initCartesian(gridModel, ecModel, api);
+    this.model = gridModel;
+  }
+  Grid.prototype.getRect = function () {
+    return this._rect;
+  };
+  Grid.prototype.update = function (ecModel, api) {
+    var axesMap = this._axesMap;
+    this._updateScale(ecModel, this.model);
+    function updateAxisTicks(axes) {
+      var alignTo;
+      // Axis is added in order of axisIndex.
+      var axesIndices = util.keys(axes);
+      var len = axesIndices.length;
+      if (!len) {
+        return;
+      }
+      var axisNeedsAlign = [];
+      // Process once and calculate the ticks for those don't use alignTicks.
+      for (var i = len - 1; i >= 0; i--) {
+        var idx = +axesIndices[i]; // Convert to number.
+        var axis = axes[idx];
+        var model = axis.model;
+        var scale = axis.scale;
+        if (
+        // Only value and log axis without interval support alignTicks.
+        helper.isIntervalOrLogScale(scale) && model.get('alignTicks') && model.get('interval') == null) {
+          axisNeedsAlign.push(axis);
+        } else {
+          axisHelper.niceScaleExtent(scale, model);
+          if (helper.isIntervalOrLogScale(scale)) {
+            // Can only align to interval or log axis.
+            alignTo = axis;
+          }
+        }
+      }
+      // All axes has set alignTicks. Pick the first one.
+      // PENDING. Should we find the axis that both set interval, min, max and align to this one?
+      if (axisNeedsAlign.length) {
+        if (!alignTo) {
+          alignTo = axisNeedsAlign.pop();
+          axisHelper.niceScaleExtent(alignTo.scale, alignTo.model);
+        }
+        util.each(axisNeedsAlign, function (axis) {
+          axisAlignTicks.alignScaleTicks(axis.scale, axis.model, alignTo.scale);
+        });
+      }
+    }
+    updateAxisTicks(axesMap.x);
+    updateAxisTicks(axesMap.y);
+    // Key: axisDim_axisIndex, value: boolean, whether onZero target.
+    var onZeroRecords = {};
+    util.each(axesMap.x, function (xAxis) {
+      fixAxisOnZero(axesMap, 'y', xAxis, onZeroRecords);
+    });
+    util.each(axesMap.y, function (yAxis) {
+      fixAxisOnZero(axesMap, 'x', yAxis, onZeroRecords);
+    });
+    // Resize again if containLabel is enabled
+    // FIXME It may cause getting wrong grid size in data processing stage
+    this.resize(this.model, api);
+  };
+  /**
+   * Resize the grid
+   */
+  Grid.prototype.resize = function (gridModel, api, ignoreContainLabel) {
+    var boxLayoutParams = gridModel.getBoxLayoutParams();
+    var isContainLabel = !ignoreContainLabel && gridModel.get('containLabel');
+    var gridRect = layout.getLayoutRect(boxLayoutParams, {
+      width: api.getWidth(),
+      height: api.getHeight()
+    });
+    this._rect = gridRect;
+    var axesList = this._axesList;
+    adjustAxes();
+    // Minus label size
+    if (isContainLabel) {
+      util.each(axesList, function (axis) {
+        if (!axis.model.get(['axisLabel', 'inside'])) {
+          var labelUnionRect = axisHelper.estimateLabelUnionRect(axis);
+          if (labelUnionRect) {
+            var dim = axis.isHorizontal() ? 'height' : 'width';
+            var margin = axis.model.get(['axisLabel', 'margin']);
+            gridRect[dim] -= labelUnionRect[dim] + margin;
+            if (axis.position === 'top') {
+              gridRect.y += labelUnionRect.height + margin;
+            } else if (axis.position === 'left') {
+              gridRect.x += labelUnionRect.width + margin;
+            }
+          }
+        }
+      });
+      adjustAxes();
+    }
+    util.each(this._coordsList, function (coord) {
+      // Calculate affine matrix to accelerate the data to point transform.
+      // If all the axes scales are time or value.
+      coord.calcAffineTransform();
+    });
+    function adjustAxes() {
+      util.each(axesList, function (axis) {
+        var isHorizontal = axis.isHorizontal();
+        var extent = isHorizontal ? [0, gridRect.width] : [0, gridRect.height];
+        var idx = axis.inverse ? 1 : 0;
+        axis.setExtent(extent[idx], extent[1 - idx]);
+        updateAxisTransform(axis, isHorizontal ? gridRect.x : gridRect.y);
+      });
+    }
+  };
+  Grid.prototype.getAxis = function (dim, axisIndex) {
+    var axesMapOnDim = this._axesMap[dim];
+    if (axesMapOnDim != null) {
+      return axesMapOnDim[axisIndex || 0];
+    }
+  };
+  Grid.prototype.getAxes = function () {
+    return this._axesList.slice();
+  };
+  Grid.prototype.getCartesian = function (xAxisIndex, yAxisIndex) {
+    if (xAxisIndex != null && yAxisIndex != null) {
+      var key = 'x' + xAxisIndex + 'y' + yAxisIndex;
+      return this._coordsMap[key];
+    }
+    if (util.isObject(xAxisIndex)) {
+      yAxisIndex = xAxisIndex.yAxisIndex;
+      xAxisIndex = xAxisIndex.xAxisIndex;
+    }
+    for (var i = 0, coordList = this._coordsList; i < coordList.length; i++) {
+      if (coordList[i].getAxis('x').index === xAxisIndex || coordList[i].getAxis('y').index === yAxisIndex) {
+        return coordList[i];
+      }
+    }
+  };
+  Grid.prototype.getCartesians = function () {
+    return this._coordsList.slice();
+  };
+  /**
+   * @implements
+   */
+  Grid.prototype.convertToPixel = function (ecModel, finder, value) {
+    var target = this._findConvertTarget(finder);
+    return target.cartesian ? target.cartesian.dataToPoint(value) : target.axis ? target.axis.toGlobalCoord(target.axis.dataToCoord(value)) : null;
+  };
+  /**
+   * @implements
+   */
+  Grid.prototype.convertFromPixel = function (ecModel, finder, value) {
+    var target = this._findConvertTarget(finder);
+    return target.cartesian ? target.cartesian.pointToData(value) : target.axis ? target.axis.coordToData(target.axis.toLocalCoord(value)) : null;
+  };
+  Grid.prototype._findConvertTarget = function (finder) {
+    var seriesModel = finder.seriesModel;
+    var xAxisModel = finder.xAxisModel || seriesModel && seriesModel.getReferringComponents('xAxis', model.SINGLE_REFERRING).models[0];
+    var yAxisModel = finder.yAxisModel || seriesModel && seriesModel.getReferringComponents('yAxis', model.SINGLE_REFERRING).models[0];
+    var gridModel = finder.gridModel;
+    var coordsList = this._coordsList;
+    var cartesian;
+    var axis;
+    if (seriesModel) {
+      cartesian = seriesModel.coordinateSystem;
+      util.indexOf(coordsList, cartesian) < 0 && (cartesian = null);
+    } else if (xAxisModel && yAxisModel) {
+      cartesian = this.getCartesian(xAxisModel.componentIndex, yAxisModel.componentIndex);
+    } else if (xAxisModel) {
+      axis = this.getAxis('x', xAxisModel.componentIndex);
+    } else if (yAxisModel) {
+      axis = this.getAxis('y', yAxisModel.componentIndex);
+    }
+    // Lowest priority.
+    else if (gridModel) {
+      var grid = gridModel.coordinateSystem;
+      if (grid === this) {
+        cartesian = this._coordsList[0];
+      }
+    }
+    return {
+      cartesian: cartesian,
+      axis: axis
+    };
+  };
+  /**
+   * @implements
+   */
+  Grid.prototype.containPoint = function (point) {
+    var coord = this._coordsList[0];
+    if (coord) {
+      return coord.containPoint(point);
+    }
+  };
+  /**
+   * Initialize cartesian coordinate systems
+   */
+  Grid.prototype._initCartesian = function (gridModel, ecModel, api) {
+    var _this = this;
+    var grid = this;
+    var axisPositionUsed = {
+      left: false,
+      right: false,
+      top: false,
+      bottom: false
+    };
+    var axesMap = {
+      x: {},
+      y: {}
+    };
+    var axesCount = {
+      x: 0,
+      y: 0
+    };
+    // Create axis
+    ecModel.eachComponent('xAxis', createAxisCreator('x'), this);
+    ecModel.eachComponent('yAxis', createAxisCreator('y'), this);
+    if (!axesCount.x || !axesCount.y) {
+      // Roll back when there no either x or y axis
+      this._axesMap = {};
+      this._axesList = [];
+      return;
+    }
+    this._axesMap = axesMap;
+    // Create cartesian2d
+    util.each(axesMap.x, function (xAxis, xAxisIndex) {
+      util.each(axesMap.y, function (yAxis, yAxisIndex) {
+        var key = 'x' + xAxisIndex + 'y' + yAxisIndex;
+        var cartesian = new Cartesian2D["default"](key);
+        cartesian.master = _this;
+        cartesian.model = gridModel;
+        _this._coordsMap[key] = cartesian;
+        _this._coordsList.push(cartesian);
+        cartesian.addAxis(xAxis);
+        cartesian.addAxis(yAxis);
+      });
+    });
+    function createAxisCreator(dimName) {
+      return function (axisModel, idx) {
+        if (!isAxisUsedInTheGrid(axisModel, gridModel)) {
+          return;
+        }
+        var axisPosition = axisModel.get('position');
+        if (dimName === 'x') {
+          // Fix position
+          if (axisPosition !== 'top' && axisPosition !== 'bottom') {
+            // Default bottom of X
+            axisPosition = axisPositionUsed.bottom ? 'top' : 'bottom';
+          }
+        } else {
+          // Fix position
+          if (axisPosition !== 'left' && axisPosition !== 'right') {
+            // Default left of Y
+            axisPosition = axisPositionUsed.left ? 'right' : 'left';
+          }
+        }
+        axisPositionUsed[axisPosition] = true;
+        var axis = new Axis2D["default"](dimName, axisHelper.createScaleByModel(axisModel), [0, 0], axisModel.get('type'), axisPosition);
+        var isCategory = axis.type === 'category';
+        axis.onBand = isCategory && axisModel.get('boundaryGap');
+        axis.inverse = axisModel.get('inverse');
+        // Inject axis into axisModel
+        axisModel.axis = axis;
+        // Inject axisModel into axis
+        axis.model = axisModel;
+        // Inject grid info axis
+        axis.grid = grid;
+        // Index of axis, can be used as key
+        axis.index = idx;
+        grid._axesList.push(axis);
+        axesMap[dimName][idx] = axis;
+        axesCount[dimName]++;
+      };
+    }
+  };
+  /**
+   * Update cartesian properties from series.
+   */
+  Grid.prototype._updateScale = function (ecModel, gridModel) {
+    // Reset scale
+    util.each(this._axesList, function (axis) {
+      axis.scale.setExtent(Infinity, -Infinity);
+      if (axis.type === 'category') {
+        var categorySortInfo = axis.model.get('categorySortInfo');
+        axis.scale.setSortInfo(categorySortInfo);
+      }
+    });
+    ecModel.eachSeries(function (seriesModel) {
+      if (cartesianAxisHelper.isCartesian2DSeries(seriesModel)) {
+        var axesModelMap = cartesianAxisHelper.findAxisModels(seriesModel);
+        var xAxisModel = axesModelMap.xAxisModel;
+        var yAxisModel = axesModelMap.yAxisModel;
+        if (!isAxisUsedInTheGrid(xAxisModel, gridModel) || !isAxisUsedInTheGrid(yAxisModel, gridModel)) {
+          return;
+        }
+        var cartesian = this.getCartesian(xAxisModel.componentIndex, yAxisModel.componentIndex);
+        var data = seriesModel.getData();
+        var xAxis = cartesian.getAxis('x');
+        var yAxis = cartesian.getAxis('y');
+        unionExtent(data, xAxis);
+        unionExtent(data, yAxis);
+      }
+    }, this);
+    function unionExtent(data, axis) {
+      util.each(axisHelper.getDataDimensionsOnAxis(data, axis.dim), function (dim) {
+        axis.scale.unionExtentFromData(data, dim);
+      });
+    }
+  };
+  /**
+   * @param dim 'x' or 'y' or 'auto' or null/undefined
+   */
+  Grid.prototype.getTooltipAxes = function (dim) {
+    var baseAxes = [];
+    var otherAxes = [];
+    util.each(this.getCartesians(), function (cartesian) {
+      var baseAxis = dim != null && dim !== 'auto' ? cartesian.getAxis(dim) : cartesian.getBaseAxis();
+      var otherAxis = cartesian.getOtherAxis(baseAxis);
+      util.indexOf(baseAxes, baseAxis) < 0 && baseAxes.push(baseAxis);
+      util.indexOf(otherAxes, otherAxis) < 0 && otherAxes.push(otherAxis);
+    });
+    return {
+      baseAxes: baseAxes,
+      otherAxes: otherAxes
+    };
+  };
+  Grid.create = function (ecModel, api) {
+    var grids = [];
+    ecModel.eachComponent('grid', function (gridModel, idx) {
+      var grid = new Grid(gridModel, ecModel, api);
+      grid.name = 'grid_' + idx;
+      // dataSampling requires axis extent, so resize
+      // should be performed in create stage.
+      grid.resize(gridModel, api, true);
+      gridModel.coordinateSystem = grid;
+      grids.push(grid);
+    });
+    // Inject the coordinateSystems into seriesModel
+    ecModel.eachSeries(function (seriesModel) {
+      if (!cartesianAxisHelper.isCartesian2DSeries(seriesModel)) {
+        return;
+      }
+      var axesModelMap = cartesianAxisHelper.findAxisModels(seriesModel);
+      var xAxisModel = axesModelMap.xAxisModel;
+      var yAxisModel = axesModelMap.yAxisModel;
+      var gridModel = xAxisModel.getCoordSysModel();
+      if (process.env.NODE_ENV !== 'production') {
+        if (!gridModel) {
+          throw new Error('Grid "' + util.retrieve3(xAxisModel.get('gridIndex'), xAxisModel.get('gridId'), 0) + '" not found');
+        }
+        if (xAxisModel.getCoordSysModel() !== yAxisModel.getCoordSysModel()) {
+          throw new Error('xAxis and yAxis must use the same grid');
+        }
+      }
+      var grid = gridModel.coordinateSystem;
+      seriesModel.coordinateSystem = grid.getCartesian(xAxisModel.componentIndex, yAxisModel.componentIndex);
+    });
+    return grids;
+  };
+  // For deciding which dimensions to use when creating list data
+  Grid.dimensions = Cartesian2D.cartesian2DDimensions;
+  return Grid;
+}();
+/**
+ * Check if the axis is used in the specified grid.
+ */
+function isAxisUsedInTheGrid(axisModel, gridModel) {
+  return axisModel.getCoordSysModel() === gridModel;
+}
+function fixAxisOnZero(axesMap, otherAxisDim, axis,
+// Key: see `getOnZeroRecordKey`
+onZeroRecords) {
+  axis.getAxesOnZeroOf = function () {
+    // TODO: onZero of multiple axes.
+    return otherAxisOnZeroOf ? [otherAxisOnZeroOf] : [];
+  };
+  // onZero can not be enabled in these two situations:
+  // 1. When any other axis is a category axis.
+  // 2. When no axis is cross 0 point.
+  var otherAxes = axesMap[otherAxisDim];
+  var otherAxisOnZeroOf;
+  var axisModel = axis.model;
+  var onZero = axisModel.get(['axisLine', 'onZero']);
+  var onZeroAxisIndex = axisModel.get(['axisLine', 'onZeroAxisIndex']);
+  if (!onZero) {
+    return;
+  }
+  // If target axis is specified.
+  if (onZeroAxisIndex != null) {
+    if (canOnZeroToAxis(otherAxes[onZeroAxisIndex])) {
+      otherAxisOnZeroOf = otherAxes[onZeroAxisIndex];
+    }
+  } else {
+    // Find the first available other axis.
+    for (var idx in otherAxes) {
+      if (otherAxes.hasOwnProperty(idx) && canOnZeroToAxis(otherAxes[idx])
+      // Consider that two Y axes on one value axis,
+      // if both onZero, the two Y axes overlap.
+      && !onZeroRecords[getOnZeroRecordKey(otherAxes[idx])]) {
+        otherAxisOnZeroOf = otherAxes[idx];
+        break;
+      }
+    }
+  }
+  if (otherAxisOnZeroOf) {
+    onZeroRecords[getOnZeroRecordKey(otherAxisOnZeroOf)] = true;
+  }
+  function getOnZeroRecordKey(axis) {
+    return axis.dim + '_' + axis.index;
+  }
+}
+function canOnZeroToAxis(axis) {
+  return axis && axis.type !== 'category' && axis.type !== 'time' && axisHelper.ifAxisCrossZero(axis);
+}
+function updateAxisTransform(axis, coordBase) {
+  var axisExtent = axis.getExtent();
+  var axisExtentSum = axisExtent[0] + axisExtent[1];
+  // Fast transform
+  axis.toGlobalCoord = axis.dim === 'x' ? function (coord) {
+    return coord + coordBase;
+  } : function (coord) {
+    return axisExtentSum - coord + coordBase;
+  };
+  axis.toLocalCoord = axis.dim === 'x' ? function (coord) {
+    return coord - coordBase;
+  } : function (coord) {
+    return axisExtentSum - coord + coordBase;
+  };
+}
+
+exports["default"] = Grid;

package/lib/node_modules/echarts/lib/coord/cartesian/GridModel.js

@@ -0,0 +1,35 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var Component = require('../../model/Component.js');
+
+var GridModel = /** @class */function (_super) {
+  tslib.__extends(GridModel, _super);
+  function GridModel() {
+    return _super !== null && _super.apply(this, arguments) || this;
+  }
+  GridModel.type = 'grid';
+  GridModel.dependencies = ['xAxis', 'yAxis'];
+  GridModel.layoutMode = 'box';
+  GridModel.defaultOption = {
+    show: false,
+    // zlevel: 0,
+    z: 0,
+    left: '10%',
+    top: 60,
+    right: '10%',
+    bottom: 70,
+    // If grid size contain label
+    containLabel: false,
+    // width: {totalWidth} - left - right,
+    // height: {totalHeight} - top - bottom,
+    backgroundColor: 'rgba(0,0,0,0)',
+    borderWidth: 1,
+    borderColor: '#ccc'
+  };
+  return GridModel;
+}(Component["default"]);
+
+exports["default"] = GridModel;