@discord/intl 0.7.1 → 0.8.0-rc.1

package/dist/formatters/react.js

@@ -34,7 +34,13 @@ function createReactBuilder(richTextElements) {
             this.result.push(richTextElements[tag](children, `${this._nodeKey++}`));
         }
         pushLiteralText(text) {
-            this.result.push(text);
+            const last = this.result[this.result.length - 1];
+            if (typeof last === 'string') {
+                this.result[this.result.length - 1] += text;
+            }
+            else {
+                this.result.push(text);
+            }
         }
         pushObject(value) {
             // @ts-expect-error this is technically invalid, but we'll just assume that if a format returns

package/dist/intl-manager.d.ts

@@ -46,7 +46,7 @@ export declare class IntlManager {
      * For static messages with no rich text and no dynamic placeholders, use this method to
      * immediately return the plain string value of the message in the current locale.
      */
-    string<T extends TypedIntlMessageGetter<undefined>>(message: T): string;
+    string<T extends TypedIntlMessageGetter<{}>>(message: T): string;
     /**
      * Return a raw string representing the syntax of the original message, as
      * authored, with no values replaced. The result of this function could be

package/dist/intl-manager.js

@@ -71,17 +71,15 @@ class IntlManager {
         const resolved = message(this.currentLocale);
         if (resolved == null || resolved.ast.length === 0)
             return '';
-        const value = resolved.ast[0];
-        if (typeof value !== 'string') {
-            throw new Error('Attempted to call `string` formatting on a non-literal message: ' +
-                JSON.stringify(resolved));
+        let result = '';
+        for (const element of resolved.ast) {
+            if (typeof element !== 'string') {
+                throw new Error('Attempted to call `string` formatting on a non-literal message: ' +
+                    JSON.stringify(resolved));
+            }
+            result += element;
         }
-        // TODO: Figure out how to make this typing exact. This currently relies on
-        // the generic typing being sound enough to know that the message can only
-        // contain a single static text node and no placeholders or rich text.
-        // As it stands, this is _technically_ typed as string | undefined, even though
-        // TypeScript doesn't actually complain about it.
-        return value;
+        return result;
     }
     /**
      * Return a raw string representing the syntax of the original message, as

package/dist/types.d.ts

@@ -49,11 +49,10 @@ export interface IntlMessageGetter extends IntlMessageGetterAdditions {
 /**
  * Getter function that retrieves a message that best matches the requested
  * locale. `FormatValues` represents either an object containing all of the
- * value types that are required to format the message, or `undefined` to
- * represent that there are no values required and the message is a plain
- * string.
+ * value types that are required to format the message, or `{}` to represent
+ * that there are no values required and the message is a plain string.
  */
-export interface TypedIntlMessageGetter<FormatValues extends object | undefined>
+export interface TypedIntlMessageGetter<FormatValues extends object>
   extends IntlMessageGetterAdditions {
   // TODO: This is lossy and unfortunate that typing can't be propagated
   // to the returned message type, but doing so causes problems with
@@ -94,11 +93,7 @@ export interface TypedIntlMessageGetter<FormatValues extends object | undefined>
    * downstream will ensure that all format values are always checked for all
    * possible cases of the message.
    */
-  __phantom: object extends FormatValues
-    ? any
-    : FormatValues extends undefined
-      ? any
-      : keyof FormatValues;
+  __phantom: object extends FormatValues ? any : {} extends FormatValues ? any : keyof FormatValues;
 }
 
 /**
@@ -145,7 +140,7 @@ type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
  * If T is a union of message types including both rich messages requiring
  * values _and_ plain string messages with no values, this type will still
  * properly resolve all of the required values, assuming that the getters for
- * the plain messages use the convention of passing `undefined` as the generic
+ * the plain messages use the convention of passing `{}` as the generic
  * argument, representing "no values should be passed for this message".
  *
  *
@@ -173,13 +168,13 @@ export type FormatValuesFor<T> =
   // be supplied, represented by the `never`. This prevents accidentally
   // passing an object, even an empty one, for those strings, and allows the
   // formatter to optimize a little more on each call.
-  [T] extends [undefined]
+  [{}] extends [T]
     ? never
     : // The `never` condition needs to be repeated here, but this time _without_
       // the `[]` syntax, so that only the union elements with actual values are
       // included in the union. Without this, the `infer U` on the latter side
       // fails to resolve and the type just becomes `never`.
-      UnionToIntersection<T extends undefined ? never : T>;
+      UnionToIntersection<{} extends T ? never : T>;
 
 /**
  * A template type for replaceable placeholder types to be defined by formatter
@@ -254,7 +249,7 @@ export type RequiredFormatValues<
   Values extends IntlMessageGetter,
   FunctionTypes extends FunctionTypeMap,
 > =
-  IntlMessageGetterInnerType<Values> extends undefined
+  {} extends IntlMessageGetterInnerType<Values>
     ? {}
     : CheckStrictAny<
         IntlMessageGetterInnerType<Values>,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@discord/intl",
-  "version": "0.7.1",
+  "version": "0.8.0-rc.1",
   "license": "MIT",
   "description": "Client runtime for managing messages and translations in a React project.",
   "main": "./dist/index.js",
@@ -19,7 +19,7 @@
     "@formatjs/intl": "^2.10.1",
     "@intrnl/xxhash64": "^0.1.2",
     "intl-messageformat": "^10.5.11",
-    "@discord/intl-ast": "0.7.1"
+    "@discord/intl-ast": "0.8.0-rc.1"
   },
   "devDependencies": {
     "@swc/cli": "^0.3.12",

package/src/formatters/react.ts

@@ -56,7 +56,12 @@ function createReactBuilder(richTextElements: RichTextFormattingMap<ReactFunctio
     }
 
     pushLiteralText(text: string) {
-      this.result.push(text);
+      const last = this.result[this.result.length - 1];
+      if (typeof last === 'string') {
+        this.result[this.result.length - 1] += text;
+      } else {
+        this.result.push(text);
+      }
     }
 
     pushObject(value: object) {

package/src/intl-manager.ts

@@ -116,24 +116,21 @@ export class IntlManager {
    * For static messages with no rich text and no dynamic placeholders, use this method to
    * immediately return the plain string value of the message in the current locale.
    */
-  string<T extends TypedIntlMessageGetter<undefined>>(message: T): string {
+  string<T extends TypedIntlMessageGetter<{}>>(message: T): string {
     const resolved = message(this.currentLocale);
     if (resolved == null || resolved.ast.length === 0) return '';
 
-    const value = resolved.ast[0] as LiteralNode;
-    if (typeof value !== 'string') {
-      throw new Error(
-        'Attempted to call `string` formatting on a non-literal message: ' +
-          JSON.stringify(resolved),
-      );
+    let result = '';
+    for (const element of resolved.ast) {
+      if (typeof element !== 'string') {
+        throw new Error(
+          'Attempted to call `string` formatting on a non-literal message: ' +
+            JSON.stringify(resolved),
+        );
+      }
+      result += element;
     }
-
-    // TODO: Figure out how to make this typing exact. This currently relies on
-    // the generic typing being sound enough to know that the message can only
-    // contain a single static text node and no placeholders or rich text.
-    // As it stands, this is _technically_ typed as string | undefined, even though
-    // TypeScript doesn't actually complain about it.
-    return value;
+    return result;
   }
 
   /**

package/src/types.d.ts

@@ -49,11 +49,10 @@ export interface IntlMessageGetter extends IntlMessageGetterAdditions {
 /**
  * Getter function that retrieves a message that best matches the requested
  * locale. `FormatValues` represents either an object containing all of the
- * value types that are required to format the message, or `undefined` to
- * represent that there are no values required and the message is a plain
- * string.
+ * value types that are required to format the message, or `{}` to represent
+ * that there are no values required and the message is a plain string.
  */
-export interface TypedIntlMessageGetter<FormatValues extends object | undefined>
+export interface TypedIntlMessageGetter<FormatValues extends object>
   extends IntlMessageGetterAdditions {
   // TODO: This is lossy and unfortunate that typing can't be propagated
   // to the returned message type, but doing so causes problems with
@@ -94,11 +93,7 @@ export interface TypedIntlMessageGetter<FormatValues extends object | undefined>
    * downstream will ensure that all format values are always checked for all
    * possible cases of the message.
    */
-  __phantom: object extends FormatValues
-    ? any
-    : FormatValues extends undefined
-      ? any
-      : keyof FormatValues;
+  __phantom: object extends FormatValues ? any : {} extends FormatValues ? any : keyof FormatValues;
 }
 
 /**
@@ -145,7 +140,7 @@ type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
  * If T is a union of message types including both rich messages requiring
  * values _and_ plain string messages with no values, this type will still
  * properly resolve all of the required values, assuming that the getters for
- * the plain messages use the convention of passing `undefined` as the generic
+ * the plain messages use the convention of passing `{}` as the generic
  * argument, representing "no values should be passed for this message".
  *
  *
@@ -173,13 +168,13 @@ export type FormatValuesFor<T> =
   // be supplied, represented by the `never`. This prevents accidentally
   // passing an object, even an empty one, for those strings, and allows the
   // formatter to optimize a little more on each call.
-  [T] extends [undefined]
+  [{}] extends [T]
     ? never
     : // The `never` condition needs to be repeated here, but this time _without_
       // the `[]` syntax, so that only the union elements with actual values are
       // included in the union. Without this, the `infer U` on the latter side
       // fails to resolve and the type just becomes `never`.
-      UnionToIntersection<T extends undefined ? never : T>;
+      UnionToIntersection<{} extends T ? never : T>;
 
 /**
  * A template type for replaceable placeholder types to be defined by formatter
@@ -254,7 +249,7 @@ export type RequiredFormatValues<
   Values extends IntlMessageGetter,
   FunctionTypes extends FunctionTypeMap,
 > =
-  IntlMessageGetterInnerType<Values> extends undefined
+  {} extends IntlMessageGetterInnerType<Values>
     ? {}
     : CheckStrictAny<
         IntlMessageGetterInnerType<Values>,