Merge pull request #427 from messageformat/mf2-updates

MF2 spec updates

Author: XM5jDcsHTyGJtQqlCi

.github/workflows/docs.yml

@@ -11,12 +11,12 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: actions/setup-node@v3
-        with: { node-version: 18 }
+      - uses: actions/setup-node@v4
+        with: { node-version: 20 }
       - uses: ruby/setup-ruby@v1
         with:
           bundler-cache: true
-          ruby-version: '2.7'
+          ruby-version: '3.3'
           working-directory: ./docs
       - run: npm ci
       - run: npm run build

docs/Gemfile

@@ -1,6 +1,3 @@
 source "https://rubygems.org"
 
 gem "github-pages", group: :jekyll_plugins
-
-# https://github.com/jekyll/jekyll/issues/8523
-gem "webrick", "~> 1.7"

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/fluent.test.ts

@@ -272,15 +272,15 @@ const testCases: Record<string, TestCase> = {
         msg: 'plural',
         scope: {},
         exp: 'B',
-        errors: ['$selector', 'bad-operand', 'not-selectable']
+        errors: ['$selector', 'bad-operand', 'bad-selector']
       },
       { msg: 'plural', scope: { selector: 1 }, exp: 'A' },
       { msg: 'plural', scope: { selector: 2 }, exp: 'B' },
       {
         msg: 'plural',
         scope: { selector: 'one' },
         exp: 'B',
-        errors: ['bad-operand', 'not-selectable']
+        errors: ['bad-operand', 'bad-selector']
       },
       {
         msg: 'default',
@@ -667,7 +667,7 @@ describe('formatToParts', () => {
       expect(msg).toEqual([{ type: 'literal', value: 'Other' }]);
       expect(onError.mock.calls.map(args => args[0].type)).toEqual([
         'bad-operand',
-        'not-selectable'
+        'bad-selector'
       ]);
     });
   });

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/declarations.ts

@@ -5,12 +5,15 @@ import type * as CST from './types.js';
 import { whitespaces } from './util.js';
 import { parseVariable } from './values.js';
 
-export function parseDeclarations(ctx: ParseContext): {
+export function parseDeclarations(
+  ctx: ParseContext,
+  start: number
+): {
   declarations: CST.Declaration[];
   end: number;
 } {
   const { source } = ctx;
-  let pos = whitespaces(source, 0);
+  let pos = start;
   const declarations: CST.Declaration[] = [];
   loop: while (source[pos] === '.') {
     const keyword = parseNameValue(source, pos + 1);

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/parse-cst.ts

@@ -52,13 +52,16 @@ export function parseCST(
 ): CST.Message {
   const ctx = new ParseContext(source, opt);
 
-  if (source.startsWith('.')) {
-    const { declarations, end: pos } = parseDeclarations(ctx);
-    return source.startsWith('.match', pos)
-      ? parseSelectMessage(ctx, pos, declarations)
-      : parsePatternMessage(ctx, pos, declarations, true);
+  const pos = whitespaces(source, 0);
+  if (source.startsWith('.', pos)) {
+    const { declarations, end } = parseDeclarations(ctx, pos);
+    return source.startsWith('.match', end)
+      ? parseSelectMessage(ctx, end, declarations)
+      : parsePatternMessage(ctx, end, declarations, true);
   } else {
-    return parsePatternMessage(ctx, 0, [], source.startsWith('{{'));
+    return source.startsWith('{{', pos)
+      ? parsePatternMessage(ctx, pos, [], true)
+      : parsePatternMessage(ctx, 0, [], false);
   }
 }
 
@@ -95,7 +98,7 @@ function parseSelectMessage(
     const sel = parseExpression(ctx, pos);
     const body = sel.markup ?? sel.annotation;
     if (body && body.type !== 'function') {
-      ctx.onError('bad-selector', body.start, body.end);
+      ctx.onError('parse-error', body.start, body.end);
     }
     selectors.push(sel);
     pos = sel.end;

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 */