@datatechsolutions/tympan 0.3.0 → 0.3.1

package/src/utilities/api-error-model/apiErrors.test.ts

@@ -0,0 +1,74 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { describe, expect, it, vi } from 'vitest'
+import {
+  ApiError,
+  codeOf,
+  CONTRACT_MAPPINGS,
+  createRunEventConsumer,
+  eventTypeFromContract,
+  HttpResponseError,
+  isApiError,
+  ProblemError,
+  runStatusFromContract,
+  statusOf,
+} from './apiErrors'
+
+const contractFile = join(dirname(fileURLToPath(import.meta.url)), '../../../../../contract/openapi/components/workflows.yaml')
+
+function contractEnum(yaml: string, schema: string, prop?: string): string[] {
+  const start = yaml.indexOf(`\n  ${schema}:`)
+  const block = yaml.slice(start, start + 1600)
+  const scoped = prop ? block.slice(block.indexOf(`${prop}:`)) : block
+  const m = /enum:\s*\[([^\]]+)\]/.exec(scoped)
+  return m ? m[1]!.split(',').map((s) => s.trim()) : []
+}
+
+describe('ApiErrorModel', () => {
+  it('HttpResponseError is an ApiError with its status', () => {
+    const e = new HttpResponseError('Not found', 404)
+    expect(isApiError(e)).toBe(true)
+    expect(statusOf(e)).toBe(404)
+    expect(codeOf(e)).toBe('http_response')
+    expect(new HttpResponseError('x').status).toBe(500)
+  })
+
+  it('reads 500 and "unknown" from a plain Error', () => {
+    expect(statusOf(new Error('x'))).toBe(500)
+    expect(codeOf(new Error('x'))).toBe('unknown')
+    expect(statusOf('boom')).toBe(500)
+  })
+
+  it('serialises message, code and status', () => {
+    expect(JSON.parse(JSON.stringify(new ApiError('Conflict', { status: 409, code: 'edition_frozen' })))).toEqual({
+      message: 'Conflict',
+      code: 'edition_frozen',
+      status: 409,
+    })
+    const p = new ProblemError({ type: '/problems/forbidden', title: 'Forbidden', status: 403, detail: 'No role' })
+    expect(p.toJSON()).toMatchObject({ status: 403, type: '/problems/forbidden', detail: 'No role' })
+  })
+
+  it('skips unknown run events without throwing', () => {
+    const onDone = vi.fn()
+    const consume = createRunEventConsumer({ 'node.completed': onDone })
+    expect(consume({ type: 'future.kind', runId: 'r1', timestamp: '2026-09-26T00:00:00Z' })).toBe(false)
+    expect(consume({ type: 'node.completed', runId: 'r1', nodeId: 'n', timestamp: '2026-09-26T00:00:00Z' })).toBe(true)
+    expect(onDone).toHaveBeenCalledTimes(1)
+  })
+
+  it.runIf(existsSync(contractFile))('maps every status and event of the OpenAPI contract', () => {
+    const yaml = readFileSync(contractFile, 'utf8')
+    const runStatuses = contractEnum(yaml, 'RunStatus')
+    const stepStatuses = contractEnum(yaml, 'StepStatus')
+    const events = contractEnum(yaml, 'RunEvent', 'event')
+    expect(runStatuses.length).toBeGreaterThan(3)
+    for (const s of runStatuses) expect(CONTRACT_MAPPINGS.runStatus).toHaveProperty(s)
+    for (const s of stepStatuses) expect(CONTRACT_MAPPINGS.stepStatus).toHaveProperty(s)
+    for (const e of events.filter((x) => x !== 'run.status')) expect(CONTRACT_MAPPINGS.events).toHaveProperty([e])
+    expect(runStatusFromContract('succeeded')).toBe('completed')
+    expect(eventTypeFromContract('run.status', 'failed')).toBe('run.failed')
+    expect(eventTypeFromContract('step.succeeded')).toBe('node.completed')
+  })
+})

package/src/utilities/api-error-model/apiErrors.ts

@@ -0,0 +1,192 @@
+// ApiErrorModel (spec: wave-2/api-error-model.md): one error shape for API
+// failures, an RFC 9457 problem variant, and the run-domain types consumed by
+// live-run components. The run vocabulary is the library's; the functions at
+// the end translate the run enums of the host's OpenAPI workflows contract into
+// it (a test reads that contract, when present, so both stay in step).
+
+export interface SerializedApiError {
+  message: string
+  code: string
+  status: number
+}
+
+export class ApiError extends Error {
+  readonly status: number
+  readonly code: string
+  constructor(message: string, init: { status?: number; code?: string; cause?: unknown } = {}) {
+    super(message, init.cause === undefined ? undefined : { cause: init.cause })
+    this.name = 'ApiError'
+    this.status = init.status ?? 500
+    this.code = init.code ?? 'unknown'
+  }
+  toJSON(): SerializedApiError {
+    return { message: this.message, code: this.code, status: this.status }
+  }
+}
+
+/** A non-2xx HTTP response. */
+export class HttpResponseError extends ApiError {
+  static readonly CODE = 'http_response'
+  constructor(message: string, status = 500) {
+    super(message, { status, code: HttpResponseError.CODE })
+    this.name = 'HttpResponseError'
+  }
+}
+
+export interface ProblemDocument {
+  type?: string
+  title?: string
+  status?: number
+  detail?: string
+  instance?: string
+  [extension: string]: unknown
+}
+
+/** An `application/problem+json` answer (RFC 9457); `type` is shown to people in meta (§2.12). */
+export class ProblemError extends ApiError {
+  readonly type: string
+  readonly title: string
+  readonly detail?: string
+  readonly problem: ProblemDocument
+  constructor(problem: ProblemDocument, fallbackStatus = 500) {
+    const status = typeof problem.status === 'number' ? problem.status : fallbackStatus
+    const type = problem.type ?? 'about:blank'
+    super(problem.detail ?? problem.title ?? type, { status, code: type })
+    this.name = 'ProblemError'
+    this.type = type
+    this.title = problem.title ?? ''
+    this.detail = problem.detail
+    this.problem = problem
+  }
+  override toJSON(): SerializedApiError & { type: string; title: string; detail?: string } {
+    return { ...super.toJSON(), type: this.type, title: this.title, detail: this.detail }
+  }
+}
+
+export function isApiError(value: unknown): value is ApiError {
+  return value instanceof ApiError
+}
+
+/** HTTP status of any thrown value; 500 when it has none. */
+export function statusOf(value: unknown): number {
+  if (isApiError(value)) return value.status
+  const s = (value as { status?: unknown } | null)?.status
+  return typeof s === 'number' && s >= 100 && s <= 599 ? s : 500
+}
+
+/** Machine code of any thrown value; "unknown" when it has none. */
+export function codeOf(value: unknown): string {
+  if (isApiError(value)) return value.code
+  const c = (value as { code?: unknown } | null)?.code
+  return typeof c === 'string' && c ? c : 'unknown'
+}
+
+/* ---- Run domain ---- */
+
+export type NodeStatus = 'pending' | 'running' | 'success' | 'error' | 'skipped'
+export type RunStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled'
+export type VariableValue = string | number | boolean | null | VariableValue[] | { [key: string]: VariableValue }
+
+export const KNOWN_RUN_EVENT_TYPES = [
+  'run.started',
+  'node.started',
+  'node.completed',
+  'node.error',
+  'node.skipped',
+  'node.restored',
+  'node.retry',
+  'run.paused',
+  'run.completed',
+  'run.failed',
+  'model.generation',
+  'tool.execution',
+  'agent.stream',
+  'ui.render',
+] as const
+export type KnownRunEventType = (typeof KNOWN_RUN_EVENT_TYPES)[number]
+
+export interface ExecutionEvent {
+  /** Open-ended: consumers ignore kinds they do not know. */
+  type: KnownRunEventType | (string & {})
+  runId: string
+  nodeId?: string
+  nodeType?: string
+  status?: NodeStatus | RunStatus
+  outputs?: Record<string, VariableValue>
+  error?: string
+  durationMs?: number
+  timestamp: string
+}
+
+const known = new Set<string>(KNOWN_RUN_EVENT_TYPES)
+
+export function isKnownRunEvent(event: ExecutionEvent): event is ExecutionEvent & { type: KnownRunEventType } {
+  return known.has(event.type)
+}
+
+export type RunEventHandlers = Partial<Record<KnownRunEventType, (event: ExecutionEvent) => void>>
+
+/** Dispatches known events to handlers; unknown kinds return false and are skipped. */
+export function createRunEventConsumer(handlers: RunEventHandlers): (event: ExecutionEvent) => boolean {
+  return (event) => {
+    if (!isKnownRunEvent(event)) return false
+    handlers[event.type]?.(event)
+    return true
+  }
+}
+
+/* ---- Contract translation ---- */
+
+const RUN_STATUS_FROM_CONTRACT: Record<string, RunStatus> = {
+  queued: 'pending',
+  running: 'running',
+  waiting: 'running',
+  succeeded: 'completed',
+  failed: 'failed',
+  cancelled: 'cancelled',
+}
+
+const NODE_STATUS_FROM_CONTRACT: Record<string, NodeStatus> = {
+  pending: 'pending',
+  running: 'running',
+  waiting: 'running',
+  succeeded: 'success',
+  failed: 'error',
+  skipped: 'skipped',
+  cancelled: 'skipped',
+}
+
+const EVENT_FROM_CONTRACT: Record<string, string> = {
+  'step.started': 'node.started',
+  'step.succeeded': 'node.completed',
+  'step.failed': 'node.error',
+  'step.waiting': 'run.paused',
+  // Logs and outputs have no library kind; they pass through as unknown.
+  'step.log': 'step.log',
+  'run.output': 'run.output',
+}
+
+/** Contract `RunStatus` → library run status (unknown values read as pending). */
+export function runStatusFromContract(status: string): RunStatus {
+  return RUN_STATUS_FROM_CONTRACT[status] ?? 'pending'
+}
+
+/** Contract `StepStatus` → library node status. */
+export function nodeStatusFromContract(status: string): NodeStatus {
+  return NODE_STATUS_FROM_CONTRACT[status] ?? 'pending'
+}
+
+/** Contract SSE event name (and run status for `run.status`) → library event type. */
+export function eventTypeFromContract(event: string, runStatus?: string): string {
+  if (event === 'run.status') {
+    const s = runStatus ? runStatusFromContract(runStatus) : 'running'
+    return s === 'completed' ? 'run.completed' : s === 'failed' ? 'run.failed' : runStatus === 'waiting' ? 'run.paused' : 'run.started'
+  }
+  return EVENT_FROM_CONTRACT[event] ?? event
+}
+
+export const CONTRACT_MAPPINGS = {
+  runStatus: RUN_STATUS_FROM_CONTRACT,
+  stepStatus: NODE_STATUS_FROM_CONTRACT,
+  events: EVENT_FROM_CONTRACT,
+} as const

package/src/utilities/entity-list-loader/useEntityListLoader.test.tsx

@@ -0,0 +1,72 @@
+import { act, renderHook, waitFor } from '@testing-library/react'
+import { forwardRef, type ReactNode } from 'react'
+import { describe, expect, it, vi } from 'vitest'
+import { RoutingProvider, type AnchorProps, type RouteHost } from '../router-adapter/Routing'
+import { useEntityListLoader } from './useEntityListLoader'
+
+const Anchor = forwardRef<HTMLAnchorElement, AnchorProps>((p, ref) => <a ref={ref} {...p} />)
+const hostAt = (visit: string): RouteHost => ({ path: '/list', visit, go: () => {}, step: () => {}, warm: () => {}, Anchor })
+
+describe('useEntityListLoader', () => {
+  it('loads two items and stops loading', async () => {
+    const { result } = renderHook(() => useEntityListLoader(() => Promise.resolve([1, 2])))
+    expect(result.current.loading).toBe(true)
+    await waitFor(() => expect(result.current.loading).toBe(false))
+    expect(result.current.items).toEqual([1, 2])
+  })
+
+  it('refetches when the location key changes', async () => {
+    const fetcher = vi.fn(() => Promise.resolve(['a']))
+    let key = 'k1'
+    const wrapper = ({ children }: { children: ReactNode }) => <RoutingProvider host={hostAt(key)}>{children}</RoutingProvider>
+    const { result, rerender } = renderHook(() => useEntityListLoader(fetcher), { wrapper })
+    await waitFor(() => expect(result.current.loading).toBe(false))
+    key = 'k2'
+    rerender()
+    await waitFor(() => expect(fetcher).toHaveBeenCalledTimes(2))
+  })
+
+  it('does not fetch with a null key and is not stuck loading', () => {
+    const fetcher = vi.fn(() => Promise.resolve([]))
+    const { result } = renderHook(() => useEntityListLoader(fetcher, { revalidationKey: null }))
+    expect(fetcher).not.toHaveBeenCalled()
+    expect(result.current.loading).toBe(false)
+  })
+
+  it('wraps a string rejection into an Error and keeps items', async () => {
+    const { result } = renderHook(() => useEntityListLoader(() => Promise.reject('offline'), { initial: ['kept'] }))
+    await waitFor(() => expect(result.current.error).toBeInstanceOf(Error))
+    expect(result.current.error?.message).toBe('offline')
+    expect(result.current.items).toEqual(['kept'])
+  })
+
+  it('ignores a response arriving after unmount', async () => {
+    const error = vi.spyOn(console, 'error').mockImplementation(() => {})
+    let resolve!: (v: number[]) => void
+    const { unmount } = renderHook(() => useEntityListLoader(() => new Promise<number[]>((r) => (resolve = r))))
+    unmount()
+    await act(async () => resolve([1]))
+    expect(error).not.toHaveBeenCalled()
+    error.mockRestore()
+  })
+
+  it('clears the error when refresh succeeds, and treats null as empty', async () => {
+    let fail = true
+    const { result } = renderHook(() => useEntityListLoader(() => (fail ? Promise.reject(new Error('x')) : Promise.resolve(null))))
+    await waitFor(() => expect(result.current.error).not.toBeNull())
+    fail = false
+    await act(() => result.current.refresh())
+    expect(result.current.error).toBeNull()
+    expect(result.current.items).toEqual([])
+  })
+
+  it('uses the latest inline fetcher without looping', async () => {
+    let calls = 0
+    const { result, rerender } = renderHook(({ v }) => useEntityListLoader(() => (calls++, Promise.resolve([v]))), { initialProps: { v: 'first' } })
+    await waitFor(() => expect(result.current.loading).toBe(false))
+    rerender({ v: 'second' })
+    await act(() => result.current.refresh())
+    expect(result.current.items).toEqual(['second'])
+    expect(calls).toBe(2)
+  })
+})

package/src/utilities/entity-list-loader/useEntityListLoader.ts

@@ -0,0 +1,107 @@
+// EntityListLoader (spec: wave-2/entity-list-loader.md).
+//
+// State lives in one reducer. Requests are numbered by a small "generation"
+// counter kept outside React; a response only lands when its generation is
+// still the newest and the host component is still mounted.
+import { useCallback, useEffect, useReducer, useRef, type Dispatch, type SetStateAction } from 'react'
+import { useVisitKey } from '../router-adapter/Routing'
+
+export interface ListLoaderOptions<T> {
+  initial?: T[]
+  /** Refetch trigger; `null` disables automatic fetching. Defaults to the location key. */
+  revalidationKey?: string | number | null
+}
+
+/** Output names are fixed by the spec. */
+export interface ListLoaderResult<T> {
+  items: T[]
+  loading: boolean
+  error: Error | null
+  refresh: () => Promise<void>
+  setItems: Dispatch<SetStateAction<T[]>>
+}
+
+interface Snapshot<T> {
+  rows: T[]
+  busy: boolean
+  failure: Error | null
+}
+
+type Event<T> =
+  | { on: 'start' }
+  | { on: 'rows'; rows: T[] }
+  | { on: 'fail'; failure: Error }
+  | { on: 'idle' }
+  | { on: 'edit'; next: SetStateAction<T[]> }
+
+function step<T>(now: Snapshot<T>, event: Event<T>): Snapshot<T> {
+  switch (event.on) {
+    case 'start':
+      return now.busy ? now : { ...now, busy: true }
+    case 'rows':
+      return { rows: event.rows, busy: false, failure: null }
+    case 'fail':
+      return { ...now, busy: false, failure: event.failure }
+    case 'idle':
+      return now.busy ? { ...now, busy: false } : now
+    case 'edit':
+      return { ...now, rows: typeof event.next === 'function' ? (event.next as (prev: T[]) => T[])(now.rows) : event.next }
+  }
+}
+
+function asError(reason: unknown): Error {
+  if (reason instanceof Error) return reason
+  return new Error(typeof reason === 'string' ? reason : String(reason))
+}
+
+/** Numbered requests: `issue()` opens one, `current(n)` says whether n may still write. */
+function generations() {
+  let newest = 0
+  let mounted = true
+  return {
+    issue: () => ++newest,
+    current: (n: number) => mounted && n === newest,
+    detach: () => {
+      mounted = false
+    },
+    attach: () => {
+      mounted = true
+    },
+  }
+}
+
+export function useEntityListLoader<T>(fetcher: () => Promise<T[] | null | undefined>, options: ListLoaderOptions<T> = {}): ListLoaderResult<T> {
+  const routeStamp = useVisitKey()
+  const trigger = options.revalidationKey === undefined ? routeStamp : options.revalidationKey
+  const [snap, send] = useReducer(step<T>, undefined, () => ({ rows: options.initial ?? [], busy: trigger !== null, failure: null }))
+
+  // The newest fetcher is read at call time, so inline functions never loop.
+  const source = useRef(fetcher)
+  source.current = fetcher
+  const gen = useRef(generations()).current
+
+  const refresh = useCallback(async () => {
+    const mine = gen.issue()
+    send({ on: 'start' })
+    let outcome: Event<T>
+    try {
+      outcome = { on: 'rows', rows: (await source.current()) ?? [] }
+    } catch (reason) {
+      outcome = { on: 'fail', failure: asError(reason) }
+    }
+    if (gen.current(mine)) send(outcome)
+  }, [gen])
+
+  useEffect(() => {
+    gen.attach()
+    return gen.detach
+  }, [gen])
+
+  useEffect(() => {
+    if (trigger === null) send({ on: 'idle' })
+    else void refresh()
+  }, [trigger, refresh])
+
+  const setItems = useCallback<Dispatch<SetStateAction<T[]>>>((next) => send({ on: 'edit', next }), [])
+  return { items: snap.rows, loading: snap.busy, error: snap.failure, refresh, setItems }
+}

package/src/utilities/formatters/formatters.locales.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest'
+import { formatAddress, formatDateTime, formatMoney, formatPercent } from './formatters'
+
+// Expected strings come from Intl itself, so the tests pin the library to the
+// platform's locale data instead of to a copy of it.
+describe('Formatters in right-to-left and non-Latin locales', () => {
+  it('money: ar-EG digits, he-IL shekel, hi-IN grouping, ja-JP yen without decimals', () => {
+    expect(formatMoney(1234.5, 'EGP', 'ar-EG')).toBe(new Intl.NumberFormat('ar-EG', { style: 'currency', currency: 'EGP' }).format(1234.5))
+    expect(formatMoney(1234.5, 'EGP', 'ar-EG')).toMatch(/[٠-٩]/)
+    expect(formatMoney(99, 'ILS', 'he-IL')).toBe(new Intl.NumberFormat('he-IL', { style: 'currency', currency: 'ILS' }).format(99))
+    expect(formatMoney(1234567, 'INR', 'hi-IN')).toBe(new Intl.NumberFormat('hi-IN', { style: 'currency', currency: 'INR' }).format(1234567))
+    expect(formatMoney(1500, 'JPY', 'ja-JP')).toBe(new Intl.NumberFormat('ja-JP', { style: 'currency', currency: 'JPY' }).format(1500))
+  })
+
+  it('percent keeps the sign rule and the locale digits', () => {
+    const ar = formatPercent(12.5, 'ar-EG')
+    expect(ar).toMatch(/[٠-٩]/)
+    expect(formatPercent(0, 'he-IL')).not.toMatch(/[+−-]/)
+    expect(formatPercent(-3, 'hi-IN')).toMatch(/3/)
+  })
+
+  it('dates in ja-JP and ar-EG', () => {
+    expect(formatDateTime('2026-09-20T14:02:00Z', { locale: 'ja-JP' })).toMatch(/2026/)
+    expect(formatDateTime('2026-09-20T14:02:00Z', { locale: 'ar-EG' })).toMatch(/[٠-٩]/)
+  })
+
+  it('unknown-country addresses join with the locale list separator (Arabic comma)', () => {
+    expect(formatAddress({ line1: 'شارع التحرير', city: 'القاهرة' }, 'ZZ', 'ar')).toBe(new Intl.ListFormat('ar', { type: 'unit', style: 'short' }).format(['شارع التحرير', 'القاهرة']))
+  })
+})

package/src/utilities/formatters/formatters.test.tsx

@@ -0,0 +1,86 @@
+import { renderHook } from '@testing-library/react'
+import { afterEach, describe, expect, it } from 'vitest'
+import { renderWithProvider } from '../../../test/render'
+import { messagesPtBR } from '../../internal/messages'
+import { TympanProvider } from '../../internal/provider'
+import {
+  formatAddress,
+  formatDateTime,
+  formatMoney,
+  formatPercent,
+  getCountry,
+  listCountries,
+  registerCountry,
+  resetCountries,
+  toneForStatus,
+  useFormatters,
+} from './formatters'
+
+afterEach(() => resetCountries())
+
+describe('Formatters', () => {
+  it('formats Brazilian real with comma decimals', () => {
+    const s = formatMoney(1234.5, 'BRL', 'pt-BR')
+    expect(s).toMatch(/R\$/)
+    expect(s).toMatch(/1\.234,50/)
+  })
+
+  it('returns the placeholder for null and invalid input', () => {
+    expect(formatMoney(null, 'BRL')).toBe('not informed')
+    expect(formatPercent(undefined, 'en-US', { placeholder: 'n/a' })).toBe('n/a')
+    expect(formatDateTime('not a date')).toBe('not informed')
+  })
+
+  it('shows the sign except for zero', () => {
+    expect(formatPercent(12.5, 'en-US')).toBe('+12.50%')
+    expect(formatPercent(0, 'en-US')).toBe('0.00%')
+    expect(formatPercent(-3, 'en-US')).toBe('-3.00%')
+  })
+
+  it('formats { value: iso } like the plain string', () => {
+    const iso = '2026-09-20T14:02:00Z'
+    expect(formatDateTime({ value: iso }, { timeZone: 'UTC' })).toBe(formatDateTime(iso, { timeZone: 'UTC' }))
+    expect(formatDateTime(iso, { timeZone: 'UTC', withTimeZone: true })).toMatch(/UTC/)
+  })
+
+  it('never leaves doubled separators for empty fields', () => {
+    registerCountry({
+      code: 'ZZ',
+      locale: { default: 'en-US' },
+      currency: { code: 'USD' },
+      address: { template: ['{street}, {number}, {complement}', '{city} / {region}', ['postalCode', 'country']] },
+    })
+    const text = formatAddress({ street: 'Rua A', number: '', complement: 'ap 2', city: 'São Paulo', region: '', postalCode: '01000-000' }, 'ZZ')
+    expect(text).not.toMatch(/,\s*,/)
+    expect(text).toBe('Rua A, ap 2\nSão Paulo\n01000-000')
+    expect(formatAddress({ a: 'x', b: '', c: 'y' }, 'QQ')).toBe('x, y')
+  })
+
+  it('maps statuses to semantic tones', () => {
+    expect(toneForStatus('rejected')).toBe('negative')
+    expect(toneForStatus('Approved')).toBe('positive')
+    expect(toneForStatus('in review')).toBe('pending')
+    expect(toneForStatus('whatever')).toBe('neutral')
+  })
+
+  it('validates and lists registered countries', () => {
+    expect(() => registerCountry({ code: 'brazil', locale: { default: 'pt-BR' }, currency: { code: 'BRL' } })).toThrow(/code/)
+    expect(() => registerCountry({ code: 'BR', locale: { default: 'pt-BR' }, currency: { code: 'R$' } })).toThrow(/currency/)
+    registerCountry({ code: 'BR', locale: { default: 'pt-BR' }, currency: { code: 'BRL' } })
+    expect(getCountry('br')?.currency.code).toBe('BRL')
+    expect(listCountries()).toHaveLength(1)
+  })
+
+  it('binds locale and the catalogue placeholder in the hook', () => {
+    const { result } = renderHook(() => useFormatters(), {
+      wrapper: ({ children }) => (
+        <TympanProvider baseMessages={messagesPtBR} locale="pt-BR">
+          {children}
+        </TympanProvider>
+      ),
+    })
+    expect(result.current.money(null, 'BRL')).toBe('não informado')
+    expect(result.current.percent(12.5)).toMatch(/12,50/)
+    void renderWithProvider
+  })
+})