@formatjs/intl 2.3.2 → 2.3.4

package/tests/formatPlural.test.ts

@@ -1,119 +0,0 @@
-/* eslint-disable @typescript-eslint/camelcase */
-
-import {formatPlural as formatPluralFn} from '../src/plural'
-
-import {IntlFormatters, IntlConfig} from '../src/types'
-
-describe('format API', () => {
-  const {NODE_ENV} = process.env
-
-  let config: IntlConfig<any>
-
-  let getPluralRules: any
-  beforeEach(() => {
-    config = {
-      locale: 'en',
-
-      messages: {},
-
-      defaultLocale: 'en',
-      defaultFormats: {},
-
-      onError: jest.fn(),
-    }
-
-    getPluralRules = jest
-      .fn()
-      .mockImplementation((...args) => new Intl.PluralRules(...args))
-  })
-
-  afterEach(() => {
-    process.env.NODE_ENV = NODE_ENV
-  })
-
-  describe('formatPlural()', () => {
-    let pf: Intl.PluralRules
-    let formatPlural: IntlFormatters['formatPlural']
-
-    beforeEach(() => {
-      pf = new Intl.PluralRules(config.locale)
-      // @ts-ignore
-      formatPlural = formatPluralFn.bind(null, config, getPluralRules)
-    })
-
-    it('should warn for invalid opt', function () {
-      // @ts-ignore
-      expect(formatPlural(0, {type: 'invalid'})).toBe('other')
-      expect(config.onError as jest.Mock).toHaveBeenCalledTimes(1)
-    })
-
-    it('formats falsy values', () => {
-      // @ts-ignore
-      expect(formatPlural(undefined)).toBe(pf.select(undefined))
-
-      // @ts-ignore
-      expect(formatPlural(false)).toBe(pf.select(false))
-
-      // @ts-ignore
-      expect(formatPlural(null)).toBe(pf.select(null))
-
-      // @ts-ignore
-      expect(formatPlural(NaN)).toBe(pf.select(NaN))
-
-      // @ts-ignore
-      expect(formatPlural('')).toBe(pf.select(''))
-      expect(formatPlural(0)).toBe(pf.select(0))
-    })
-
-    it('formats integer values', () => {
-      expect(formatPlural(0)).toBe(pf.select(0))
-      expect(formatPlural(1)).toBe(pf.select(1))
-      expect(formatPlural(2)).toBe(pf.select(2))
-    })
-
-    it('formats decimal values', () => {
-      expect(formatPlural(0.1)).toBe(pf.select(0.1))
-      expect(formatPlural(1.0)).toBe(pf.select(1.0))
-      expect(formatPlural(1.1)).toBe(pf.select(1.1))
-    })
-
-    it('formats string values parsed as numbers', () => {
-      expect(Number('0')).toBe(0)
-
-      // @ts-ignore
-      expect(formatPlural('0')).toBe(pf.select('0'))
-      expect(Number('1')).toBe(1)
-
-      // @ts-ignore
-      expect(formatPlural('1')).toBe(pf.select('1'))
-
-      expect(Number('0.1')).toBe(0.1)
-
-      // @ts-ignore
-      expect(formatPlural('0.1')).toBe(pf.select('0.1'))
-      expect(Number('1.0')).toBe(1.0)
-
-      // @ts-ignore
-      expect(formatPlural('1.0')).toBe(pf.select('1.0'))
-    })
-
-    describe('options', () => {
-      it('accepts empty options', () => {
-        expect(formatPlural(0, {})).toBe(pf.select(0))
-      })
-
-      it('accepts valid IntlPluralFormat options', () => {
-        expect(() => formatPlural(22, {type: 'ordinal'})).not.toThrow()
-      })
-
-      describe('ordinals', () => {
-        it('formats using ordinal plural rules', () => {
-          const opts = {type: 'ordinal'} as Intl.PluralRulesOptions
-          pf = new Intl.PluralRules(config.locale, opts)
-
-          expect(formatPlural(22, opts)).toBe(pf.select(22))
-        })
-      })
-    })
-  })
-})

package/tests/formatRelativeTime.test.ts

@@ -1,145 +0,0 @@
-/* eslint-disable @typescript-eslint/camelcase */
-import {formatRelativeTime as formatRelativeTimeFn} from '../src/relativeTime'
-import {IntlConfig, IntlFormatters} from '../src/types'
-
-describe('format API', () => {
-  const {NODE_ENV} = process.env
-
-  let config: IntlConfig<any>
-
-  let getRelativeTimeFormat: any
-  beforeEach(() => {
-    config = {
-      locale: 'en',
-
-      messages: {},
-      formats: {
-        relative: {
-          seconds: {
-            style: 'narrow',
-          },
-          // @ts-ignore
-          missing: undefined,
-        },
-      },
-      defaultLocale: 'en',
-      defaultFormats: {},
-
-      onError: jest.fn(),
-    }
-
-    getRelativeTimeFormat = jest
-      .fn()
-      .mockImplementation((...args) => new Intl.RelativeTimeFormat(...args))
-  })
-
-  afterEach(() => {
-    process.env.NODE_ENV = NODE_ENV
-  })
-
-  describe('formatRelativeTime()', () => {
-    let rf: any
-    let formatRelativeTime: IntlFormatters['formatRelativeTime']
-
-    beforeEach(() => {
-      rf = new Intl.RelativeTimeFormat(config.locale, undefined)
-      // @ts-ignore
-      formatRelativeTime = formatRelativeTimeFn.bind(
-        null,
-        config,
-        getRelativeTimeFormat
-      )
-    })
-
-    it('falls back and warns when no value is provided', () => {
-      // @ts-ignore
-      expect(formatRelativeTime()).toBe('undefined')
-      expect(
-        (config.onError as jest.Mock).mock.calls.map(c => c[0].code)
-      ).toMatchSnapshot()
-    })
-
-    it('falls back and warns when a non-finite value is provided', () => {
-      expect(formatRelativeTime(NaN)).toBe('NaN')
-      expect(config.onError as jest.Mock).toHaveBeenCalledTimes(1)
-    })
-
-    it('formats falsy finite values', () => {
-      // @ts-ignore
-      expect(formatRelativeTime(false)).toBe('in 0 seconds')
-
-      // @ts-ignore
-      expect(formatRelativeTime(null)).toBe('in 0 seconds')
-      expect(formatRelativeTime(0)).toBe(rf.format(0, 'second'))
-    })
-
-    it('formats with short format', () => {
-      expect(formatRelativeTime(-59, 'second', {style: 'short'})).toBe(
-        '59 sec. ago'
-      )
-    })
-
-    describe('options', () => {
-      it('accepts empty options', () => {
-        expect(formatRelativeTime(0, 'second', {})).toBe(rf.format(0, 'second'))
-      })
-
-      it('accepts valid IntlRelativeFormat options', () => {
-        expect(() =>
-          formatRelativeTime(0, 'second', {numeric: 'auto'})
-        ).not.toThrow()
-        expect(() =>
-          formatRelativeTime(0, 'second', {style: 'short'})
-        ).not.toThrow()
-      })
-
-      it('falls back and warns on invalid IntlRelativeFormat options', () => {
-        // @ts-ignore
-        expect(formatRelativeTime(0, 'invalid')).toBe('0')
-        expect(
-          (config.onError as jest.Mock).mock.calls.map(c => c[0].code)
-        ).toMatchSnapshot()
-      })
-
-      it('uses configured named formats', () => {
-        const format = 'seconds'
-
-        const {locale, formats} = config
-
-        rf = new Intl.RelativeTimeFormat(locale, formats!.relative![format])
-
-        expect(formatRelativeTime(-120, 'second', {format})).toBe(
-          rf.format(-120, 'second', {style: 'narrow'})
-        )
-      })
-
-      it('uses named formats as defaults', () => {
-        const opts = {numeric: 'auto' as const}
-        const format = 'seconds'
-
-        const {locale, formats} = config
-        rf = new Intl.RelativeTimeFormat(locale, {
-          ...opts,
-          ...formats!.relative![format],
-        })
-
-        expect(formatRelativeTime(0, 'minute', {...opts, format})).toBe(
-          rf.format(0, 'minute', {numeric: 'auto'})
-        )
-      })
-
-      it('handles missing named formats and warns', () => {
-        const format = 'missing'
-
-        rf = new Intl.RelativeTimeFormat(config.locale, undefined)
-
-        expect(formatRelativeTime(-1, 'second', {format})).toBe(
-          rf.format(-1, 'second')
-        )
-        expect(
-          (config.onError as jest.Mock).mock.calls.map(c => c[0].code)
-        ).toMatchSnapshot()
-      })
-    })
-  })
-})

package/tests/formatTime.test.ts

@@ -1,234 +0,0 @@
-/* eslint-disable @typescript-eslint/camelcase */
-import {DateTimeFormat} from '@formatjs/ecma402-abstract'
-import {formatTime as formatTimeFn} from '../src/dateTime'
-import {IntlConfig, IntlFormatters, Formatters} from '../src/types'
-import '@formatjs/intl-datetimeformat/polyfill'
-import '@formatjs/intl-datetimeformat/locale-data/en'
-import '@formatjs/intl-datetimeformat/add-all-tz'
-
-describe('format API', () => {
-  const {NODE_ENV} = process.env
-
-  let config: IntlConfig<any>
-
-  let getDateTimeFormat: Formatters['getDateTimeFormat'] = (
-    ...args: ConstructorParameters<typeof Intl.DateTimeFormat>
-  ) => new Intl.DateTimeFormat(...args) as DateTimeFormat
-  beforeEach(() => {
-    config = {
-      locale: 'en',
-
-      messages: {},
-
-      formats: {
-        time: {
-          'hour-only': {
-            hour: '2-digit',
-            hour12: false,
-          },
-          missing: undefined,
-        },
-      } as any,
-
-      defaultLocale: 'en',
-      defaultFormats: {},
-
-      onError: jest.fn(),
-    }
-  })
-
-  afterEach(() => {
-    process.env.NODE_ENV = NODE_ENV
-  })
-
-  describe('formatTime()', () => {
-    let df: Intl.DateTimeFormat
-    let formatTime: IntlFormatters['formatTime']
-
-    beforeEach(() => {
-      df = new Intl.DateTimeFormat(config.locale, {
-        hour: 'numeric',
-        minute: 'numeric',
-      })
-      // @ts-ignore
-      formatTime = formatTimeFn.bind(null, config, getDateTimeFormat)
-      ;(config.onError as jest.Mock).mockClear()
-    })
-
-    it('render now if no value is provided', () => {
-      // @ts-ignore
-      expect(formatTime()).toBe(df.format())
-    })
-
-    it('should not inject additional hour/minute when dateStyle are used', function () {
-      expect(config.onError).not.toHaveBeenCalled()
-      formatTimeFn(config as any, getDateTimeFormat, new Date(), {
-        dateStyle: 'short',
-      })
-
-      expect(config.onError).not.toHaveBeenCalled()
-    })
-
-    it('should not inject additional hour/minute when timeStyle are used', function () {
-      expect(config.onError).not.toHaveBeenCalled()
-      formatTimeFn(config as any, getDateTimeFormat, new Date(), {
-        timeStyle: 'short',
-      })
-
-      expect(config.onError).not.toHaveBeenCalled()
-    })
-
-    it('falls back and warns when a non-finite value is provided', () => {
-      expect(formatTime(NaN)).toBe('NaN')
-      // @ts-ignore
-      expect(formatTime('')).toBe(df.format(''))
-      expect(config.onError as jest.Mock).toHaveBeenCalledTimes(1)
-    })
-
-    it('formats falsy finite values', () => {
-      // @ts-ignore
-      expect(formatTime(false)).toBe(df.format(false))
-      // @ts-ignore
-      expect(formatTime(null)).toBe(df.format(null))
-      expect(formatTime(0)).toBe(df.format(0))
-    })
-
-    it('formats date instance values', () => {
-      expect(formatTime(new Date(0))).toBe(df.format(new Date(0)))
-    })
-
-    it('formats date string values', () => {
-      expect(formatTime(new Date(0).toString())).toBe(df.format(0))
-    })
-
-    it('formats date ms timestamp values', () => {
-      const timestamp = Date.now()
-      expect(formatTime(timestamp)).toBe(df.format(timestamp))
-    })
-
-    it('uses the time zone specified by the provider', () => {
-      const timestamp = Date.now()
-      config.timeZone = 'Africa/Johannesburg'
-      // @ts-ignore
-      formatTime = formatTimeFn.bind(null, config, getDateTimeFormat)
-      const johannesburgDf = new Intl.DateTimeFormat(config.locale, {
-        hour: 'numeric',
-        minute: 'numeric',
-        timeZone: 'Africa/Johannesburg',
-      })
-      expect(formatTime(timestamp)).toBe(johannesburgDf.format(timestamp))
-      config.timeZone = 'America/Chicago'
-      // @ts-ignore
-      formatTime = formatTimeFn.bind(null, config, getDateTimeFormat)
-      const chicagoDf = new Intl.DateTimeFormat(config.locale, {
-        hour: 'numeric',
-        minute: 'numeric',
-        timeZone: 'America/Chicago',
-      })
-      expect(formatTime(timestamp)).toBe(chicagoDf.format(timestamp))
-    })
-
-    describe('options', () => {
-      it('accepts empty options', () => {
-        expect(formatTime(0, {})).toBe(df.format(0))
-      })
-
-      it('accepts valid Intl.DateTimeFormat options', () => {
-        expect(() => formatTime(0, {hour: '2-digit'})).not.toThrow()
-      })
-
-      it('falls back and warns on invalid Intl.DateTimeFormat options', () => {
-        // @ts-expect-error just for test
-        expect(formatTime(0, {hour: 'invalid'})).toBe('0')
-        expect(
-          (config.onError as jest.Mock).mock.calls.map(c => c[0].code)
-        ).toMatchSnapshot()
-      })
-
-      it('uses configured named formats', () => {
-        const date = new Date()
-        const format = 'hour-only'
-
-        const {locale, formats} = config
-        df = new Intl.DateTimeFormat(locale, formats!.time![format])
-
-        expect(formatTime(date, {format})).toBe(df.format(date))
-      })
-
-      it('uses named formats as defaults', () => {
-        const date = new Date()
-        const opts: Intl.DateTimeFormatOptions = {minute: '2-digit'}
-        const format = 'hour-only'
-
-        const {locale, formats} = config
-        df = new Intl.DateTimeFormat(locale, {
-          ...opts,
-          ...formats!.time![format],
-        })
-
-        expect(formatTime(date, {...opts, format})).toBe(df.format(date))
-      })
-
-      it('handles missing named formats and warns', () => {
-        const date = new Date()
-        const format = 'missing'
-
-        expect(formatTime(date, {format})).toBe(df.format(date))
-        expect(
-          (config.onError as jest.Mock).mock.calls.map(c => c[0].code)
-        ).toMatchSnapshot()
-      })
-
-      it('should set default values', () => {
-        const date = new Date()
-        const {locale} = config
-        const day = 'numeric'
-        df = new Intl.DateTimeFormat(locale, {
-          hour: 'numeric',
-          minute: 'numeric',
-          day,
-        })
-        expect(formatTime(date, {day})).toBe(df.format(date))
-      })
-
-      it('should not set default values when second is provided', () => {
-        const date = new Date()
-        const {locale} = config
-        const second = 'numeric'
-        df = new Intl.DateTimeFormat(locale, {second})
-        expect(formatTime(date, {second})).toBe(df.format(date))
-      })
-
-      it('should not set default values when minute is provided', () => {
-        const date = new Date()
-        const {locale} = config
-        const minute = 'numeric'
-        df = new Intl.DateTimeFormat(locale, {minute})
-        expect(formatTime(date, {minute})).toBe(df.format(date))
-      })
-
-      it('should not set default values when hour is provided', () => {
-        const date = new Date()
-        const {locale} = config
-        const hour = 'numeric'
-        df = new Intl.DateTimeFormat(locale, {hour})
-        expect(formatTime(date, {hour})).toBe(df.format(date))
-      })
-
-      it('uses time zone specified in options over the one passed through by the provider', () => {
-        const timestamp = Date.now()
-        config.timeZone = 'Africa/Johannesburg'
-        // @ts-ignore
-        formatTime = formatTimeFn.bind(null, config, getDateTimeFormat)
-        const chicagoDf = new Intl.DateTimeFormat(config.locale, {
-          hour: 'numeric',
-          minute: 'numeric',
-          timeZone: 'America/Chicago',
-        })
-        expect(formatTime(timestamp, {timeZone: 'America/Chicago'})).toBe(
-          chicagoDf.format(timestamp)
-        )
-      })
-    })
-  })
-})

package/tests/global.d.ts

@@ -1,7 +0,0 @@
-import IntlListFormat from '@formatjs/intl-listformat'
-
-declare global {
-  namespace Intl {
-    const ListFormat: typeof IntlListFormat
-  }
-}

package/tsconfig.json

@@ -1,5 +0,0 @@
-// @generated
-{
-  // This is purely for IDE, not for compilation
-  "extends": "../../tsconfig.json"
-}