@aemforms/af-formatters 0.22.9

package/lib/date/DateParser.js

@@ -0,0 +1,522 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ShorthandStyles = void 0;
+exports.adjustTimeZone = adjustTimeZone;
+exports.datetimeToNumber = datetimeToNumber;
+exports.formatDate = formatDate;
+exports.numberToDatetime = numberToDatetime;
+exports.offsetMS = offsetMS;
+exports.offsetMSFallback = offsetMSFallback;
+exports.parseDate = parseDate;
+exports.parseDefaultDate = parseDefaultDate;
+
+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.
+ **************************************************************************/
+
+/**
+ * Credit: https://git.corp.adobe.com/dc/dfl/blob/master/src/patterns/dates.js
+ */
+// Test Japanese full/half width character support
+// get the localized month names resulting from a given pattern
+const twelveMonths = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11].map(m => new Date(2000, m, 1));
+/**
+ * returns the name of all the months for a given locale and given Date Format Settings
+ * @param locale {string}
+ * @param options {string} instance of Intl.DateTimeFormatOptions
+ */
+
+function monthNames(locale, options) {
+  return twelveMonths.map(month => {
+    const parts = new Intl.DateTimeFormat(locale, options).formatToParts(month);
+    const m = parts.find(p => p.type === 'month');
+    return m && m.value;
+  });
+}
+/**
+ * return an array of digits used by a given locale
+ * @param locale {string}
+ */
+
+
+function digitChars(locale) {
+  return new Intl.NumberFormat(locale, {
+    style: 'decimal',
+    useGrouping: false
+  }).format(9876543210).split('').reverse();
+}
+/**
+ * returns the calendar name used in a given locale
+ * @param locale {string}
+ */
+
+
+function calendarName(locale) {
+  var _parts$find;
+
+  const parts = new Intl.DateTimeFormat(locale, {
+    era: 'short'
+  }).formatToParts(new Date());
+  const era = (_parts$find = parts.find(p => p.type === 'era')) === null || _parts$find === void 0 ? void 0 : _parts$find.value;
+  return era === 'هـ' ? 'islamic' : 'gregory';
+}
+/**
+ * returns the representation of the time of day for a given language
+ * @param language {string}
+ */
+
+
+function getDayPeriod(language) {
+  const morning = new Date(2000, 1, 1, 1, 1, 1);
+  const afternoon = new Date(2000, 1, 1, 16, 1, 1);
+  const df = new Intl.DateTimeFormat(language, {
+    dateStyle: 'full',
+    timeStyle: 'full'
+  });
+  const am = df.formatToParts(morning).find(p => p.type === 'dayPeriod');
+  const pm = df.formatToParts(afternoon).find(p => p.type === 'dayPeriod');
+  if (!am || !pm) return null;
+  return {
+    regex: `(${am.value}|${pm.value})`,
+    fn: (period, obj) => obj.hour += period === pm.value ? 12 : 0
+  };
+}
+/**
+ * get the offset in MS, given a date and timezone
+ * @param dateObj {Date}
+ * @param timeZone {string}
+ */
+
+
+function offsetMS(dateObj, timeZone) {
+  let tzOffset;
+
+  try {
+    tzOffset = new Intl.DateTimeFormat('en-US', {
+      timeZone,
+      timeZoneName: 'longOffset'
+    }).format(dateObj);
+  } catch (e) {
+    return offsetMSFallback(dateObj, timeZone);
+  }
+
+  const offset = /GMT([+\-−])?(\d{1,2}):?(\d{0,2})?/.exec(tzOffset);
+  if (!offset) return 0;
+  const [sign, hours, minutes] = offset.slice(1);
+  const nHours = isNaN(parseInt(hours)) ? 0 : parseInt(hours);
+  const nMinutes = isNaN(parseInt(minutes)) ? 0 : parseInt(minutes);
+  const result = (nHours * 60 + nMinutes) * 60 * 1000;
+  return sign === '-' ? -result : result;
+}
+
+function getTimezoneOffsetFrom(otherTimezone) {
+  var date = new Date();
+
+  function objFromStr(str) {
+    var array = str.replace(":", " ").split(" ");
+    return {
+      day: parseInt(array[0]),
+      hour: parseInt(array[1]),
+      minute: parseInt(array[2])
+    };
+  }
+
+  var str = date.toLocaleString('en-US', {
+    timeZone: otherTimezone,
+    day: 'numeric',
+    hour: 'numeric',
+    minute: 'numeric',
+    hour12: false
+  });
+  var other = objFromStr(str);
+  str = date.toLocaleString('en-US', {
+    day: 'numeric',
+    hour: 'numeric',
+    minute: 'numeric',
+    hour12: false
+  });
+  var myLocale = objFromStr(str);
+  var otherOffset = other.day * 24 * 60 + other.hour * 60 + other.minute; // utc date + otherTimezoneDifference
+
+  var myLocaleOffset = myLocale.day * 24 * 60 + myLocale.hour * 60 + myLocale.minute; // utc date + myTimeZoneDifference
+  // (utc date + otherZoneDifference) - (utc date + myZoneDifference) - (-1 * myTimeZoneDifference)
+
+  return otherOffset - myLocaleOffset - date.getTimezoneOffset();
+}
+
+function offsetMSFallback(dateObj, timezone) {
+  //const defaultOffset = dateObj.getTimezoneOffset();
+  const timezoneOffset = getTimezoneOffsetFrom(timezone);
+  return timezoneOffset * 60 * 1000;
+}
+/**
+ * adjust from the default JavaScript timezone to the default timezone
+ * @param dateObj {Date}
+ * @param timeZone {string}
+ */
+
+
+function adjustTimeZone(dateObj, timeZone) {
+  if (dateObj === null) return null; // const defaultOffset = new Intl.DateTimeFormat('en-US', { timeZoneName: 'longOffset'}).format(dateObj);
+
+  let baseDate = dateObj.getTime() - dateObj.getTimezoneOffset() * 60 * 1000;
+  const offset = offsetMS(dateObj, timeZone);
+  const fallBackOffset = offsetMSFallback(dateObj, timeZone);
+  baseDate += -offset; // get the offset for the default JS environment
+  // return days since the epoch
+
+  return new Date(baseDate);
+}
+/**
+ * Our script object model treats dates as numbers where the integer portion is days since the epoch,
+ * the fractional portion is the number hours in the day
+ * @param dateObj {Date}
+ * @returns {number}
+ */
+
+
+function datetimeToNumber(dateObj) {
+  if (dateObj === null) return 0; // return days since the epoch
+
+  return dateObj.getTime() / (1000 * 60 * 60 * 24);
+}
+/**
+ * Our script object model treats dates as numbers where the integer portion is days since the epoch,
+ * the fractional portion is the number hours in the day
+ * @param num
+ * @returns {Date}
+ */
+
+
+function numberToDatetime(num) {
+  return new Date(Math.round(num * 1000 * 60 * 60 * 24));
+}
+/**
+ * in some cases, DateTimeFormat doesn't respect the 'numeric' vs. '2-digit' setting
+ * for time values. The function corrects that
+ * @param formattedParts instance of Intl.DateTimeFormatPart[]
+ * @param parsed
+ */
+
+
+function fixDigits(formattedParts, parsed) {
+  ['hour', 'minute', 'second'].forEach(type => {
+    const defn = formattedParts.find(f => f.type === type);
+    if (!defn) return;
+    const fmt = parsed.find(pair => pair[0] === type)[1];
+    if (fmt === '2-digit' && defn.value.length === 1) defn.value = `0${defn.value}`;
+    if (fmt === 'numeric' && defn.value.length === 2 && defn.value.charAt(0) === '0') defn.value = defn.value.slice(1);
+  });
+}
+
+function fixYear(formattedParts, parsed) {
+  // two digit years are handled differently in DateTimeFormat. 00 becomes 1900
+  // providing a two digit year 0010 gets formatted to 10 and when parsed becomes 1910
+  // Hence we need to pad the year with 0 as required by the skeleton and mentioned in
+  // unicode. https://www.unicode.org/reports/tr35/tr35-dates.html#dfst-year
+  const defn = formattedParts.find(f => f.type === 'year');
+  if (!defn) return; // eslint-disable-next-line no-unused-vars
+
+  const chars = parsed.find(pair => pair[0] === 'year')[2];
+
+  while (defn.value.length < chars) {
+    defn.value = `0${defn.value}`;
+  }
+}
+/**
+ *
+ * @param dateValue {Date}
+ * @param language {string}
+ * @param skeleton {string}
+ * @param timeZone {string}
+ * @returns {T}
+ */
+
+
+function formatDateToParts(dateValue, language, skeleton, timeZone) {
+  // DateTimeFormat renames some of the options in its formatted output
+  //@ts-ignore
+  const mappings = key => ({
+    hour12: 'dayPeriod',
+    fractionalSecondDigits: 'fractionalSecond'
+  })[key] || key; // produces an array of name/value pairs of skeleton parts
+
+
+  const allParameters = (0, _SkeletonParser.parseDateTimeSkeleton)(skeleton, language);
+  allParameters.push(['timeZone', timeZone]);
+  const parsed = allParameters.filter(p => !p[0].startsWith('x-'));
+  const nonStandard = allParameters.filter(p => p[0].startsWith('x-')); // reduce to a set of options that can be used to format
+
+  const options = Object.fromEntries(parsed);
+  delete options.literal;
+  const df = new Intl.DateTimeFormat(language, options); // formattedParts will have all the pieces we need for our date -- but not in the correct order
+
+  const formattedParts = df.formatToParts(dateValue);
+  fixDigits(formattedParts, allParameters);
+  fixYear(formattedParts, parsed); // iterate through the original parsed components and use its ordering and literals,
+  // and add  the formatted pieces
+
+  return parsed.reduce((result, cur) => {
+    if (cur[0] === 'literal') result.push(cur);else {
+      const v = formattedParts.find(p => p.type === mappings(cur[0]));
+
+      if (v && v.type === 'timeZoneName') {
+        const tz = nonStandard.find(p => p[0] === 'x-timeZoneName')[1];
+        const category = tz[0];
+
+        if (category === 'Z') {
+          if (tz.length < 4) {
+            // handle 'Z', 'ZZ', 'ZZZ' Time Zone: ISO8601 basic hms? / RFC 822
+            v.value = v.value.replace(/(GMT|:)/g, '');
+            if (v.value === '') v.value = '+0000';
+          } else if (tz.length === 5) {
+            // 'ZZZZZ' Time Zone: ISO8601 extended hms?
+            if (v.value === 'GMT') v.value = 'Z';else v.value = v.value.replace(/GMT/, '');
+          }
+        }
+
+        if (category === 'X' || category === 'x') {
+          if (tz.length === 1) {
+            // 'X' ISO8601 basic hm?, with Z for 0
+            // -08, +0530, Z
+            // 'x' ISO8601 basic hm?, without Z for 0
+            v.value = v.value.replace(/(GMT|:(00)?)/g, '');
+          }
+
+          if (tz.length === 2) {
+            // 'XX' ISO8601 basic hm, with Z
+            // -0800, Z
+            // 'xx' ISO8601 basic hm, without Z
+            v.value = v.value.replace(/(GMT|:)/g, '');
+          }
+
+          if (tz.length === 3) {
+            // 'XXX' ISO8601 extended hm, with Z
+            // -08:00, Z
+            // 'xxx' ISO8601 extended hm, without Z
+            v.value = v.value.replace(/GMT/g, '');
+          }
+
+          if (category === 'X' && v.value === '') v.value = 'Z';
+        } else if (tz === 'O') {
+          // eliminate 'GMT', leading and trailing zeros
+          v.value = v.value.replace(/GMT/g, '').replace(/0(\d+):/, '$1:').replace(/:00/, '');
+          if (v.value === '') v.value = '+0';
+        }
+      }
+
+      if (v) result.push([v.type, v.value]);
+    }
+    return result;
+  }, []);
+}
+
+const ShorthandStyles = ["full", "long", "medium", "short"];
+/**
+ *
+ * @param dateValue {Date}
+ * @param language {string}
+ * @param skeleton {string}
+ * @param timeZone {string}
+ */
+
+exports.ShorthandStyles = ShorthandStyles;
+
+function formatDate(dateValue, language, skeleton, timeZone) {
+  if (ShorthandStyles.find(type => skeleton.includes(type))) {
+    const options = {
+      timeZone
+    }; // the skeleton could have two keywords -- one for date, one for time
+
+    const parts = skeleton.split(/\s/).filter(s => s.length);
+
+    if (ShorthandStyles.indexOf(parts[0]) > -1) {
+      options.dateStyle = parts[0];
+    }
+
+    if (parts.length > 1 && ShorthandStyles.indexOf(parts[1]) > -1) {
+      options.timeStyle = parts[1];
+    }
+
+    return new Intl.DateTimeFormat(language, options).format(dateValue);
+  }
+
+  const parts = formatDateToParts(dateValue, language, skeleton, timeZone);
+  return parts.map(p => p[1]).join('');
+}
+/**
+ *
+ * @param dateString {string}
+ * @param language {string}
+ * @param skeleton {string}
+ * @param timeZone {string}
+ */
+
+
+function parseDate(dateString, language, skeleton, timeZone) {
+  let bUseUTC = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+  // start by getting all the localized parts of a date/time picture:
+  // digits, calendar name
+  const lookups = [];
+  const regexParts = [];
+  const calendar = calendarName(language);
+  const digits = digitChars(language);
+  const twoDigit = `([${digits[0]}-${digits[9]}]{1,2})`;
+  const threeDigit = `([${digits[0]}-${digits[9]}]{1,3})`;
+  const fourDigit = `([${digits[0]}-${digits[9]}]{1,4})`;
+  let hourCycle = 'h12';
+  let _bUseUTC = bUseUTC;
+  let _setFullYear = false; // functions to process the results of the regex match
+
+  const isSeparator = str => str.length === 1 && ':-/.'.includes(str);
+
+  const monthNumber = str => getNumber(str) - 1;
+
+  const getNumber = str => str.split('').reduce((total, digit) => total * 10 + digits.indexOf(digit), 0);
+
+  const yearNumber = templateDigits => str => {
+    let year = getNumber(str); //todo: align with AF
+
+    year = year < 100 && templateDigits === 2 ? year + 2000 : year;
+    if (calendar === 'islamic') year = Math.ceil(year * 0.97 + 622);
+
+    if (templateDigits > 2 && year < 100) {
+      _setFullYear = true;
+    }
+
+    return year;
+  };
+
+  const monthLookup = list => month => list.indexOf(month);
+
+  const parsed = (0, _SkeletonParser.parseDateTimeSkeleton)(skeleton, language);
+  const months = monthNames(language, Object.fromEntries(parsed)); // build up a regex expression that identifies each option in the skeleton
+  // We build two parallel structures:
+  // 1. the regex expression that will extract parts of the date/time
+  // 2. a lookup array that will convert the matched results into date/time values
+
+  parsed.forEach(_ref => {
+    let [option, value, len] = _ref;
+
+    // use a generic regex pattern for all single-character separator literals.
+    // Then we'll be forgiving when it comes to separators: / vs - vs : etc
+    if (option === 'literal') {
+      if (isSeparator(value)) regexParts.push(`[^${digits[0]}-${digits[9]}]`);else regexParts.push(value);
+    } else if (option === 'month' && ['numeric', '2-digit'].includes(value)) {
+      regexParts.push(twoDigit);
+      lookups.push(['month', monthNumber]);
+    } else if (option === 'month' && ['formatted', 'long', 'short', 'narrow'].includes(value)) {
+      regexParts.push(`(${months.join('|')})`);
+      lookups.push(['month', monthLookup(months)]);
+    } else if (['day', 'minute', 'second'].includes(option)) {
+      if (option === 'minute' || option === 'second') {
+        _bUseUTC = false;
+      }
+
+      regexParts.push(twoDigit);
+      lookups.push([option, getNumber]);
+    } else if (option === 'fractionalSecondDigits') {
+      _bUseUTC = false;
+      regexParts.push(threeDigit);
+      lookups.push([option, (v, obj) => obj.fractionalSecondDigits + getNumber(v)]);
+    } else if (option === 'hour') {
+      _bUseUTC = false;
+      regexParts.push(twoDigit);
+      lookups.push([option, (v, obj) => obj.hour + getNumber(v)]);
+    } else if (option === 'year') {
+      regexParts.push('numeric' === value ? fourDigit : twoDigit);
+      lookups.push(['year', yearNumber(len)]);
+    } else if (option === 'dayPeriod') {
+      _bUseUTC = false;
+      const dayPeriod = getDayPeriod(language);
+
+      if (dayPeriod) {
+        regexParts.push(dayPeriod.regex);
+        lookups.push(['hour', dayPeriod.fn]);
+      } // Any other part that we don't need, we'll just add a non-greedy consumption
+
+    } else if (option === 'hourCycle') {
+      _bUseUTC = false;
+      hourCycle = value;
+    } else if (option === 'x-timeZoneName') {
+      _bUseUTC = false; // we handle only the GMT offset picture
+
+      regexParts.push('(?:GMT|UTC|Z)?([+\\-−0-9]{0,3}:?[0-9]{0,2})');
+      lookups.push([option, (v, obj) => {
+        _bUseUTC = true; // v could be undefined if we're on GMT time
+
+        if (!v) return; // replace the unicode minus, then extract hours [and minutes]
+
+        const timeParts = v.replace(/−/, '-').match(/([+\-\d]{2,3}):?(\d{0,2})/);
+        const hours = timeParts[1] * 1;
+        obj.hour -= hours;
+        const mins = timeParts.length > 2 ? timeParts[2] * 1 : 0;
+        obj.minute -= hours < 0 ? -mins : mins;
+      }]);
+    } else if (option !== 'timeZoneName') {
+      _bUseUTC = false;
+      regexParts.push('.+?');
+    }
+
+    return regexParts;
+  }, []);
+  const regex = new RegExp(regexParts.join(''));
+  const match = dateString.match(regex);
+  if (match === null) return dateString; // now loop through all the matched pieces and build up an object we'll use to create a Date object
+
+  const dateObj = {
+    year: 1972,
+    month: 0,
+    day: 1,
+    hour: 0,
+    minute: 0,
+    second: 0,
+    fractionalSecondDigits: 0
+  };
+  match.slice(1).forEach((m, index) => {
+    const [element, func] = lookups[index];
+    dateObj[element] = func(m, dateObj);
+  });
+  if (hourCycle === 'h24' && dateObj.hour === 24) dateObj.hour = 0;
+  if (hourCycle === 'h12' && dateObj.hour === 12) dateObj.hour = 0;
+
+  if (_bUseUTC) {
+    const utcDate = new Date(Date.UTC(dateObj.year, dateObj.month, dateObj.day, dateObj.hour, dateObj.minute, dateObj.second, dateObj.fractionalSecondDigits));
+
+    if (_setFullYear) {
+      utcDate.setUTCFullYear(dateObj.year);
+    }
+
+    return utcDate;
+  }
+
+  const jsDate = new Date(dateObj.year, dateObj.month, dateObj.day, dateObj.hour, dateObj.minute, dateObj.second, dateObj.fractionalSecondDigits);
+
+  if (_setFullYear) {
+    jsDate.setFullYear(dateObj.year);
+  }
+
+  return timeZone == null ? jsDate : adjustTimeZone(jsDate, timeZone);
+}
+
+function parseDefaultDate(dateString, language, bUseUTC) {
+  return parseDate(dateString, language, 'short', null, false);
+}

package/lib/date/SkeletonParser.js

@@ -0,0 +1,315 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSkeleton = getSkeleton;
+exports.parseDateTimeSkeleton = parseDateTimeSkeleton;
+
+var _DateParser = require("./DateParser");
+
+/*************************************************************************
+ * 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.
+ **************************************************************************/
+
+/**
+ * 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 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 (_DateParser.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 (_DateParser.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");
+
+var _SkeletonParser = require("./SkeletonParser");

package/lib/index.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "formatDate", {
+  enumerable: true,
+  get: function () {
+    return _date.formatDate;
+  }
+});
+Object.defineProperty(exports, "getSkeleton", {
+  enumerable: true,
+  get: function () {
+    return _date.getSkeleton;
+  }
+});
+Object.defineProperty(exports, "parseDate", {
+  enumerable: true,
+  get: function () {
+    return _date.parseDate;
+  }
+});
+
+var _date = require("./date");

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@aemforms/af-formatters",
+  "version": "0.22.9",
+  "description": "Core Module for Forms Runtime",
+  "author": "Adobe Systems",
+  "license": "Adobe Proprietary",
+  "main": "lib/index.js",
+  "directories": {
+    "lib": "lib",
+    "source": "src",
+    "test": "src/__tests__"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "jest-junit": {
+    "suiteName": "core tests",
+    "suiteNameTemplate": "{filename}",
+    "classNameTemplate": "model-test.{filename}",
+    "outputDirectory": "./target/test-reports"
+  },
+  "files": [
+    "lib",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "jest --silent",
+    "eslint": "npx eslint src/**",
+    "eslint:fix": "npx eslint --fix src/**",
+    "test:ci": "jest --silent --coverage",
+    "build": "babel src -d lib",
+    "clean": "rm -rf lib target",
+    "prepublishOnly": "npm run build && npm run test",
+    "docs": "npx typedoc --options .typedoc.cjs"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.18.10",
+    "@babel/core": "^7.19.0",
+    "@babel/preset-env": "^7.19.0",
+    "babel-jest": "^29.0.2",
+    "eslint": "^7.30.0",
+    "eslint-config-standard": "^16.0.3",
+    "eslint-plugin-import": "^2.23.4",
+    "eslint-plugin-jest": "^24.3.6",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^5.1.0",
+    "form-data": "^4.0.0",
+    "jest": "26.6.0",
+    "jest-junit": "^12.2.0",
+    "nock": "^13.1.3",
+    "node-fetch": "^2.6.1",
+    "ts-jest": "26.5.6",
+    "typedoc": "0.22.11",
+    "typedoc-plugin-markdown": "3.11.13"
+  }
+}