choerodon-ui/dataset/utils/index.js

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

"use strict";

var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard")["default"];

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

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.MIN_SAFE_INTEGER = exports.MAX_SAFE_INTEGER = void 0;
exports.bigNumberToFixed = bigNumberToFixed;
exports["default"] = void 0;
exports.getDateFormatByField = getDateFormatByField;
exports.getDateFormatByFieldType = getDateFormatByFieldType;
exports.getGlobalConfig = getGlobalConfig;
exports.getNearStepValues = getNearStepValues;
exports.getNumberFormatOptions = getNumberFormatOptions;
exports.getPrecision = getPrecision;
exports.isEmpty = isEmpty;
exports.isSame = isSame;
exports.isSameLike = isSameLike;
exports.isValidBigNumber = isValidBigNumber;
exports.normalizeLanguage = normalizeLanguage;
exports.parseBigNumber = parseBigNumber;
exports.parseNumber = parseNumber;
exports.plus = plus;
exports.toLocaleStringPolyfill = toLocaleStringPolyfill;
exports.toLocaleStringSupportsLocales = toLocaleStringSupportsLocales;
exports.toRangeValue = toRangeValue;
exports.warning = warning;

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

var _moment = _interopRequireWildcard(require("moment"));

var _mobx = require("mobx");

var _warning = _interopRequireDefault(require("warning"));

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

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

var _isObject = _interopRequireDefault(require("lodash/isObject"));

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

var _isEqual = _interopRequireDefault(require("lodash/isEqual"));

var _isString = _interopRequireDefault(require("lodash/isString"));

var _bignumber = require("bignumber.js");

var _enum = require("../enum");

var _enum2 = require("../data-set/enum");

var _configure = require("../configure");

var _formatter = require("../formatter");

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 || 1 - Math.pow(2, 53);
exports.MIN_SAFE_INTEGER = MIN_SAFE_INTEGER;
var warned = {};

function warning(valid, message) {
  if (!valid && !warned[message]) {
    (0, _warning["default"])(false, message);
    warned[message] = true;
  }
}

function isEmpty(value) {
  return (0, _isNil["default"])(value) || value === '';
}

function isSame(newValue, oldValue) {
  return newValue === oldValue || isEmpty(newValue) && isEmpty(oldValue) || (0, _isEqual["default"])(newValue, oldValue);
}

function isSameLike(newValue, oldValue) {
  /* eslint-disable-next-line */
  return isSame(newValue, oldValue) || newValue == oldValue;
}

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

  return Number((0, _formatter.formatNumber)(value, undefined, {
    maximumFractionDigits: precision,
    useGrouping: false
  }));
}

function parseBigNumber(value, precision, defaultValue) {
  var valueBig = new _bignumber.BigNumber(value);
  precision = !isEmpty(precision) && precision >= 0 && isFinite(precision) ? new _bignumber.BigNumber(precision).integerValue(_bignumber.BigNumber.ROUND_DOWN).toNumber() : valueBig.decimalPlaces();
  return bigNumberToFixed(valueBig, precision, defaultValue);
}

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 isValidBigNumber(bigNumber) {
  return !!bigNumber && !bigNumber.isNaN() && bigNumber.isFinite();
}

function bigNumberToFixed(bigNumber, precision, defaultValue) {
  return isValidBigNumber(bigNumber) ? bigNumber.toFixed((0, _defaultTo["default"])(precision, bigNumber.decimalPlaces())) : defaultValue;
}

function getBigBeforeStepValue(valueFactorBig, minOrMaxFactorBig, stepFactorBig) {
  // value - ((value - minFactor) % stepFactor)
  return valueFactorBig.minus(valueFactorBig.minus(minOrMaxFactorBig).modulo(stepFactorBig));
}

function getBigNumberNearStepValues(value, step, min, max) {
  if (isEmpty(min)) {
    return undefined;
  }

  var valueBig = new _bignumber.BigNumber(value);
  var minBig = new _bignumber.BigNumber(min);
  var stepBig = new _bignumber.BigNumber(step);
  var maxBig;

  if (isEmpty(max)) {
    maxBig = valueBig.plus(step);
  } else {
    maxBig = new _bignumber.BigNumber(max);
  }

  var maxDecimal = Math.max(valueBig.decimalPlaces(), stepBig.decimalPlaces());
  var precisionFactorBig = new _bignumber.BigNumber(10).exponentiatedBy(maxDecimal);
  var valueFactorBig = valueBig.multipliedBy(precisionFactorBig);
  var minFactorBig = new _bignumber.BigNumber(minBig.multipliedBy(precisionFactorBig).toFixed(0));
  var stepFactorBig = stepBig.multipliedBy(precisionFactorBig);
  var maxFactorBig = new _bignumber.BigNumber(maxBig.multipliedBy(precisionFactorBig).toFixed(0)); // min 等于最小安全数时, 且 max 小于 0, 设置 step 计算起点为: Math.floor(max / step) * step

  var minFactorBase = minBig.isEqualTo(-MAX_SAFE_INTEGER) ? maxBig.isLessThan(0) ? stepBig.multipliedBy(maxBig.dividedBy(stepBig).toFormat(0, _bignumber.BigNumber.ROUND_FLOOR)) : new _bignumber.BigNumber(0) : minBig;
  var minFactorBaseBig = new _bignumber.BigNumber(minFactorBase.multipliedBy(precisionFactorBig).toFixed(0));
  var beforeStepFactorBig = getBigBeforeStepValue(valueFactorBig, minFactorBaseBig, stepFactorBig);

  if (beforeStepFactorBig.isEqualTo(valueFactorBig)) {
    return undefined;
  }

  if (beforeStepFactorBig.isGreaterThan(maxFactorBig)) {
    beforeStepFactorBig = getBigBeforeStepValue(maxFactorBig, minFactorBaseBig, stepFactorBig);
  } else if (beforeStepFactorBig.isLessThan(minFactorBig)) {
    beforeStepFactorBig = minFactorBig;
  }

  var afterStepFactorBig = beforeStepFactorBig.plus(stepFactorBig);
  var values = [bigNumberToFixed(beforeStepFactorBig.dividedBy(precisionFactorBig), undefined, String(value))];

  if (afterStepFactorBig.isLessThanOrEqualTo(maxFactorBig) && afterStepFactorBig.dividedBy(precisionFactorBig).isLessThanOrEqualTo(maxBig)) {
    values.push(bigNumberToFixed(afterStepFactorBig.dividedBy(precisionFactorBig), undefined, String(value)));
  }

  return values;
}

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, isBigNumber) {
  if ((0, _moment.isMoment)(value)) {
    if (!(0, _isNumber["default"])(step) && !(0, _isString["default"])(step)) {
      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);
      }
    }
  } else if (!isEmpty(value) && !!step && (0, _typeof2["default"])(step) !== 'object') {
    if (isBigNumber) {
      return getBigNumberNearStepValues(value, step, min, max);
    }

    min = (0, _defaultTo["default"])(Number(min), -MAX_SAFE_INTEGER);
    max = (0, _defaultTo["default"])(Number(max), MAX_SAFE_INTEGER);
    var precisionFactor = getPrecisionFactor(Number(value), Number(step));
    var valueFactor = precisionFix(Number(value), precisionFactor);
    var minFactor = precisionFix(min, precisionFactor); // min 等于最小安全数时, 且 max 小于 0, 设置 step 计算起点为: Math.floor(max / step) * step

    var minFactorBase = min === -MAX_SAFE_INTEGER ? max < 0 ? precisionFix(Math.floor(max / Number(step)) * Number(step), precisionFactor) : 0 : minFactor;
    var maxFactor = precisionFix(max, precisionFactor);
    var stepFactor = precisionFix(Number(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 && afterStepFactor / precisionFactor <= max) {
      values.push(afterStepFactor / precisionFactor);
    }

    return values;
  }
}

function getGlobalConfig(key, field) {
  if (field) {
    return field.dataSet.getConfig(key);
  }

  return (0, _configure.getConfig)(key);
}

function getDateFormatByFieldType(type, field) {
  var formatter = getGlobalConfig('formatter', field);

  switch (type) {
    case _enum2.FieldType.date:
      return formatter.date;

    case _enum2.FieldType.dateTime:
      return formatter.dateTime;

    case _enum2.FieldType.week:
      return formatter.week;

    case _enum2.FieldType.month:
      return formatter.month;

    case _enum2.FieldType.year:
      return formatter.year;

    case _enum2.FieldType.time:
      return formatter.time;

    default:
      return formatter.date;
  }
}

function getDateFormatByField(field, type, record) {
  if (field) {
    return field.get('format', record) || getDateFormatByFieldType(type || field.get('type', record), field);
  }

  if (type) {
    return getDateFormatByFieldType(type, field);
  }

  return getGlobalConfig('formatter', field).jsonDate || _moment["default"].defaultFormat;
}

var supportsLocales;

function toLocaleStringSupportsLocales() {
  if (supportsLocales === undefined) {
    try {
      0 .toLocaleString('i');
      supportsLocales = false;
    } catch (e) {
      supportsLocales = e.name === 'RangeError';
    }
  }

  return supportsLocales;
}

function getNumberFormatOptions(type, options) {
  if (type === _enum2.FieldType.number) {
    return {
      style: 'decimal'
    };
  }

  if (options && options.currency) {
    return {
      style: 'currency'
    };
  }

  return {
    style: 'decimal',
    minimumFractionDigits: 2,
    maximumFractionDigits: 2
  };
}

function toLocaleStringPolyfill(value, type, options) {
  if (type === _enum2.FieldType.number) {
    var fraction = String(value).split('.')[1];
    return value.toLocaleString().split('.')[0] + (fraction ? ".".concat(fraction) : '');
  }

  var currency = options && options.currency;
  return "".concat(currency ? "".concat(currency, " ") : '').concat(value.toLocaleString());
}

function toRangeValue(value, range) {
  if ((0, _mobx.isArrayLike)(range)) {
    if ((0, _mobx.isObservableObject)(value)) {
      return [(0, _mobx.get)(value, range[0]), (0, _mobx.get)(value, range[1])];
    }

    if ((0, _isObject["default"])(value)) {
      return [value[range[0]], value[range[1]]];
    }
  } else if ((0, _mobx.isArrayLike)(value)) {
    return value.slice(0, 2);
  }

  return [undefined, undefined];
}

function normalizeLanguage(language) {
  return language && language.replace('_', '-').toLowerCase();
}

var _default = {
  MAX_SAFE_INTEGER: MAX_SAFE_INTEGER,
  MIN_SAFE_INTEGER: MIN_SAFE_INTEGER,
  warning: warning,
  isEmpty: isEmpty,
  isSame: isSame,
  isSameLike: isSameLike,
  parseNumber: parseNumber,
  getPrecision: getPrecision,
  plus: plus,
  getNearStepValues: getNearStepValues,
  getDateFormatByFieldType: getDateFormatByFieldType,
  getDateFormatByField: getDateFormatByField,
  toLocaleStringSupportsLocales: toLocaleStringSupportsLocales,
  getNumberFormatOptions: getNumberFormatOptions,
  toLocaleStringPolyfill: toLocaleStringPolyfill,
  toRangeValue: toRangeValue,
  normalizeLanguage: normalizeLanguage,
  isValidBigNumber: isValidBigNumber,
  bigNumberToFixed: bigNumberToFixed,
  parseBigNumber: parseBigNumber,
  formatFileSize: _formatter.formatFileSize
};
exports["default"] = _default;
//# sourceMappingURL=index.js.map