@alicloud/cloud-charts/es/common/tickMethod.js


import extended from '@antv/scale/esm/util/extended';
import { head, isNil, last } from '@antv/util';
// import strictLimit from '@antv/scale/esm/util/strict-limit';
import interval from '@antv/scale/esm/util/interval';
export function integer(cfg) {
  var min = cfg.min,
    max = cfg.max,
    tickCount = cfg.tickCount,
    nice = cfg.nice,
    tickInterval = cfg.tickInterval,
    minLimit = cfg.minLimit,
    maxLimit = cfg.maxLimit;

  // console.log('integer', min, max, tickCount, nice, tickInterval, minLimit, maxLimit);

  var ticks = [];
  var integerRes = convertMiniInteger(min, max, tickCount, nice);
  // 如果有整数计算结果，则使用该 ticks
  if (integerRes) {
    ticks = integerRes.ticks;
  } else {
    ticks = extended(min, max, tickCount, nice).ticks;
  }

  // console.log('ticks', ticks);

  if (!isNil(minLimit) || !isNil(maxLimit)) {
    return strictLimit(cfg, ticks);
  }
  if (tickInterval) {
    return interval(min, max, tickInterval).ticks;
  }
  return ticks;
}
function convertMiniInteger(dMin, dMax, n, onlyLoose) {
  if (n === void 0) {
    n = 5;
  }
  if (onlyLoose === void 0) {
    onlyLoose = true;
  }
  // 处理小于 0 和小数的 tickCount
  var m = n < 0 ? 0 : Math.round(n);

  // nan 也会导致异常
  if (Number.isNaN(dMin) || Number.isNaN(dMax) || typeof dMin !== 'number' || typeof dMax !== 'number' || !m) {
    return {
      min: 0,
      max: 0,
      ticks: []
    };
  }

  // js 极大值极小值问题，差值小于 1e-15 会导致计算出错
  if (dMax - dMin < 1e-15 || m === 1) {
    return {
      min: dMin,
      max: dMax,
      ticks: [dMin]
    };
  }
  if (!onlyLoose) {
    return undefined;
  }

  // 相差只有 1
  if (dMax - dMin <= 1) {
    if (dMin >= 0 && dMin < 1) {
      // 值域两端接近 0，则不跨越 0
      return {
        min: 0,
        max: 2,
        ticks: [0, 1, 2]
      };
    } else if (dMax > -1 && dMax <= 0) {
      // 值域两端接近 0，则不跨越 0
      return {
        min: -2,
        max: 0,
        ticks: [-2, -1, 0]
      };
    } else {
      return {
        min: dMin - 1,
        max: dMax + 1,
        ticks: [dMin - 1, dMin, dMax, dMax + 1]
      };
    }
  }

  // 相差只有 2
  if (dMax - dMin <= 2) {
    if (dMin >= 0 && dMin < 1) {
      // 值域两端接近 0，则不跨越 0
      return {
        min: 0,
        max: 3,
        ticks: [0, 1, 2, 3]
      };
    } else if (dMax > -1 && dMax <= 0) {
      // 值域两端接近 0，则不跨越 0
      return {
        min: -3,
        max: 0,
        ticks: [-3, -2, -1, 0]
      };
    } else {
      var min = Math.round(dMin - 1);
      var max = Math.round(dMax + 1);
      return {
        min: min,
        max: max,
        ticks: [min, dMin, dMin + Math.round((dMax - dMin) / 2), dMax, max]
      };
    }
  }

  // 相差 9 / 10
  if (dMax - dMin === 9 || dMax - dMin === 10) {
    if (dMin >= 0 && dMin < 1) {
      // 值域两端接近 0，则不跨越 0
      return {
        min: 0,
        max: 10,
        ticks: [0, 2, 4, 6, 8, 10]
      };
    } else if (dMax > -1 && dMax <= 0) {
      // 值域两端接近 0，则不跨越 0
      return {
        min: -10,
        max: 0,
        ticks: [-10, -8, -6, -4, -2, 0]
      };
      // } else {
      //   const min = Math.round(dMin - 1);
      //   const max = Math.round(dMax - 1);
      //   return {
      //     min,
      //     max,
      //     ticks: [min, dMin, Math.round((dMax - dMin) / 2) ,dMax, max],
      //   };
    }
  }
  return undefined;
}
function strictLimit(cfg, ticks) {
  var defaultMin = head(ticks);
  var defaultMax = last(ticks);
  var minLimit = cfg.minLimit,
    maxLimit = cfg.maxLimit,
    min = cfg.min,
    max = cfg.max,
    _cfg$tickCount = cfg.tickCount,
    tickCount = _cfg$tickCount === void 0 ? 5 : _cfg$tickCount;
  if (!isNil(minLimit) && !isNil(defaultMin) && defaultMin === minLimit && isNil(maxLimit)) {
    return ticks;
  }
  if (!isNil(maxLimit) && !isNil(defaultMax) && defaultMax === maxLimit && isNil(minLimit)) {
    return ticks;
  }
  var tickMin = isNil(minLimit) ? isNil(defaultMin) ? min : defaultMin : minLimit;
  var tickMax = isNil(maxLimit) ? isNil(defaultMax) ? max : defaultMax : maxLimit;
  if (tickMin > tickMax) {
    var _ref = [tickMin, tickMax];
    tickMax = _ref[0];
    tickMin = _ref[1];
  }
  if (tickCount <= 2) {
    return [tickMin, tickMax];
  }
  var step = (tickMax - tickMin) / (tickCount - 1);
  var newTicks = [];
  for (var i = 0; i < tickCount; i++) {
    newTicks.push(tickMin + step * i);
  }
  return newTicks;
}