choerodon-ui/pro/es/number-field/utils.js

An enterprise-class UI design language and React-based implementation

import { isMoment } from 'moment';
import isNil from 'lodash/isNil';
import isNumber from 'lodash/isNumber';
import defaultTo from 'lodash/defaultTo';
import { TimeUnit } from '../date-picker/enum';
import defaultFormatNumber from '../formatter/formatNumber';
export var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || Math.pow(2, 53) - 1;
export var MIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER || -(Math.pow(2, 53) - 1);
export function getPrecision(value) {
  var valueString = value.toString();

  if (valueString.indexOf('e-') >= 0) {
    return parseInt(valueString.slice(valueString.indexOf('e-') + 2), 10);
  }

  if (valueString.indexOf('.') >= 0) {
    return valueString.length - valueString.indexOf('.') - 1;
  }

  return 0;
}

function getMaxPrecision(value, step) {
  var stepPrecision = getPrecision(step);
  var currentValuePrecision = getPrecision(value);

  if (!value) {
    return stepPrecision;
  }

  return Math.max(currentValuePrecision, stepPrecision);
}

function getPrecisionFactor(value, step) {
  return Math.pow(10, getMaxPrecision(value, step));
}

function precisionFix(value, precisionFactor) {
  return Math.round(value * precisionFactor);
}

export function plus() {
  for (var _len = arguments.length, values = new Array(_len), _key = 0; _key < _len; _key++) {
    values[_key] = arguments[_key];
  }

  if (values.length > 2) {
    return plus(values.shift(), plus.apply(void 0, values));
  }

  if (values.length < 2) {
    return values[0];
  }

  var v1 = values[0];
  var v2 = values[1];
  var precisionFactor = getPrecisionFactor(v1, v2);
  return (precisionFix(v1, precisionFactor) + precisionFix(v2, precisionFactor)) / precisionFactor;
}

function getBeforeStepValue(value, minFactor, stepFactor) {
  return value - (value - minFactor) % stepFactor;
}

function getNearStepMoments(value, step, unit) {
  var unitValue = value.get(unit);
  var mod = unitValue % step;

  if (mod !== 0) {
    var before = unitValue - mod;
    var after = before + step;
    return [value.clone().set(unit, before), value.clone().set(unit, after)];
  }
}

export function getNearStepValues(value, step, min, max) {
  if (isNumber(step)) {
    if (isNumber(value)) {
      min = defaultTo(Number(min), -MAX_SAFE_INTEGER);
      max = defaultTo(Number(max), MAX_SAFE_INTEGER);
      var precisionFactor = getPrecisionFactor(value, step);
      var valueFactor = precisionFix(value, precisionFactor);
      var minFactor = precisionFix(min, precisionFactor);
      var minFactorBase = min === -MAX_SAFE_INTEGER ? 0 : minFactor;
      var maxFactor = precisionFix(max, precisionFactor);
      var stepFactor = precisionFix(step, precisionFactor);
      var beforeStepFactor = getBeforeStepValue(valueFactor, minFactorBase, stepFactor);

      if (beforeStepFactor === valueFactor) {
        return undefined;
      }

      if (beforeStepFactor > maxFactor) {
        beforeStepFactor = getBeforeStepValue(maxFactor, minFactorBase, stepFactor);
      } else if (beforeStepFactor < minFactor) {
        beforeStepFactor = minFactor;
      }

      var afterStepFactor = beforeStepFactor + stepFactor;
      var values = [beforeStepFactor / precisionFactor];

      if (afterStepFactor <= maxFactor) {
        values.push(afterStepFactor / precisionFactor);
      }

      return values;
    }
  } else if (isMoment(value)) {
    var hour = step.hour,
        minute = step.minute,
        second = step.second;

    if (second) {
      return getNearStepMoments(value, second, TimeUnit.second);
    }

    if (minute) {
      return getNearStepMoments(value, minute, TimeUnit.minute);
    }

    if (hour) {
      return getNearStepMoments(value, hour, TimeUnit.hour);
    }
  }
}
export function parseNumber(value, precision) {
  if (isNil(precision)) {
    return Number(value);
  }

  return Number(defaultFormatNumber(value, undefined, {
    maximumFractionDigits: precision,
    useGrouping: false
  }));
}
//# sourceMappingURL=utils.js.map