react-intl 4.2.0 → 4.3.1

package/dist/react-intl.js

@@ -4301,15 +4301,27 @@
     };
   }();
 
+  var ErrorCode;
+
+  (function (ErrorCode) {
+    // When we have a placeholder but no value to format
+    ErrorCode["MISSING_VALUE"] = "MISSING_VALUE"; // When value supplied is invalid
+
+    ErrorCode["INVALID_VALUE"] = "INVALID_VALUE"; // When we need specific Intl API but it's not available
+
+    ErrorCode["MISSING_INTL_API"] = "MISSING_INTL_API";
+  })(ErrorCode || (ErrorCode = {}));
+
   var FormatError =
   /** @class */
   function (_super) {
     __extends$1(FormatError, _super);
 
-    function FormatError(msg, code) {
+    function FormatError(msg, code, originalMessage) {
       var _this = _super.call(this, msg) || this;
 
       _this.code = code;
+      _this.originalMessage = originalMessage;
       return _this;
     }
 
@@ -4325,29 +4337,50 @@
   function (_super) {
     __extends$1(InvalidValueError, _super);
 
-    function InvalidValueError(variableId, value, options) {
-      return _super.call(this, "Invalid values for \"" + variableId + "\": \"" + value + "\". Options are \"" + Object.keys(options).join('", "') + "\"", 1
+    function InvalidValueError(variableId, value, options, originalMessage) {
+      return _super.call(this, "Invalid values for \"" + variableId + "\": \"" + value + "\". Options are \"" + Object.keys(options).join('", "') + "\"", "INVALID_VALUE"
       /* INVALID_VALUE */
-      ) || this;
+      , originalMessage) || this;
     }
 
     return InvalidValueError;
   }(FormatError);
 
+  var InvalidValueTypeError =
+  /** @class */
+  function (_super) {
+    __extends$1(InvalidValueTypeError, _super);
+
+    function InvalidValueTypeError(value, type, originalMessage) {
+      return _super.call(this, "Value for \"" + value + "\" must be of type " + type, "INVALID_VALUE"
+      /* INVALID_VALUE */
+      , originalMessage) || this;
+    }
+
+    return InvalidValueTypeError;
+  }(FormatError);
+
   var MissingValueError =
   /** @class */
   function (_super) {
     __extends$1(MissingValueError, _super);
 
     function MissingValueError(variableId, originalMessage) {
-      return _super.call(this, "The intl string context variable \"" + variableId + "\" was not provided to the string \"" + originalMessage + "\"", 0
+      return _super.call(this, "The intl string context variable \"" + variableId + "\" was not provided to the string \"" + originalMessage + "\"", "MISSING_VALUE"
       /* MISSING_VALUE */
-      ) || this;
+      , originalMessage) || this;
     }
 
     return MissingValueError;
   }(FormatError);
 
+  var PART_TYPE;
+
+  (function (PART_TYPE) {
+    PART_TYPE[PART_TYPE["literal"] = 0] = "literal";
+    PART_TYPE[PART_TYPE["object"] = 1] = "object";
+  })(PART_TYPE || (PART_TYPE = {}));
+
   function mergeLiteral(parts) {
     if (parts.length < 2) {
       return parts;
@@ -4483,7 +4516,7 @@
         var formatFn = values[value_1];
 
         if (!isFormatXMLElementFn(formatFn)) {
-          throw new TypeError("Value for \"" + value_1 + "\" must be a function");
+          throw new InvalidValueTypeError(value_1, 'function', originalMessage);
         }
 
         var parts = formatToParts(children, locales, formatters, formats, values);
@@ -4511,7 +4544,7 @@
         var opt = el.options[value] || el.options.other;
 
         if (!opt) {
-          throw new InvalidValueError(el.value, value, Object.keys(el.options));
+          throw new InvalidValueError(el.value, value, Object.keys(el.options), originalMessage);
         }
 
         result.push.apply(result, formatToParts(opt.value, locales, formatters, formats, values));
@@ -4523,9 +4556,9 @@
 
         if (!opt) {
           if (!Intl.PluralRules) {
-            throw new FormatError("Intl.PluralRules is not available in this environment.\nTry polyfilling it using \"@formatjs/intl-pluralrules\"\n", 2
+            throw new FormatError("Intl.PluralRules is not available in this environment.\nTry polyfilling it using \"@formatjs/intl-pluralrules\"\n", "MISSING_INTL_API"
             /* MISSING_INTL_API */
-            );
+            , originalMessage);
           }
 
           var rule = formatters.getPluralRules(locales, {
@@ -4535,7 +4568,7 @@
         }
 
         if (!opt) {
-          throw new InvalidValueError(el.value, value, Object.keys(el.options));
+          throw new InvalidValueError(el.value, value, Object.keys(el.options), originalMessage);
         }
 
         result.push.apply(result, formatToParts(opt.value, locales, formatters, formats, values, value - (el.offset || 0)));
@@ -4769,18 +4802,27 @@
     }
   }
 
+  (function (ReactIntlErrorCode) {
+    ReactIntlErrorCode["FORMAT_ERROR"] = "FORMAT_ERROR";
+    ReactIntlErrorCode["UNSUPPORTED_FORMATTER"] = "UNSUPPORTED_FORMATTER";
+    ReactIntlErrorCode["INVALID_CONFIG"] = "INVALID_CONFIG";
+    ReactIntlErrorCode["MISSING_DATA"] = "MISSING_DATA";
+    ReactIntlErrorCode["MISSING_TRANSLATION"] = "MISSING_TRANSLATION";
+  })(exports.ReactIntlErrorCode || (exports.ReactIntlErrorCode = {}));
+
   var ReactIntlError = /*#__PURE__*/function (_Error) {
     _inherits(ReactIntlError, _Error);
 
     var _super = _createSuper(ReactIntlError);
 
-    function ReactIntlError(code, message, exception) {
+    function ReactIntlError(code, message, descriptor, exception) {
       var _this;
 
       _classCallCheck(this, ReactIntlError);
 
       _this = _super.call(this, "[React Intl Error ".concat(code, "] ").concat(message, " ").concat(exception ? "\n".concat(exception.stack) : ''));
       _this.code = code;
+      _this.descriptor = descriptor;
 
       if (typeof Error.captureStackTrace === 'function') {
         Error.captureStackTrace(_assertThisInitialized(_this), ReactIntlError);
@@ -5472,7 +5514,7 @@
     var RelativeTimeFormat = Intl.RelativeTimeFormat;
 
     if (!RelativeTimeFormat) {
-      config.onError(new FormatError("Intl.RelativeTimeFormat is not available in this environment.\nTry polyfilling it using \"@formatjs/intl-relativetimeformat\"\n", 2
+      config.onError(new FormatError("Intl.RelativeTimeFormat is not available in this environment.\nTry polyfilling it using \"@formatjs/intl-relativetimeformat\"\n", "MISSING_INTL_API"
       /* MISSING_INTL_API */
       ));
     }
@@ -5580,7 +5622,7 @@
     var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
 
     if (!Intl.PluralRules) {
-      onError(new FormatError("Intl.PluralRules is not available in this environment.\nTry polyfilling it using \"@formatjs/intl-pluralrules\"\n", 2
+      onError(new FormatError("Intl.PluralRules is not available in this environment.\nTry polyfilling it using \"@formatjs/intl-pluralrules\"\n", "MISSING_INTL_API"
       /* MISSING_INTL_API */
       ));
     }
@@ -5662,7 +5704,7 @@
       } catch (e) {
         onError(new ReactIntlError("FORMAT_ERROR"
         /* FORMAT_ERROR */
-        , "Error formatting message: \"".concat(id, "\" for locale: \"").concat(locale, "\"") + (defaultMessage ? ', using default message as fallback.' : ''), e));
+        , "Error formatting message: \"".concat(id, "\" for locale: \"").concat(locale, "\"") + (defaultMessage ? ', using default message as fallback.' : ''), messageDescriptor, e));
       }
     } else if (!defaultMessage || locale && locale.toLowerCase() !== defaultLocale.toLowerCase()) {
       // This prevents warnings from littering the console in development
@@ -5670,7 +5712,7 @@
       // default locale.
       onError(new ReactIntlError("MISSING_TRANSLATION"
       /* MISSING_TRANSLATION */
-      , "Missing message: \"".concat(id, "\" for locale: \"").concat(locale, "\"") + (defaultMessage ? ', using default message as fallback.' : '')));
+      , "Missing message: \"".concat(id, "\" for locale: \"").concat(locale, "\"") + (defaultMessage ? ', using default message as fallback.' : ''), messageDescriptor));
     }
 
     if (!formattedMessageParts && defaultMessage) {
@@ -5681,14 +5723,14 @@
       } catch (e) {
         onError(new ReactIntlError("FORMAT_ERROR"
         /* FORMAT_ERROR */
-        , "Error formatting the default message for: \"".concat(id, "\""), e));
+        , "Error formatting the default message for: \"".concat(id, "\""), messageDescriptor, e));
       }
     }
 
     if (!formattedMessageParts) {
       onError(new ReactIntlError("FORMAT_ERROR"
       /* FORMAT_ERROR */
-      , "Cannot format message: \"".concat(id, "\", ") + "using message ".concat(message || defaultMessage ? 'source' : 'id', " as fallback.")));
+      , "Cannot format message: \"".concat(id, "\", ") + "using message ".concat(message || defaultMessage ? 'source' : 'id', " as fallback."), messageDescriptor));
 
       if (typeof message === 'string') {
         return message || defaultMessage || String(id);
@@ -5758,7 +5800,7 @@
     var ListFormat = Intl.ListFormat;
 
     if (!ListFormat) {
-      onError(new FormatError("Intl.ListFormat is not available in this environment.\nTry polyfilling it using \"@formatjs/intl-listformat\"\n", 2
+      onError(new FormatError("Intl.ListFormat is not available in this environment.\nTry polyfilling it using \"@formatjs/intl-listformat\"\n", "MISSING_INTL_API"
       /* MISSING_INTL_API */
       ));
     }
@@ -5812,7 +5854,7 @@
     var DisplayNames = Intl.DisplayNames;
 
     if (!DisplayNames) {
-      onError(new FormatError("Intl.DisplayNames is not available in this environment.\nTry polyfilling it using \"@formatjs/intl-displaynames\"\n", 2
+      onError(new FormatError("Intl.DisplayNames is not available in this environment.\nTry polyfilling it using \"@formatjs/intl-displaynames\"\n", "MISSING_INTL_API"
       /* MISSING_INTL_API */
       ));
     }