@prestack/thread-ui 0.0.1 → 0.0.2

package/dist/ui/i18n/parse.ts

@@ -0,0 +1,315 @@
+
+
+export interface Money {
+  readonly amount: number
+
+  readonly currency: string
+}
+
+export type Node =
+  | { readonly kind: 'text'; readonly value: string }
+  | { readonly kind: 'arg'; readonly name: string }
+  | { readonly kind: 'number'; readonly name: string; readonly style?: string }
+  | { readonly kind: 'date'; readonly name: string; readonly style?: string }
+  | { readonly kind: 'time'; readonly name: string; readonly style?: string }
+  | { readonly kind: 'money'; readonly name: string }
+  | {
+      readonly kind: 'plural'
+      readonly name: string
+      readonly ordinal: boolean
+      readonly offset: number
+      readonly options: ReadonlyMap<string, readonly Node[]>
+    }
+  | {
+      readonly kind: 'select'
+      readonly name: string
+      readonly options: ReadonlyMap<string, readonly Node[]>
+    }
+
+  | { readonly kind: 'pound' }
+
+export class MessageSyntaxError extends Error {
+  readonly source: string
+  readonly position: number
+
+  constructor(message: string, source: string, position: number) {
+    super(`${message} (at ${position} in ${JSON.stringify(source)})`)
+    this.name = 'MessageSyntaxError'
+    this.source = source
+    this.position = position
+  }
+}
+
+const ARG_TYPES = new Set(['number', 'date', 'time', 'money', 'plural', 'selectordinal', 'select'])
+
+class Parser {
+  readonly #src: string
+  #pos = 0
+
+  constructor(src: string) {
+    this.#src = src
+  }
+
+  parse(): readonly Node[] {
+    const nodes = this.#parseBody(false)
+    if (this.#pos < this.#src.length) {
+      throw new MessageSyntaxError('unexpected "}"', this.#src, this.#pos)
+    }
+    return nodes
+  }
+
+  #parseBody(inSub: boolean): readonly Node[] {
+    const nodes: Node[] = []
+    let text = ''
+
+    const flush = (): void => {
+      if (text !== '') {
+        nodes.push({ kind: 'text', value: text })
+        text = ''
+      }
+    }
+
+    while (this.#pos < this.#src.length) {
+      const ch = this.#src[this.#pos]
+
+      if (ch === "'") {
+
+        const next = this.#src[this.#pos + 1]
+        if (next === "'") {
+          text += "'"
+          this.#pos += 2
+          continue
+        }
+        if (next === '{' || next === '}' || next === '#') {
+          this.#pos += 1
+          while (this.#pos < this.#src.length) {
+            if (this.#src[this.#pos] === "'") {
+              if (this.#src[this.#pos + 1] === "'") {
+                text += "'"
+                this.#pos += 2
+                continue
+              }
+              this.#pos += 1
+              break
+            }
+            text += this.#src[this.#pos]
+            this.#pos += 1
+          }
+          continue
+        }
+
+        text += "'"
+        this.#pos += 1
+        continue
+      }
+
+      if (ch === '#' && inSub) {
+        flush()
+        nodes.push({ kind: 'pound' })
+        this.#pos += 1
+        continue
+      }
+
+      if (ch === '}') {
+        if (inSub) break
+        throw new MessageSyntaxError('unexpected "}"', this.#src, this.#pos)
+      }
+
+      if (ch === '{') {
+        flush()
+        nodes.push(this.#parseArg())
+        continue
+      }
+
+      text += ch
+      this.#pos += 1
+    }
+
+    flush()
+    return nodes
+  }
+
+  #parseArg(): Node {
+    const start = this.#pos
+    this.#pos += 1
+    this.#skipWs()
+
+    const name = this.#readIdent()
+    if (name === '') throw new MessageSyntaxError('expected an argument name', this.#src, start)
+
+    this.#skipWs()
+
+    if (this.#peek() === '}') {
+      this.#pos += 1
+      return { kind: 'arg', name }
+    }
+
+    if (this.#peek() !== ',') {
+      throw new MessageSyntaxError(`expected "," or "}" after "${name}"`, this.#src, this.#pos)
+    }
+    this.#pos += 1
+    this.#skipWs()
+
+    const type = this.#readIdent()
+    if (!ARG_TYPES.has(type)) {
+      throw new MessageSyntaxError(`unknown argument type "${type}"`, this.#src, this.#pos)
+    }
+    this.#skipWs()
+
+    if (type === 'plural' || type === 'selectordinal') {
+      return this.#parsePlural(name, type === 'selectordinal')
+    }
+    if (type === 'select') {
+      return this.#parseSelect(name)
+    }
+
+    let style: string | undefined
+    if (this.#peek() === ',') {
+      this.#pos += 1
+      this.#skipWs()
+      style = this.#readUntil('}').trim()
+    }
+    this.#expect('}')
+
+    if (type === 'money') {
+      if (style !== undefined && style !== '') {
+        throw new MessageSyntaxError('money takes no style — the currency travels with the value', this.#src, this.#pos)
+      }
+      return { kind: 'money', name }
+    }
+    if (type === 'number') return style ? { kind: 'number', name, style } : { kind: 'number', name }
+    if (type === 'date') return style ? { kind: 'date', name, style } : { kind: 'date', name }
+    return style ? { kind: 'time', name, style } : { kind: 'time', name }
+  }
+
+  #parsePlural(name: string, ordinal: boolean): Node {
+    if (this.#peek() !== ',') {
+      throw new MessageSyntaxError('expected "," before plural options', this.#src, this.#pos)
+    }
+    this.#pos += 1
+    this.#skipWs()
+
+    let offset = 0
+    if (this.#src.startsWith('offset:', this.#pos)) {
+      this.#pos += 'offset:'.length
+      this.#skipWs()
+      const digits = this.#readWhile((c) => c >= '0' && c <= '9')
+      if (digits === '') throw new MessageSyntaxError('expected a number after "offset:"', this.#src, this.#pos)
+      offset = Number(digits)
+      this.#skipWs()
+    }
+
+    const options = this.#parseOptions()
+    if (!options.has('other')) {
+
+      throw new MessageSyntaxError(`plural "${name}" is missing the required "other" branch`, this.#src, this.#pos)
+    }
+    return { kind: 'plural', name, ordinal, offset, options }
+  }
+
+  #parseSelect(name: string): Node {
+    if (this.#peek() !== ',') {
+      throw new MessageSyntaxError('expected "," before select options', this.#src, this.#pos)
+    }
+    this.#pos += 1
+    this.#skipWs()
+
+    const options = this.#parseOptions()
+    if (!options.has('other')) {
+      throw new MessageSyntaxError(`select "${name}" is missing the required "other" branch`, this.#src, this.#pos)
+    }
+    return { kind: 'select', name, options }
+  }
+
+  #parseOptions(): ReadonlyMap<string, readonly Node[]> {
+    const options = new Map<string, readonly Node[]>()
+
+    while (this.#pos < this.#src.length && this.#peek() !== '}') {
+      this.#skipWs()
+      if (this.#peek() === '}') break
+
+      const key = this.#readWhile((c) => !/\s/.test(c) && c !== '{')
+      if (key === '') throw new MessageSyntaxError('expected an option key', this.#src, this.#pos)
+      if (options.has(key)) {
+        throw new MessageSyntaxError(`duplicate option "${key}"`, this.#src, this.#pos)
+      }
+
+      this.#skipWs()
+      this.#expect('{')
+      options.set(key, this.#parseBody(true))
+      this.#expect('}')
+      this.#skipWs()
+    }
+
+    this.#expect('}')
+    return options
+  }
+
+  #peek(): string | undefined {
+    return this.#src[this.#pos]
+  }
+
+  #expect(ch: string): void {
+    if (this.#src[this.#pos] !== ch) {
+      throw new MessageSyntaxError(`expected "${ch}"`, this.#src, this.#pos)
+    }
+    this.#pos += 1
+  }
+
+  #skipWs(): void {
+    while (this.#pos < this.#src.length && /\s/.test(this.#src[this.#pos] ?? '')) this.#pos += 1
+  }
+
+  #readWhile(pred: (c: string) => boolean): string {
+    let out = ''
+    while (this.#pos < this.#src.length) {
+      const c = this.#src[this.#pos]
+      if (c === undefined || !pred(c)) break
+      out += c
+      this.#pos += 1
+    }
+    return out
+  }
+
+  #readIdent(): string {
+    return this.#readWhile((c) => /[A-Za-z0-9_]/.test(c))
+  }
+
+  #readUntil(stop: string): string {
+    return this.#readWhile((c) => c !== stop)
+  }
+}
+
+const cache = new Map<string, readonly Node[]>()
+
+export function parseMessage(src: string): readonly Node[] {
+  const hit = cache.get(src)
+  if (hit) return hit
+  const parsed = new Parser(src).parse()
+  cache.set(src, parsed)
+  return parsed
+}
+
+export function messageArgs(src: string): ReadonlySet<string> {
+  const names = new Set<string>()
+
+  const pass = (nodes: readonly Node[]): void => {
+    for (const node of nodes) {
+      switch (node.kind) {
+        case 'text':
+        case 'pound':
+          break
+        case 'plural':
+        case 'select':
+          names.add(node.name)
+          for (const body of node.options.values()) pass(body)
+          break
+        default:
+          names.add(node.name)
+      }
+    }
+  }
+
+  pass(parseMessage(src))
+  return names
+}

package/dist/ui/i18n/translator.ts

@@ -0,0 +1,31 @@
+import { formatMessage } from './format.ts'
+import { type CatalogShape, type Locale, type Translator, entryText } from './types.ts'
+
+export class UnknownMessageKeyError extends Error {
+  readonly key: string
+  constructor(key: string, locale: Locale) {
+    super(`no message "${key}" in locale "${locale}"`)
+    this.name = 'UnknownMessageKeyError'
+    this.key = key
+  }
+}
+
+export interface TranslatorOptions {
+  readonly locale: Locale
+  readonly timeZone?: string
+}
+
+export function createTranslator<C extends CatalogShape>(
+  catalog: C,
+  options: TranslatorOptions,
+): Translator<C> {
+  const translate = (key: string, params?: Readonly<Record<string, unknown>>): string => {
+    const entry = catalog[key]
+    if (entry === undefined) throw new UnknownMessageKeyError(key, options.locale)
+    return formatMessage(entryText(entry), params ?? {}, {
+      locale: options.locale,
+      timeZone: options.timeZone,
+    })
+  }
+  return translate as Translator<C>
+}

package/dist/ui/i18n/types.ts

@@ -0,0 +1,96 @@
+
+
+import type { Money } from './parse.ts'
+
+export type { Money } from './parse.ts'
+
+export type Locale = string
+
+type Trim<S extends string> = S extends ` ${infer R}`
+  ? Trim<R>
+  : S extends `${infer R} `
+    ? Trim<R>
+    : S
+
+type HasSubMessages<S extends string> = S extends `${string},plural${string}`
+  ? true
+  : S extends `${string}, plural${string}`
+    ? true
+    : S extends `${string},select${string}`
+      ? true
+      : S extends `${string}, select${string}`
+        ? true
+        : false
+
+type ArgName<Inner extends string> = Inner extends `${infer N},${string}` ? Trim<N> : Trim<Inner>
+
+type ArgValue<Inner extends string> = Inner extends `${string},${infer Rest}`
+  ? Trim<Rest> extends `number${string}`
+    ? number
+    : Trim<Rest> extends `date${string}`
+      ? Date | number
+      : Trim<Rest> extends `time${string}`
+        ? Date | number
+        : Trim<Rest> extends `money${string}`
+          ? Money
+          : string | number
+  : string | number
+
+type SimpleParams<S extends string> = S extends `${string}{${infer Inner}}${infer Rest}`
+  ? { [K in ArgName<Inner>]: ArgValue<Inner> } & SimpleParams<Rest>
+  : unknown
+
+type Prettify<T> = { [K in keyof T]: T[K] } & {}
+
+export type MessageParams<S extends string> = Prettify<SimpleParams<S>>
+
+declare const PARAMS: unique symbol
+
+export interface DeclaredMessage<P extends Record<string, unknown>> {
+  readonly text: string
+  readonly [PARAMS]?: P
+}
+
+export function msg<P extends Record<string, unknown>>(text: string): DeclaredMessage<P> {
+  return { text }
+}
+
+export type MessageEntry = string | DeclaredMessage<Record<string, unknown>>
+
+export interface RequiresExplicitParams {
+  readonly __error: 'plural/select messages must declare params: use msg<{ ... }>(text)'
+}
+
+export type ValidEntry<E> = E extends string
+  ? HasSubMessages<E> extends true
+    ? RequiresExplicitParams
+    : E
+  : E
+
+export type CatalogShape = Readonly<Record<string, MessageEntry>>
+
+export type ParamsOf<E> =
+  E extends DeclaredMessage<infer P>
+    ? P
+    : E extends string
+      ? MessageParams<E>
+      : never
+
+type HasNoKeys<T> = [keyof T] extends [never] ? true : false
+
+export type Translator<C extends CatalogShape> = <K extends keyof C & string>(
+  key: K,
+  ...args: HasNoKeys<ParamsOf<C[K]>> extends true
+    ? [params?: Record<string, never>]
+    : [params: ParamsOf<C[K]>]
+) => string
+
+export function entryText(entry: MessageEntry): string {
+  return typeof entry === 'string' ? entry : entry.text
+}
+
+export function defineCatalog<const C extends Record<string, MessageEntry>>(catalog: {
+  [K in keyof C]: ValidEntry<C[K]>
+}): C {
+  return catalog as unknown as C
+}