@formatjs/ecma402-abstract 1.11.9 → 1.11.10

package/types/number.ts

@@ -1,240 +0,0 @@
-import {LDMLPluralRule} from './plural-rules'
-import {LocaleData} from './core'
-
-export type NumberFormatNotation =
-  | 'standard'
-  | 'scientific'
-  | 'engineering'
-  | 'compact'
-
-export type NumberFormatRoundingType =
-  | 'significantDigits'
-  | 'fractionDigits'
-  | 'compactRounding'
-
-export interface NumberFormatDigitOptions {
-  minimumIntegerDigits?: number
-  minimumSignificantDigits?: number
-  maximumSignificantDigits?: number
-  minimumFractionDigits?: number
-  maximumFractionDigits?: number
-}
-
-export interface NumberFormatDigitInternalSlots {
-  minimumIntegerDigits: number
-  minimumSignificantDigits?: number
-  maximumSignificantDigits?: number
-  roundingType: NumberFormatRoundingType
-  // These two properties are only used when `roundingType` is "fractionDigits".
-  minimumFractionDigits?: number
-  maximumFractionDigits?: number
-  notation?: NumberFormatNotation
-}
-
-// All fields are optional due to de-duping
-export type RawNumberLocaleData = LocaleData<NumberFormatLocaleInternalData>
-
-export interface NumberFormatLocaleInternalData {
-  units: UnitDataTable
-  currencies: Record<string, CurrencyData>
-  numbers: RawNumberData
-  // Bc of relevantExtensionKeys in the spec
-  nu: string[]
-}
-
-export interface UnitDataTable {
-  simple: Record<string, UnitData>
-  compound: Record<string, CompoundUnitData>
-}
-
-export interface UnitData {
-  // A pattern where {0} is number placeholder. Example: "摂氏 {0} 度".
-  long: LDMLPluralRuleMap<string>
-  short: LDMLPluralRuleMap<string>
-  narrow: LDMLPluralRuleMap<string>
-  // perUnitPattern. See http://unicode.org/reports/tr35/tr35-general.html#perUnitPatterns
-  perUnit: Record<'narrow' | 'short' | 'long', string | undefined>
-}
-
-// The values are patterns on how to compose simple units.
-// For example, "{0} per {1}".
-export interface CompoundUnitData {
-  long: string
-  short: string
-  narrow: string
-}
-
-export interface CurrencyData {
-  displayName: LDMLPluralRuleMap<string>
-  symbol: string
-  narrow: string
-}
-
-export type DecimalFormatNum =
-  | '1000'
-  | '10000'
-  | '100000'
-  | '1000000'
-  | '10000000'
-  | '100000000'
-  | '1000000000'
-  | '10000000000'
-  | '100000000000'
-  | '1000000000000'
-  | '10000000000000'
-  | '100000000000000'
-export type NumberingSystem = string
-
-/**
- * We only care about insertBetween bc we assume
- * `currencyMatch` & `surroundingMatch` are all the same
- *
- * @export
- * @interface CurrencySpacingData
- */
-export interface CurrencySpacingData {
-  beforeInsertBetween: string
-  afterInsertBetween: string
-}
-
-export interface RawCurrencyData {
-  currencySpacing: CurrencySpacingData
-  standard: string
-  accounting: string
-  short?: Record<DecimalFormatNum, LDMLPluralRuleMap<string>>
-  // IMPORTANT: We're making the assumption here that currency unitPattern
-  // are the same for all LDMLPluralRule
-  unitPattern: string
-}
-
-export interface SymbolsData {
-  decimal: string
-  group: string
-  list: string
-  percentSign: string
-  plusSign: string
-  minusSign: string
-  exponential: string
-  superscriptingExponent: string
-  perMille: string
-  infinity: string
-  nan: string
-  timeSeparator: string
-}
-
-export interface RawNumberData {
-  nu: string[]
-  // numberingSystem -> pattern
-  symbols: Record<NumberingSystem, SymbolsData>
-  // numberingSystem -> pattern
-  decimal: Record<
-    NumberingSystem,
-    {
-      // The standard number pattern of the decimal.
-      standard: string
-      // These two are compact notation mappings.
-      long: Record<DecimalFormatNum, LDMLPluralRuleMap<string>>
-      short: Record<DecimalFormatNum, LDMLPluralRuleMap<string>>
-    }
-  >
-  percent: Record<NumberingSystem, string>
-  currency: Record<NumberingSystem, RawCurrencyData>
-}
-
-export type LDMLPluralRuleMap<T> = Omit<
-  Partial<Record<LDMLPluralRule, T>>,
-  'other'
-> & {
-  other: T
-}
-
-export interface RawNumberFormatResult {
-  formattedString: string
-  roundedNumber: number
-  integerDigitsCount: number
-}
-
-export type NumberFormatOptionsLocaleMatcher = 'lookup' | 'best fit'
-export type NumberFormatOptionsStyle =
-  | 'decimal'
-  | 'percent'
-  | 'currency'
-  | 'unit'
-export type NumberFormatOptionsCompactDisplay = 'short' | 'long'
-export type NumberFormatOptionsCurrencyDisplay =
-  | 'symbol'
-  | 'code'
-  | 'name'
-  | 'narrowSymbol'
-export type NumberFormatOptionsCurrencySign = 'standard' | 'accounting'
-export type NumberFormatOptionsNotation = NumberFormatNotation
-export type NumberFormatOptionsSignDisplay =
-  | 'auto'
-  | 'always'
-  | 'never'
-  | 'exceptZero'
-export type NumberFormatOptionsUnitDisplay = 'long' | 'short' | 'narrow'
-
-export interface NumberFormatInternal extends NumberFormatDigitInternalSlots {
-  locale: string
-  dataLocale: string
-  style: NumberFormatOptionsStyle
-  currency?: string
-  currencyDisplay: NumberFormatOptionsCurrencyDisplay
-  unit?: string
-  unitDisplay: NumberFormatOptionsUnitDisplay
-  currencySign: NumberFormatOptionsCurrencySign
-  notation: NumberFormatOptionsNotation
-  compactDisplay: NumberFormatOptionsCompactDisplay
-  signDisplay: NumberFormatOptionsSignDisplay
-  useGrouping: boolean
-  pl: Intl.PluralRules
-  boundFormat?: Intl.NumberFormat['format']
-  numberingSystem: string
-  // Locale-dependent formatter data
-  dataLocaleData: NumberFormatLocaleInternalData
-}
-
-export type NumberFormatOptions = Omit<
-  Intl.NumberFormatOptions,
-  'signDisplay'
-> &
-  NumberFormatDigitOptions & {
-    localeMatcher?: NumberFormatOptionsLocaleMatcher
-    style?: NumberFormatOptionsStyle
-    compactDisplay?: NumberFormatOptionsCompactDisplay
-    currencyDisplay?: NumberFormatOptionsCurrencyDisplay
-    currencySign?: NumberFormatOptionsCurrencySign
-    notation?: NumberFormatOptionsNotation
-    signDisplay?: NumberFormatOptionsSignDisplay
-    unit?: string
-    unitDisplay?: NumberFormatOptionsUnitDisplay
-    numberingSystem?: string
-    trailingZeroDisplay?: 'auto' | 'stripIfInteger'
-    roundingPriority?: 'auto' | 'morePrecision' | 'lessPrecision'
-  }
-
-export type ResolvedNumberFormatOptions = Intl.ResolvedNumberFormatOptions &
-  Pick<
-    NumberFormatInternal,
-    | 'currencySign'
-    | 'unit'
-    | 'unitDisplay'
-    | 'notation'
-    | 'compactDisplay'
-    | 'signDisplay'
-  >
-
-export type NumberFormatPartTypes =
-  | Intl.NumberFormatPartTypes
-  | 'exponentSeparator'
-  | 'exponentMinusSign'
-  | 'exponentInteger'
-  | 'compact'
-  | 'unit'
-  | 'literal'
-
-export interface NumberFormatPart {
-  type: NumberFormatPartTypes
-  value: string
-}

package/types/plural-rules.ts

@@ -1,18 +0,0 @@
-import {LocaleData} from './core'
-import {NumberFormatDigitInternalSlots} from './number'
-export type LDMLPluralRule = 'zero' | 'one' | 'two' | 'few' | 'many' | 'other'
-export interface PluralRulesData {
-  categories: {
-    cardinal: string[]
-    ordinal: string[]
-  }
-  fn: (val: number | string, ord?: boolean) => LDMLPluralRule
-}
-
-export type PluralRulesLocaleData = LocaleData<PluralRulesData>
-
-export interface PluralRulesInternal extends NumberFormatDigitInternalSlots {
-  initializedPluralRules: boolean
-  locale: string
-  type: 'cardinal' | 'ordinal'
-}

package/types/relative-time.ts

@@ -1,74 +0,0 @@
-import {LocaleData} from './core'
-import {LDMLPluralRule} from './plural-rules'
-
-export interface FieldData {
-  '0'?: string
-  '1'?: string
-  '-1'?: string
-  '2'?: string
-  '-2'?: string
-  '3'?: string
-  '-3'?: string
-  future: RelativeTimeData
-  past: RelativeTimeData
-}
-
-type RelativeTimeData = {[u in LDMLPluralRule]?: string}
-
-export type UnpackedLocaleFieldsData = {
-  [f in RelativeTimeField]?: FieldData
-} & {nu: Array<string | null>}
-
-export type LocaleFieldsData = {
-  [f in RelativeTimeField]?: FieldData
-} & {nu?: Array<string | null>}
-
-export type RelativeTimeField =
-  | 'second'
-  | 'second-short'
-  | 'second-narrow'
-  | 'minute'
-  | 'minute-short'
-  | 'minute-narrow'
-  | 'hour'
-  | 'hour-short'
-  | 'hour-narrow'
-  | 'day'
-  | 'day-short'
-  | 'day-narrow'
-  | 'week'
-  | 'week-short'
-  | 'week-narrow'
-  | 'month'
-  | 'month-short'
-  | 'month-narrow'
-  | 'quarter'
-  | 'quarter-short'
-  | 'quarter-narrow'
-  | 'year'
-  | 'year-short'
-  | 'year-narrow'
-
-export type RelativeTimeFormatSingularUnit = Exclude<
-  Intl.RelativeTimeFormatUnit,
-  | 'seconds'
-  | 'minutes'
-  | 'hours'
-  | 'days'
-  | 'weeks'
-  | 'months'
-  | 'quarters'
-  | 'years'
->
-
-export type RelativeTimeLocaleData = LocaleData<LocaleFieldsData>
-export interface RelativeTimeFormatInternal {
-  numberFormat: Intl.NumberFormat
-  pluralRules: Intl.PluralRules
-  locale: string
-  fields: LocaleFieldsData
-  style: Intl.ResolvedRelativeTimeFormatOptions['style']
-  numeric: Intl.ResolvedRelativeTimeFormatOptions['numeric']
-  numberingSystem: string
-  initializedRelativeTimeFormat: boolean
-}

package/utils.ts

@@ -1,128 +0,0 @@
-/**
- * Cannot do Math.log(x) / Math.log(10) bc if IEEE floating point issue
- * @param x number
- */
-export function getMagnitude(x: number): number {
-  // Cannot count string length via Number.toString because it may use scientific notation
-  // for very small or very large numbers.
-  return Math.floor(Math.log(x) * Math.LOG10E)
-}
-
-export function repeat(s: string, times: number): string {
-  if (typeof s.repeat === 'function') {
-    return s.repeat(times)
-  }
-  const arr = new Array(times)
-  for (let i = 0; i < arr.length; i++) {
-    arr[i] = s
-  }
-  return arr.join('')
-}
-
-export function setInternalSlot<
-  Instance extends object,
-  Internal extends object,
-  Field extends keyof Internal
->(
-  map: WeakMap<Instance, Internal>,
-  pl: Instance,
-  field: Field,
-  value: NonNullable<Internal>[Field]
-) {
-  if (!map.get(pl)) {
-    map.set(pl, Object.create(null))
-  }
-  const slots = map.get(pl)!
-  slots[field] = value
-}
-
-export function setMultiInternalSlots<
-  Instance extends object,
-  Internal extends object,
-  K extends keyof Internal
->(
-  map: WeakMap<Instance, Internal>,
-  pl: Instance,
-  props: Pick<NonNullable<Internal>, K>
-) {
-  for (const k of Object.keys(props) as K[]) {
-    setInternalSlot(map, pl, k, props[k])
-  }
-}
-
-export function getInternalSlot<
-  Instance extends object,
-  Internal extends object,
-  Field extends keyof Internal
->(
-  map: WeakMap<Instance, Internal>,
-  pl: Instance,
-  field: Field
-): Internal[Field] {
-  return getMultiInternalSlots(map, pl, field)[field]
-}
-
-export function getMultiInternalSlots<
-  Instance extends object,
-  Internal extends object,
-  Field extends keyof Internal
->(
-  map: WeakMap<Instance, Internal>,
-  pl: Instance,
-  ...fields: Field[]
-): Pick<Internal, Field> {
-  const slots = map.get(pl)
-  if (!slots) {
-    throw new TypeError(`${pl} InternalSlot has not been initialized`)
-  }
-  return fields.reduce((all, f) => {
-    all[f] = slots[f]
-    return all
-  }, Object.create(null) as Pick<Internal, Field>)
-}
-
-export interface LiteralPart {
-  type: 'literal'
-  value: string
-}
-
-export function isLiteralPart(
-  patternPart: LiteralPart | {type: string; value?: string}
-): patternPart is LiteralPart {
-  return patternPart.type === 'literal'
-}
-
-/*
-  17 ECMAScript Standard Built-in Objects:
-    Every built-in Function object, including constructors, that is not
-    identified as an anonymous function has a name property whose value
-    is a String.
-
-    Unless otherwise specified, the name property of a built-in Function
-    object, if it exists, has the attributes { [[Writable]]: false,
-    [[Enumerable]]: false, [[Configurable]]: true }.
-*/
-export function defineProperty<T extends object>(
-  target: T,
-  name: string | symbol,
-  {value}: {value: any} & ThisType<any>
-) {
-  Object.defineProperty(target, name, {
-    configurable: true,
-    enumerable: false,
-    writable: true,
-    value,
-  })
-}
-
-export const UNICODE_EXTENSION_SEQUENCE_REGEX = /-u(?:-[0-9a-z]{2,8})+/gi
-
-export function invariant(
-  condition: boolean,
-  message: string,
-  Err: any = Error
-): asserts condition {
-  if (!condition) {
-    throw new Err(message)
-  }
-}