@discord/intl-ast 0.6.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Discord, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,104 @@
+export declare enum FormatJsNodeType {
+    Literal = 0,
+    Argument = 1,
+    Number = 2,
+    Date = 3,
+    Time = 4,
+    Select = 5,
+    Plural = 6,
+    Pound = 7,
+    Tag = 8
+}
+export type LiteralNode = [FormatJsNodeType.Literal, string];
+export type ArgumentNode = [FormatJsNodeType.Argument, string];
+export type NumberNode = [FormatJsNodeType.Number, string, string | undefined];
+export type DateNode = [FormatJsNodeType.Date, string, string | undefined];
+export type TimeNode = [FormatJsNodeType.Time, string, string | undefined];
+export type SelectNode = [FormatJsNodeType.Select, string, Record<string, {
+    value: AstNode[];
+}>];
+export type PluralNode = [
+    FormatJsNodeType.Plural,
+    string,
+    Record<string, {
+        value: AstNode[];
+    }>,
+    number,
+    FormatJsPluralType
+];
+export type PoundNode = [FormatJsNodeType.Pound];
+export type TagNode = [FormatJsNodeType.Tag, string, AstNode[]];
+export type AstNode = LiteralNode | ArgumentNode | NumberNode | DateNode | TimeNode | SelectNode | PluralNode | PoundNode | TagNode;
+export declare enum AstNodeIndices {
+    Type = 0,
+    Value = 1,
+    Style = 2,
+    Options = 2,
+    Offset = 3,
+    PluralType = 4,
+    Children = 2
+}
+export interface FullFormatJsLiteral {
+    type: FormatJsNodeType.Literal;
+    value: string;
+}
+export interface FullFormatJsArgument {
+    type: FormatJsNodeType.Argument;
+    value: string;
+}
+export interface FullFormatJsNumber {
+    type: FormatJsNodeType.Number;
+    value: string;
+    style?: string;
+}
+export interface FullFormatJsDate {
+    type: FormatJsNodeType.Date;
+    value: string;
+    style?: string;
+}
+export interface FullFormatJsTime {
+    type: FormatJsNodeType.Time;
+    value: string;
+    style?: string;
+}
+export interface FullFormatJsSelect {
+    type: FormatJsNodeType.Select;
+    value: string;
+    options: Record<string, {
+        value: FullFormatJsNode[];
+    }>;
+}
+export type FormatJsPluralType = 'cardinal' | 'ordinal';
+export interface FullFormatJsPlural {
+    type: FormatJsNodeType.Plural;
+    value: string;
+    options: Record<string, {
+        value: FullFormatJsNode[];
+    }>;
+    offset: number;
+    pluralType: FormatJsPluralType;
+}
+export interface FullFormatJsPound {
+    type: FormatJsNodeType.Pound;
+}
+export interface FullFormatJsTag {
+    type: FormatJsNodeType.Tag;
+    value: string;
+    children: FullFormatJsNode[];
+}
+export type FullFormatJsNode = FullFormatJsLiteral | FullFormatJsArgument | FullFormatJsNumber | FullFormatJsDate | FullFormatJsTime | FullFormatJsSelect | FullFormatJsPlural | FullFormatJsPound | FullFormatJsTag;
+export declare const FORMAT_JS_POUND: FullFormatJsPound;
+/**
+ * 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>>): FullFormatJsNode[];
+export declare function compressFormatJsToAst(node: FullFormatJsNode): AstNode;
+export declare function compressFormatJsToAst(node: FullFormatJsNode[]): AstNode[];
+/**
+ * Returns true if the given `node` is a compressed `AstNode` rather than a `FullFormatJsNode`. This
+ * also works for checking arrays of nodes, returning true if the nodes of the array are compressed.
+ */
+export declare function isCompressedAst(node: AstNode | FullFormatJsNode): node is AstNode;
+export declare function isCompressedAst(node: AstNode[] | FullFormatJsNode[]): node is AstNode[];

package/dist/index.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FORMAT_JS_POUND = exports.AstNodeIndices = exports.FormatJsNodeType = void 0;
+exports.hydrateFormatJsAst = hydrateFormatJsAst;
+exports.compressFormatJsToAst = compressFormatJsToAst;
+exports.isCompressedAst = isCompressedAst;
+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 = {}));
+var AstNodeIndices;
+(function (AstNodeIndices) {
+    AstNodeIndices[AstNodeIndices["Type"] = 0] = "Type";
+    AstNodeIndices[AstNodeIndices["Value"] = 1] = "Value";
+    AstNodeIndices[AstNodeIndices["Style"] = 2] = "Style";
+    AstNodeIndices[AstNodeIndices["Options"] = 2] = "Options";
+    AstNodeIndices[AstNodeIndices["Offset"] = 3] = "Offset";
+    AstNodeIndices[AstNodeIndices["PluralType"] = 4] = "PluralType";
+    AstNodeIndices[AstNodeIndices["Children"] = 2] = "Children";
+})(AstNodeIndices || (exports.AstNodeIndices = AstNodeIndices = {}));
+//#endregion
+//#region Hydration
+//
+// Utilities for converting compressed Keyless Json into the fully-typed FormatJS node structure.
+// 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 (let i = 0; i < elements.length; i++) {
+        elements[i] = hydrateFormatJsAst(elements[i]);
+    }
+}
+function hydratePlural(keyless) {
+    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) {
+    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 exports.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}`);
+    }
+}
+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 compressFormatJsToAst(node) {
+    if (Array.isArray(node)) {
+        return node.map((element) => compressFormatJsToAst(element));
+    }
+    console.log('compressing');
+    switch (node.type) {
+        case FormatJsNodeType.Literal:
+        case FormatJsNodeType.Argument:
+            return [node.type, node.value];
+        case FormatJsNodeType.Number:
+        case FormatJsNodeType.Date:
+        case FormatJsNodeType.Time:
+            return [node.type, node.value, node.style];
+        case FormatJsNodeType.Select: {
+            const reducedOptions = {};
+            for (const [name, option] of Object.entries(node.options)) {
+                reducedOptions[name] = { value: compressFormatJsToAst(option.value) };
+            }
+            return [node.type, node.value, reducedOptions];
+        }
+        case FormatJsNodeType.Plural: {
+            const reducedOptions = {};
+            for (const [name, option] of Object.entries(node.options)) {
+                reducedOptions[name] = { value: compressFormatJsToAst(option.value) };
+            }
+            return [node.type, node.value, reducedOptions, node.offset, node.pluralType];
+        }
+        case FormatJsNodeType.Pound:
+            return [node.type];
+        case FormatJsNodeType.Tag:
+            return [node.type, node.value, compressFormatJsToAst(node.children)];
+    }
+}
+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]);
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@discord/intl-ast",
+  "version": "0.6.1",
+  "license": "MIT",
+  "description": "Types and utilities for working with the ICU+Markdown AST format from @discord/intl",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "default": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "devDependencies": {
+    "typescript": "*"
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:release": "tsc"
+  }
+}