hyperformula-dc/commonjs/CellContentParser.js

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

"use strict";

require("core-js/modules/es.object.to-string.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.isFormula = isFormula;
exports.isBoolean = isBoolean;
exports.isError = isError;
exports.CellContentParser = exports.CellContent = void 0;

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

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

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

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

var _Cell = require("./Cell");

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

var _errorMessage = require("./error-message");

var _errors = require("./errors");

var _ArithmeticHelper = require("./interpreter/ArithmeticHelper");

var _InterpreterValue = require("./interpreter/InterpreterValue");

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 _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var CellContent;
exports.CellContent = CellContent;

(function (CellContent) {
  var Number = function Number(value) {
    _classCallCheck(this, Number);

    this.value = value;
    this.value = (0, _InterpreterValue.cloneNumber)(this.value, (0, _ArithmeticHelper.fixNegativeZero)((0, _InterpreterValue.getRawValue)(this.value)));
  };

  CellContent.Number = Number;

  var String = function String(value) {
    _classCallCheck(this, String);

    this.value = value;
  };

  CellContent.String = String;

  var Boolean = function Boolean(value) {
    _classCallCheck(this, Boolean);

    this.value = value;
  };

  CellContent.Boolean = Boolean;

  var Empty = /*#__PURE__*/function () {
    function Empty() {
      _classCallCheck(this, Empty);
    }

    _createClass(Empty, null, [{
      key: "getSingletonInstance",
      value: function getSingletonInstance() {
        if (!Empty.instance) {
          Empty.instance = new Empty();
        }

        return Empty.instance;
      }
    }]);

    return Empty;
  }();

  CellContent.Empty = Empty;

  var Formula = function Formula(formula) {
    _classCallCheck(this, Formula);

    this.formula = formula;
  };

  CellContent.Formula = Formula;

  var Error = function Error(errorType, message) {
    _classCallCheck(this, Error);

    this.value = new _Cell.CellError(errorType, message);
  };

  CellContent.Error = Error;
})(CellContent || (exports.CellContent = CellContent = {}));
/**
 * Checks whether string looks like formula or not.
 *
 * @param text - formula
 */


function isFormula(text) {
  return text.startsWith('=');
}

function isBoolean(text) {
  var tl = text.toLowerCase();
  return tl === 'true' || tl === 'false';
}

function isError(text, errorMapping) {
  var upperCased = text.toUpperCase();
  var errorRegex = /#[A-Za-z0-9\/]+[?!]?/;
  return errorRegex.test(upperCased) && Object.prototype.hasOwnProperty.call(errorMapping, upperCased);
}

var CellContentParser = /*#__PURE__*/function () {
  function CellContentParser(config, dateHelper, numberLiteralsHelper) {
    _classCallCheck(this, CellContentParser);

    this.config = config;
    this.dateHelper = dateHelper;
    this.numberLiteralsHelper = numberLiteralsHelper;
  }

  _createClass(CellContentParser, [{
    key: "currencyMatcher",
    value: function currencyMatcher(token) {
      var _iterator = _createForOfIteratorHelper(this.config.currencySymbol),
          _step;

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

          if (token.startsWith(currency)) {
            return [currency, token.slice(currency.length)];
          }

          if (token.endsWith(currency)) {
            return [currency, token.slice(0, token.length - currency.length)];
          }
        }
      } catch (err) {
        _iterator.e(err);
      } finally {
        _iterator.f();
      }

      return undefined;
    }
  }, {
    key: "parse",
    value: function parse(content) {
      if (content === undefined || content === null) {
        return CellContent.Empty.getSingletonInstance();
      } else if (typeof content === 'number') {
        if ((0, _ArithmeticHelper.isNumberOverflow)(content)) {
          return new CellContent.Error(_Cell.ErrorType.NUM, _errorMessage.ErrorMessage.ValueLarge);
        } else {
          return new CellContent.Number(content);
        }
      } else if (typeof content === 'boolean') {
        return new CellContent.Boolean(content);
      } else if (content instanceof Date) {
        var dateVal = this.dateHelper.dateToNumber({
          day: content.getDate(),
          month: content.getMonth() + 1,
          year: content.getFullYear()
        });
        var timeVal = (0, _DateTimeHelper.timeToNumber)({
          hours: content.getHours(),
          minutes: content.getMinutes(),
          seconds: content.getSeconds() + content.getMilliseconds() / 1000
        });
        var val = dateVal + timeVal;

        if (val < 0) {
          return new CellContent.Error(_Cell.ErrorType.NUM, _errorMessage.ErrorMessage.DateBounds);
        }

        if (val % 1 === 0) {
          return new CellContent.Number(new _InterpreterValue.DateNumber(val, 'Date()'));
        } else if (val < 1) {
          return new CellContent.Number(new _InterpreterValue.TimeNumber(val, 'Date()'));
        } else {
          return new CellContent.Number(new _InterpreterValue.DateTimeNumber(val, 'Date()'));
        }
      } else if (typeof content === 'string') {
        if (isBoolean(content)) {
          return new CellContent.Boolean(content.toLowerCase() === 'true');
        } else if (isFormula(content)) {
          return new CellContent.Formula(content);
        } else if (isError(content, this.config.errorMapping)) {
          return new CellContent.Error(this.config.errorMapping[content.toUpperCase()]);
        } else {
          var trimmedContent = content.trim();
          var mode = 0;
          var currency;

          if (trimmedContent.endsWith('%')) {
            mode = 1;
            trimmedContent = trimmedContent.slice(0, trimmedContent.length - 1);
          } else {
            var res = this.currencyMatcher(trimmedContent);

            if (res !== undefined) {
              mode = 2;

              var _res = _slicedToArray(res, 2);

              currency = _res[0];
              trimmedContent = _res[1];
            }
          }

          var _val = this.numberLiteralsHelper.numericStringToMaybeNumber(trimmedContent);

          if (_val !== undefined) {
            var parseAsNum;

            if (mode === 1) {
              parseAsNum = new _InterpreterValue.PercentNumber(_val / 100);
            } else if (mode === 2) {
              parseAsNum = new _InterpreterValue.CurrencyNumber(_val, currency);
            } else {
              parseAsNum = _val;
            }

            return new CellContent.Number(parseAsNum);
          }

          var parsedDateNumber = this.dateHelper.dateStringToDateNumber(trimmedContent);

          if (parsedDateNumber !== undefined) {
            return new CellContent.Number(parsedDateNumber);
          } else {
            return new CellContent.String(content.startsWith('\'') ? content.slice(1) : content);
          }
        }
      } else {
        throw new _errors.UnableToParseError(content);
      }
    }
  }]);

  return CellContentParser;
}();

exports.CellContentParser = CellContentParser;