@aemforms/af-formatters 0.22.30 → 0.22.32

package/lib/date/SkeletonParser.js

@@ -0,0 +1,319 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ShorthandStyles = void 0;
+exports.getSkeleton = getSkeleton;
+exports.parseDateTimeSkeleton = parseDateTimeSkeleton;
+
+/*************************************************************************
+* ADOBE CONFIDENTIAL
+* ___________________
+*
+* Copyright 2022 Adobe
+* All Rights Reserved.
+*
+* NOTICE: All information contained herein is, and remains
+* the property of Adobe and its suppliers, if any. The intellectual
+* and technical concepts contained herein are proprietary to Adobe
+* and its suppliers and are protected by all applicable intellectual
+* property laws, including trade secret and copyright laws.
+* Dissemination of this information or reproduction of this material
+* is strictly forbidden unless prior written permission is obtained
+* from Adobe.
+
+* Adobe permits you to use and modify this file solely in accordance with
+* the terms of the Adobe license agreement accompanying it.
+*************************************************************************/
+
+/**
+ * https://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
+ * Credit: https://git.corp.adobe.com/dc/dfl/blob/master/src/patterns/parseDateTimeSkeleton.js
+ * Created a separate library to be used elsewhere as well.
+ */
+const DATE_TIME_REGEX = // eslint-disable-next-line max-len
+/(?:[Eec]{1,6}|G{1,5}|[Qq]{1,5}|(?:[yYur]+|U{1,5})|[ML]{1,5}|d{1,2}|D{1,3}|F{1}|[abB]{1,5}|[hkHK]{1,2}|w{1,2}|W{1}|m{1,2}|s{1,2}|[zZOvV]{1,5}|[zZOvVxX]{1,3}|S{1,3}|'(?:[^']|'')*')|[^a-zA-Z']+/g;
+const ShorthandStyles = ["full", "long", "medium", "short"];
+exports.ShorthandStyles = ShorthandStyles;
+const testDate = new Date(2000, 2, 1, 2, 3, 4);
+/**
+ * Since the formatted month names are different than standalone month names, we need to identify the correct option
+ * to pass for formatting
+ * @param value {string} formatted value of the month
+ * @param language {string} language in which the month is formatted
+ * @param isMediumFormatStyle {boolean} if shorthand style used for formatting was medium
+ */
+
+function deduceMonthOption(value, language, isMediumFormatStyle) {
+  const formattedMarch = value;
+  const longMarch = new Intl.DateTimeFormat(language, {
+    month: 'long'
+  }).formatToParts(testDate)[0].value;
+  const shortMarch = new Intl.DateTimeFormat(language, {
+    month: 'short'
+  }).formatToParts(testDate)[0].value;
+  const monthOptions = {
+    [longMarch]: 'long',
+    [shortMarch]: 'short',
+    '03': '2-digit',
+    '3': 'numeric'
+  };
+
+  if (formattedMarch !== undefined) {
+    monthOptions[formattedMarch] = isMediumFormatStyle ? 'short' : 'long';
+  }
+
+  return monthOptions[value];
+}
+
+function getSkeleton(skeleton, language) {
+  if (ShorthandStyles.find(type => skeleton.includes(type))) {
+    const parsed = parseDateStyle(skeleton, language);
+    const result = [];
+    const symbols = {
+      month: 'M',
+      year: 'Y',
+      day: 'd'
+    };
+    parsed.forEach(_ref => {
+      let [type, option, length] = _ref;
+
+      if (type in symbols) {
+        result.push(Array(length).fill(symbols[type]).join(''));
+      } else if (type === 'literal') {
+        result.push(option);
+      }
+    });
+    return result.join('');
+  }
+
+  return skeleton;
+}
+/**
+ *
+ * @param skeleton shorthand style for the date concatenated with shorthand style of time. The
+ * Shorthand style for both date and time is one of ['full', 'long', 'medium', 'short'].
+ * @param language {string} language to parse the date shorthand style
+ * @returns {[*,string][]}
+ */
+
+
+function parseDateStyle(skeleton, language) {
+  const options = {}; // the skeleton could have two keywords -- one for date, one for time
+
+  const styles = skeleton.split(/\s/).filter(s => s.length);
+  options.dateStyle = styles[0];
+  if (styles.length > 1) options.timeStyle = styles[1];
+  const testDate = new Date(2000, 2, 1, 2, 3, 4);
+  const parts = new Intl.DateTimeFormat(language, options).formatToParts(testDate); // oddly, the formatted month name can be different from the standalone month name
+
+  const formattedMarch = parts.find(p => p.type === 'month').value;
+  const longMarch = new Intl.DateTimeFormat(language, {
+    month: 'long'
+  }).formatToParts(testDate)[0].value;
+  const shortMarch = new Intl.DateTimeFormat(language, {
+    month: 'short'
+  }).formatToParts(testDate)[0].value;
+  const result = [];
+  parts.forEach(_ref2 => {
+    let {
+      type,
+      value
+    } = _ref2;
+    let option;
+
+    if (type === 'month') {
+      option = {
+        [formattedMarch]: skeleton === 'medium' ? 'short' : 'long',
+        [longMarch]: 'long',
+        [shortMarch]: 'short',
+        '03': '2-digit',
+        '3': 'numeric'
+      }[value];
+    }
+
+    if (type === 'year') option = {
+      '2000': 'numeric',
+      '00': '2-digit'
+    }[value];
+    if (['day', 'hour', 'minute', 'second'].includes(type)) option = value.length === 2 ? '2-digit' : 'numeric';
+    if (type === 'literal') option = value;
+    if (type === 'dayPeriod') option = 'short';
+    result.push([type, option, value.length]);
+  });
+  return result;
+}
+/**
+ * Parse Date time skeleton into Intl.DateTimeFormatOptions parts
+ * Ref: https://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
+ */
+
+
+function parseDateTimeSkeleton(skeleton, language) {
+  if (ShorthandStyles.find(type => skeleton.includes(type))) {
+    return parseDateStyle(skeleton, language);
+  }
+
+  const result = [];
+  skeleton.replace(DATE_TIME_REGEX, match => {
+    const len = match.length;
+
+    switch (match[0]) {
+      // Era
+      case 'G':
+        result.push(['era', len === 4 ? 'long' : len === 5 ? 'narrow' : 'short', len]);
+        break;
+      // Year
+
+      case 'y':
+        result.push(['year', len === 2 ? '2-digit' : 'numeric', len]);
+        break;
+
+      case 'Y':
+      case 'u':
+      case 'U':
+      case 'r':
+        throw new RangeError('`Y/u/U/r` (year) patterns are not supported, use `y` instead');
+      // Quarter
+
+      case 'q':
+      case 'Q':
+        throw new RangeError('`q/Q` (quarter) patterns are not supported');
+      // Month
+
+      case 'M':
+      case 'L':
+        result.push(['month', ['numeric', '2-digit', 'short', 'long', 'narrow'][len - 1], len]);
+        break;
+      // Week
+
+      case 'w':
+      case 'W':
+        throw new RangeError('`w/W` (week) patterns are not supported');
+
+      case 'd':
+        result.push(['day', ['numeric', '2-digit'][len - 1], len]);
+        break;
+
+      case 'D':
+      case 'F':
+      case 'g':
+        throw new RangeError('`D/F/g` (day) patterns are not supported, use `d` instead');
+      // Weekday
+
+      case 'E':
+        result.push(['weekday', ['short', 'short', 'short', 'long', 'narrow', 'narrow'][len - 1], len]);
+        break;
+
+      case 'e':
+        if (len < 4) {
+          throw new RangeError('`e..eee` (weekday) patterns are not supported');
+        }
+
+        result.push(['weekday', ['short', 'long', 'narrow', 'short'][len - 4], len]);
+        break;
+
+      case 'c':
+        if (len < 3 || len > 5) {
+          throw new RangeError('`c, cc, cccccc` (weekday) patterns are not supported');
+        }
+
+        result.push(['weekday', ['short', 'long', 'narrow', 'short'][len - 3], len]);
+        break;
+      // Period
+
+      case 'a':
+        // AM, PM
+        result.push(['hour12', true, 1]);
+        break;
+
+      case 'b': // am, pm, noon, midnight
+
+      case 'B':
+        // flexible day periods
+        throw new RangeError('`b/B` (period) patterns are not supported, use `a` instead');
+      // Hour
+
+      case 'h':
+        result.push(['hourCycle', 'h12']);
+        result.push(['hour', ['numeric', '2-digit'][len - 1], len]);
+        break;
+
+      case 'H':
+        result.push(['hourCycle', 'h23', 1]);
+        result.push(['hour', ['numeric', '2-digit'][len - 1], len]);
+        break;
+
+      case 'K':
+        result.push(['hourCycle', 'h11', 1]);
+        result.push(['hour', ['numeric', '2-digit'][len - 1], len]);
+        break;
+
+      case 'k':
+        result.push(['hourCycle', 'h24', 1]);
+        result.push(['hour', ['numeric', '2-digit'][len - 1], len]);
+        break;
+
+      case 'j':
+      case 'J':
+      case 'C':
+        throw new RangeError('`j/J/C` (hour) patterns are not supported, use `h/H/K/k` instead');
+      // Minute
+
+      case 'm':
+        result.push(['minute', ['numeric', '2-digit'][len - 1], len]);
+        break;
+      // Second
+
+      case 's':
+        result.push(['second', ['numeric', '2-digit'][len - 1], len]);
+        break;
+
+      case 'S':
+        result.push(['fractionalSecondDigits', len, len]);
+        break;
+
+      case 'A':
+        throw new RangeError('`S/A` (millisecond) patterns are not supported, use `s` instead');
+      // Zone
+
+      case 'O':
+        // timeZone GMT-8 or GMT-08:00
+        result.push(['timeZoneName', len < 4 ? 'shortOffset' : 'longOffset', len]);
+        result.push(['x-timeZoneName', len < 4 ? 'O' : 'OOOO', len]);
+        break;
+
+      case 'X': // 1, 2, 3, 4: The ISO8601 varios formats
+
+      case 'x': // 1, 2, 3, 4: The ISO8601 varios formats
+
+      case 'Z':
+        // 1..3, 4, 5: The ISO8601 varios formats
+        // Z, ZZ, ZZZ should produce -0800
+        // ZZZZ should produce GMT-08:00
+        // ZZZZZ should produce -8:00 or -07:52:58
+        result.push(['timeZoneName', 'longOffset', 1]);
+        result.push(['x-timeZoneName', match, 1]);
+        break;
+
+      case 'z': // 1..3, 4: specific non-location format
+
+      case 'v': // 1, 4: generic non-location format
+
+      case 'V':
+        // 1, 2, 3, 4: time zone ID or city
+        throw new RangeError('z/v/V` (timeZone) patterns are not supported, use `X/x/Z/O` instead');
+
+      case '\'':
+        result.push(['literal', match.slice(1, -1).replace(/''/g, '\''), -1]);
+        break;
+
+      default:
+        result.push(['literal', match, -1]);
+    }
+
+    return '';
+  });
+  return result;
+}

package/lib/date/index.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "formatDate", {
+  enumerable: true,
+  get: function () {
+    return _DateParser.formatDate;
+  }
+});
+Object.defineProperty(exports, "getSkeleton", {
+  enumerable: true,
+  get: function () {
+    return _SkeletonParser.getSkeleton;
+  }
+});
+Object.defineProperty(exports, "parseDate", {
+  enumerable: true,
+  get: function () {
+    return _DateParser.parseDate;
+  }
+});
+
+var _DateParser = require("./DateParser.js");
+
+var _SkeletonParser = require("./SkeletonParser.js");

package/lib/index.js

@@ -0,0 +1,103 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.format = void 0;
+Object.defineProperty(exports, "formatDate", {
+  enumerable: true,
+  get: function () {
+    return _index.formatDate;
+  }
+});
+Object.defineProperty(exports, "formatNumber", {
+  enumerable: true,
+  get: function () {
+    return _NumberParser.formatNumber;
+  }
+});
+exports.parse = void 0;
+Object.defineProperty(exports, "parseDate", {
+  enumerable: true,
+  get: function () {
+    return _index.parseDate;
+  }
+});
+Object.defineProperty(exports, "parseDateSkeleton", {
+  enumerable: true,
+  get: function () {
+    return _index.getSkeleton;
+  }
+});
+Object.defineProperty(exports, "parseNumber", {
+  enumerable: true,
+  get: function () {
+    return _NumberParser.parseNumber;
+  }
+});
+
+var _index = require("./date/index.js");
+
+var _NumberParser = require("./number/NumberParser.js");
+
+/*************************************************************************
+* ADOBE CONFIDENTIAL
+* ___________________
+*
+* Copyright 2022 Adobe
+* All Rights Reserved.
+*
+* NOTICE: All information contained herein is, and remains
+* the property of Adobe and its suppliers, if any. The intellectual
+* and technical concepts contained herein are proprietary to Adobe
+* and its suppliers and are protected by all applicable intellectual
+* property laws, including trade secret and copyright laws.
+* Dissemination of this information or reproduction of this material
+* is strictly forbidden unless prior written permission is obtained
+* from Adobe.
+
+* Adobe permits you to use and modify this file solely in accordance with
+* the terms of the Adobe license agreement accompanying it.
+*************************************************************************/
+const getCategory = function (skeleton) {
+  const chkCategory = skeleton === null || skeleton === void 0 ? void 0 : skeleton.match(/^(?:(num|date)\|)?(.+)/);
+  return [chkCategory === null || chkCategory === void 0 ? void 0 : chkCategory[1], chkCategory === null || chkCategory === void 0 ? void 0 : chkCategory[2]];
+};
+
+const format = function (value, locale, skeleton, timezone) {
+  const [category, skelton] = getCategory(skeleton);
+
+  switch (category) {
+    case 'date':
+      if (!(value instanceof Date)) {
+        value = new Date(value);
+      }
+
+      return (0, _index.formatDate)(value, locale, skelton, timezone);
+
+    case 'num':
+      return (0, _NumberParser.formatNumber)(value, locale, skelton);
+
+    default:
+      throw `unable to deduce the format. The skeleton should be date|<format> for date formats and num|<format> for numbers`;
+  }
+};
+
+exports.format = format;
+
+const parse = function (value, locale, skeleton, timezone) {
+  const [category, skelton] = getCategory(skeleton);
+
+  switch (category) {
+    case 'date':
+      return (0, _index.parseDate)(value, locale, skelton, timezone);
+
+    case 'number':
+      return (0, _NumberParser.parseNumber)(value, locale, skelton);
+
+    default:
+      throw `unable to deduce the format. The skeleton should be date|<format> for date formats and num|<format> for numbers`;
+  }
+};
+
+exports.parse = parse;

package/lib/number/NumberParser.js

@@ -0,0 +1,128 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatNumber = formatNumber;
+exports.parseDefaultNumber = parseDefaultNumber;
+exports.parseNumber = parseNumber;
+
+var _SkeletonParser = require("./SkeletonParser.js");
+
+/*************************************************************************
+* ADOBE CONFIDENTIAL
+* ___________________
+*
+* Copyright 2022 Adobe
+* All Rights Reserved.
+*
+* NOTICE: All information contained herein is, and remains
+* the property of Adobe and its suppliers, if any. The intellectual
+* and technical concepts contained herein are proprietary to Adobe
+* and its suppliers and are protected by all applicable intellectual
+* property laws, including trade secret and copyright laws.
+* Dissemination of this information or reproduction of this material
+* is strictly forbidden unless prior written permission is obtained
+* from Adobe.
+
+* Adobe permits you to use and modify this file solely in accordance with
+* the terms of the Adobe license agreement accompanying it.
+*************************************************************************/
+function formatNumber(numberValue, language, skeletn) {
+  if (skeletn.startsWith('num|')) {
+    skeletn = skel.split('|')[1];
+  }
+
+  if (!skeletn) return numberValue;
+  language = language || "en";
+  const {
+    options,
+    order
+  } = (0, _SkeletonParser.parseNumberSkeleton)(skeletn, language);
+  return new Intl.NumberFormat(language, options).format(numberValue);
+}
+
+function getMetaInfo(language, skel) {
+  const parts = {}; // gather digits and radix symbol
+
+  let options = new Intl.NumberFormat(language, {
+    style: 'decimal',
+    useGrouping: false
+  }).formatToParts(9876543210.1);
+  parts.digits = options.find(p => p.type === 'integer').value.split('').reverse();
+  parts.decimal = options.find(p => p.type === 'decimal').value; // extract type values from the parts
+
+  const gather = type => {
+    const find = options.find(p => p.type === type);
+    if (find) parts[type] = find.value;
+  }; // now gather the localized parts that correspond to the provided skeleton.
+
+
+  const parsed = (0, _SkeletonParser.parseNumberSkeleton)(skel);
+  const nf = new Intl.NumberFormat(language, parsed);
+  options = nf.formatToParts(-987654321);
+  gather('group');
+  gather('minusSign');
+  gather('percentSign'); // it's possible to have multiple currency representations in a single value
+
+  parts.currency = options.filter(p => p.type === 'currency').map(p => p.value); // collect all literals.  Most likely a literal is an accounting bracket
+
+  parts.literal = options.filter(p => p.type === 'literal').map(p => p.value);
+  options = nf.formatToParts(987654321);
+  gather('plusSign');
+  gather('exponentSeparator');
+  gather('unit');
+  return parts;
+}
+
+function parseNumber(numberString, language, skel) {
+  try {
+    // factor will be updated to reflect: negative, percent, exponent etc.
+    if (skel.startsWith('num|')) {
+      skel = skel.split('|')[1];
+    }
+
+    let factor = 1;
+    let number = numberString;
+    const meta = getMetaInfo(language, skel);
+    if (meta.group) number = number.replaceAll(meta.group, '');
+    number = number.replace(meta.decimal, '.');
+    if (meta.unit) number = number.replaceAll(meta.unit, '');
+
+    if (meta.minusSign && number.includes(meta.minusSign)) {
+      number = number.replace(meta.minusSign, '');
+      factor *= -1;
+    }
+
+    if (meta.percentSign && number.includes(meta.percentSign)) {
+      factor = factor / 100;
+      number = number.replace(meta.percentSign, '');
+    }
+
+    meta.currency.forEach(currency => number = number.replace(currency, ''));
+    meta.literal.forEach(literal => {
+      if (number.includes(literal)) {
+        if (literal === '(') factor = factor * -1;
+        number = number.replace(literal, '');
+      }
+    });
+    if (meta.plusSign) number = number.replace(meta.plusSign, '');
+
+    if (meta.exponentSeparator) {
+      let e;
+      [number, e] = number.split(meta.exponentSeparator);
+      factor = factor * Math.pow(10, e);
+    }
+
+    const result = factor * number;
+    return isNaN(result) ? numberString : result;
+  } catch (e) {
+    console.dir(e);
+    return numberString;
+  }
+}
+
+function parseDefaultNumber(numberString, language) {
+  const currency = currencies[language] || 'USD';
+  return parseNumber(numberString, language, `currency/${currency}`);
+}