@formatjs/ecma402-abstract 1.11.8 → 1.11.9

package/CanonicalizeLocaleList.ts

@@ -0,0 +1,8 @@
+/**
+ * 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

@@ -0,0 +1,29 @@
+/**
+ * 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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,28 @@
+/**
+ * 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

@@ -0,0 +1,29 @@
+/**
+ * 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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,14 @@
+/**
+ * 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

@@ -0,0 +1,66 @@
+/**
+ * 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

@@ -0,0 +1,27 @@
+/**
+ * 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

@@ -0,0 +1,23 @@
+/**
+ * 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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,71 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,71 @@
+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}
+}