@ledgerhq/coin-module-framework 1.0.5 → 2.0.0

package/src/currencies/BigNumberToLocaleString.ts

@@ -0,0 +1,70 @@
+// Forked from @ledgerhq/live-currency-format/src/BigNumberToLocaleString.ts
+import { BigNumber } from 'bignumber.js'
+import { getSeparators } from './localeUtility'
+
+export type SupportedOptions = {
+  minimumFractionDigits: number
+  maximumFractionDigits: number
+  useGrouping: boolean
+}
+
+const getFormatForLocale = (locale: string) => {
+  const { decimal, thousands } = getSeparators(locale)
+  const opts = {
+    decimalSeparator: '.',
+    groupSeparator: ',',
+    groupSize: 3,
+    secondaryGroupSize: 0,
+    fractionGroupSeparator: '\xA0', // non-breaking space
+    fractionGroupSize: 0,
+  }
+  if (typeof decimal === 'string') opts.decimalSeparator = decimal
+  if (typeof thousands === 'string') opts.groupSeparator = thousands
+  return opts
+}
+
+export const toLocaleString = (
+  n: BigNumber,
+  localeInput?: string,
+  options: Partial<SupportedOptions> = {}
+): string => {
+  let locale = localeInput
+  if (!locale) locale = 'en'
+  const minimumFractionDigits =
+    typeof options.minimumFractionDigits === 'number' ? options.minimumFractionDigits : 0
+  const maximumFractionDigits =
+    typeof options.maximumFractionDigits === 'number'
+      ? options.maximumFractionDigits
+      : Math.max(minimumFractionDigits, 3)
+  const useGrouping = 'useGrouping' in options ? options.useGrouping : true
+  const format = getFormatForLocale(locale)
+
+  if (!useGrouping) {
+    format.groupSeparator = ''
+  }
+
+  const BN = BigNumber.clone({
+    FORMAT: format,
+  })
+  const bn = new BN(n)
+  const maxDecimals = bn.toFormat(maximumFractionDigits, BigNumber.ROUND_FLOOR)
+
+  if (maximumFractionDigits !== minimumFractionDigits) {
+    const minDecimals = bn.toFormat(minimumFractionDigits, BigNumber.ROUND_FLOOR)
+    let i = maxDecimals.length
+
+    while (i > minDecimals.length) {
+      if (maxDecimals[i - 1] !== '0') {
+        if (maxDecimals[i - 1] === format.decimalSeparator) {
+          i--
+        }
+        break
+      }
+      i--
+    }
+
+    return maxDecimals.slice(0, i)
+  }
+
+  return maxDecimals
+}

package/src/currencies/formatCurrencyUnit.test.ts

@@ -0,0 +1,215 @@
+// Forked from @ledgerhq/live-currency-format/src/formatCurrencyUnit.test.ts
+// Snapshot tests using @ledgerhq/cryptoassets removed (not available in this repo)
+import { formatCurrencyUnit, formatCurrencyUnitFragment } from './formatCurrencyUnit'
+import { BigNumber } from 'bignumber.js'
+import type { Unit } from '../api/types'
+
+describe('formatCurrencyUnit', () => {
+  describe('error handling', () => {
+    const unit: Unit = {
+      name: 'Test',
+      code: 'TST',
+      magnitude: 2,
+      showAllDigits: false,
+      prefixCode: false,
+    }
+
+    test('handles non-BigNumber', () => {
+      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation()
+      expect(formatCurrencyUnit(unit, null as unknown as BigNumber)).toBe('')
+      consoleSpy.mockRestore()
+    })
+
+    test('handles NaN', () => {
+      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation()
+      expect(formatCurrencyUnit(unit, new BigNumber(NaN))).toBe('')
+      consoleSpy.mockRestore()
+    })
+
+    test('handles Infinity', () => {
+      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation()
+      expect(formatCurrencyUnit(unit, new BigNumber(Infinity))).toBe('')
+      consoleSpy.mockRestore()
+    })
+  })
+
+  describe('formatCurrencyUnit options', () => {
+    const unit: Unit = {
+      name: 'Test',
+      code: 'USD',
+      magnitude: 2,
+      showAllDigits: false,
+      prefixCode: false,
+    }
+
+    test('prefixCode true', () => {
+      const prefixUnit: Unit = { ...unit, prefixCode: true }
+      expect(formatCurrencyUnit(prefixUnit, new BigNumber('12345'), { showCode: true })).toBe(
+        'USD123.45'
+      )
+    })
+
+    test('prefixCode false', () => {
+      expect(formatCurrencyUnit(unit, new BigNumber('12345'), { showCode: true })).toBe(
+        '123.45\u00A0USD'
+      )
+    })
+
+    test('negative with prefixCode', () => {
+      const prefixUnit: Unit = { ...unit, prefixCode: true }
+      expect(formatCurrencyUnit(prefixUnit, new BigNumber('-12345'), { showCode: true })).toBe(
+        '-USD123.45'
+      )
+    })
+
+    test('negative with suffixCode', () => {
+      expect(formatCurrencyUnit(unit, new BigNumber('-12345'), { showCode: true })).toBe(
+        '-123.45\u00A0USD'
+      )
+    })
+
+    test('alwaysShowSign', () => {
+      expect(formatCurrencyUnit(unit, new BigNumber('12345'), { alwaysShowSign: true })).toBe(
+        '+123.45'
+      )
+    })
+
+    test('discreet mode', () => {
+      expect(formatCurrencyUnit(unit, new BigNumber('12345'), { discreet: true })).toBe('***')
+    })
+
+    test('joinFragmentsSeparator', () => {
+      const prefixUnit: Unit = { ...unit, prefixCode: true }
+      expect(
+        formatCurrencyUnit(prefixUnit, new BigNumber('12345'), {
+          showCode: true,
+          joinFragmentsSeparator: '-',
+        })
+      ).toBe('USD-123.45')
+    })
+
+    test('useGrouping false', () => {
+      expect(
+        formatCurrencyUnit(unit, new BigNumber('12345678'), { useGrouping: false })
+      ).not.toContain(',')
+    })
+
+    test('showAllDigits', () => {
+      const highMagUnit: Unit = { ...unit, magnitude: 4 }
+      expect(formatCurrencyUnit(highMagUnit, new BigNumber('12345'), { showAllDigits: true })).toBe(
+        '1.2345'
+      )
+    })
+
+    test('filters undefined options', () => {
+      expect(
+        formatCurrencyUnit(unit, new BigNumber('12345'), { showCode: undefined, locale: 'en-US' })
+      ).toBe('123.45')
+    })
+  })
+
+  describe('formatCurrencyUnitFragment', () => {
+    const unit: Unit = {
+      name: 'Test',
+      code: 'USD',
+      magnitude: 2,
+      showAllDigits: false,
+      prefixCode: false,
+    }
+
+    test('basic structure', () => {
+      const result = formatCurrencyUnitFragment(unit, new BigNumber('12345'))
+      expect(result.integerPart).toBe('123')
+      expect(result.decimalPart).toBe('45')
+      expect(result.decimalSeparator).toBe('.')
+      expect(result.currencyText).toBe('')
+      expect(result.currencyPosition).toBe('end')
+    })
+
+    test('negative with prefixCode false', () => {
+      const result = formatCurrencyUnitFragment(unit, new BigNumber('-12345'), { showCode: true })
+      expect(result.integerPart).toBe('-123')
+      expect(result.currencyText).toBe('USD')
+    })
+
+    test('negative with prefixCode true', () => {
+      const prefixUnit: Unit = { ...unit, prefixCode: true }
+      const result = formatCurrencyUnitFragment(prefixUnit, new BigNumber('-12345'), {
+        showCode: true,
+      })
+      expect(result.integerPart).toBe('123')
+      expect(result.currencyText).toBe('-USD')
+    })
+
+    test('negative with prefixCode true but no code', () => {
+      const prefixUnit: Unit = { ...unit, prefixCode: true }
+      const result = formatCurrencyUnitFragment(prefixUnit, new BigNumber('-12345'), {
+        showCode: false,
+      })
+      expect(result.integerPart).toBe('-123')
+      expect(result.currencyText).toBe('')
+    })
+
+    test('alwaysShowSign', () => {
+      const result = formatCurrencyUnitFragment(unit, new BigNumber('12345'), {
+        alwaysShowSign: true,
+      })
+      expect(result.integerPart).toBe('+123')
+    })
+
+    test('no decimals', () => {
+      const result = formatCurrencyUnitFragment(unit, new BigNumber('10000'))
+      expect(result.integerPart).toBe('100')
+      expect(result.decimalPart).toBe('')
+    })
+
+    test('french locale', () => {
+      const result = formatCurrencyUnitFragment(unit, new BigNumber('12345'), { locale: 'fr-FR' })
+      expect(result.decimalSeparator).toBe(',')
+    })
+
+    test('error handling', () => {
+      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation()
+      const result = formatCurrencyUnitFragment(unit, null as unknown as BigNumber)
+      expect(result.integerPart).toBe('')
+      expect(result.decimalPart).toBe('')
+      consoleSpy.mockRestore()
+    })
+
+    test('error handling with prefixCode true', () => {
+      const prefixUnit: Unit = { ...unit, prefixCode: true }
+      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation()
+      const result = formatCurrencyUnitFragment(prefixUnit, new BigNumber(NaN))
+      expect(result.currencyPosition).toBe('start')
+      consoleSpy.mockRestore()
+    })
+  })
+
+  describe('coverage edge cases', () => {
+    test('disableRounding with subMagnitude', () => {
+      const unit: Unit = {
+        name: 'Test',
+        code: 'TST',
+        magnitude: 2,
+        showAllDigits: false,
+        prefixCode: false,
+      }
+      const value = new BigNumber('12345')
+      const result = formatCurrencyUnit(unit, value, { disableRounding: true, subMagnitude: 1 })
+      expect(result).toContain('123.45')
+    })
+
+    test('prefixCode true without code', () => {
+      const unit: Unit = {
+        name: 'Test',
+        code: 'USD',
+        magnitude: 2,
+        showAllDigits: false,
+        prefixCode: true,
+      }
+      const value = new BigNumber('12345')
+      const result = formatCurrencyUnit(unit, value, { showCode: false })
+      expect(result).toBe('123.45')
+    })
+  })
+})

package/src/currencies/formatCurrencyUnit.ts

@@ -1,6 +1,200 @@
-export {
-  formatCurrencyUnit,
-  formatCurrencyUnitFragment,
-  type formatCurrencyUnitOptions,
-  type FormatterValue,
-} from '@ledgerhq/live-currency-format'
+// Forked from @ledgerhq/live-currency-format/src/formatCurrencyUnit.ts
+import { BigNumber } from 'bignumber.js'
+import { getSeparators } from './localeUtility'
+import { toLocaleString } from './BigNumberToLocaleString'
+import type { Unit } from '../api/types'
+
+const nonBreakableSpace = '\u00A0'
+const defaultFormatOptions = {
+  locale: 'en-EN',
+  showCode: false,
+  alwaysShowSign: false,
+  showAllDigits: false,
+  disableRounding: false,
+  useGrouping: true,
+  subMagnitude: 0,
+  discreet: false,
+  joinFragmentsSeparator: '',
+  dynamicSignificantDigits: 6,
+  staticSignificantDigits: 8,
+}
+
+export type formatCurrencyUnitOptions = Partial<typeof defaultFormatOptions>
+
+export type FormatterValue = {
+  integerPart: string
+  decimalPart: string
+  decimalSeparator: '.' | ','
+  currencyText: string
+  currencyPosition: 'start' | 'end'
+}
+
+type FormatState = {
+  value: string
+  sign: string | null
+  code: string | null
+  decimalSeparator: '.' | ','
+  currencyPosition: 'start' | 'end'
+}
+
+type ResolvedFormatOptions = typeof defaultFormatOptions & Unit
+
+const buildFormatState = (
+  unit: Unit,
+  value: BigNumber,
+  _options?: formatCurrencyUnitOptions
+): FormatState => {
+  const emptyState = (): FormatState => ({
+    value: '',
+    sign: null,
+    code: null,
+    decimalSeparator: '.',
+    currencyPosition: unit.prefixCode ? 'start' : 'end',
+  })
+
+  if (!BigNumber.isBigNumber(value)) {
+    console.warn('formatCurrencyUnit called with value=', value)
+    return emptyState()
+  }
+
+  if (value.isNaN()) {
+    console.warn('formatCurrencyUnit called with NaN value!')
+    return emptyState()
+  }
+
+  if (!value.isFinite()) {
+    console.warn('formatCurrencyUnit called with infinite value=', value)
+    return emptyState()
+  }
+
+  const options: Record<string, unknown> = {}
+
+  if (_options) {
+    let k: keyof formatCurrencyUnitOptions
+    for (k in _options) {
+      const optionValue = _options[k]
+      if (optionValue !== undefined) {
+        options[k] = optionValue
+      }
+    }
+  }
+
+  const resolvedOptions: ResolvedFormatOptions = {
+    ...defaultFormatOptions,
+    ...unit,
+    ...options,
+  }
+  const {
+    showCode,
+    alwaysShowSign,
+    showAllDigits,
+    locale,
+    disableRounding,
+    useGrouping,
+    subMagnitude,
+    discreet,
+    dynamicSignificantDigits,
+    staticSignificantDigits,
+  } = resolvedOptions
+  const { magnitude, code } = unit
+  const floatValue = value.div(new BigNumber(10).pow(magnitude))
+  const floatValueAbs = floatValue.abs()
+  const minimumFractionDigits = showAllDigits ? magnitude : 0
+  const maximumFractionDigits = disableRounding
+    ? magnitude + subMagnitude
+    : Math.max(
+        minimumFractionDigits,
+        Math.max(
+          0,
+          Math.min(
+            dynamicSignificantDigits - Math.ceil(Math.log(floatValueAbs.toNumber()) / Math.log(10)),
+            magnitude + subMagnitude,
+            staticSignificantDigits
+          )
+        )
+      )
+  const sign =
+    alwaysShowSign || floatValue.isNegative() ? (floatValue.isNegative() ? '-' : '+') : null
+  const formattedValue = discreet
+    ? '***'
+    : toLocaleString(floatValueAbs, locale, {
+        maximumFractionDigits,
+        minimumFractionDigits,
+        useGrouping,
+      })
+
+  const separators = getSeparators(locale)
+  const decimalSeparator = separators.decimal === ',' ? ',' : '.'
+  const currencyPosition = unit.prefixCode ? 'start' : 'end'
+  return {
+    value: formattedValue,
+    sign,
+    code: showCode ? code : null,
+    decimalSeparator,
+    currencyPosition,
+  }
+}
+
+export const formatCurrencyUnitFragment = (
+  unit: Unit,
+  value: BigNumber,
+  options?: formatCurrencyUnitOptions
+): FormatterValue => {
+  const {
+    value: formattedValue,
+    sign,
+    code,
+    decimalSeparator,
+    currencyPosition,
+  } = buildFormatState(unit, value, options)
+  const hasDecimals = formattedValue.indexOf(decimalSeparator) !== -1
+  const [integerPartRaw, decimalPartRaw] = hasDecimals
+    ? formattedValue.split(decimalSeparator)
+    : [formattedValue, '']
+
+  let integerPart = integerPartRaw
+  const decimalPart = decimalPartRaw || ''
+  let currencyText = code || ''
+
+  if (sign) {
+    if (currencyPosition === 'start' && currencyText) {
+      currencyText = `${sign}${currencyText}`
+    } else {
+      integerPart = `${sign}${integerPart}`
+    }
+  }
+
+  return {
+    integerPart,
+    decimalPart,
+    decimalSeparator,
+    currencyText,
+    currencyPosition,
+  }
+}
+
+export const formatCurrencyUnit = (
+  unit: Unit,
+  value: BigNumber,
+  options?: formatCurrencyUnitOptions
+): string => {
+  const joinFragmentsSeparator =
+    (options && options.joinFragmentsSeparator) || defaultFormatOptions.joinFragmentsSeparator
+  const { value: formattedValue, sign, code } = buildFormatState(unit, value, options)
+  const parts: string[] = []
+
+  if (unit.prefixCode) {
+    if (sign) parts.push(sign)
+    if (code) parts.push(code)
+    parts.push(formattedValue)
+  } else {
+    if (sign) parts.push(sign)
+    parts.push(formattedValue)
+    if (code) {
+      parts.push(nonBreakableSpace)
+      parts.push(code)
+    }
+  }
+
+  return parts.join(joinFragmentsSeparator)
+}

package/src/currencies/localeUtility.test.ts

@@ -0,0 +1,22 @@
+// Forked from @ledgerhq/live-currency-format/src/localeUtility.test.ts
+import { getSeparators } from './localeUtility'
+
+describe('localeUtility', () => {
+  test('getSeparators with known locale in staticFallback', () => {
+    const result = getSeparators('en')
+    expect(result.decimal).toBe('.')
+    expect(result.thousands).toBe(',')
+  })
+
+  test('getSeparators with locale not in staticFallback', () => {
+    const result = getSeparators('it')
+    expect(result.decimal).toBeDefined()
+    expect(result.thousands).toBeDefined()
+  })
+
+  test('getFallback uses en when locale not in staticFallback', () => {
+    const result = getSeparators('de')
+    expect(result.decimal).toBeDefined()
+    expect(result.thousands).toBeDefined()
+  })
+})

package/src/currencies/localeUtility.ts

@@ -0,0 +1,59 @@
+// Forked from @ledgerhq/live-currency-format/src/localeUtility.ts
+const memoize = <T extends (arg: string) => ReturnType<T>>(fn: T): T => {
+  const cache: Record<string, ReturnType<T>> = {}
+  return ((arg: string) => {
+    if (!(arg in cache)) {
+      cache[arg] = fn(arg)
+    }
+    return cache[arg]
+  }) as T
+}
+
+const options = {
+  style: 'currency' as const,
+  currency: 'USD',
+}
+const localeNotAvailable = (1.2).toLocaleString('en', options) !== '$1.20'
+
+const getFallback = (locale: string) =>
+  staticFallback[Object.prototype.hasOwnProperty.call(staticFallback, locale) ? locale : 'en']
+
+const staticFallback: Record<string, string[]> = {
+  en: ['-$1.00', '10,000.2'],
+  es: ['-1,00 US$', '10.000,2'],
+  fr: ['-1,00 $US', '10 000,2'],
+  ja: ['-US$1.00', '10,000.2'],
+  ko: ['-US$1.00', '10,000.2'],
+  ru: ['-1,00 $', '10 000,2'],
+  zh: ['-US$1.00', '10,000.2'],
+}
+
+export const prefixFormat = ['sign', 'code', 'value'] as const
+export const suffixFormat = ['sign', 'value', 'separator', 'code'] as const
+
+export type GetSeparators = (locale: string) => {
+  decimal: string | null | undefined
+  thousands: string | null | undefined
+}
+
+export const getSeparators: GetSeparators = memoize((locale) => {
+  const res = localeNotAvailable ? getFallback(locale)[1] : (10000.2).toLocaleString(locale)
+  let decimal
+  let thousands
+
+  for (let i = 0; i < res.length; i++) {
+    const c = res[i]
+    if (/[0-9]/.test(c)) continue
+
+    if (!thousands) {
+      thousands = c
+    } else {
+      decimal = c
+    }
+  }
+
+  return {
+    decimal,
+    thousands,
+  }
+})

package/src/currencies/parseCurrencyUnit.test.ts

@@ -0,0 +1,26 @@
+// Forked from @ledgerhq/live-currency-format/src/parseCurrencyUnit.test.ts
+import { BigNumber } from 'bignumber.js'
+import type { Unit } from '../api/types'
+import { parseCurrencyUnit } from './parseCurrencyUnit'
+
+const unit: Unit = {
+  name: 'Test Unit',
+  code: 'TST',
+  magnitude: 2,
+  showAllDigits: false,
+  prefixCode: false,
+}
+
+describe('parseCurrencyUnit', () => {
+  test('parses dot decimals', () => {
+    expect(parseCurrencyUnit(unit, '1.23')).toEqual(new BigNumber(123))
+  })
+
+  test('parses comma decimals', () => {
+    expect(parseCurrencyUnit(unit, '1,23')).toEqual(new BigNumber(123))
+  })
+
+  test('returns zero on invalid input', () => {
+    expect(parseCurrencyUnit(unit, 'invalid')).toEqual(new BigNumber(0))
+  })
+})

package/src/currencies/parseCurrencyUnit.ts

@@ -1 +1,10 @@
-export { parseCurrencyUnit } from '@ledgerhq/live-currency-format'
+// Forked from @ledgerhq/live-currency-format/src/parseCurrencyUnit.ts
+import type { Unit } from '../api/types'
+import { BigNumber } from 'bignumber.js'
+
+export const parseCurrencyUnit = (unit: Unit, valueString: string): BigNumber => {
+  const str = valueString.replace(/,/g, '.')
+  const value = new BigNumber(str)
+  if (value.isNaN()) return new BigNumber(0)
+  return value.times(new BigNumber(10).pow(unit.magnitude)).integerValue()
+}