{"version":3,"file":"93748.cc0205cf102bc1879e0c.js","mappings":"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","sources":["webpack://[name]/./src/utils/TextFormatUtil.ts"],"sourcesContent":["/*\n * JM4Web TextFormatUtil\n */\nimport moment from \"moment\";\nexport default class TextFormatUtil{\n\n  static timeFormatValidator = /(((\\s*h+\\s*:\\s*mm\\s*:s+\\s*)|(\\s*mm\\s*:s+\\s*)|(\\s*h+\\s*:\\s*mm\\s*)|(\\s*s+\\s*)|(\\s*mm^m\\s*)|(\\s*h+\\s*))((AP\\s*|A\\s*|ap\\s*|a\\s*)?))/g;\n  static dateFormatValidator = /(((M+|mmmm)(.+)?(D+|d+)(.+)?(Y+|y+)(\\s+)?)|((D+|d+)(.+)?(M+|mmmm)(.+)?(Y+|y+)(\\s+)?)|((D+|d+)(.+)?(Y+|y+)(.+)?(M+|mmmm)(\\s+)?)|((M+|mmmm)(.+)?(Y+|y+)(.+)?(D+|d+)(\\s+)?)|((Y+|y+)(.+)?(M+|mmmm)(.+)?(D+|d+)(\\s+)?)|((Y+|y+)(.+)?(D+|d+)(.+)?(M+|mmmm)(\\s+)?)|((M+|mmmm)(.+)?(D+|d+)?(.+)?(Y+|y+)?(\\s+)?)|((Y+|y+)(.+)?(D+|d+)?(.+)?(M+|mmmm)?(\\s+)?)|((D+|d+)(.+)?(M+|mmmm)?(.+)?(Y+|y+)?(\\s+)?))/g;\n\n  static applyPadding(formatOpt, strValue) {\n      if (!formatOpt.isPadding)\n          return strValue;\n      // keep negative symbol \n      var isNegative = false;\n      if (strValue.charAt(0) == \"-\") {\n          isNegative = true;\n          strValue = strValue.substring(1);\n      }\n      // This code aligns with native runtime behavior when value is \"0\"\n      var dotPos = strValue.indexOf(\".\");\n      // Get the legnth of the integer part of the number\n      var integerLen;\n      // There is a dot in number\n      if (dotPos != -1) {\n          integerLen = dotPos;\n      }\n      // there is and exponential symbol\n      else if (formatOpt.ePos != -1) {\n          integerLen = strValue.indexOf(formatOpt.eSymbol);\n      }\n      // is just an integer number\n      else {\n          integerLen = strValue.length;\n      }\n      // Add padding\n      var padLength = formatOpt.leadingDigits - integerLen;\n      //strValue = strValue === \"0\" && padLength > 0 ? \"\" : strValue;\n      for (var i = 0; i < padLength; i++) {\n          if (formatOpt.format.charAt(i) == '0') {\n              strValue = '0' + strValue;\n          }\n      }\n      return isNegative ? \"-\" + strValue : strValue;\n  }\n\n  static formatINTValue(options, newValue, style, grouping) {\n      if (newValue != null) {\n          if (newValue === \"\") {\n              return newValue;\n          }\n          if (typeof newValue == \"string\" || typeof newValue == \"object\") {\n              return this.applyStyle(this.applyPadding(options, newValue), style, grouping);\n          }\n          return this.applyStyle(this.applyPadding(options, Math.round(newValue) + \"\"), style, grouping);\n      }\n  }\n\n  // Time: O(3n) - Space: memory allocation through String::substring\n  static applyStyle (strValue, style, groupingThousand) {\n      if (style) {\n          var changeDecimalSymbol = style.decimalSymbol != \".\" && style.decimalSymbol != \"\";\n          if (!changeDecimalSymbol && !groupingThousand) {\n              return strValue;\n          }\n          var indexOfDecimalSymbol = strValue.indexOf(\".\"); // O(n)\n          var newStrValue = strValue;\n          // Add symbol to group thousand\n          if (groupingThousand) {\n              newStrValue = \"\";\n              var strInteger = indexOfDecimalSymbol != -1 ? strValue.substring(0, indexOfDecimalSymbol) /*O(n)*/ : strValue;\n              for (var end = strInteger.length - 1, i = end; i >= 0; i--) // O(n)\n               {\n                  var digit = strInteger.charAt(i);\n                  if (groupingThousand && i < end && ((end - i) % style.digitsGrouping) == 0) {\n                      newStrValue = style.thousandSymbol + newStrValue;\n                  }\n                  newStrValue = digit + newStrValue;\n              }\n          }\n          // if decimal is present\n          if (indexOfDecimalSymbol != -1) {\n              // if is necessary a to use non standard symbol\n              if (changeDecimalSymbol) {\n                  // if I have group thousand I append the decimal part with new symbol\n                  if (groupingThousand) {\n                      return newStrValue + style.decimalSymbol + strValue.substring(indexOfDecimalSymbol + 1); // O(n)\n                  }\n                  // otherwise I just replace the symbol\n                  return strValue.replace(\".\", style.decimalSymbol);\n              }\n              else {\n                  if (groupingThousand) {\n                      return newStrValue + strValue.substring(indexOfDecimalSymbol); // O(n)\n                  }\n                  // Nothing to do, this should never verify\n                  return strValue;\n              }\n          }\n          // only the integer part I have done\n          return newStrValue;\n      }\n      // if no style return the input\n      return strValue;\n  }\n\n  static formatDecimalPlaces (options, newValue) {\n      var optionalDecimals = options.optionalDecimals;\n      var decimals = options.decimalPlaces;\n      if (newValue % 1 == 0 && decimals == optionalDecimals) {\n          return newValue.toString();\n      }\n      else {\n          if (optionalDecimals != 0) {\n              var normalizedNumber = newValue * Math.pow(10, decimals);\n              var end = false;\n              for (var i = 1; i <= optionalDecimals && !end; i++) {\n                  if (normalizedNumber % Math.pow(10, i) == 0) {\n                      decimals--;\n                  }\n                  else {\n                      end = true;\n                  }\n              }\n          }\n          return newValue.toFixed(decimals);\n      }\n  }\n  \n  static formatFLOATValue(options, newValue, style, groupingThousand) {\n      if (newValue != null) {\n          if (typeof newValue != \"number\")\n              newValue = parseFloat(newValue);\n          return this.applyStyle(this.applyPadding(options, this.formatDecimalPlaces(options, newValue)), style, groupingThousand);\n      }\n      return \"\";\n  }\n\n  static formatHexadecimalValue (options, newValue) {\n      var isHEXL = options.numericFormat == enNumericType.HEXL;\n      var hNum = parseInt(newValue);\n      var fl = hNum < 0 ? true : false;\n      hNum = hNum < 0 ? (0xFFFFFFFFFFFFF + hNum + 1) : hNum;\n      var strValue;\n      if (isHEXL)\n          strValue = hNum.toString(16);\n      else\n          strValue = hNum.toString(16).toUpperCase();\n      if (fl && strValue.length < 16) {\n          var pad1 = 16 - strValue.length;\n          for (var i = 0; i < pad1; i++) {\n              if (isHEXL)\n                  strValue = \"f\" + strValue;\n              else\n                  strValue = \"F\" + strValue;\n          }\n      }\n      return this.applyPadding(options, strValue);\n  }\n  \n  static formatExponentialValue(options, newValue, expDigits, style, groupingThousand) {\n      var strValue;\n      strValue = TextFormatUtil.scientificNotation(newValue, options.decimalPlaces, options.magnitudeDegree, expDigits);\n      var isUppercased = options.format.indexOf(\"E\") > 0;\n      if (isUppercased)\n          strValue = strValue.replace(\"e\", \"E\");\n      return this.applyStyle(this.applyPadding(options, strValue), style, groupingThousand);\n  }\n\n  static scientificNotation (value, decimals, coefficentDegree, expDigits) {\n      // Initalize elements\n      var minCoefficent = 1;\n      var maxCoefficent = coefficentDegree == 1 ? 10 : Math.pow(10, coefficentDegree);\n      var magnitude = 0;\n      var sign = value >= 0 ? 1 : -1;\n      value = value * sign; // abs\n      // Calculate mat\n      var normalizer = value > 0 && value < 1 ? 1 / maxCoefficent : maxCoefficent;\n      while ((value < minCoefficent || value >= maxCoefficent) && value !== 0) {\n          value /= normalizer;\n          magnitude += coefficentDegree;\n      }\n      return (sign * value).toFixed(decimals) + \"e\" + (normalizer == maxCoefficent ? \"+\" : \"-\") + (expDigits > 0 ? \"0\" : \"\") + magnitude;\n  }\n\n  static formatText(options, newValue, style, groupingThousand) {\n      var strValue;\n      switch (options.numericFormat) {\n          case enNumericType.INT:\n              strValue = this.formatINTValue(options, newValue, style, groupingThousand);\n              break;\n          case enNumericType.FLOAT:\n              strValue = this.formatFLOATValue(options, newValue, style, groupingThousand);\n              break;\n          case enNumericType.HEXL:\n              strValue = this.formatHexadecimalValue(options, newValue);\n              break;\n          case enNumericType.HEXU:\n              strValue = this.formatHexadecimalValue(options, newValue);\n              break;\n          case enNumericType.EXP:\n              strValue = this.formatExponentialValue(options, newValue, 0, style, groupingThousand);\n              break;\n          case enNumericType.EXPD:\n              strValue = this.formatExponentialValue(options, newValue, 1, style, groupingThousand);\n              break;\n          default:\n              strValue = this.applyPadding(options, newValue + \"\");\n              break;\n      }\n      return strValue;\n  }\n\n  static getIndexesOfSeparators(format) {\n      var indexSymbol = {\n          \"e\": -1,\n          \"E\": -1,\n          \"+\": -1,\n          \"-\": -1,\n          \",\": -1,\n          \"h\": -1,\n          \"H\": -1,\n          \".\": -1,\n          \"0\": -1,\n          \"#\": -1\n      };\n      for (var i = 0, len = format.length; i < len; i++) {\n          var char = format.charAt(i);\n          switch (char) {\n              case \"e\":\n              case \"E\":\n              case \"+\":\n              case \"-\":\n              case \",\":\n              case \"h\":\n              case \"H\":\n              case \".\":\n              case \"0\":\n              case \"#\":\n                  indexSymbol[char] = i;\n                  break;\n          }\n      }\n      return indexSymbol;\n  }\n\n  static countOptionalDecimalDigits (format, idxDot) {\n      var optionalDigits = 0;\n      var end = false;\n      for (var i = format.length - 1; i > idxDot && !end; i--) {\n          if (format.charAt(i) == '#') {\n              optionalDigits++;\n          }\n          else {\n              end = true;\n          }\n      }\n      return optionalDigits;\n  }\n\n  static countOptionalLeadingDigits (format, idxDot) {\n      var optionalDigits = 0;\n      var end = idxDot != -1 ? idxDot : format.length;\n      for (var i = 0; i < end; i++) {\n          if (format.charAt(i) == '#') {\n              optionalDigits++;\n          }\n      }\n      return optionalDigits;\n  }\n\n  static parseFormat (format) {\n      var formatType = enFormatType.NUMBER;\n      var numericFormat = enNumericType.INT;\n      var decimalPlaces = 0;\n      var optionalDecimals = 0;\n      var optionalLeading = 0;\n      var leadingDigits = 0;\n      var dotPos = -1;\n      var magnitudeDegree = 1;\n      var ePos = -1;\n      var eSymbol = \"\";\n      var hPos = -1;\n      var oldDigitsGrouping = -1;\n      if (format.toLowerCase() == \"none\") {\n          formatType = enFormatType.TEXT;\n      }\n      else {\n          // Get index of symbols\n          var indexOfSymbol = TextFormatUtil.getIndexesOfSeparators(format);\n          // Exponential\n          var indexOfE = indexOfSymbol.e != -1 ? indexOfSymbol.e : indexOfSymbol.E;\n          if (indexOfE != -1) {\n              eSymbol = indexOfSymbol.e != -1 ? \"e\" : \"E\";\n              numericFormat = enNumericType.EXP;\n              if (indexOfSymbol[\".\"] != -1) {\n                  dotPos = indexOfSymbol[\".\"];\n                  magnitudeDegree = dotPos;\n                  decimalPlaces = (indexOfE - dotPos) - 1;\n                  leadingDigits = indexOfSymbol[\".\"];\n              }\n              else {\n                  magnitudeDegree = indexOfE;\n                  decimalPlaces = 0;\n                  leadingDigits = indexOfE;\n              }\n              magnitudeDegree = magnitudeDegree > 0 ? magnitudeDegree : 1;\n              if (indexOfSymbol[\"+\"] != -1 && ((format.length - 1) - indexOfSymbol[\"+\"] >= 2)) {\n                  numericFormat = enNumericType.EXPD;\n              }\n          }\n          // Decimals\n          else if (indexOfSymbol[\".\"] != -1) {\n              numericFormat = enNumericType.FLOAT;\n              dotPos = indexOfSymbol[\".\"];\n              decimalPlaces = (format.length - 1) - dotPos;\n              optionalDecimals = TextFormatUtil.countOptionalDecimalDigits(format, dotPos);\n              leadingDigits = dotPos;\n          }\n          // Hex\n          else if (indexOfSymbol.h != -1 || indexOfSymbol.H != -1) {\n              numericFormat = indexOfSymbol.h != -1 ? enNumericType.HEXL : enNumericType.HEXU;\n              hPos = indexOfSymbol.h != -1 ? indexOfSymbol.h : indexOfSymbol.H;\n              leadingDigits = hPos;\n          }\n          // contains only # 0r 0\n          else {\n              if (indexOfSymbol[\"#\"] != -1 || indexOfSymbol[\"0\"]) {\n                  numericFormat = enNumericType.INT;\n                  leadingDigits = format.length;\n                  optionalLeading = this.countOptionalLeadingDigits(format, -1);\n                  // Old thousand\n                  if (indexOfSymbol[\",\"] != -1) {\n                      oldDigitsGrouping = (format.length - 1) - indexOfSymbol[\",\"];\n                  }\n              }\n              else {\n                  formatType = enFormatType.TEXT;\n              }\n          }\n      }\n      var isPadding = leadingDigits > 0 && leadingDigits > optionalLeading;\n      return {\n          format: format,\n          formatType: formatType,\n          numericFormat: numericFormat,\n          decimalPlaces: decimalPlaces,\n          isPadding: isPadding,\n          magnitudeDegree: magnitudeDegree,\n          dotPos: dotPos,\n          leadingDigits: leadingDigits,\n          hPos: hPos,\n          ePos: ePos,\n          eSymbol: eSymbol,\n          oldDigitsGrouping: oldDigitsGrouping,\n          optionalDecimals: optionalDecimals,\n          optionalLeading: optionalLeading\n      };\n  }\n\n  static format (options, value, style, groupingThousand) {\n      return TextFormatUtil.formatText(options, value, style, groupingThousand);\n  }\n\n  static addDecimalDigitsToFormat  (format, decimalDigits) {\n      format += \".\";\n      for (var i = 0; i < decimalDigits; i++) {\n          format += \"0\";\n      }\n      return format;\n  }\n\n  static addLeadingDigitsToFormat (format, leadingDigits) {\n      for (var i = 1; i < leadingDigits; i++) {\n          format = \"0\" + format;\n      }\n      return format;\n  }\n\n  static generateDynamicFormat (options) {\n      var format = options.format;\n      if (format.indexOf(\"h\") >= 0)\n          format = \"#h\";\n      else if (format.indexOf(\"H\") >= 0)\n          format = \"#H\";\n      else\n          format = \"#\";\n      if (options.decimalPlaces !== undefined && format === \"#\") {\n          if (options.decimalPlaces > 0) {\n              format = TextFormatUtil.addDecimalDigitsToFormat(format, options.decimalPlaces);\n          }\n      }\n      if (options.leadingDigits !== undefined) {\n          if (options.leadingDigits > 0) {\n              format = this.addLeadingDigitsToFormat(format, options.leadingDigits);\n          }\n      }\n      return format;\n  }\n\n  static containsD (format, strD) {\n      var numberOfD = strD.length;\n      var idxTwoLowerD = format.indexOf(strD);\n      if (idxTwoLowerD != -1) {\n          var len = format.length;\n          return (idxTwoLowerD - 1 > 0 && format.charAt(idxTwoLowerD - 1) != \"d\" || idxTwoLowerD - 1 == -1) &&\n              (idxTwoLowerD + numberOfD < (len - numberOfD) && format.charAt(idxTwoLowerD + numberOfD) != \"d\" || idxTwoLowerD + numberOfD == len);\n      }\n      return false;\n  }\n\n  static parseDateTimeFormat (format, configuration) {\n      // Check global format configuration\n      if (format == \"LONG-DATE\") {\n          format = configuration.longDateFormat != undefined ? configuration.longDateFormat : format;\n      }\n      else if (format == \"SHORT-DATE\") {\n          format = configuration.shortDateFormat != undefined ? configuration.shortDateFormat : format;\n      }\n      var formatOptions = {\n          format: format,\n          formatType: enFormatType.DATETIME,\n      };\n      // Convert to moment format\n      var idx_AP = formatOptions.format.indexOf(\"AP\");\n      var idx_ap = formatOptions.format.indexOf(\"ap\");\n      if (idx_AP != -1 || idx_ap != -1) {\n          formatOptions.format = idx_AP != -1 ? formatOptions.format.replace(\"AP\", \"A\") : formatOptions.format.replace(\"ap\", \"a\");\n          formatOptions.format = formatOptions.format.replace(\"HH\", \"hh\");\n      }\n      else {\n          formatOptions.format = formatOptions.format.replace(\"hh\", \"HH\");\n      }\n      // Replace years to uppercase. Native runtime serializes Y and y with no difference\n      formatOptions.format = formatOptions.format.replace(/y/g, \"Y\");\n      // Convert dd->DD. Native runtime serialize DD and dd with no difference\n      if (TextFormatUtil.containsD(formatOptions.format, \"dd\") || TextFormatUtil.containsD(formatOptions.format, \"d\")) {\n          formatOptions.format = formatOptions.format.replace(/d/g, \"D\");\n      }\n      // Convert mmmm->MMMM. Studio sometimes serializes mmmm instead of MMMM\n      formatOptions.format = formatOptions.format.replace(/m{4}/, \"MMMM\");\n      // Convert DDDD->dddd. Moment.js requirement\n      formatOptions.format = formatOptions.format.replace(/D{4}/, \"dddd\");\n      // Convert DDD->ddd. Moment.js requirement\n      formatOptions.format = formatOptions.format.replace(/D{3}/, \"ddd\");\n      return formatOptions;\n  }\n  \n  static formatDateTime (value, timeSpec, formatOpt, config) {\n      var mT = moment(value);\n      switch (timeSpec) {\n          case \"global\":\n              mT.utcOffset(0);\n              break;\n          case \"server\":\n              var serverOffset;\n              if (config.serverOffset !== undefined) {\n                  serverOffset = config.serverOffset;\n                  /* Note: 65536 value stay for GMT 0.00 */\n                  if (serverOffset > 720) {\n                      serverOffset -= 65536;\n                  }\n              }\n              else {\n                  serverOffset = 0;\n              }\n              mT.utcOffset(serverOffset);\n      }\n      // Intregrate millisecond format for trend table with sampling 1/10;\n      var format = formatOpt.format;\n      if (formatOpt.milliseconds) {\n          format = formatOpt.format.replace(/ss/i, \"ss.SSS\");\n      }\n      if (formatOpt.locale) {\n          mT.locale(formatOpt.locale);\n      }\n      return mT.format(format);\n  }\n}\n\nenum enNumericType {\n\tINT = 0,\n\tFLOAT = 1,\n\tHEXL = 2,\n\tHEXU = 3,\n\tEXP = 4,\n\tEXPD = 5,\n\tTHOUSAND = 6\n}\n\nenum enFormatType {\n\tTEXT = 0,\n\tNUMBER = 1,\n\tDATETIME = 2\n}\n\nexport function abbreviate(value: number): string {\n    // cannot calculate log10(0)\n    if (value == 0) return \"0\";\n    let str = \"\" + value\n    if(str.length < 6) {\n      return str;\n    }\n  \n    const abbr = [\"\", \"k\", \"M\", \"B\"];\n    const digs = Math.floor(Math.log10(value));\n    const abbrIdx = Math.floor(digs / 3);\n    const abbrFigs = digs % 3;\n    const abbrVal = Math.floor(value / Math.pow(10, digs - abbrFigs));\n    return abbrVal + abbr[abbrIdx];\n  }"],"names":["formatOpt","strValue","isNegative","dotPos","integerLen","padLength","i","options","newValue","style","grouping","groupingThousand","changeDecimalSymbol","indexOfDecimalSymbol","newStrValue","strInteger","end","digit","optionalDecimals","decimals","normalizedNumber","isHEXL","enNumericType","hNum","fl","pad1","expDigits","TextFormatUtil","isUppercased","value","coefficentDegree","minCoefficent","maxCoefficent","magnitude","sign","normalizer","format","indexSymbol","len","char","idxDot","optionalDigits","formatType","enFormatType","numericFormat","decimalPlaces","optionalLeading","leadingDigits","magnitudeDegree","ePos","eSymbol","hPos","oldDigitsGrouping","indexOfSymbol","indexOfE","isPadding","decimalDigits","strD","numberOfD","idxTwoLowerD","configuration","formatOptions","idx_AP","idx_ap","timeSpec","config","mT","serverOffset","abbreviate","str","abbr","digs","abbrIdx","abbrFigs","abbrVal"],"sourceRoot":""}