@meith/i18n 0.7.0

package/src/timestamp.ts

@@ -0,0 +1,97 @@
+import type { Translator } from './translator'
+
+export interface TimestampLabel {
+  readonly iso: string
+  readonly label: string
+}
+
+interface CalendarParts {
+  readonly year: number
+  readonly month: number
+  readonly day: number
+}
+
+const DAY_IN_MS = 24 * 60 * 60 * 1000
+
+export function formatTimestamp(at: Date, now: Date, translator: Translator): TimestampLabel {
+  const iso = at.toISOString()
+  const when = calendarParts(at, translator)
+  const today = calendarParts(now, translator)
+  const time = clock(at, translator)
+
+  if (sameDay(when, today)) {
+    return { iso, label: translator.t('time.today', { time }) }
+  }
+
+  if (sameDay(when, calendarParts(new Date(now.getTime() - DAY_IN_MS), translator))) {
+    return { iso, label: translator.t('time.yesterday', { time }) }
+  }
+
+  const day = number(when.day, translator)
+  const month = monthName(at, translator)
+
+  if (when.year === today.year) {
+    return { iso, label: translator.t('time.thisYear', { day, month, time }) }
+  }
+
+  return {
+    iso,
+    label: translator.t('time.past', { day, month, year: number(when.year, translator) }),
+  }
+}
+
+export function formatDay(at: Date, translator: Translator): TimestampLabel {
+  const when = calendarParts(at, translator)
+
+  return {
+    iso: at.toISOString(),
+    label: translator.t('time.day', {
+      day: number(when.day, translator),
+      month: monthName(at, translator),
+      year: number(when.year, translator),
+    }),
+  }
+}
+
+function calendarParts(at: Date, translator: Translator): CalendarParts {
+  const parts = new Map(
+    new Intl.DateTimeFormat('en-GB', {
+      timeZone: translator.timeZone,
+      year: 'numeric',
+      month: 'numeric',
+      day: 'numeric',
+    })
+      .formatToParts(at)
+      .map((part) => [part.type, part.value]),
+  )
+
+  return {
+    year: Number(parts.get('year')),
+    month: Number(parts.get('month')),
+    day: Number(parts.get('day')),
+  }
+}
+
+function sameDay(a: CalendarParts, b: CalendarParts): boolean {
+  return a.year === b.year && a.month === b.month && a.day === b.day
+}
+
+function clock(at: Date, translator: Translator): string {
+  const cycle = translator.t('time.hourCycle')
+
+  return translator.parts(at, {
+    hour: '2-digit',
+    minute: '2-digit',
+    ...(cycle === 'h11' || cycle === 'h12' || cycle === 'h23' || cycle === 'h24'
+      ? { hourCycle: cycle }
+      : {}),
+  })
+}
+
+function monthName(at: Date, translator: Translator): string {
+  return translator.parts(at, { month: 'short' })
+}
+
+function number(value: number, translator: Translator): string {
+  return translator.number(value, { useGrouping: false })
+}

package/src/translator.ts

@@ -0,0 +1,88 @@
+import type { MessageCatalog } from './catalog'
+import { type Locale, SOURCE_LOCALE } from './locale'
+import { formatMessage, type MessageArgs, pluralCategory } from './message'
+
+export const DEFAULT_TIME_ZONE = 'UTC'
+
+export interface Translator {
+  readonly locale: Locale
+  readonly timeZone: string
+  t(key: string, args?: MessageArgs): string
+  has(key: string): boolean
+  pattern(key: string): string | undefined
+  number(value: number, options?: Intl.NumberFormatOptions): string
+  list(items: readonly string[], options?: Intl.ListFormatOptions): string
+  parts(value: Date, options: Intl.DateTimeFormatOptions): string
+  plural(value: number, ordinal?: boolean): string
+}
+
+export interface TranslatorInput {
+  readonly locale: Locale
+  readonly catalog: MessageCatalog
+  readonly timeZone?: string
+}
+
+export function createTranslator(input: TranslatorInput): Translator {
+  const locale = input.locale
+  const timeZone = usableTimeZone(input.timeZone)
+  const context = { locale, timeZone }
+
+  return {
+    locale,
+    timeZone,
+
+    t(key, args = {}) {
+      const pattern = input.catalog[key]
+      if (pattern === undefined) return key
+
+      try {
+        return formatMessage(pattern, args, context)
+      } catch {
+        return pattern
+      }
+    },
+
+    has(key) {
+      return input.catalog[key] !== undefined
+    },
+
+    pattern(key) {
+      return input.catalog[key]
+    },
+
+    number(value, options) {
+      return new Intl.NumberFormat(locale, options).format(value)
+    },
+
+    list(items, options) {
+      return new Intl.ListFormat(locale, options).format(items)
+    },
+
+    parts(value, options) {
+      return new Intl.DateTimeFormat(locale, { timeZone, ...options }).format(value)
+    },
+
+    plural(value, ordinal = false) {
+      return pluralCategory(locale, value, ordinal)
+    },
+  }
+}
+
+export function usableTimeZone(timeZone: string | null | undefined): string {
+  if (typeof timeZone !== 'string' || timeZone.trim() === '') return DEFAULT_TIME_ZONE
+
+  try {
+    new Intl.DateTimeFormat('en', { timeZone }).format(0)
+    return timeZone
+  } catch {
+    return DEFAULT_TIME_ZONE
+  }
+}
+
+export function sourceTranslator(catalog: MessageCatalog, timeZone?: string): Translator {
+  return createTranslator({
+    locale: SOURCE_LOCALE,
+    catalog,
+    ...(timeZone === undefined ? {} : { timeZone }),
+  })
+}