@antv/f2/lib/controller/scale.js

Charts for mobile visualization.

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _tslib = require("tslib");
var _util = require("@antv/util");
var _src = require("../deps/f2-scale/src");
var _catTick = _interopRequireDefault(require("./tick/cat-tick"));
var _linearTick = _interopRequireDefault(require("./tick/linear-tick"));
(0, _src.registerScale)('cat', _src.Category);
(0, _src.registerScale)('category', _src.Category);
(0, _src.registerScale)('identity', _src.Identity);
(0, _src.registerScale)('linear', _src.Linear);
(0, _src.registerScale)('log', _src.Log);
(0, _src.registerScale)('pow', _src.Pow);
(0, _src.registerScale)('time', _src.Time);
(0, _src.registerScale)('timeCat', _src.TimeCat);
(0, _src.registerScale)('quantize', _src.Quantize);
(0, _src.registerScale)('quantile', _src.Quantile);
// 覆盖0.3.x的 cat 方法
(0, _src.registerTickMethod)('cat', _catTick.default);
(0, _src.registerTickMethod)('time-cat', _catTick.default);
// 覆盖linear 度量的tick算法
(0, _src.registerTickMethod)('wilkinson-extended', _linearTick.default);
var ScaleController = /** @class */function () {
  function ScaleController(data) {
    this.data = data;
    this.options = {};
    this.scales = {};
  }
  ScaleController.prototype._getType = function (option) {
    var type = option.type,
      values = option.values,
      field = option.field;
    if (type) {
      return type;
    }
    if ((0, _util.isNumber)(field) || (0, _util.isNil)(values[0]) && field) {
      return 'identity';
    }
    if (typeof values[0] === 'number') {
      return 'linear';
    }
    return 'cat';
  };
  ScaleController.prototype._getOption = function (option) {
    var values = option.values,
      field = option.field,
      justifyContent = option.justifyContent;
    var type = this._getType(option);
    option.type = type;
    // identity
    if (type === 'identity') {
      option.field = field.toString();
      option.values = [field];
      return option;
    }
    // linear 类型
    if (type === 'linear') {
      // 设置默认nice
      if (typeof option.nice !== 'boolean') {
        option.nice = true;
      }
      // 重置最大最小
      var _a = (0, _util.getRange)(values),
        min = _a.min,
        max = _a.max;
      if ((0, _util.isNil)(option.min)) {
        option.min = min;
      }
      if ((0, _util.isNil)(option.max)) {
        option.max = max;
      }
      option.values = values.sort(function (a, b) {
        return a - b;
      });
      return option;
    }
    // 分类类型和 timeCat 类型，调整 range
    if (type === 'cat' || type === 'timeCat') {
      if (option.range) {
        return option;
      }
      var count = values.length;
      var range = [0, 1];
      // 如果只有一项，显示在中间
      if (count === 1) {
        range = [0.5, 1];
      } else if (justifyContent) {
        // 居中
        var offset = 1 / count * 0.5;
        range = [offset, 1 - offset];
      } else {
        // 最后留 1 / count
        var offset = 1 / count;
        range = [0, 1 - offset];
      }
      option.range = range;
    }
    return option;
  };
  ScaleController.prototype.createScale = function (option) {
    var type = option.type;
    if ((0, _util.isFunction)(type)) {
      return new type(option);
    }
    var ScaleClass = (0, _src.getScale)(type);
    return new ScaleClass(option);
  };
  // 更新或创建scale
  ScaleController.prototype.setScale = function (field, option) {
    var _a = this,
      options = _a.options,
      scales = _a.scales;
    options[field] = (0, _util.mix)({}, options[field], option);
    // 如果scale有更新，scale 也需要重新创建
    if (scales[field]) {
      scales[field].change(options[field]);
      // delete scales[field];
    }
  };
  ScaleController.prototype.create = function (options) {
    this.update(options);
  };
  ScaleController.prototype.update = function (options) {
    var _this = this;
    if (!options) return;
    (0, _util.each)(options, function (option, field) {
      _this.setScale(field, option);
    });
  };
  ScaleController.prototype.changeData = function (data) {
    this.data = data;
    this.scales = {};
  };
  ScaleController.prototype.getData = function () {
    return this.data;
  };
  ScaleController.prototype.getScale = function (field) {
    var _a = this,
      scales = _a.scales,
      options = _a.options,
      data = _a.data;
    var scale = scales[field];
    if (scale) {
      // for adjust=dodge, 需要更新 range
      var option_1 = this._getOption((0, _tslib.__assign)((0, _tslib.__assign)({}, options[field]), {
        values: scale.values
      }));
      if (option_1.range) {
        scale.range = option_1.range;
      }
      return scale;
    }
    var option = options[field];
    if (!option) {
      return null;
    }
    var values = option.values ? option.values : data ? (0, _util.valuesOfKey)(data, field) : [];
    var scaleOption = this._getOption((0, _tslib.__assign)((0, _tslib.__assign)({}, option), {
      field: field,
      values: values
    }));
    var newScale = this.createScale(scaleOption);
    scales[field] = newScale;
    return newScale;
  };
  ScaleController.prototype.getScales = function () {
    var _this = this;
    var _a = this,
      options = _a.options,
      scales = _a.scales;
    (0, _util.each)(options, function (option, field) {
      _this.getScale(field);
    });
    return scales;
  };
  ScaleController.prototype.getOptions = function () {
    var scales = this.scales;
    var options = {};
    (0, _util.each)(scales, function (scale, field) {
      options[field] = (0, _tslib.__assign)({}, scale.__cfg__);
    });
    return options;
  };
  ScaleController.prototype.adjustStartZero = function (scale) {
    var options = this.options;
    var field = scale.field,
      min = scale.min,
      max = scale.max;
    var option = options[field];
    // 如果有定义，则不处理
    if (option && option.min) {
      return;
    }
    if (min > 0) {
      scale.change({
        min: 0
      });
    } else if (max < 0) {
      scale.change({
        max: 0
      });
    }
  };
  // 饼图下的scale调整
  ScaleController.prototype.adjustPieScale = function (scale) {
    var options = this.options;
    var field = scale.field;
    var option = options[field];
    if (option && !(0, _util.isNil)(option.nice)) {
      return null;
    }
    scale.change({
      nice: false
    });
  };
  //堆叠下的scale调整
  ScaleController.prototype._updateStackRange = function (scale, flattenArray) {
    var options = this.options;
    var field = scale.field;
    var option = options[field];
    var dataMin = Infinity;
    var dataMax = -Infinity;
    for (var i = 0, len = flattenArray.length; i < len; i++) {
      var obj = flattenArray[i];
      var tmpMin = Math.min.apply(null, obj[field]);
      var tmpMax = Math.max.apply(null, obj[field]);
      if (tmpMin < dataMin) {
        dataMin = tmpMin;
      }
      if (tmpMax > dataMax) {
        dataMax = tmpMax;
      }
    }
    // 如果有定义，则优先级更高
    var min = (option === null || option === void 0 ? void 0 : option.min) || dataMin;
    var max = (option === null || option === void 0 ? void 0 : option.max) || dataMax;
    if (min !== scale.min || max !== scale.max) {
      scale.change({
        min: min,
        max: max
      });
    }
  };
  // 获取scale 在 0点对位置的值
  ScaleController.prototype.getZeroValue = function (scale) {
    var min = scale.min,
      max = scale.max;
    var value;
    if (min >= 0) {
      value = min;
    } else if (max <= 0) {
      value = max;
    } else {
      value = 0;
    }
    return scale.scale(value);
  };
  return ScaleController;
}();
var _default = exports.default = ScaleController;