feat(common): drop use of the Intl API to improve browser support (#18284)

BREAKING CHANGE: Because of multiple bugs and browser inconsistencies, we have dropped the intl api in favor of data exported from the Unicode Common Locale Data Repository (CLDR).
Unfortunately we had to change the i18n pipes (date, number, currency, percent) and there are some breaking changes.

1. I18n pipes
* Breaking change:
  - By default Angular now only contains locale data for the language `en-US`, if you set the value of `LOCALE_ID` to another locale, you will have to import new locale data for this language because we don't use the intl API anymore.

* Features:
  - you don't need to use the intl polyfill for Angular anymore.
  - all i18n pipes now have an additional last parameter `locale` which allows you to use a specific locale instead of the one defined in the token `LOCALE_ID` (whose value is `en-US` by default).
  - the new locale data extracted from CLDR are now available to developers as well and can be used through an API (which should be especially useful for library authors).
  - you can still use the old pipes for now, but their names have been changed and they are no longer included in the `CommonModule`. To use them, you will have to import the `DeprecatedI18NPipesModule` after the `CommonModule` (the order is important):

  ```ts
  import { NgModule } from '@angular/core';
  import { CommonModule, DeprecatedI18NPipesModule } from '@angular/common';

  @NgModule({
    imports: [
      CommonModule,
      // import deprecated module after
      DeprecatedI18NPipesModule
    ]
  })
  export class AppModule { }
  ```

  Dont forget that you will still need to import the intl API polyfill if you want to use those deprecated pipes.

2. Date pipe
* Breaking changes:
  - the predefined formats (`short`, `shortTime`, `shortDate`, `medium`, ...) now use the patterns given by CLDR (like it was in AngularJS) instead of the ones from the intl API. You might notice some changes, e.g. `shortDate` will be `8/15/17` instead of `8/15/2017` for `en-US`.
  - the narrow version of eras is now `GGGGG` instead of `G`, the format `G` is now similar to `GG` and `GGG`.
  - the narrow version of months is now `MMMMM` instead of `L`, the format `L` is now the short standalone version of months.
  - the narrow version of the week day is now `EEEEE` instead of `E`, the format `E` is now similar to `EE` and `EEE`.
  - the timezone `z` will now fallback to `O` and output `GMT+1` instead of the complete zone name (e.g. `Pacific Standard Time`), this is because the quantity of data required to have all the zone names in all of the existing locales is too big.
  - the timezone `Z` will now output the ISO8601 basic format, e.g. `+0100`, you should now use `ZZZZ` to get `GMT+01:00`.

  | Field type | Format        | Example value         | v4 | v5            |
  |------------|---------------|-----------------------|----|---------------|
  | Eras       | Narrow        | A for AD              | G  | GGGGG         |
  | Months     | Narrow        | S for September       | L  | MMMMM         |
  | Week day   | Narrow        | M for Monday          | E  | EEEEE         |
  | Timezone   | Long location | Pacific Standard Time | z  | Not available |
  | Timezone   | Long GMT      | GMT+01:00             | Z  | ZZZZ          |

* Features
  - new predefined formats `long`, `full`, `longTime`, `fullTime`.
  - the format `yyy` is now supported, e.g. the year `52` will be `052` and the year `2017` will be `2017`.
  - standalone months are now supported with the formats `L` to `LLLLL`.
  - week of the year is now supported with the formats `w` and `ww`, e.g. weeks `5` and `05`.
  - week of the month is now supported with the format `W`, e.g. week `3`.
  - fractional seconds are now supported with the format `S` to `SSS`.
  - day periods for AM/PM now supports additional formats `aa`, `aaa`, `aaaa` and `aaaaa`. The formats `a` to `aaa` are similar, while `aaaa` is the wide version if available (e.g. `ante meridiem` for `am`), or equivalent to `a` otherwise, and `aaaaa` is the narrow version (e.g. `a` for `am`).
  - extra day periods are now supported with the formats `b` to `bbbbb` (and `B` to `BBBBB` for the standalone equivalents), e.g. `morning`, `noon`, `afternoon`, ....
  - the short non-localized timezones are now available with the format `O` to `OOOO`. The formats `O` to `OOO` will output `GMT+1` while the format `OOOO` will be `GMT+01:00`.
  - the ISO8601 basic time zones are now available with the formats `Z` to `ZZZZZ`. The formats `Z` to `ZZZ` will output `+0100`, while the format `ZZZZ` will be `GMT+01:00` and `ZZZZZ` will be `+01:00`.

* Bug fixes
  - the date pipe will now work exactly the same across all browsers, which will fix a lot of bugs for safari and IE.
  - eras can now be used on their own without the date, e.g. the format `GG` will be `AD` instead of `8 15, 2017 AD`.

3. Currency pipe
* Breaking change:
  - the default value for `symbolDisplay` is now `symbol` instead of `code`. This means that by default you will see `$4.99` for `en-US` instead of `USD4.99` previously.

* Deprecation:
  - the second parameter of the currency pipe (`symbolDisplay`) is no longer a boolean, it now takes the values `code`, `symbol` or `symbol-narrow`. A boolean value is still valid for now, but it is deprecated and it will print a warning message in the console.

* Features:
  - you can now choose between `code`, `symbol` or `symbol-narrow` which gives you access to more options for some currencies (e.g. the canadian dollar with the code `CAD` has the symbol `CA$` and the symbol-narrow `$`).

4. Percent pipe
* Breaking change
  - if you don't specify the number of digits to round to, the local format will be used (and it usually rounds numbers to 0 digits, instead of not rounding previously), e.g. `{{ 3.141592 | percent }}` will output `314%` for the locale `en-US` instead of `314.1592%` previously.

Fixes #10809, #9524, #7008, #9324, #7590, #6724, #3429, #17576, #17478, #17319, #17200, #16838, #16624, #16625, #16591, #14131, #12632, #11376, #11187

PR Close #18284

packages/common/src/i18n/format_number.ts

@@ -0,0 +1,379 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {NumberFormatStyle, NumberSymbol, getLocaleNumberFormat, getLocaleNumberSymbol} from './locale_data_api';
+
+export const NUMBER_FORMAT_REGEXP = /^(\d+)?\.((\d+)(-(\d+))?)?$/;
+const MAX_DIGITS = 22;
+const DECIMAL_SEP = '.';
+const ZERO_CHAR = '0';
+const PATTERN_SEP = ';';
+const GROUP_SEP = ',';
+const DIGIT_CHAR = '#';
+const CURRENCY_CHAR = '¤';
+const PERCENT_CHAR = '%';
+
+/** @internal */
+export type FormatNumberRes = {
+  str: string | null,
+  error?: string
+};
+
+/**
+ * Transform a number to a locale string based on a style and a format
+ *
+ * @internal
+ */
+export function formatNumber(
+    value: number | string, locale: string, style: NumberFormatStyle, digitsInfo?: string | null,
+    currency: string | null = null): FormatNumberRes {
+  const res: FormatNumberRes = {str: null};
+  const format = getLocaleNumberFormat(locale, style);
+  let num;
+
+  // Convert strings to numbers
+  if (typeof value === 'string' && !isNaN(+value - parseFloat(value))) {
+    num = +value;
+  } else if (typeof value !== 'number') {
+    res.error = `${value} is not a number`;
+    return res;
+  } else {
+    num = value;
+  }
+
+  if (style === NumberFormatStyle.Percent) {
+    num = num * 100;
+  }
+
+  const numStr = Math.abs(num) + '';
+  const pattern = parseNumberFormat(format, getLocaleNumberSymbol(locale, NumberSymbol.MinusSign));
+  let formattedText = '';
+  let isZero = false;
+
+  if (!isFinite(num)) {
+    formattedText = getLocaleNumberSymbol(locale, NumberSymbol.Infinity);
+  } else {
+    const parsedNumber = parseNumber(numStr);
+
+    let minInt = pattern.minInt;
+    let minFraction = pattern.minFrac;
+    let maxFraction = pattern.maxFrac;
+
+    if (digitsInfo) {
+      const parts = digitsInfo.match(NUMBER_FORMAT_REGEXP);
+      if (parts === null) {
+        res.error = `${digitsInfo} is not a valid digit info`;
+        return res;
+      }
+      const minIntPart = parts[1];
+      const minFractionPart = parts[3];
+      const maxFractionPart = parts[5];
+      if (minIntPart != null) {
+        minInt = parseIntAutoRadix(minIntPart);
+      }
+      if (minFractionPart != null) {
+        minFraction = parseIntAutoRadix(minFractionPart);
+      }
+      if (maxFractionPart != null) {
+        maxFraction = parseIntAutoRadix(maxFractionPart);
+      } else if (minFractionPart != null && minFraction > maxFraction) {
+        maxFraction = minFraction;
+      }
+    }
+
+    roundNumber(parsedNumber, minFraction, maxFraction);
+
+    let digits = parsedNumber.digits;
+    let integerLen = parsedNumber.integerLen;
+    const exponent = parsedNumber.exponent;
+    let decimals = [];
+    isZero = digits.every(d => !d);
+
+    // pad zeros for small numbers
+    for (; integerLen < minInt; integerLen++) {
+      digits.unshift(0);
+    }
+
+    // pad zeros for small numbers
+    for (; integerLen < 0; integerLen++) {
+      digits.unshift(0);
+    }
+
+    // extract decimals digits
+    if (integerLen > 0) {
+      decimals = digits.splice(integerLen, digits.length);
+    } else {
+      decimals = digits;
+      digits = [0];
+    }
+
+    // format the integer digits with grouping separators
+    const groups = [];
+    if (digits.length >= pattern.lgSize) {
+      groups.unshift(digits.splice(-pattern.lgSize, digits.length).join(''));
+    }
+
+    while (digits.length > pattern.gSize) {
+      groups.unshift(digits.splice(-pattern.gSize, digits.length).join(''));
+    }
+
+    if (digits.length) {
+      groups.unshift(digits.join(''));
+    }
+
+    const groupSymbol = currency ? NumberSymbol.CurrencyGroup : NumberSymbol.Group;
+    formattedText = groups.join(getLocaleNumberSymbol(locale, groupSymbol));
+
+    // append the decimal digits
+    if (decimals.length) {
+      const decimalSymbol = currency ? NumberSymbol.CurrencyDecimal : NumberSymbol.Decimal;
+      formattedText += getLocaleNumberSymbol(locale, decimalSymbol) + decimals.join('');
+    }
+
+    if (exponent) {
+      formattedText += getLocaleNumberSymbol(locale, NumberSymbol.Exponential) + '+' + exponent;
+    }
+  }
+
+  if (num < 0 && !isZero) {
+    formattedText = pattern.negPre + formattedText + pattern.negSuf;
+  } else {
+    formattedText = pattern.posPre + formattedText + pattern.posSuf;
+  }
+
+  if (style === NumberFormatStyle.Currency && currency !== null) {
+    res.str = formattedText
+                  .replace(CURRENCY_CHAR, currency)
+                  // if we have 2 time the currency character, the second one is ignored
+                  .replace(CURRENCY_CHAR, '');
+    return res;
+  }
+
+  if (style === NumberFormatStyle.Percent) {
+    res.str = formattedText.replace(
+        new RegExp(PERCENT_CHAR, 'g'), getLocaleNumberSymbol(locale, NumberSymbol.PercentSign));
+    return res;
+  }
+
+  res.str = formattedText;
+  return res;
+}
+
+interface ParsedNumberFormat {
+  minInt: number;
+  // the minimum number of digits required in the fraction part of the number
+  minFrac: number;
+  // the maximum number of digits required in the fraction part of the number
+  maxFrac: number;
+  // the prefix for a positive number
+  posPre: string;
+  // the suffix for a positive number
+  posSuf: string;
+  // the prefix for a negative number (e.g. `-` or `(`))
+  negPre: string;
+  // the suffix for a negative number (e.g. `)`)
+  negSuf: string;
+  // number of digits in each group of separated digits
+  gSize: number;
+  // number of digits in the last group of digits before the decimal separator
+  lgSize: number;
+}
+
+function parseNumberFormat(format: string, minusSign = '-'): ParsedNumberFormat {
+  const p = {
+    minInt: 1,
+    minFrac: 0,
+    maxFrac: 0,
+    posPre: '',
+    posSuf: '',
+    negPre: '',
+    negSuf: '',
+    gSize: 0,
+    lgSize: 0
+  };
+
+  const patternParts = format.split(PATTERN_SEP);
+  const positive = patternParts[0];
+  const negative = patternParts[1];
+
+  const positiveParts = positive.indexOf(DECIMAL_SEP) !== -1 ?
+      positive.split(DECIMAL_SEP) :
+      [
+        positive.substring(0, positive.lastIndexOf(ZERO_CHAR) + 1),
+        positive.substring(positive.lastIndexOf(ZERO_CHAR) + 1)
+      ],
+        integer = positiveParts[0], fraction = positiveParts[1] || '';
+
+  p.posPre = integer.substr(0, integer.indexOf(DIGIT_CHAR));
+
+  for (let i = 0; i < fraction.length; i++) {
+    const ch = fraction.charAt(i);
+    if (ch === ZERO_CHAR) {
+      p.minFrac = p.maxFrac = i + 1;
+    } else if (ch === DIGIT_CHAR) {
+      p.maxFrac = i + 1;
+    } else {
+      p.posSuf += ch;
+    }
+  }
+
+  const groups = integer.split(GROUP_SEP);
+  p.gSize = groups[1] ? groups[1].length : 0;
+  p.lgSize = (groups[2] || groups[1]) ? (groups[2] || groups[1]).length : 0;
+
+  if (negative) {
+    const trunkLen = positive.length - p.posPre.length - p.posSuf.length,
+          pos = negative.indexOf(DIGIT_CHAR);
+
+    p.negPre = negative.substr(0, pos).replace(/'/g, '');
+    p.negSuf = negative.substr(pos + trunkLen).replace(/'/g, '');
+  } else {
+    p.negPre = minusSign + p.posPre;
+    p.negSuf = p.posSuf;
+  }
+
+  return p;
+}
+
+interface ParsedNumber {
+  // an array of digits containing leading zeros as necessary
+  digits: number[];
+  // the exponent for numbers that would need more than `MAX_DIGITS` digits in `d`
+  exponent: number;
+  // the number of the digits in `d` that are to the left of the decimal point
+  integerLen: number;
+}
+
+/**
+ * Parse a number (as a string)
+ * Significant bits of this parse algorithm came from https://github.com/MikeMcl/big.js/
+ */
+function parseNumber(numStr: string): ParsedNumber {
+  let exponent = 0, digits, integerLen;
+  let i, j, zeros;
+
+  // Decimal point?
+  if ((integerLen = numStr.indexOf(DECIMAL_SEP)) > -1) {
+    numStr = numStr.replace(DECIMAL_SEP, '');
+  }
+
+  // Exponential form?
+  if ((i = numStr.search(/e/i)) > 0) {
+    // Work out the exponent.
+    if (integerLen < 0) integerLen = i;
+    integerLen += +numStr.slice(i + 1);
+    numStr = numStr.substring(0, i);
+  } else if (integerLen < 0) {
+    // There was no decimal point or exponent so it is an integer.
+    integerLen = numStr.length;
+  }
+
+  // Count the number of leading zeros.
+  for (i = 0; numStr.charAt(i) === ZERO_CHAR; i++) { /* empty */
+  }
+
+  if (i === (zeros = numStr.length)) {
+    // The digits are all zero.
+    digits = [0];
+    integerLen = 1;
+  } else {
+    // Count the number of trailing zeros
+    zeros--;
+    while (numStr.charAt(zeros) === ZERO_CHAR) zeros--;
+
+    // Trailing zeros are insignificant so ignore them
+    integerLen -= i;
+    digits = [];
+    // Convert string to array of digits without leading/trailing zeros.
+    for (j = 0; i <= zeros; i++, j++) {
+      digits[j] = +numStr.charAt(i);
+    }
+  }
+
+  // If the number overflows the maximum allowed digits then use an exponent.
+  if (integerLen > MAX_DIGITS) {
+    digits = digits.splice(0, MAX_DIGITS - 1);
+    exponent = integerLen - 1;
+    integerLen = 1;
+  }
+
+  return {digits, exponent, integerLen};
+}
+
+/**
+ * Round the parsed number to the specified number of decimal places
+ * This function changes the parsedNumber in-place
+ */
+function roundNumber(parsedNumber: ParsedNumber, minFrac: number, maxFrac: number) {
+  if (minFrac > maxFrac) {
+    throw new Error(
+        `The minimum number of digits after fraction (${minFrac}) is higher than the maximum (${maxFrac}).`);
+  }
+
+  let digits = parsedNumber.digits;
+  let fractionLen = digits.length - parsedNumber.integerLen;
+  const fractionSize = Math.min(Math.max(minFrac, fractionLen), maxFrac);
+
+  // The index of the digit to where rounding is to occur
+  let roundAt = fractionSize + parsedNumber.integerLen;
+  let digit = digits[roundAt];
+
+  if (roundAt > 0) {
+    // Drop fractional digits beyond `roundAt`
+    digits.splice(Math.max(parsedNumber.integerLen, roundAt));
+
+    // Set non-fractional digits beyond `roundAt` to 0
+    for (let j = roundAt; j < digits.length; j++) {
+      digits[j] = 0;
+    }
+  } else {
+    // We rounded to zero so reset the parsedNumber
+    fractionLen = Math.max(0, fractionLen);
+    parsedNumber.integerLen = 1;
+    digits.length = Math.max(1, roundAt = fractionSize + 1);
+    digits[0] = 0;
+    for (let i = 1; i < roundAt; i++) digits[i] = 0;
+  }
+
+  if (digit >= 5) {
+    if (roundAt - 1 < 0) {
+      for (let k = 0; k > roundAt; k--) {
+        digits.unshift(0);
+        parsedNumber.integerLen++;
+      }
+      digits.unshift(1);
+      parsedNumber.integerLen++;
+    } else {
+      digits[roundAt - 1]++;
+    }
+  }
+
+  // Pad out with zeros to get the required fraction length
+  for (; fractionLen < Math.max(0, fractionSize); fractionLen++) digits.push(0);
+
+
+  // Do any carrying, e.g. a digit was rounded up to 10
+  const carry = digits.reduceRight(function(carry, d, i, digits) {
+    d = d + carry;
+    digits[i] = d % 10;
+    return Math.floor(d / 10);
+  }, 0);
+  if (carry) {
+    digits.unshift(carry);
+    parsedNumber.integerLen++;
+  }
+}
+
+/** @internal */
+export function parseIntAutoRadix(text: string): number {
+  const result: number = parseInt(text);
+  if (isNaN(result)) {
+    throw new Error('Invalid integer literal when parsing ' + text);
+  }
+  return result;
+}