Remove fallback implementation of Intl.PluralRules

The intersection of browsers that support ES6 modules (and therefore run our JavaScript) but do not support `Intl.PluralRules` is relatively small:

- Safari 10.3 - 12.5 on iOS
- Safari 10.1 - 12.1 on macOS
- Edge 16-18
- Chrome 61-62
- Opera 48-49

These browsers represent a tiny percentage of users and do not justify the overhead of including the extra JavaScript to implement the fallback logic, so let’s remove it.

These browsers will instead fall back to the ‘other’ translation. For example, when using the Character Count in English it will display ‘You have 1 characters remaining’ rather than the singular translation ‘You have 1 character remaining’.

Author: colinrotherham

packages/nhsuk-frontend/src/nhsuk/i18n.jsdom.test.mjs

@@ -261,7 +261,7 @@ describe('I18n', () => {
       expect(IntlPluralRulesSelect).toHaveBeenCalledWith(1)
     })
 
-    it('falls back to internal fallback rules', () => {
+    it('falls back to "other" when the browser does not support Intl.PluralRules', () => {
       const i18n = new I18n(
         {
           test: {
@@ -278,13 +278,7 @@ describe('I18n', () => {
         .spyOn(i18n, 'hasIntlPluralRulesSupport')
         .mockImplementation(() => false)
 
-      const selectPluralFormUsingFallbackRules = jest.spyOn(
-        i18n,
-        'selectPluralFormUsingFallbackRules'
-      )
-
-      i18n.getPluralSuffix('test', 1)
-      expect(selectPluralFormUsingFallbackRules).toHaveBeenCalledWith(1)
+      expect(i18n.getPluralSuffix('test', 1)).toBe('other')
     })
 
     it('returns the preferred plural form for the locale if a translation exists', () => {
@@ -390,68 +384,4 @@ describe('I18n', () => {
       expect(i18n.getPluralSuffix('test', 'nonsense')).toBe('other')
     })
   })
-
-  describe('.getPluralRulesForLocale', () => {
-    it('returns the correct rules for a locale in the map', () => {
-      const locale = 'ar'
-      const i18n = new I18n({}, { locale })
-      expect(i18n.getPluralRulesForLocale()).toBe('arabic')
-    })
-
-    it('returns the correct rules for a locale in the map with regional indicator', () => {
-      const locale = 'pt-PT'
-      const i18n = new I18n({}, { locale })
-      expect(i18n.getPluralRulesForLocale()).toBe('spanish')
-    })
-
-    it('returns the correct rules for a locale allowing for no regional indicator', () => {
-      const locale = 'cy-GB'
-      const i18n = new I18n({}, { locale })
-      expect(i18n.getPluralRulesForLocale()).toBe('welsh')
-    })
-  })
-
-  describe('.selectPluralFormUsingFallbackRules', () => {
-    // The locales we want to test, with numbers for any 'special cases' in
-    // those locales we want to ensure are handled correctly
-    /** @type {[string, number[]][]} */
-    const locales = [
-      ['ar', [105, 125]],
-      ['zh', []],
-      ['fr', []],
-      ['de', []],
-      ['ga', [9]],
-      ['ru', [3, 13, 101]],
-      ['gd', [15]],
-      ['es', [1000000, 2000000]],
-      ['cy', [3, 6]]
-    ]
-
-    it.each(locales)(
-      'matches `Intl.PluralRules.select()` for %s locale',
-      (locale, localeNumbers) => {
-        const i18n = new I18n({}, { locale })
-        const intl = new Intl.PluralRules(locale)
-
-        const numbersToTest = [0, 1, 2, 5, 25, 100, ...localeNumbers]
-
-        numbersToTest.forEach((num) => {
-          expect(i18n.selectPluralFormUsingFallbackRules(num)).toBe(
-            intl.select(num)
-          )
-        })
-      }
-    )
-
-    it('returns "other" for unsupported locales', () => {
-      const locale = 'la'
-      const i18n = new I18n({}, { locale })
-
-      const numbersToTest = [0, 1, 2, 5, 25, 100]
-
-      numbersToTest.forEach((num) => {
-        expect(i18n.selectPluralFormUsingFallbackRules(num)).toBe('other')
-      })
-    })
-  })
 })

packages/nhsuk-frontend/src/nhsuk/i18n.mjs

@@ -179,7 +179,7 @@ export class I18n {
     // use the hardcoded fallback.
     const preferredForm = this.hasIntlPluralRulesSupport()
       ? new Intl.PluralRules(this.locale).select(count)
-      : this.selectPluralFormUsingFallbackRules(count)
+      : 'other'
 
     // Use the correct plural form if provided
     if (isObject(translation)) {
@@ -201,239 +201,6 @@ export class I18n {
       `i18n: Plural form ".other" is required for "${this.locale}" locale`
     )
   }
-
-  /**
-   * Get the plural form using our fallback implementation
-   *
-   * This is split out into a separate function to make it easier to test the
-   * fallback behaviour in an environment where Intl.PluralRules exists.
-   *
-   * @param {number} count - Number used to determine which pluralisation to use.
-   * @returns {PluralRule} The pluralisation form for count in this locale.
-   */
-  selectPluralFormUsingFallbackRules(count) {
-    // Currently our custom code can only handle positive integers, so let's
-    // make sure our number is one of those.
-    count = Math.abs(Math.floor(count))
-
-    const ruleset = this.getPluralRulesForLocale()
-
-    if (ruleset) {
-      return I18n.pluralRules[ruleset](count)
-    }
-
-    return 'other'
-  }
-
-  /**
-   * Work out which pluralisation rules to use for the current locale
-   *
-   * The locale may include a regional indicator (such as en-GB), but we don't
-   * usually care about this part, as pluralisation rules are usually the same
-   * regardless of region. There are exceptions, however, (e.g. Portuguese) so
-   * this searches by both the full and shortened locale codes, just to be sure.
-   *
-   * @returns {string | undefined} The name of the pluralisation rule to use (a key for one
-   *   of the functions in this.pluralRules)
-   */
-  getPluralRulesForLocale() {
-    const localeShort = this.locale.split('-')[0]
-
-    // Look through the plural rules map to find which `pluralRule` is
-    // appropriate for our current `locale`.
-    for (const pluralRule in I18n.pluralRulesMap) {
-      const languages = I18n.pluralRulesMap[pluralRule]
-      if (languages.includes(this.locale) || languages.includes(localeShort)) {
-        return pluralRule
-      }
-    }
-  }
-
-  /**
-   * Map of plural rules to languages where those rules apply.
-   *
-   * Note: These groups are named for the most dominant or recognisable language
-   * that uses each system. The groupings do not imply that the languages are
-   * related to one another. Many languages have evolved the same systems
-   * independently of one another.
-   *
-   * Code to support more languages can be found in the i18n spike:
-   * {@link https://github.com/alphagov/govuk-frontend/blob/spike-i18n-support/src/govuk/i18n.mjs}
-   *
-   * Languages currently supported:
-   *
-   * Arabic: Arabic (ar)
-   * Chinese: Burmese (my), Chinese (zh), Indonesian (id), Japanese (ja),
-   *   Javanese (jv), Korean (ko), Malay (ms), Thai (th), Vietnamese (vi)
-   * French: Armenian (hy), Bangla (bn), French (fr), Gujarati (gu), Hindi (hi),
-   *   Persian Farsi (fa), Punjabi (pa), Zulu (zu)
-   * German: Afrikaans (af), Albanian (sq), Azerbaijani (az), Basque (eu),
-   *   Bulgarian (bg), Catalan (ca), Danish (da), Dutch (nl), English (en),
-   *   Estonian (et), Finnish (fi), Georgian (ka), German (de), Greek (el),
-   *   Hungarian (hu), Luxembourgish (lb), Norwegian (no), Somali (so),
-   *   Swahili (sw), Swedish (sv), Tamil (ta), Telugu (te), Turkish (tr),
-   *   Urdu (ur)
-   * Irish: Irish Gaelic (ga)
-   * Russian: Russian (ru), Ukrainian (uk)
-   * Scottish: Scottish Gaelic (gd)
-   * Spanish: European Portuguese (pt-PT), Italian (it), Spanish (es)
-   * Welsh: Welsh (cy)
-   *
-   * @type {{ [key: string]: string[] }}
-   */
-  static pluralRulesMap = {
-    arabic: ['ar'],
-    chinese: ['my', 'zh', 'id', 'ja', 'jv', 'ko', 'ms', 'th', 'vi'],
-    french: ['hy', 'bn', 'fr', 'gu', 'hi', 'fa', 'pa', 'zu'],
-    german: [
-      'af',
-      'sq',
-      'az',
-      'eu',
-      'bg',
-      'ca',
-      'da',
-      'nl',
-      'en',
-      'et',
-      'fi',
-      'ka',
-      'de',
-      'el',
-      'hu',
-      'lb',
-      'no',
-      'so',
-      'sw',
-      'sv',
-      'ta',
-      'te',
-      'tr',
-      'ur'
-    ],
-    irish: ['ga'],
-    russian: ['ru', 'uk'],
-    scottish: ['gd'],
-    spanish: ['pt-PT', 'it', 'es'],
-    welsh: ['cy']
-  }
-
-  /**
-   * Different pluralisation rule sets
-   *
-   * Returns the appropriate suffix for the plural form associated with `n`.
-   * Possible suffixes: 'zero', 'one', 'two', 'few', 'many', 'other' (the actual
-   * meaning of each differs per locale). 'other' should always exist, even in
-   * languages without plurals, such as Chinese.
-   * {@link https://cldr.unicode.org/index/cldr-spec/plural-rules}
-   *
-   * The count must be a positive integer. Negative numbers and decimals aren't accounted for
-   *
-   * @type {{ [key: string]: (count: number) => PluralRule }}
-   */
-  static pluralRules = {
-    arabic(n) {
-      if (n === 0) {
-        return 'zero'
-      }
-      if (n === 1) {
-        return 'one'
-      }
-      if (n === 2) {
-        return 'two'
-      }
-      if (n % 100 >= 3 && n % 100 <= 10) {
-        return 'few'
-      }
-      if (n % 100 >= 11 && n % 100 <= 99) {
-        return 'many'
-      }
-      return 'other'
-    },
-    chinese() {
-      return 'other'
-    },
-    french(n) {
-      return n === 0 || n === 1 ? 'one' : 'other'
-    },
-    german(n) {
-      return n === 1 ? 'one' : 'other'
-    },
-    irish(n) {
-      if (n === 1) {
-        return 'one'
-      }
-      if (n === 2) {
-        return 'two'
-      }
-      if (n >= 3 && n <= 6) {
-        return 'few'
-      }
-      if (n >= 7 && n <= 10) {
-        return 'many'
-      }
-      return 'other'
-    },
-    russian(n) {
-      const lastTwo = n % 100
-      const last = lastTwo % 10
-      if (last === 1 && lastTwo !== 11) {
-        return 'one'
-      }
-      if (last >= 2 && last <= 4 && !(lastTwo >= 12 && lastTwo <= 14)) {
-        return 'few'
-      }
-      if (
-        last === 0 ||
-        (last >= 5 && last <= 9) ||
-        (lastTwo >= 11 && lastTwo <= 14)
-      ) {
-        return 'many'
-      }
-      // Note: The 'other' suffix is only used by decimal numbers in Russian.
-      // We don't anticipate it being used, but it's here for consistency.
-      return 'other'
-    },
-    scottish(n) {
-      if (n === 1 || n === 11) {
-        return 'one'
-      }
-      if (n === 2 || n === 12) {
-        return 'two'
-      }
-      if ((n >= 3 && n <= 10) || (n >= 13 && n <= 19)) {
-        return 'few'
-      }
-      return 'other'
-    },
-    spanish(n) {
-      if (n === 1) {
-        return 'one'
-      }
-      if (n % 1000000 === 0 && n !== 0) {
-        return 'many'
-      }
-      return 'other'
-    },
-    welsh(n) {
-      if (n === 0) {
-        return 'zero'
-      }
-      if (n === 1) {
-        return 'one'
-      }
-      if (n === 2) {
-        return 'two'
-      }
-      if (n === 3) {
-        return 'few'
-      }
-      if (n === 6) {
-        return 'many'
-      }
-      return 'other'
-    }
-  }
 }
 
 /**