@formatjs/ecma402-abstract 1.11.9 → 1.11.10

package/CanonicalizeLocaleList.ts

@@ -1,8 +0,0 @@
-/**
- * http://ecma-international.org/ecma-402/7.0/index.html#sec-canonicalizelocalelist
- * @param locales
- */
-export function CanonicalizeLocaleList(locales?: string | string[]): string[] {
-  // TODO
-  return ((Intl as any).getCanonicalLocales as any)(locales)
-}

package/CanonicalizeTimeZoneName.ts

@@ -1,29 +0,0 @@
-/**
- * https://tc39.es/ecma402/#sec-canonicalizetimezonename
- * @param tz
- */
-export function CanonicalizeTimeZoneName(
-  tz: string,
-  {
-    tzData,
-    uppercaseLinks,
-  }: {
-    tzData: Record<string, unknown>
-    uppercaseLinks: Record<string, string>
-  }
-) {
-  const uppercasedTz = tz.toUpperCase()
-  const uppercasedZones = Object.keys(tzData).reduce(
-    (all: Record<string, string>, z) => {
-      all[z.toUpperCase()] = z
-      return all
-    },
-    {}
-  )
-  const ianaTimeZone =
-    uppercaseLinks[uppercasedTz] || uppercasedZones[uppercasedTz]
-  if (ianaTimeZone === 'Etc/UTC' || ianaTimeZone === 'Etc/GMT') {
-    return 'UTC'
-  }
-  return ianaTimeZone
-}

package/CoerceOptionsToObject.ts

@@ -1,13 +0,0 @@
-import {ToObject} from './262'
-
-/**
- * https://tc39.es/ecma402/#sec-coerceoptionstoobject
- * @param options
- * @returns
- */
-export function CoerceOptionsToObject<T>(options?: T): T {
-  if (typeof options === 'undefined') {
-    return Object.create(null)
-  }
-  return ToObject(options)
-}

package/DefaultNumberOption.ts

@@ -1,28 +0,0 @@
-/**
- * https://tc39.es/ecma402/#sec-defaultnumberoption
- * @param val
- * @param min
- * @param max
- * @param fallback
- */
-export function DefaultNumberOption(
-  val: any,
-  min: number,
-  max: number,
-  fallback: number
-): number
-export function DefaultNumberOption(
-  val: any,
-  min: number,
-  max: number,
-  fallback: number | undefined
-): number | undefined {
-  if (val !== undefined) {
-    val = Number(val)
-    if (isNaN(val) || val < min || val > max) {
-      throw new RangeError(`${val} is outside of range [${min}, ${max}]`)
-    }
-    return Math.floor(val)
-  }
-  return fallback
-}

package/GetNumberOption.ts

@@ -1,29 +0,0 @@
-/**
- * https://tc39.es/ecma402/#sec-getnumberoption
- * @param options
- * @param property
- * @param min
- * @param max
- * @param fallback
- */
-
-import {DefaultNumberOption} from './DefaultNumberOption'
-
-export function GetNumberOption<T extends object, K extends keyof T>(
-  options: T,
-  property: K,
-  minimum: number,
-  maximum: number,
-  fallback: number
-): number
-export function GetNumberOption<T extends object, K extends keyof T>(
-  options: T,
-  property: K,
-  minimum: number,
-  maximum: number,
-  fallback: number | undefined
-): number | undefined {
-  const val = options[property]
-  // @ts-expect-error
-  return DefaultNumberOption(val, minimum, maximum, fallback)
-}

package/GetOption.ts

@@ -1,38 +0,0 @@
-import {ToString} from './262'
-
-/**
- * https://tc39.es/ecma402/#sec-getoption
- * @param opts
- * @param prop
- * @param type
- * @param values
- * @param fallback
- */
-export function GetOption<T extends object, K extends keyof T, F>(
-  opts: T,
-  prop: K,
-  type: 'string' | 'boolean',
-  values: T[K][] | undefined,
-  fallback: F
-): Exclude<T[K], undefined> | F {
-  if (typeof opts !== 'object') {
-    throw new TypeError('Options must be an object')
-  }
-  let value: any = opts[prop]
-  if (value !== undefined) {
-    if (type !== 'boolean' && type !== 'string') {
-      throw new TypeError('invalid type')
-    }
-    if (type === 'boolean') {
-      value = Boolean(value)
-    }
-    if (type === 'string') {
-      value = ToString(value)
-    }
-    if (values !== undefined && !values.filter(val => val == value).length) {
-      throw new RangeError(`${value} is not within ${values.join(', ')}`)
-    }
-    return value
-  }
-  return fallback
-}

package/GetOptionsObject.ts

@@ -1,14 +0,0 @@
-/**
- * https://tc39.es/ecma402/#sec-getoptionsobject
- * @param options
- * @returns
- */
-export function GetOptionsObject<T extends object>(options?: T): T {
-  if (typeof options === 'undefined') {
-    return Object.create(null)
-  }
-  if (typeof options === 'object') {
-    return options
-  }
-  throw new TypeError('Options must be an object')
-}

package/IsSanctionedSimpleUnitIdentifier.ts

@@ -1,66 +0,0 @@
-/**
- * https://tc39.es/ecma402/#table-sanctioned-simple-unit-identifiers
- */
-export const SANCTIONED_UNITS = [
-  'angle-degree',
-  'area-acre',
-  'area-hectare',
-  'concentr-percent',
-  'digital-bit',
-  'digital-byte',
-  'digital-gigabit',
-  'digital-gigabyte',
-  'digital-kilobit',
-  'digital-kilobyte',
-  'digital-megabit',
-  'digital-megabyte',
-  'digital-petabyte',
-  'digital-terabit',
-  'digital-terabyte',
-  'duration-day',
-  'duration-hour',
-  'duration-millisecond',
-  'duration-minute',
-  'duration-month',
-  'duration-second',
-  'duration-week',
-  'duration-year',
-  'length-centimeter',
-  'length-foot',
-  'length-inch',
-  'length-kilometer',
-  'length-meter',
-  'length-mile-scandinavian',
-  'length-mile',
-  'length-millimeter',
-  'length-yard',
-  'mass-gram',
-  'mass-kilogram',
-  'mass-ounce',
-  'mass-pound',
-  'mass-stone',
-  'temperature-celsius',
-  'temperature-fahrenheit',
-  'volume-fluid-ounce',
-  'volume-gallon',
-  'volume-liter',
-  'volume-milliliter',
-]
-
-// In CLDR, the unit name always follows the form `namespace-unit` pattern.
-// For example: `digital-bit` instead of `bit`. This function removes the namespace prefix.
-export function removeUnitNamespace(unit: string) {
-  return unit.slice(unit.indexOf('-') + 1)
-}
-
-/**
- * https://tc39.es/ecma402/#table-sanctioned-simple-unit-identifiers
- */
-export const SIMPLE_UNITS = SANCTIONED_UNITS.map(removeUnitNamespace)
-
-/**
- * https://tc39.es/ecma402/#sec-issanctionedsimpleunitidentifier
- */
-export function IsSanctionedSimpleUnitIdentifier(unitIdentifier: string) {
-  return SIMPLE_UNITS.indexOf(unitIdentifier) > -1
-}

package/IsValidTimeZoneName.ts

@@ -1,27 +0,0 @@
-/**
- * https://tc39.es/ecma402/#sec-isvalidtimezonename
- * @param tz
- * @param implDetails implementation details
- */
-export function IsValidTimeZoneName(
-  tz: string,
-  {
-    tzData,
-    uppercaseLinks,
-  }: {
-    tzData: Record<string, unknown>
-    uppercaseLinks: Record<string, string>
-  }
-): boolean {
-  const uppercasedTz = tz.toUpperCase()
-  const zoneNames = new Set()
-  const linkNames = new Set()
-  Object.keys(tzData)
-    .map(z => z.toUpperCase())
-    .forEach(z => zoneNames.add(z))
-  Object.keys(uppercaseLinks).forEach(linkName => {
-    linkNames.add(linkName.toUpperCase())
-    zoneNames.add(uppercaseLinks[linkName].toUpperCase())
-  })
-  return zoneNames.has(uppercasedTz) || linkNames.has(uppercasedTz)
-}

package/IsWellFormedCurrencyCode.ts

@@ -1,23 +0,0 @@
-/**
- * This follows https://tc39.es/ecma402/#sec-case-sensitivity-and-case-mapping
- * @param str string to convert
- */
-function toUpperCase(str: string): string {
-  return str.replace(/([a-z])/g, (_, c) => c.toUpperCase())
-}
-
-const NOT_A_Z_REGEX = /[^A-Z]/
-
-/**
- * https://tc39.es/ecma402/#sec-iswellformedcurrencycode
- */
-export function IsWellFormedCurrencyCode(currency: string): boolean {
-  currency = toUpperCase(currency)
-  if (currency.length !== 3) {
-    return false
-  }
-  if (NOT_A_Z_REGEX.test(currency)) {
-    return false
-  }
-  return true
-}

package/IsWellFormedUnitIdentifier.ts

@@ -1,32 +0,0 @@
-import {IsSanctionedSimpleUnitIdentifier} from './IsSanctionedSimpleUnitIdentifier'
-
-/**
- * This follows https://tc39.es/ecma402/#sec-case-sensitivity-and-case-mapping
- * @param str string to convert
- */
-function toLowerCase(str: string): string {
-  return str.replace(/([A-Z])/g, (_, c) => c.toLowerCase())
-}
-
-/**
- * https://tc39.es/ecma402/#sec-iswellformedunitidentifier
- * @param unit
- */
-export function IsWellFormedUnitIdentifier(unit: string) {
-  unit = toLowerCase(unit)
-  if (IsSanctionedSimpleUnitIdentifier(unit)) {
-    return true
-  }
-  const units = unit.split('-per-')
-  if (units.length !== 2) {
-    return false
-  }
-  const [numerator, denominator] = units
-  if (
-    !IsSanctionedSimpleUnitIdentifier(numerator) ||
-    !IsSanctionedSimpleUnitIdentifier(denominator)
-  ) {
-    return false
-  }
-  return true
-}

package/NumberFormat/ComputeExponent.ts

@@ -1,49 +0,0 @@
-import {getMagnitude} from '../utils'
-import {ComputeExponentForMagnitude} from './ComputeExponentForMagnitude'
-import {FormatNumericToString} from './FormatNumericToString'
-import {NumberFormatInternal} from '../types/number'
-
-/**
- * The abstract operation ComputeExponent computes an exponent (power of ten) by which to scale x
- * according to the number formatting settings. It handles cases such as 999 rounding up to 1000,
- * requiring a different exponent.
- *
- * NOT IN SPEC: it returns [exponent, magnitude].
- */
-export function ComputeExponent(
-  numberFormat: Intl.NumberFormat,
-  x: number,
-  {
-    getInternalSlots,
-  }: {getInternalSlots(nf: Intl.NumberFormat): NumberFormatInternal}
-): [number, number] {
-  if (x === 0) {
-    return [0, 0]
-  }
-  if (x < 0) {
-    x = -x
-  }
-  const magnitude = getMagnitude(x)
-  const exponent = ComputeExponentForMagnitude(numberFormat, magnitude, {
-    getInternalSlots,
-  })
-  // Preserve more precision by doing multiplication when exponent is negative.
-  x = exponent < 0 ? x * 10 ** -exponent : x / 10 ** exponent
-  const formatNumberResult = FormatNumericToString(
-    getInternalSlots(numberFormat),
-    x
-  )
-  if (formatNumberResult.roundedNumber === 0) {
-    return [exponent, magnitude]
-  }
-  const newMagnitude = getMagnitude(formatNumberResult.roundedNumber)
-  if (newMagnitude === magnitude - exponent) {
-    return [exponent, magnitude]
-  }
-  return [
-    ComputeExponentForMagnitude(numberFormat, magnitude + 1, {
-      getInternalSlots,
-    }),
-    magnitude + 1,
-  ]
-}

package/NumberFormat/ComputeExponentForMagnitude.ts

@@ -1,71 +0,0 @@
-import {NumberFormatInternal, DecimalFormatNum} from '../types/number'
-
-/**
- * The abstract operation ComputeExponentForMagnitude computes an exponent by which to scale a
- * number of the given magnitude (power of ten of the most significant digit) according to the
- * locale and the desired notation (scientific, engineering, or compact).
- */
-export function ComputeExponentForMagnitude(
-  numberFormat: Intl.NumberFormat,
-  magnitude: number,
-  {
-    getInternalSlots,
-  }: {getInternalSlots(nf: Intl.NumberFormat): NumberFormatInternal}
-): number {
-  const internalSlots = getInternalSlots(numberFormat)
-  const {notation, dataLocaleData, numberingSystem} = internalSlots
-
-  switch (notation) {
-    case 'standard':
-      return 0
-    case 'scientific':
-      return magnitude
-    case 'engineering':
-      return Math.floor(magnitude / 3) * 3
-    default: {
-      // Let exponent be an implementation- and locale-dependent (ILD) integer by which to scale a
-      // number of the given magnitude in compact notation for the current locale.
-      const {compactDisplay, style, currencyDisplay} = internalSlots
-      let thresholdMap
-      if (style === 'currency' && currencyDisplay !== 'name') {
-        const currency =
-          dataLocaleData.numbers.currency[numberingSystem] ||
-          dataLocaleData.numbers.currency[dataLocaleData.numbers.nu[0]]
-        thresholdMap = currency.short
-      } else {
-        const decimal =
-          dataLocaleData.numbers.decimal[numberingSystem] ||
-          dataLocaleData.numbers.decimal[dataLocaleData.numbers.nu[0]]
-        thresholdMap = compactDisplay === 'long' ? decimal.long : decimal.short
-      }
-      if (!thresholdMap) {
-        return 0
-      }
-      const num = String(10 ** magnitude) as DecimalFormatNum
-      const thresholds = Object.keys(thresholdMap) as DecimalFormatNum[] // TODO: this can be pre-processed
-      if (num < thresholds[0]) {
-        return 0
-      }
-      if (num > thresholds[thresholds.length - 1]) {
-        return thresholds[thresholds.length - 1].length - 1
-      }
-      const i = thresholds.indexOf(num)
-      if (i === -1) {
-        return 0
-      }
-      // See https://unicode.org/reports/tr35/tr35-numbers.html#Compact_Number_Formats
-      // Special handling if the pattern is precisely `0`.
-      const magnitudeKey = thresholds[i]
-      // TODO: do we need to handle plural here?
-      const compactPattern = thresholdMap[magnitudeKey].other
-      if (compactPattern === '0') {
-        return 0
-      }
-      // Example: in zh-TW, `10000000` maps to `0000萬`. So we need to return 8 - 4 = 4 here.
-      return (
-        magnitudeKey.length -
-        thresholdMap[magnitudeKey].other.match(/0+/)![0].length
-      )
-    }
-  }
-}

package/NumberFormat/CurrencyDigits.ts

@@ -1,13 +0,0 @@
-import {HasOwnProperty} from '../262'
-
-/**
- * https://tc39.es/ecma402/#sec-currencydigits
- */
-export function CurrencyDigits(
-  c: string,
-  {currencyDigitsData}: {currencyDigitsData: Record<string, number>}
-): number {
-  return HasOwnProperty(currencyDigitsData, c)
-    ? (currencyDigitsData as Record<string, number>)[c]
-    : 2
-}

package/NumberFormat/FormatNumericToParts.ts

@@ -1,22 +0,0 @@
-import {PartitionNumberPattern} from './PartitionNumberPattern'
-import {ArrayCreate} from '../262'
-import {NumberFormatInternal, NumberFormatPart} from '../types/number'
-
-export function FormatNumericToParts(
-  nf: Intl.NumberFormat,
-  x: number,
-  implDetails: {
-    getInternalSlots(nf: Intl.NumberFormat): NumberFormatInternal
-  }
-): NumberFormatPart[] {
-  const parts = PartitionNumberPattern(nf, x, implDetails)
-  const result = ArrayCreate(0) as NumberFormatPart[]
-
-  for (const part of parts) {
-    result.push({
-      type: part.type,
-      value: part.value,
-    })
-  }
-  return result
-}

package/NumberFormat/FormatNumericToString.ts

@@ -1,71 +0,0 @@
-import {SameValue} from '../262'
-import {ToRawPrecision} from './ToRawPrecision'
-import {repeat} from '../utils'
-import {
-  NumberFormatDigitInternalSlots,
-  RawNumberFormatResult,
-} from '../types/number'
-import {ToRawFixed} from './ToRawFixed'
-
-/**
- * https://tc39.es/ecma402/#sec-formatnumberstring
- */
-export function FormatNumericToString(
-  intlObject: Pick<
-    NumberFormatDigitInternalSlots,
-    | 'roundingType'
-    | 'minimumSignificantDigits'
-    | 'maximumSignificantDigits'
-    | 'minimumIntegerDigits'
-    | 'minimumFractionDigits'
-    | 'maximumFractionDigits'
-  >,
-  x: number
-) {
-  const isNegative = x < 0 || SameValue(x, -0)
-  if (isNegative) {
-    x = -x
-  }
-
-  let result: RawNumberFormatResult
-
-  const rourndingType = intlObject.roundingType
-
-  switch (rourndingType) {
-    case 'significantDigits':
-      result = ToRawPrecision(
-        x,
-        intlObject.minimumSignificantDigits!,
-        intlObject.maximumSignificantDigits!
-      )
-      break
-    case 'fractionDigits':
-      result = ToRawFixed(
-        x,
-        intlObject.minimumFractionDigits!,
-        intlObject.maximumFractionDigits!
-      )
-      break
-    default:
-      result = ToRawPrecision(x, 1, 2)
-      if (result.integerDigitsCount > 1) {
-        result = ToRawFixed(x, 0, 0)
-      }
-      break
-  }
-
-  x = result.roundedNumber
-  let string = result.formattedString
-  const int = result.integerDigitsCount
-  const minInteger = intlObject.minimumIntegerDigits
-
-  if (int < minInteger) {
-    const forwardZeros = repeat('0', minInteger - int)
-    string = forwardZeros + string
-  }
-
-  if (isNegative) {
-    x = -x
-  }
-  return {roundedNumber: x, formattedString: string}
-}