suoqiu-f2/lib/geom/base.js

Charts for mobile visualization.

"use strict";

exports.__esModule = true;
exports["default"] = void 0;
var Attr = _interopRequireWildcard(require("../attr/index"));
var _common = require("../util/common");
var _base = _interopRequireDefault(require("../base"));
var _global = _interopRequireWildcard(require("../global"));
var _shape = _interopRequireDefault(require("./shape/shape"));
var _base2 = _interopRequireDefault(require("@antv/adjust/lib/base"));
var _util = require("./aria/util");
function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
function _inheritsLoose(t, o) { t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o); }
function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
var GROUP_ATTRS = ['color', 'size', 'shape'];
var FIELD_ORIGIN = '_origin';
var FIELD_ORIGIN_Y = '_originY';
function parseFields(field) {
  if ((0, _common.isArray)(field)) {
    return field;
  }
  if ((0, _common.isString)(field)) {
    return field.split('*');
  }
  return [field];
}

/**
 * The parent class for Geometry
 * @class Geom
 */
var Geom = /*#__PURE__*/function (_Base) {
  function Geom() {
    return _Base.apply(this, arguments) || this;
  }
  _inheritsLoose(Geom, _Base);
  var _proto = Geom.prototype;
  _proto.getDefaultCfg = function getDefaultCfg() {
    return {
      /**
       * geometry type
       * @type {String}
       */
      type: null,
      /**
       * the data of geometry
       * @type {Array}
       */
      data: null,
      /**
       * the attrs of geo,etry
       * @type {Object}
       */
      attrs: {},
      scales: {},
      /**
       * group for storing the shapes
       * @type {Canvas}
       */
      container: null,
      /**
       * style options
       * @type {Object}
       */
      styleOptions: null,
      chart: null,
      shapeType: '',
      /**
       * wether to generate key points for each shape
       * @protected
       * @type {Boolean}
       */
      generatePoints: false,
      attrOptions: {},
      sortable: false,
      startOnZero: true,
      visible: true,
      connectNulls: false,
      // 是否丢弃没有值的分组。
      ignoreEmptyGroup: false,
      // 是否已经初始化
      isInit: false
    };
  };
  _proto.init = function init() {
    var self = this;
    var isInit = self.get('isInit');
    if (isInit) {
      return;
    }
    self._initAttrs();
    self._processData();
    self.set('isInit', true);
  };
  _proto._getGroupScales = function _getGroupScales() {
    var self = this;
    var scales = [];
    (0, _common.each)(GROUP_ATTRS, function (attrName) {
      var attr = self.getAttr(attrName);
      if (attr) {
        var attrScales = attr.scales;
        (0, _common.each)(attrScales, function (scale) {
          if (scale && scale.isCategory && scales.indexOf(scale) === -1) {
            scales.push(scale);
          }
        });
      }
    });
    return scales;
  };
  _proto._groupData = function _groupData(data) {
    var self = this;
    var colDefs = self.get('colDefs');
    var groupScales = self._getGroupScales();
    if (groupScales.length) {
      var appendConditions = {};
      var names = [];
      (0, _common.each)(groupScales, function (scale) {
        var field = scale.field;
        names.push(field);
        if (colDefs && colDefs[field] && colDefs[field].values) {
          // users have defined
          appendConditions[scale.field] = colDefs[field].values;
        }
      });
      return _common.Array.group(data, names, appendConditions);
    }
    return [data];
  };
  _proto._setAttrOptions = function _setAttrOptions(attrName, attrCfg) {
    var options = this.get('attrOptions');
    options[attrName] = attrCfg;
    var attrs = this.get('attrs');
    // 说明已经初始化过了
    if (Object.keys(attrs).length) {
      this._createAttr(attrName, attrCfg);
    }
  };
  _proto._createAttrOption = function _createAttrOption(attrName, field, cfg, defaultValues) {
    var attrCfg = {};
    attrCfg.field = field;
    if (cfg) {
      if ((0, _common.isFunction)(cfg)) {
        attrCfg.callback = cfg;
      } else {
        attrCfg.values = cfg;
      }
    } else {
      attrCfg.values = defaultValues;
    }
    this._setAttrOptions(attrName, attrCfg);
  };
  _proto._createAttr = function _createAttr(type, option) {
    var self = this;
    var attrs = self.get('attrs');
    var coord = self.get('coord');
    var className = (0, _common.upperFirst)(type);
    var fields = parseFields(option.field);
    if (type === 'position') {
      option.coord = coord;
    }
    var scales = [];
    for (var i = 0, len = fields.length; i < len; i++) {
      var field = fields[i];
      var scale = self._createScale(field);
      scales.push(scale);
    }
    if (type === 'position') {
      var yScale = scales[1];

      // 饼图的处理，但是还不知道为啥
      if (coord.type === 'polar' && coord.transposed && self.hasAdjust('stack')) {
        if (yScale.values.length) {
          yScale.change({
            nice: false,
            min: 0,
            max: Math.max.apply(null, yScale.values)
          });
        }
      }
    }
    option.scales = scales;
    var attr = new Attr[className](option);
    attrs[type] = attr;
    return attr;
  };
  _proto._initAttrs = function _initAttrs() {
    var self = this;
    var attrOptions = self.get('attrOptions');
    for (var type in attrOptions) {
      if (attrOptions.hasOwnProperty(type)) {
        this._createAttr(type, attrOptions[type]);
      }
    }
  };
  _proto._createScale = function _createScale(field) {
    var scales = this.get('scales');
    var scale = scales[field];
    if (!scale) {
      scale = this.get('chart').createScale(field);
      scales[field] = scale;
    }
    return scale;
  };
  _proto._processData = function _processData() {
    var self = this;
    var data = this.get('data');
    var dataArray = [];
    var groupedArray = this._groupData(data);
    if (this.get('ignoreEmptyGroup')) {
      var yScale = this.getYScale();
      groupedArray = groupedArray.filter(function (group) {
        return group.some(function (item) {
          return typeof item[yScale.field] !== 'undefined';
        });
      });
    }
    for (var i = 0, len = groupedArray.length; i < len; i++) {
      var subData = groupedArray[i];
      var tempData = self._saveOrigin(subData);
      if (this.hasAdjust('dodge')) {
        self._numberic(tempData);
      }
      dataArray.push(tempData);
    }
    if (self.get('adjust')) {
      self._adjustData(dataArray);
    }
    if (self.get('sortable')) {
      self._sort(dataArray);
    }
    self.emit('afterprocessdata', {
      dataArray: dataArray
    });
    self.set('mappingData', dataArray);
    self.set('dataArray', dataArray);
    return dataArray;
  };
  _proto._saveOrigin = function _saveOrigin(data) {
    var rst = [];
    for (var i = 0, len = data.length; i < len; i++) {
      var origin = data[i];
      var obj = {};
      for (var k in origin) {
        obj[k] = origin[k];
      }
      obj[FIELD_ORIGIN] = origin;
      rst.push(obj);
    }
    return rst;
  };
  _proto._numberic = function _numberic(data) {
    var positionAttr = this.getAttr('position');
    var scales = positionAttr.scales;
    for (var j = 0, len = data.length; j < len; j++) {
      var obj = data[j];
      var count = Math.min(2, scales.length);
      for (var i = 0; i < count; i++) {
        var scale = scales[i];
        if (scale.isCategory) {
          var field = scale.field;
          obj[field] = scale.translate(obj[field]);
        }
      }
    }
  };
  _proto._adjustData = function _adjustData(dataArray) {
    var self = this;
    var adjust = self.get('adjust');
    if (adjust) {
      var adjustType = (0, _common.upperFirst)(adjust.type);
      if (!_base2["default"][adjustType]) {
        throw new Error('not support such adjust : ' + adjust);
      }
      var xScale = self.getXScale();
      var yScale = self.getYScale();
      var cfg = (0, _common.mix)({
        xField: xScale.field,
        yField: yScale.field
      }, adjust);
      var adjustObject = new _base2["default"][adjustType](cfg);
      adjustObject.processAdjust(dataArray);
      if (adjustType === 'Stack') {
        self._updateStackRange(yScale.field, yScale, dataArray);
      }
    }
  };
  _proto._updateStackRange = function _updateStackRange(field, scale, dataArray) {
    var mergeArray = _common.Array.merge(dataArray);
    var min = scale.min;
    var max = scale.max;
    for (var i = 0, len = mergeArray.length; i < len; i++) {
      var obj = mergeArray[i];
      var tmpMin = Math.min.apply(null, obj[field]);
      var tmpMax = Math.max.apply(null, obj[field]);
      if (tmpMin < min) {
        min = tmpMin;
      }
      if (tmpMax > max) {
        max = tmpMax;
      }
    }
    if (min < scale.min || max > scale.max) {
      scale.change({
        min: min,
        max: max
      });
    }
  };
  _proto._sort = function _sort(mappedArray) {
    var self = this;
    var xScale = self.getXScale();
    var field = xScale.field,
      type = xScale.type;
    if (type !== 'identity' && xScale.values.length > 1) {
      (0, _common.each)(mappedArray, function (itemArr) {
        itemArr.sort(function (obj1, obj2) {
          if (type === 'timeCat') {
            return (0, _common.toTimeStamp)(obj1[FIELD_ORIGIN][field]) - (0, _common.toTimeStamp)(obj2[FIELD_ORIGIN][field]);
          }
          return xScale.translate(obj1[FIELD_ORIGIN][field]) - xScale.translate(obj2[FIELD_ORIGIN][field]);
        });
      });
    }
    self.set('hasSorted', true);
    self.set('dataArray', mappedArray);
  };
  _proto.paint = function paint() {
    var self = this;
    var dataArray = self.get('mappingData');
    var mappedArray = [];
    var shapeFactory = self.getShapeFactory();
    shapeFactory.setCoord(self.get('coord'));
    self._beforeMapping(dataArray);
    for (var i = 0, len = dataArray.length; i < len; i++) {
      var data = dataArray[i];
      if (data.length) {
        var mappedData = self._mapping(data);
        mappedArray.push(mappedData);
        self.draw(mappedData, shapeFactory);
      }
    }
    self.set('dataArray', mappedArray);
    this.generateAria();
  };
  _proto.getShapeFactory = function getShapeFactory() {
    var shapeFactory = this.get('shapeFactory');
    if (!shapeFactory) {
      var shapeType = this.get('shapeType');
      shapeFactory = _shape["default"].getShapeFactory(shapeType);
      this.set('shapeFactory', shapeFactory);
    }
    return shapeFactory;
  };
  _proto._mapping = function _mapping(data) {
    var self = this;
    var attrs = self.get('attrs');
    var yField = self.getYScale().field;

    // 用来缓存转换的值，减少mapping耗时
    var mappedCache = {};
    var mappedData = new Array(data.length);
    for (var k in attrs) {
      if (attrs.hasOwnProperty(k)) {
        var attr = attrs[k];
        var names = attr.names;
        var scales = attr.scales;
        for (var i = 0, len = data.length; i < len; i++) {
          var record = data[i];
          var mappedRecord = _extends({}, record, mappedData[i]);
          mappedRecord[FIELD_ORIGIN_Y] = record[yField];

          // 获取视觉属性对应的value值
          // 位置的缓存命中率低，还是每次单独计算
          if (attr.type === 'position') {
            var values = self._getAttrValues(attr, record);
            for (var j = 0, _len = values.length; j < _len; j++) {
              var val = values[j];
              var name = names[j];
              mappedRecord[name] = (0, _common.isArray)(val) && val.length === 1 ? val[0] : val;
            }
          } else {
            // 除了position其他都只有一项
            var _name = names[0];
            var field = scales[0].field;
            var value = record[field];
            var key = "" + _name + value;
            var _values = mappedCache[key];
            if (!_values) {
              _values = self._getAttrValues(attr, record);
              mappedCache[key] = _values;
            }
            mappedRecord[_name] = _values[0];
          }
          // 设置新数组
          mappedData[i] = mappedRecord;
        }
      }
    }
    return mappedData;
  };
  _proto._getAttrValues = function _getAttrValues(attr, record) {
    var scales = attr.scales;
    var params = [];
    for (var i = 0, len = scales.length; i < len; i++) {
      var scale = scales[i];
      var field = scale.field;
      if (scale.type === 'identity') {
        params.push(scale.value);
      } else {
        params.push(record[field]);
      }
    }
    var values = attr.mapping.apply(attr, params);
    return values;
  };
  _proto.getAttrValue = function getAttrValue(attrName, record) {
    var attr = this.getAttr(attrName);
    var rst = null;
    if (attr) {
      var values = this._getAttrValues(attr, record);
      rst = values[0];
    }
    return rst;
  };
  _proto._beforeMapping = function _beforeMapping(dataArray) {
    var self = this;
    if (self.get('generatePoints')) {
      self._generatePoints(dataArray);
    }
  };
  _proto.isInCircle = function isInCircle() {
    var coord = this.get('coord');
    return coord && coord.isPolar;
  };
  _proto.getCallbackCfg = function getCallbackCfg(fields, cfg, origin) {
    if (!fields) {
      return cfg;
    }
    var tmpCfg = {};
    var params = fields.map(function (field) {
      return origin[field];
    });
    (0, _common.each)(cfg, function (v, k) {
      if ((0, _common.isFunction)(v)) {
        tmpCfg[k] = v.apply(null, params);
      } else {
        tmpCfg[k] = v;
      }
    });
    return tmpCfg;
  };
  _proto.getDrawCfg = function getDrawCfg(obj) {
    var self = this;
    var isInCircle = self.isInCircle();
    var cfg = {
      origin: obj,
      x: obj.x,
      y: obj.y,
      color: obj.color,
      size: obj.size,
      shape: obj.shape,
      isInCircle: isInCircle,
      opacity: obj.opacity
    };
    var styleOptions = self.get('styleOptions');
    if (styleOptions && styleOptions.style) {
      cfg.style = self.getCallbackCfg(styleOptions.fields, styleOptions.style, obj[FIELD_ORIGIN]);
    }
    if (self.get('generatePoints')) {
      cfg.points = obj.points;
      cfg.nextPoints = obj.nextPoints;
    }
    if (isInCircle) {
      cfg.center = self.get('coord').center;
    }
    return cfg;
  };
  _proto.draw = function draw(data, shapeFactory) {
    var self = this;
    var container = self.get('container');
    var yScale = self.getYScale();
    (0, _common.each)(data, function (obj, index) {
      if (yScale && (0, _common.isNil)(obj._origin[yScale.field])) {
        return;
      }
      obj.index = index;
      var cfg = self.getDrawCfg(obj);
      var shape = obj.shape;
      self.drawShape(shape, obj, cfg, container, shapeFactory);
    });
  };
  _proto.drawShape = function drawShape(shape, shapeData, cfg, container, shapeFactory) {
    var gShape = shapeFactory.drawShape(shape, cfg, container);
    if (gShape) {
      (0, _common.each)([].concat(gShape), function (s) {
        s.set('origin', shapeData);
      });
    }
  };
  _proto._generatePoints = function _generatePoints(dataArray) {
    var self = this;
    var shapeFactory = self.getShapeFactory();
    var shapeAttr = self.getAttr('shape');
    (0, _common.each)(dataArray, function (data) {
      for (var i = 0, len = data.length; i < len; i++) {
        var obj = data[i];
        var cfg = self.createShapePointsCfg(obj);
        var shape = shapeAttr ? self._getAttrValues(shapeAttr, obj) : null;
        var points = shapeFactory.getShapePoints(shape, cfg);
        obj.points = points;
      }
    });
    // 添加nextPoints
    (0, _common.each)(dataArray, function (data, index) {
      var nextData = dataArray[index + 1];
      if (nextData) {
        data[0].nextPoints = nextData[0].points;
      }
    });
  }

  // 生成无障碍文本
  ;
  _proto.generateAria = function generateAria() {
    var container = this.get('container');
    var aria = container.get('aria');
    if (!aria) {
      return;
    }
    var ariaLables = [];
    var coord = this.get('coord');
    var xScale = this.getXScale();
    var yScale = this.getYScale();
    var coordAriaLabel = (0, _util.generateCoordAria)(coord, xScale, yScale);
    ariaLables.push(coordAriaLabel);
    var _lang$geometry = _global.lang.geometry,
      prefix = _lang$geometry.prefix,
      oneData = _lang$geometry.oneData,
      partData = _lang$geometry.partData,
      allData = _lang$geometry.allData;
    var dataArray = this.get('dataArray');
    var count = dataArray.length;

    // 只处理一个，不然太复杂
    var groupScale = this._getGroupScales()[0];
    if (groupScale) {
      var prefixLabel = (0, _common.substitute)(prefix, {
        count: count
      });
      ariaLables.push(prefixLabel);
      (0, _common.each)(dataArray, function (data, index) {
        var len = data.length;
        if (!len) return;
        var firstObj = data[0]._origin;
        if (len === 1) {
          ariaLables.push((0, _common.substitute)(oneData, {
            index: index + 1,
            count: len,
            name: firstObj[groupScale.field],
            values: firstObj[yScale.field]
          }));
        } else {
          var template = len > 5 ? partData : allData;
          var values = data.slice(0, 5).map(function (record) {
            var _origin = record._origin;
            var xValue = xScale.getText(_origin[xScale.field]);
            var yValue = yScale.getText(_origin[yScale.field]);
            return xValue + ":" + yValue;
          });
          ariaLables.push((0, _common.substitute)(template, {
            index: index + 1,
            count: len,
            part: 3,
            name: firstObj[groupScale.field],
            values: values.join(' ')
          }));
        }
      });
    }
    container.set('ariaLabel', ariaLables.join(''));
  }

  /**
   * get the info of each shape
   * @protected
   * @param  {Object} obj the data item
   * @return {Object} cfg return the result
   */;
  _proto.createShapePointsCfg = function createShapePointsCfg(obj) {
    var xScale = this.getXScale();
    var yScale = this.getYScale();
    var x = this._normalizeValues(obj[xScale.field], xScale);
    var y;
    if (yScale) {
      y = this._normalizeValues(obj[yScale.field], yScale);
    } else {
      y = obj.y ? obj.y : 0.1;
    }
    return {
      x: x,
      y: y,
      y0: yScale ? yScale.scale(this.getYMinValue()) : undefined
    };
  };
  _proto.getYMinValue = function getYMinValue() {
    var yScale = this.getYScale();
    var min = yScale.min,
      max = yScale.max;
    var value;
    if (this.get('startOnZero')) {
      if (max <= 0 && min <= 0) {
        value = max;
      } else {
        value = min >= 0 ? min : 0;
      }
    } else {
      value = min;
    }
    return value;
  };
  _proto._normalizeValues = function _normalizeValues(values, scale) {
    var rst = [];
    if ((0, _common.isArray)(values)) {
      for (var i = 0, len = values.length; i < len; i++) {
        var v = values[i];
        rst.push(scale.scale(v));
      }
    } else {
      rst = scale.scale(values);
    }
    return rst;
  };
  _proto.getAttr = function getAttr(name) {
    return this.get('attrs')[name];
  };
  _proto.getXScale = function getXScale() {
    return this.getAttr('position').scales[0];
  };
  _proto.getYScale = function getYScale() {
    return this.getAttr('position').scales[1];
  };
  _proto.hasAdjust = function hasAdjust(adjust) {
    return this.get('adjust') && this.get('adjust').type === adjust;
  };
  _proto._getSnap = function _getSnap(scale, item, arr) {
    var i = 0;
    var values;
    var yField = this.getYScale().field; // 叠加的维度
    if (this.hasAdjust('stack') && scale.field === yField) {
      values = [];
      arr.forEach(function (obj) {
        values.push(obj[FIELD_ORIGIN_Y]);
      });
      for (var len = values.length; i < len; i++) {
        if (values[0][0] > item) {
          break;
        }
        if (values[values.length - 1][1] <= item) {
          i = values.length - 1;
          break;
        }
        if (values[i][0] <= item && values[i][1] > item) {
          break;
        }
      }
    } else {
      values = scale.values;
      values.sort(function (a, b) {
        return a - b;
      });
      for (var _len2 = values.length; i < _len2; i++) {
        // 如果只有1个点直接返回第1个点
        if (_len2 <= 1) {
          break;
        }
        // 第1个点和第2个点之间
        if ((values[0] + values[1]) / 2 > item) {
          break;
        }
        // 中间的点
        if ((values[i - 1] + values[i]) / 2 <= item && (values[i + 1] + values[i]) / 2 > item) {
          break;
        }
        // 最后2个点
        if ((values[values.length - 2] + values[values.length - 1]) / 2 <= item) {
          i = values.length - 1;
          break;
        }
      }
    }
    var result = values[i];
    return result;
  };
  _proto.getSnapRecords = function getSnapRecords(point) {
    var self = this;
    var coord = self.get('coord');
    var xScale = self.getXScale();
    var yScale = self.getYScale();
    var xfield = xScale.field;
    var dataArray = self.get('dataArray');
    if (!this.get('hasSorted')) {
      this._sort(dataArray);
    }
    var rst = [];
    var invertPoint = coord.invertPoint(point);
    var invertPointX = invertPoint.x;
    if (self.isInCircle() && !coord.transposed && invertPointX > (1 + xScale.rangeMax()) / 2) {
      invertPointX = xScale.rangeMin();
    }
    if (xScale.isCategory) {
      var min = xScale.rangeMin();
      var max = xScale.rangeMax();
      // 归一到 范围内
      if (invertPointX < min) {
        invertPointX = min;
      }
      if (invertPointX > max) {
        invertPointX = max;
      }
    }
    var xValue = xScale.invert(invertPointX);
    if (!xScale.isCategory) {
      xValue = self._getSnap(xScale, xValue);
    }
    var tmp = [];
    dataArray.forEach(function (data) {
      data.forEach(function (obj) {
        var originValue = (0, _common.isNil)(obj[FIELD_ORIGIN]) ? obj[xfield] : obj[FIELD_ORIGIN][xfield];
        if (self._isEqual(originValue, xValue, xScale)) {
          tmp.push(obj);
        }
      });
    });

    // special for pie chart
    if (this.hasAdjust('stack') && coord.isPolar && coord.transposed) {
      if (invertPointX >= 0 && invertPointX <= 1) {
        var yValue = yScale.invert(invertPoint.y);
        yValue = self._getSnap(yScale, yValue, tmp);
        tmp.forEach(function (obj) {
          if ((0, _common.isArray)(yValue) ? obj[FIELD_ORIGIN_Y].toString() === yValue.toString() : obj[FIELD_ORIGIN_Y] === yValue) {
            rst.push(obj);
          }
        });
      }
    } else {
      rst = tmp;
    }
    return rst;
  };
  _proto.getRecords = function getRecords(value) {
    var _this = this;
    var xScale = this.getXScale();
    var dataArray = this.get('dataArray');
    var xfield = xScale.field;
    return dataArray.map(function (data) {
      for (var len = data.length, i = len - 1; i >= 0; i--) {
        var obj = data[i];
        var originValue = (0, _common.isNil)(obj[FIELD_ORIGIN]) ? obj[xfield] : obj[FIELD_ORIGIN][xfield];
        if (_this._isEqual(originValue, value, xScale)) {
          return obj;
        }
      }
      return null;
    });
  };
  _proto._isEqual = function _isEqual(originValue, value, scale) {
    if (scale.type === 'timeCat') {
      return (0, _common.toTimeStamp)(originValue) === value;
    }
    return value === originValue;
  };
  _proto.position = function position(field) {
    this._setAttrOptions('position', {
      field: field
    });
    return this;
  };
  _proto.color = function color(field, values) {
    this._createAttrOption('color', field, values, _global["default"].colors);
    return this;
  };
  _proto.size = function size(field, values) {
    this._createAttrOption('size', field, values, _global["default"].sizes);
    return this;
  };
  _proto.shape = function shape(field, values) {
    var type = this.get('type');
    var shapes = _global["default"].shapes[type] || [];
    this._createAttrOption('shape', field, values, shapes);
    return this;
  };
  _proto.style = function style(field, cfg) {
    var styleOptions = this.get('styleOptions');
    if (!styleOptions) {
      styleOptions = {};
      this.set('styleOptions', styleOptions);
    }
    if ((0, _common.isObject)(field)) {
      cfg = field;
      field = null;
    }
    var fields;
    if (field) {
      fields = parseFields(field);
    }
    styleOptions.fields = fields;
    styleOptions.style = cfg;
    return this;
  };
  _proto.adjust = function adjust(type) {
    if ((0, _common.isString)(type)) {
      type = {
        type: type
      };
    }
    this.set('adjust', type);
    return this;
  };
  _proto.animate = function animate(cfg) {
    this.set('animateCfg', cfg);
    return this;
  };
  _proto.changeData = function changeData(data) {
    this.set('data', data);
    // 改变数据后，情况度量，因为需要重新实例化
    this.set('scales', {});
    if (!this.get('isInit')) return;
    this.set('isInit', false);
    this.init();
  };
  _proto.clearInner = function clearInner() {
    var container = this.get('container');
    if (container) {
      container.clear();
      // container.setMatrix([ 1, 0, 0, 1, 0, 0 ]);
    }
  };
  _proto.reset = function reset() {
    this.set('isInit', false);
    this.set('attrs', {});
    this.set('attrOptions', {});
    this.set('adjust', null);
    this.clearInner();
  };
  _proto.clear = function clear() {
    this.clearInner();
  };
  _proto.destroy = function destroy() {
    this.set('isInit', false);
    this.clear();
    _Base.prototype.destroy.call(this);
  };
  _proto._display = function _display(visible) {
    this.set('visible', visible);
    var container = this.get('container');
    var canvas = container.get('canvas');
    container.set('visible', visible);
    canvas.draw();
  };
  _proto.show = function show() {
    this._display(true);
  };
  _proto.hide = function hide() {
    this._display(false);
  };
  return Geom;
}(_base["default"]);
var _default = exports["default"] = Geom;