@prestack/thread-ui 0.1.10 → 0.1.12

package/dist/ui/i18n/parse.ts

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

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

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