numerica/packages/core/src/locales/de-DE/index.ts

import BigNumber from 'bignumber.js';
import {
  BLANK_DIGIT,
  createBlankDigits,
  deconstructNumeric,
  groupDigits,
  NEGATIVE_SIGN,
  normalizeNumeric,
  Numeric,
} from '../../utils/numeric';
import getLatinPowerName from '../../utils/common/latinPowers';

const config = {
  "onesNames": ['zero', 'ein', 'zwei', 'drei', 'vier', 'fünf', 'sechs', 'sieben', 'acht', 'neun'],
  "teensNames": ['zehn', 'elf', 'zwölf', 'dreizehn', 'vierzehn', 'fünfzehn', 'sechzehn', 'siebzehn', 'achtzehn', 'neunzehn'],
  "tensNames": ['zero', 'zehn', 'zwanzig', 'dreißig', 'vierzig', 'fünfzig', 'sechzig', 'siebzig', 'achtzig', 'neunzig'],
  "hundredName": "hundert",
  "thousandName": "tausend",
  "millia": "millia",
  "illion": "illion",
  "illiard": "illiarde",
  "and": "und",
  "hundredsLatinNames": ["", "cen", "duocen", "trecen", "quadringen", "quingen", "sescen", "septingen", "octingen", "nongen"],
  "onesLatinNames": ["", "un", "duo", "tre", "quattuor", "quin", "sex", "septen", "octo", "novem"],
  "tensLatinNames": ["", "dec", "vigin", "trigin", "quadragin", "quinquagin", "sexagin", "septuagin", "octogin", "nonagin"],
  "onesSpecialLatinNames": ["", "m", "b", "tr", "quadr", "quin", "sex", "sep", "oct", "non"],
  "negative": "negative",
  "grouping": 3,
  "latinGrouping": 3
}

const getGroupIndexName = (index: BigNumber, digits: string) => {
  if (index.eq(1)) {
    return config.thousandName
  }

  const basicIndex = index.dividedToIntegerBy(2)
  const isOdd = index.mod(2).eq(1)
  const latinPowerName = getLatinPowerName(basicIndex, isOdd, config)
  const latinPowerNameWithCase = latinPowerName.slice(0, 1).toUpperCase() + latinPowerName.slice(1)
  if (digits.padStart(config.grouping, BLANK_DIGIT) === '001') {
    return latinPowerNameWithCase
  }
  if (latinPowerNameWithCase.endsWith('e')) {
    return latinPowerNameWithCase + 'n'
  }
  return latinPowerNameWithCase + 'en'
}

const getGroupDigitsName = (digitsRaw: string, index: BigNumber) => {
  const { grouping, onesNames, teensNames, tensNames, hundredName } = config
  const digits = digitsRaw.padStart(grouping, BLANK_DIGIT)
  const [hundreds, tens, ones] = digits.split('').map(s => Number(s))
  const names = []
  if (hundreds !== 0) {
    names.push(onesNames[hundreds])
    names.push(hundredName)
  }
  if (tens === 1) {
    names.push(teensNames[ones])
  } else if (tens > 1) {
    if (ones > 0) {
      names.push(onesNames[ones])
      names.push(config.and)
    }
    names.push(tensNames[tens])
  } else {
    if (hundreds === 0 && ones === 1 && index.gte(2)) {
      names.push(onesNames[ones] + 'e')
    } else if (hundreds !== 0 && ones > 0 || hundreds === 0) {
      names.push(onesNames[ones])
    }
  }
  return names.join('')
}

const getGroupName = (g: [string, BigNumber]) => {
  const [digits, index] = g
  if (index.lt(1)) {
    return getGroupDigitsName(digits, index)
  }
  if (index.lt(2)) {
    return [getGroupDigitsName(digits, index), getGroupIndexName(index, digits)].join('')
  }
  return [getGroupDigitsName(digits, index), getGroupIndexName(index, digits)].join(' ')
}

type Options = {
  groupSeparator: string
}

const getLocalizedNumberName = (xRaw: Numeric, options = {} as Partial<Options>) => {
  const {
    groupSeparator = ' '
  } = options

  const x = normalizeNumeric(xRaw)
  const { significandDigits, exponent } = deconstructNumeric(x)
  const blankDigits = createBlankDigits(config.grouping)
  const groups = groupDigits(significandDigits, exponent, config.grouping)

  if (groups.length === 1) {
    return getGroupName(groups[0])
  }

  const base = groups.filter(([digits]) => digits !== blankDigits).map(g => getGroupName(g)).join(groupSeparator)

  if (x.startsWith(NEGATIVE_SIGN)) {
    return [config.negative, base].join(' ')
  }

  return base
}

export default getLocalizedNumberName