@prestack/thread-ui 0.1.10 → 0.1.11

package/dist/ui/generators/variants.ts

@@ -1,196 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from '@prestack/thread/integrations/disk'
-import { 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
-}
-
-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) {
-      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

@@ -1,191 +0,0 @@
-
-
-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

@@ -1,221 +0,0 @@
-
-
-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

@@ -1,33 +0,0 @@
-
-
-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' })
-}