@dnb/eufemia/components/number-format/utils/formatNumberCore.js

DNB Eufemia Design System UI Library

import { LOCALE } from "../../../shared/defaults.js";
import { warn, escapeRegexChars } from "../../../shared/component-helper.js";
import { IS_MAC } from "../../../shared/helpers.js";
import { ABSENT_VALUE_FORMAT, NUMBER_MINUS } from "./constants.js";
import { getFallbackCurrencyDisplay } from "./currencyDisplay.js";
function toIntlOptions({
  decimals: _decimals,
  ...rest
}) {
  return rest;
}
function getFormatParts({
  number,
  locale = null,
  options = null
}) {
  if (typeof Intl !== 'undefined' && typeof Intl.NumberFormat === 'function') {
    const inst = new Intl.NumberFormat(locale || LOCALE, toIntlOptions(options || {}));
    if (typeof inst.formatToParts === 'function') {
      return inst.formatToParts(Number(number));
    }
    return [{
      value: inst.format(Number(number)),
      type: 'unknown'
    }];
  }
  return [{
    value: String(number),
    type: 'unknown'
  }];
}
export function formatToParts(args) {
  try {
    return getFormatParts(args);
  } catch (e) {
    warn('NumberFormat: Failed to format number with Intl.NumberFormat:', e);
  }
  return [{
    value: String(args.number),
    type: 'unknown'
  }];
}
function joinParts(parts) {
  return parts.reduce((acc, {
    value
  }) => acc + value, '');
}
function alignParts(parts, currencyDisplay) {
  return parts.map(item => {
    if (item.type === 'currency') {
      return {
        ...item,
        value: alignCurrencySymbol(item.value, currencyDisplay)
      };
    }
    return item;
  });
}
export function alignCurrencySymbol(output, currencyDisplay) {
  if (typeof output === 'string' && currencyDisplay === 'name') {
    output = output.replace(/(nor[^\s]+?)\s(\w+)/i, '$2');
  }
  return String(output);
}
export const prepareMinus = (display, locale) => {
  if (!(locale && /(no|nb|nn)$/i.test(locale))) {
    return display;
  }
  const first = display.charAt(0);
  const second = display.charAt(1);
  if (first === '-' && second === '-') {
    return display;
  }
  const reg = `^(${NUMBER_MINUS})`;
  if (new RegExp(reg).test(first)) {
    if (parseFloat(second) > 0) {
      display = display.replace(new RegExp(reg + '(.*)'), '-$2');
    } else {
      display = display.replace(new RegExp(reg + '([^0-9]+)(.*)'), '$2-$3');
    }
  }
  return display;
};
export function prepareMinusParts(display, parts, locale) {
  const number = prepareMinus(display, locale);
  if (!parts || number === display) {
    return {
      number,
      parts: parts !== null && parts !== void 0 ? parts : []
    };
  }
  const nextParts = parts.map(part => {
    if (part.type === 'minusSign' && display.startsWith(part.value) && number.startsWith('-')) {
      return {
        ...part,
        value: '-'
      };
    }
    return part;
  });
  if (joinParts(nextParts) === number) {
    return {
      number,
      parts: nextParts
    };
  }
  return {
    number,
    parts: []
  };
}
export const enhanceSR = (value, aria, locale) => {
  if (IS_MAC && Math.abs(parseFloat(String(value))) <= 99999) {
    aria = String(aria).replace(/\s([0-9])/g, '$1');
  }
  aria = prepareMinus(aria, locale);
  return aria;
};
function replaceNaNWithDash(number) {
  const string = String(number);
  const replaced = string.replace(/NaN/, ABSENT_VALUE_FORMAT);
  if (!/NaN/.test(string)) {
    return replaced;
  }
  const escapedDash = escapeRegexChars(ABSENT_VALUE_FORMAT);
  return replaced.replace(new RegExp(`([^\\s])${escapedDash}`, 'g'), `$1 ${ABSENT_VALUE_FORMAT}`);
}
export const formatNumberCore = (number, locale, options = {}, formatter = null) => {
  return formatNumberCoreParts(number, locale, options, formatter).number;
};
export const formatNumberCoreParts = (number, locale, options = {}, formatter = null) => {
  let parts = [];
  try {
    if (options.currencyDisplay) {
      options.currencyDisplay = getFallbackCurrencyDisplay(locale, options.currencyDisplay);
    }
    delete options.decimals;
    parts = getFormatParts({
      number: formatter ? Number(number) : parseFloat(String(number)),
      locale,
      options
    }).map(item => formatter ? formatter(item) : item);
    parts = alignParts(parts, options.currencyDisplay);
    number = joinParts(parts);
    if (new RegExp(`^(${NUMBER_MINUS})(0|0[^\\d]|0\\s.*)$`).test(String(number))) {
      number = String(number).replace(new RegExp(`(${NUMBER_MINUS})0`), '0');
    }
  } catch (e) {
    warn(`Number could not be formatted: ${JSON.stringify([number, locale, options])}`, e);
  }
  number = replaceNaNWithDash(alignCurrencySymbol(number, options.currencyDisplay));
  if (joinParts(parts) !== String(number)) {
    parts = [];
  }
  return {
    number: String(number),
    parts
  };
};
//# sourceMappingURL=formatNumberCore.js.map