@pyreon/i18n 0.11.5 → 0.11.7

package/src/tests/i18n.test.tsx

@@ -1,120 +1,120 @@
-import { effect } from "@pyreon/reactivity"
-import { mount } from "@pyreon/runtime-dom"
-import { I18nProvider, useI18n } from "../context"
-import { createI18n } from "../create-i18n"
-import { interpolate } from "../interpolation"
-import { resolvePluralCategory } from "../pluralization"
-import { parseRichText, Trans } from "../trans"
-import type { TranslationDictionary } from "../types"
+import { effect } from '@pyreon/reactivity'
+import { mount } from '@pyreon/runtime-dom'
+import { I18nProvider, useI18n } from '../context'
+import { createI18n } from '../create-i18n'
+import { interpolate } from '../interpolation'
+import { resolvePluralCategory } from '../pluralization'
+import { parseRichText, Trans } from '../trans'
+import type { TranslationDictionary } from '../types'
 
 // ─── interpolate ─────────────────────────────────────────────────────────────
 
-describe("interpolate", () => {
-  it("replaces placeholders with values", () => {
-    expect(interpolate("Hello {{name}}!", { name: "Alice" })).toBe("Hello Alice!")
+describe('interpolate', () => {
+  it('replaces placeholders with values', () => {
+    expect(interpolate('Hello {{name}}!', { name: 'Alice' })).toBe('Hello Alice!')
   })
 
-  it("handles multiple placeholders", () => {
-    expect(interpolate("{{greeting}}, {{name}}!", { greeting: "Hi", name: "Bob" })).toBe("Hi, Bob!")
+  it('handles multiple placeholders', () => {
+    expect(interpolate('{{greeting}}, {{name}}!', { greeting: 'Hi', name: 'Bob' })).toBe('Hi, Bob!')
   })
 
-  it("handles whitespace inside braces", () => {
-    expect(interpolate("Hello {{ name }}!", { name: "Alice" })).toBe("Hello Alice!")
+  it('handles whitespace inside braces', () => {
+    expect(interpolate('Hello {{ name }}!', { name: 'Alice' })).toBe('Hello Alice!')
   })
 
-  it("leaves unmatched placeholders as-is", () => {
-    expect(interpolate("Hello {{name}}!", {})).toBe("Hello {{name}}!")
+  it('leaves unmatched placeholders as-is', () => {
+    expect(interpolate('Hello {{name}}!', {})).toBe('Hello {{name}}!')
   })
 
-  it("returns template unchanged when no values provided", () => {
-    expect(interpolate("Hello {{name}}!")).toBe("Hello {{name}}!")
+  it('returns template unchanged when no values provided', () => {
+    expect(interpolate('Hello {{name}}!')).toBe('Hello {{name}}!')
   })
 
-  it("returns template unchanged when no placeholders present", () => {
-    expect(interpolate("Hello world!", { name: "Alice" })).toBe("Hello world!")
+  it('returns template unchanged when no placeholders present', () => {
+    expect(interpolate('Hello world!', { name: 'Alice' })).toBe('Hello world!')
   })
 
-  it("handles number values", () => {
-    expect(interpolate("Count: {{count}}", { count: 42 })).toBe("Count: 42")
+  it('handles number values', () => {
+    expect(interpolate('Count: {{count}}', { count: 42 })).toBe('Count: 42')
   })
 })
 
 // ─── resolvePluralCategory ───────────────────────────────────────────────────
 
-describe("resolvePluralCategory", () => {
+describe('resolvePluralCategory', () => {
   it('returns "one" for count 1 in English', () => {
-    expect(resolvePluralCategory("en", 1)).toBe("one")
+    expect(resolvePluralCategory('en', 1)).toBe('one')
   })
 
   it('returns "other" for count 0 in English', () => {
-    expect(resolvePluralCategory("en", 0)).toBe("other")
+    expect(resolvePluralCategory('en', 0)).toBe('other')
   })
 
   it('returns "other" for count > 1 in English', () => {
-    expect(resolvePluralCategory("en", 5)).toBe("other")
+    expect(resolvePluralCategory('en', 5)).toBe('other')
   })
 
-  it("uses custom plural rules when provided", () => {
+  it('uses custom plural rules when provided', () => {
     const rules = {
-      custom: (count: number) => (count === 0 ? "zero" : count === 1 ? "one" : "other"),
+      custom: (count: number) => (count === 0 ? 'zero' : count === 1 ? 'one' : 'other'),
     }
-    expect(resolvePluralCategory("custom", 0, rules)).toBe("zero")
-    expect(resolvePluralCategory("custom", 1, rules)).toBe("one")
-    expect(resolvePluralCategory("custom", 5, rules)).toBe("other")
+    expect(resolvePluralCategory('custom', 0, rules)).toBe('zero')
+    expect(resolvePluralCategory('custom', 1, rules)).toBe('one')
+    expect(resolvePluralCategory('custom', 5, rules)).toBe('other')
   })
 })
 
 // ─── createI18n ──────────────────────────────────────────────────────────────
 
-describe("createI18n", () => {
+describe('createI18n', () => {
   const en = {
-    greeting: "Hello {{name}}!",
-    farewell: "Goodbye",
+    greeting: 'Hello {{name}}!',
+    farewell: 'Goodbye',
     nested: {
       deep: {
-        key: "Deep value",
+        key: 'Deep value',
       },
     },
   }
 
   const de = {
-    greeting: "Hallo {{name}}!",
-    farewell: "Auf Wiedersehen",
+    greeting: 'Hallo {{name}}!',
+    farewell: 'Auf Wiedersehen',
     nested: {
       deep: {
-        key: "Tiefer Wert",
+        key: 'Tiefer Wert',
       },
     },
   }
 
-  it("translates a simple key", () => {
-    const i18n = createI18n({ locale: "en", messages: { en } })
-    expect(i18n.t("greeting", { name: "Alice" })).toBe("Hello Alice!")
+  it('translates a simple key', () => {
+    const i18n = createI18n({ locale: 'en', messages: { en } })
+    expect(i18n.t('greeting', { name: 'Alice' })).toBe('Hello Alice!')
   })
 
-  it("translates nested keys with dot notation", () => {
-    const i18n = createI18n({ locale: "en", messages: { en } })
-    expect(i18n.t("nested.deep.key")).toBe("Deep value")
+  it('translates nested keys with dot notation', () => {
+    const i18n = createI18n({ locale: 'en', messages: { en } })
+    expect(i18n.t('nested.deep.key')).toBe('Deep value')
   })
 
-  it("returns the key itself when missing", () => {
-    const i18n = createI18n({ locale: "en", messages: { en } })
-    expect(i18n.t("nonexistent.key")).toBe("nonexistent.key")
+  it('returns the key itself when missing', () => {
+    const i18n = createI18n({ locale: 'en', messages: { en } })
+    expect(i18n.t('nonexistent.key')).toBe('nonexistent.key')
   })
 
-  it("falls back to fallbackLocale when key is missing", () => {
+  it('falls back to fallbackLocale when key is missing', () => {
     const i18n = createI18n({
-      locale: "de",
-      fallbackLocale: "en",
-      messages: { en: { ...en, onlyEn: "English only" }, de },
+      locale: 'de',
+      fallbackLocale: 'en',
+      messages: { en: { ...en, onlyEn: 'English only' }, de },
     })
-    expect(i18n.t("onlyEn")).toBe("English only")
+    expect(i18n.t('onlyEn')).toBe('English only')
   })
 
-  it("calls onMissingKey when translation is not found", () => {
+  it('calls onMissingKey when translation is not found', () => {
     const missing: string[] = []
     const i18n = createI18n({
-      locale: "en",
+      locale: 'en',
       messages: { en },
       onMissingKey: (locale, key) => {
         missing.push(`${locale}:${key}`)
@@ -122,13 +122,13 @@ describe("createI18n", () => {
       },
     })
 
-    expect(i18n.t("unknown")).toBe("[MISSING: unknown]")
-    expect(missing).toEqual(["en:unknown"])
+    expect(i18n.t('unknown')).toBe('[MISSING: unknown]')
+    expect(missing).toEqual(['en:unknown'])
   })
 
-  it("falls back to key when onMissingKey returns void", () => {
+  it('falls back to key when onMissingKey returns void', () => {
     const i18n = createI18n({
-      locale: "en",
+      locale: 'en',
       messages: { en },
       onMissingKey: () => {
         // intentionally returns undefined
@@ -136,196 +136,196 @@ describe("createI18n", () => {
       },
     })
 
-    expect(i18n.t("unknown")).toBe("unknown")
+    expect(i18n.t('unknown')).toBe('unknown')
   })
 
-  it("uses fallback locale for plural forms", () => {
+  it('uses fallback locale for plural forms', () => {
     const i18n = createI18n({
-      locale: "de",
-      fallbackLocale: "en",
+      locale: 'de',
+      fallbackLocale: 'en',
       messages: {
         en: {
-          items_one: "{{count}} item",
-          items_other: "{{count}} items",
+          items_one: '{{count}} item',
+          items_other: '{{count}} items',
         },
         de: {},
       },
     })
 
     // German has no items translation, falls back to English plural forms
-    expect(i18n.t("items", { count: 1 })).toBe("1 item")
-    expect(i18n.t("items", { count: 5 })).toBe("5 items")
+    expect(i18n.t('items', { count: 1 })).toBe('1 item')
+    expect(i18n.t('items', { count: 5 })).toBe('5 items')
   })
 
-  it("reactively updates when locale changes", () => {
+  it('reactively updates when locale changes', () => {
     const i18n = createI18n({
-      locale: "en",
+      locale: 'en',
       messages: { en, de },
     })
 
     const results: string[] = []
     const cleanup = effect(() => {
-      results.push(i18n.t("farewell"))
+      results.push(i18n.t('farewell'))
     })
 
-    expect(results).toEqual(["Goodbye"])
+    expect(results).toEqual(['Goodbye'])
 
-    i18n.locale.set("de")
-    expect(results).toEqual(["Goodbye", "Auf Wiedersehen"])
+    i18n.locale.set('de')
+    expect(results).toEqual(['Goodbye', 'Auf Wiedersehen'])
 
     cleanup.dispose()
   })
 
-  it("reactively updates when messages are added", () => {
+  it('reactively updates when messages are added', () => {
     const i18n = createI18n({
-      locale: "en",
+      locale: 'en',
       messages: { en },
     })
 
     const results: string[] = []
     const cleanup = effect(() => {
-      results.push(i18n.t("newKey"))
+      results.push(i18n.t('newKey'))
     })
 
-    expect(results).toEqual(["newKey"]) // Missing key returns key itself
+    expect(results).toEqual(['newKey']) // Missing key returns key itself
 
-    i18n.addMessages("en", { newKey: "New value!" })
-    expect(results).toEqual(["newKey", "New value!"])
+    i18n.addMessages('en', { newKey: 'New value!' })
+    expect(results).toEqual(['newKey', 'New value!'])
 
     cleanup.dispose()
   })
 
-  it("reports available locales", () => {
+  it('reports available locales', () => {
     const i18n = createI18n({
-      locale: "en",
+      locale: 'en',
       messages: { en, de },
     })
-    expect(i18n.availableLocales()).toEqual(["en", "de"])
+    expect(i18n.availableLocales()).toEqual(['en', 'de'])
   })
 
-  it("exists() checks key presence", () => {
-    const i18n = createI18n({ locale: "en", messages: { en } })
-    expect(i18n.exists("greeting")).toBe(true)
-    expect(i18n.exists("nested.deep.key")).toBe(true)
-    expect(i18n.exists("nonexistent")).toBe(false)
+  it('exists() checks key presence', () => {
+    const i18n = createI18n({ locale: 'en', messages: { en } })
+    expect(i18n.exists('greeting')).toBe(true)
+    expect(i18n.exists('nested.deep.key')).toBe(true)
+    expect(i18n.exists('nonexistent')).toBe(false)
   })
 
-  it("exists() checks namespaced keys", () => {
+  it('exists() checks namespaced keys', () => {
     const i18n = createI18n({
-      locale: "en",
+      locale: 'en',
       messages: { en: {} },
     })
-    i18n.addMessages("en", { title: "Admin Panel" }, "admin")
-    expect(i18n.exists("admin:title")).toBe(true)
-    expect(i18n.exists("admin:nonexistent")).toBe(false)
+    i18n.addMessages('en', { title: 'Admin Panel' }, 'admin')
+    expect(i18n.exists('admin:title')).toBe(true)
+    expect(i18n.exists('admin:nonexistent')).toBe(false)
   })
 
-  it("exists() checks fallback locale", () => {
+  it('exists() checks fallback locale', () => {
     const i18n = createI18n({
-      locale: "de",
-      fallbackLocale: "en",
-      messages: { en: { ...en, onlyEn: "yes" }, de },
+      locale: 'de',
+      fallbackLocale: 'en',
+      messages: { en: { ...en, onlyEn: 'yes' }, de },
     })
-    expect(i18n.exists("onlyEn")).toBe(true)
+    expect(i18n.exists('onlyEn')).toBe(true)
   })
 })
 
 // ─── Pluralization ───────────────────────────────────────────────────────────
 
-describe("createI18n pluralization", () => {
-  it("selects the correct plural form", () => {
+describe('createI18n pluralization', () => {
+  it('selects the correct plural form', () => {
     const i18n = createI18n({
-      locale: "en",
+      locale: 'en',
       messages: {
         en: {
-          items_one: "{{count}} item",
-          items_other: "{{count}} items",
+          items_one: '{{count}} item',
+          items_other: '{{count}} items',
         },
       },
     })
 
-    expect(i18n.t("items", { count: 1 })).toBe("1 item")
-    expect(i18n.t("items", { count: 5 })).toBe("5 items")
-    expect(i18n.t("items", { count: 0 })).toBe("0 items")
+    expect(i18n.t('items', { count: 1 })).toBe('1 item')
+    expect(i18n.t('items', { count: 5 })).toBe('5 items')
+    expect(i18n.t('items', { count: 0 })).toBe('0 items')
   })
 
-  it("falls back to base key when plural form is missing", () => {
+  it('falls back to base key when plural form is missing', () => {
     const i18n = createI18n({
-      locale: "en",
+      locale: 'en',
       messages: {
         en: {
-          items: "some items", // No _one or _other suffixes
+          items: 'some items', // No _one or _other suffixes
         },
       },
     })
 
-    expect(i18n.t("items", { count: 1 })).toBe("some items")
+    expect(i18n.t('items', { count: 1 })).toBe('some items')
   })
 
-  it("falls back to basic rules when Intl.PluralRules fails", () => {
+  it('falls back to basic rules when Intl.PluralRules fails', () => {
     // Use an invalid locale to trigger the catch branch
-    const category1 = resolvePluralCategory("invalid-xxx-yyy", 1)
-    const category5 = resolvePluralCategory("invalid-xxx-yyy", 5)
+    const category1 = resolvePluralCategory('invalid-xxx-yyy', 1)
+    const category5 = resolvePluralCategory('invalid-xxx-yyy', 5)
     // Intl.PluralRules may either handle it or throw — either way we get a result
-    expect(typeof category1).toBe("string")
-    expect(typeof category5).toBe("string")
+    expect(typeof category1).toBe('string')
+    expect(typeof category5).toBe('string')
   })
 
-  it("uses custom plural rules", () => {
+  it('uses custom plural rules', () => {
     const i18n = createI18n({
-      locale: "ar",
+      locale: 'ar',
       pluralRules: {
         ar: (count: number) => {
-          if (count === 0) return "zero"
-          if (count === 1) return "one"
-          if (count === 2) return "two"
-          if (count >= 3 && count <= 10) return "few"
-          return "other"
+          if (count === 0) return 'zero'
+          if (count === 1) return 'one'
+          if (count === 2) return 'two'
+          if (count >= 3 && count <= 10) return 'few'
+          return 'other'
         },
       },
       messages: {
         ar: {
-          items_zero: "لا عناصر",
-          items_one: "عنصر واحد",
-          items_two: "عنصران",
-          items_few: "{{count}} عناصر",
-          items_other: "{{count}} عنصراً",
+          items_zero: 'لا عناصر',
+          items_one: 'عنصر واحد',
+          items_two: 'عنصران',
+          items_few: '{{count}} عناصر',
+          items_other: '{{count}} عنصراً',
         },
       },
     })
 
-    expect(i18n.t("items", { count: 0 })).toBe("لا عناصر")
-    expect(i18n.t("items", { count: 1 })).toBe("عنصر واحد")
-    expect(i18n.t("items", { count: 2 })).toBe("عنصران")
-    expect(i18n.t("items", { count: 5 })).toBe("5 عناصر")
-    expect(i18n.t("items", { count: 100 })).toBe("100 عنصراً")
+    expect(i18n.t('items', { count: 0 })).toBe('لا عناصر')
+    expect(i18n.t('items', { count: 1 })).toBe('عنصر واحد')
+    expect(i18n.t('items', { count: 2 })).toBe('عنصران')
+    expect(i18n.t('items', { count: 5 })).toBe('5 عناصر')
+    expect(i18n.t('items', { count: 100 })).toBe('100 عنصراً')
   })
 })
 
 // ─── Namespaces ──────────────────────────────────────────────────────────────
 
-describe("createI18n namespaces", () => {
-  it("supports namespace:key syntax", () => {
+describe('createI18n namespaces', () => {
+  it('supports namespace:key syntax', () => {
     const i18n = createI18n({
-      locale: "en",
-      messages: { en: { greeting: "Hi" } },
+      locale: 'en',
+      messages: { en: { greeting: 'Hi' } },
     })
     // "greeting" is in the default "common" namespace
-    expect(i18n.t("greeting")).toBe("Hi")
+    expect(i18n.t('greeting')).toBe('Hi')
   })
 
-  it("loads namespaces asynchronously", async () => {
+  it('loads namespaces asynchronously', async () => {
     const loaderCalls: string[] = []
 
     const i18n = createI18n({
-      locale: "en",
+      locale: 'en',
       loader: async (locale, namespace) => {
         loaderCalls.push(`${locale}:${namespace}`)
-        if (namespace === "auth") {
+        if (namespace === 'auth') {
           return {
-            login: "Log in",
+            login: 'Log in',
             errors: {
-              invalid: "Invalid credentials",
+              invalid: 'Invalid credentials',
             },
           }
         }
@@ -333,20 +333,20 @@ describe("createI18n namespaces", () => {
       },
     })
 
-    expect(i18n.t("auth:login")).toBe("auth:login") // Not loaded yet
+    expect(i18n.t('auth:login')).toBe('auth:login') // Not loaded yet
 
-    await i18n.loadNamespace("auth")
+    await i18n.loadNamespace('auth')
 
-    expect(loaderCalls).toEqual(["en:auth"])
-    expect(i18n.t("auth:login")).toBe("Log in")
-    expect(i18n.t("auth:errors.invalid")).toBe("Invalid credentials")
+    expect(loaderCalls).toEqual(['en:auth'])
+    expect(i18n.t('auth:login')).toBe('Log in')
+    expect(i18n.t('auth:errors.invalid')).toBe('Invalid credentials')
   })
 
-  it("tracks loading state", async () => {
+  it('tracks loading state', async () => {
     let resolveLoader: ((dict: TranslationDictionary) => void) | undefined
 
     const i18n = createI18n({
-      locale: "en",
+      locale: 'en',
       loader: async () => {
         return new Promise<TranslationDictionary>((resolve) => {
           resolveLoader = resolve
@@ -356,231 +356,231 @@ describe("createI18n namespaces", () => {
 
     expect(i18n.isLoading()).toBe(false)
 
-    const loadPromise = i18n.loadNamespace("test")
+    const loadPromise = i18n.loadNamespace('test')
     expect(i18n.isLoading()).toBe(true)
 
-    resolveLoader!({ hello: "world" })
+    resolveLoader!({ hello: 'world' })
     await loadPromise
 
     expect(i18n.isLoading()).toBe(false)
   })
 
-  it("does not re-fetch already loaded namespaces", async () => {
+  it('does not re-fetch already loaded namespaces', async () => {
     let callCount = 0
 
     const i18n = createI18n({
-      locale: "en",
+      locale: 'en',
       loader: async () => {
         callCount++
-        return { key: "value" }
+        return { key: 'value' }
       },
     })
 
-    await i18n.loadNamespace("test")
-    await i18n.loadNamespace("test")
+    await i18n.loadNamespace('test')
+    await i18n.loadNamespace('test')
 
     expect(callCount).toBe(1)
   })
 
-  it("deduplicates concurrent loads for the same namespace", async () => {
+  it('deduplicates concurrent loads for the same namespace', async () => {
     let callCount = 0
 
     const i18n = createI18n({
-      locale: "en",
+      locale: 'en',
       loader: async () => {
         callCount++
-        return { key: "value" }
+        return { key: 'value' }
       },
     })
 
     // Fire two loads concurrently — should only call loader once
-    await Promise.all([i18n.loadNamespace("test"), i18n.loadNamespace("test")])
+    await Promise.all([i18n.loadNamespace('test'), i18n.loadNamespace('test')])
 
     expect(callCount).toBe(1)
   })
 
-  it("loadedNamespaces reflects current locale namespaces", async () => {
+  it('loadedNamespaces reflects current locale namespaces', async () => {
     const i18n = createI18n({
-      locale: "en",
-      loader: async (_locale, ns) => ({ [`${ns}Key`]: "value" }),
+      locale: 'en',
+      loader: async (_locale, ns) => ({ [`${ns}Key`]: 'value' }),
     })
 
     expect(i18n.loadedNamespaces().size).toBe(0)
 
-    await i18n.loadNamespace("auth")
-    expect(i18n.loadedNamespaces().has("auth")).toBe(true)
+    await i18n.loadNamespace('auth')
+    expect(i18n.loadedNamespaces().has('auth')).toBe(true)
 
-    await i18n.loadNamespace("admin")
-    expect(i18n.loadedNamespaces().has("auth")).toBe(true)
-    expect(i18n.loadedNamespaces().has("admin")).toBe(true)
+    await i18n.loadNamespace('admin')
+    expect(i18n.loadedNamespaces().has('auth')).toBe(true)
+    expect(i18n.loadedNamespaces().has('admin')).toBe(true)
   })
 
-  it("loadNamespace is a no-op without a loader", async () => {
+  it('loadNamespace is a no-op without a loader', async () => {
     const i18n = createI18n({
-      locale: "en",
-      messages: { en: { key: "value" } },
+      locale: 'en',
+      messages: { en: { key: 'value' } },
     })
 
-    await i18n.loadNamespace("test") // Should not throw
+    await i18n.loadNamespace('test') // Should not throw
     expect(i18n.isLoading()).toBe(false)
   })
 
-  it("handles loader returning undefined", async () => {
+  it('handles loader returning undefined', async () => {
     const i18n = createI18n({
-      locale: "en",
+      locale: 'en',
       loader: async () => undefined,
     })
 
-    await i18n.loadNamespace("missing")
-    expect(i18n.loadedNamespaces().has("missing")).toBe(false)
+    await i18n.loadNamespace('missing')
+    expect(i18n.loadedNamespaces().has('missing')).toBe(false)
   })
 
-  it("handles loader errors gracefully", async () => {
+  it('handles loader errors gracefully', async () => {
     const i18n = createI18n({
-      locale: "en",
+      locale: 'en',
       loader: async () => {
-        throw new Error("Network error")
+        throw new Error('Network error')
       },
     })
 
-    await expect(i18n.loadNamespace("test")).rejects.toThrow("Network error")
+    await expect(i18n.loadNamespace('test')).rejects.toThrow('Network error')
     expect(i18n.isLoading()).toBe(false) // Loading state cleaned up
   })
 
-  it("addMessages does not corrupt store when source is mutated", () => {
-    const i18n = createI18n({ locale: "en", messages: { en: {} } })
+  it('addMessages does not corrupt store when source is mutated', () => {
+    const i18n = createI18n({ locale: 'en', messages: { en: {} } })
 
-    const source = { greeting: "Hello" }
-    i18n.addMessages("en", source)
+    const source = { greeting: 'Hello' }
+    i18n.addMessages('en', source)
 
     // Mutating the source should not affect the store
-    source.greeting = "MUTATED"
-    expect(i18n.t("greeting")).toBe("Hello")
+    source.greeting = 'MUTATED'
+    expect(i18n.t('greeting')).toBe('Hello')
   })
 
-  it("loads namespace for a specific locale", async () => {
+  it('loads namespace for a specific locale', async () => {
     const loaderCalls: string[] = []
 
     const i18n = createI18n({
-      locale: "en",
+      locale: 'en',
       loader: async (locale, namespace) => {
         loaderCalls.push(`${locale}:${namespace}`)
         return { key: `${locale} value` }
       },
     })
 
-    await i18n.loadNamespace("common", "de")
-    expect(loaderCalls).toEqual(["de:common"])
+    await i18n.loadNamespace('common', 'de')
+    expect(loaderCalls).toEqual(['de:common'])
   })
 
-  it("addMessages merges into existing namespace", () => {
+  it('addMessages merges into existing namespace', () => {
     const i18n = createI18n({
-      locale: "en",
+      locale: 'en',
       messages: {
-        en: { existing: "yes" },
+        en: { existing: 'yes' },
       },
     })
 
-    i18n.addMessages("en", { added: "also yes" })
-    expect(i18n.t("existing")).toBe("yes")
-    expect(i18n.t("added")).toBe("also yes")
+    i18n.addMessages('en', { added: 'also yes' })
+    expect(i18n.t('existing')).toBe('yes')
+    expect(i18n.t('added')).toBe('also yes')
   })
 
-  it("addMessages deep-merges nested dictionaries", () => {
+  it('addMessages deep-merges nested dictionaries', () => {
     const i18n = createI18n({
-      locale: "en",
+      locale: 'en',
       messages: {
         en: {
           errors: {
-            auth: "Auth error",
+            auth: 'Auth error',
           },
         },
       },
     })
 
-    i18n.addMessages("en", {
+    i18n.addMessages('en', {
       errors: {
-        network: "Network error",
+        network: 'Network error',
       },
     })
 
-    expect(i18n.t("errors.auth")).toBe("Auth error")
-    expect(i18n.t("errors.network")).toBe("Network error")
+    expect(i18n.t('errors.auth')).toBe('Auth error')
+    expect(i18n.t('errors.network')).toBe('Network error')
   })
 
-  it("addMessages to a specific namespace", () => {
+  it('addMessages to a specific namespace', () => {
     const i18n = createI18n({
-      locale: "en",
+      locale: 'en',
       messages: { en: {} },
     })
 
-    i18n.addMessages("en", { title: "Dashboard" }, "admin")
-    expect(i18n.t("admin:title")).toBe("Dashboard")
+    i18n.addMessages('en', { title: 'Dashboard' }, 'admin')
+    expect(i18n.t('admin:title')).toBe('Dashboard')
   })
 
-  it("addMessages creates locale if not exists", () => {
-    const i18n = createI18n({ locale: "en", messages: { en: {} } })
+  it('addMessages creates locale if not exists', () => {
+    const i18n = createI18n({ locale: 'en', messages: { en: {} } })
 
-    i18n.addMessages("fr", { greeting: "Bonjour" })
-    i18n.locale.set("fr")
-    expect(i18n.t("greeting")).toBe("Bonjour")
-    expect(i18n.availableLocales()).toContain("fr")
+    i18n.addMessages('fr', { greeting: 'Bonjour' })
+    i18n.locale.set('fr')
+    expect(i18n.t('greeting')).toBe('Bonjour')
+    expect(i18n.availableLocales()).toContain('fr')
   })
 })
 
 // ─── Locale switching with namespaces ────────────────────────────────────────
 
-describe("createI18n locale switching", () => {
-  it("reloads translations when switching locale with loader", async () => {
+describe('createI18n locale switching', () => {
+  it('reloads translations when switching locale with loader', async () => {
     const translations: Record<string, Record<string, TranslationDictionary>> = {
-      en: { common: { hello: "Hello" } },
-      de: { common: { hello: "Hallo" } },
+      en: { common: { hello: 'Hello' } },
+      de: { common: { hello: 'Hallo' } },
     }
 
     const i18n = createI18n({
-      locale: "en",
+      locale: 'en',
       loader: async (locale, ns) => translations[locale]?.[ns],
     })
 
-    await i18n.loadNamespace("common")
-    expect(i18n.t("hello")).toBe("Hello")
+    await i18n.loadNamespace('common')
+    expect(i18n.t('hello')).toBe('Hello')
 
-    i18n.locale.set("de")
-    await i18n.loadNamespace("common")
-    expect(i18n.t("hello")).toBe("Hallo")
+    i18n.locale.set('de')
+    await i18n.loadNamespace('common')
+    expect(i18n.t('hello')).toBe('Hallo')
   })
 
-  it("handles mixed static + async messages", async () => {
+  it('handles mixed static + async messages', async () => {
     const i18n = createI18n({
-      locale: "en",
+      locale: 'en',
       messages: {
-        en: { staticKey: "From static" },
+        en: { staticKey: 'From static' },
       },
       loader: async (_locale, ns) => {
-        if (ns === "dynamic") return { dynamicKey: "From loader" }
+        if (ns === 'dynamic') return { dynamicKey: 'From loader' }
         return undefined
       },
     })
 
-    expect(i18n.t("staticKey")).toBe("From static")
-    expect(i18n.t("dynamic:dynamicKey")).toBe("dynamic:dynamicKey")
+    expect(i18n.t('staticKey')).toBe('From static')
+    expect(i18n.t('dynamic:dynamicKey')).toBe('dynamic:dynamicKey')
 
-    await i18n.loadNamespace("dynamic")
-    expect(i18n.t("dynamic:dynamicKey")).toBe("From loader")
+    await i18n.loadNamespace('dynamic')
+    expect(i18n.t('dynamic:dynamicKey')).toBe('From loader')
   })
 })
 
 // ─── I18nProvider / useI18n context ──────────────────────────────────────────
 
-describe("I18nProvider / useI18n", () => {
-  it("provides i18n instance to child components via useI18n", () => {
+describe('I18nProvider / useI18n', () => {
+  it('provides i18n instance to child components via useI18n', () => {
     const i18n = createI18n({
-      locale: "en",
-      messages: { en: { hello: "Hello World" } },
+      locale: 'en',
+      messages: { en: { hello: 'Hello World' } },
     })
 
     let received: ReturnType<typeof useI18n> | undefined
-    const el = document.createElement("div")
+    const el = document.createElement('div')
     document.body.appendChild(el)
     const Child = () => {
       received = useI18n()
@@ -594,19 +594,19 @@ describe("I18nProvider / useI18n", () => {
     )
 
     expect(received).toBe(i18n)
-    expect(received!.t("hello")).toBe("Hello World")
+    expect(received!.t('hello')).toBe('Hello World')
     unmount()
     el.remove()
   })
 
-  it("renders children passed as a function", () => {
+  it('renders children passed as a function', () => {
     const i18n = createI18n({
-      locale: "en",
-      messages: { en: { key: "Value" } },
+      locale: 'en',
+      messages: { en: { key: 'Value' } },
     })
 
     let received: ReturnType<typeof useI18n> | undefined
-    const el = document.createElement("div")
+    const el = document.createElement('div')
     document.body.appendChild(el)
     const Child = () => {
       received = useI18n()
@@ -615,14 +615,14 @@ describe("I18nProvider / useI18n", () => {
     const unmount = mount(<I18nProvider instance={i18n}>{() => <Child />}</I18nProvider>, el)
 
     expect(received).toBeDefined()
-    expect(received!.t("key")).toBe("Value")
+    expect(received!.t('key')).toBe('Value')
     unmount()
     el.remove()
   })
 
-  it("useI18n throws when called outside I18nProvider", () => {
+  it('useI18n throws when called outside I18nProvider', () => {
     let error: Error | undefined
-    const el = document.createElement("div")
+    const el = document.createElement('div')
     document.body.appendChild(el)
 
     const Child = () => {
@@ -636,19 +636,19 @@ describe("I18nProvider / useI18n", () => {
     const unmount = mount(<Child />, el)
 
     expect(error).toBeDefined()
-    expect(error!.message).toContain("useI18n() must be used within an <I18nProvider>")
+    expect(error!.message).toContain('useI18n() must be used within an <I18nProvider>')
     unmount()
     el.remove()
   })
 
-  it("renders direct VNode children (not a function)", () => {
+  it('renders direct VNode children (not a function)', () => {
     const i18n = createI18n({
-      locale: "en",
-      messages: { en: { test: "Test value" } },
+      locale: 'en',
+      messages: { en: { test: 'Test value' } },
     })
 
     let received: ReturnType<typeof useI18n> | undefined
-    const el = document.createElement("div")
+    const el = document.createElement('div')
     document.body.appendChild(el)
     const Child = () => {
       received = useI18n()
@@ -662,7 +662,7 @@ describe("I18nProvider / useI18n", () => {
     )
 
     expect(received).toBeDefined()
-    expect(received!.t("test")).toBe("Test value")
+    expect(received!.t('test')).toBe('Test value')
     unmount()
     el.remove()
   })
@@ -670,15 +670,15 @@ describe("I18nProvider / useI18n", () => {
 
 // ─── Pluralization — Intl.PluralRules unavailable fallback ──────────────────
 
-describe("resolvePluralCategory fallback when Intl is unavailable", () => {
-  it("falls back to basic one/other when Intl is undefined", () => {
+describe('resolvePluralCategory fallback when Intl is unavailable', () => {
+  it('falls back to basic one/other when Intl is undefined', () => {
     const originalIntl = globalThis.Intl
     // @ts-expect-error — temporarily remove Intl
     globalThis.Intl = undefined
 
-    expect(resolvePluralCategory("en", 1)).toBe("one")
-    expect(resolvePluralCategory("en", 0)).toBe("other")
-    expect(resolvePluralCategory("en", 5)).toBe("other")
+    expect(resolvePluralCategory('en', 1)).toBe('one')
+    expect(resolvePluralCategory('en', 0)).toBe('other')
+    expect(resolvePluralCategory('en', 5)).toBe('other')
 
     globalThis.Intl = originalIntl
   })
@@ -686,93 +686,93 @@ describe("resolvePluralCategory fallback when Intl is unavailable", () => {
 
 // ─── parseRichText ──────────────────────────────────────────────────────────
 
-describe("parseRichText", () => {
-  it("returns a single-element array for plain text", () => {
-    expect(parseRichText("Hello world")).toEqual(["Hello world"])
+describe('parseRichText', () => {
+  it('returns a single-element array for plain text', () => {
+    expect(parseRichText('Hello world')).toEqual(['Hello world'])
   })
 
-  it("returns empty array for empty string", () => {
-    expect(parseRichText("")).toEqual([])
+  it('returns empty array for empty string', () => {
+    expect(parseRichText('')).toEqual([])
   })
 
-  it("parses a single tag", () => {
-    expect(parseRichText("Hello <bold>world</bold>!")).toEqual([
-      "Hello ",
-      { tag: "bold", children: "world" },
-      "!",
+  it('parses a single tag', () => {
+    expect(parseRichText('Hello <bold>world</bold>!')).toEqual([
+      'Hello ',
+      { tag: 'bold', children: 'world' },
+      '!',
     ])
   })
 
-  it("parses multiple tags", () => {
-    expect(parseRichText("Read <terms>terms</terms> and <privacy>policy</privacy>")).toEqual([
-      "Read ",
-      { tag: "terms", children: "terms" },
-      " and ",
-      { tag: "privacy", children: "policy" },
+  it('parses multiple tags', () => {
+    expect(parseRichText('Read <terms>terms</terms> and <privacy>policy</privacy>')).toEqual([
+      'Read ',
+      { tag: 'terms', children: 'terms' },
+      ' and ',
+      { tag: 'privacy', children: 'policy' },
     ])
   })
 
-  it("handles tags at the start and end", () => {
-    expect(parseRichText("<a>start</a> middle <b>end</b>")).toEqual([
-      { tag: "a", children: "start" },
-      " middle ",
-      { tag: "b", children: "end" },
+  it('handles tags at the start and end', () => {
+    expect(parseRichText('<a>start</a> middle <b>end</b>')).toEqual([
+      { tag: 'a', children: 'start' },
+      ' middle ',
+      { tag: 'b', children: 'end' },
     ])
   })
 
-  it("handles adjacent tags with no gap", () => {
-    expect(parseRichText("<a>one</a><b>two</b>")).toEqual([
-      { tag: "a", children: "one" },
-      { tag: "b", children: "two" },
+  it('handles adjacent tags with no gap', () => {
+    expect(parseRichText('<a>one</a><b>two</b>')).toEqual([
+      { tag: 'a', children: 'one' },
+      { tag: 'b', children: 'two' },
     ])
   })
 
-  it("leaves unmatched tags as plain text", () => {
-    expect(parseRichText("Hello <open>no close")).toEqual(["Hello <open>no close"])
+  it('leaves unmatched tags as plain text', () => {
+    expect(parseRichText('Hello <open>no close')).toEqual(['Hello <open>no close'])
   })
 })
 
 // ─── Trans ──────────────────────────────────────────────────────────────────
 
-describe("Trans", () => {
-  it("returns plain translated text when no components provided", () => {
-    const t = (key: string) => (key === "hello" ? "Hello World" : key)
-    const result = Trans({ t, i18nKey: "hello" })
-    expect(result).toBe("Hello World")
+describe('Trans', () => {
+  it('returns plain translated text when no components provided', () => {
+    const t = (key: string) => (key === 'hello' ? 'Hello World' : key)
+    const result = Trans({ t, i18nKey: 'hello' })
+    expect(result).toBe('Hello World')
   })
 
-  it("returns plain translated text with values but no components", () => {
+  it('returns plain translated text with values but no components', () => {
     const i18n = createI18n({
-      locale: "en",
-      messages: { en: { greeting: "Hi {{name}}!" } },
+      locale: 'en',
+      messages: { en: { greeting: 'Hi {{name}}!' } },
     })
     const result = Trans({
       t: i18n.t,
-      i18nKey: "greeting",
-      values: { name: "Alice" },
+      i18nKey: 'greeting',
+      values: { name: 'Alice' },
     })
-    expect(result).toBe("Hi Alice!")
+    expect(result).toBe('Hi Alice!')
   })
 
-  it("returns plain string when components map is provided but text has no tags", () => {
-    const t = () => "No tags here"
+  it('returns plain string when components map is provided but text has no tags', () => {
+    const t = () => 'No tags here'
     const result = Trans({
       t,
-      i18nKey: "plain",
-      components: { bold: (ch: string) => ({ type: "strong", children: ch }) },
+      i18nKey: 'plain',
+      components: { bold: (ch: string) => ({ type: 'strong', children: ch }) },
     })
-    expect(result).toBe("No tags here")
+    expect(result).toBe('No tags here')
   })
 
-  it("invokes component functions for matched tags", () => {
-    const t = () => "Click <link>here</link> please"
+  it('invokes component functions for matched tags', () => {
+    const t = () => 'Click <link>here</link> please'
     const result = Trans({
       t,
-      i18nKey: "action",
+      i18nKey: 'action',
       components: {
         link: (children: string) => ({
-          type: "a",
-          props: { href: "/go" },
+          type: 'a',
+          props: { href: '/go' },
           children,
         }),
       },
@@ -780,87 +780,87 @@ describe("Trans", () => {
 
     // Result is a Fragment VNode; check its children
     expect(result).toBeTruthy()
-    expect(typeof result).toBe("object")
+    expect(typeof result).toBe('object')
     // The Fragment wraps: ["Click ", { type: 'a', ... }, " please"]
     const vnode = result as any
     expect(vnode.children.length).toBe(3)
-    expect(vnode.children[0]).toBe("Click ")
+    expect(vnode.children[0]).toBe('Click ')
     expect(vnode.children[1]).toEqual({
-      type: "a",
-      props: { href: "/go" },
-      children: "here",
+      type: 'a',
+      props: { href: '/go' },
+      children: 'here',
     })
-    expect(vnode.children[2]).toBe(" please")
+    expect(vnode.children[2]).toBe(' please')
   })
 
-  it("renders unmatched tags as plain text children (no raw HTML)", () => {
-    const t = () => "Hello <unknown>world</unknown>"
+  it('renders unmatched tags as plain text children (no raw HTML)', () => {
+    const t = () => 'Hello <unknown>world</unknown>'
     const result = Trans({
       t,
-      i18nKey: "test",
+      i18nKey: 'test',
       components: {}, // No matching component
     })
 
     const vnode = result as any
     expect(vnode.children.length).toBe(2)
-    expect(vnode.children[0]).toBe("Hello ")
+    expect(vnode.children[0]).toBe('Hello ')
     // Unmatched tags render children as plain text, stripping markup for safety
-    expect(vnode.children[1]).toBe("world")
+    expect(vnode.children[1]).toBe('world')
   })
 
-  it("works with values and components together", () => {
+  it('works with values and components together', () => {
     const i18n = createI18n({
-      locale: "en",
+      locale: 'en',
       messages: {
-        en: { items: "You have <bold>{{count}}</bold> items" },
+        en: { items: 'You have <bold>{{count}}</bold> items' },
       },
     })
 
     const result = Trans({
       t: i18n.t,
-      i18nKey: "items",
+      i18nKey: 'items',
       values: { count: 42 },
       components: {
-        bold: (children: string) => ({ type: "strong", children }),
+        bold: (children: string) => ({ type: 'strong', children }),
       },
     })
 
     const vnode = result as any
     expect(vnode.children.length).toBe(3)
-    expect(vnode.children[0]).toBe("You have ")
-    expect(vnode.children[1]).toEqual({ type: "strong", children: "42" })
-    expect(vnode.children[2]).toBe(" items")
+    expect(vnode.children[0]).toBe('You have ')
+    expect(vnode.children[1]).toEqual({ type: 'strong', children: '42' })
+    expect(vnode.children[2]).toBe(' items')
   })
 })
 
 // ─── addMessages flat keys ──────────────────────────────────────────────────
 
-describe("addMessages flat dot-notation keys", () => {
-  it("flat key makes t() resolve via dot notation", () => {
-    const i18n = createI18n({ locale: "en", messages: { en: {} } })
-    i18n.addMessages("en", { "section.title": "Report" })
-    expect(i18n.t("section.title")).toBe("Report")
+describe('addMessages flat dot-notation keys', () => {
+  it('flat key makes t() resolve via dot notation', () => {
+    const i18n = createI18n({ locale: 'en', messages: { en: {} } })
+    i18n.addMessages('en', { 'section.title': 'Report' })
+    expect(i18n.t('section.title')).toBe('Report')
   })
 
-  it("nested keys still work", () => {
-    const i18n = createI18n({ locale: "en", messages: { en: {} } })
-    i18n.addMessages("en", { section: { title: "Report" } })
-    expect(i18n.t("section.title")).toBe("Report")
+  it('nested keys still work', () => {
+    const i18n = createI18n({ locale: 'en', messages: { en: {} } })
+    i18n.addMessages('en', { section: { title: 'Report' } })
+    expect(i18n.t('section.title')).toBe('Report')
   })
 
-  it("mixed flat and nested keys", () => {
-    const i18n = createI18n({ locale: "en", messages: { en: {} } })
-    i18n.addMessages("en", { "a.b": "flat", c: { d: "nested" } })
-    expect(i18n.t("a.b")).toBe("flat")
-    expect(i18n.t("c.d")).toBe("nested")
+  it('mixed flat and nested keys', () => {
+    const i18n = createI18n({ locale: 'en', messages: { en: {} } })
+    i18n.addMessages('en', { 'a.b': 'flat', c: { d: 'nested' } })
+    expect(i18n.t('a.b')).toBe('flat')
+    expect(i18n.t('c.d')).toBe('nested')
   })
 })
 
 // ─── core subpath ───────────────────────────────────────────────────────────
 
-describe("i18n core subpath", () => {
-  it("exports createI18n and interpolate without @pyreon/core dependency", async () => {
-    const mod = await import("../core")
+describe('i18n core subpath', () => {
+  it('exports createI18n and interpolate without @pyreon/core dependency', async () => {
+    const mod = await import('../core')
     expect(mod.createI18n).toBeDefined()
     expect(mod.interpolate).toBeDefined()
   })