intl-messageformat 7.8.4 → 8.2.1

package/lib/core.d.ts

@@ -1,5 +1,5 @@
 import { parse, MessageFormatElement } from 'intl-messageformat-parser';
-import { FormatterCache, Formatters, Formats, FormatXMLElementFn, PrimitiveType, MessageFormatPart } from './formatters';
+import { FormatterCache, Formatters, Formats, FormatXMLElementFn, MessageFormatPart } from './formatters';
 export interface Options {
     formatters?: Formatters;
 }
@@ -12,9 +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: (values?: Record<string, PrimitiveType> | undefined) => string;
-    formatToParts: (values?: Record<string, any> | undefined) => MessageFormatPart[];
-    formatHTMLMessage: (values?: Record<string, string | number | boolean | object | Date | FormatXMLElementFn | null | undefined> | undefined) => (string | object)[];
+    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>[];
     resolvedOptions: () => {
         locale: string;
     };

package/lib/core.js

@@ -16,7 +16,7 @@ var __assign = (this && this.__assign) || function () {
 };
 import { parse } from 'intl-messageformat-parser';
 import memoizeIntlConstructor from 'intl-format-cache';
-import { formatToString, formatToParts, formatHTMLMessage, } from './formatters';
+import { formatToParts, } from './formatters';
 // -- MessageFormat --------------------------------------------------------
 function mergeConfig(c1, c2) {
     if (!c2) {
@@ -58,14 +58,30 @@ var IntlMessageFormat = /** @class */ (function () {
             pluralRules: {},
         };
         this.format = function (values) {
-            return formatToString(_this.ast, _this.locales, _this.formatters, _this.formats, values, _this.message);
+            var parts = _this.formatToParts(values);
+            // Hot path for straight simple msg translations
+            if (parts.length === 1) {
+                return parts[0].value;
+            }
+            var result = parts.reduce(function (all, part) {
+                if (!all.length ||
+                    part.type !== 0 /* literal */ ||
+                    typeof all[all.length - 1] !== 'string') {
+                    all.push(part.value);
+                }
+                else {
+                    all[all.length - 1] += part.value;
+                }
+                return all;
+            }, []);
+            if (result.length <= 1) {
+                return result[0] || '';
+            }
+            return result;
         };
         this.formatToParts = function (values) {
             return formatToParts(_this.ast, _this.locales, _this.formatters, _this.formats, values, undefined, _this.message);
         };
-        this.formatHTMLMessage = function (values) {
-            return formatHTMLMessage(_this.ast, _this.locales, _this.formatters, _this.formats, values, _this.message);
-        };
         this.resolvedOptions = function () { return ({
             locale: Intl.NumberFormat.supportedLocalesOf(_this.locales)[0],
         }); };

package/lib/error.d.ts

@@ -0,0 +1,16 @@
+export declare const enum ErrorCode {
+    MISSING_VALUE = 0,
+    INVALID_VALUE = 1,
+    MISSING_INTL_API = 2
+}
+export declare class FormatError extends Error {
+    readonly code: ErrorCode;
+    constructor(msg: string, code: ErrorCode);
+    toString(): string;
+}
+export declare class InvalidValueError extends FormatError {
+    constructor(variableId: string, value: any, options: string[]);
+}
+export declare class MissingValueError extends FormatError {
+    constructor(variableId: string, originalMessage?: string);
+}

package/lib/error.js

@@ -0,0 +1,42 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var FormatError = /** @class */ (function (_super) {
+    __extends(FormatError, _super);
+    function FormatError(msg, code) {
+        var _this = _super.call(this, msg) || this;
+        _this.code = code;
+        return _this;
+    }
+    FormatError.prototype.toString = function () {
+        return "[formatjs Error: " + this.code + "] " + this.message;
+    };
+    return FormatError;
+}(Error));
+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;
+    }
+    return InvalidValueError;
+}(FormatError));
+export { InvalidValueError };
+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 MissingValueError;
+}(FormatError));
+export { MissingValueError };

package/lib/formatters.d.ts

@@ -16,19 +16,17 @@ export interface Formatters {
 }
 export declare const enum PART_TYPE {
     literal = 0,
-    argument = 1
+    object = 1
 }
 export interface LiteralPart {
     type: PART_TYPE.literal;
     value: string;
 }
-export interface ArgumentPart {
-    type: PART_TYPE.argument;
-    value: any;
+export interface ObjectPart<T = any> {
+    type: PART_TYPE.object;
+    value: T;
 }
-export declare type MessageFormatPart = LiteralPart | ArgumentPart;
+export declare type MessageFormatPart<T> = LiteralPart | ObjectPart<T>;
 export declare type PrimitiveType = string | number | boolean | null | undefined | Date;
-export declare function formatToParts(els: MessageFormatElement[], locales: string | string[], formatters: Formatters, formats: Formats, values?: Record<string, any>, currentPluralValue?: number, originalMessage?: string): MessageFormatPart[];
-export declare function formatToString(els: MessageFormatElement[], locales: string | string[], formatters: Formatters, formats: Formats, values?: Record<string, PrimitiveType>, originalMessage?: string): string;
-export declare type FormatXMLElementFn = (...args: any[]) => string | object;
-export declare function formatHTMLMessage(els: MessageFormatElement[], locales: string | string[], formatters: Formatters, formats: Formats, values?: Record<string, PrimitiveType | object | FormatXMLElementFn>, originalMessage?: string): Array<string | object>;
+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>;

package/lib/formatters.js

@@ -1,33 +1,5 @@
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __spreadArrays = (this && this.__spreadArrays) || function () {
-    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
-    for (var r = Array(s), k = 0, i = 0; i < il; i++)
-        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
-            r[k] = a[j];
-    return r;
-};
-import { convertNumberSkeletonToNumberFormatOptions, isArgumentElement, isDateElement, isDateTimeSkeleton, isLiteralElement, isNumberElement, isNumberSkeleton, isPluralElement, isPoundElement, isSelectElement, isTimeElement, parseDateTimeSkeleton, } from 'intl-messageformat-parser';
-var FormatError = /** @class */ (function (_super) {
-    __extends(FormatError, _super);
-    function FormatError(msg, variableId) {
-        var _this = _super.call(this, msg) || this;
-        _this.variableId = variableId;
-        return _this;
-    }
-    return FormatError;
-}(Error));
+import { convertNumberSkeletonToNumberFormatOptions, isArgumentElement, isDateElement, isDateTimeSkeleton, isLiteralElement, isNumberElement, isNumberSkeleton, isPluralElement, isPoundElement, isSelectElement, isTimeElement, parseDateTimeSkeleton, isTagElement, } from 'intl-messageformat-parser';
+import { MissingValueError, InvalidValueError, FormatError, } from './error';
 function mergeLiteral(parts) {
     if (parts.length < 2) {
         return parts;
@@ -45,6 +17,9 @@ function mergeLiteral(parts) {
         return all;
     }, []);
 }
+function isFormatXMLElementFn(el) {
+    return typeof el === 'function';
+}
 // TODO(skeleton): add skeleton support
 export function formatToParts(els, locales, formatters, formats, values, currentPluralValue, 
 // For debugging
@@ -83,7 +58,7 @@ originalMessage) {
         var varName = el.value;
         // Enforce that all required values are provided by the caller.
         if (!(values && varName in values)) {
-            throw new FormatError("The intl string context variable \"" + varName + "\" was not provided to the string \"" + originalMessage + "\"");
+            throw new MissingValueError(varName, originalMessage);
         }
         var value = values[varName];
         if (isArgumentElement(el)) {
@@ -94,7 +69,7 @@ originalMessage) {
                         : '';
             }
             result.push({
-                type: 1 /* argument */,
+                type: typeof value === 'string' ? 0 /* literal */ : 1 /* object */,
                 value: value,
             });
             continue;
@@ -140,10 +115,28 @@ originalMessage) {
             });
             continue;
         }
+        if (isTagElement(el)) {
+            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");
+            }
+            var parts = formatToParts(children, locales, formatters, formats, values);
+            var chunks = formatFn.apply(void 0, parts.map(function (p) { return p.value; }));
+            if (!Array.isArray(chunks)) {
+                chunks = [chunks];
+            }
+            result.push.apply(result, chunks.map(function (c) {
+                return {
+                    type: typeof c === 'string' ? 0 /* literal */ : 1 /* object */,
+                    value: c,
+                };
+            }));
+        }
         if (isSelectElement(el)) {
             var opt = el.options[value] || el.options.other;
             if (!opt) {
-                throw new RangeError("Invalid values for \"" + el.value + "\": \"" + value + "\". Options are \"" + Object.keys(el.options).join('", "') + "\"");
+                throw new InvalidValueError(el.value, value, Object.keys(el.options));
             }
             result.push.apply(result, formatToParts(opt.value, locales, formatters, formats, values));
             continue;
@@ -152,7 +145,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");
+                    throw new FormatError("Intl.PluralRules is not available in this environment.\nTry polyfilling it using \"@formatjs/intl-pluralrules\"\n", 2 /* MISSING_INTL_API */);
                 }
                 var rule = formatters
                     .getPluralRules(locales, { type: el.pluralType })
@@ -160,7 +153,7 @@ originalMessage) {
                 opt = el.options[rule] || el.options.other;
             }
             if (!opt) {
-                throw new RangeError("Invalid values for \"" + el.value + "\": \"" + value + "\". Options are \"" + Object.keys(el.options).join('", "') + "\"");
+                throw new InvalidValueError(el.value, value, Object.keys(el.options));
             }
             result.push.apply(result, formatToParts(opt.value, locales, formatters, formats, values, value - (el.offset || 0)));
             continue;
@@ -168,136 +161,3 @@ originalMessage) {
     }
     return mergeLiteral(result);
 }
-export function formatToString(els, locales, formatters, formats, values, 
-// For debugging
-originalMessage) {
-    var parts = formatToParts(els, locales, formatters, formats, values, undefined, originalMessage);
-    // Hot path for straight simple msg translations
-    if (parts.length === 1) {
-        return parts[0].value;
-    }
-    return parts.reduce(function (all, part) { return (all += part.value); }, '');
-}
-// Singleton
-var domParser;
-var TOKEN_DELIMITER = '@@';
-var TOKEN_REGEX = /@@(\d+_\d+)@@/g;
-var counter = 0;
-function generateId() {
-    return Date.now() + "_" + ++counter;
-}
-function restoreRichPlaceholderMessage(text, objectParts) {
-    return text
-        .split(TOKEN_REGEX)
-        .filter(Boolean)
-        .map(function (c) { return (objectParts[c] != null ? objectParts[c] : c); })
-        .reduce(function (all, c) {
-        if (!all.length) {
-            all.push(c);
-        }
-        else if (typeof c === 'string' &&
-            typeof all[all.length - 1] === 'string') {
-            all[all.length - 1] += c;
-        }
-        else {
-            all.push(c);
-        }
-        return all;
-    }, []);
-}
-/**
- * Not exhaustive, just for sanity check
- */
-var SIMPLE_XML_REGEX = /(<([0-9a-zA-Z-_]*?)>(.*?)<\/([0-9a-zA-Z-_]*?)>)|(<[0-9a-zA-Z-_]*?\/>)/;
-var TEMPLATE_ID = Date.now() + '@@';
-var VOID_ELEMENTS = [
-    'area',
-    'base',
-    'br',
-    'col',
-    'embed',
-    'hr',
-    'img',
-    'input',
-    'link',
-    'meta',
-    'param',
-    'source',
-    'track',
-    'wbr',
-];
-function formatHTMLElement(el, objectParts, values) {
-    var tagName = el.tagName;
-    var outerHTML = el.outerHTML, textContent = el.textContent, childNodes = el.childNodes;
-    // Regular text
-    if (!tagName) {
-        return restoreRichPlaceholderMessage(textContent || '', objectParts);
-    }
-    tagName = tagName.toLowerCase();
-    var isVoidElement = ~VOID_ELEMENTS.indexOf(tagName);
-    var formatFnOrValue = values[tagName];
-    if (formatFnOrValue && isVoidElement) {
-        throw new FormatError(tagName + " is a self-closing tag and can not be used, please use another tag name.");
-    }
-    if (!childNodes.length) {
-        return [outerHTML];
-    }
-    var chunks = Array.prototype.slice.call(childNodes).reduce(function (all, child) {
-        return all.concat(formatHTMLElement(child, objectParts, values));
-    }, []);
-    // Legacy HTML
-    if (!formatFnOrValue) {
-        return __spreadArrays(["<" + tagName + ">"], chunks, ["</" + tagName + ">"]);
-    }
-    // HTML Tag replacement
-    if (typeof formatFnOrValue === 'function') {
-        return [formatFnOrValue.apply(void 0, chunks)];
-    }
-    return [formatFnOrValue];
-}
-export function formatHTMLMessage(els, locales, formatters, formats, values, 
-// For debugging
-originalMessage) {
-    var parts = formatToParts(els, locales, formatters, formats, values, undefined, originalMessage);
-    var objectParts = {};
-    var formattedMessage = parts.reduce(function (all, part) {
-        if (part.type === 0 /* literal */) {
-            return (all += part.value);
-        }
-        var id = generateId();
-        objectParts[id] = part.value;
-        return (all += "" + TOKEN_DELIMITER + id + TOKEN_DELIMITER);
-    }, '');
-    // Not designed to filter out aggressively
-    if (!SIMPLE_XML_REGEX.test(formattedMessage)) {
-        return restoreRichPlaceholderMessage(formattedMessage, objectParts);
-    }
-    if (!values) {
-        throw new FormatError('Message has placeholders but no values was given');
-    }
-    if (typeof DOMParser === 'undefined') {
-        throw new FormatError('Cannot format XML message without DOMParser');
-    }
-    if (!domParser) {
-        domParser = new DOMParser();
-    }
-    var content = domParser
-        .parseFromString("<formatted-message id=\"" + TEMPLATE_ID + "\">" + formattedMessage + "</formatted-message>", 'text/html')
-        .getElementById(TEMPLATE_ID);
-    if (!content) {
-        throw new FormatError("Malformed HTML message " + formattedMessage);
-    }
-    var tagsToFormat = Object.keys(values).filter(function (varName) { return !!content.getElementsByTagName(varName).length; });
-    // No tags to format
-    if (!tagsToFormat.length) {
-        return restoreRichPlaceholderMessage(formattedMessage, objectParts);
-    }
-    var caseSensitiveTags = tagsToFormat.filter(function (tagName) { return tagName !== tagName.toLowerCase(); });
-    if (caseSensitiveTags.length) {
-        throw new FormatError("HTML tag must be lowercased but the following tags are not: " + caseSensitiveTags.join(', '));
-    }
-    // We're doing this since top node is `<formatted-message/>` which does not have a formatter
-    return Array.prototype.slice
-        .call(content.childNodes)
-        .reduce(function (all, child) { return all.concat(formatHTMLElement(child, objectParts, values)); }, []);
-}

package/lib/index.d.ts

@@ -1,4 +1,5 @@
 import IntlMessageFormat from './core';
 export * from './formatters';
 export * from './core';
+export * from './error';
 export default IntlMessageFormat;

package/lib/index.js

@@ -6,4 +6,5 @@ See the accompanying LICENSE file for terms.
 import IntlMessageFormat from './core';
 export * from './formatters';
 export * from './core';
+export * from './error';
 export default IntlMessageFormat;

package/lib/intl-messageformat.d.ts

@@ -1,14 +1,19 @@
 import { MessageFormatElement } from 'intl-messageformat-parser';
 import { parse } from 'intl-messageformat-parser';
 
-export declare interface ArgumentPart {
-    type: PART_TYPE.argument;
-    value: any;
-}
-
 export declare function createDefaultFormatters(cache?: FormatterCache): Formatters;
 
-export declare function formatHTMLMessage(els: MessageFormatElement[], locales: string | string[], formatters: Formatters, formats: Formats, values?: Record<string, PrimitiveType | object | FormatXMLElementFn>, originalMessage?: string): Array<string | object>;
+export declare const enum ErrorCode {
+    MISSING_VALUE = 0,
+    INVALID_VALUE = 1,
+    MISSING_INTL_API = 2
+}
+
+export declare class FormatError extends Error {
+    readonly code: ErrorCode;
+    constructor(msg: string, code: ErrorCode);
+    toString(): string;
+}
 
 export declare interface Formats {
     number: Record<string, Intl.NumberFormatOptions>;
@@ -28,11 +33,9 @@ export declare interface Formatters {
     getPluralRules(...args: ConstructorParameters<typeof Intl.PluralRules>): Intl.PluralRules;
 }
 
-export declare function formatToParts(els: MessageFormatElement[], locales: string | string[], formatters: Formatters, formats: Formats, values?: Record<string, any>, currentPluralValue?: number, originalMessage?: string): MessageFormatPart[];
-
-export declare function formatToString(els: MessageFormatElement[], locales: string | string[], formatters: Formatters, formats: Formats, values?: Record<string, PrimitiveType>, originalMessage?: string): string;
+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 = (...args: any[]) => string | object;
+export declare type FormatXMLElementFn<T> = (...args: Array<string | T>) => string | Array<string | T>;
 
 declare class IntlMessageFormat {
     private readonly ast;
@@ -42,9 +45,8 @@ declare class IntlMessageFormat {
     private readonly message;
     private readonly formatterCache;
     constructor(message: string | MessageFormatElement[], locales?: string | string[], overrideFormats?: Partial<Formats>, opts?: Options);
-    format: (values?: Record<string, PrimitiveType> | undefined) => string;
-    formatToParts: (values?: Record<string, any> | undefined) => MessageFormatPart[];
-    formatHTMLMessage: (values?: Record<string, string | number | boolean | object | Date | FormatXMLElementFn | null | undefined> | undefined) => (string | object)[];
+    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>[];
     resolvedOptions: () => {
         locale: string;
     };
@@ -111,12 +113,25 @@ declare class IntlMessageFormat {
 export { IntlMessageFormat }
 export default IntlMessageFormat;
 
+export declare class InvalidValueError extends FormatError {
+    constructor(variableId: string, value: any, options: string[]);
+}
+
 export declare interface LiteralPart {
     type: PART_TYPE.literal;
     value: string;
 }
 
-export declare type MessageFormatPart = LiteralPart | ArgumentPart;
+export declare type MessageFormatPart<T> = LiteralPart | ObjectPart<T>;
+
+export declare class MissingValueError extends FormatError {
+    constructor(variableId: string, originalMessage?: string);
+}
+
+export declare interface ObjectPart<T = any> {
+    type: PART_TYPE.object;
+    value: T;
+}
 
 export declare interface Options {
     formatters?: Formatters;
@@ -124,7 +139,7 @@ export declare interface Options {
 
 export declare const enum PART_TYPE {
     literal = 0,
-    argument = 1
+    object = 1
 }
 
 export declare type PrimitiveType = string | number | boolean | null | undefined | Date;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "intl-messageformat",
-  "version": "7.8.4",
+  "version": "8.2.1",
   "description": "Formats ICU Message strings with number, date, plural, and select placeholders to create localized messages.",
   "keywords": [
     "i18n",
@@ -32,7 +32,7 @@
   "types": "lib/intl-messageformat.d.ts",
   "dependencies": {
     "intl-format-cache": "^4.2.21",
-    "intl-messageformat-parser": "^3.6.4"
+    "intl-messageformat-parser": "^4.1.0"
   },
   "files": [
     "dist",
@@ -58,5 +58,5 @@
     "test": "tests"
   },
   "license": "BSD-3-Clause",
-  "gitHead": "a7842673d8ad205171ad7c8cb8bb2f318b427c0c"
+  "gitHead": "e0bb34c71e99fd4c68244f3bc668c748b2f18413"
 }

package/src/core.ts

@@ -10,12 +10,11 @@ import {
   FormatterCache,
   Formatters,
   Formats,
-  formatToString,
   formatToParts,
   FormatXMLElementFn,
-  formatHTMLMessage,
   PrimitiveType,
   MessageFormatPart,
+  PART_TYPE,
 } from './formatters';
 
 // -- MessageFormat --------------------------------------------------------
@@ -122,17 +121,35 @@ export class IntlMessageFormat {
       (opts && opts.formatters) || createDefaultFormatters(this.formatterCache);
   }
 
-  format = (values?: Record<string, PrimitiveType>) =>
-    formatToString(
-      this.ast,
-      this.locales,
-      this.formatters,
-      this.formats,
-      values,
-      this.message
-    );
+  format = <T = void>(
+    values?: Record<string, PrimitiveType | T | FormatXMLElementFn<T>>
+  ) => {
+    const parts = this.formatToParts(values);
+    // Hot path for straight simple msg translations
+    if (parts.length === 1) {
+      return parts[0].value;
+    }
+    const result = parts.reduce((all, part) => {
+      if (
+        !all.length ||
+        part.type !== PART_TYPE.literal ||
+        typeof all[all.length - 1] !== 'string'
+      ) {
+        all.push(part.value);
+      } else {
+        all[all.length - 1] += part.value;
+      }
+      return all;
+    }, [] as Array<string | T>);
 
-  formatToParts = (values?: Record<string, any>): MessageFormatPart[] =>
+    if (result.length <= 1) {
+      return result[0] || '';
+    }
+    return result;
+  };
+  formatToParts = <T>(
+    values?: Record<string, PrimitiveType | T | FormatXMLElementFn<T>>
+  ): MessageFormatPart<T>[] =>
     formatToParts(
       this.ast,
       this.locales,
@@ -142,18 +159,6 @@ export class IntlMessageFormat {
       undefined,
       this.message
     );
-  formatHTMLMessage = (
-    values?: Record<string, PrimitiveType | object | FormatXMLElementFn>
-  ) =>
-    formatHTMLMessage(
-      this.ast,
-      this.locales,
-      this.formatters,
-      this.formats,
-      values,
-      this.message
-    );
-
   resolvedOptions = () => ({
     locale: Intl.NumberFormat.supportedLocalesOf(this.locales)[0],
   });

package/src/error.ts

@@ -0,0 +1,39 @@
+export const enum ErrorCode {
+  // When we have a placeholder but no value to format
+  MISSING_VALUE,
+  // When value supplied is invalid
+  INVALID_VALUE,
+  // When we need specific Intl API but it's not available
+  MISSING_INTL_API,
+}
+
+export class FormatError extends Error {
+  public readonly code: ErrorCode;
+  constructor(msg: string, code: ErrorCode) {
+    super(msg);
+    this.code = code;
+  }
+  public toString() {
+    return `[formatjs Error: ${this.code}] ${this.message}`;
+  }
+}
+
+export class InvalidValueError extends FormatError {
+  constructor(variableId: string, value: any, options: string[]) {
+    super(
+      `Invalid values for "${variableId}": "${value}". Options are "${Object.keys(
+        options
+      ).join('", "')}"`,
+      ErrorCode.INVALID_VALUE
+    );
+  }
+}
+
+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
+    );
+  }
+}