feat(mf2): Implement :unit formatter (unicode-org/message-format-wg#922)

Author: XM5jDcsHTyGJtQqlCi

mf2/fluent/src/fluent.test.ts

@@ -83,7 +83,7 @@ const testCases: Record<string, TestCase> = {
       num-fraction-bad = { NUMBER($arg, minimumFractionDigits: "oops") }
       num-currency = { NUMBER($arg, style: "currency", currency: "EUR") }
       # TODO: num-percent = { NUMBER($arg, style: "percent") }
-      # TODO: num-unit = { NUMBER($arg, style: "unit", unit: "meter") }
+      num-unit = { NUMBER($arg, style: "unit", unit: "meter") }
       num-unknown = { NUMBER($arg, unknown: "unknown") }
     `,
     tests: [
@@ -97,7 +97,7 @@ const testCases: Record<string, TestCase> = {
       },
       { msg: 'num-currency', scope: { arg: 1234 }, exp: '€1,234.00' },
       // TODO: { msg: 'num-percent', scope: { arg: 1234 }, exp: '123,400%' },
-      // TODO: { msg: 'num-unit', scope: { arg: 1234 }, exp: '1,234 m' },
+      { msg: 'num-unit', scope: { arg: 1234 }, exp: '1,234 m' },
       { msg: 'num-unknown', scope: { arg: 1234 }, exp: '1,234' }
     ]
   },

mf2/messageformat/src/functions/index.ts

@@ -6,4 +6,5 @@ export { fallback, type MessageFallback } from './fallback.js';
 export { math } from './math.js';
 export { integer, number, type MessageNumber } from './number.js';
 export { string, type MessageString } from './string.js';
+export { unit } from './unit.js';
 export { unknown, type MessageUnknownValue } from './unknown.js';

mf2/messageformat/src/functions/unit.test.ts

@@ -0,0 +1,39 @@
+import { MessageFormat } from '../index.js';
+
+test('selection', () => {
+  const mf = new MessageFormat(
+    'en',
+    '.local $n = {42 :unit unit=meter} .match $n 42 {{exact}} * {{other}}'
+  );
+  const onError = jest.fn();
+  expect(mf.format(undefined, onError)).toEqual('other');
+  expect(onError.mock.calls).toMatchObject([[{ type: 'bad-selector' }]]);
+});
+
+describe('complex operand', () => {
+  test(':currency result', () => {
+    const mf = new MessageFormat(
+      'en',
+      '.local $n = {42 :unit unit=meter trailingZeroDisplay=stripIfInteger} {{{$n :unit signDisplay=always}}}'
+    );
+    const nf = new Intl.NumberFormat('en', {
+      signDisplay: 'always',
+      style: 'unit',
+      // @ts-expect-error TS doesn't know about trailingZeroDisplay
+      trailingZeroDisplay: 'stripIfInteger',
+      unit: 'meter'
+    });
+    expect(mf.format()).toEqual(nf.format(42));
+    expect(mf.formatToParts()).toMatchObject([{ parts: nf.formatToParts(42) }]);
+  });
+
+  test('external variable', () => {
+    const mf = new MessageFormat('en', '{$n :unit}');
+    const nf = new Intl.NumberFormat('en', { style: 'unit', unit: 'meter' });
+    const n = { valueOf: () => 42, options: { unit: 'meter' } };
+    expect(mf.format({ n })).toEqual(nf.format(42));
+    expect(mf.formatToParts({ n })).toMatchObject([
+      { parts: nf.formatToParts(42) }
+    ]);
+  });
+});

mf2/messageformat/src/functions/unit.ts

@@ -0,0 +1,65 @@
+import { MessageError, MessageResolutionError } from '../errors.js';
+import type { MessageFunctionContext } from './index.js';
+import type { MessageNumber, MessageNumberOptions } from './number.js';
+import { getMessageNumber, readNumericOperand } from './number.js';
+import { asPositiveInteger, asString } from './utils.js';
+
+/**
+ * `unit` accepts as input numerical values as well as
+ * objects wrapping a numerical value that also include a `unit` property.
+ *
+ * @beta
+ */
+export function unit(
+  ctx: MessageFunctionContext,
+  exprOpt: Record<string | symbol, unknown>,
+  operand?: unknown
+): MessageNumber {
+  const { source } = ctx;
+  const input = readNumericOperand(operand, source);
+  const options: MessageNumberOptions = Object.assign({}, input.options, {
+    localeMatcher: ctx.localeMatcher,
+    style: 'unit'
+  } as const);
+
+  for (const [name, optval] of Object.entries(exprOpt)) {
+    if (optval === undefined) continue;
+    try {
+      switch (name) {
+        case 'signDisplay':
+        case 'roundingMode':
+        case 'roundingPriority':
+        case 'trailingZeroDisplay':
+        case 'unit':
+        case 'unitDisplay':
+        case 'useGrouping':
+          // @ts-expect-error Let Intl.NumberFormat construction fail
+          options[name] = asString(optval);
+          break;
+        case 'minimumIntegerDigits':
+        case 'minimumFractionDigits':
+        case 'maximumFractionDigits':
+        case 'minimumSignificantDigits':
+        case 'maximumSignificantDigits':
+        case 'roundingIncrement':
+          // @ts-expect-error TS types don't know about roundingIncrement
+          options[name] = asPositiveInteger(optval);
+          break;
+      }
+    } catch (error) {
+      if (error instanceof MessageError) {
+        ctx.onError(error);
+      } else {
+        const msg = `Value ${optval} is not valid for :currency option ${name}`;
+        ctx.onError(new MessageResolutionError('bad-option', msg, source));
+      }
+    }
+  }
+
+  if (!options.unit) {
+    const msg = 'A unit identifier is required for :unit';
+    throw new MessageResolutionError('bad-operand', msg, source);
+  }
+
+  return getMessageNumber(ctx, input.value, options, false);
+}

mf2/messageformat/src/messageformat.ts

@@ -13,7 +13,8 @@ import {
   math,
   number,
   string,
-  time
+  time,
+  unit
 } from './functions/index.js';
 import { BIDI_ISOLATE, type MessageValue } from './message-value.js';
 import { formatMarkup } from './resolve/format-markup.js';
@@ -30,7 +31,8 @@ const defaultFunctions = Object.freeze({
   math,
   number,
   string,
-  time
+  time,
+  unit
 });
 
 /**