@discord/intl-ast 0.7.0 → 0.7.1

package/dist/index.d.ts

@@ -9,7 +9,7 @@ export declare enum FormatJsNodeType {
     Pound = 7,
     Tag = 8
 }
-export type LiteralNode = [string];
+export type LiteralNode = string;
 export type ArgumentNode = [FormatJsNodeType.Argument, string];
 export type NumberNode = [FormatJsNodeType.Number, string, string | undefined];
 export type DateNode = [FormatJsNodeType.Date, string, string | undefined];

package/dist/index.js

@@ -37,8 +37,9 @@ var AstNodeIndices;
 exports.FORMAT_JS_POUND = Object.freeze({ type: 7 });
 function hydrateArray(elements) {
     for (let i = 0; i < elements.length; i++) {
-        elements[i] = hydrateFormatJsAst(elements[i]);
+        elements[i] = hydrateSingle(elements[i]);
     }
+    return true;
 }
 function hydratePlural(keyless) {
     const [type, value, options, offset, pluralType] = keyless;
@@ -49,29 +50,24 @@ function hydratePlural(keyless) {
     // This saves multiple allocations compared to building a new object
     // from scratch, either for the whole options object or for each value.
     for (const key in options) {
-        hydrateArray(options[key].value);
+        hydrateArray(options[key]);
+        options[key] = { value: options[key] };
     }
-    const valueOptions = options.map((option) => ({ value: option }));
     // `pluralType` is technically only valid on `Plural` nodes, even
     // though the structure is identical to `Select`.
     if (type === FormatJsNodeType.Plural) {
-        return {
-            type,
-            value,
-            options,
-            offset: valueOptions,
-            pluralType,
-        };
+        return { type, value, options, offset, pluralType };
     }
     else {
-        return { type, value, options: valueOptions, offset };
+        return { type, value, options, offset };
     }
 }
 function hydrateSingle(keyless) {
+    if (typeof keyless === 'string') {
+        return { type: 0, value: keyless };
+    }
     const [type] = keyless;
     switch (type) {
-        case FormatJsNodeType.Literal:
-            return { type: 0, value: keyless[0] };
         case FormatJsNodeType.Argument:
             return { type, value: keyless[1] };
         case FormatJsNodeType.Number:
@@ -93,18 +89,24 @@ function hydrateSingle(keyless) {
     }
 }
 function hydrateFormatJsAst(keyless) {
-    // If the first element of the array is itself an array, then we have a list
-    // of elements to parse rather than a single object.
-    if (Array.isArray(keyless[0])) {
+    // If the first element of the array is a string, then we _do_ have an array of elements, but the
+    // first one is a literal node.
+    if (typeof keyless[0] === 'string') {
         hydrateArray(keyless);
         return keyless;
     }
-    else if (keyless.length === 0) {
+    if (keyless.length === 0) {
         // Some entries can be empty arrays, like an empty set of children, and those can
         // be preserved.
         return keyless;
     }
-    return hydrateSingle(keyless);
+    // If the first element is otherwise not an array, then it must be a
+    // type identifier for a single node.
+    if (!Array.isArray(keyless[0])) {
+        return hydrateSingle(keyless);
+    }
+    hydrateArray(keyless);
+    return keyless;
 }
 function compressFormatJsToAst(node) {
     if (Array.isArray(node)) {
@@ -112,7 +114,7 @@ function compressFormatJsToAst(node) {
     }
     switch (node.type) {
         case FormatJsNodeType.Literal:
-            return [node.value];
+            return node.value;
         case FormatJsNodeType.Argument:
             return [node.type, node.value];
         case FormatJsNodeType.Number:
@@ -143,7 +145,7 @@ function isCompressedAst(node) {
     // Not an array at all means this is a singular fully-typed node.
     if (!Array.isArray(node))
         return false;
-    // Otherwise just check the first element. If it's an array, then the ast is compressed as
-    // keyless.
-    return Array.isArray(node[0]);
+    // Otherwise just check the first element. If it's an array or a direct string, then the ast is
+    // compressed as keyless.
+    return Array.isArray(node[0]) || typeof node[0] === 'string';
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@discord/intl-ast",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "license": "MIT",
   "description": "Types and utilities for working with the ICU+Markdown AST format from @discord/intl",
   "main": "./dist/index.js",