@aemforms/af-formatters 0.22.25 → 0.22.26

package/lib/esm/date/SkeletonParser.js

@@ -0,0 +1,260 @@
+/*************************************************************************
+ * 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;
+
+export const ShorthandStyles = ["full", "long", "medium", "short"]
+
+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];
+}
+
+export 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(([type, option, length]) => {
+            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(({type, value}) => {
+        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
+ */
+export 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/esm/date/index.js

@@ -0,0 +1,20 @@
+/*************************************************************************
+ * 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.
+ **************************************************************************/
+
+import { parseDate, formatDate } from './DateParser.js';
+import {getSkeleton} from "./SkeletonParser.js";
+export {parseDate, formatDate, getSkeleton}

package/lib/esm/index.js

@@ -0,0 +1,36 @@
+import {parseDate, formatDate, getSkeleton as parseDateSkeleton} from "./date/index.js";
+import {parseNumber, formatNumber} from "./number/NumberParser.js"
+
+const getCategory = function (skeleton) {
+    const chkCategory = skeleton?.match(/^(?:(num|date)\|)?(.+)/);
+    return [chkCategory?.[1], chkCategory?.[2]]
+}
+
+export 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 formatDate(value, locale, skelton, timezone)
+        case 'num':
+            return 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`
+    }
+}
+
+export const parse = function (value, locale, skeleton, timezone) {
+    const [category, skelton] = getCategory(skeleton)
+    switch (category) {
+        case 'date':
+            return parseDate(value, locale, skelton, timezone)
+        case 'number':
+            return 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`
+    }
+}
+
+export {parseDate, formatDate, parseDateSkeleton, parseNumber, formatNumber}

package/lib/esm/number/NumberParser.js

@@ -0,0 +1,81 @@
+import {parseNumberSkeleton} from "./SkeletonParser.js";
+
+export function formatNumber(numberValue, language, skeletn) {
+    if (!skeletn) return numberValue
+    language = language || "en"
+    const {options, order} = 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 = 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;
+}
+
+export function parseNumber(numberString, language, skel) {
+    try {
+        // factor will be updated to reflect: negative, percent, exponent etc.
+        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;
+    }
+}
+
+export function parseDefaultNumber(numberString, language) {
+    const currency = currencies[language] || 'USD';
+    return parseNumber(numberString, language, `currency/${currency}`);
+}

package/lib/esm/number/SkeletonParser.js

@@ -0,0 +1,172 @@
+import {getCurrency} from "./currencies.js"
+
+const NUMBER_REGEX =
+    // eslint-disable-next-line max-len
+    /(?:[#]+|[@]+(?:#+)?|[0]+|[,]|[.]|[-]|[+]|[%]|[¤]{1,4}(?:\/([a-zA-Z]{3}))?|[;]|[K]{1,2}|E{1,2}[+]?|'(?:[^']|'')*')|[^a-zA-Z']+/g;
+
+const options = {
+    compactDisplay : ['short', 'long'], //valid only when notation is compact
+    currency: '', // must be provided if the style is currency
+    currencyDisplay: ["symbol", 'narrowSymbol', 'code', 'name'],
+    currencySign : ['accounting', 'standard'],
+    localeMatcher : ['lookup', 'best fit'],
+    notation : ['standard', 'scientific', 'engineering', 'compact'],
+    numberingSystem :'' ,
+    signDisplay : ['auto', 'always', 'exceptZero', 'negative', 'never'],
+    style : ['decimal', 'currency', 'percent', 'unit'],
+    unit: '', //https://tc39.es/proposal-unified-intl-numberformat/section6/locales-currencies-tz_proposed_out.html#sec-issanctionedsimpleunitidentifier
+    unitDisplay : ['long', 'short', 'narrow'],
+    useGrouping : ['always', 'auto', 'min2', false, true],
+    roundingMode : '',
+    roundingPriority : '',
+    roundingIncrement : '',
+    trailingZeroDisplay : ['auto', 'stripIfInteger'],
+    minimumIntegerDigits : '',
+    minimumFractionDigits : '',
+    maximumFractionDigits : '',
+    minimumSignificantDigits : '',
+    maximumSignificantDigits : ''
+}
+const supportedUnits = ['acre', 'bit', 'byte', 'celsius', 'centimeter', 'day',
+    'degree', 'fahrenheit', 'fluid-ounce', 'foot', 'gallon', 'gigabit',
+    'gigabyte', 'gram', 'hectare', 'hour', 'inch', 'kilobit', 'kilobyte',
+    'kilogram', 'kilometer', 'liter', 'megabit', 'megabyte', 'meter', 'mile',
+    'mile-scandinavian', 'milliliter', 'millimeter', 'millisecond', 'minute', 'month',
+    'ounce', 'percent', 'petabyte', 'pound', 'second', 'stone', 'terabit', 'terabyte', 'week', 'yard', 'year'].join('|')
+export const ShorthandStyles = [/^currency(?:\/([a-zA-Z]{3}))?$/, /^decimal$/, /^integer$/,  /^percent$/, new RegExp(`^unit\/(${supportedUnits})$`)]
+
+
+export function parseNumberSkeleton(skeleton, language) {
+    const options = {}
+    const order = [];
+    let match, index
+    for (index = 0; index < ShorthandStyles.length && match == null; index++) {
+        match = ShorthandStyles[index].exec(skeleton)
+    }
+    if (match) {
+        switch(index) {
+            case 1:
+                options.style = 'currency'
+                options.currencyDisplay = 'narrowSymbol'
+                if (match[1]) {
+                    options.currency = match[1]
+                } else {
+                    options.currency = getCurrency(language)
+                }
+                break;
+            case 2:
+                const defaultOptions = new Intl.NumberFormat(language, {}).resolvedOptions();
+                options.minimumFractionDigits = options.minimumFractionDigits || 2;
+                break;
+            case 3:
+                options.minimumFractionDigits = 0;
+                options.maximumFractionDigits = 0;
+                break;
+            case 4:
+                options.style = 'percent'
+                break;
+            case 5:
+                options.style = "unit";
+                options.unitDisplay = "long";
+                options.unit = match[1];
+                break;
+        }
+        return {
+            options,
+            order
+        }
+    }
+    options.useGrouping = false
+    options.minimumIntegerDigits = 1
+    options.maximumFractionDigits = 0
+    options.minimumFractionDigits = 0
+    skeleton.replace(NUMBER_REGEX, (match, offset) => {
+        const len = match.length;
+        switch(match[0]) {
+            case '#':
+                order.push(['digit', len])
+                if (options?.decimal === true) {
+                    options.maximumFractionDigits = options.minimumFractionDigits + len
+                }
+                break;
+            case '@':
+                if (options?.minimumSignificantDigits) {
+                    throw "@ symbol should occur together"
+                }
+                order.push(['@', len])
+                options.minimumSignificantDigits = len
+                const hashes = match.match(/#+/) || ""
+                options.maximumSignificantDigits = len + hashes.length
+                order.push(['digit', hashes.length])
+                break;
+            case ',':
+                if (options?.decimal === true) {
+                    throw "grouping character not supporting for fractions"
+                }
+                order.push(['group', 1])
+                options.useGrouping = 'auto';
+                break;
+            case '.':
+                if (options?.decimal) {
+                    console.error("only one decimal symbol is allowed");
+                } else {
+                    order.push(['decimal', 1])
+                    options.decimal = true;
+                }
+                break;
+            case '0':
+                order.push('0', len)
+                if(options.minimumSignificantDigits || options.maximumSignificantDigits) {
+                    throw "0 is not supported with @"
+                }
+                if (options?.decimal === true) {
+                    options.minimumFractionDigits = len;
+                } else {
+                    options.minimumIntegerDigits = len
+                }
+                break;
+            case '-':
+                if (offset !== 0) {
+                    console.error("sign display is always in the beginning")
+                }
+                options.signDisplay = 'negative'
+                order.push(['signDisplay', 1, '-'])
+                break;
+            case '+':
+                if (offset !== 0 && order[order.length - 1][0] === 'E') {
+                    console.error("sign display is always in the beginning")
+                }
+                if (offset === 0) {
+                    options.signDisplay = 'always'
+                }
+                order.push(['signDisplay', 1, '+'])
+                break;
+            case '¤':
+                if (offset !== 0 && offset !== skeleton.length - 1) {
+                    console.error("currency display should be either in the beginning or at the end")
+                }
+                options.style = 'currency'
+                options.currencyDisplay = ['symbol', 'code', 'name', 'narrowSymbol'][len -1]
+                options.currency = getCurrency(language)
+                order.push(['currency', len])
+                break;
+            case '%':
+                if (offset !== 0 && offset !== skeleton.length - 1) {
+                    console.error("percent display should be either in the beginning or at the end")
+                }
+                order.push(['%', 1])
+                options.style = 'percent'
+                break;
+            case 'E':
+                order.push(['E', len])
+                options.style = ['scientific','engineering'](len - 1)
+                break;
+            default:
+                console.error("unknown chars" + match);
+        }
+    })
+    return {
+        options,
+        order
+    };
+}

package/lib/esm/number/currencies.js

@@ -0,0 +1,38 @@
+const currencies = {
+  'da-DK': 'DKK',
+  'de-DE': 'EUR',
+  'en-US': 'USD',
+  'en-GB': 'GBP',
+  'es-ES': 'EUR',
+  'fi-FI': 'EUR',
+  'fr-FR': 'EUR',
+  'it-IT': 'EUR',
+  'ja-JP': 'JPY',
+  'nb-NO': 'NOK',
+  'nl-NL': 'EUR',
+  'pt-BR': 'BRL',
+  'sv-SE': 'SEK',
+  'zh-CN': 'CNY',
+  'zh-TW': 'TWD',
+  'ko-KR': 'KRW',
+  'cs-CZ': 'CZK',
+  'pl-PL': 'PLN',
+  'ru-RU': 'RUB',
+  'tr-TR': 'TRY'
+};
+
+const locales = Object.keys(currencies)
+
+const getCurrency = function (locale) {
+  if (locales.indexOf(locale) > -1) {
+    return currencies[locale]
+  } else {
+    const matchingLocale = locales.find(x => x.startsWith(locale))
+    if (matchingLocale) {
+      return currencies[matchingLocale]
+    }
+  }
+  return ''
+}
+
+export {getCurrency}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aemforms/af-formatters",
-  "version": "0.22.25",
+  "version": "0.22.26",
   "description": "Formatting Module for Forms Runtime",
   "author": "Adobe Systems",
   "license": "Adobe Proprietary",