@fmdevui/fm-dev 1.0.113 → 1.0.115

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/visualMap/visualEncoding.js

@@ -0,0 +1,69 @@
+'use strict';
+
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var visualSolution = require('../../visual/visualSolution.js');
+var VisualMapping = require('../../visual/VisualMapping.js');
+var helper = require('../../visual/helper.js');
+
+var visualMapEncodingHandlers = [{
+  createOnAllSeries: true,
+  reset: function (seriesModel, ecModel) {
+    var resetDefines = [];
+    ecModel.eachComponent('visualMap', function (visualMapModel) {
+      var pipelineContext = seriesModel.pipelineContext;
+      if (!visualMapModel.isTargetSeries(seriesModel) || pipelineContext && pipelineContext.large) {
+        return;
+      }
+      resetDefines.push(visualSolution.incrementalApplyVisual(visualMapModel.stateList, visualMapModel.targetVisuals, util.bind(visualMapModel.getValueState, visualMapModel), visualMapModel.getDataDimensionIndex(seriesModel.getData())));
+    });
+    return resetDefines;
+  }
+},
+// Only support color.
+{
+  createOnAllSeries: true,
+  reset: function (seriesModel, ecModel) {
+    var data = seriesModel.getData();
+    var visualMetaList = [];
+    ecModel.eachComponent('visualMap', function (visualMapModel) {
+      if (visualMapModel.isTargetSeries(seriesModel)) {
+        var visualMeta = visualMapModel.getVisualMeta(util.bind(getColorVisual, null, seriesModel, visualMapModel)) || {
+          stops: [],
+          outerColors: []
+        };
+        var dimIdx = visualMapModel.getDataDimensionIndex(data);
+        if (dimIdx >= 0) {
+          // visualMeta.dimension should be dimension index, but not concrete dimension.
+          visualMeta.dimension = dimIdx;
+          visualMetaList.push(visualMeta);
+        }
+      }
+    });
+    // 
+    seriesModel.getData().setVisual('visualMeta', visualMetaList);
+  }
+}];
+// FIXME
+// performance and export for heatmap?
+// value can be Infinity or -Infinity
+function getColorVisual(seriesModel, visualMapModel, value, valueState) {
+  var mappings = visualMapModel.targetVisuals[valueState];
+  var visualTypes = VisualMapping.default.prepareVisualTypes(mappings);
+  var resultVisual = {
+    color: helper.getVisualFromData(seriesModel.getData(), 'color') // default color.
+  };
+  for (var i = 0, len = visualTypes.length; i < len; i++) {
+    var type = visualTypes[i];
+    var mapping = mappings[type === 'opacity' ? '__alphaForOpacity' : type];
+    mapping && mapping.applyVisual(value, getVisual, setVisual);
+  }
+  return resultVisual.color;
+  function getVisual(key) {
+    return resultVisual[key];
+  }
+  function setVisual(key, value) {
+    resultVisual[key] = value;
+  }
+}
+
+exports.visualMapEncodingHandlers = visualMapEncodingHandlers;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/visualMap/visualMapAction.js

@@ -0,0 +1,61 @@
+'use strict';
+
+/*
+* 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.
+*/
+var visualMapActionInfo = {
+  type: 'selectDataRange',
+  event: 'dataRangeSelected',
+  // FIXME use updateView appears wrong
+  update: 'update'
+};
+var visualMapActionHander = function (payload, ecModel) {
+  ecModel.eachComponent({
+    mainType: 'visualMap',
+    query: payload
+  }, function (model) {
+    model.setSelected(payload.selected);
+  });
+};
+
+exports.visualMapActionHander = visualMapActionHander;
+exports.visualMapActionInfo = visualMapActionInfo;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/Axis.js

@@ -0,0 +1,261 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var number = require('../util/number.js');
+var axisTickLabelBuilder = require('./axisTickLabelBuilder.js');
+
+var NORMALIZED_EXTENT = [0, 1];
+/**
+ * Base class of Axis.
+ *
+ * Lifetime: recreate for each main process.
+ * [NOTICE]: Some caches is stored on the axis instance (see `axisTickLabelBuilder.ts`)
+ *  which is based on this lifetime.
+ */
+var Axis = /** @class */function () {
+  function Axis(dim, scale, extent) {
+    this.onBand = false;
+    // Make sure that `extent[0] > extent[1]` only if `inverse: true`.
+    // `inverse` can be inferred by `extent` unless `extent[0] === extent[1]`.
+    this.inverse = false;
+    this.dim = dim;
+    this.scale = scale;
+    this._extent = extent || [0, 0];
+  }
+  /**
+   * If axis extent contain given coord
+   */
+  Axis.prototype.contain = function (coord) {
+    var extent = this._extent;
+    var min = Math.min(extent[0], extent[1]);
+    var max = Math.max(extent[0], extent[1]);
+    return coord >= min && coord <= max;
+  };
+  /**
+   * If axis extent contain given data
+   */
+  Axis.prototype.containData = function (data) {
+    return this.scale.contain(this.scale.parse(data));
+  };
+  /**
+   * Get coord extent.
+   */
+  Axis.prototype.getExtent = function () {
+    return this._extent.slice();
+  };
+  /**
+   * Get precision used for formatting
+   */
+  Axis.prototype.getPixelPrecision = function (dataExtent) {
+    return number.getPixelPrecision(dataExtent || this.scale.getExtent(), this._extent);
+  };
+  /**
+   * Set coord extent
+   */
+  Axis.prototype.setExtent = function (start, end) {
+    var extent = this._extent;
+    extent[0] = start;
+    extent[1] = end;
+  };
+  /**
+   * Convert data to coord. Data is the rank if it has an ordinal scale
+   */
+  Axis.prototype.dataToCoord = function (data, clamp) {
+    var extent = this._extent;
+    var scale = this.scale;
+    data = scale.normalize(scale.parse(data));
+    if (this.onBand && scale.type === 'ordinal') {
+      extent = extent.slice();
+      fixExtentWithBands(extent, scale.count());
+    }
+    return number.linearMap(data, NORMALIZED_EXTENT, extent, clamp);
+  };
+  /**
+   * Convert coord to data. Data is the rank if it has an ordinal scale
+   */
+  Axis.prototype.coordToData = function (coord, clamp) {
+    var extent = this._extent;
+    var scale = this.scale;
+    if (this.onBand && scale.type === 'ordinal') {
+      extent = extent.slice();
+      fixExtentWithBands(extent, scale.count());
+    }
+    var t = number.linearMap(coord, extent, NORMALIZED_EXTENT, clamp);
+    return this.scale.scale(t);
+  };
+  /**
+   * Convert pixel point to data in axis
+   */
+  Axis.prototype.pointToData = function (point, clamp) {
+    // Should be implemented in derived class if necessary.
+    return;
+  };
+  /**
+   * Different from `zrUtil.map(axis.getTicks(), axis.dataToCoord, axis)`,
+   * `axis.getTicksCoords` considers `onBand`, which is used by
+   * `boundaryGap:true` of category axis and splitLine and splitArea.
+   * @param opt.tickModel default: axis.model.getModel('axisTick')
+   * @param opt.clamp If `true`, the first and the last
+   *        tick must be at the axis end points. Otherwise, clip ticks
+   *        that outside the axis extent.
+   */
+  Axis.prototype.getTicksCoords = function (opt) {
+    opt = opt || {};
+    var tickModel = opt.tickModel || this.getTickModel();
+    var result = axisTickLabelBuilder.createAxisTicks(this, tickModel, {
+      breakTicks: opt.breakTicks,
+      pruneByBreak: opt.pruneByBreak
+    });
+    var ticks = result.ticks;
+    var ticksCoords = util.map(ticks, function (tickVal) {
+      return {
+        coord: this.dataToCoord(this.scale.type === 'ordinal' ? this.scale.getRawOrdinalNumber(tickVal) : tickVal),
+        tickValue: tickVal
+      };
+    }, this);
+    var alignWithLabel = tickModel.get('alignWithLabel');
+    fixOnBandTicksCoords(this, ticksCoords, alignWithLabel, opt.clamp);
+    return ticksCoords;
+  };
+  Axis.prototype.getMinorTicksCoords = function () {
+    if (this.scale.type === 'ordinal') {
+      // Category axis doesn't support minor ticks
+      return [];
+    }
+    var minorTickModel = this.model.getModel('minorTick');
+    var splitNumber = minorTickModel.get('splitNumber');
+    // Protection.
+    if (!(splitNumber > 0 && splitNumber < 100)) {
+      splitNumber = 5;
+    }
+    var minorTicks = this.scale.getMinorTicks(splitNumber);
+    var minorTicksCoords = util.map(minorTicks, function (minorTicksGroup) {
+      return util.map(minorTicksGroup, function (minorTick) {
+        return {
+          coord: this.dataToCoord(minorTick),
+          tickValue: minorTick
+        };
+      }, this);
+    }, this);
+    return minorTicksCoords;
+  };
+  Axis.prototype.getViewLabels = function (ctx) {
+    ctx = ctx || axisTickLabelBuilder.createAxisLabelsComputingContext(axisTickLabelBuilder.AxisTickLabelComputingKind.determine);
+    return axisTickLabelBuilder.createAxisLabels(this, ctx).labels;
+  };
+  Axis.prototype.getLabelModel = function () {
+    return this.model.getModel('axisLabel');
+  };
+  /**
+   * Notice here we only get the default tick model. For splitLine
+   * or splitArea, we should pass the splitLineModel or splitAreaModel
+   * manually when calling `getTicksCoords`.
+   * In GL, this method may be overridden to:
+   * `axisModel.getModel('axisTick', grid3DModel.getModel('axisTick'));`
+   */
+  Axis.prototype.getTickModel = function () {
+    return this.model.getModel('axisTick');
+  };
+  /**
+   * Get width of band
+   */
+  Axis.prototype.getBandWidth = function () {
+    var axisExtent = this._extent;
+    var dataExtent = this.scale.getExtent();
+    var len = dataExtent[1] - dataExtent[0] + (this.onBand ? 1 : 0);
+    // Fix #2728, avoid NaN when only one data.
+    len === 0 && (len = 1);
+    var size = Math.abs(axisExtent[1] - axisExtent[0]);
+    return Math.abs(size) / len;
+  };
+  /**
+   * Only be called in category axis.
+   * Can be overridden, consider other axes like in 3D.
+   * @return Auto interval for cateogry axis tick and label
+   */
+  Axis.prototype.calculateCategoryInterval = function (ctx) {
+    ctx = ctx || axisTickLabelBuilder.createAxisLabelsComputingContext(axisTickLabelBuilder.AxisTickLabelComputingKind.determine);
+    return axisTickLabelBuilder.calculateCategoryInterval(this, ctx);
+  };
+  return Axis;
+}();
+function fixExtentWithBands(extent, nTick) {
+  var size = extent[1] - extent[0];
+  var len = nTick;
+  var margin = size / len / 2;
+  extent[0] += margin;
+  extent[1] -= margin;
+}
+// If axis has labels [1, 2, 3, 4]. Bands on the axis are
+// |---1---|---2---|---3---|---4---|.
+// So the displayed ticks and splitLine/splitArea should between
+// each data item, otherwise cause misleading (e.g., split tow bars
+// of a single data item when there are two bar series).
+// Also consider if tickCategoryInterval > 0 and onBand, ticks and
+// splitLine/spliteArea should layout appropriately corresponding
+// to displayed labels. (So we should not use `getBandWidth` in this
+// case).
+function fixOnBandTicksCoords(axis, ticksCoords, alignWithLabel, clamp) {
+  var ticksLen = ticksCoords.length;
+  if (!axis.onBand || alignWithLabel || !ticksLen) {
+    return;
+  }
+  var axisExtent = axis.getExtent();
+  var last;
+  var diffSize;
+  if (ticksLen === 1) {
+    ticksCoords[0].coord = axisExtent[0];
+    ticksCoords[0].onBand = true;
+    last = ticksCoords[1] = {
+      coord: axisExtent[1],
+      tickValue: ticksCoords[0].tickValue,
+      onBand: true
+    };
+  } else {
+    var crossLen = ticksCoords[ticksLen - 1].tickValue - ticksCoords[0].tickValue;
+    var shift_1 = (ticksCoords[ticksLen - 1].coord - ticksCoords[0].coord) / crossLen;
+    util.each(ticksCoords, function (ticksItem) {
+      ticksItem.coord -= shift_1 / 2;
+      ticksItem.onBand = true;
+    });
+    var dataExtent = axis.scale.getExtent();
+    diffSize = 1 + dataExtent[1] - ticksCoords[ticksLen - 1].tickValue;
+    last = {
+      coord: ticksCoords[ticksLen - 1].coord + shift_1 * diffSize,
+      tickValue: dataExtent[1] + 1,
+      onBand: true
+    };
+    ticksCoords.push(last);
+  }
+  var inverse = axisExtent[0] > axisExtent[1];
+  // Handling clamp.
+  if (littleThan(ticksCoords[0].coord, axisExtent[0])) {
+    clamp ? ticksCoords[0].coord = axisExtent[0] : ticksCoords.shift();
+  }
+  if (clamp && littleThan(axisExtent[0], ticksCoords[0].coord)) {
+    ticksCoords.unshift({
+      coord: axisExtent[0],
+      onBand: true
+    });
+  }
+  if (littleThan(axisExtent[1], last.coord)) {
+    clamp ? last.coord = axisExtent[1] : ticksCoords.pop();
+  }
+  if (clamp && littleThan(last.coord, axisExtent[1])) {
+    ticksCoords.push({
+      coord: axisExtent[1],
+      onBand: true
+    });
+  }
+  function littleThan(a, b) {
+    // Avoid rounding error cause calculated tick coord different with extent.
+    // It may cause an extra unnecessary tick added.
+    a = number.round(a);
+    b = number.round(b);
+    return inverse ? a > b : a < b;
+  }
+}
+
+exports.default = Axis;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/CoordinateSystem.js

@@ -0,0 +1,49 @@
+'use strict';
+
+/*
+* 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 isCoordinateSystemType(coordSys, type) {
+  return coordSys.type === type;
+}
+
+exports.isCoordinateSystemType = isCoordinateSystemType;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/View.js

@@ -0,0 +1,221 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js');
+var vector = require('../../../../../zrender@6.0.0/node_modules/zrender/lib/core/vector.js');
+var matrix = require('../../../../../zrender@6.0.0/node_modules/zrender/lib/core/matrix.js');
+var BoundingRect = require('../../../../../zrender@6.0.0/node_modules/zrender/lib/core/BoundingRect.js');
+var Transformable = require('../../../../../zrender@6.0.0/node_modules/zrender/lib/core/Transformable.js');
+var number = require('../util/number.js');
+var util = require('../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var roamHelper = require('../component/helper/roamHelper.js');
+
+var v2ApplyTransform = vector.applyTransform;
+var View = /** @class */function (_super) {
+  tslib_es6.__extends(View, _super);
+  function View(name, opt) {
+    var _this = _super.call(this) || this;
+    _this.type = 'view';
+    _this.dimensions = ['x', 'y'];
+    /**
+     * Represents the transform brought by roam/zoom.
+     * If `View['_viewRect']` applies roam transform,
+     * we can get the final displayed rect.
+     */
+    _this._roamTransformable = new Transformable.default();
+    /**
+     * Represents the transform from `View['_rect']` to `View['_viewRect']`.
+     */
+    _this._rawTransformable = new Transformable.default();
+    _this.name = name;
+    _this._opt = opt;
+    return _this;
+  }
+  View.prototype.setBoundingRect = function (x, y, width, height) {
+    this._rect = new BoundingRect.default(x, y, width, height);
+    this._updateCenterAndZoom();
+    return this._rect;
+  };
+  View.prototype.getBoundingRect = function () {
+    return this._rect;
+  };
+  /**
+   * If no need to transform `View['_rect']` to `View['_viewRect']`, the calling of
+   * `setViewRect` can be omitted.
+   */
+  View.prototype.setViewRect = function (x, y, width, height) {
+    this._transformTo(x, y, width, height);
+    this._viewRect = new BoundingRect.default(x, y, width, height);
+  };
+  /**
+   * Transformed to particular position and size
+   */
+  View.prototype._transformTo = function (x, y, width, height) {
+    var rect = this.getBoundingRect();
+    var rawTransform = this._rawTransformable;
+    rawTransform.transform = rect.calculateTransform(new BoundingRect.default(x, y, width, height));
+    var rawParent = rawTransform.parent;
+    rawTransform.parent = null;
+    rawTransform.decomposeTransform();
+    rawTransform.parent = rawParent;
+    this._updateTransform();
+  };
+  /**
+   * [NOTICE]
+   *  The definition of this center has always been irrelevant to some other series center like
+   *  'series-pie.center' - this center is a point on the same coord sys as `View['_rect'].x/y`,
+   *  rather than canvas viewport, and the unit is not necessarily pixel (e.g., in geo case).
+   *  @see {View['_center']} for details.
+   */
+  View.prototype.setCenter = function (centerCoord) {
+    // #16904 introcuded percentage string here, such as '33%'. But it was based on canvas
+    // width/height, which is not reasonable - the unit may incorrect, and it is unpredictable if
+    // the `View['_rect']` is not calculated based on the current canvas rect. Therefore the percentage
+    // value is changed to based on `View['_rect'].width/height` since v6. Under this definition, users
+    // can use '0%' to map the top-left of `View['_rect']` to the center of `View['_viewRect']`.
+    var opt = this._opt;
+    if (opt && opt.api && opt.ecModel && opt.ecModel.getShallow('legacyViewCoordSysCenterBase') && centerCoord) {
+      centerCoord = [number.parsePercent(centerCoord[0], opt.api.getWidth()), number.parsePercent(centerCoord[1], opt.api.getWidth())];
+    }
+    this._centerOption = util.clone(centerCoord);
+    this._updateCenterAndZoom();
+  };
+  View.prototype.setZoom = function (zoom) {
+    this._zoom = roamHelper.clampByZoomLimit(zoom || 1, this.zoomLimit);
+    this._updateCenterAndZoom();
+  };
+  /**
+   * Get default center without roam
+   */
+  View.prototype.getDefaultCenter = function () {
+    // Rect before any transform
+    var rawRect = this.getBoundingRect();
+    var cx = rawRect.x + rawRect.width / 2;
+    var cy = rawRect.y + rawRect.height / 2;
+    return [cx, cy];
+  };
+  View.prototype.getCenter = function () {
+    return this._center || this.getDefaultCenter();
+  };
+  View.prototype.getZoom = function () {
+    return this._zoom || 1;
+  };
+  View.prototype.getRoamTransform = function () {
+    return this._roamTransformable.getLocalTransform();
+  };
+  /**
+   * Ensure this method is idempotent, since it should be called when
+   * every relevant prop (e.g. _centerOption/_zoom/_rect/_viewRect) changed.
+   */
+  View.prototype._updateCenterAndZoom = function () {
+    var centerOption = this._centerOption;
+    var rect = this._rect;
+    if (centerOption && rect) {
+      this._center = [number.parsePercent(centerOption[0], rect.width, rect.x), number.parsePercent(centerOption[1], rect.height, rect.y)];
+    }
+    // Must update after view transform updated
+    var rawTransformMatrix = this._rawTransformable.getLocalTransform();
+    var roamTransform = this._roamTransformable;
+    var defaultCenter = this.getDefaultCenter();
+    var center = this.getCenter();
+    var zoom = this.getZoom();
+    center = vector.applyTransform([], center, rawTransformMatrix);
+    defaultCenter = vector.applyTransform([], defaultCenter, rawTransformMatrix);
+    roamTransform.originX = center[0];
+    roamTransform.originY = center[1];
+    roamTransform.x = defaultCenter[0] - center[0];
+    roamTransform.y = defaultCenter[1] - center[1];
+    roamTransform.scaleX = roamTransform.scaleY = zoom;
+    this._updateTransform();
+  };
+  /**
+   * Update transform props on `this` based on the current
+   * `this._roamTransformable` and `this._rawTransformable`.
+   */
+  View.prototype._updateTransform = function () {
+    var roamTransformable = this._roamTransformable;
+    var rawTransformable = this._rawTransformable;
+    rawTransformable.parent = roamTransformable;
+    roamTransformable.updateTransform();
+    rawTransformable.updateTransform();
+    matrix.copy(this.transform || (this.transform = []), rawTransformable.transform || matrix.create());
+    this._rawTransform = rawTransformable.getLocalTransform();
+    this.invTransform = this.invTransform || [];
+    matrix.invert(this.invTransform, this.transform);
+    this.decomposeTransform();
+  };
+  View.prototype.getTransformInfo = function () {
+    var rawTransformable = this._rawTransformable;
+    var roamTransformable = this._roamTransformable;
+    // Because roamTransformabel has `originX/originY` modified,
+    // but the caller of `getTransformInfo` can not handle `originX/originY`,
+    // so need to recalculate them.
+    var dummyTransformable = new Transformable.default();
+    dummyTransformable.transform = roamTransformable.transform;
+    dummyTransformable.decomposeTransform();
+    return {
+      roam: {
+        x: dummyTransformable.x,
+        y: dummyTransformable.y,
+        scaleX: dummyTransformable.scaleX,
+        scaleY: dummyTransformable.scaleY
+      },
+      raw: {
+        x: rawTransformable.x,
+        y: rawTransformable.y,
+        scaleX: rawTransformable.scaleX,
+        scaleY: rawTransformable.scaleY
+      }
+    };
+  };
+  View.prototype.getViewRect = function () {
+    return this._viewRect;
+  };
+  /**
+   * Get view rect after roam transform
+   */
+  View.prototype.getViewRectAfterRoam = function () {
+    var rect = this.getBoundingRect().clone();
+    rect.applyTransform(this.transform);
+    return rect;
+  };
+  /**
+   * Convert a single (lon, lat) data item to (x, y) point.
+   */
+  View.prototype.dataToPoint = function (data, noRoam, out) {
+    var transform = noRoam ? this._rawTransform : this.transform;
+    out = out || [];
+    return transform ? v2ApplyTransform(out, data, transform) : vector.copy(out, data);
+  };
+  /**
+   * Convert a (x, y) point to (lon, lat) data
+   */
+  View.prototype.pointToData = function (point, reserved, out) {
+    out = out || [];
+    var invTransform = this.invTransform;
+    return invTransform ? v2ApplyTransform(out, point, invTransform) : (out[0] = point[0], out[1] = point[1], out);
+  };
+  View.prototype.convertToPixel = function (ecModel, finder, value) {
+    var coordSys = getCoordSys(finder);
+    return coordSys === this ? coordSys.dataToPoint(value) : null;
+  };
+  View.prototype.convertFromPixel = function (ecModel, finder, pixel) {
+    var coordSys = getCoordSys(finder);
+    return coordSys === this ? coordSys.pointToData(pixel) : null;
+  };
+  /**
+   * @implements
+   */
+  View.prototype.containPoint = function (point) {
+    return this.getViewRectAfterRoam().contain(point[0], point[1]);
+  };
+  View.dimensions = ['x', 'y'];
+  return View;
+}(Transformable.default);
+function getCoordSys(finder) {
+  var seriesModel = finder.seriesModel;
+  return seriesModel ? seriesModel.coordinateSystem : null; // e.g., graph.
+}
+
+exports.default = View;