@aemforms/af-formatters 0.22.26 → 0.22.30

package/lib/esm/number/SkeletonParser.js

@@ -1,61 +1,54 @@
-import {getCurrency} from "./currencies.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.
 
-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;
+* Adobe permits you to use and modify this file solely in accordance with
+* the terms of the Adobe license agreement accompanying it.
+*************************************************************************/
 
-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 : ''
-}
+import { getCurrency } from './currencies.js';
+
+const NUMBER_REGEX =
+    /(?:[#]+|[@]+(#+)?|[0]+|[,]|[.]|[-]|[+]|[%]|[¤]{1,4}(?:\/([a-zA-Z]{3}))?|[;]|[K]{1,2}|E{1,2}[+]?|'(?:[^']|'')*')|[^a-zA-Z']+/g;
 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 = {}
+    'ounce', 'percent', 'petabyte', 'pound', 'second', 'stone', 'terabit', 'terabyte', 'week', 'yard', 'year'].join('|');
+const ShorthandStyles = [/^currency(?:\/([a-zA-Z]{3}))?$/, /^decimal$/, /^integer$/,  /^percent$/, new RegExp(`^unit\/(${supportedUnits})$`)];
+function parseNumberSkeleton(skeleton, language) {
+    const options = {};
     const order = [];
-    let match, index
+    let match, index;
     for (index = 0; index < ShorthandStyles.length && match == null; index++) {
-        match = ShorthandStyles[index].exec(skeleton)
+        match = ShorthandStyles[index].exec(skeleton);
     }
     if (match) {
         switch(index) {
             case 1:
-                options.style = 'currency'
-                options.currencyDisplay = 'narrowSymbol'
+                options.style = 'currency';
+                options.currencyDisplay = 'narrowSymbol';
                 if (match[1]) {
-                    options.currency = match[1]
+                    options.currency = match[1];
                 } else {
-                    options.currency = getCurrency(language)
+                    options.currency = getCurrency(language);
                 }
                 break;
             case 2:
-                const defaultOptions = new Intl.NumberFormat(language, {}).resolvedOptions();
+                new Intl.NumberFormat(language, {}).resolvedOptions();
                 options.minimumFractionDigits = options.minimumFractionDigits || 2;
                 break;
             case 3:
@@ -63,7 +56,8 @@ export function parseNumberSkeleton(skeleton, language) {
                 options.maximumFractionDigits = 0;
                 break;
             case 4:
-                options.style = 'percent'
+                options.style = 'percent';
+                options.maximumFractionDigits = 2;
                 break;
             case 5:
                 options.style = "unit";
@@ -76,97 +70,104 @@ export function parseNumberSkeleton(skeleton, language) {
             order
         }
     }
-    options.useGrouping = false
-    options.minimumIntegerDigits = 1
-    options.maximumFractionDigits = 0
-    options.minimumFractionDigits = 0
-    skeleton.replace(NUMBER_REGEX, (match, offset) => {
+    options.useGrouping = false;
+    options.minimumIntegerDigits = 1;
+    options.maximumFractionDigits = 0;
+    options.minimumFractionDigits = 0;
+    skeleton.replace(NUMBER_REGEX, (match, maxSignificantDigits, currencySymbol, offset) => {
         const len = match.length;
         switch(match[0]) {
             case '#':
-                order.push(['digit', len])
+                order.push(['digit', len]);
                 if (options?.decimal === true) {
-                    options.maximumFractionDigits = options.minimumFractionDigits + len
+                    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])
+                const hashes = maxSignificantDigits || "";
+                order.push(['@', len - hashes.length]);
+                options.minimumSignificantDigits = len - hashes.length;
+                options.maximumSignificantDigits = len;
+                order.push(['digit', hashes.length]);
                 break;
             case ',':
                 if (options?.decimal === true) {
                     throw "grouping character not supporting for fractions"
                 }
-                order.push(['group', 1])
+                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])
+                    order.push(['decimal', 1]);
                     options.decimal = true;
                 }
                 break;
             case '0':
-                order.push('0', len)
+                order.push('0', len);
                 if(options.minimumSignificantDigits || options.maximumSignificantDigits) {
                     throw "0 is not supported with @"
                 }
                 if (options?.decimal === true) {
                     options.minimumFractionDigits = len;
+                    if (!options.maximumFractionDigits) {
+                        options.maximumFractionDigits = len;
+                    }
                 } else {
-                    options.minimumIntegerDigits = len
+                    options.minimumIntegerDigits = len;
                 }
                 break;
             case '-':
                 if (offset !== 0) {
-                    console.error("sign display is always in the beginning")
+                    console.error("sign display is always in the beginning");
                 }
-                options.signDisplay = 'negative'
-                order.push(['signDisplay', 1, '-'])
+                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")
+                    console.error("sign display is always in the beginning");
                 }
                 if (offset === 0) {
-                    options.signDisplay = 'always'
+                    options.signDisplay = 'always';
                 }
-                order.push(['signDisplay', 1, '+'])
+                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")
+                    console.error("currency display should be either in the beginning or at the end");
+                } else {
+                    options.style = 'currency';
+                    options.currencyDisplay = ['symbol', 'code', 'name', 'narrowSymbol'][len - 1];
+                    options.currency = currencySymbol || getCurrency(language);
+                    order.push(['currency', len]);
                 }
-                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")
+                    console.error("percent display should be either in the beginning or at the end");
+                } else {
+                    order.push(['%', 1]);
+                    options.style = 'percent';
                 }
-                order.push(['%', 1])
-                options.style = 'percent'
                 break;
             case 'E':
-                order.push(['E', len])
-                options.style = ['scientific','engineering'](len - 1)
+                order.push(['E', len]);
+                options.style = ['scientific','engineering'](len - 1);
                 break;
             default:
                 console.error("unknown chars" + match);
         }
-    })
+    });
     return {
         options,
         order
     };
 }
+
+export { ShorthandStyles, parseNumberSkeleton };

package/lib/esm/number/currencies.js

@@ -1,3 +1,23 @@
+/*************************************************************************
+* 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 currencies = {
   'da-DK': 'DKK',
   'de-DE': 'EUR',
@@ -20,19 +40,17 @@ const currencies = {
   'ru-RU': 'RUB',
   'tr-TR': 'TRY'
 };
-
-const locales = Object.keys(currencies)
-
+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))
+    const matchingLocale = locales.find(x => x.startsWith(locale));
     if (matchingLocale) {
       return currencies[matchingLocale]
     }
   }
   return ''
-}
+};
 
-export {getCurrency}
+export { getCurrency };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aemforms/af-formatters",
-  "version": "0.22.26",
+  "version": "0.22.30",
   "description": "Formatting Module for Forms Runtime",
   "author": "Adobe Systems",
   "license": "Adobe Proprietary",
@@ -27,6 +27,16 @@
     "lib",
     "LICENSE"
   ],
+  "scripts": {
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest --silent",
+    "eslint": "npx eslint src/**",
+    "eslint:fix": "npx eslint --fix src/**",
+    "test:ci": "NODE_OPTIONS=--experimental-vm-modules jest --silent --coverage",
+    "build": "npm run clean && mkdir -p lib/esm && cp -R src/* lib/esm/ && rollup -c rollup.config.js",
+    "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",