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

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

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getPrecision = getPrecision;
exports.plus = plus;
exports.getNearStepValues = getNearStepValues;
exports.parseNumber = parseNumber;
exports.MIN_SAFE_INTEGER = exports.MAX_SAFE_INTEGER = void 0;

var _moment = require("moment");

var _isNil = _interopRequireDefault(require("lodash/isNil"));

var _isNumber = _interopRequireDefault(require("lodash/isNumber"));

var _defaultTo = _interopRequireDefault(require("lodash/defaultTo"));

var _enum = require("../date-picker/enum");

var _formatNumber = _interopRequireDefault(require("../formatter/formatNumber"));

var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || Math.pow(2, 53) - 1;
exports.MAX_SAFE_INTEGER = MAX_SAFE_INTEGER;
var MIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER || -(Math.pow(2, 53) - 1);
exports.MIN_SAFE_INTEGER = MIN_SAFE_INTEGER;

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);
}

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)];
  }
}

function getNearStepValues(value, step, min, max) {
  if ((0, _isNumber["default"])(step)) {
    if ((0, _isNumber["default"])(value)) {
      min = (0, _defaultTo["default"])(Number(min), -MAX_SAFE_INTEGER);
      max = (0, _defaultTo["default"])(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 ((0, _moment.isMoment)(value)) {
    var hour = step.hour,
        minute = step.minute,
        second = step.second;

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

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

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

function parseNumber(value, precision) {
  if ((0, _isNil["default"])(precision)) {
    return Number(value);
  }

  return Number((0, _formatNumber["default"])(value, undefined, {
    maximumFractionDigits: precision,
    useGrouping: false
  }));
}
//# sourceMappingURL=utils.js.map