@geenius/i18n 0.1.0

package/packages/shared/src/config.ts

@@ -0,0 +1,344 @@
+/**
+ * I18n configuration and setup
+ */
+
+import type { Locale, I18nConfig, TranslationDict } from './types'
+
+/**
+ * I18n configuration builder
+ *
+ * @example
+ * ```ts
+ * const i18nConfig = createI18nConfig()
+ *   .withDefaultLocale('en')
+ *   .withSupportedLocales(['en', 'fr', 'de'])
+ *   .withFallbackLocale('en')
+ *   .withNamespace('common')
+ * ```
+ */
+export class I18nConfigBuilder {
+  private config: I18nConfig = {
+    defaultLocale: 'en',
+    supportedLocales: ['en'],
+    fallbackLocale: 'en',
+    namespace: 'translations',
+    debug: false,
+  }
+
+  /**
+   * Sets default locale
+   */
+  withDefaultLocale(locale: Locale): this {
+    this.config.defaultLocale = locale
+    return this
+  }
+
+  /**
+   * Sets supported locales
+   */
+  withSupportedLocales(locales: Locale[]): this {
+    this.config.supportedLocales = locales
+    return this
+  }
+
+  /**
+   * Sets fallback locale when translation is missing
+   */
+  withFallbackLocale(locale: Locale): this {
+    this.config.fallbackLocale = locale
+    return this
+  }
+
+  /**
+   * Sets translation namespace
+   */
+  withNamespace(namespace: string): this {
+    this.config.namespace = namespace
+    return this
+  }
+
+  /**
+   * Sets debug mode
+   */
+  withDebug(enabled: boolean): this {
+    this.config.debug = enabled
+    return this
+  }
+
+  /**
+   * Enables missing key warnings
+   */
+  withMissingKeyWarnings(enabled: boolean): this {
+    this.config.missingKeyWarnings = enabled
+    return this
+  }
+
+  /**
+   * Sets missing key prefix
+   */
+  withMissingKeyPrefix(prefix: string): this {
+    this.config.missingKeyPrefix = prefix
+    return this
+  }
+
+  /**
+   * Builds the configuration
+   */
+  build(): I18nConfig {
+    if (!this.config.supportedLocales.includes(this.config.defaultLocale)) {
+      throw new Error(
+        `Default locale ${this.config.defaultLocale} must be in supported locales`
+      )
+    }
+
+    if (!this.config.supportedLocales.includes(this.config.fallbackLocale)) {
+      throw new Error(
+        `Fallback locale ${this.config.fallbackLocale} must be in supported locales`
+      )
+    }
+
+    return this.config
+  }
+}
+
+/**
+ * Creates a new I18n configuration builder
+ */
+export function createI18nConfig(): I18nConfigBuilder {
+  return new I18nConfigBuilder()
+}
+
+/**
+ * Translation loader configuration
+ */
+export interface TranslationLoaderConfig {
+  /** Base URL for loading translations */
+  baseUrl?: string
+  /** Whether to cache loaded translations */
+  cache?: boolean
+  /** Cache duration in milliseconds */
+  cacheDuration?: number
+  /** Whether to load all locales on init */
+  preloadAll?: boolean
+}
+
+/**
+ * Creates a translation loader
+ *
+ * @example
+ * ```ts
+ * const loader = createTranslationLoader({
+ *   baseUrl: '/locales',
+ *   cache: true,
+ *   cacheDuration: 3600000
+ * })
+ *
+ * const translations = await loader.load('en', 'common')
+ * ```
+ */
+export function createTranslationLoader(config: TranslationLoaderConfig = {}) {
+  const cache = new Map<string, { data: TranslationDict; timestamp: number }>()
+  const {
+    baseUrl = '/locales',
+    cache: enableCache = true,
+    cacheDuration = 3600000, // 1 hour
+  } = config
+
+  return {
+    /**
+     * Loads translations for a locale and namespace
+     */
+    async load(locale: Locale, namespace: string): Promise<TranslationDict> {
+      const cacheKey = `${locale}:${namespace}`
+
+      // Check cache
+      if (enableCache) {
+        const cached = cache.get(cacheKey)
+        if (cached && Date.now() - cached.timestamp < cacheDuration) {
+          return cached.data
+        }
+      }
+
+      try {
+        const url = `${baseUrl}/${locale}/${namespace}.json`
+        const response = await fetch(url)
+
+        if (!response.ok) {
+          console.warn(
+            `Failed to load translations from ${url}: ${response.statusText}`
+          )
+          return {}
+        }
+
+        const data = (await response.json()) as TranslationDict
+
+        // Cache result
+        if (enableCache) {
+          cache.set(cacheKey, {
+            data,
+            timestamp: Date.now(),
+          })
+        }
+
+        return data
+      } catch (error) {
+        console.error(`Error loading translations for ${locale}/${namespace}:`, error)
+        return {}
+      }
+    },
+
+    /**
+     * Preloads all locales for a namespace
+     */
+    async preload(locales: Locale[], namespace: string): Promise<void> {
+      await Promise.all(locales.map((locale) => this.load(locale, namespace)))
+    },
+
+    /**
+     * Clears cache
+     */
+    clearCache(locale?: Locale, namespace?: string) {
+      if (locale && namespace) {
+        cache.delete(`${locale}:${namespace}`)
+      } else {
+        cache.clear()
+      }
+    },
+
+    /**
+     * Gets cache stats
+     */
+    getCacheStats() {
+      return {
+        size: cache.size,
+        entries: Array.from(cache.keys()),
+      }
+    },
+  }
+}
+
+/**
+ * Namespace loader for managing multiple translation namespaces
+ *
+ * @example
+ * ```ts
+ * const loader = createNamespaceLoader(createTranslationLoader())
+ * const translations = await loader.loadMultiple('en', ['common', 'errors'])
+ * ```
+ */
+export function createNamespaceLoader(
+  translationLoader: ReturnType<typeof createTranslationLoader>
+) {
+  const namespaces = new Map<string, TranslationDict>()
+
+  return {
+    /**
+     * Loads a single namespace
+     */
+    async load(locale: Locale, namespace: string): Promise<TranslationDict> {
+      const translations = await translationLoader.load(locale, namespace)
+      const key = `${locale}:${namespace}`
+      namespaces.set(key, translations)
+      return translations
+    },
+
+    /**
+     * Loads multiple namespaces
+     */
+    async loadMultiple(
+      locale: Locale,
+      namespaceList: string[]
+    ): Promise<Record<string, TranslationDict>> {
+      const result: Record<string, TranslationDict> = {}
+
+      for (const ns of namespaceList) {
+        result[ns] = await this.load(locale, ns)
+      }
+
+      return result
+    },
+
+    /**
+     * Gets loaded namespace
+     */
+    get(locale: Locale, namespace: string): TranslationDict | undefined {
+      return namespaces.get(`${locale}:${namespace}`)
+    },
+
+    /**
+     * Merges multiple translations into one
+     */
+    merge(
+      locale: Locale,
+      namespaceList: string[]
+    ): TranslationDict {
+      const merged: TranslationDict = {}
+
+      for (const ns of namespaceList) {
+        const trans = this.get(locale, ns)
+        if (trans) {
+          Object.assign(merged, trans)
+        }
+      }
+
+      return merged
+    },
+  }
+}
+
+/**
+ * Default i18n configurations for different scenarios
+ */
+export const i18nPresets = {
+  /**
+   * Simple single-language setup
+   */
+  simple: (locale: Locale = 'en'): I18nConfig => {
+    return createI18nConfig()
+      .withDefaultLocale(locale)
+      .withSupportedLocales([locale])
+      .build()
+  },
+
+  /**
+   * Multi-language with common locales
+   */
+  multi: (defaultLocale: Locale = 'en'): I18nConfig => {
+    return createI18nConfig()
+      .withDefaultLocale(defaultLocale)
+      .withSupportedLocales(['en', 'fr', 'de', 'es', 'it'])
+      .build()
+  },
+
+  /**
+   * Global localization
+   */
+  global: (defaultLocale: Locale = 'en'): I18nConfig => {
+    return createI18nConfig()
+      .withDefaultLocale(defaultLocale)
+      .withSupportedLocales([
+        'en',
+        'fr',
+        'de',
+        'es',
+        'it',
+        'pt',
+        'ru',
+        'zh',
+        'ja',
+        'ko',
+      ] as Locale[])
+      .build()
+  },
+
+  /**
+   * Development configuration with debug output
+   */
+  development: (): I18nConfig => {
+    return createI18nConfig()
+      .withDebug(true)
+      .withMissingKeyWarnings(true)
+      .withMissingKeyPrefix('[MISSING] ')
+      .build()
+  },
+}

package/packages/shared/src/index.ts

@@ -0,0 +1,106 @@
+export type {
+  Locale, Direction, I18nNamespace, TranslationDict, I18nConfig,
+  LocaleInfo, TranslationEntry, MissingKey, LocaleStat,
+} from './types'
+
+import type { Locale, Direction, LocaleInfo, TranslationDict } from './types'
+
+// ─── LOCALE_INFO (14 locales) ─────────────────────────
+export const LOCALE_INFO: Record<Locale, LocaleInfo> = {
+  en: { code: 'en', name: 'English', nativeName: 'English', direction: 'ltr', flag: '🇬🇧' },
+  fr: { code: 'fr', name: 'French', nativeName: 'Français', direction: 'ltr', flag: '🇫🇷' },
+  de: { code: 'de', name: 'German', nativeName: 'Deutsch', direction: 'ltr', flag: '🇩🇪' },
+  es: { code: 'es', name: 'Spanish', nativeName: 'Español', direction: 'ltr', flag: '🇪🇸' },
+  pt: { code: 'pt', name: 'Portuguese', nativeName: 'Português', direction: 'ltr', flag: '🇵🇹' },
+  it: { code: 'it', name: 'Italian', nativeName: 'Italiano', direction: 'ltr', flag: '🇮🇹' },
+  nl: { code: 'nl', name: 'Dutch', nativeName: 'Nederlands', direction: 'ltr', flag: '🇳🇱' },
+  ru: { code: 'ru', name: 'Russian', nativeName: 'Русский', direction: 'ltr', flag: '🇷🇺' },
+  zh: { code: 'zh', name: 'Chinese', nativeName: '中文', direction: 'ltr', flag: '🇨🇳' },
+  ja: { code: 'ja', name: 'Japanese', nativeName: '日本語', direction: 'ltr', flag: '🇯🇵' },
+  ko: { code: 'ko', name: 'Korean', nativeName: '한국어', direction: 'ltr', flag: '🇰🇷' },
+  ar: { code: 'ar', name: 'Arabic', nativeName: 'العربية', direction: 'rtl', flag: '🇸🇦' },
+  he: { code: 'he', name: 'Hebrew', nativeName: 'עברית', direction: 'rtl', flag: '🇮🇱' },
+  tr: { code: 'tr', name: 'Turkish', nativeName: 'Türkçe', direction: 'ltr', flag: '🇹🇷' },
+}
+
+export const ALL_LOCALES: Locale[] = Object.keys(LOCALE_INFO) as Locale[]
+export const RTL_LOCALES: Locale[] = ['ar', 'he']
+
+// ─── Translation Utilities ────────────────────────────
+export function interpolate(template: string, params: Record<string, string | number>): string {
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => String(params[key] ?? `{{${key}}}`))
+}
+
+export function t(key: string, dict: TranslationDict, params?: Record<string, string | number>): string {
+  const parts = key.split('.')
+  let current: string | TranslationDict = dict
+  for (const part of parts) {
+    if (typeof current !== 'object' || current === null) return key
+    current = (current as TranslationDict)[part]
+    if (current === undefined) return key
+  }
+  if (typeof current !== 'string') return key
+  return params ? interpolate(current, params) : current
+}
+
+export function plural(key: string, count: number, dict: TranslationDict): string {
+  if (count === 0) { const zero = t(`${key}_zero`, dict); if (zero !== `${key}_zero`) return zero }
+  if (count === 1) { const one = t(`${key}_one`, dict); if (one !== `${key}_one`) return one }
+  const other = t(`${key}_other`, dict)
+  if (other !== `${key}_other`) return interpolate(other, { count })
+  return t(key, dict, { count })
+}
+
+// ─── Formatting ───────────────────────────────────────
+export function formatDate(date: Date | string, locale: Locale, format?: Intl.DateTimeFormatOptions): string {
+  const d = typeof date === 'string' ? new Date(date) : date
+  return new Intl.DateTimeFormat(locale, format ?? { dateStyle: 'medium' }).format(d)
+}
+
+export function formatNumber(n: number, locale: Locale, opts?: Intl.NumberFormatOptions): string {
+  return new Intl.NumberFormat(locale, opts).format(n)
+}
+
+export function formatCurrency(amount: number, currency: string, locale: Locale): string {
+  return new Intl.NumberFormat(locale, { style: 'currency', currency }).format(amount)
+}
+
+// ─── Detection & Direction ────────────────────────────
+export function detectLocale(supportedLocales: Locale[]): Locale {
+  if (typeof navigator === 'undefined') return supportedLocales[0] ?? 'en'
+  const browserLang = navigator.language.split('-')[0] as Locale
+  if (supportedLocales.includes(browserLang)) return browserLang
+  const full = navigator.language as Locale
+  if (supportedLocales.includes(full)) return full
+  return supportedLocales[0] ?? 'en'
+}
+
+export function getDirection(locale: Locale): Direction {
+  return LOCALE_INFO[locale]?.direction ?? 'ltr'
+}
+
+export function isRTL(locale: Locale): boolean {
+  return getDirection(locale) === 'rtl'
+}
+
+// ─── Namespace Loader (stub) ──────────────────────────
+const namespaceCache = new Map<string, TranslationDict>()
+
+export async function loadNamespace(locale: Locale, ns: string): Promise<TranslationDict> {
+  const cacheKey = `${locale}:${ns}`
+  if (namespaceCache.has(cacheKey)) return namespaceCache.get(cacheKey)!
+  // In real usage this would fetch from API/CDN — stub returns empty dict
+  const dict: TranslationDict = {}
+  namespaceCache.set(cacheKey, dict)
+  return dict
+}
+
+export function flattenDict(dict: TranslationDict, prefix = ''): Record<string, string> {
+  const result: Record<string, string> = {}
+  for (const [key, value] of Object.entries(dict)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key
+    if (typeof value === 'string') result[fullKey] = value
+    else Object.assign(result, flattenDict(value, fullKey))
+  }
+  return result
+}

package/packages/shared/src/types.ts

@@ -0,0 +1,51 @@
+export type Locale = 'en' | 'fr' | 'de' | 'es' | 'pt' | 'it' | 'nl' | 'ru' | 'zh' | 'ja' | 'ko' | 'ar' | 'he' | 'tr'
+export type Direction = 'ltr' | 'rtl'
+export type I18nNamespace = 'common' | 'auth' | 'dashboard' | 'billing' | 'errors' | string
+
+export type TranslationDict = Record<string, string | TranslationDict>
+
+export interface I18nConfig {
+  defaultLocale: Locale
+  supportedLocales: Locale[]
+  fallbackLocale?: Locale
+  namespaces?: I18nNamespace[]
+  detectBrowser?: boolean
+  persistLocale?: boolean
+  dateFormat?: string
+  numberFormat?: Intl.NumberFormatOptions
+}
+
+export interface LocaleInfo {
+  code: Locale
+  name: string
+  nativeName: string
+  direction: Direction
+  flag: string
+}
+
+export interface TranslationEntry {
+  id: string
+  locale: Locale
+  namespace: string
+  key: string
+  value: string
+  lastEditedBy?: string
+  updatedAt: string
+  createdAt: string
+}
+
+export interface MissingKey {
+  id: string
+  locale: Locale
+  namespace: string
+  key: string
+  detectedAt: string
+  count: number
+}
+
+export interface LocaleStat {
+  locale: Locale
+  totalKeys: number
+  missingKeys: number
+  coverage: number
+}

package/packages/shared/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler"
+  },
+  "include": [
+    "src"
+  ]
+}

package/packages/shared/tsup.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+    entry: { index: 'src/index.ts' },
+    outDir: 'dist',
+    format: ['esm'],
+    dts: true,
+    sourcemap: true,
+    clean: true,
+    treeshake: true,
+})

package/packages/shared/vitest.config.ts

@@ -0,0 +1,4 @@
+import { defineConfig } from 'vitest/config'
+export default defineConfig({
+  test: { globals: true, environment: 'node' },
+})

package/packages/solidjs/README.md

@@ -0,0 +1 @@
+# ✦ @geenius-i18n/solidjs\n\n> Geenius I18n — SolidJS components & primitives\n\n---\n\n## Overview\nBuilt with Steve Jobs-level minimalism and Jony Ive-level craftsmanship, this package is designed to deliver unparalleled developer experience (DX) and rock-solid performance.\n\n## Installation\n\n```bash\npnpm add @geenius-i18n/solidjs\n```\n\n## Usage\n\n```typescript\nimport { init } from '@geenius-i18n/solidjs';\n\n// Initialize the module with absolute precision\ninit({\n  mode: 'premium',\n});\n```\n\n## Architecture\n- **Zero-config**: It just works.\n- **Strictly Typed**: Fully written in TypeScript for flawless IntelliSense.\n- **Framework Agnostic**: seamlessly integrates into the Geenius ecosystem.\n\n---\n\n*Designed by Antigravity HQ*\n

package/packages/solidjs/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@geenius-i18n/solidjs",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "description": "Geenius I18n — SolidJS components & primitives",
+  "author": "Antigravity HQ",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "clean": "rm -rf dist",
+    "type-check": "tsc --noEmit",
+    "prepublishOnly": "pnpm clean && pnpm build"
+  },
+  "dependencies": {
+    "@geenius-i18n/shared": "workspace:*"
+  },
+  "devDependencies": {
+    "solid-js": "^1.9.0",
+    "tsup": "^8.5.1",
+    "typescript": "~6.0.2",
+    "@tanstack/solid-router": "^1.111.0"
+  },
+  "peerDependencies": {
+    "solid-js": "^1.8.0 || ^1.9.0",
+    "@tanstack/solid-router": "^1.0.0"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

package/packages/solidjs/src/components/LocaleCard.tsx

@@ -0,0 +1,44 @@
+import { Show } from 'solid-js'
+import type { Component } from 'solid-js'
+import type { Locale } from '@geenius-i18n/shared'
+import { LOCALE_INFO } from '@geenius-i18n/shared'
+
+interface Props {
+  locale: Locale
+  coverage?: number
+}
+
+export const LocaleCard: Component<Props> = (props) => {
+  const info = () => LOCALE_INFO[props.locale]
+  const barColor = () =>
+    (props.coverage ?? 0) >= 90 ? 'oklch(0.72 0.18 155)' :
+    (props.coverage ?? 0) >= 70 ? 'oklch(0.72 0.18 60)' :
+    'oklch(0.60 0.25 25)'
+
+  return (
+    <div style={{
+      'border-radius': '0.75rem', border: '1px solid oklch(1 0 0 / 0.08)',
+      background: 'oklch(1 0 0 / 0.02)', padding: '1rem',
+    }}>
+      <div style={{ display: 'flex', 'align-items': 'center', gap: '0.75rem', 'margin-bottom': '0.75rem' }}>
+        <span style={{ 'font-size': '1.5rem' }}>{info()?.flag}</span>
+        <div>
+          <p style={{ 'font-size': '0.875rem', 'font-weight': '600', color: 'oklch(1 0 0 / 0.85)' }}>{info()?.nativeName}</p>
+          <p style={{ 'font-size': '0.625rem', color: 'oklch(1 0 0 / 0.4)' }}>{info()?.name} — {props.locale.toUpperCase()}</p>
+        </div>
+        <Show when={info()?.direction === 'rtl'}>
+          <span style={{
+            'margin-left': 'auto', 'font-size': '0.625rem', padding: '0.125rem 0.375rem',
+            'border-radius': '0.25rem', background: 'oklch(0.72 0.18 60 / 0.15)', color: 'oklch(0.72 0.18 60)',
+          }}>RTL</span>
+        </Show>
+      </div>
+      <Show when={props.coverage !== undefined}>
+        <div style={{ height: '0.375rem', 'border-radius': '9999px', background: 'oklch(1 0 0 / 0.05)', overflow: 'hidden' }}>
+          <div style={{ height: '100%', 'border-radius': '9999px', background: barColor(), width: `${props.coverage}%` }} />
+        </div>
+        <p style={{ 'margin-top': '0.25rem', 'font-size': '0.625rem', color: 'oklch(1 0 0 / 0.4)', 'text-align': 'right' }}>{props.coverage}%</p>
+      </Show>
+    </div>
+  )
+}

package/packages/solidjs/src/components/LocaleStatsCard.tsx

@@ -0,0 +1,35 @@
+import { For, Show } from 'solid-js'
+import type { Component } from 'solid-js'
+import type { LocaleStat } from '@geenius-i18n/shared'
+import { LOCALE_INFO } from '@geenius-i18n/shared'
+
+export const LocaleStatsCard: Component<{ stats: LocaleStat[] }> = (props) => {
+  return (
+    <div style={{ display: 'grid', 'grid-template-columns': 'repeat(4, 1fr)', gap: '0.75rem' }}>
+      <For each={props.stats}>
+        {(s) => {
+          const info = LOCALE_INFO[s.locale]
+          const barColor = s.coverage >= 90 ? 'oklch(0.72 0.18 155)' : s.coverage >= 70 ? 'oklch(0.72 0.18 60)' : 'oklch(0.60 0.25 25)'
+          return (
+            <div style={{ 'border-radius': '0.75rem', border: '1px solid oklch(1 0 0 / 0.08)', background: 'oklch(1 0 0 / 0.02)', padding: '1rem' }}>
+              <div style={{ display: 'flex', 'align-items': 'center', gap: '0.5rem', 'margin-bottom': '0.5rem' }}>
+                <span style={{ 'font-size': '1.125rem' }}>{info?.flag}</span>
+                <span style={{ 'font-size': '0.75rem', 'font-weight': '500', color: 'oklch(1 0 0 / 0.8)' }}>{info?.nativeName}</span>
+              </div>
+              <div style={{ display: 'flex', 'justify-content': 'space-between', 'font-size': '0.625rem', color: 'oklch(1 0 0 / 0.4)', 'margin-bottom': '0.25rem' }}>
+                <span>{s.totalKeys} keys</span>
+                <span style={{ 'font-weight': '700' }}>{s.coverage}%</span>
+              </div>
+              <div style={{ height: '0.375rem', 'border-radius': '9999px', background: 'oklch(1 0 0 / 0.05)', overflow: 'hidden' }}>
+                <div style={{ height: '100%', 'border-radius': '9999px', background: barColor, width: `${s.coverage}%` }} />
+              </div>
+              <Show when={s.missingKeys > 0}>
+                <p style={{ 'margin-top': '0.375rem', 'font-size': '0.625rem', color: 'oklch(0.60 0.25 25)' }}>{s.missingKeys} missing</p>
+              </Show>
+            </div>
+          )
+        }}
+      </For>
+    </div>
+  )
+}