feat(mf2): Keep attributes in data model, use Map for options & attributes (unicode-org/message-format-wg#845)

Author: XM5jDcsHTyGJtQqlCi

packages/mf2-fluent/src/fluent-to-message.ts

@@ -119,13 +119,13 @@ function asExpression(exp: Fluent.Expression): Expression {
         throw new Error(`More than one positional argument is not supported.`);
       }
       if (named.length > 0) {
-        annotation.options = [];
+        annotation.options = new Map();
         for (const { name, value } of named) {
           const quoted = value.type !== 'NumberLiteral';
           const litValue = quoted ? value.parse().value : value.value;
-          annotation.options.push({
-            name: name.name,
-            value: { type: 'literal', value: litValue }
+          annotation.options.set(name.name, {
+            type: 'literal',
+            value: litValue
           });
         }
       }
@@ -152,13 +152,13 @@ function asExpression(exp: Fluent.Expression): Expression {
         ? `-${exp.id.name}.${exp.attribute.name}`
         : `-${exp.id.name}`;
       if (exp.arguments?.named.length) {
-        annotation.options = [];
+        annotation.options = new Map();
         for (const { name, value } of exp.arguments.named) {
           const quoted = value.type !== 'NumberLiteral';
           const litValue = quoted ? value.parse().value : value.value;
-          annotation.options.push({
-            name: name.name,
-            value: { type: 'literal', value: litValue }
+          annotation.options.set(name.name, {
+            type: 'literal',
+            value: litValue
           });
         }
       }

packages/mf2-fluent/src/message-to-fluent.ts

@@ -165,17 +165,19 @@ function functionRefToFluent(
 ): Fluent.InlineExpression {
   const args = new Fluent.CallArguments();
   if (arg) args.positional[0] = arg;
-  if (options) {
-    args.named = options.map(opt => {
-      const va = valueToFluent(ctx, opt.value);
+  if (options?.size) {
+    args.named = [];
+    for (const [name, value] of options) {
+      const va = valueToFluent(ctx, value);
       if (va instanceof Fluent.BaseLiteral) {
-        const id = new Fluent.Identifier(opt.name);
-        return new Fluent.NamedArgument(id, va);
+        const id = new Fluent.Identifier(name);
+        args.named.push(new Fluent.NamedArgument(id, va));
+      } else {
+        throw new Error(
+          `Fluent options must have literal values (got ${va.type} for ${name})`
+        );
       }
-      throw new Error(
-        `Fluent options must have literal values (got ${va.type} for ${opt.name})`
-      );
-    });
+    }
   }
 
   const id = ctx.functionMap[name];

packages/mf2-icu-mf1/src/mf1-to-message-data.ts

@@ -3,7 +3,7 @@ import type {
   Expression,
   FunctionAnnotation,
   Message,
-  Option,
+  Options,
   VariableRef,
   Variant
 } from 'messageformat';
@@ -76,9 +76,7 @@ function tokenToPart(
           if (pt.type === 'content') value += pt.value;
           else throw new Error(`Unsupported param type: ${pt.type}`);
         }
-        annotation.options = [
-          { name: 'param', value: { type: 'literal', value } }
-        ];
+        annotation.options = new Map([['param', { type: 'literal', value }]]);
       }
       return {
         type: 'expression',
@@ -93,12 +91,9 @@ function tokenToPart(
         name: 'number'
       };
       if (pluralOffset) {
-        annotation.options = [
-          {
-            name: 'pluralOffset',
-            value: { type: 'literal', value: String(pluralOffset) }
-          }
-        ];
+        annotation.options = new Map([
+          ['pluralOffset', { type: 'literal', value: String(pluralOffset) }]
+        ]);
       }
       return {
         type: 'expression',
@@ -126,22 +121,19 @@ function argToExpression({
     };
   }
 
-  const options: Option[] = [];
+  const options: Options = new Map();
   if (pluralOffset) {
-    options.push({
-      name: 'pluralOffset',
-      value: { type: 'literal', value: String(pluralOffset) }
+    options.set('pluralOffset', {
+      type: 'literal',
+      value: String(pluralOffset)
     });
   }
   if (type === 'selectordinal') {
-    options.push({
-      name: 'type',
-      value: { type: 'literal', value: 'ordinal' }
-    });
+    options.set('type', { type: 'literal', value: 'ordinal' });
   }
 
   const annotation: FunctionAnnotation = { type: 'function', name: 'number' };
-  if (options.length) annotation.options = options;
+  if (options.size) annotation.options = options;
 
   return { type: 'expression', arg, annotation };
 }

packages/mf2-messageformat/src/cst/expression.ts

@@ -277,15 +277,12 @@ function parseAttribute(ctx: ParseContext, start: number): CST.Attribute {
   let pos = id.end;
   const ws = whitespaces(source, pos);
   let equals: CST.Syntax<'='> | undefined;
-  let value: CST.Literal | CST.VariableRef | undefined;
+  let value: CST.Literal | undefined;
   if (source[pos + ws] === '=') {
     pos += ws + 1;
     equals = { start: pos - 1, end: pos, value: '=' };
     pos += whitespaces(source, pos);
-    value =
-      source[pos] === '$'
-        ? parseVariable(ctx, pos)
-        : parseLiteral(ctx, pos, true);
+    value = parseLiteral(ctx, pos, true);
     pos = value.end;
   }
   return {

packages/mf2-messageformat/src/cst/types.ts

@@ -186,7 +186,7 @@ export interface Attribute {
   open: Syntax<'@'>;
   name: Identifier;
   equals?: Syntax<'='>;
-  value?: Literal | VariableRef;
+  value?: Literal;
 }
 
 /** @beta */

packages/mf2-messageformat/src/data-model/format-markup.ts

@@ -10,9 +10,9 @@ export function formatMarkup(
   const source =
     kind === 'close' ? `/${name}` : kind === 'open' ? `#${name}` : `#${name}/`;
   const part: MessageMarkupPart = { type: 'markup', kind, source, name };
-  if (options?.length) {
+  if (options?.size) {
     part.options = {};
-    for (const { name, value } of options) {
+    for (const [name, value] of options) {
       let rv = resolveValue(ctx, value);
       if (typeof rv === 'object' && typeof rv?.valueOf === 'function') {
         const vv = rv.valueOf();

packages/mf2-messageformat/src/data-model/from-cst.ts

@@ -95,17 +95,16 @@ function asExpression(
   allowMarkup: boolean
 ): Model.Expression | Model.Markup {
   if (exp.type === 'expression') {
-    const attributes = exp.attributes.length
-      ? exp.attributes.map(asAttribute)
-      : undefined;
     if (allowMarkup && exp.markup) {
       const cm = exp.markup;
       const name = asName(cm.name);
       const kind =
         cm.open.value === '/' ? 'close' : cm.close ? 'standalone' : 'open';
       const markup: Model.Markup = { type: 'markup', kind, name };
-      if (cm.options.length) markup.options = cm.options.map(asOption);
-      if (attributes) markup.attributes = attributes;
+      if (cm.options.length) markup.options = asOptions(cm.options);
+      if (exp.attributes.length) {
+        markup.attributes = asAttributes(exp.attributes);
+      }
       markup[cst] = exp;
       return markup;
     }
@@ -121,7 +120,7 @@ function asExpression(
       switch (ca.type) {
         case 'function':
           annotation = { type: 'function', name: asName(ca.name) };
-          if (ca.options.length) annotation.options = ca.options.map(asOption);
+          if (ca.options.length) annotation.options = asOptions(ca.options);
           break;
         case 'reserved-annotation':
           annotation = {
@@ -142,25 +141,38 @@ function asExpression(
       else expression = { type: 'expression', annotation };
     }
     if (expression) {
-      if (attributes) expression.attributes = attributes;
+      if (exp.attributes.length) {
+        expression.attributes = asAttributes(exp.attributes);
+      }
       expression[cst] = exp;
       return expression;
     }
   }
   throw new MessageSyntaxError('parse-error', exp.start, exp.end);
 }
 
-const asOption = (option: CST.Option): Model.Option => ({
-  name: asName(option.name),
-  value: asValue(option.value),
-  [cst]: option
-});
+function asOptions(options: CST.Option[]): Model.Options {
+  const map: Model.Options = new Map();
+  for (const opt of options) {
+    const name = asName(opt.name);
+    if (map.has(name)) {
+      throw new MessageSyntaxError('duplicate-option-name', opt.start, opt.end);
+    }
+    map.set(name, asValue(opt.value));
+  }
+  return map;
+}
 
-function asAttribute(attr: CST.Attribute): Model.Attribute {
-  const name = asName(attr.name);
-  return attr.value
-    ? { name, value: asValue(attr.value), [cst]: attr }
-    : { name, [cst]: attr };
+function asAttributes(attributes: CST.Attribute[]): Model.Attributes {
+  const map: Model.Attributes = new Map();
+  for (const attr of attributes) {
+    const name = asName(attr.name);
+    if (map.has(name)) {
+      throw new MessageSyntaxError('duplicate-attribute', attr.start, attr.end);
+    }
+    map.set(name, attr.value ? asValue(attr.value) : true);
+  }
+  return map;
 }
 
 function asName(id: CST.Identifier): string {

packages/mf2-messageformat/src/data-model/parse.test.ts

@@ -35,7 +35,11 @@ describe('private annotations', () => {
       declarations: [],
       pattern: [
         'foo ',
-        { type: 'expression', annotation: { type: 'priv-bar' } }
+        {
+          type: 'expression',
+          annotation: { type: 'priv-bar' },
+          attributes: new Map([['baz', true]])
+        }
       ]
     });
   });

packages/mf2-messageformat/src/data-model/parse.ts

@@ -236,7 +236,7 @@ function expression(allowMarkup: boolean): Model.Expression | Model.Markup {
       pos += 1; // ':'
       annotation = { type: 'function', name: identifier() };
       const options_ = options();
-      if (options_.length) annotation.options = options_;
+      if (options_) annotation.options = options_;
       break;
     }
     case '#':
@@ -246,7 +246,7 @@ function expression(allowMarkup: boolean): Model.Expression | Model.Markup {
       const kind = sigil === '#' ? 'open' : 'close';
       markup = { type: 'markup', kind, name: identifier() };
       const options_ = options();
-      if (options_.length) markup.options = options_;
+      if (options_) markup.options = options_;
       break;
     }
     case '^':
@@ -267,50 +267,75 @@ function expression(allowMarkup: boolean): Model.Expression | Model.Markup {
       throw SyntaxError('parse-error', pos);
   }
 
-  while (source[pos] === '@') attribute();
+  const attributes_ = attributes();
   if (markup?.kind === 'open' && source[pos] === '/') {
     markup.kind = 'standalone';
     pos += 1; // '/'
   }
   expect('}', true);
 
   if (annotation) {
-    return arg
+    const exp: Model.Expression = arg
       ? { type: 'expression', arg, annotation }
       : { type: 'expression', annotation };
+    if (attributes_) exp.attributes = attributes_;
+    return exp;
+  }
+  if (markup) {
+    if (attributes_) markup.attributes = attributes_;
+    return markup;
   }
-  if (markup) return markup;
   if (!arg) throw SyntaxError('empty-token', start, pos);
-  return { type: 'expression', arg };
+  return attributes_
+    ? { type: 'expression', arg, attributes: attributes_ }
+    : { type: 'expression', arg };
 }
 
 /** Requires and consumes leading and trailing whitespace. */
 function options() {
   ws('/}');
-  const options: Model.Option[] = [];
+  const options: Model.Options = new Map();
+  let isEmpty = true;
   while (pos < source.length) {
     const next = source[pos];
     if (next === '@' || next === '/' || next === '}') break;
+    const start = pos;
     const name_ = identifier();
+    if (options.has(name_)) {
+      throw SyntaxError('duplicate-option-name', start, pos);
+    }
     ws();
     expect('=', true);
     ws();
-    options.push({ name: name_, value: value(true) });
+    options.set(name_, value(true));
+    isEmpty = false;
     ws('/}');
   }
-  return options;
+  return isEmpty ? null : options;
 }
 
-function attribute() {
-  pos += 1; // '@'
-  identifier(); // name
-  ws('=/}');
-  if (source[pos] === '=') {
-    pos += 1; // '='
-    ws();
-    value(true); // value
-    ws('/}');
+function attributes() {
+  const attributes: Model.Attributes = new Map();
+  let isEmpty = true;
+  while (source[pos] === '@') {
+    const start = pos;
+    pos += 1; // '@'
+    const name_ = identifier();
+    if (attributes.has(name_)) {
+      throw SyntaxError('duplicate-attribute', start, pos);
+    }
+    ws('=/}');
+    if (source[pos] === '=') {
+      pos += 1; // '='
+      ws();
+      attributes.set(name_, literal(true));
+      ws('/}');
+    } else {
+      attributes.set(name_, true);
+    }
+    isEmpty = false;
   }
+  return isEmpty ? null : attributes;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any

packages/mf2-messageformat/src/data-model/resolve-function-annotation.ts

@@ -6,7 +6,7 @@ import { getValueSource, resolveValue } from './resolve-value.js';
 import type {
   FunctionAnnotation,
   Literal,
-  Option,
+  Options,
   VariableRef
 } from './types.js';
 
@@ -51,10 +51,10 @@ export function resolveFunctionAnnotation(
   }
 }
 
-function resolveOptions(ctx: Context, options: Option[] | undefined) {
+function resolveOptions(ctx: Context, options: Options | undefined) {
   const opt: Record<string, unknown> = Object.create(null);
   if (options) {
-    for (const { name, value } of options) {
+    for (const [name, value] of options) {
       opt[name] = resolveValue(ctx, value);
     }
   }