@prestack/thread-ui 0.0.1 → 0.0.2

package/dist/ui/generators/variants.ts

@@ -0,0 +1,205 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { basename, dirname, join, resolve } from 'node:path'
+import { argv, stdout } from 'node:process'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+import { exit, invoked } from '@prestack/thread/core/invoked'
+import type { Threaded } from '@prestack/thread/core/thread'
+import { findTree, inTree, strayFiles } from '@prestack/thread/core/tree'
+
+export function nameOf(id: string): string {
+  return id.replace(/-/g, '_').toUpperCase()
+}
+
+function starter(row: Threaded): string {
+  return `import { variant } from '../variant.ts'
+
+export const ${nameOf(row.id)} = variant({
+  id: '${row.id}',
+  sets: [],
+  reacts: [],
+} as const)
+`
+}
+
+export function seeds(
+  rows: readonly Threaded[],
+  has: (at: string) => boolean,
+): readonly { readonly path: string; readonly content: string }[] {
+  return rows.filter((row) => !has(row.at)).map((row) => ({ path: row.at, content: starter(row) }))
+}
+
+export async function mismatched(
+  rows: readonly Threaded[],
+  loader: (row: Threaded) => Promise<{ readonly id?: string } | undefined>,
+): Promise<readonly string[]> {
+  const found: string[] = []
+  for (const row of rows) {
+    const variant = await loader(row)
+    if (variant === undefined) {
+      found.push(
+        `\`${row.id}\` is declared at \`${row.at}\`, and that file exports no \`${nameOf(row.id)}\`. ` +
+          'A row names a file, and the file is the thing.',
+      )
+      continue
+    }
+    if (variant.id !== row.id) {
+      found.push(
+        `\`${row.at}\` declares itself \`${String(variant.id)}\`, and the row that names it calls it \`${row.id}\`. ` +
+          "A variant file and the row that names it have to be the same variant — make the file's `id` match the row, or fix the row.",
+      )
+    }
+  }
+  return found
+}
+
+function extensionOf(path: string): string {
+  const name = basename(path)
+  const at = name.lastIndexOf('.')
+  return at === -1 ? '' : name.slice(at)
+}
+
+const VAR_PREFIX = /^var_/
+
+export function orphaned(rows: readonly Threaded[], strays: readonly string[]): readonly string[] {
+  const named = new Set(rows.map((row) => row.at))
+  return strays
+    .filter((one) => !named.has(one))
+    .map(
+      (one) =>
+        `\`${one}\` is under variants and no row names it — not a variant, a file somebody wrote. ` +
+        'Add a row for it, or delete the file.',
+    )
+}
+
+const GUARDED = /=\s*variant\s*\(/
+
+const TYPED = /import type \{ Variant \} from '([^']*)'/
+
+const OPENS = /export const ([A-Z0-9_]+) = \{/
+
+const CLOSES = /\} as const satisfies Variant/
+
+export function unguarded(rows: readonly Threaded[], read: (at: string) => string): readonly string[] {
+  return rows
+    .filter((row) => !GUARDED.test(read(row.at)))
+    .map(
+      (row) =>
+        `\`${row.at}\` declares \`${row.id}\` with \`satisfies Variant\`, which accepts a value no ` +
+        'row holds — `satisfies` checks against `string`, so `8px` and `var(--x)` compile. Run ' +
+        '`thread variants` and it rewrites the two lines that wrap the declaration, leaving what is ' +
+        'between them alone.',
+    )
+}
+
+export function guarding(source: string): string | undefined {
+  if (GUARDED.test(source)) return undefined
+  const typed = TYPED.exec(source)
+  const opens = OPENS.exec(source)
+  if (typed === null || opens === null || !CLOSES.test(source)) return undefined
+  return source
+    .replace(typed[0], `import { variant } from '${typed[1] ?? ''}'`)
+    .replace(opens[0], `export const ${opens[1] ?? ''} = variant({`)
+    .replace(CLOSES, '} as const)')
+}
+
+const SHEET = `variants.${'ts'}`
+
+const MINE = `variants.${'ts'}`
+
+async function run(): Promise<number> {
+  const own = argv.includes('--own')
+
+  const held = own
+    ? ((await import(pathToFileURL(resolve(fileURLToPath(import.meta.url), '../..', MINE)).href)) as {
+        VARIANTS?: { readonly declares?: readonly Threaded[] }
+      })
+    : undefined
+
+  const tree = own ? undefined : findTree()
+  const root = tree === undefined ? resolve(fileURLToPath(import.meta.url), '../../../../..') : tree.at
+  if (tree !== undefined && !existsSync(inTree(tree, SHEET))) {
+    stdout.write(`thread: this tree has no ${tree.name}/${SHEET}, so it declares no variant and there is nothing to seed or check.\n`)
+    return 0
+  }
+  const sheet =
+    tree === undefined
+      ? { VARIANT: held?.VARIANTS }
+      : ((await import(pathToFileURL(inTree(tree, SHEET)).href)) as {
+          VARIANT?: { readonly declares?: readonly Threaded[] }
+        })
+
+  if (sheet.VARIANT === undefined) {
+    stdout.write(
+      own
+        ? `variants: this package's own ${MINE} exports no \`VARIANTS\`.\n`
+        : `thread: ${String(tree?.name)}/${SHEET} exports no \`VARIANT\`, so nothing declares a variant here.\n`,
+    )
+    return 1
+  }
+
+  const rows = sheet.VARIANT.declares ?? []
+  const checking = argv.includes('--check')
+  const exists = (where: string): boolean => existsSync(join(root, where))
+  const made = seeds(rows, exists)
+
+  if (checking) {
+    const unseeded = rows.find((row) => !exists(row.at))
+    if (unseeded !== undefined) {
+      stdout.write(
+        `thread: \`${unseeded.id}\` is declared at \`${unseeded.at}\`, and the file is not there yet. ` +
+          'A row names a file, and `--check` never writes one — run `thread variants` and commit what it seeds.\n',
+      )
+      return 1
+    }
+  } else {
+    for (const seed of made) {
+      mkdirSync(dirname(join(root, seed.path)), { recursive: true })
+      writeFileSync(join(root, seed.path), seed.content, 'utf8')
+      stdout.write(`thread: seeded ${seed.path}\n`)
+    }
+  }
+
+  const wrong = (
+    await mismatched(rows, async (row) => {
+      const module = (await import(pathToFileURL(join(root, row.at)).href)) as Record<string, unknown>
+      return module[nameOf(row.id)] as { readonly id?: string } | undefined
+    })
+  )[0]
+  if (wrong !== undefined) {
+    stdout.write(`thread: ${wrong}\n`)
+    return 1
+  }
+
+  const read = (at: string): string => readFileSync(join(root, at), 'utf8')
+  if (checking) {
+    const loose = unguarded(rows, read)[0]
+    if (loose !== undefined) {
+      stdout.write(`thread: ${loose}\n`)
+      return 1
+    }
+  } else {
+    for (const row of rows) {
+      const written = guarding(read(row.at))
+      if (written === undefined) continue
+      writeFileSync(join(root, row.at), written, 'utf8')
+      stdout.write(`thread: ${row.at} now declares through \`variant(...)\`\n`)
+    }
+  }
+
+  const stray = orphaned(rows, strayFiles(root, 'var_', '.' + 'ts'))[0]
+  if (stray !== undefined) {
+    stdout.write(`thread: ${stray}\n`)
+    return 1
+  }
+
+  stdout.write(
+    checking
+      ? `thread: ${String(rows.length)} variant(s) declared, all seeded\n`
+      : `thread: ${String(rows.length)} variant(s) declared, ${String(made.length)} seeded, ` +
+        `${String(rows.length - made.length)} already written\n`,
+  )
+  return 0
+}
+
+if (invoked(import.meta.url)) exit(await run())

package/dist/ui/i18n/catalogs/en.ts

@@ -0,0 +1,191 @@
+
+
+import { defineCatalog, msg } from '../types.ts'
+
+export const en = defineCatalog({
+
+  'errors.auth.unauthenticated.title': 'You need to sign in to do this',
+  'errors.auth.invalid_credentials.title': 'That email or password did not match',
+  'errors.auth.token_expired.title': 'Your session expired — sign in again',
+  'errors.auth.token_reused.title': 'This sign-in link was already used, so we signed you out everywhere',
+  'errors.auth.session_revoked.title': 'This session was signed out',
+  'errors.auth.denied.title': 'You do not have permission to do this',
+
+  'errors.quota.exceeded.title': 'You have used everything included in your plan',
+  'errors.quota.reservation_expired.title': 'That request took too long and was released',
+
+  'errors.rate_limit.exceeded.title': 'Too many attempts — wait a moment and try again',
+
+  'errors.feature.not_in_plan.title': 'Your plan does not include this feature',
+
+  'errors.db.not_found.title': 'We could not find that',
+  'errors.db.constraint_violation.title': 'That change would break a rule on this data',
+  'errors.db.already_exists.title': 'That already exists',
+  'errors.db.conflict.title': 'Someone else changed this first — reload and try again',
+  'errors.db.migration_checksum_mismatch.title': 'A migration that already ran has been edited',
+  'errors.db.destructive_without_dry_run.title': 'This change can delete data, so it needs a test run first',
+  'errors.db.round_trip_budget_exceeded.title': 'This node asked the database for more than it was built to need',
+  'errors.db.cursor_invalid.title': 'That link to the next page does not belong to this list',
+  'errors.db.cursor_expired.title': 'That link to the next page is too old — start again from the first page',
+
+  'errors.workflow.node_failed.title': 'A node in this process failed',
+  'errors.workflow.invalid_transition.title': 'This process cannot move to that state from here',
+  'errors.workflow.compensation_failed.title': 'We could not undo a failed process — someone needs to look at this',
+  'errors.workflow.already_running.title': 'This is already running — wait for it to finish before starting another',
+
+  'errors.queue.job_failed.title': 'A background job failed',
+  'errors.queue.dlq_exhausted.title': 'A background job failed too many times and was set aside',
+
+  'errors.ai.provider_unavailable.title': 'The AI service is not responding',
+  'errors.ai.schema_validation_failed.title': 'The AI returned something we could not use',
+  'errors.ai.tool_not_in_mask.title': 'The AI tried to use a tool it is not allowed to use',
+  'errors.ai.node_cap_exceeded.title': 'The AI took too many turns and was stopped',
+
+  'errors.search.index_failed.title': 'We could not add that to the search index',
+  'errors.search.query_invalid.title': 'That search is not valid',
+
+  'errors.comms.channel_kind_undeclared.title': 'A way of messaging was added without a name',
+  'errors.comms.channel_kind_undescribed.title': 'A way of messaging was added without a description',
+  'errors.comms.channel_kind_unlabelled.title': 'A way of messaging has no name people can be shown',
+  'errors.comms.channel_kind_undocumented.title': 'A way of messaging was added with no instructions for using it',
+  'errors.comms.channel_kind_duplicate.title': 'Two ways of messaging were added under the same name',
+
+  'errors.config.invalid.title': 'The configuration is not valid',
+  'errors.config.missing_env.title': 'A required setting is missing',
+  'errors.config.secret_in_public_var.title': 'A secret is named so the browser would see it',
+  'errors.config.credential_invalid.title': 'That credential was not accepted',
+  'errors.config.scope_missing.title': 'That credential does not have the access this needs',
+  'errors.config.resource_not_found.title': 'That credential works, but the resource it points to was not found',
+  'errors.config.destination_incompatible.title': 'The destination cannot receive this — check its plan',
+  'errors.config.blocks_exit.title': 'This was set up in a way that blocks moving it out — contact support',
+
+  'errors.net.timeout.title': 'That took too long',
+  'errors.net.upstream_unavailable.title': 'A service we depend on is down',
+  'errors.net.destination_refused.title': 'That address cannot receive webhooks',
+
+  'errors.internal.unexpected.title': 'Something went wrong on our side',
+  'errors.internal.not_implemented.title': 'This is not built yet',
+  'errors.internal.invalid_argument.title': 'Some of the information sent was not valid',
+
+  'quota.exceeded.detail': msg<{ used: number; allowance: number; meter: string }>(
+    '{used, number} of {allowance, number} {meter} used.',
+  ),
+  'rate_limit.retry_after': msg<{ seconds: number }>(
+    'Try again in {seconds, plural, one {# second} other {# seconds}}.',
+  ),
+
+  'migration.impact.rows': msg<{ rows: number; table: string }>(
+    '{rows, plural, =0 {No rows} one {# row} other {# rows}} in {table} will be affected.',
+  ),
+  'migration.dry_run.required': 'Run this on a test copy before applying it.',
+  'sandbox.created': 'Test environment ready.',
+  'sandbox.torn_down': 'Test environment removed.',
+
+  'platform.event.deploy_reverted.version_id': 'Restored version',
+  'platform.event.deploy_reverted.description': 'A prior version was restored by a new forward deployment.',
+
+  'billing.invoice.total': msg<{ total: { amount: number; currency: string } }>(
+    'Total: {total, money}.',
+  ),
+  'billing.invoice.due': msg<{ due: Date | number }>('Due {due, date, medium}.'),
+  'billing.usage.summary': msg<{ cost: { amount: number; currency: string }; calls: number }>(
+    '{calls, plural, one {# call} other {# calls}} costing {cost, money}.',
+  ),
+
+  'common.empty': 'Nothing here yet.',
+  'common.loading': 'Loading…',
+  'common.error': 'Something went wrong.',
+  'common.retry': 'Try again',
+  'common.cancel': 'Cancel',
+  'common.confirm': 'Confirm',
+  'common.saved': 'Saved.',
+
+  'comms.kind.email.label': 'Email',
+  'comms.kind.internal.label': 'Internal message',
+  'comms.kind.push.label': 'Push notification',
+  'comms.kind.widget.label': 'Live chat',
+
+  'auth.ui.signIn.title': 'Sign in',
+  'auth.ui.signIn.submit': 'Sign in',
+  'auth.ui.signUp.title': 'Create your account',
+  'auth.ui.signUp.submit': 'Create account',
+  'auth.ui.field.email': 'Email',
+  'auth.ui.field.password': 'Password',
+  'auth.ui.field.name': 'Name',
+  'auth.ui.field.code': 'Code',
+  'auth.ui.field.optional': 'optional',
+  'auth.ui.magicLink.submit': 'Email me a sign-in link',
+  'auth.ui.magicLink.sent': 'If that address can be used, we have sent it a sign-in link.',
+  'auth.ui.otp.submit': 'Email me a code',
+  'auth.ui.otp.confirm': 'Sign in with the code',
+  'auth.ui.otp.sent': 'If that address can be used, we have sent it a code.',
+  'auth.ui.reset.submit': 'Email me a reset link',
+  'auth.ui.reset.sent': 'If that address can be used, we have sent it a reset link.',
+  'auth.ui.oauth.continueWith': msg<{ provider: string }>('Continue with {provider}'),
+  'auth.ui.passkey.signIn': 'Use a passkey',
+  'auth.ui.passkey.register': 'Add a passkey',
+  'auth.ui.passkey.added': 'Passkey added. You can use it to sign in from now on.',
+  'auth.ui.passkey.unsupported': 'This browser cannot use passkeys.',
+
+  'auth.ui.passkey.cancelled': 'Passkey sign-in was cancelled.',
+  'auth.ui.passkey.failed': 'That passkey could not be used.',
+
+  'consent.telemetry.label': 'Product analytics',
+  'consent.telemetry.describe':
+    'Which screens you visit and which buttons you press, so we can see where this app is confusing. Never what you type — passwords, messages and form contents are not recorded.',
+  'consent.title': 'Choose what you share',
+  'consent.accept': 'Accept selected',
+  'consent.acceptAll': 'Accept all',
+  'consent.decline': 'Decline all',
+  'consent.withdraw': 'Withdraw consent',
+  'consent.required': 'Always on',
+  'auth.ui.switch.toSignUp': 'Need an account? Create one',
+  'auth.ui.switch.toSignIn': 'Already have an account? Sign in',
+  'auth.ui.switch.toReset': 'Forgotten your password?',
+  'auth.ui.switch.back': 'Back',
+  'auth.ui.working': 'Working…',
+  'auth.ui.separator': 'or',
+
+  'auth.ui.error.generic': 'That did not work. Check what you entered and try again.',
+  'auth.ui.error.offline': 'We could not reach the server. Check your connection and try again.',
+  'auth.ui.signedIn': 'You are signed in.',
+
+  'auth.provider.google': 'Google',
+  'auth.provider.apple': 'Apple',
+  'auth.provider.github': 'GitHub',
+  'auth.provider.microsoft': 'Microsoft',
+  'validation.required': 'This is required.',
+  'validation.text.invalid': 'Enter some text.',
+  'validation.text.too_long': 'This is too long.',
+  'validation.richtext.invalid': 'This content could not be read.',
+  'validation.richtext.too_many_blocks': 'This content is too long.',
+  'validation.number.invalid': 'Enter a number.',
+  'validation.number.below_min': 'This is below the lowest value allowed.',
+  'validation.number.above_max': 'This is above the highest value allowed.',
+  'validation.integer.invalid': 'Enter a whole number.',
+  'validation.money.invalid': 'Enter an amount.',
+
+  'validation.money.bare_number': 'An amount needs a currency. Choose one and enter the amount again.',
+  'validation.percent.range': 'Enter a number between 0 and 100.',
+  'validation.duration.negative': 'A length of time cannot be negative.',
+  'validation.bool.invalid': 'Choose yes or no.',
+  'validation.date.format': 'Enter a date as YYYY-MM-DD.',
+  'validation.date.invalid': 'That date does not exist.',
+  'validation.datetime.format': 'Enter a date and time.',
+  'validation.phone.invalid': 'Enter a phone number with 6 to 15 digits.',
+  'validation.email.invalid': 'Enter an email address.',
+
+  'validation.password.tooShort': 'Use at least 8 characters.',
+  'validation.otp.invalid': 'Enter the 6-digit code.',
+  'validation.url.invalid': 'Enter a web address.',
+  'validation.url.scheme': 'Only web, email and phone links are allowed.',
+  'validation.ref.invalid': 'That file could not be found.',
+  'validation.geo.invalid': 'Enter a location.',
+  'validation.rating.range': 'Choose a rating.',
+  'validation.select.undeclared': 'Choose one of the options.',
+  'validation.json.too_deep': 'This data is nested too deeply.',
+  'validation.json.too_large': 'This data is too large.',
+
+})
+
+export type EnCatalog = typeof en

package/dist/ui/i18n/format.ts

@@ -0,0 +1,221 @@
+
+
+import { type Money, type Node, parseMessage } from './parse.ts'
+import type { Locale } from './types.ts'
+
+export class MissingParamError extends Error {
+  readonly param: string
+  constructor(param: string, message: string) {
+    super(`missing parameter "${param}" for message ${JSON.stringify(message)}`)
+    this.name = 'MissingParamError'
+    this.param = param
+  }
+}
+
+export class ParamTypeError extends Error {
+  constructor(param: string, expected: string, received: unknown) {
+    super(`parameter "${param}" must be ${expected}, received ${typeof received}`)
+    this.name = 'ParamTypeError'
+  }
+}
+
+export interface FormatOptions {
+  readonly locale: Locale
+
+  readonly timeZone?: string
+}
+
+const numberFormats = new Map<string, Intl.NumberFormat>()
+const dateFormats = new Map<string, Intl.DateTimeFormat>()
+const pluralRules = new Map<string, Intl.PluralRules>()
+
+function numberFormat(locale: Locale, style: string | undefined): Intl.NumberFormat {
+  const key = `${locale}|${style ?? ''}`
+  let fmt = numberFormats.get(key)
+  if (!fmt) {
+    const options: Intl.NumberFormatOptions =
+      style === 'percent'
+        ? { style: 'percent' }
+        : style === 'integer'
+          ? { maximumFractionDigits: 0 }
+          : {}
+    fmt = new Intl.NumberFormat(locale, options)
+    numberFormats.set(key, fmt)
+  }
+  return fmt
+}
+
+function moneyFormat(locale: Locale, currency: string): Intl.NumberFormat {
+  const key = `${locale}|money|${currency}`
+  let fmt = numberFormats.get(key)
+  if (!fmt) {
+    fmt = new Intl.NumberFormat(locale, { style: 'currency', currency })
+    numberFormats.set(key, fmt)
+  }
+  return fmt
+}
+
+type DateStyle = 'full' | 'long' | 'medium' | 'short'
+const DATE_STYLES = new Set<string>(['full', 'long', 'medium', 'short'])
+
+function dateFormat(
+  locale: Locale,
+  kind: 'date' | 'time',
+  style: string | undefined,
+  timeZone: string | undefined,
+): Intl.DateTimeFormat {
+  const resolved: DateStyle = DATE_STYLES.has(style ?? '') ? (style as DateStyle) : 'medium'
+  const key = `${locale}|${kind}|${resolved}|${timeZone ?? ''}`
+  let fmt = dateFormats.get(key)
+  if (!fmt) {
+    const options: Intl.DateTimeFormatOptions =
+      kind === 'date' ? { dateStyle: resolved } : { timeStyle: resolved }
+    if (timeZone !== undefined) options.timeZone = timeZone
+    fmt = new Intl.DateTimeFormat(locale, options)
+    dateFormats.set(key, fmt)
+  }
+  return fmt
+}
+
+function plural(locale: Locale, ordinal: boolean): Intl.PluralRules {
+  const key = `${locale}|${ordinal ? 'ordinal' : 'cardinal'}`
+  let rules = pluralRules.get(key)
+  if (!rules) {
+    rules = new Intl.PluralRules(locale, { type: ordinal ? 'ordinal' : 'cardinal' })
+    pluralRules.set(key, rules)
+  }
+  return rules
+}
+
+function requireParam(
+  params: Readonly<Record<string, unknown>>,
+  name: string,
+  source: string,
+): unknown {
+  if (!(name in params) || params[name] === undefined) {
+    throw new MissingParamError(name, source)
+  }
+  return params[name]
+}
+
+function asNumber(value: unknown, name: string): number {
+  if (typeof value !== 'number' || Number.isNaN(value)) {
+    throw new ParamTypeError(name, 'a number', value)
+  }
+  return value
+}
+
+function asMoney(value: unknown, name: string): Money {
+  if (
+    typeof value !== 'object' ||
+    value === null ||
+    typeof (value as Money).amount !== 'number' ||
+    typeof (value as Money).currency !== 'string' ||
+    (value as Money).currency === ''
+  ) {
+
+    throw new ParamTypeError(name, 'a { amount, currency } pair', value)
+  }
+  return value as Money
+}
+
+function asDate(value: unknown, name: string): Date | number {
+  if (value instanceof Date) return value
+  if (typeof value === 'number') return value
+  throw new ParamTypeError(name, 'a Date or a timestamp', value)
+}
+
+interface RenderContext {
+  readonly locale: Locale
+  readonly timeZone: string | undefined
+  readonly params: Readonly<Record<string, unknown>>
+  readonly source: string
+
+  readonly poundValue: number | undefined
+}
+
+function render(nodes: readonly Node[], ctx: RenderContext): string {
+  let out = ''
+
+  for (const node of nodes) {
+    switch (node.kind) {
+      case 'text':
+        out += node.value
+        break
+
+      case 'pound':
+        out +=
+          ctx.poundValue === undefined
+            ? '#'
+            : numberFormat(ctx.locale, undefined).format(ctx.poundValue)
+        break
+
+      case 'arg': {
+        const value = requireParam(ctx.params, node.name, ctx.source)
+        out += typeof value === 'number' ? numberFormat(ctx.locale, undefined).format(value) : String(value)
+        break
+      }
+
+      case 'number': {
+        const value = asNumber(requireParam(ctx.params, node.name, ctx.source), node.name)
+        out += numberFormat(ctx.locale, node.style).format(value)
+        break
+      }
+
+      case 'money': {
+        const value = asMoney(requireParam(ctx.params, node.name, ctx.source), node.name)
+        out += moneyFormat(ctx.locale, value.currency).format(value.amount)
+        break
+      }
+
+      case 'date': {
+        const value = asDate(requireParam(ctx.params, node.name, ctx.source), node.name)
+        out += dateFormat(ctx.locale, 'date', node.style, ctx.timeZone).format(value)
+        break
+      }
+
+      case 'time': {
+        const value = asDate(requireParam(ctx.params, node.name, ctx.source), node.name)
+        out += dateFormat(ctx.locale, 'time', node.style, ctx.timeZone).format(value)
+        break
+      }
+
+      case 'plural': {
+        const value = asNumber(requireParam(ctx.params, node.name, ctx.source), node.name)
+        const adjusted = value - node.offset
+
+        let body = node.options.get(`=${value}`)
+        if (!body) {
+          const category = plural(ctx.locale, node.ordinal).select(adjusted)
+          body = node.options.get(category) ?? node.options.get('other')
+        }
+
+        out += render(body ?? [], { ...ctx, poundValue: adjusted })
+        break
+      }
+
+      case 'select': {
+        const value = requireParam(ctx.params, node.name, ctx.source)
+        const body = node.options.get(String(value)) ?? node.options.get('other')
+        out += render(body ?? [], ctx)
+        break
+      }
+    }
+  }
+
+  return out
+}
+
+export function formatMessage(
+  source: string,
+  params: Readonly<Record<string, unknown>>,
+  opts: FormatOptions,
+): string {
+  return render(parseMessage(source), {
+    locale: opts.locale,
+    timeZone: opts.timeZone,
+    params,
+    source,
+    poundValue: undefined,
+  })
+}

package/dist/ui/i18n/locales.ts

@@ -0,0 +1,33 @@
+
+
+export const REFERENCE_LOCALE = 'en'
+
+export interface LocaleDecl {
+
+  readonly tag: string
+
+  readonly endonym: string
+}
+
+const REGISTRY = new Map<string, LocaleDecl>([[REFERENCE_LOCALE, { tag: 'en', endonym: 'English' }]])
+
+export function defineLocale(locale: LocaleDecl): void {
+  if (!/^[a-z]{2,3}(-[A-Za-z0-9]{2,8})*$/.test(locale.tag)) {
+    throw new Error(`"${locale.tag}" is not a BCP 47 tag — write \`pt-BR\`, \`zh-Hans\`, \`en\``)
+  }
+  if (REGISTRY.has(locale.tag)) throw new Error(`locale "${locale.tag}" is already declared`)
+  REGISTRY.set(locale.tag, locale)
+}
+
+export function locales(): readonly LocaleDecl[] {
+  return [...REGISTRY.values()].sort((a, b) => (a.tag < b.tag ? -1 : a.tag > b.tag ? 1 : 0))
+}
+
+export function locale(tag: string): LocaleDecl | undefined {
+  return REGISTRY.get(tag)
+}
+
+export function resetLocales(): void {
+  REGISTRY.clear()
+  REGISTRY.set(REFERENCE_LOCALE, { tag: 'en', endonym: 'English' })
+}