@aemforms/af-formatters 0.22.23 → 0.22.26

package/lib/esm/number/SkeletonParser.js

@@ -1,54 +1,61 @@
-/*************************************************************************
-* 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.
-*************************************************************************/
-
-import { getCurrency } from './currencies.js';
+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;
+    // 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('|');
-const ShorthandStyles = [/^currency(?:\/([a-zA-Z]{3}))?$/, /^decimal$/, /^integer$/,  /^percent$/, new RegExp(`^unit\/(${supportedUnits})$`)];
-function parseNumberSkeleton(skeleton, language) {
-    const options = {};
+    '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;
+    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:
-                new Intl.NumberFormat(language, {}).resolvedOptions();
+                const defaultOptions = new Intl.NumberFormat(language, {}).resolvedOptions();
                 options.minimumFractionDigits = options.minimumFractionDigits || 2;
                 break;
             case 3:
@@ -56,8 +63,7 @@ function parseNumberSkeleton(skeleton, language) {
                 options.maximumFractionDigits = 0;
                 break;
             case 4:
-                options.style = 'percent';
-                options.maximumFractionDigits = 2;
+                options.style = 'percent'
                 break;
             case 5:
                 options.style = "unit";
@@ -70,104 +76,97 @@ function parseNumberSkeleton(skeleton, language) {
             order
         }
     }
-    options.useGrouping = false;
-    options.minimumIntegerDigits = 1;
-    options.maximumFractionDigits = 0;
-    options.minimumFractionDigits = 0;
-    skeleton.replace(NUMBER_REGEX, (match, maxSignificantDigits, currencySymbol, offset) => {
+    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]);
+                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"
                 }
-                const hashes = maxSignificantDigits || "";
-                order.push(['@', len - hashes.length]);
-                options.minimumSignificantDigits = len - hashes.length;
-                options.maximumSignificantDigits = len;
-                order.push(['digit', hashes.length]);
+                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]);
+                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");
-                } else {
-                    options.style = 'currency';
-                    options.currencyDisplay = ['symbol', 'code', 'name', 'narrowSymbol'][len - 1];
-                    options.currency = currencySymbol || getCurrency(language);
-                    order.push(['currency', len]);
+                    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");
-                } else {
-                    order.push(['%', 1]);
-                    options.style = 'percent';
+                    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);
+                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,23 +1,3 @@
-/*************************************************************************
-* 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',
@@ -40,17 +20,19 @@ 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.23",
+  "version": "0.22.26",
   "description": "Formatting Module for Forms Runtime",
   "author": "Adobe Systems",
   "license": "Adobe Proprietary",
@@ -27,16 +27,6 @@
     "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",