intl-messageformat 8.2.1 → 8.3.2

package/lib/core.d.ts

@@ -12,8 +12,8 @@ export declare class IntlMessageFormat {
     private readonly message;
     private readonly formatterCache;
     constructor(message: string | MessageFormatElement[], locales?: string | string[], overrideFormats?: Partial<Formats>, opts?: Options);
-    format: <T = void>(values?: Record<string, string | number | boolean | Date | T | FormatXMLElementFn<T> | null | undefined> | undefined) => string | T | (string | T)[];
-    formatToParts: <T>(values?: Record<string, string | number | boolean | Date | T | FormatXMLElementFn<T> | null | undefined> | undefined) => MessageFormatPart<T>[];
+    format: <T = void>(values?: Record<string, string | number | boolean | Date | T | FormatXMLElementFn<T, string | (string | T)[]> | null | undefined> | undefined) => string | T | (string | T)[];
+    formatToParts: <T>(values?: Record<string, string | number | boolean | Date | T | FormatXMLElementFn<T, string | (string | T)[]> | null | undefined> | undefined) => MessageFormatPart<T>[];
     resolvedOptions: () => {
         locale: string;
     };

package/lib/error.d.ts

@@ -1,15 +1,26 @@
 export declare const enum ErrorCode {
-    MISSING_VALUE = 0,
-    INVALID_VALUE = 1,
-    MISSING_INTL_API = 2
+    MISSING_VALUE = "MISSING_VALUE",
+    INVALID_VALUE = "INVALID_VALUE",
+    MISSING_INTL_API = "MISSING_INTL_API"
 }
 export declare class FormatError extends Error {
     readonly code: ErrorCode;
-    constructor(msg: string, code: ErrorCode);
+    /**
+     * Original message we're trying to format
+     * `undefined` if we're only dealing w/ AST
+     *
+     * @type {(string | undefined)}
+     * @memberof FormatError
+     */
+    readonly originalMessage: string | undefined;
+    constructor(msg: string, code: ErrorCode, originalMessage?: string);
     toString(): string;
 }
 export declare class InvalidValueError extends FormatError {
-    constructor(variableId: string, value: any, options: string[]);
+    constructor(variableId: string, value: any, options: string[], originalMessage?: string);
+}
+export declare class InvalidValueTypeError extends FormatError {
+    constructor(value: any, type: string, originalMessage?: string);
 }
 export declare class MissingValueError extends FormatError {
     constructor(variableId: string, originalMessage?: string);

package/lib/error.js

@@ -11,11 +11,21 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
+export 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(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;
     }
     FormatError.prototype.toString = function () {
@@ -26,16 +36,24 @@ var FormatError = /** @class */ (function (_super) {
 export { FormatError };
 var InvalidValueError = /** @class */ (function (_super) {
     __extends(InvalidValueError, _super);
-    function InvalidValueError(variableId, value, options) {
-        return _super.call(this, "Invalid values for \"" + variableId + "\": \"" + value + "\". Options are \"" + Object.keys(options).join('", "') + "\"", 1 /* INVALID_VALUE */) || this;
+    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 */, originalMessage) || this;
     }
     return InvalidValueError;
 }(FormatError));
 export { InvalidValueError };
+var InvalidValueTypeError = /** @class */ (function (_super) {
+    __extends(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));
+export { InvalidValueTypeError };
 var MissingValueError = /** @class */ (function (_super) {
     __extends(MissingValueError, _super);
     function MissingValueError(variableId, originalMessage) {
-        return _super.call(this, "The intl string context variable \"" + variableId + "\" was not provided to the string \"" + originalMessage + "\"", 0 /* MISSING_VALUE */) || this;
+        return _super.call(this, "The intl string context variable \"" + variableId + "\" was not provided to the string \"" + originalMessage + "\"", "MISSING_VALUE" /* MISSING_VALUE */, originalMessage) || this;
     }
     return MissingValueError;
 }(FormatError));

package/lib/formatters.d.ts

@@ -29,4 +29,4 @@ export interface ObjectPart<T = any> {
 export declare type MessageFormatPart<T> = LiteralPart | ObjectPart<T>;
 export declare type PrimitiveType = string | number | boolean | null | undefined | Date;
 export declare function formatToParts<T>(els: MessageFormatElement[], locales: string | string[], formatters: Formatters, formats: Formats, values?: Record<string, PrimitiveType | T | FormatXMLElementFn<T>>, currentPluralValue?: number, originalMessage?: string): MessageFormatPart<T>[];
-export declare type FormatXMLElementFn<T> = (...args: Array<string | T>) => string | Array<string | T>;
+export declare type FormatXMLElementFn<T, R = string | Array<string | T>> = (...args: Array<string | T>) => R;

package/lib/formatters.js

@@ -1,5 +1,10 @@
 import { convertNumberSkeletonToNumberFormatOptions, isArgumentElement, isDateElement, isDateTimeSkeleton, isLiteralElement, isNumberElement, isNumberSkeleton, isPluralElement, isPoundElement, isSelectElement, isTimeElement, parseDateTimeSkeleton, isTagElement, } from 'intl-messageformat-parser';
-import { MissingValueError, InvalidValueError, FormatError, } from './error';
+import { MissingValueError, InvalidValueError, FormatError, InvalidValueTypeError, } from './error';
+export 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;
@@ -119,7 +124,7 @@ originalMessage) {
             var children = el.children, value_1 = el.value;
             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);
             var chunks = formatFn.apply(void 0, parts.map(function (p) { return p.value; }));
@@ -136,7 +141,7 @@ originalMessage) {
         if (isSelectElement(el)) {
             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));
             continue;
@@ -145,7 +150,7 @@ originalMessage) {
             var opt = el.options["=" + value];
             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 /* MISSING_INTL_API */);
+                    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, { type: el.pluralType })
@@ -153,7 +158,7 @@ originalMessage) {
                 opt = el.options[rule] || 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, value - (el.offset || 0)));
             continue;

package/lib/intl-messageformat.d.ts

@@ -4,14 +4,22 @@ import { parse } from 'intl-messageformat-parser';
 export declare function createDefaultFormatters(cache?: FormatterCache): Formatters;
 
 export declare const enum ErrorCode {
-    MISSING_VALUE = 0,
-    INVALID_VALUE = 1,
-    MISSING_INTL_API = 2
+    MISSING_VALUE = "MISSING_VALUE",
+    INVALID_VALUE = "INVALID_VALUE",
+    MISSING_INTL_API = "MISSING_INTL_API"
 }
 
 export declare class FormatError extends Error {
     readonly code: ErrorCode;
-    constructor(msg: string, code: ErrorCode);
+    /**
+     * Original message we're trying to format
+     * `undefined` if we're only dealing w/ AST
+     *
+     * @type {(string | undefined)}
+     * @memberof FormatError
+     */
+    readonly originalMessage: string | undefined;
+    constructor(msg: string, code: ErrorCode, originalMessage?: string);
     toString(): string;
 }
 
@@ -35,7 +43,7 @@ export declare interface Formatters {
 
 export declare function formatToParts<T>(els: MessageFormatElement[], locales: string | string[], formatters: Formatters, formats: Formats, values?: Record<string, PrimitiveType | T | FormatXMLElementFn<T>>, currentPluralValue?: number, originalMessage?: string): MessageFormatPart<T>[];
 
-export declare type FormatXMLElementFn<T> = (...args: Array<string | T>) => string | Array<string | T>;
+export declare type FormatXMLElementFn<T, R = string | Array<string | T>> = (...args: Array<string | T>) => R;
 
 declare class IntlMessageFormat {
     private readonly ast;
@@ -45,8 +53,8 @@ declare class IntlMessageFormat {
     private readonly message;
     private readonly formatterCache;
     constructor(message: string | MessageFormatElement[], locales?: string | string[], overrideFormats?: Partial<Formats>, opts?: Options);
-    format: <T = void>(values?: Record<string, string | number | boolean | Date | T | FormatXMLElementFn<T> | null | undefined> | undefined) => string | T | (string | T)[];
-    formatToParts: <T>(values?: Record<string, string | number | boolean | Date | T | FormatXMLElementFn<T> | null | undefined> | undefined) => MessageFormatPart<T>[];
+    format: <T = void>(values?: Record<string, string | number | boolean | Date | T | FormatXMLElementFn<T, string | (string | T)[]> | null | undefined> | undefined) => string | T | (string | T)[];
+    formatToParts: <T>(values?: Record<string, string | number | boolean | Date | T | FormatXMLElementFn<T, string | (string | T)[]> | null | undefined> | undefined) => MessageFormatPart<T>[];
     resolvedOptions: () => {
         locale: string;
     };
@@ -114,7 +122,11 @@ export { IntlMessageFormat }
 export default IntlMessageFormat;
 
 export declare class InvalidValueError extends FormatError {
-    constructor(variableId: string, value: any, options: string[]);
+    constructor(variableId: string, value: any, options: string[], originalMessage?: string);
+}
+
+export declare class InvalidValueTypeError extends FormatError {
+    constructor(value: any, type: string, originalMessage?: string);
 }
 
 export declare interface LiteralPart {

package/lib/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.7.0"
+      "packageVersion": "7.7.8"
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "intl-messageformat",
-  "version": "8.2.1",
+  "version": "8.3.2",
   "description": "Formats ICU Message strings with number, date, plural, and select placeholders to create localized messages.",
   "keywords": [
     "i18n",
@@ -31,8 +31,8 @@
   "module": "lib/index.js",
   "types": "lib/intl-messageformat.d.ts",
   "dependencies": {
-    "intl-format-cache": "^4.2.21",
-    "intl-messageformat-parser": "^4.1.0"
+    "intl-format-cache": "^4.2.22",
+    "intl-messageformat-parser": "^4.1.1"
   },
   "files": [
     "dist",
@@ -40,7 +40,7 @@
     "src"
   ],
   "devDependencies": {
-    "@formatjs/intl-pluralrules": "^1.5.2"
+    "@formatjs/intl-pluralrules": "^1.5.3"
   },
   "sideEffects": false,
   "scripts": {
@@ -58,5 +58,5 @@
     "test": "tests"
   },
   "license": "BSD-3-Clause",
-  "gitHead": "e0bb34c71e99fd4c68244f3bc668c748b2f18413"
+  "gitHead": "33528f6975bd231fdf8635726892c98499326109"
 }

package/src/error.ts

@@ -1,17 +1,26 @@
 export const enum ErrorCode {
   // When we have a placeholder but no value to format
-  MISSING_VALUE,
+  MISSING_VALUE = 'MISSING_VALUE',
   // When value supplied is invalid
-  INVALID_VALUE,
+  INVALID_VALUE = 'INVALID_VALUE',
   // When we need specific Intl API but it's not available
-  MISSING_INTL_API,
+  MISSING_INTL_API = 'MISSING_INTL_API',
 }
 
 export class FormatError extends Error {
   public readonly code: ErrorCode;
-  constructor(msg: string, code: ErrorCode) {
+  /**
+   * Original message we're trying to format
+   * `undefined` if we're only dealing w/ AST
+   *
+   * @type {(string | undefined)}
+   * @memberof FormatError
+   */
+  public readonly originalMessage: string | undefined;
+  constructor(msg: string, code: ErrorCode, originalMessage?: string) {
     super(msg);
     this.code = code;
+    this.originalMessage = originalMessage;
   }
   public toString() {
     return `[formatjs Error: ${this.code}] ${this.message}`;
@@ -19,12 +28,28 @@ export class FormatError extends Error {
 }
 
 export class InvalidValueError extends FormatError {
-  constructor(variableId: string, value: any, options: string[]) {
+  constructor(
+    variableId: string,
+    value: any,
+    options: string[],
+    originalMessage?: string
+  ) {
     super(
       `Invalid values for "${variableId}": "${value}". Options are "${Object.keys(
         options
       ).join('", "')}"`,
-      ErrorCode.INVALID_VALUE
+      ErrorCode.INVALID_VALUE,
+      originalMessage
+    );
+  }
+}
+
+export class InvalidValueTypeError extends FormatError {
+  constructor(value: any, type: string, originalMessage?: string) {
+    super(
+      `Value for "${value}" must be of type ${type}`,
+      ErrorCode.INVALID_VALUE,
+      originalMessage
     );
   }
 }
@@ -33,7 +58,8 @@ export class MissingValueError extends FormatError {
   constructor(variableId: string, originalMessage?: string) {
     super(
       `The intl string context variable "${variableId}" was not provided to the string "${originalMessage}"`,
-      ErrorCode.MISSING_VALUE
+      ErrorCode.MISSING_VALUE,
+      originalMessage
     );
   }
 }

package/src/formatters.ts

@@ -19,6 +19,7 @@ import {
   InvalidValueError,
   ErrorCode,
   FormatError,
+  InvalidValueTypeError,
 } from './error';
 
 export interface Formats {
@@ -203,7 +204,7 @@ export function formatToParts<T>(
       const {children, value} = el;
       const formatFn = values[value];
       if (!isFormatXMLElementFn<T>(formatFn)) {
-        throw new TypeError(`Value for "${value}" must be a function`);
+        throw new InvalidValueTypeError(value, 'function', originalMessage);
       }
       const parts = formatToParts<T>(
         children,
@@ -231,7 +232,12 @@ export function formatToParts<T>(
     if (isSelectElement(el)) {
       const opt = el.options[value as string] || 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(
         ...formatToParts(opt.value, locales, formatters, formats, values)
@@ -246,7 +252,8 @@ export function formatToParts<T>(
             `Intl.PluralRules is not available in this environment.
 Try polyfilling it using "@formatjs/intl-pluralrules"
 `,
-            ErrorCode.MISSING_INTL_API
+            ErrorCode.MISSING_INTL_API,
+            originalMessage
           );
         }
         const rule = formatters
@@ -255,7 +262,12 @@ Try polyfilling it using "@formatjs/intl-pluralrules"
         opt = el.options[rule] || 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(
         ...formatToParts(
@@ -273,6 +285,6 @@ Try polyfilling it using "@formatjs/intl-pluralrules"
   return mergeLiteral(result);
 }
 
-export type FormatXMLElementFn<T> = (
+export type FormatXMLElementFn<T, R = string | Array<string | T>> = (
   ...args: Array<string | T>
-) => string | Array<string | T>;
+) => R;