react-intl 2.2.1 → 2.4.0

package/src/plural.js

@@ -9,20 +9,20 @@
 import IntlMessageFormat from 'intl-messageformat';
 
 function resolveLocale(locales) {
-    // IntlMessageFormat#_resolveLocale() does not depend on `this`.
-    return IntlMessageFormat.prototype._resolveLocale(locales);
+  // IntlMessageFormat#_resolveLocale() does not depend on `this`.
+  return IntlMessageFormat.prototype._resolveLocale(locales);
 }
 
 function findPluralFunction(locale) {
-    // IntlMessageFormat#_findPluralFunction() does not depend on `this`.
-    return IntlMessageFormat.prototype._findPluralRuleFunction(locale);
+  // IntlMessageFormat#_findPluralFunction() does not depend on `this`.
+  return IntlMessageFormat.prototype._findPluralRuleFunction(locale);
 }
 
 export default class IntlPluralFormat {
-    constructor(locales, options = {}) {
-        let useOrdinal = options.style === 'ordinal';
-        let pluralFn   = findPluralFunction(resolveLocale(locales));
+  constructor(locales, options = {}) {
+    let useOrdinal = options.style === 'ordinal';
+    let pluralFn = findPluralFunction(resolveLocale(locales));
 
-        this.format = (value) => pluralFn(value, useOrdinal);
-    }
+    this.format = value => pluralFn(value, useOrdinal);
+  }
 }

package/src/types.js

@@ -4,85 +4,95 @@
  * See the accompanying LICENSE file for terms.
  */
 
-import {PropTypes} from 'react';
+import PropTypes from 'prop-types';
 
-const {bool, number, string, func, object, oneOf, shape, any} = PropTypes;
+const {
+  bool,
+  number,
+  string,
+  func,
+  object,
+  oneOf,
+  shape,
+  any,
+  oneOfType,
+} = PropTypes;
 const localeMatcher = oneOf(['best fit', 'lookup']);
 const narrowShortLong = oneOf(['narrow', 'short', 'long']);
 const numeric2digit = oneOf(['numeric', '2-digit']);
 const funcReq = func.isRequired;
 
 export const intlConfigPropTypes = {
-    locale       : string,
-    formats      : object,
-    messages     : object,
-    textComponent: any,
+  locale: string,
+  formats: object,
+  messages: object,
+  textComponent: any,
 
-    defaultLocale : string,
-    defaultFormats: object,
+  defaultLocale: string,
+  defaultFormats: object,
 };
 
 export const intlFormatPropTypes = {
-    formatDate       : funcReq,
-    formatTime       : funcReq,
-    formatRelative   : funcReq,
-    formatNumber     : funcReq,
-    formatPlural     : funcReq,
-    formatMessage    : funcReq,
-    formatHTMLMessage: funcReq,
+  formatDate: funcReq,
+  formatTime: funcReq,
+  formatRelative: funcReq,
+  formatNumber: funcReq,
+  formatPlural: funcReq,
+  formatMessage: funcReq,
+  formatHTMLMessage: funcReq,
 };
 
 export const intlShape = shape({
-    ...intlConfigPropTypes,
-    ...intlFormatPropTypes,
-    formatters: object,
-    now: funcReq,
+  ...intlConfigPropTypes,
+  ...intlFormatPropTypes,
+  formatters: object,
+  now: funcReq,
 });
 
 export const messageDescriptorPropTypes = {
-    id            : string.isRequired,
-    description   : string,
-    defaultMessage: string,
+  id: string.isRequired,
+  description: oneOfType([string, object]),
+  defaultMessage: string,
 };
 
 export const dateTimeFormatPropTypes = {
-    localeMatcher,
-    formatMatcher: oneOf(['basic', 'best fit']),
+  localeMatcher,
+  formatMatcher: oneOf(['basic', 'best fit']),
 
-    timeZone: string,
-    hour12  : bool,
+  timeZone: string,
+  hour12: bool,
 
-    weekday     : narrowShortLong,
-    era         : narrowShortLong,
-    year        : numeric2digit,
-    month       : oneOf(['numeric', '2-digit', 'narrow', 'short', 'long']),
-    day         : numeric2digit,
-    hour        : numeric2digit,
-    minute      : numeric2digit,
-    second      : numeric2digit,
-    timeZoneName: oneOf(['short', 'long']),
+  weekday: narrowShortLong,
+  era: narrowShortLong,
+  year: numeric2digit,
+  month: oneOf(['numeric', '2-digit', 'narrow', 'short', 'long']),
+  day: numeric2digit,
+  hour: numeric2digit,
+  minute: numeric2digit,
+  second: numeric2digit,
+  timeZoneName: oneOf(['short', 'long']),
 };
 
 export const numberFormatPropTypes = {
-    localeMatcher,
+  localeMatcher,
 
-    style          : oneOf(['decimal', 'currency', 'percent']),
-    currency       : string,
-    currencyDisplay: oneOf(['symbol', 'code', 'name']),
-    useGrouping    : bool,
+  style: oneOf(['decimal', 'currency', 'percent']),
+  currency: string,
+  currencyDisplay: oneOf(['symbol', 'code', 'name']),
+  useGrouping: bool,
 
-    minimumIntegerDigits    : number,
-    minimumFractionDigits   : number,
-    maximumFractionDigits   : number,
-    minimumSignificantDigits: number,
-    maximumSignificantDigits: number,
+  minimumIntegerDigits: number,
+  minimumFractionDigits: number,
+  maximumFractionDigits: number,
+  minimumSignificantDigits: number,
+  maximumSignificantDigits: number,
 };
 
 export const relativeFormatPropTypes = {
-    style: oneOf(['best fit', 'numeric']),
-    units: oneOf(['second', 'minute', 'hour', 'day', 'month', 'year']),
+  style: oneOf(['best fit', 'numeric']),
+  units: oneOf(['second', 'minute', 'hour', 'day', 'month', 'year']),
 };
 
 export const pluralFormatPropTypes = {
-    style: oneOf(['cardinal', 'ordinal']),
+  style: oneOf(['cardinal', 'ordinal']),
 };

package/src/utils.js

@@ -15,79 +15,89 @@ import {intlConfigPropTypes} from './types';
 const intlConfigPropNames = Object.keys(intlConfigPropTypes);
 
 const ESCAPED_CHARS = {
-    '&' : '&',
-    '>' : '>',
-    '<' : '&lt;',
-    '"' : '&quot;',
-    '\'': '&#x27;',
+  '&': '&amp;',
+  '>': '&gt;',
+  '<': '&lt;',
+  '"': '&quot;',
+  "'": '&#x27;',
 };
 
 const UNSAFE_CHARS_REGEX = /[&><"']/g;
 
 export function escape(str) {
-    return ('' + str).replace(UNSAFE_CHARS_REGEX, (match) => ESCAPED_CHARS[match]);
+  return ('' + str).replace(UNSAFE_CHARS_REGEX, match => ESCAPED_CHARS[match]);
 }
 
 export function filterProps(props, whitelist, defaults = {}) {
-    return whitelist.reduce((filtered, name) => {
-        if (props.hasOwnProperty(name)) {
-            filtered[name] = props[name];
-        } else if (defaults.hasOwnProperty(name)) {
-            filtered[name] = defaults[name];
-        }
-
-        return filtered;
-    }, {});
+  return whitelist.reduce((filtered, name) => {
+    if (props.hasOwnProperty(name)) {
+      filtered[name] = props[name];
+    } else if (defaults.hasOwnProperty(name)) {
+      filtered[name] = defaults[name];
+    }
+
+    return filtered;
+  }, {});
 }
 
 export function invariantIntlContext({intl} = {}) {
-    invariant(intl,
-        '[React Intl] Could not find required `intl` object. ' +
-        '<IntlProvider> needs to exist in the component ancestry.'
-    );
+  invariant(
+    intl,
+    '[React Intl] Could not find required `intl` object. ' +
+      '<IntlProvider> needs to exist in the component ancestry.'
+  );
 }
 
 export function shallowEquals(objA, objB) {
-    if (objA === objB) {
-        return true;
-    }
-
-    if (typeof objA !== 'object' || objA === null ||
-        typeof objB !== 'object' || objB === null) {
-        return false;
-    }
-
-    let keysA = Object.keys(objA);
-    let keysB = Object.keys(objB);
-
-    if (keysA.length !== keysB.length) {
-        return false;
-    }
-
-    // Test for A's keys different from B.
-    let bHasOwnProperty = Object.prototype.hasOwnProperty.bind(objB);
-    for (let i = 0; i < keysA.length; i++) {
-        if (!bHasOwnProperty(keysA[i]) || objA[keysA[i]] !== objB[keysA[i]]) {
-            return false;
-        }
+  if (objA === objB) {
+    return true;
+  }
+
+  if (
+    typeof objA !== 'object' ||
+    objA === null ||
+    typeof objB !== 'object' ||
+    objB === null
+  ) {
+    return false;
+  }
+
+  let keysA = Object.keys(objA);
+  let keysB = Object.keys(objB);
+
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+
+  // Test for A's keys different from B.
+  let bHasOwnProperty = Object.prototype.hasOwnProperty.bind(objB);
+  for (let i = 0; i < keysA.length; i++) {
+    if (!bHasOwnProperty(keysA[i]) || objA[keysA[i]] !== objB[keysA[i]]) {
+      return false;
     }
+  }
 
-    return true;
+  return true;
 }
 
 export function shouldIntlComponentUpdate(
-    {props, state, context = {}},
-    nextProps, nextState, nextContext = {}
+  {props, state, context = {}},
+  nextProps,
+  nextState,
+  nextContext = {}
 ) {
-    const {intl = {}} = context;
-    const {intl: nextIntl = {}} = nextContext;
-
-    return (
-        !shallowEquals(nextProps, props) ||
-        !shallowEquals(nextState, state) ||
-        !(nextIntl === intl || shallowEquals(
-            filterProps(nextIntl, intlConfigPropNames),
-            filterProps(intl, intlConfigPropNames)
-        ))
-    );
+  const {intl = {}} = context;
+  const {intl: nextIntl = {}} = nextContext;
+
+  return (
+    !shallowEquals(nextProps, props) ||
+    !shallowEquals(nextState, state) ||
+    !(
+      nextIntl === intl ||
+      shallowEquals(
+        filterProps(nextIntl, intlConfigPropNames),
+        filterProps(intl, intlConfigPropNames)
+      )
+    )
+  );
 }