@discord/intl 0.5.2 → 0.6.1

package/src/message.ts

@@ -1,12 +1,20 @@
-import { FormatJsNode, FormatJsNodeType, FormatJsTag } from './keyless-json';
+import {
+  AstNode,
+  FullFormatJsNode,
+  FormatJsNodeType,
+  compressFormatJsToAst,
+  isCompressedAst,
+  AstNodeIndices,
+  TagNode,
+} from '@discord/intl-ast';
 
 export class InternalIntlMessage {
   locale: string;
-  ast: FormatJsNode[];
+  ast: AstNode[];
 
-  constructor(messageOrAst: FormatJsNode[], locale: string) {
+  constructor(messageOrAst: AstNode[] | FullFormatJsNode[], locale: string) {
     this.locale = locale;
-    this.ast = messageOrAst;
+    this.ast = isCompressedAst(messageOrAst) ? messageOrAst : compressFormatJsToAst(messageOrAst);
   }
 
   /**
@@ -15,54 +23,55 @@ export class InternalIntlMessage {
    */
   reserialize(): string {
     const result = { value: '' };
-    serializeFormatJsAst(this.ast, result);
+    serializeAst(this.ast, result);
     return result.value;
   }
 }
 
 // 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: FormatJsNode[], result: { value: string }) {
+function serializeAst(ast: AstNode[], result: { value: string }) {
   for (const node of ast) {
-    switch (node.type) {
+    switch (node[AstNodeIndices.Type]) {
       case FormatJsNodeType.Literal:
-        result.value += node.value;
+        result.value += node[AstNodeIndices.Value];
         return;
       case FormatJsNodeType.Argument:
         // Empties are an artifact of our parsing strategy, not necessary here.
         if (result.value === '$_') return;
-        result.value += '{' + node.value + '}';
+        result.value += '{' + node[AstNodeIndices.Value] + '}';
         return;
       case FormatJsNodeType.Date:
-        result.value += '{' + node.value + ', date';
-        if (node.style != null) {
-          result.value += ', ' + node.style;
+        result.value += '{' + node[AstNodeIndices.Value] + ', date';
+        if (node[AstNodeIndices.Style] != null) {
+          result.value += ', ' + node[AstNodeIndices.Style];
         }
         result.value += '}';
         return;
       case FormatJsNodeType.Time:
-        result.value += '{' + node.value + ', time';
-        if (node.style != null) {
-          result.value += ', ' + node.style;
+        result.value += '{' + node[AstNodeIndices.Value] + ', time';
+        if (node[AstNodeIndices.Style] != null) {
+          result.value += ', ' + node[AstNodeIndices.Style];
         }
         result.value += '}';
         return;
       case FormatJsNodeType.Number:
-        result.value += '{' + node.value + ', number';
-        if (node.style != null) {
-          result.value += ', ' + node.style;
+        result.value += '{' + node[AstNodeIndices.Value] + ', number';
+        if (node[AstNodeIndices.Style] != null) {
+          result.value += ', ' + node[AstNodeIndices.Style];
         }
         result.value += '}';
         return;
       case FormatJsNodeType.Plural: {
-        const pluralType = node.pluralType == 'ordinal' ? 'selectordinal' : 'plural';
-        result.value += '{' + node.value + ', ' + pluralType + ', ';
-        if (node.offset) {
-          result.value += 'offset:' + node.offset;
+        const pluralType =
+          node[AstNodeIndices.PluralType] == 'ordinal' ? 'selectordinal' : 'plural';
+        result.value += '{' + node[AstNodeIndices.Value] + ', ' + pluralType + ', ';
+        if (node[AstNodeIndices.Offset]) {
+          result.value += 'offset:' + node[AstNodeIndices.Offset];
         }
-        for (const [name, arm] of Object.entries(node.options)) {
+        for (const [name, arm] of Object.entries(node[AstNodeIndices.Options])) {
           result.value += ' ' + name + ' {';
-          serializeFormatJsAst(arm.value, result);
+          serializeAst(arm.value, result);
           result.value += '}';
         }
         return;
@@ -71,59 +80,59 @@ function serializeFormatJsAst(ast: FormatJsNode[], result: { value: string }) {
         result.value += '#';
         return;
       case FormatJsNodeType.Select: {
-        result.value += '{' + node.value + ', select, ';
-        for (const [name, arm] of Object.entries(node.options)) {
+        result.value += '{' + node[AstNodeIndices.Value] + ', select, ';
+        for (const [name, arm] of Object.entries(node[AstNodeIndices.Options])) {
           result.value += ' ' + name + ' {';
-          serializeFormatJsAst(arm.value, result);
+          serializeAst(arm.value, result);
           result.value += '}';
         }
         return;
       }
       case FormatJsNodeType.Tag:
-        serializeFormatJsTag(node, result);
+        serializeAstTag(node, result);
         return;
     }
   }
 }
 
-function serializeFormatJsTag(node: FormatJsTag, result: { value: string }) {
-  switch (node.value) {
+function serializeAstTag(node: TagNode, result: { value: string }) {
+  switch (node[AstNodeIndices.Value]) {
     case '$b':
       result.value += '**';
-      serializeFormatJsAst(node.children, result);
+      serializeAst(node[AstNodeIndices.Children], result);
       result.value += '**';
       return;
     case '$i':
       result.value += '*';
-      serializeFormatJsAst(node.children, result);
+      serializeAst(node[AstNodeIndices.Children], result);
       result.value += '*';
       return;
     case '$code':
       result.value += '`';
-      serializeFormatJsAst(node.children, result);
+      serializeAst(node[AstNodeIndices.Children], result);
       result.value += '`';
       return;
     case '$p':
-      serializeFormatJsAst(node.children, result);
+      serializeAst(node[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.
-      const [target, ...children] = node.children;
+      const [target, ...children] = node[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[AstNodeIndices.Children], result);
+      result.value += '](' + node[AstNodeIndices.Value] + ')';
       return;
   }
 }

package/dist/keyless-json.d.ts

@@ -1,68 +0,0 @@
-export declare enum FormatJsNodeType {
-    Literal = 0,
-    Argument = 1,
-    Number = 2,
-    Date = 3,
-    Time = 4,
-    Select = 5,
-    Plural = 6,
-    Pound = 7,
-    Tag = 8
-}
-export interface FormatJsLiteral {
-    type: FormatJsNodeType.Literal;
-    value: string;
-}
-export interface FormatJsArgument {
-    type: FormatJsNodeType.Argument;
-    value: string;
-}
-export interface FormatJsNumber {
-    type: FormatJsNodeType.Number;
-    value: string;
-    style?: string;
-}
-export interface FormatJsDate {
-    type: FormatJsNodeType.Date;
-    value: string;
-    style?: string;
-}
-export interface FormatJsTime {
-    type: FormatJsNodeType.Time;
-    value: string;
-    style?: string;
-}
-export interface FormatJsSelect {
-    type: FormatJsNodeType.Select;
-    value: string;
-    options: Record<string, {
-        value: FormatJsNode[];
-    }>;
-}
-export type FormatJsPluralType = 'cardinal' | 'ordinal';
-export interface FormatJsPlural {
-    type: FormatJsNodeType.Plural;
-    value: string;
-    options: Record<string, {
-        value: FormatJsNode[];
-    }>;
-    offset: number;
-    pluralType: FormatJsPluralType;
-}
-export interface FormatJsPound {
-    type: FormatJsNodeType.Pound;
-}
-export interface FormatJsTag {
-    type: FormatJsNodeType.Tag;
-    value: string;
-    children: FormatJsNode[];
-}
-export type FormatJsNode = FormatJsLiteral | FormatJsArgument | FormatJsNumber | FormatJsDate | FormatJsTime | FormatJsSelect | FormatJsPlural | FormatJsPound | FormatJsTag;
-export declare const FORMAT_JS_POUND: FormatJsPound;
-/**
- * Hydrate the given keyless JSON into a FormatJS-compatible AST structure.
- * The given object is reused as much as possible, meaning it cannot be safely
- * used again after hydrating.
- */
-export declare function hydrateFormatJsAst(keyless: Array<Array<any>>): FormatJsNode[];
-export declare function hydrateMessages(messages: Record<string, any>): Record<string, any>;

package/dist/keyless-json.js

@@ -1,107 +0,0 @@
-"use strict";
-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.FORMAT_JS_POUND = exports.FormatJsNodeType = void 0;
-exports.hydrateFormatJsAst = hydrateFormatJsAst;
-exports.hydrateMessages = hydrateMessages;
-var FormatJsNodeType;
-(function (FormatJsNodeType) {
-    FormatJsNodeType[FormatJsNodeType["Literal"] = 0] = "Literal";
-    FormatJsNodeType[FormatJsNodeType["Argument"] = 1] = "Argument";
-    FormatJsNodeType[FormatJsNodeType["Number"] = 2] = "Number";
-    FormatJsNodeType[FormatJsNodeType["Date"] = 3] = "Date";
-    FormatJsNodeType[FormatJsNodeType["Time"] = 4] = "Time";
-    FormatJsNodeType[FormatJsNodeType["Select"] = 5] = "Select";
-    FormatJsNodeType[FormatJsNodeType["Plural"] = 6] = "Plural";
-    FormatJsNodeType[FormatJsNodeType["Pound"] = 7] = "Pound";
-    FormatJsNodeType[FormatJsNodeType["Tag"] = 8] = "Tag";
-})(FormatJsNodeType || (exports.FormatJsNodeType = FormatJsNodeType = {}));
-// Using a static object here ensures there's only one allocation for it, which
-// will likely appear in many, many messages. Freezing ensures that the shared
-// object can't be accidentally modified if a consumer tries to transform the
-// AST.
-exports.FORMAT_JS_POUND = Object.freeze({ type: 7 });
-function hydrateArray(elements) {
-    for (var i = 0; i < elements.length; i++) {
-        elements[i] = hydrateFormatJsAst(elements[i]);
-    }
-}
-function hydratePlural(keyless) {
-    var _a = __read(keyless, 5), type = _a[0], value = _a[1], options = _a[2], offset = _a[3], pluralType = _a[4];
-    // This tries to be efficient about updating the value for each option
-    // with a parsed version, reusing the same receiving object, and even
-    // the inner key within it, just replacing the end value with the
-    // parsed version.
-    // This saves multiple allocations compared to building a new object
-    // from scratch, either for the whole options object or for each value.
-    for (var key in options) {
-        hydrateArray(options[key].value);
-    }
-    // `pluralType` is technically only valid on `Plural` nodes, even
-    // though the structure is identical to `Select`.
-    if (type === FormatJsNodeType.Plural) {
-        return { type: type, value: value, options: options, offset: offset, pluralType: pluralType };
-    }
-    else {
-        return { type: type, value: value, options: options, offset: offset };
-    }
-}
-function hydrateSingle(keyless) {
-    var _a = __read(keyless, 1), type = _a[0];
-    switch (type) {
-        case FormatJsNodeType.Literal:
-        case FormatJsNodeType.Argument:
-            return { type: type, value: keyless[1] };
-        case FormatJsNodeType.Number:
-        case FormatJsNodeType.Date:
-        case FormatJsNodeType.Time:
-            return { type: type, value: keyless[1], style: keyless[2] };
-        case FormatJsNodeType.Select:
-        case FormatJsNodeType.Plural:
-            return hydratePlural(keyless);
-        case FormatJsNodeType.Pound:
-            return exports.FORMAT_JS_POUND;
-        case FormatJsNodeType.Tag: {
-            var _b = __read(keyless, 3), type_1 = _b[0], value = _b[1], children = _b[2];
-            hydrateArray(children);
-            return { type: type_1, value: value, children: children };
-        }
-        default:
-            throw new Error("FormatJS keyless JSON encountered an unknown type: ".concat(type));
-    }
-}
-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])) {
-        hydrateArray(keyless);
-        return keyless;
-    }
-    else 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);
-}
-function hydrateMessages(messages) {
-    for (var key in messages) {
-        messages[key] = hydrateFormatJsAst(messages[key]);
-    }
-    return messages;
-}

package/src/keyless-json.ts

@@ -1,161 +0,0 @@
-export enum FormatJsNodeType {
-  Literal = 0,
-  Argument,
-  Number,
-  Date,
-  Time,
-  Select,
-  Plural,
-  Pound,
-  Tag,
-}
-
-export interface FormatJsLiteral {
-  type: FormatJsNodeType.Literal;
-  value: string;
-}
-
-export interface FormatJsArgument {
-  type: FormatJsNodeType.Argument;
-  value: string;
-}
-
-export interface FormatJsNumber {
-  type: FormatJsNodeType.Number;
-  value: string;
-  style?: string;
-}
-
-export interface FormatJsDate {
-  type: FormatJsNodeType.Date;
-  value: string;
-  style?: string;
-}
-
-export interface FormatJsTime {
-  type: FormatJsNodeType.Time;
-  value: string;
-  style?: string;
-}
-
-export interface FormatJsSelect {
-  type: FormatJsNodeType.Select;
-  value: string;
-  options: Record<string, { value: FormatJsNode[] }>;
-}
-
-export type FormatJsPluralType = 'cardinal' | 'ordinal';
-
-export interface FormatJsPlural {
-  type: FormatJsNodeType.Plural;
-  value: string;
-  options: Record<string, { value: FormatJsNode[] }>;
-  offset: number;
-  pluralType: FormatJsPluralType;
-}
-
-export interface FormatJsPound {
-  type: FormatJsNodeType.Pound;
-}
-
-export interface FormatJsTag {
-  type: FormatJsNodeType.Tag;
-  value: string;
-  children: FormatJsNode[];
-}
-
-export type FormatJsNode =
-  | FormatJsLiteral
-  | FormatJsArgument
-  | FormatJsNumber
-  | FormatJsDate
-  | FormatJsTime
-  | FormatJsSelect
-  | FormatJsPlural
-  | FormatJsPound
-  | FormatJsTag;
-
-// Using a static object here ensures there's only one allocation for it, which
-// will likely appear in many, many messages. Freezing ensures that the shared
-// object can't be accidentally modified if a consumer tries to transform the
-// AST.
-export const FORMAT_JS_POUND: FormatJsPound = Object.freeze({ type: 7 });
-
-function hydrateArray(elements: Array<Array<any>>) {
-  for (let i = 0; i < elements.length; i++) {
-    elements[i] = hydrateFormatJsAst(elements[i]);
-  }
-}
-
-function hydratePlural(keyless: Array<any>): FormatJsNode {
-  const [type, value, options, offset, pluralType] = keyless;
-  // This tries to be efficient about updating the value for each option
-  // with a parsed version, reusing the same receiving object, and even
-  // the inner key within it, just replacing the end value with the
-  // parsed version.
-  // 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);
-  }
-  // `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, pluralType };
-  } else {
-    return { type, value, options, offset };
-  }
-}
-
-function hydrateSingle(keyless: Array<any>): FormatJsNode {
-  const [type] = keyless;
-  switch (type) {
-    case FormatJsNodeType.Literal:
-    case FormatJsNodeType.Argument:
-      return { type, value: keyless[1] };
-    case FormatJsNodeType.Number:
-    case FormatJsNodeType.Date:
-    case FormatJsNodeType.Time:
-      return { type, value: keyless[1], style: keyless[2] };
-    case FormatJsNodeType.Select:
-    case FormatJsNodeType.Plural:
-      return hydratePlural(keyless);
-    case FormatJsNodeType.Pound:
-      return FORMAT_JS_POUND;
-    case FormatJsNodeType.Tag: {
-      const [type, value, children] = keyless;
-      hydrateArray(children);
-      return { type, value, children: children };
-    }
-    default:
-      throw new Error(`FormatJS keyless JSON encountered an unknown type: ${type}`);
-  }
-}
-
-/**
- * Hydrate the given keyless JSON into a FormatJS-compatible AST structure.
- * The given object is reused as much as possible, meaning it cannot be safely
- * used again after hydrating.
- */
-export function hydrateFormatJsAst(keyless: Array<Array<any>>): FormatJsNode[];
-export function hydrateFormatJsAst(keyless: Array<any>): FormatJsNode | FormatJsNode[] {
-  // 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])) {
-    hydrateArray(keyless);
-    return keyless;
-  } else 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);
-}
-
-export function hydrateMessages(messages: Record<string, any>) {
-  for (const key in messages) {
-    messages[key] = hydrateFormatJsAst(messages[key]);
-  }
-  return messages;
-}