prosebook 0.3.0 → 0.5.0

package/src/tools/native/model.ts

@@ -9,7 +9,8 @@ import { chainOf } from '#src/runtime/locale.ts';
 import type { Catalog, Message, Problem } from '#src/tools/catalog.ts';
 import type { Entry } from '#src/tools/compile.ts';
 import type { NativeTarget } from '#src/tools/config.ts';
-import { numberOptions, optionArgsOf, placeholderOf, selectionOf, TYPE, type MessageFormatElement } from '#src/tools/icu.ts';
+import { dateOptions, numberOptions, optionArgsOf, placeholderOf, selectionOf, TYPE, type MessageFormatElement } from '#src/tools/icu.ts';
+import { dateSpec, type DateSpec } from './date.ts';
 import { docText } from './emit.ts';
 import { numberSpec, roundingOf, type NumberSpec, type Rounding } from './number.ts';
 import { pluralRules, type PluralRules } from './plurals.ts';
@@ -19,6 +20,8 @@ export type Part =
   | { type: 'string'; arg: string }
   /** The argument less `offset`, in format `format`; `fallback` where it isn't a number. */
   | { type: 'number'; arg: string; offset: number; format: number; fallback: string }
+  /** The argument, a date, in date format `format`. */
+  | { type: 'date'; arg: string; format: number }
   | { type: 'select'; arg: string; arms: Arm[]; other: Part[] }
   | {
       type: 'plural';
@@ -45,7 +48,7 @@ export interface NativeMessage {
   words: string[];
   /** The source text, its context, and what's asked of it. */
   doc: string[];
-  args: { name: string; type: 'string' | 'number'; doc?: string }[];
+  args: { name: string; type: 'string' | 'number' | 'date'; doc?: string }[];
   /** A tree per locale that renders it its own way; every locale is in one. */
   bodies: { locales: string[]; parts: Part[] }[];
 }
@@ -56,13 +59,30 @@ export interface NativeModel {
   source: string;
   messages: NativeMessage[];
   formats: NumberSpec[];
+  dates: DateSpec[];
   rules: { name: string; rules: PluralRules }[];
 }
 
-/** Whether a target takes `key`, and the prefix that took it in (longest first), which its name leaves out. */
-function prefixOf(target: NativeTarget, key: string): string | undefined {
-  if (target.keys === undefined) return '';
-  return [...target.keys].sort((a, b) => b.length - a.length).find((p) => key.startsWith(`${p}.`));
+/**
+ * The words a target names `key` by, less the prefix that took it in (longest first): `tray.quit-app`
+ * is quit, app under `['tray']`. Nothing when the target doesn't take the key.
+ */
+export function wordsFor(target: NativeTarget, key: string): string[] | undefined {
+  return restOf(target, key)
+    ?.split(/[.\-_]/)
+    .filter(Boolean);
+}
+
+/** `key` less the prefix that took it in, as written: `tray.quit-app` is `quit-app` under `['tray']`. */
+export function restOf(target: NativeTarget, key: string): string | undefined {
+  const prefix = target.keys === undefined ? '' : [...target.keys].sort((a, b) => b.length - a.length).find((p) => key.startsWith(`${p}.`));
+  if (prefix === undefined) return undefined;
+  return key.slice(prefix === '' ? 0 : prefix.length + 1);
+}
+
+/** The locale whose text `locale` shows for `key`: its own, else the first down its fallback chain that has it. */
+export function foundIn(key: string, locale: string, locales: string[], asts: Map<string, Map<string, MessageFormatElement[]>>) {
+  return chainOf(locale, locales, locales[0]!).find((l) => asts.get(l)?.has(key));
 }
 
 /** Values a file declares once each, numbered by what they hold, so locales that format alike share one. */
@@ -90,21 +110,18 @@ export function nativeModel(
   const source = locales[0]!;
   const asts = new Map([...entries].map(([locale, list]) => [locale, new Map(list)]));
   const formats = new Numbered<NumberSpec>();
+  const dates = new Numbered<DateSpec>();
   const rules = new Numbered<{ name: string; rules: PluralRules }>();
   const problems: Problem[] = [];
   const messages: NativeMessage[] = [];
 
   for (const m of catalog.messages) {
-    const prefix = prefixOf(target, m.key);
-    if (prefix === undefined) continue;
-    const words = m.key
-      .slice(prefix === '' ? 0 : prefix.length + 1)
-      .split(/[.\-_]/)
-      .filter(Boolean);
+    const words = wordsFor(target, m.key);
+    if (words === undefined) continue;
     const bodies = new Map<string, { locales: string[]; parts: Part[] }>();
     let failed = false;
     for (const locale of locales) {
-      const found = chainOf(locale, locales, source).find((l) => asts.get(l)?.has(m.key));
+      const found = foundIn(m.key, locale, locales, asts);
       if (found === undefined) continue;
       const body = bodies.get(found);
       if (body !== undefined) {
@@ -112,7 +129,7 @@ export function nativeModel(
         continue;
       }
       try {
-        bodies.set(found, { locales: [locale], parts: parts(asts.get(found)!.get(m.key)!, found, formats, rules, null) });
+        bodies.set(found, { locales: [locale], parts: parts(asts.get(found)!.get(m.key)!, found, { formats, dates, rules }, null) });
       } catch (e) {
         failed = true;
         problems.push({
@@ -130,16 +147,16 @@ export function nativeModel(
       doc: docOf(m),
       args: [...m.args].map(([name, type]) => ({
         name,
-        type: type === 'number' ? 'number' : 'string',
+        type: type === 'number' ? 'number' : type === 'Date | number' ? 'date' : 'string',
         doc: m.argDocs.has(name) ? docText(m.argDocs.get(name)!) : undefined,
       })),
       bodies: [...bodies.values()],
     });
   }
-  return { model: { locales, source, messages, formats: formats.list, rules: rules.list }, problems };
+  return { model: { locales, source, messages, formats: formats.list, dates: dates.list, rules: rules.list }, problems };
 }
 
-function fileOf(m: Message, locale: string, source: string): string {
+export function fileOf(m: Message, locale: string, source: string): string {
   return locale === source ? m.file : (m.translations.get(locale)?.file ?? m.file);
 }
 
@@ -151,11 +168,38 @@ function docOf(m: Message): string[] {
   return lines.map(docText);
 }
 
-const LEAVE_OUT = "or leave the key out of this target's `keys`";
+export const LEAVE_OUT = "or leave the key out of this target's `keys`";
 
 /** Specs by locale and options, kept across runs: taking a format apart checks it against `Intl` dozens of times. */
 const SPECS = new Map<string, NumberSpec | Error>();
 
+/** What a file declares, numbered as the messages use it. */
+interface Declared {
+  formats: Numbered<NumberSpec>;
+  dates: Numbered<DateSpec>;
+  rules: Numbered<{ name: string; rules: PluralRules }>;
+}
+
+/** Date specs as `SPECS` keeps number specs. */
+const DATE_SPECS = new Map<string, DateSpec | Error>();
+
+function date(dates: Numbered<DateSpec>, locale: string, options: Intl.DateTimeFormatOptions | undefined): number {
+  const key = JSON.stringify([locale, options ?? {}]);
+  let spec = DATE_SPECS.get(key);
+  if (spec === undefined) {
+    try {
+      spec = dateSpec(locale, options);
+    } catch (e) {
+      spec = new Error(`native code can't format this date in ${locale}: ${(e as Error).message}. Format it another way, ${LEAVE_OUT}`, {
+        cause: e,
+      });
+    }
+    DATE_SPECS.set(key, spec);
+  }
+  if (spec instanceof Error) throw spec;
+  return dates.add(spec);
+}
+
 function format(formats: Numbered<NumberSpec>, locale: string, options: Intl.NumberFormatOptions | undefined): number {
   const key = JSON.stringify([locale, options ?? {}]);
   let spec = SPECS.get(key);
@@ -175,13 +219,8 @@ function format(formats: Numbered<NumberSpec>, locale: string, options: Intl.Num
 
 type Pound = { arg: string; offset: number } | null;
 
-function parts(
-  elements: MessageFormatElement[],
-  locale: string,
-  formats: Numbered<NumberSpec>,
-  rules: Numbered<{ name: string; rules: PluralRules }>,
-  pound: Pound,
-): Part[] {
+function parts(elements: MessageFormatElement[], locale: string, declared: Declared, pound: Pound): Part[] {
+  const { formats, dates, rules } = declared;
   const out: Part[] = [];
   const text = (value: string) => {
     const last = out.at(-1);
@@ -195,7 +234,7 @@ function parts(
     if (isolate !== undefined) text(isolate[1]);
   };
   const arms = (options: Record<string, { value: MessageFormatElement[] }>, own: Pound) =>
-    Object.entries(options).map(([key, option]) => ({ key, parts: parts(option.value, locale, formats, rules, own) }));
+    Object.entries(options).map(([key, option]) => ({ key, parts: parts(option.value, locale, declared, own) }));
 
   for (const el of elements) {
     if (Object.keys(optionArgsOf(el) ?? {}).length > 0) {
@@ -204,9 +243,8 @@ function parts(
       );
     }
     if (isDateElement(el) || isTimeElement(el)) {
-      throw new Error(
-        `{${el.value}} is a date, which native code doesn't format: pass it formatted, as a plain {${el.value}}, ${LEAVE_OUT}`,
-      );
+      placed(el, el.value, { type: 'date', arg: el.value, format: date(dates, locale, dateOptions(el)) });
+      continue;
     }
     if (isNumberElement(el)) {
       const fallback = placeholderOf(el, el.value).fallback;

package/src/tools/native/printf.ts

@@ -0,0 +1,137 @@
+/**
+ * Messages as printf-style format strings, for the targets whose platform fills values in itself:
+ * Android's resources and Apple's `.strings` and `.stringsdict` files. Text and plain `{name}` placeholders, as `%N$s`
+ * with N the argument's place in the message's arguments, so a translation can put them in another
+ * order; anything `Intl` would format fails with the fix.
+ */
+import { isDateElement, isNumberElement, isTimeElement } from '@formatjs/icu-messageformat-parser';
+
+import type { PluralElement } from '@formatjs/icu-messageformat-parser';
+import type { Message } from '#src/tools/catalog.ts';
+
+import { numberOptions, placeholderOf, selectionOf, TYPE, type MessageFormatElement } from '#src/tools/icu.ts';
+import { docText } from './emit.ts';
+import { LEAVE_OUT } from './model.ts';
+
+export interface Printf {
+  /** Who fills values in, and with what, as problems name them: `Android`, `String.format`. */
+  platform: string;
+  formatter: string;
+  /** What holds the text, as problems name it: `Android resources`. */
+  holder: string;
+  /** A string argument's conversion: `s`, or `@` for Apple's objects. */
+  string: string;
+  /** A count's conversion: `d`, or `lld` for Apple's 64-bit `Int`. */
+  count: string;
+  /** Text as the file holds it; `formatted` when the string has arguments, so `%` must be doubled. */
+  escape: (text: string, formatted: boolean) => string;
+  /** The problem with a plural the target can't hold where it is. */
+  plural: (name: string) => string;
+}
+
+/** The context and what each argument holds, on one line, for the comment above an entry. */
+export function noteOf(m: Message): string {
+  const lines = [
+    m.context,
+    ...[...m.args.keys()].map((a) => (m.argDocs.has(a) ? `${a}: ${m.argDocs.get(a)!.replace(/\.$/, '')}.` : undefined)),
+  ];
+  return docText(lines.filter((l) => l !== undefined && l !== '').join(' '));
+}
+
+/** What a plural's arms may hold as its count: `#`, or the count as a plain `:number` or `:integer`. */
+function isCount(el: MessageFormatElement, count: string): boolean {
+  if (el.type === TYPE.pound) return true;
+  if (!isNumberElement(el) || el.value !== count) return false;
+  const options = Object.entries(numberOptions(el) ?? {});
+  return options.length === 0 || (options.length === 1 && options[0]![0] === 'maximumFractionDigits' && options[0]![1] === 0);
+}
+
+/** What a platform's plurals are called in problems, and what they can't hold. */
+export interface PluralHolder {
+  /** `Android`, as in "Android selects on the count as an integer". */
+  platform: string;
+  /** `Android's <plurals>`. */
+  plurals: string;
+  /** Why an `=N` arm has no place, after "have none for one number". */
+  exact: string;
+}
+
+/**
+ * Throws, with the fix, where a plural asks for more than a platform's plurals pick on: one count,
+ * as an integer, by its cardinal category.
+ */
+export function checkPlural(plural: PluralElement, holder: PluralHolder): void {
+  const named = `{${plural.value}}`;
+  if (plural.pluralType === 'ordinal') {
+    throw new Error(
+      `${named} is an ordinal, and ${holder.plurals} are cardinal only: write a key per case and pick one in code, ${LEAVE_OUT}`,
+    );
+  }
+  if (plural.offset !== 0)
+    throw new Error(`${named} has an offset, which ${holder.plurals} don't: count without it, and say the rest in each arm, ${LEAVE_OUT}`);
+
+  const selection = selectionOf(plural);
+  if (selection !== undefined && (selection.fn.name !== 'integer' || Object.keys(selection.fn.options).length > 0)) {
+    throw new Error(
+      `${named} selects with :${selection.fn.name} and its options, and ${holder.platform} selects on the count as an integer: select with a bare :number or :integer, ${LEAVE_OUT}`,
+    );
+  }
+  const exact = Object.keys(plural.options).filter((k) => k.startsWith('='));
+  if (exact.length > 0) {
+    throw new Error(
+      `${named} has the arm ${exact.join(', ')}, and ${holder.plurals} have none for one number${holder.exact}: say it in a category's arm, or write a key for it and pick that in code, ${LEAVE_OUT}`,
+    );
+  }
+}
+
+/** `elements` as a format string over `args`; inside a plural, its `count` is `%N$d` (or `lld`). */
+export function formatString(elements: MessageFormatElement[], args: string[], printf: Printf, count?: string): string {
+  const formatted = args.length > 0;
+  const place = (el: MessageFormatElement, name: string, conversion: string) => {
+    const at = args.indexOf(name);
+    if (at < 0) throw new Error(`{${name}} is not an argument of this message: say it in the source text too`);
+    const { isolate } = placeholderOf(el, name);
+    const spec = `%${at + 1}$${conversion}`;
+    return isolate === undefined ? spec : `${printf.escape(isolate[0], formatted)}${spec}${printf.escape(isolate[1], formatted)}`;
+  };
+  let out = '';
+  for (const el of elements) {
+    if (count !== undefined && isCount(el, count)) {
+      out += place(el, count, printf.count);
+      continue;
+    }
+    if (isDateElement(el) || isTimeElement(el)) {
+      throw new Error(
+        `{${el.value}} is a date, which ${printf.holder} don't format: pass it formatted, as a plain {${el.value}}, ${LEAVE_OUT}`,
+      );
+    }
+    if (isNumberElement(el)) {
+      throw new Error(
+        `{${el.value}} is a formatted number, and ${printf.platform} fills values in with ${printf.formatter}, not Intl: pass it formatted, as a plain {${el.value}}, ${LEAVE_OUT}`,
+      );
+    }
+    switch (el.type) {
+      case TYPE.literal:
+        out += printf.escape(el.value, formatted);
+        break;
+      case TYPE.argument:
+        out += place(el, el.value, printf.string);
+        break;
+      case TYPE.pound:
+        // Outside a plural, `#` is text.
+        out += '#';
+        break;
+      case TYPE.select:
+        throw new Error(
+          `{${el.value}} is a select, which ${printf.holder} can't hold: write a key per case and pick one in code, ${LEAVE_OUT}`,
+        );
+      case TYPE.plural:
+        throw new Error(printf.plural(el.value));
+      case TYPE.tag:
+        throw new Error(`<${el.value}> is a tag, and ${printf.holder} here hold plain text: say it without the tag, ${LEAVE_OUT}`);
+      default:
+        throw new Error(`prosebook: no ${printf.platform} writer for ICU element type ${(el as MessageFormatElement).type}`);
+    }
+  }
+  return out;
+}

package/src/tools/native/rust.ts

@@ -3,6 +3,7 @@
  * a private `rt` module, so no argument a message names can shadow it.
  */
 import type { NativeTarget } from '#src/tools/config.ts';
+import { pieceExpr, type DateSpec } from './date.ts';
 import { checkNames, conditionCode, float, leading, pascal, snake, stringLiteral, wordsOf } from './emit.ts';
 import type { NativeMessage, NativeModel, Part } from './model.ts';
 import type { NumberSpec } from './number.ts';
@@ -50,6 +51,7 @@ function value(part: Exclude<Part, { type: 'text' }>, indent: string): string {
     const of = part.offset === 0 ? argName(part.arg) : `${argName(part.arg)} - ${float(part.offset)}`;
     return `rt::number(${of}, &rt::F${part.format}, ${lit(part.fallback)})`;
   }
+  if (part.type === 'date') return `rt::D${part.format}(&${argName(part.arg)})`;
   if (part.type === 'select') {
     const arms = part.arms.map((a) => `${inner}${lit(a.key)} => ${expr(a.parts, inner)},\n`).join('');
     return `match ${argName(part.arg)} {\n${arms}${inner}_ => ${expr(part.other, inner)},\n${indent}}`;
@@ -74,7 +76,9 @@ function method(m: NativeMessage, name: string, enumName: string): string {
   const isStatic = m.bodies.every((b) => b.parts.every((p) => p.type === 'text'));
   if (isStatic && m.args.length === 0)
     return `${head}    pub fn ${name}(self) -> &'static str {\n        match self {\n${arms((parts) => lit(parts[0]?.type === 'text' ? parts[0].value : ''))}        }\n    }\n`;
-  const params = m.args.map((a) => `, ${argName(a.name)}: ${a.type === 'number' ? 'impl Number' : '&str'}`).join('');
+  const params = m.args
+    .map((a) => `, ${argName(a.name)}: ${a.type === 'number' ? 'impl Number' : a.type === 'date' ? 'DateTime' : '&str'}`)
+    .join('');
   const argDocs = m.args.filter((a) => a.doc !== undefined).map((a) => `* \`${argName(a.name)}\`: ${a.doc}`);
   const docs = argDocs.length > 0 ? `${head}    ///\n${doc(argDocs, '    ')}` : head;
   const numbers = m.args
@@ -107,6 +111,81 @@ function formatConst(spec: NumberSpec, i: number): string {
   return `    pub const F${i}: Format = Format {\n${fields.map((f) => `        ${f},\n`).join('')}    };\n`;
 }
 
+/** A date format as a function of the date. */
+function dateFn(spec: DateSpec, i: number): string {
+  const digits = spec.digits === undefined ? 'None' : `Some(G${i})`;
+  const at = (field: string) => (field === 'weekday' ? 't.weekday() as i64' : `t.${field} as i64`);
+  const lines = spec.pieces.map((piece) => {
+    if (piece.type === 'text') return `s += ${lit(piece.value)};`;
+    if (piece.type === 'name') return `s += [${piece.names.map(lit).join(', ')}][(${pieceExpr(piece, at)}) as usize];`;
+    return `s += &pad(${pieceExpr(piece, at)}, ${piece.pad}, ${digits});`;
+  });
+  const table = spec.digits === undefined ? '' : `    const G${i}: [&str; 10] = [${spec.digits.map(lit).join(', ')}];\n`;
+  const body = lines.map((l) => `        ${l}\n`).join('');
+  return `${table}    pub fn D${i}(t: &super::DateTime) -> String {\n        let mut s = String::new();\n${body}        s\n    }\n`;
+}
+
+const DATE = `
+    /// \`value\` written with at least \`width\` digits, in \`digits\` where the locale has its own.
+    fn pad(value: i64, width: usize, digits: Option<[&'static str; 10]>) -> String {
+        let text = format!("{:0width$}", value, width = width);
+        match digits {
+            Some(digits) => text.bytes().map(|b| if b.is_ascii_digit() { digits[(b - b'0') as usize] } else { "-" }).collect(),
+            None => text,
+        }
+    }
+`;
+
+const DATE_TIME = `
+/// A date and time as a clock shows it, in the time zone it is shown in.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct DateTime {
+    pub year: i32,
+    /// 1 to 12.
+    pub month: u8,
+    pub day: u8,
+    /// 0 to 23.
+    pub hour: u8,
+    pub minute: u8,
+    pub second: u8,
+}
+
+impl DateTime {
+    /// The time \`seconds\` after the Unix epoch, on a clock \`offset\` seconds ahead of UTC: the
+    /// local time's offset where it is shown, which Rust's standard library can't look up.
+    pub fn from_unix(seconds: i64, offset: i32) -> DateTime {
+        let local = seconds + offset as i64;
+        let (days, time) = (local.div_euclid(86_400), local.rem_euclid(86_400));
+        // Howard Hinnant's civil_from_days: the Gregorian date \`days\` after 1970-01-01.
+        let z = days + 719_468;
+        let (era, doe) = (z.div_euclid(146_097), z.rem_euclid(146_097));
+        let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
+        let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
+        let mp = (5 * doy + 2) / 153;
+        let month = if mp < 10 { mp + 3 } else { mp - 9 };
+        DateTime {
+            year: (yoe + era * 400 + if month <= 2 { 1 } else { 0 }) as i32,
+            month: month as u8,
+            day: (doy - (153 * mp + 2) / 5 + 1) as u8,
+            hour: (time / 3600) as u8,
+            minute: (time / 60 % 60) as u8,
+            second: (time % 60) as u8,
+        }
+    }
+
+    /// The day of the week, 0 for Sunday.
+    pub fn weekday(self) -> u8 {
+        // days_from_civil, its inverse.
+        let m = self.month as i64;
+        let y = self.year as i64 - if m <= 2 { 1 } else { 0 };
+        let (era, yoe) = (y.div_euclid(400), y.rem_euclid(400));
+        let doy = (153 * (if m > 2 { m - 3 } else { m + 9 }) + 2) / 5 + self.day as i64 - 1;
+        let days = era * 146_097 + yoe * 365 + yoe / 4 - yoe / 100 + doy - 719_468;
+        (days + 4).rem_euclid(7) as u8
+    }
+}
+`;
+
 const NUMBER = `
     /// A number format, taken apart when the file was generated.
     pub struct Format {
@@ -300,6 +379,8 @@ export function rustModule(model: NativeModel, target: NativeTarget & { name: st
   const tags = model.locales.map((l) => `            ${name}::${variant(l)} => ${lit(l)},\n`).join('');
   const methods = model.messages.map((m, i) => method(m, names[i]![1], name)).join('\n');
   const usesNumbers = model.messages.some((m) => m.args.some((a) => a.type === 'number'));
+  const usesDates = model.dates.length > 0;
+  const usesFormats = model.formats.length + model.rules.length > 0;
   const rules = model.rules
     .map(({ name: rule, rules }, i) => {
       const checks = rules.map(
@@ -310,17 +391,17 @@ export function rustModule(model: NativeModel, target: NativeTarget & { name: st
     })
     .join('\n');
   const runtime =
-    model.formats.length + model.rules.length === 0
+    !usesFormats && !usesDates
       ? ''
       : `
 /// What formats the messages, generated with them.
-mod rt {${NUMBER}${model.rules.length > 0 ? PLURAL : ''}
-${model.formats.map(formatConst).join('\n')}${rules === '' ? '' : `\n${rules}`}}
+mod rt {${usesFormats ? NUMBER : ''}${model.rules.length > 0 ? PLURAL : ''}${usesDates ? DATE : ''}
+${[...model.formats.map(formatConst), ...model.dates.map(dateFn)].join('\n')}${rules === '' ? '' : `\n${rules}`}}
 `;
 
   return `${banner}
 #![allow(dead_code, non_snake_case, clippy::all)]
-${usesNumbers ? NUMBER_TRAIT : ''}
+${usesNumbers ? NUMBER_TRAIT : ''}${usesDates ? DATE_TIME : ''}
 /// A locale the catalog is written or translated in, and its messages.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum ${name} {

package/src/tools/native/swift.ts

@@ -3,6 +3,7 @@
  * message, and a file-private enum holding what formats them.
  */
 import type { NativeTarget } from '#src/tools/config.ts';
+import { pieceExpr, type DateSpec } from './date.ts';
 import { camel, checkNames, conditionCode, float, leading, stringLiteral, wordsOf } from './emit.ts';
 import type { NativeMessage, NativeModel, Part } from './model.ts';
 import type { NumberSpec } from './number.ts';
@@ -36,6 +37,7 @@ function value(part: Exclude<Part, { type: 'text' }>, indent: string, rt: string
     const of = part.offset === 0 ? argName(part.arg) : `${argName(part.arg)} - ${float(part.offset)}`;
     return `${rt}.number(${of}, ${rt}.f${part.format}, ${lit(part.fallback)})`;
   }
+  if (part.type === 'date') return `${rt}.d${part.format}(${argName(part.arg)})`;
   if (part.type === 'select') {
     const arms = part.arms.map((a) => `${inner}case ${lit(a.key)}: return ${expr(a.parts, inner, rt)}\n`).join('');
     return `{ () -> String in\n${inner}switch ${argName(part.arg)} {\n${arms}${inner}default: return ${expr(part.other, inner, rt)}\n${inner}}\n${indent}}()`;
@@ -66,10 +68,17 @@ function member(m: NativeMessage, name: string, rt: string, number: NumberProtoc
   const head = doc(argDocs.length > 0 ? [...m.doc, '', ...argDocs] : m.doc, '    ');
   const body = `        switch self {\n${cases((parts) => expr(parts, '        ', rt))}        }\n`;
   if (m.args.length === 0) return `${head}    public var ${name}: String {\n${body}    }\n`;
-  const params = m.args.map((a) => `${argName(a.name)}: ${a.type === 'number' ? `some ${number.type}` : 'String'}`).join(', ');
+  const params = m.args
+    .map((a) => `${argName(a.name)}: ${a.type === 'number' ? `some ${number.type}` : a.type === 'date' ? 'Date' : 'String'}`)
+    .join(', ');
   const numbers = m.args
-    .filter((a) => a.type === 'number')
-    .map((a) => `        let ${argName(a.name)} = ${argName(a.name)}.${number.value}\n`)
+    .map((a) =>
+      a.type === 'number'
+        ? `        let ${argName(a.name)} = ${argName(a.name)}.${number.value}\n`
+        : a.type === 'date'
+          ? `        let ${argName(a.name)} = ${rt}.clock(${argName(a.name)})\n`
+          : '',
+    )
     .join('');
   return `${head}    public func ${name}(${params}) -> String {\n${numbers}${body}    }\n`;
 }
@@ -97,6 +106,51 @@ function formatConst(spec: NumberSpec, i: number): string {
   return `    static let f${i} = Format(\n${fields.map((f) => `        ${f}`).join(',\n')}\n    )\n`;
 }
 
+/** A date format as a function of the clock's fields. */
+function dateFn(spec: DateSpec, i: number): string {
+  const digits = spec.digits === undefined ? 'nil' : `g${i}`;
+  const at = (field: string) => `t.${field}`;
+  const lines = spec.pieces.map((piece) => {
+    if (piece.type === 'text') return `s += ${lit(piece.value)}`;
+    if (piece.type === 'name') return `s += [${piece.names.map(lit).join(', ')}][${pieceExpr(piece, at)}]`;
+    return `s += pad(${pieceExpr(piece, at)}, ${piece.pad}, ${digits})`;
+  });
+  const table = spec.digits === undefined ? '' : `    static let g${i} = [${spec.digits.map(lit).join(', ')}]\n`;
+  const body = lines.map((l) => `        ${l}\n`).join('');
+  return `${table}    static func d${i}(_ t: Clock) -> String {\n        var s = ""\n${body}        return s\n    }\n`;
+}
+
+const DATE = `
+    /// A date as the clock shows it in the device's time zone; \`weekday\` is 0 for Sunday.
+    struct Clock {
+        let year: Int
+        let month: Int
+        let day: Int
+        let hour: Int
+        let minute: Int
+        let second: Int
+        let weekday: Int
+    }
+
+    static func clock(_ date: Date) -> Clock {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = .current
+        let c = calendar.dateComponents([.year, .month, .day, .hour, .minute, .second, .weekday], from: date)
+        return Clock(
+            year: c.year ?? 0, month: c.month ?? 1, day: c.day ?? 1, hour: c.hour ?? 0, minute: c.minute ?? 0,
+            second: c.second ?? 0, weekday: (c.weekday ?? 1) - 1
+        )
+    }
+
+    /// \`value\` written with at least \`width\` digits, in \`digits\` where the locale has its own.
+    private static func pad(_ value: Int, _ width: Int, _ digits: [String]?) -> String {
+        var text = String(value)
+        while text.count < width { text = "0" + text }
+        guard let digits else { return text }
+        return text.map { c in c.wholeNumberValue.map { digits[$0] } ?? String(c) }.joined()
+    }
+`;
+
 const NUMBER = `
     /// A number format, taken apart when the file was generated.
     struct Format {
@@ -265,6 +319,8 @@ export function swiftFile(model: NativeModel, target: NativeTarget & { name: str
   const number = { type: `${name}Number`, value: `${name.charAt(0).toLowerCase()}${name.slice(1)}Value` };
   const members = model.messages.map((m, i) => member(m, names[i]![1], rt, number)).join('\n');
   const usesNumbers = model.messages.some((m) => m.args.some((a) => a.type === 'number'));
+  const usesDates = model.dates.length > 0;
+  const usesFormats = model.formats.length + model.rules.length > 0;
   const numberProtocol = !usesNumbers
     ? ''
     : `
@@ -285,12 +341,12 @@ ${NUMBER_TYPES.map((t) => `extension ${t}: ${number.type} { public var ${number.
     })
     .join('\n');
   const runtime =
-    model.formats.length + model.rules.length === 0
+    !usesFormats && !usesDates
       ? ''
       : `
 /// What formats the messages, generated with them.
-private enum ${rt} {${NUMBER}${model.rules.length > 0 ? PLURAL : ''}
-${model.formats.map(formatConst).join('\n')}${rules === '' ? '' : `\n${rules}`}}
+private enum ${rt} {${usesFormats ? NUMBER : ''}${model.rules.length > 0 ? PLURAL : ''}${usesDates ? DATE : ''}
+${[...model.formats.map(formatConst), ...model.dates.map(dateFn)].join('\n')}${rules === '' ? '' : `\n${rules}`}}
 `;
 
   return `${banner}