hyperformula/commonjs/format/format.js

HyperFormula is a JavaScript engine for efficient processing of spreadsheet-like data and formulas

"use strict";

require("core-js/modules/es.array.slice.js");

require("core-js/modules/es.function.name.js");

require("core-js/modules/es.array.from.js");

require("core-js/modules/es.string.iterator.js");

require("core-js/modules/es.symbol.js");

require("core-js/modules/es.symbol.description.js");

require("core-js/modules/es.symbol.iterator.js");

require("core-js/modules/es.array.iterator.js");

require("core-js/modules/web.dom-collections.iterator.js");

exports.__esModule = true;
exports.defaultStringifyDateTime = defaultStringifyDateTime;
exports.defaultStringifyDuration = defaultStringifyDuration;
exports.format = format;
exports.padLeft = padLeft;
exports.padRight = padRight;

require("core-js/modules/es.regexp.exec.js");

require("core-js/modules/es.string.split.js");

require("core-js/modules/es.object.to-string.js");

require("core-js/modules/es.regexp.to-string.js");

require("core-js/modules/es.number.constructor.js");

require("core-js/modules/es.number.to-fixed.js");

require("core-js/modules/es.string.starts-with.js");

var _DateTimeDefault = require("../DateTimeDefault");

var _DateTimeHelper = require("../DateTimeHelper");

var _parser = require("./parser");

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function format(value, formatArg, config, dateHelper) {
  var tryDateTime = config.stringifyDateTime(dateHelper.numberToSimpleDateTime(value), formatArg); // default points to defaultStringifyDateTime()

  if (tryDateTime !== undefined) {
    return tryDateTime;
  }

  var tryDuration = config.stringifyDuration((0, _DateTimeHelper.numberToSimpleTime)(value), formatArg);

  if (tryDuration !== undefined) {
    return tryDuration;
  }

  var expression = (0, _parser.parseForNumberFormat)(formatArg);

  if (expression !== undefined) {
    return numberFormat(expression.tokens, value);
  }

  return formatArg;
}

function padLeft(number, size) {
  var result = number + '';

  while (result.length < size) {
    result = '0' + result;
  }

  return result;
}

function padRight(number, size) {
  var result = number + '';

  while (result.length < size) {
    result = result + '0';
  }

  return result;
}

function countChars(text, char) {
  return text.split(char).length - 1;
}

function numberFormat(tokens, value) {
  var result = '';

  for (var i = 0; i < tokens.length; ++i) {
    var token = tokens[i];

    if (token.type === _parser.TokenType.FREE_TEXT) {
      result += token.value;
      continue;
    }

    var tokenParts = token.value.split('.');
    var integerFormat = tokenParts[0];
    var decimalFormat = tokenParts[1] || '';
    var separator = tokenParts[1] ? '.' : '';
    /* get fixed-point number without trailing zeros */

    var valueParts = Number(value.toFixed(decimalFormat.length)).toString().split('.');
    var integerPart = valueParts[0] || '';
    var decimalPart = valueParts[1] || '';

    if (integerFormat.length > integerPart.length) {
      var padSizeInteger = countChars(integerFormat.substr(0, integerFormat.length - integerPart.length), '0');
      integerPart = padLeft(integerPart, padSizeInteger + integerPart.length);
    }

    var padSizeDecimal = countChars(decimalFormat.substr(decimalPart.length, decimalFormat.length - decimalPart.length), '0');
    decimalPart = padRight(decimalPart, padSizeDecimal + decimalPart.length);
    result += integerPart + separator + decimalPart;
  }

  return result;
}

function defaultStringifyDuration(time, formatArg) {
  var expression = (0, _parser.parseForDateTimeFormat)(formatArg);

  if (expression === undefined) {
    return undefined;
  }

  var tokens = expression.tokens;
  var result = '';

  var _iterator = _createForOfIteratorHelper(tokens),
      _step;

  try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var token = _step.value;

      if (token.type === _parser.TokenType.FREE_TEXT) {
        result += token.value;
        continue;
      }

      if (_DateTimeDefault.secondsExtendedRegexp.test(token.value)) {
        var fractionOfSecondPrecision = token.value.length - 3;
        result += (time.seconds < 10 ? '0' : '') + Math.round(time.seconds * Math.pow(10, fractionOfSecondPrecision)) / Math.pow(10, fractionOfSecondPrecision);
        continue;
      }

      switch (token.value.toLowerCase()) {
        case 'h':
        case 'hh':
          {
            result += padLeft(time.hours, token.value.length);
            time.hours = 0;
            break;
          }

        case '[hh]':
          {
            result += padLeft(time.hours, token.value.length - 2);
            time.hours = 0;
            break;
          }

        case 'm':
        case 'mm':
          {
            result += padLeft(time.minutes, token.value.length);
            time.minutes = 0;
            break;
          }

        case '[mm]':
          {
            result += padLeft(time.minutes + 60 * time.hours, token.value.length - 2);
            time.minutes = 0;
            time.hours = 0;
            break;
          }

        /* seconds */

        case 's':
        case 'ss':
          {
            result += padLeft(time.seconds, token.value.length);
            break;
          }

        default:
          {
            return undefined;
          }
      }
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }

  return result;
}

function defaultStringifyDateTime(dateTime, formatArg) {
  var expression = (0, _parser.parseForDateTimeFormat)(formatArg);

  if (expression === undefined) {
    return undefined;
  }

  var tokens = expression.tokens;
  var result = '';
  var minutes = false;
  var ampm = tokens.some(function (token) {
    return token.type === _parser.TokenType.FORMAT && (token.value === 'a/p' || token.value === 'A/P' || token.value === 'am/pm' || token.value === 'AM/PM');
  });

  for (var i = 0; i < tokens.length; i++) {
    var token = tokens[i];

    if (token.type === _parser.TokenType.FREE_TEXT) {
      result += token.value;
      continue;
    }

    if (_DateTimeDefault.secondsExtendedRegexp.test(token.value)) {
      var fractionOfSecondPrecision = token.value.length - 3;
      result += (dateTime.seconds < 10 ? '0' : '') + Math.round(dateTime.seconds * Math.pow(10, fractionOfSecondPrecision)) / Math.pow(10, fractionOfSecondPrecision);
      continue;
    }

    switch (token.value.toLowerCase()) {
      /* hours*/
      case 'h':
      case 'hh':
        {
          minutes = true;
          result += padLeft(ampm ? (dateTime.hours + 11) % 12 + 1 : dateTime.hours, token.value.length);
          break;
        }

      /* days */

      case 'd':
      case 'dd':
        {
          result += padLeft(dateTime.day, token.value.length);
          break;
        }

      /* seconds */

      case 's':
      case 'ss':
        {
          result += padLeft(Math.round(dateTime.seconds), token.value.length);
          break;
        }

      /* minutes / months */

      case 'm':
      case 'mm':
        {
          if (i + 1 < tokens.length && tokens[i + 1].value.startsWith(':')) {
            minutes = true;
          }

          if (minutes) {
            result += padLeft(dateTime.minutes, token.value.length);
          } else {
            result += padLeft(dateTime.month, token.value.length);
          }

          minutes = true;
          break;
        }

      /* years */

      case 'yy':
        {
          result += padLeft(dateTime.year % 100, token.value.length);
          break;
        }

      case 'yyyy':
        {
          result += dateTime.year;
          break;
        }

      /* AM / PM */

      case 'am/pm':
      case 'a/p':
        {
          var _token$value$split = token.value.split('/'),
              _token$value$split2 = _slicedToArray(_token$value$split, 2),
              am = _token$value$split2[0],
              pm = _token$value$split2[1];

          result += dateTime.hours < 12 ? am : pm;
          break;
        }

      default:
        {
          return undefined;
        }
    }
  }

  return result;
}