@lion/ui 0.0.1

package/components/localize/src/number/formatNumberToParts.js

@@ -0,0 +1,161 @@
+import { emptyStringWhenNumberNan } from './utils/emptyStringWhenNumberNan.js';
+import { getSeparatorsFromNumber } from './getSeparatorsFromNumber.js';
+import { getDecimalSeparator } from './getDecimalSeparator.js';
+import { getGroupSeparator } from './getGroupSeparator.js';
+import { getLocale } from '../utils/getLocale.js';
+import { normalizeIntl } from './utils/normalize-format-number-to-parts/normalizeIntl.js';
+import { normalSpaces } from './utils/normalSpaces.js';
+
+/**
+ * Round the number based on the options
+ *
+ * @param {number} number
+ * @param {string} roundMode
+ * @throws {Error} roundMode can only be round|floor|ceiling
+ * @returns {number}
+ */
+export function roundNumber(number, roundMode) {
+  switch (roundMode) {
+    case 'floor':
+      return Math.floor(number);
+    case 'ceiling':
+      return Math.ceil(number);
+    case 'round':
+      return Math.round(number);
+    default:
+      throw new Error('roundMode can only be round|floor|ceiling');
+  }
+}
+
+/**
+ * Splits a number up in parts for integer, fraction, group, literal, decimal and currency.
+ *
+ * @typedef {import('../../types/LocalizeMixinTypes.js').FormatNumberPart} FormatNumberPart
+ * @param {number} number Number to split up
+ * @param {import('../../types/LocalizeMixinTypes.js').FormatNumberOptions} [options] Intl options are available extended by roundMode,returnIfNaN
+ * @returns {string | FormatNumberPart[]} Array with parts or (an empty string or returnIfNaN if not a number)
+ */
+export function formatNumberToParts(number, options = {}) {
+  let parsedNumber = typeof number === 'string' ? parseFloat(number) : number;
+  const computedLocale = getLocale(options && options.locale);
+  // when parsedNumber is not a number we should return an empty string or returnIfNaN
+  if (Number.isNaN(parsedNumber)) {
+    return emptyStringWhenNumberNan(options && options.returnIfNaN);
+  }
+  // If roundMode is given the number is rounded based upon the mode
+  if (options && options.roundMode) {
+    parsedNumber = roundNumber(number, options.roundMode);
+  }
+  let formattedParts = [];
+
+  const formattedNumber = Intl.NumberFormat(computedLocale, options).format(parsedNumber);
+  const { decimalSeparator, groupSeparator } = getSeparatorsFromNumber(
+    parsedNumber,
+    formattedNumber,
+    options,
+  );
+
+  // eslint-disable-next-line no-irregular-whitespace
+  const regexCurrency = /[.,\s0-9 _ ]/;
+  const regexMinusSign = /[-]/; // U+002D, Hyphen-Minus, -
+  const regexNum = /[0-9]/;
+  const regexSpace = /[\s]/;
+  let currency = '';
+  let numberPart = '';
+  let fraction = false;
+  let isGroup = false;
+  const group = getGroupSeparator(computedLocale, options);
+  const decimal = getDecimalSeparator(computedLocale, options);
+  if (decimalSeparator && groupSeparator && group === decimal) {
+    throw new Error(`Decimal and group (thousand) separator are the same character: '${group}'.
+This can happen due to both props being specified as the same, or one of the props being the same as the other one from default locale.
+Please specify .groupSeparator / .decimalSeparator on the formatOptions object to be different.`);
+  }
+
+  for (let i = 0; i < formattedNumber.length; i += 1) {
+    // detect minusSign
+    if (regexMinusSign.test(formattedNumber[i])) {
+      formattedParts.push({ type: 'minusSign', value: '−' /* U+2212, 'Minus-Sign', &minus; */ });
+    }
+    // detect numbers
+    if (regexNum.test(formattedNumber[i])) {
+      numberPart += formattedNumber[i];
+    }
+
+    // detect currency (symbol or code)
+    if (!regexCurrency.test(formattedNumber[i]) && !regexMinusSign.test(formattedNumber[i])) {
+      currency += formattedNumber[i];
+    }
+    // push when another character then currency
+    if (regexCurrency.test(formattedNumber[i]) && currency) {
+      formattedParts.push({ type: 'currency', value: currency });
+      currency = '';
+    }
+
+    // group sep must be lead by / followed by a number
+    if (
+      formattedNumber[i] === groupSeparator &&
+      formattedNumber[i - 1].match(regexNum) &&
+      formattedNumber[i + 1].match(regexNum)
+    ) {
+      // Write number grouping
+      if (numberPart) {
+        formattedParts.push({ type: 'integer', value: numberPart });
+        numberPart = '';
+      }
+
+      formattedParts.push({ type: 'group', value: group });
+      isGroup = true;
+    }
+
+    if (formattedNumber[i] === decimalSeparator) {
+      // Write number grouping
+      if (numberPart) {
+        formattedParts.push({ type: 'integer', value: numberPart });
+        numberPart = '';
+      }
+
+      formattedParts.push({ type: 'decimal', value: decimal });
+      fraction = true;
+    }
+
+    // detect literals (empty spaces) or space group separator
+    if (regexSpace.test(formattedNumber[i])) {
+      const hasNumberPart = !!numberPart;
+      // Write number grouping
+      if (numberPart && !fraction) {
+        formattedParts.push({ type: 'integer', value: numberPart });
+        numberPart = '';
+      } else if (numberPart) {
+        formattedParts.push({ type: 'fraction', value: numberPart });
+        numberPart = '';
+      }
+      // If space equals the group separator it gets type group
+      if (normalSpaces(formattedNumber[i]) === group && hasNumberPart && !fraction) {
+        formattedParts.push({ type: 'group', value: formattedNumber[i] });
+        // if we already pushed it as a group separator, don't add it as a literal on top..
+      } else if (!isGroup) {
+        formattedParts.push({ type: 'literal', value: formattedNumber[i] });
+      }
+    }
+    isGroup = false;
+    // Numbers after the decimal sign are fractions, write the last
+    // fractions at the end of the number
+    if (fraction === true && i === formattedNumber.length - 1) {
+      // write last number part
+      if (numberPart) {
+        formattedParts.push({ type: 'fraction', value: numberPart });
+      }
+      // If there are no fractions but we reached the end write the number part as integer
+    } else if (i === formattedNumber.length - 1 && numberPart) {
+      formattedParts.push({ type: 'integer', value: numberPart });
+    }
+    // push currency on end of loop
+    if (i === formattedNumber.length - 1 && currency) {
+      formattedParts.push({ type: 'currency', value: currency });
+      currency = '';
+    }
+  }
+  formattedParts = normalizeIntl(formattedParts, options, computedLocale);
+  return formattedParts;
+}

package/components/localize/src/number/getCurrencyName.js

@@ -0,0 +1,31 @@
+import { localize } from '../singleton.js';
+import { formatNumberToParts } from './formatNumberToParts.js';
+import { forceCurrencyNameForPHPEnGB } from './utils/normalize-get-currency-name/forceCurrencyNameForPHPEnGB.js';
+
+/**
+ * Based on number, returns currency name like 'US dollar'
+ *
+ * @typedef {import('../../types/LocalizeMixinTypes.js').FormatNumberPart} FormatNumberPart
+ * @param {string} currencyIso iso code like USD
+ * @param {import('../../types/LocalizeMixinTypes.js').FormatNumberOptions} [options] Intl options are available extended by roundMode
+ * @returns {string} currency name like 'US dollar'
+ */
+export function getCurrencyName(currencyIso, options) {
+  const parts = /** @type {FormatNumberPart[]} */ (
+    formatNumberToParts(1, {
+      ...options,
+      style: 'currency',
+      currency: currencyIso,
+      currencyDisplay: 'name',
+    })
+  );
+  let currencyName = parts
+    .filter(p => p.type === 'currency')
+    .map(o => o.value)
+    .join(' ');
+  const locale = options?.locale || localize.locale;
+  if (currencyIso === 'PHP' && locale === 'en-GB') {
+    currencyName = forceCurrencyNameForPHPEnGB(currencyName);
+  }
+  return currencyName;
+}

package/components/localize/src/number/getDecimalSeparator.js

@@ -0,0 +1,20 @@
+import { getLocale } from '../utils/getLocale.js';
+
+/**
+ * To get the decimal separator
+ *
+ * @param {string} [locale] To override the browser locale
+ * @param {import('../../types/LocalizeMixinTypes.js').FormatNumberOptions} [options]
+ * @returns {string} The separator
+ */
+export function getDecimalSeparator(locale, options) {
+  if (options && options.decimalSeparator) {
+    return options.decimalSeparator;
+  }
+  const computedLocale = getLocale(locale);
+  const formattedNumber = Intl.NumberFormat(computedLocale, {
+    style: 'decimal',
+    minimumFractionDigits: 1,
+  }).format(1);
+  return formattedNumber[1];
+}

package/components/localize/src/number/getFractionDigits.js

@@ -0,0 +1,20 @@
+import { formatNumberToParts } from './formatNumberToParts.js';
+
+/**
+ * @example
+ * getFractionDigits('JOD'); // return 3
+ *
+ * @typedef {import('../../types/LocalizeMixinTypes.js').FormatNumberPart} FormatNumberPart
+ * @param {string} [currency="EUR"] Currency code e.g. EUR
+ * @returns {number} fraction for the given currency
+ */
+export function getFractionDigits(currency = 'EUR') {
+  const parts = /** @type {FormatNumberPart[]} */ (
+    formatNumberToParts(123, {
+      style: 'currency',
+      currency,
+    })
+  );
+  const [fractionPart] = parts.filter(part => part.type === 'fraction');
+  return fractionPart ? fractionPart.value.length : 0;
+}

package/components/localize/src/number/getGroupSeparator.js

@@ -0,0 +1,21 @@
+import { getLocale } from '../utils/getLocale.js';
+import { normalSpaces } from './utils/normalSpaces.js';
+
+/**
+ * Gets the group separator
+ *
+ * @param {string} [locale] To override the browser locale
+ * @param {import('../../types/LocalizeMixinTypes.js').FormatNumberOptions} [options]
+ * @returns {string}
+ */
+export function getGroupSeparator(locale, options) {
+  if (options && options.groupSeparator) {
+    return options.groupSeparator;
+  }
+  const computedLocale = getLocale(locale);
+  const formattedNumber = Intl.NumberFormat(computedLocale, {
+    style: 'decimal',
+    minimumFractionDigits: 0,
+  }).format(10000);
+  return normalSpaces(formattedNumber[2]);
+}

package/components/localize/src/number/getSeparatorsFromNumber.js

@@ -0,0 +1,58 @@
+/**
+ *
+ * @param {number} parsedNumber
+ * @param {string} formattedNumber
+ * @param {import('../../types/LocalizeMixinTypes.js').FormatNumberOptions} [options]
+ * @returns {{groupSeparator: string|null, decimalSeparator: string|null}}
+ */
+export function getSeparatorsFromNumber(parsedNumber, formattedNumber, options) {
+  // separator can only happen if there is at least 1 digit before and after the separator
+  // eslint-disable-next-line no-irregular-whitespace
+  const regexSeparator = /[0-9](?<sep>[\s,. _ '])[0-9]/g;
+
+  /** @type {string[]} */
+  const separators = [];
+  let match;
+  // eslint-disable-next-line no-cond-assign
+  while ((match = regexSeparator.exec(formattedNumber)) !== null) {
+    if (match.groups && match.groups.sep) {
+      separators.push(match.groups?.sep);
+    }
+  }
+
+  let groupSeparator = null;
+  let decimalSeparator = null;
+  if (separators) {
+    if (separators.length === 1) {
+      const parts = formattedNumber.split(separators[0]);
+      // Not sure if decimal or group, because only 1 separator.
+      // if the separator is followed by at least 3 or more digits
+      // and if the original number value is more or equal than 1000 or less or equal than -1000
+      // or the minimum integer digits is forced to more than 3,
+      // it has to be the group separator
+      if (
+        parts[1].replace(/[^0-9]/g, '').length >= 3 &&
+        (parsedNumber >= 1000 ||
+          parsedNumber <= -1 * 1000 ||
+          (options?.minimumIntegerDigits && options.minimumIntegerDigits > 3))
+      ) {
+        [groupSeparator] = separators;
+      } else {
+        [decimalSeparator] = separators;
+      }
+    } else if (separators.every(val => val === separators[0])) {
+      // multiple separators, check if they are all the same or not
+      // if the same, it means they are group separators
+      // if not, it means that the last one must be the decimal separator
+      [groupSeparator] = separators;
+    } else {
+      [groupSeparator] = separators;
+      decimalSeparator = separators[separators.length - 1];
+    }
+  }
+
+  return {
+    groupSeparator,
+    decimalSeparator,
+  };
+}

package/components/localize/src/number/normalizeCurrencyLabel.js

@@ -0,0 +1,10 @@
+/**
+ * For Turkey fixes currency label with locale options
+ *
+ * @param {string} currency
+ * @param {string} locale
+ * @returns {string}
+ */
+export function normalizeCurrencyLabel(currency, locale) {
+  return currency === 'TRY' && locale === 'tr-TR' ? 'TL' : currency;
+}

package/components/localize/src/number/parseNumber.js

@@ -0,0 +1,149 @@
+import { getDecimalSeparator } from './getDecimalSeparator.js';
+
+/**
+ * @param {string} value to evaluate
+ * @return {boolean} true if value equal . or ,
+ */
+function isDecimalSeparator(value) {
+  return value === '.' || value === ',';
+}
+
+/**
+ * Determines the best possible parsing mode.
+ *
+ * - If there is only one separator (withLocale)
+ * - 1,23 => xxx1.23 (heuristic)
+ * - else parse mode depends mostly on the last 4 chars
+ * - 1234 => xxx1234 (heuristic)
+ * - [space]123 => xxx123 (heuristic)
+ * - ,123 => unclear
+ *   - if 1.000,123 (we find a different separator) => 1000.123 (heuristic)
+ *   - if 1,000,123 (we find only same separators) => 1000123 (unparseable)
+ *   - if 100,123 (we find no more separators) => unclear
+ *     - if en => 100123 (withLocale)
+ *     - if nl => 100.123 (withLocale)
+ *
+ * See also {@link parseAmount}
+ *
+ * @example
+ * getParseMode('1.234') => 'withLocale'
+ *
+ * @param {string} value Clean number (only [0-9 ,.]) to be parsed
+ * @return {string} unparseable|withLocale|heuristic
+ */
+function getParseMode(value, { mode = 'auto' } = {}) {
+  const separators = value.match(/[., ]/g);
+
+  if (mode === 'auto' && separators && separators.length === 1) {
+    return 'withLocale';
+  }
+
+  if (value.length > 4) {
+    const charAtLastSeparatorPosition = value[value.length - 4];
+    if (isDecimalSeparator(charAtLastSeparatorPosition)) {
+      const firstPart = value.substring(0, value.length - 4);
+      const otherSeparators = firstPart.match(/[., ]/g);
+      if (otherSeparators) {
+        const lastSeparator = charAtLastSeparatorPosition;
+        return otherSeparators.indexOf(lastSeparator) === -1 ? 'heuristic' : 'unparseable';
+      }
+      return 'withLocale';
+    }
+  }
+  return 'heuristic';
+}
+
+/**
+ * Parses numbers by considering the locale.
+ * Useful for numbers with an ending pair of 3 number chars as in this case you can not be
+ * certain if it is a group or comma separator. e.g. 1.234; 1,234; 1234.567;
+ * Taking into consideration the locale we make the best possible assumption.
+ *
+ * @example
+ * parseWithLocale('1.234', { locale: 'en-GB' }) => 1.234
+ * parseWithLocale('1,234', { locale: 'en-GB' }) => 1234
+ *
+ * @param {string} value Number to be parsed
+ * @param {import('../../types/LocalizeMixinTypes.js').FormatNumberOptions} options Locale Options
+ */
+function parseWithLocale(value, options) {
+  const locale = options && options.locale ? options.locale : undefined;
+  const separator = getDecimalSeparator(locale, options);
+  const regexNumberAndLocaleSeparator = new RegExp(`[0-9${separator}-]`, 'g');
+  let numberAndLocaleSeparator = value.match(regexNumberAndLocaleSeparator)?.join('');
+  if (separator === ',') {
+    numberAndLocaleSeparator = numberAndLocaleSeparator?.replace(',', '.');
+  }
+  if (!numberAndLocaleSeparator) {
+    return NaN;
+  }
+  return parseFloat(numberAndLocaleSeparator);
+}
+
+/**
+ * Parses numbers by considering all separators.
+ * It only keeps the last separator and uses it as decimal separator.
+ *
+ * Warning: This function works only with numbers that can be heuristically parsed.
+ *
+ * @param {string} value Number that can be heuristically parsed
+ * @return {number} parsed javascript number
+ */
+function parseHeuristic(value) {
+  if (value.match(/[0-9., ]/g)) {
+    // 1. put placeholder at decimal separator
+    const numberString = value
+      .replace(/(,|\.)([^,|.]*)$/g, '_decSep_$2')
+      .replace(/(,|\.| )/g, '') // 2. remove all group separators
+      .replace(/_decSep_/, '.'); // 3. restore decimal separator
+    return parseFloat(numberString);
+  }
+  return 0;
+}
+
+/**
+ * Parses a number string and returns the best possible javascript number.
+ * For edge cases it may use locale to give the best possible assumption.
+ *
+ * It has 3 "methods" of returning numbers
+ * - 'unparseable': becomes just numbers
+ * - 'withLocale': result depends on given or global locale
+ * - 'heuristic': result depends on considering separators
+ *
+ * @example
+ * parseNumber('1.234.567'); // method: unparseable => 1234567
+ * parseNumber('1.234'); // method: withLocale => depending on locale 1234 or 1.234
+ * parseNumber('1.234,56'); // method: heuristic => 1234.56
+ * parseNumber('1 234.56'); // method: heuristic => 1234.56
+ * parseNumber('1,234.56'); // method: heuristic => 1234.56
+ *
+ * @param {string} value Number to be parsed
+ * @param {import('../../types/LocalizeMixinTypes.js').FormatNumberOptions} [options] Locale Options
+ */
+export function parseNumber(value, options) {
+  const containsNumbers = value.match(/\d/g);
+  if (!containsNumbers) {
+    return undefined;
+  }
+  const matchedInput = value.match(/[0-9,.\- ]/g);
+  if (!matchedInput) {
+    return undefined;
+  }
+  const cleanedInput = matchedInput.join('');
+  const parseMode = getParseMode(cleanedInput, options);
+  switch (parseMode) {
+    case 'unparseable': {
+      const cleanedInputMatchStr = cleanedInput.match(/[0-9]/g)?.join('');
+      if (!cleanedInputMatchStr) {
+        return NaN;
+      }
+      return parseFloat(cleanedInputMatchStr);
+    }
+    case 'withLocale':
+      return parseWithLocale(cleanedInput, options || {});
+    case 'heuristic':
+      return parseHeuristic(cleanedInput);
+    default:
+      return 0;
+  }
+}

package/components/localize/src/number/utils/emptyStringWhenNumberNan.js

@@ -0,0 +1,11 @@
+import { localize } from '../../singleton.js';
+
+/**
+ * When number is NaN we should return an empty string or returnIfNaN param
+ *
+ * @param {string|undefined} returnIfNaN
+ * @returns {string}
+ */
+export function emptyStringWhenNumberNan(returnIfNaN) {
+  return returnIfNaN || localize.formatNumberOptions.returnIfNaN;
+}

package/components/localize/src/number/utils/normalSpaces.js

@@ -0,0 +1,8 @@
+/**
+ * @param {string} value
+ * @returns {string} value with forced "normal" space
+ */
+export function normalSpaces(value) {
+  // If non-breaking space (160) or narrow non-breaking space (8239) then return ' '
+  return value.charCodeAt(0) === 160 || value.charCodeAt(0) === 8239 ? ' ' : value;
+}

package/components/localize/src/number/utils/normalize-format-number-to-parts/forceAddGroupSeparators.js

@@ -0,0 +1,71 @@
+/**
+ * Add separators when they are not present
+ *
+ * @typedef {import('../../../../types/LocalizeMixinTypes.js').FormatNumberPart} FormatNumberPart
+ * @param {FormatNumberPart[]} formattedParts
+ * @param {string} groupSeparator
+ * @returns {FormatNumberPart[]}
+ */
+export function forceAddGroupSeparators(formattedParts, groupSeparator) {
+  /** @type {FormatNumberPart[]} */
+  let concatArray = [];
+  let firstPart;
+  let integerPart;
+
+  for (let i = 0; i < formattedParts.length; i += 1) {
+    if (formattedParts[i].type === 'integer') {
+      firstPart = formattedParts.splice(0, i);
+      integerPart = formattedParts.splice(0, 1);
+    }
+  }
+  if (integerPart !== undefined) {
+    const numberOfDigits = integerPart[0].value.length;
+    const mod3 = numberOfDigits % 3;
+    const groups = Math.floor(numberOfDigits / 3);
+    const numberArray = [];
+    let numberOfGroups = 0;
+    let numberPart = '';
+    let firstGroup = false;
+    // Loop through the  integer
+    for (let i = 0; i < numberOfDigits; i += 1) {
+      numberPart += integerPart[0].value[i];
+      // Create first grouping which is < 3
+      if (numberPart.length === mod3 && firstGroup === false) {
+        numberArray.push({
+          type: 'integer',
+          value: numberPart,
+        });
+        if (numberOfDigits > 3) {
+          numberArray.push({
+            type: 'group',
+            value: groupSeparator,
+          });
+        }
+        numberPart = '';
+        firstGroup = true;
+        // Create groupings of 3
+      } else if (numberPart.length === 3 && i < numberOfDigits - 1) {
+        numberOfGroups += 1;
+        numberArray.push({
+          type: 'integer',
+          value: numberPart,
+        });
+        if (numberOfGroups !== groups) {
+          numberArray.push({
+            type: 'group',
+            value: groupSeparator,
+          });
+        }
+        numberPart = '';
+      }
+    }
+    numberArray.push({
+      type: 'integer',
+      value: numberPart,
+    });
+    if (firstPart) {
+      concatArray = firstPart.concat(numberArray, formattedParts);
+    }
+  }
+  return concatArray;
+}

package/components/localize/src/number/utils/normalize-format-number-to-parts/forceCurrencyToEnd.js

@@ -0,0 +1,21 @@
+/**
+ * For Dutch and Belgian amounts the currency should be at the end of the string
+ *
+ * @typedef {import('../../../../types/LocalizeMixinTypes.js').FormatNumberPart} FormatNumberPart
+ * @param {FormatNumberPart[]} formattedParts
+ * @returns {FormatNumberPart[]}
+ */
+export function forceCurrencyToEnd(formattedParts) {
+  if (formattedParts[0].type === 'currency') {
+    const moveCur = formattedParts.splice(0, 1);
+    const moveLit = formattedParts.splice(0, 1);
+    formattedParts.push(moveLit[0]);
+    formattedParts.push(moveCur[0]);
+  } else if (formattedParts[0].type === 'minusSign' && formattedParts[1].type === 'currency') {
+    const moveCur = formattedParts.splice(1, 1);
+    const moveLit = formattedParts.splice(1, 1);
+    formattedParts.push(moveLit[0]);
+    formattedParts.push(moveCur[0]);
+  }
+  return formattedParts;
+}

package/components/localize/src/number/utils/normalize-format-number-to-parts/forceENAUSymbols.js

@@ -0,0 +1,25 @@
+/** @type {Object.<string,string>} */
+const CURRENCY_CODE_SYMBOL_MAP = {
+  EUR: '€',
+  USD: '$',
+  JPY: '¥',
+};
+
+/**
+ * Change the symbols for locale 'en-AU', due to bug in Chrome
+ *
+ * @typedef {import('../../../../types/LocalizeMixinTypes.js').FormatNumberPart} FormatNumberPart
+ * @param {FormatNumberPart[]} formattedParts
+ * @param {import('../../../../types/LocalizeMixinTypes.js').FormatNumberOptions} options
+ * @returns {FormatNumberPart[]}
+ */
+export function forceENAUSymbols(formattedParts, { currency, currencyDisplay } = {}) {
+  const result = formattedParts;
+  if (formattedParts.length > 1 && currencyDisplay === 'symbol' && currency) {
+    if (Object.keys(CURRENCY_CODE_SYMBOL_MAP).includes(currency)) {
+      result[0].value = CURRENCY_CODE_SYMBOL_MAP[currency];
+    }
+    result[1].value = '';
+  }
+  return result;
+}

package/components/localize/src/number/utils/normalize-format-number-to-parts/forceNormalSpaces.js

@@ -0,0 +1,20 @@
+import { normalSpaces } from '../normalSpaces.js';
+
+/**
+ * Parts with forced "normal" spaces
+ *
+ * @typedef {import('../../../../types/LocalizeMixinTypes.js').FormatNumberPart} FormatNumberPart
+ * @param {FormatNumberPart[]} formattedParts
+ * @returns {FormatNumberPart[]}
+ */
+export function forceNormalSpaces(formattedParts) {
+  /** @type {FormatNumberPart[]} */
+  const result = [];
+  formattedParts.forEach(part => {
+    result.push({
+      type: part.type,
+      value: normalSpaces(part.value),
+    });
+  });
+  return result;
+}

package/components/localize/src/number/utils/normalize-format-number-to-parts/forceSpaceBetweenCurrencyCodeAndNumber.js

@@ -0,0 +1,35 @@
+/**
+ * When in some locales there is no space between currency and amount it is added
+ *
+ * @typedef {import('../../../../types/LocalizeMixinTypes.js').FormatNumberPart} FormatNumberPart
+ * @param {FormatNumberPart[]} formattedParts
+ * @param {import('../../../../types/LocalizeMixinTypes.js').FormatNumberOptions} options
+ * @returns {FormatNumberPart[]}
+ */
+export function forceSpaceBetweenCurrencyCodeAndNumber(
+  formattedParts,
+  { currency, currencyDisplay } = {},
+) {
+  const numberOfParts = formattedParts.length;
+  const literalObject = { type: 'literal', value: ' ' };
+  if (numberOfParts > 1 && currency && currencyDisplay === 'code') {
+    if (formattedParts[0].type === 'currency' && formattedParts[1].type !== 'literal') {
+      // currency in front of a number: EUR 1.00
+      formattedParts.splice(1, 0, literalObject);
+    } else if (
+      formattedParts[0].type === 'minusSign' &&
+      formattedParts[1].type === 'currency' &&
+      formattedParts[2].type !== 'literal'
+    ) {
+      // currency in front of a negative number: -EUR 1.00
+      formattedParts.splice(2, 0, literalObject);
+    } else if (
+      formattedParts[numberOfParts - 1].type === 'currency' &&
+      formattedParts[numberOfParts - 2].type !== 'literal'
+    ) {
+      // currency in behind a number: 1.00 EUR || -1.00 EUR
+      formattedParts.splice(numberOfParts - 1, 0, literalObject);
+    }
+  }
+  return formattedParts;
+}