@formatjs/intl 2.3.2 → 2.3.4

package/tests/formatMessage.test.ts

@@ -1,495 +0,0 @@
-/* eslint-disable @typescript-eslint/camelcase */
-import '@formatjs/intl-numberformat/polyfill'
-import '@formatjs/intl-numberformat/locale-data/en'
-import '@formatjs/intl-numberformat/locale-data/es'
-import IntlMessageFormat from 'intl-messageformat'
-import {parse} from '@formatjs/icu-messageformat-parser'
-import {formatMessage as baseFormatMessage} from '../src/message'
-import {Formatters, IntlConfig, IntlFormatters} from '../src/types'
-
-describe('format API', () => {
-  const {NODE_ENV} = process.env
-
-  let config: IntlConfig<any>
-  let state: Formatters
-
-  beforeEach(() => {
-    config = {
-      locale: 'en',
-
-      messages: {
-        no_args: 'Hello, World!',
-        with_arg: 'Hello, {name}!',
-        with_named_format: 'It is {now, date, year_only}',
-        with_html: 'Hello, <b>{name}</b>!',
-
-        missing: undefined as any,
-        empty: '',
-        invalid: 'invalid {}',
-        missing_value: 'missing {arg_missing}',
-        missing_named_format: 'missing {now, date, format_missing}',
-        richText: 'rich <b>text</b>',
-        ast_simple: parse('hello world'),
-        ast_var: parse('hello there, {name}'),
-      } as Record<string, any>,
-
-      formats: {
-        date: {
-          'year-only': {
-            year: 'numeric',
-          },
-          missing: undefined,
-        },
-
-        time: {
-          'hour-only': {
-            hour: '2-digit',
-            hour12: false,
-          },
-          missing: undefined,
-        },
-
-        relative: {
-          seconds: {
-            style: 'narrow',
-          },
-          missing: undefined,
-        },
-
-        number: {
-          percent: {
-            style: 'percent',
-            minimumFractionDigits: 2,
-          },
-          missing: undefined,
-        },
-      } as any,
-
-      defaultLocale: 'en',
-      defaultFormats: {},
-
-      onError: jest.fn(),
-    }
-
-    state = {
-      getDateTimeFormat: jest
-        .fn()
-        .mockImplementation((...args) => new Intl.DateTimeFormat(...args)),
-      getNumberFormat: jest
-        .fn()
-        .mockImplementation((...args) => new Intl.NumberFormat(...args)),
-      getMessageFormat: jest
-        .fn()
-        .mockImplementation(
-          (msg, ...args) => new IntlMessageFormat(msg, ...args)
-        ),
-      getRelativeTimeFormat: jest
-        .fn()
-        .mockImplementation((...args) => new Intl.RelativeTimeFormat(...args)),
-      getPluralRules: jest
-        .fn()
-        .mockImplementation((...args) => new Intl.PluralRules(...args)),
-      getListFormat: jest
-        .fn()
-        .mockImplementation((...args) => new Intl.ListFormat(...args)),
-      getDisplayNames: jest
-        .fn()
-        .mockImplementation(
-          (...args) => new (Intl as any).DisplayNames(...args)
-        ),
-    }
-  })
-
-  afterEach(() => {
-    process.env.NODE_ENV = NODE_ENV
-  })
-
-  describe('formatMessage()', () => {
-    let formatMessage: IntlFormatters['formatMessage']
-
-    beforeEach(() => {
-      // @ts-ignore
-      formatMessage = baseFormatMessage.bind(null, config, state)
-    })
-    it('should hot path message without values', function () {
-      ;(state.getMessageFormat as jest.Mock).mockClear()
-      expect(formatMessage({id: 'no_args'})).toBe('Hello, World!')
-      expect(state.getMessageFormat).not.toHaveBeenCalled()
-      expect(formatMessage({id: 'with_arg'}, {name: 'foo'})).toBe('Hello, foo!')
-      expect(state.getMessageFormat).toHaveBeenCalled()
-    })
-    it('should hot path message without values', function () {
-      ;(state.getMessageFormat as jest.Mock).mockClear()
-      const err = jest.spyOn(console, 'error')
-      expect(formatMessage({id: 'no_args'})).toBe('Hello, World!')
-      expect(err).not.toHaveBeenCalled()
-    })
-    it('should not crash of messages does not have Object.prototype', function () {
-      const messages = Object.create(null)
-      messages!.no_args = 'Hello'
-      // @ts-ignore
-      formatMessage = baseFormatMessage.bind(
-        null,
-        {
-          ...config,
-          messages,
-        },
-        state
-      )
-      expect(() => formatMessage({id: 'no_args'})).not.toThrow()
-      expect(formatMessage({id: 'no_args'})).toBe('Hello')
-    })
-    ;[`Hello, World!'{foo}'`, `'\ud83d'\udc04`].forEach(msg =>
-      it(`should render escaped msg ${msg} properly in production`, () => {
-        process.env.NODE_ENV = 'production'
-
-        const descriptor = {
-          id: 'hello',
-          defaultMessage: msg,
-        }
-
-        const mf = new IntlMessageFormat(msg, 'en')
-
-        expect(formatMessage(descriptor)).toBe(mf.format())
-      })
-    )
-
-    it('throws when no Message Descriptor is provided', () => {
-      // @ts-ignore
-      expect(() => formatMessage()).toThrow(
-        '[@formatjs/intl] An `id` must be provided to format a message.'
-      )
-    })
-
-    it('throws when Message Descriptor `id` is missing or falsy', () => {
-      expect(() => formatMessage({})).toThrow(
-        '[@formatjs/intl] An `id` must be provided to format a message.'
-      )
-      ;[undefined, null, false, 0, ''].forEach(id => {
-        // @ts-ignore
-        expect(() => formatMessage({id})).toThrow(
-          '[@formatjs/intl] An `id` must be provided to format a message.'
-        )
-      })
-    })
-
-    it('formats basic messages', () => {
-      const {locale, messages} = config
-      const mf = new IntlMessageFormat(messages!.no_args, locale)
-
-      expect(formatMessage({id: 'no_args'})).toBe(mf.format())
-    })
-
-    it('formats basic message with preparsed defaultMessage', () => {
-      const {locale, messages} = config
-      const mf = new IntlMessageFormat(messages!.ast_var, locale)
-
-      expect(
-        formatMessage(
-          {id: 'foo', defaultMessage: messages!.ast_var},
-          {
-            name: 'hey',
-          }
-        )
-      ).toBe(
-        mf.format({
-          name: 'hey',
-        })
-      )
-    })
-
-    it('formats message with ID as a method in Object.prototype, GH issue #1885', () => {
-      expect(formatMessage({id: 'toString'})).toBe('toString')
-      expect(formatMessage({id: '__proto__'})).toBe('__proto__')
-    })
-
-    it('formats legacy HTML messages', () => {
-      const {locale, messages} = config
-      const mf = new IntlMessageFormat(messages!.richText, locale)
-      const values = {
-        b: (s: string) => `<foobar>${s}</foobar>`,
-      }
-      expect(formatMessage({id: 'richText'}, values)).toBe(
-        // @ts-ignore
-        mf.format<string>(values)
-      )
-    })
-
-    it('formats basic AST messages', () => {
-      const {locale, messages} = config
-      const mf = new IntlMessageFormat(messages!.ast_simple, locale)
-
-      expect(formatMessage({id: 'ast_simple'})).toBe(mf.format())
-    })
-
-    it('formats basic AST messages in prod', () => {
-      const {locale, messages} = config
-      const mf = new IntlMessageFormat(messages!.ast_simple, locale)
-      process.env.NODE_ENV = 'production'
-      expect(formatMessage({id: 'ast_simple'})).toBe(mf.format())
-    })
-
-    it('formats messages with placeholders', () => {
-      const {locale, messages} = config
-      const mf = new IntlMessageFormat(messages!.with_arg, locale)
-      const values = {name: 'Eric'}
-
-      expect(formatMessage({id: 'with_arg'}, values)).toBe(mf.format(values))
-    })
-
-    it('formats AST message with placeholders', () => {
-      const {locale, messages} = config
-      const mf = new IntlMessageFormat(messages!.ast_var, locale)
-      const values = {name: 'Eric'}
-
-      expect(formatMessage({id: 'ast_var'}, values)).toBe(mf.format(values))
-    })
-
-    it('formats messages with named formats', () => {
-      const {locale, messages, formats} = config
-      const mf = new IntlMessageFormat(
-        messages!.with_named_format,
-        locale,
-        formats
-      )
-      const values = {now: Date.now()}
-
-      expect(formatMessage({id: 'with_named_format'}, values)).toBe(
-        mf.format(values)
-      )
-    })
-
-    describe('fallbacks', () => {
-      it('formats message with missing named formats', () => {
-        const {locale, messages} = config
-        const mf = new IntlMessageFormat(messages!.missing_named_format, locale)
-        const values = {now: Date.now()}
-
-        expect(formatMessage({id: 'missing_named_format'}, values)).toBe(
-          mf.format(values)
-        )
-      })
-
-      it('formats `defaultMessage` when message is missing', () => {
-        const {locale, messages} = config
-        const mf = new IntlMessageFormat(messages!.with_arg, locale)
-        const id = 'missing'
-        const values = {name: 'Eric'}
-
-        expect(
-          formatMessage(
-            {
-              id: id,
-              defaultMessage: messages!.with_arg,
-            },
-            values
-          )
-        ).toBe(mf.format(values))
-      })
-
-      it('warns when `message` is missing and locales are different', () => {
-        config.locale = 'fr'
-
-        const {locale, messages, defaultLocale} = config
-        const mf = new IntlMessageFormat(messages!.with_arg, locale)
-        const id = 'missing'
-        const values = {name: 'Eric'}
-
-        expect(locale).not.toEqual(defaultLocale)
-
-        expect(
-          formatMessage(
-            {
-              id,
-              defaultMessage: messages!.with_arg,
-            },
-            values
-          )
-        ).toBe(mf.format(values))
-
-        expect((config.onError as jest.Mock).mock.calls.map(c => c[0].code))
-          .toMatchInlineSnapshot(`
-          Array [
-            "MISSING_TRANSLATION",
-          ]
-        `)
-      })
-
-      it('warns when `message` and `defaultMessage` are missing', () => {
-        const {messages} = config
-        const id = 'missing'
-        const values = {name: 'Eric'}
-
-        expect(
-          formatMessage(
-            {
-              id: id,
-              defaultMessage: messages!.missing,
-            },
-            values
-          )
-        ).toBe(id)
-
-        expect((config.onError as jest.Mock).mock.calls.map(c => c[0].code))
-          .toMatchInlineSnapshot(`
-          Array [
-            "MISSING_TRANSLATION",
-          ]
-        `)
-      })
-
-      it('formats `defaultMessage` when message has a syntax error', () => {
-        const {locale, messages} = config
-        const mf = new IntlMessageFormat(messages!.with_arg, locale)
-        const id = 'invalid'
-        const values = {name: 'Eric'}
-
-        expect(
-          formatMessage(
-            {
-              id: id,
-              defaultMessage: messages!.with_arg,
-            },
-            values
-          )
-        ).toBe(mf.format(values))
-
-        expect(
-          (config.onError as jest.Mock).mock.calls.map(c => c[0].code)
-        ).toMatchSnapshot()
-      })
-
-      it('formats `defaultMessage` when message has missing values', () => {
-        const {locale, messages} = config
-        const mf = new IntlMessageFormat(messages!.with_arg, locale)
-        const id = 'missing_value'
-        const values = {name: 'Eric'}
-
-        expect(
-          formatMessage(
-            {
-              id: id,
-              defaultMessage: messages!.with_arg,
-            },
-            values
-          )
-        ).toBe(mf.format(values))
-
-        expect(
-          (config.onError as jest.Mock).mock.calls.map(c => c[0].code)
-        ).toMatchSnapshot()
-      })
-
-      it('returns message source when message and `defaultMessage` have formatting errors', () => {
-        const {messages} = config
-        const id = 'missing_value'
-
-        expect(
-          formatMessage(
-            {
-              id,
-              defaultMessage: messages!.invalid,
-            },
-            {
-              foo: 1,
-            }
-          )
-        ).toBe(messages![id])
-        expect(
-          (config.onError as jest.Mock).mock.calls.map(c => c[0].code)
-        ).toMatchSnapshot()
-      })
-
-      it('returns message source when formatting error and missing `defaultMessage`', () => {
-        const {messages} = config
-        const id = 'missing_value'
-
-        expect(
-          formatMessage(
-            {
-              id,
-              defaultMessage: messages!.missing,
-            },
-            {foo: 1}
-          )
-        ).toBe(messages![id])
-        expect(
-          (config.onError as jest.Mock).mock.calls.map(c => c[0].code)
-        ).toMatchSnapshot()
-      })
-
-      it('returns `defaultMessage` source when formatting errors and missing message', () => {
-        config.locale = 'en-US'
-
-        const {messages} = config
-        const id = 'missing'
-
-        expect(
-          formatMessage({
-            id,
-            defaultMessage: messages!.invalid,
-          })
-        ).toBe(messages!.invalid)
-
-        expect(
-          (config.onError as jest.Mock).mock.calls.map(c => c[0].code)
-        ).toMatchSnapshot()
-      })
-
-      it('returns message `id` when message and `defaultMessage` are missing', () => {
-        const id = 'missing'
-
-        expect(formatMessage({id})).toBe(id)
-
-        expect(
-          (config.onError as jest.Mock).mock.calls.map(c => c[0].code)
-        ).toMatchSnapshot()
-      })
-
-      it('returns an empty string when `fallbackOnEmptyString` is false', () => {
-        config.fallbackOnEmptyString = false
-        const id = 'empty'
-
-        expect(formatMessage({id})).toBe('')
-      })
-
-      it('does not return an empty string when `fallbackOnEmptyString` is true', () => {
-        config.fallbackOnEmptyString = true
-        const id = 'empty'
-
-        expect(formatMessage({id})).toBe(id)
-      })
-
-      it('returns message `id` when message and `defaultMessage` are empty', () => {
-        const {messages} = config
-        const id = 'empty'
-
-        expect(
-          formatMessage({
-            id: id,
-            defaultMessage: messages![id],
-          })
-        ).toBe(id)
-
-        expect(
-          (config.onError as jest.Mock).mock.calls.map(c => c[0].code)
-        ).toMatchSnapshot()
-      })
-
-      it('allow passing Intl.MessageFormat opts in', function () {
-        const {locale, messages, formats} = config
-        const opts = {
-          ignoreTag: true,
-        }
-        const mf = new IntlMessageFormat(
-          messages!.richText,
-          locale,
-          formats,
-          opts
-        )
-
-        expect(formatMessage({id: 'richText'}, opts)).toBe(mf.format())
-      })
-    })
-  })
-})

package/tests/formatNumber.test.ts

@@ -1,172 +0,0 @@
-/* eslint-disable @typescript-eslint/camelcase */
-import '@formatjs/intl-numberformat/polyfill'
-import '@formatjs/intl-numberformat/locale-data/en'
-import '@formatjs/intl-numberformat/locale-data/es'
-import {formatNumber as formatNumberFn} from '../src/number'
-import {IntlConfig} from '../src/types'
-
-describe('format API', () => {
-  const {NODE_ENV} = process.env
-
-  let config: IntlConfig<any>
-
-  let getNumberFormat: any
-  beforeEach(() => {
-    config = {
-      locale: 'en',
-
-      messages: {},
-
-      formats: {
-        date: {
-          'year-only': {
-            year: 'numeric',
-          },
-          missing: undefined,
-        },
-
-        time: {
-          'hour-only': {
-            hour: '2-digit',
-            hour12: false,
-          },
-          missing: undefined,
-        },
-
-        relative: {
-          seconds: {
-            style: 'narrow',
-          },
-          missing: undefined,
-        },
-
-        number: {
-          percent: {
-            style: 'percent',
-            minimumFractionDigits: 2,
-          },
-          missing: undefined,
-        },
-      } as any,
-
-      defaultLocale: 'en',
-      defaultFormats: {},
-
-      onError: jest.fn(),
-    }
-
-    getNumberFormat = jest
-      .fn()
-      .mockImplementation((...args) => new Intl.NumberFormat(...args))
-  })
-
-  afterEach(() => {
-    process.env.NODE_ENV = NODE_ENV
-  })
-
-  describe('formatNumber()', () => {
-    let nf: any
-    let formatNumber: any
-
-    beforeEach(() => {
-      nf = new Intl.NumberFormat(config.locale)
-      // @ts-ignore
-      formatNumber = formatNumberFn.bind(null, config, getNumberFormat)
-    })
-
-    it('returns "NaN" when no value is provided', () => {
-      expect(nf.format()).toBe('NaN')
-      expect(formatNumber()).toBe('NaN')
-    })
-
-    it('returns "NaN" when a non-number value is provided', () => {
-      expect(nf.format(NaN)).toBe('NaN')
-      expect(formatNumber(NaN)).toBe('NaN')
-    })
-
-    it('formats falsy values', () => {
-      expect(formatNumber(false)).toBe(nf.format(false))
-      expect(formatNumber(null)).toBe(nf.format(null))
-      expect(formatNumber('')).toBe(nf.format(''))
-      expect(formatNumber(0)).toBe(nf.format(0))
-    })
-
-    it('formats number values', () => {
-      expect(formatNumber(1000)).toBe(nf.format(1000))
-      expect(formatNumber(1.1)).toBe(nf.format(1.1))
-    })
-
-    it('formats string values parsed as numbers', () => {
-      expect(Number('1000')).toBe(1000)
-      expect(formatNumber('1000')).toBe(nf.format('1000'))
-      expect(Number('1.10')).toBe(1.1)
-      expect(formatNumber('1.10')).toBe(nf.format('1.10'))
-    })
-
-    describe('options', () => {
-      it('accepts empty options', () => {
-        expect(formatNumber(1000, {})).toBe(nf.format(1000))
-      })
-
-      it('accepts valid Intl.NumberFormat options', () => {
-        expect(() => formatNumber(0, {style: 'percent'})).not.toThrow()
-      })
-
-      it('falls back and warns on invalid Intl.NumberFormat options', () => {
-        expect(formatNumber(0, {style: 'invalid'})).toBe(String(0))
-        expect(
-          (config.onError as jest.Mock).mock.calls.map(c => c[0].code)
-        ).toMatchSnapshot()
-      })
-
-      it('uses configured named formats', () => {
-        const num = 0.505
-        const format = 'percent'
-
-        const {locale, formats} = config
-        nf = new Intl.NumberFormat(
-          locale,
-          formats!.number![format] as Intl.NumberFormatOptions
-        )
-
-        expect(formatNumber(num, {format})).toBe(nf.format(num))
-      })
-
-      it('uses named formats as defaults', () => {
-        const num = 0.500059
-        const opts = {maximumFractionDigits: 3}
-        const format = 'percent'
-
-        const {locale, formats} = config
-        nf = new Intl.NumberFormat(locale, {
-          ...opts,
-          ...formats!.number![format],
-        } as Intl.NumberFormatOptions)
-
-        expect(formatNumber(num, {...opts, format})).toBe(nf.format(num))
-      })
-
-      it('handles missing named formats and warns', () => {
-        const num = 1000
-        const format = 'missing'
-
-        nf = new Intl.NumberFormat(config.locale)
-
-        expect(formatNumber(num, {format})).toBe(nf.format(num))
-        expect(
-          (config.onError as jest.Mock).mock.calls.map(c => c[0].code)
-        ).toMatchSnapshot()
-      })
-
-      it('uses provided numberingSystem', () => {
-        const num = 0.1
-        const numberingSystem = 'arab'
-        const style = 'percent'
-        // @ts-ignore
-        nf = new Intl.NumberFormat(config.locale, {numberingSystem, style})
-
-        expect(formatNumber(num, {numberingSystem, style})).toBe(nf.format(num))
-      })
-    })
-  })
-})