@discord/intl 0.5.2 → 0.6.0

package/dist/message.js

@@ -1,186 +1,127 @@
 "use strict";
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InternalIntlMessage = void 0;
-var keyless_json_1 = require("./keyless-json");
-var InternalIntlMessage = /** @class */ (function () {
-    function InternalIntlMessage(messageOrAst, locale) {
+const intl_ast_1 = require("@discord/intl-ast");
+class InternalIntlMessage {
+    constructor(messageOrAst, locale) {
         this.locale = locale;
-        this.ast = messageOrAst;
+        this.ast = (0, intl_ast_1.isCompressedAst)(messageOrAst) ? messageOrAst : (0, intl_ast_1.compressFormatJsToAst)(messageOrAst);
     }
     /**
      * Return a stringified serialization of this message's AST, with no
      * formatting or values applied.
      */
-    InternalIntlMessage.prototype.reserialize = function () {
-        var result = { value: '' };
-        serializeFormatJsAst(this.ast, result);
+    reserialize() {
+        const result = { value: '' };
+        serializeAst(this.ast, result);
         return result.value;
-    };
-    return InternalIntlMessage;
-}());
+    }
+}
 exports.InternalIntlMessage = InternalIntlMessage;
 // Accepting an object as the `result` parameter lets the same string get passed around and
 // appended, rather than creating a bunch of intermediate strings.
-function serializeFormatJsAst(ast, result) {
-    var e_1, _a, e_2, _b, e_3, _c;
-    try {
-        for (var ast_1 = __values(ast), ast_1_1 = ast_1.next(); !ast_1_1.done; ast_1_1 = ast_1.next()) {
-            var node = ast_1_1.value;
-            switch (node.type) {
-                case keyless_json_1.FormatJsNodeType.Literal:
-                    result.value += node.value;
+function serializeAst(ast, result) {
+    for (const node of ast) {
+        switch (node[intl_ast_1.AstNodeIndices.Type]) {
+            case intl_ast_1.FormatJsNodeType.Literal:
+                result.value += node[intl_ast_1.AstNodeIndices.Value];
+                return;
+            case intl_ast_1.FormatJsNodeType.Argument:
+                // Empties are an artifact of our parsing strategy, not necessary here.
+                if (result.value === '$_')
                     return;
-                case keyless_json_1.FormatJsNodeType.Argument:
-                    // Empties are an artifact of our parsing strategy, not necessary here.
-                    if (result.value === '$_')
-                        return;
-                    result.value += '{' + node.value + '}';
-                    return;
-                case keyless_json_1.FormatJsNodeType.Date:
-                    result.value += '{' + node.value + ', date';
-                    if (node.style != null) {
-                        result.value += ', ' + node.style;
-                    }
-                    result.value += '}';
-                    return;
-                case keyless_json_1.FormatJsNodeType.Time:
-                    result.value += '{' + node.value + ', time';
-                    if (node.style != null) {
-                        result.value += ', ' + node.style;
-                    }
-                    result.value += '}';
-                    return;
-                case keyless_json_1.FormatJsNodeType.Number:
-                    result.value += '{' + node.value + ', number';
-                    if (node.style != null) {
-                        result.value += ', ' + node.style;
-                    }
+                result.value += '{' + node[intl_ast_1.AstNodeIndices.Value] + '}';
+                return;
+            case intl_ast_1.FormatJsNodeType.Date:
+                result.value += '{' + node[intl_ast_1.AstNodeIndices.Value] + ', date';
+                if (node[intl_ast_1.AstNodeIndices.Style] != null) {
+                    result.value += ', ' + node[intl_ast_1.AstNodeIndices.Style];
+                }
+                result.value += '}';
+                return;
+            case intl_ast_1.FormatJsNodeType.Time:
+                result.value += '{' + node[intl_ast_1.AstNodeIndices.Value] + ', time';
+                if (node[intl_ast_1.AstNodeIndices.Style] != null) {
+                    result.value += ', ' + node[intl_ast_1.AstNodeIndices.Style];
+                }
+                result.value += '}';
+                return;
+            case intl_ast_1.FormatJsNodeType.Number:
+                result.value += '{' + node[intl_ast_1.AstNodeIndices.Value] + ', number';
+                if (node[intl_ast_1.AstNodeIndices.Style] != null) {
+                    result.value += ', ' + node[intl_ast_1.AstNodeIndices.Style];
+                }
+                result.value += '}';
+                return;
+            case intl_ast_1.FormatJsNodeType.Plural: {
+                const pluralType = node[intl_ast_1.AstNodeIndices.PluralType] == 'ordinal' ? 'selectordinal' : 'plural';
+                result.value += '{' + node[intl_ast_1.AstNodeIndices.Value] + ', ' + pluralType + ', ';
+                if (node[intl_ast_1.AstNodeIndices.Offset]) {
+                    result.value += 'offset:' + node[intl_ast_1.AstNodeIndices.Offset];
+                }
+                for (const [name, arm] of Object.entries(node[intl_ast_1.AstNodeIndices.Options])) {
+                    result.value += ' ' + name + ' {';
+                    serializeAst(arm.value, result);
                     result.value += '}';
-                    return;
-                case keyless_json_1.FormatJsNodeType.Plural: {
-                    var pluralType = node.pluralType == 'ordinal' ? 'selectordinal' : 'plural';
-                    result.value += '{' + node.value + ', ' + pluralType + ', ';
-                    if (node.offset) {
-                        result.value += 'offset:' + node.offset;
-                    }
-                    try {
-                        for (var _d = (e_2 = void 0, __values(Object.entries(node.options))), _e = _d.next(); !_e.done; _e = _d.next()) {
-                            var _f = __read(_e.value, 2), name = _f[0], arm = _f[1];
-                            result.value += ' ' + name + ' {';
-                            serializeFormatJsAst(arm.value, result);
-                            result.value += '}';
-                        }
-                    }
-                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                    finally {
-                        try {
-                            if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
-                        }
-                        finally { if (e_2) throw e_2.error; }
-                    }
-                    return;
                 }
-                case keyless_json_1.FormatJsNodeType.Pound:
-                    result.value += '#';
-                    return;
-                case keyless_json_1.FormatJsNodeType.Select: {
-                    result.value += '{' + node.value + ', select, ';
-                    try {
-                        for (var _g = (e_3 = void 0, __values(Object.entries(node.options))), _h = _g.next(); !_h.done; _h = _g.next()) {
-                            var _j = __read(_h.value, 2), name = _j[0], arm = _j[1];
-                            result.value += ' ' + name + ' {';
-                            serializeFormatJsAst(arm.value, result);
-                            result.value += '}';
-                        }
-                    }
-                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                    finally {
-                        try {
-                            if (_h && !_h.done && (_c = _g.return)) _c.call(_g);
-                        }
-                        finally { if (e_3) throw e_3.error; }
-                    }
-                    return;
+                return;
+            }
+            case intl_ast_1.FormatJsNodeType.Pound:
+                result.value += '#';
+                return;
+            case intl_ast_1.FormatJsNodeType.Select: {
+                result.value += '{' + node[intl_ast_1.AstNodeIndices.Value] + ', select, ';
+                for (const [name, arm] of Object.entries(node[intl_ast_1.AstNodeIndices.Options])) {
+                    result.value += ' ' + name + ' {';
+                    serializeAst(arm.value, result);
+                    result.value += '}';
                 }
-                case keyless_json_1.FormatJsNodeType.Tag:
-                    serializeFormatJsTag(node, result);
-                    return;
+                return;
             }
+            case intl_ast_1.FormatJsNodeType.Tag:
+                serializeAstTag(node, result);
+                return;
         }
     }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (ast_1_1 && !ast_1_1.done && (_a = ast_1.return)) _a.call(ast_1);
-        }
-        finally { if (e_1) throw e_1.error; }
-    }
 }
-function serializeFormatJsTag(node, result) {
-    switch (node.value) {
+function serializeAstTag(node, result) {
+    switch (node[intl_ast_1.AstNodeIndices.Value]) {
         case '$b':
             result.value += '**';
-            serializeFormatJsAst(node.children, result);
+            serializeAst(node[intl_ast_1.AstNodeIndices.Children], result);
             result.value += '**';
             return;
         case '$i':
             result.value += '*';
-            serializeFormatJsAst(node.children, result);
+            serializeAst(node[intl_ast_1.AstNodeIndices.Children], result);
             result.value += '*';
             return;
         case '$code':
             result.value += '`';
-            serializeFormatJsAst(node.children, result);
+            serializeAst(node[intl_ast_1.AstNodeIndices.Children], result);
             result.value += '`';
             return;
         case '$p':
-            serializeFormatJsAst(node.children, result);
+            serializeAst(node[intl_ast_1.AstNodeIndices.Children], result);
             result.value += '\n\n';
             return;
         case '$link':
             // The target is the first child of the link. We don't have to care if it's a placeholder
             // or not, because the serialization will automatically remove the extra empty.
-            var _a = __read(node.children), target = _a[0], children = _a.slice(1);
+            const [target, ...children] = node[intl_ast_1.AstNodeIndices.Children];
             result.value += '[';
-            serializeFormatJsAst(children, result);
+            serializeAst(children, result);
             result.value += '](';
             if (target != null) {
-                serializeFormatJsAst([target], result);
+                serializeAst([target], result);
             }
             result.value += ')';
             return;
         default:
             // Any other tag name is a hook, which just adds the `$[` on a link tag.
             result.value += '$[';
-            serializeFormatJsAst(node.children, result);
-            result.value += '](' + node.value + ')';
+            serializeAst(node[intl_ast_1.AstNodeIndices.Children], result);
+            result.value += '](' + node[intl_ast_1.AstNodeIndices.Value] + ')';
             return;
     }
 }

package/package.json

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

package/src/format.ts

@@ -23,7 +23,7 @@ import {
   parseNumberSkeletonFromString,
 } from '@formatjs/icu-skeleton-parser';
 
-import { FormatJsNode, FormatJsNodeType } from './keyless-json';
+import { AstNode, AstNodeIndices, FormatJsNodeType } from '@discord/intl-ast';
 import { Formatters, MissingValueError } from 'intl-messageformat';
 import type { FormatConfig } from './format-config';
 import type { RichTextTagNames } from './types';
@@ -47,7 +47,7 @@ export type FormatBuilderConstructor<Result> = new () => FormatBuilder<Result>;
 
 export function bindFormatValuesWithBuilder<T, Builder extends FormatBuilder<T>>(
   builder: Builder,
-  nodes: FormatJsNode[],
+  nodes: AstNode[],
   locales: string | string[],
   formatters: Formatters,
   formatConfig: FormatConfig,
@@ -56,15 +56,16 @@ export function bindFormatValuesWithBuilder<T, Builder extends FormatBuilder<T>>
   originalMessage?: string,
 ) {
   // Hot path for static messages that are just parsed as a single string element.
-  if (nodes.length === 1 && nodes[0].type === FormatJsNodeType.Literal) {
-    builder.pushLiteralText(nodes[0].value);
+  if (nodes.length === 1 && nodes[0][AstNodeIndices.Type] === FormatJsNodeType.Literal) {
+    builder.pushLiteralText(nodes[0][AstNodeIndices.Value]);
     return;
   }
 
   for (const node of nodes) {
-    switch (node.type) {
+    const nodeType = node[AstNodeIndices.Type];
+    switch (nodeType) {
       case FormatJsNodeType.Literal:
-        builder.pushLiteralText(node.value);
+        builder.pushLiteralText(node[AstNodeIndices.Value]);
         continue;
 
       case FormatJsNodeType.Pound:
@@ -78,7 +79,7 @@ export function bindFormatValuesWithBuilder<T, Builder extends FormatBuilder<T>>
         continue;
     }
 
-    const { value: variableName } = node;
+    const variableName = node[AstNodeIndices.Value];
     // Enforce that all required values are provided by the caller, even if the
     // actual value is falsy/undefined.
     if (!(variableName in values) && !isRichTextTag(variableName)) {
@@ -86,8 +87,7 @@ export function bindFormatValuesWithBuilder<T, Builder extends FormatBuilder<T>>
     }
 
     const value = values[variableName];
-
-    switch (node.type) {
+    switch (nodeType) {
       case FormatJsNodeType.Argument:
         // Empty values don't need to be added at all, they are purely for AST representation.
         if (variableName == '$_') break;
@@ -101,26 +101,28 @@ export function bindFormatValuesWithBuilder<T, Builder extends FormatBuilder<T>>
         }
         break;
       case FormatJsNodeType.Date: {
+        const nodeStyle = node[AstNodeIndices.Style];
         // Distinct from FormatJS: We don't currently parse the skeleton ahead of time in the AST,
         // so this manages parsing the skeleton as well before passing it onto the date formatter.
         const style =
-          node.style in formatConfig.date
-            ? formatConfig.date[node.style]
-            : node.style != null
-              ? parseDateTimeSkeleton(node.style)
+          nodeStyle in formatConfig.date
+            ? formatConfig.date[nodeStyle]
+            : nodeStyle != null
+              ? parseDateTimeSkeleton(nodeStyle)
               : formatConfig.time.medium;
         // @ts-expect-error Cast string values to dates properly.
         builder.pushLiteralText(formatters.getDateTimeFormat(locales, style).format(value));
         break;
       }
       case FormatJsNodeType.Time: {
+        const nodeStyle = node[AstNodeIndices.Style];
         // Distinct from FormatJS: We don't currently parse the skeleton ahead of time in the AST,
         // so this manages parsing the skeleton as well before passing it onto the date formatter.
         const style =
-          node.style in formatConfig.time
-            ? formatConfig.time[node.style]
-            : node.style != null
-              ? parseDateTimeSkeleton(node.style)
+          nodeStyle in formatConfig.time
+            ? formatConfig.time[nodeStyle]
+            : nodeStyle != null
+              ? parseDateTimeSkeleton(nodeStyle)
               : undefined; // TODO: parseSkeleton();
         builder.pushLiteralText(
           // @ts-expect-error Cast string values to dates properly.
@@ -129,13 +131,14 @@ export function bindFormatValuesWithBuilder<T, Builder extends FormatBuilder<T>>
         break;
       }
       case FormatJsNodeType.Number: {
+        const nodeStyle = node[AstNodeIndices.Style];
         // Distinct from FormatJS: We don't currently parse the skeleton ahead of time in the AST,
         // so this manages parsing the skeleton as well before passing it onto the date formatter.
         const style =
-          node.style in formatConfig.number
-            ? formatConfig.number[node.style]
-            : node.style != null
-              ? parseNumberSkeleton(parseNumberSkeletonFromString(node.style))
+          nodeStyle in formatConfig.number
+            ? formatConfig.number[nodeStyle]
+            : nodeStyle != null
+              ? parseNumberSkeleton(parseNumberSkeletonFromString(nodeStyle))
               : undefined;
         const scaledValue =
           // @ts-expect-error This is a weird cast that's not accurate, but works in the short term.
@@ -145,7 +148,7 @@ export function bindFormatValuesWithBuilder<T, Builder extends FormatBuilder<T>>
       }
 
       case FormatJsNodeType.Tag: {
-        const { children } = node;
+        const children = node[AstNodeIndices.Children];
         const appliedChildren = bindFormatValues(
           builder.constructor as FormatBuilderConstructor<T>,
           children,
@@ -175,9 +178,11 @@ export function bindFormatValuesWithBuilder<T, Builder extends FormatBuilder<T>>
       }
 
       case FormatJsNodeType.Select: {
-        const option = node.value in node.options ? node.options[node.value] : node.options.other;
+        const value = node[AstNodeIndices.Value];
+        const options = node[AstNodeIndices.Options];
+        const option = value in options ? options[value] : options.other;
         if (option == null) {
-          throw `${node.value} is not a known option for select value ${variableName}. Valid options are ${Object.keys(node.options).join(', ')}`;
+          throw `${value} is not a known option for select value ${variableName}. Valid options are ${Object.keys(options).join(', ')}`;
         }
         bindFormatValuesWithBuilder(
           builder,
@@ -191,18 +196,22 @@ export function bindFormatValuesWithBuilder<T, Builder extends FormatBuilder<T>>
       }
 
       case FormatJsNodeType.Plural: {
+        const value = node[AstNodeIndices.Value];
+        const options = node[AstNodeIndices.Options];
+        const offset = node[AstNodeIndices.Offset];
+        const pluralType = node[AstNodeIndices.PluralType];
         const option = (() => {
           const exactSelector = `=${value}`;
-          if (exactSelector in node.options) return node.options[exactSelector];
+          if (exactSelector in options) return options[exactSelector];
           const rule = formatters
-            .getPluralRules(locales, { type: node.pluralType })
+            .getPluralRules(locales, { type: pluralType })
             // @ts-expect-error Assert this `as number` properly.
-            .select((value as number) - (node.offset ?? 0));
-          return node.options[rule] ?? node.options.other;
+            .select((value as number) - (offset ?? 0));
+          return options[rule] ?? options.other;
         })();
 
         if (option == null) {
-          throw `${node.value} is not a known option for plural value ${variableName}. Valid options are ${Object.keys(node.options).join(', ')}`;
+          throw `${value} is not a known option for plural value ${variableName}. Valid options are ${Object.keys(options).join(', ')}`;
         }
         bindFormatValuesWithBuilder(
           builder,
@@ -222,7 +231,7 @@ export function bindFormatValuesWithBuilder<T, Builder extends FormatBuilder<T>>
 
 export function bindFormatValues<Result>(
   Builder: FormatBuilderConstructor<Result>,
-  nodes: FormatJsNode[],
+  nodes: AstNode[],
   locales: string | string[],
   formatters: Formatters,
   formatConfig: FormatConfig,

package/src/intl-manager.ts

@@ -1,3 +1,4 @@
+import { AstNodeIndices } from '@discord/intl-ast';
 import { createIntl, IntlShape } from '@formatjs/intl';
 import { Formatters } from 'intl-messageformat';
 
@@ -9,7 +10,6 @@ import type {
 } from './types';
 import { InternalIntlMessage } from './message';
 import { bindFormatValues, FormatBuilderConstructor } from './format';
-import { FormatJsLiteral } from './keyless-json';
 import { DEFAULT_FORMAT_CONFIG, FormatConfig } from './format-config';
 
 /**
@@ -123,7 +123,9 @@ export class IntlManager {
     // 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.
-    return (resolved.ast[0] as FormatJsLiteral).value;
+    // As it stands, this is _technically_ typed as string | undefined, even though
+    // TypeScript doesn't actually complain about it.
+    return resolved.ast[0][AstNodeIndices.Value];
   }
 
   /**

package/src/message-loader.ts

@@ -1,7 +1,13 @@
-import { FormatJsNode } from './keyless-json';
+import { AstNode, FullFormatJsNode } from '@discord/intl-ast';
 import { InternalIntlMessage } from './message';
 
-type MessagesData = Record<string, FormatJsNode[]>;
+/**
+ * Type representing the serialized content of a translations file, which is a record of hashed
+ * message keys to their AST structure. This type represents both compressed, keyless AstNodes as
+ * well as fully-typed, object FullFormatJsNodes as the message content, since either can be given
+ * depending on the configuration of the bundler/compiler.
+ */
+type MessagesData = Record<string, AstNode[] | FullFormatJsNode[]>;
 export interface IntlMessageGetterAdditions {
   onChange(callback: () => void): () => void;
 }