@lokascript/i18n 1.3.0 → 2.1.0

package/src/runtime.test.ts

@@ -0,0 +1,152 @@
+import { describe, it, expect, beforeEach, vi as vitest } from 'vitest';
+import { RuntimeI18nManager, initializeI18n, getI18n, runtimeI18n } from './runtime';
+
+// Reset the global runtimeI18n between tests
+function resetGlobalI18n() {
+  // Directly reset the module-level variable via re-import side effects
+  // We'll test initializeI18n/getI18n via the exported functions
+}
+
+describe('RuntimeI18nManager', () => {
+  let manager: RuntimeI18nManager;
+
+  beforeEach(() => {
+    manager = new RuntimeI18nManager({ locale: 'en' });
+  });
+
+  describe('constructor', () => {
+    it('creates with default options', () => {
+      const m = new RuntimeI18nManager();
+      expect(m.getLocale()).toBe('en');
+    });
+
+    it('creates with custom locale', () => {
+      const m = new RuntimeI18nManager({ locale: 'es' });
+      expect(m.getLocale()).toBe('es');
+    });
+  });
+
+  describe('getLocale', () => {
+    it('returns current locale', () => {
+      expect(manager.getLocale()).toBe('en');
+    });
+  });
+
+  describe('setLocale', () => {
+    it('updates the current locale', async () => {
+      await manager.setLocale('fr');
+      expect(manager.getLocale()).toBe('fr');
+    });
+
+    it('skips when same locale', async () => {
+      const observer = vitest.fn();
+      manager.onLocaleChange(observer);
+      await manager.setLocale('en'); // same as current
+      expect(observer).not.toHaveBeenCalled();
+    });
+
+    it('notifies observers on locale change', async () => {
+      const observer = vitest.fn();
+      manager.onLocaleChange(observer);
+      await manager.setLocale('ja');
+      expect(observer).toHaveBeenCalledWith('ja');
+    });
+  });
+
+  describe('onLocaleChange', () => {
+    it('subscribes to locale changes', async () => {
+      const callback = vitest.fn();
+      manager.onLocaleChange(callback);
+      await manager.setLocale('ko');
+      expect(callback).toHaveBeenCalledWith('ko');
+    });
+
+    it('returns cleanup function that unsubscribes', async () => {
+      const callback = vitest.fn();
+      const cleanup = manager.onLocaleChange(callback);
+      cleanup();
+      await manager.setLocale('de');
+      expect(callback).not.toHaveBeenCalled();
+    });
+
+    it('supports multiple observers', async () => {
+      const cb1 = vitest.fn();
+      const cb2 = vitest.fn();
+      manager.onLocaleChange(cb1);
+      manager.onLocaleChange(cb2);
+      await manager.setLocale('fr');
+      expect(cb1).toHaveBeenCalledWith('fr');
+      expect(cb2).toHaveBeenCalledWith('fr');
+    });
+  });
+
+  describe('isRTL', () => {
+    it('returns true for Arabic', () => {
+      expect(manager.isRTL('ar')).toBe(true);
+    });
+
+    it('returns false for English', () => {
+      expect(manager.isRTL('en')).toBe(false);
+    });
+
+    it('uses current locale when no argument', () => {
+      expect(manager.isRTL()).toBe(false);
+    });
+  });
+
+  describe('getSupportedLocales', () => {
+    it('returns array of locale codes', () => {
+      const locales = manager.getSupportedLocales();
+      expect(locales).toContain('en');
+      expect(locales).toContain('es');
+      expect(locales).toContain('ja');
+      expect(locales.length).toBeGreaterThanOrEqual(22);
+    });
+  });
+
+  describe('translate', () => {
+    it('translates from English to target locale', () => {
+      const result = manager.translate('on', { to: 'es' });
+      expect(typeof result).toBe('string');
+      expect(result.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('createLocaleSwitcher', () => {
+    it('creates a dropdown element by default', () => {
+      const switcher = manager.createLocaleSwitcher();
+      expect(switcher.tagName).toBe('SELECT');
+    });
+
+    it('creates a button container when type is buttons', () => {
+      const switcher = manager.createLocaleSwitcher({ type: 'buttons' });
+      expect(switcher.tagName).toBe('DIV');
+    });
+
+    it('applies custom className', () => {
+      const switcher = manager.createLocaleSwitcher({ className: 'my-switcher' });
+      expect(switcher.className).toBe('my-switcher');
+    });
+  });
+});
+
+describe('initializeI18n / getI18n', () => {
+  it('getI18n throws before initialization', () => {
+    // Reset global state — the module re-exports `runtimeI18n` as let
+    // We can't easily reset it, so we test the pattern
+    // This test is valid only if runtimeI18n hasn't been set yet in this module scope
+  });
+
+  it('initializeI18n creates a global instance', () => {
+    const instance = initializeI18n({ locale: 'en' });
+    expect(instance).toBeInstanceOf(RuntimeI18nManager);
+    expect(instance.getLocale()).toBe('en');
+  });
+
+  it('getI18n returns the initialized instance', () => {
+    initializeI18n({ locale: 'fr' });
+    const instance = getI18n();
+    expect(instance).toBeInstanceOf(RuntimeI18nManager);
+    expect(instance.getLocale()).toBe('fr');
+  });
+});

package/src/runtime.ts

@@ -4,6 +4,7 @@ import { HyperscriptTranslator } from './translator';
 import { Dictionary, I18nConfig, TranslationOptions } from './types';
 import { getBrowserLocales, isRTL } from './utils/locale';
 import { getFormatter } from './formatting';
+import { profiles } from './grammar/profiles';
 
 /**
  * Runtime i18n manager for client-side locale switching
@@ -377,21 +378,39 @@ export class RuntimeI18nManager {
    * Get locale display name
    */
   private getLocaleDisplayName(locale: string, showNative: boolean): string {
-    const names: Record<string, { english: string; native: string }> = {
-      en: { english: 'English', native: 'English' },
-      es: { english: 'Spanish', native: 'Español' },
-      fr: { english: 'French', native: 'Français' },
-      de: { english: 'German', native: 'Deutsch' },
-      ja: { english: 'Japanese', native: '日本語' },
-      ko: { english: 'Korean', native: '한국어' },
-      zh: { english: 'Chinese', native: '中文' },
-      ar: { english: 'Arabic', native: 'العربية' },
-    };
+    if (showNative) {
+      const profile = profiles[locale];
+      if (profile) return profile.name;
+      return locale;
+    }
 
-    const info = names[locale];
-    if (!info) return locale;
+    const englishNames: Record<string, string> = {
+      en: 'English',
+      es: 'Spanish',
+      fr: 'French',
+      de: 'German',
+      ja: 'Japanese',
+      ko: 'Korean',
+      zh: 'Chinese',
+      ar: 'Arabic',
+      tr: 'Turkish',
+      pt: 'Portuguese',
+      id: 'Indonesian',
+      qu: 'Quechua',
+      sw: 'Swahili',
+      it: 'Italian',
+      vi: 'Vietnamese',
+      pl: 'Polish',
+      ru: 'Russian',
+      uk: 'Ukrainian',
+      hi: 'Hindi',
+      bn: 'Bengali',
+      th: 'Thai',
+      ms: 'Malay',
+      tl: 'Tagalog',
+    };
 
-    return showNative ? info.native : info.english;
+    return englishNames[locale] || locale;
   }
 
   /**

package/src/utils/locale.test.ts

@@ -0,0 +1,108 @@
+import { describe, it, expect } from 'vitest';
+import { parseLocale, getBestMatchingLocale, formatLocaleName } from './locale';
+
+describe('parseLocale', () => {
+  it('parses simple language codes', () => {
+    const result = parseLocale('en');
+    expect(result.language).toBe('en');
+    expect(result.region).toBeUndefined();
+    expect(result.script).toBeUndefined();
+  });
+
+  it('parses language-region codes', () => {
+    const result = parseLocale('en-US');
+    expect(result.language).toBe('en');
+    expect(result.region).toBe('US');
+    expect(result.script).toBeUndefined();
+  });
+
+  it('parses language-script-region codes', () => {
+    const result = parseLocale('zh-Hans-CN');
+    expect(result.language).toBe('zh');
+    expect(result.script).toBe('Hans');
+    expect(result.region).toBe('CN');
+  });
+
+  it('parses language-script without region', () => {
+    const result = parseLocale('zh-Hans');
+    expect(result.language).toBe('zh');
+    expect(result.script).toBe('Hans');
+    expect(result.region).toBeUndefined();
+  });
+
+  it('normalizes language to lowercase and region to uppercase', () => {
+    const result = parseLocale('EN-us');
+    expect(result.language).toBe('en');
+    expect(result.region).toBe('US');
+  });
+});
+
+describe('getBestMatchingLocale', () => {
+  const available = ['en', 'fr', 'zh-Hans', 'zh-Hant', 'es'];
+
+  it('returns exact match', () => {
+    expect(getBestMatchingLocale('en', available)).toBe('en');
+  });
+
+  it('returns script match over language-only match', () => {
+    expect(getBestMatchingLocale('zh-Hans-CN', available)).toBe('zh-Hans');
+  });
+
+  it('falls back to language-only match', () => {
+    expect(getBestMatchingLocale('fr-CA', available)).toBe('fr');
+  });
+
+  it('returns null when no match', () => {
+    expect(getBestMatchingLocale('de', available)).toBeNull();
+  });
+
+  it('prefers script match when available', () => {
+    expect(getBestMatchingLocale('zh-Hant-TW', available)).toBe('zh-Hant');
+  });
+});
+
+describe('formatLocaleName', () => {
+  it('returns native name from grammar profile', () => {
+    expect(formatLocaleName('ja')).toBe('日本語');
+    expect(formatLocaleName('ko')).toBe('한국어');
+    expect(formatLocaleName('es')).toBe('Español');
+    expect(formatLocaleName('ar')).toBe('العربية');
+    expect(formatLocaleName('en')).toBe('English');
+  });
+
+  it('returns locale code for unknown locales', () => {
+    expect(formatLocaleName('xx')).toBe('xx');
+    expect(formatLocaleName('unknown')).toBe('unknown');
+  });
+
+  it('covers all 22 supported languages', () => {
+    const codes = [
+      'en',
+      'es',
+      'ja',
+      'ko',
+      'zh',
+      'fr',
+      'de',
+      'ar',
+      'tr',
+      'pt',
+      'id',
+      'qu',
+      'sw',
+      'bn',
+      'it',
+      'ru',
+      'uk',
+      'vi',
+      'hi',
+      'tl',
+      'th',
+      'pl',
+    ];
+    for (const code of codes) {
+      const name = formatLocaleName(code);
+      expect(name).not.toBe(code); // Should return a real name, not the code itself
+    }
+  });
+});

package/src/utils/locale.ts

@@ -2,6 +2,7 @@
 
 import { dictionaries } from '../dictionaries';
 import { DICTIONARY_CATEGORIES } from '../types';
+import { profiles } from '../grammar/profiles';
 
 export interface LocaleInfo {
   code: string;
@@ -98,17 +99,7 @@ export function getBestMatchingLocale(
 
   const requested = parseLocale(requestedLocale);
 
-  // Try language-only match
-  const languageMatch = availableLocales.find(locale => {
-    const available = parseLocale(locale);
-    return available.language === requested.language;
-  });
-
-  if (languageMatch) {
-    return languageMatch;
-  }
-
-  // Try language-script match
+  // Try language+script match first (more specific)
   if (requested.script) {
     const scriptMatch = availableLocales.find(locale => {
       const available = parseLocale(locale);
@@ -120,6 +111,16 @@ export function getBestMatchingLocale(
     }
   }
 
+  // Fall back to language-only match
+  const languageMatch = availableLocales.find(locale => {
+    const available = parseLocale(locale);
+    return available.language === requested.language;
+  });
+
+  if (languageMatch) {
+    return languageMatch;
+  }
+
   return null;
 }
 
@@ -160,24 +161,17 @@ function escapeRegex(str: string): string {
 }
 
 /**
- * Format a locale for display
+ * Format a locale for display using the native name from its grammar profile.
  */
 export function formatLocaleName(locale: string): string {
-  const names: Record<string, string> = {
-    en: 'English',
-    es: 'Español',
-    ko: '한국어',
-    zh: '中文',
+  const profile = profiles[locale];
+  if (profile) return profile.name;
+
+  // Fallback for sub-locale codes (e.g., 'zh-TW')
+  const subLocaleNames: Record<string, string> = {
     'zh-TW': '繁體中文',
-    ja: '日本語',
-    fr: 'Français',
-    de: 'Deutsch',
-    pt: 'Português',
-    hi: 'हिन्दी',
-    ar: 'العربية',
   };
-
-  return names[locale] || locale;
+  return subLocaleNames[locale] || locale;
 }
 
 /**