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


import _extends from "@babel/runtime/helpers/extends";
// 复写G2时间轴标签计算方法
import { filter, isNil, isNumber, last } from '@antv/util';
import { DAY, HOUR, MINUTE, MONTH, SECOND, YEAR } from '@antv/scale/esm/util/time';
import _ from 'lodash';

function getYear(date) {
  return new Date(date).getFullYear();
}

function createYear(year) {
  return new Date(year, 0, 1).getTime();
}

function getMonth(date) {
  return new Date(date).getMonth();
}

function diffMonth(min, max) {
  var minYear = getYear(min);
  var maxYear = getYear(max);
  var minMonth = getMonth(min);
  var maxMonth = getMonth(max);
  return (maxYear - minYear) * 12 + (maxMonth - minMonth) % 12;
}

function creatMonth(year, month) {
  return new Date(year, month, 1).getTime();
}

function diffDay(min, max) {
  return Math.ceil((max - min) / DAY);
}

function diffHour(min, max) {
  return Math.ceil((max - min) / HOUR);
}

function diffMinus(min, max) {
  return Math.ceil((max - min) / (60 * 1000));
} // 如果计算出来的ticks超出最大最小值，保证最大最小值正确，然后根据宽度和数据量均分
// 1. 确认最大最小值正确，默认刻度个数为7个
// 2. 用户自定义高于一切
// 3. 如果计算出来的的刻度数量小于默认刻度个数，则使用计算出来的刻度


function avgTicks(min, max, tickCount, sourceTicks) {
  console.log(min, max, tickCount, sourceTicks);
  var tickLength = (sourceTicks === null || sourceTicks === void 0 ? void 0 : sourceTicks.length) < tickCount ? sourceTicks === null || sourceTicks === void 0 ? void 0 : sourceTicks.length : tickCount;
  var avg = (max - min) / (tickLength - 1 <= 0 ? 1 : tickLength - 1);
  var ticks = [];

  for (var i = min; i <= max; i += avg) {
    ticks.push(i);
  } // console.log(tickLength, ticks, sourceTicks);


  if (_.isEqual(ticks, sourceTicks)) {// console.log(1111)
  }

  return ticks;
}
/**
 * 计算 time 的 ticks，对 month, year 进行 pretty 处理
 * @param cfg 度量的配置项
 * @returns 计算后的 ticks
 */


export function timePretty(cfg) {
  var min = cfg.min,
      max = cfg.max,
      minTickInterval = cfg.minTickInterval,
      tickCount = cfg.tickCount;
  var tickInterval = cfg.tickInterval;
  var ticks = []; // 指定 tickInterval 后 tickCount 不生效，需要重新计算

  if (!tickInterval) {
    tickInterval = (max - min) / tickCount; // 如果设置了最小间距，则使用最小间距

    if (minTickInterval && tickInterval < minTickInterval) {
      tickInterval = minTickInterval;
    }
  }

  tickInterval = Math.max(Math.floor((max - min) / (Math.pow(2, 12) - 1)), tickInterval);
  var minYear = getYear(min); // 如果间距大于 1 年，则将开始日期从整年开始

  if (tickInterval > YEAR) {
    var maxYear = getYear(max);
    var yearInterval = Math.ceil(tickInterval / YEAR);

    for (var i = minYear; i <= maxYear + yearInterval; i = i + yearInterval) {
      ticks.push(createYear(i));
    }
  } else if (tickInterval > MONTH) {
    // 大于月时
    var monthInterval = Math.ceil(tickInterval / MONTH);
    var mmMoth = getMonth(min);
    var dMonths = diffMonth(min, max);

    for (var _i = 0; _i <= dMonths + monthInterval; _i = _i + monthInterval) {
      ticks.push(creatMonth(minYear, _i + mmMoth));
    }
  } else if (tickInterval > DAY) {
    // 大于天
    var date = new Date(min);
    var year = date.getFullYear();
    var month = date.getMonth();
    var mday = date.getDate();
    var day = Math.ceil(tickInterval / DAY);
    var ddays = diffDay(min, max);

    for (var _i2 = 0; _i2 < ddays + day; _i2 = _i2 + day) {
      ticks.push(new Date(year, month, mday + _i2).getTime());
    }
  } else if (tickInterval > HOUR) {
    // 大于小时
    var _date = new Date(min);

    var _year = _date.getFullYear();

    var _month = _date.getMonth();

    var _day = _date.getDate();

    var hour = _date.getHours();

    var hours = Math.ceil(tickInterval / HOUR);
    var dHours = diffHour(min, max);

    for (var _i3 = 0; _i3 <= dHours + hours; _i3 = _i3 + hours) {
      ticks.push(new Date(_year, _month, _day, hour + _i3).getTime());
    }
  } else if (tickInterval > MINUTE) {
    // 大于分钟
    var dMinus = diffMinus(min, max);
    var minutes = Math.ceil(tickInterval / MINUTE);

    for (var _i4 = 0; _i4 <= dMinus + minutes; _i4 = _i4 + minutes) {
      ticks.push(min + _i4 * MINUTE);
    }
  } else {
    // 小于分钟
    var interval = tickInterval;

    if (interval < SECOND) {
      interval = SECOND;
    }

    var minSecond = Math.floor(min / SECOND) * SECOND;
    var dSeconds = Math.ceil((max - min) / SECOND);
    var seconds = Math.ceil(interval / SECOND);

    for (var _i5 = 0; _i5 < dSeconds + seconds; _i5 = _i5 + seconds) {
      ticks.push(minSecond + _i5 * SECOND);
    }
  } // 最好是能从算法能解决这个问题，但是如果指定了 tickInterval，计算 ticks，也只能这么算，所以
  // 打印警告提示


  if (ticks.length >= 512) {
    console.warn("Notice: current ticks length(" + ticks.length + ") >= 512, may cause performance issues, even out of memory. Because of the configure \"tickInterval\"(in milliseconds, current is " + tickInterval + ") is too small, increase the value to solve the problem!");
  } // console.log('ticks', ticks);
  // if (max > min) {
  //   ticks = avgTicks(min, max, tickCount, ticks);
  // }


  return ticks;
}
/**
 * 计算分类 ticks
 * @param cfg 度量的配置项
 * @returns 计算后的 ticks
 */

export default function calculateCatTicks(cfg) {
  var values = cfg.values,
      tickInterval = cfg.tickInterval,
      tickCount = cfg.tickCount,
      showLast = cfg.showLast;

  if (isNumber(tickInterval)) {
    var _ticks = filter(values, function (__, i) {
      return i % tickInterval === 0;
    });

    var lastValue = last(values);

    if (showLast && last(_ticks) !== lastValue) {
      _ticks.push(lastValue);
    }

    return _ticks;
  }

  var len = values.length;
  var min = cfg.min,
      max = cfg.max;

  if (isNil(min)) {
    min = 0;
  }

  if (isNil(max)) {
    max = values.length - 1;
  }

  if (!isNumber(tickCount) || tickCount >= len) return values.slice(min, max + 1);
  if (tickCount <= 0 || max <= 0) return [];
  var interval = tickCount === 1 ? len : Math.floor(len / (tickCount - 1));
  var ticks = [];
  var idx = min;

  for (var i = 0; i < tickCount; i++) {
    if (idx >= max) break;
    idx = Math.min(min + i * interval, max);
    if (i === tickCount - 1 && showLast) ticks.push(values[max]);else ticks.push(values[idx]);
  }

  return ticks;
} // 时间分类算法

export function timeCat(cfg) {
  // 默认保留最后一条
  var ticks = calculateCatTicks(_extends({
    showLast: true
  }, cfg));
  return ticks;
}