@minejs/i18n 0.0.4 → 0.0.6

package/README.md

@@ -8,11 +8,10 @@
 </div>
 
 <div align="center">
-    <img src="https://img.shields.io/badge/v-0.0.4-black"/>
-    <img src="https://img.shields.io/badge/🔥-@minejs-black"/>
-    <img src="https://img.shields.io/badge/zero-dependencies-black" alt="Test Coverage" />
+    <img src="https://img.shields.io/badge/v-0.0.6-black"/>
+    <a href="https://img.shields.io/github/stars/minejs-org"><img src="https://img.shields.io/badge/🔥-@minejs-black"/></a>
     <br>
-    <img src="https://img.shields.io/badge/coverage-95.19%25-brightgreen" alt="Test Coverage" />
+    <img src="https://img.shields.io/badge/coverage-94.40%25-brightgreen" alt="Test Coverage" />
     <img src="https://img.shields.io/github/issues/minejs-org/i18n?style=flat" alt="Github Repo Issues" />
     <img src="https://img.shields.io/github/stars/minejs-org/i18n?style=social" alt="GitHub Repo stars" />
 </div>
@@ -24,700 +23,305 @@
 
 <!-- ╔══════════════════════════════ DOC ══════════════════════════════╗ -->
 
-- ## Quick Start 🔥
-
-    > **_A lightweight, production-ready internationalization (i18n) library with zero dependencies._**
-
-    - ### Setup
-
-        > install [`hmm`](https://github.com/minejs-org/hmm) first.
-
-        ```bash
-        hmm i @minejs/i18n
-        ```
+- ## Overview 👀
 
-    <div align="center"> <img src="./assets/img/line.png" alt="line" style="display: block; margin-top:20px;margin-bottom:20px;width:500px;"/> <br> </div>
+    - #### Why ?
+        > To unify the translation system and languages ​​on the server and client, faster, cleaner, more maintainable.
 
-    - ### Usage
+    - #### When ?
+        > When you need to add a translation to your server or client.
 
-        ```ts
-        import { I18nManager, setupI18n, t, setLanguage } from '@minejs/i18n'
-        ```
-
-        - ### 1. Basic Translation
-
-            ```typescript
-            import { I18nManager } from '@minejs/i18n'
-
-            // Create a manager instance
-            const i18n = new I18nManager()
-
-            // Load translations
-            i18n.loadLanguage('en', {
-                greeting: 'Hello',
-                welcome: 'Welcome to our app'
-            })
-
-            i18n.loadLanguage('ar', {
-                greeting: 'مرحبا',
-                welcome: 'مرحبا بك في تطبيقنا'
-            })
-
-            // Translate
-            console.log(i18n.t('greeting')) // "Hello"
-
-            // Switch language
-            await i18n.setLanguage('ar')
-            console.log(i18n.t('greeting')) // "مرحبا"
-            ```
-
-        - ### 2. Parameter Replacement
-
-            ```typescript
-            const i18n = new I18nManager()
-
-            i18n.loadLanguage('en', {
-                message: 'Hello {name}, you have {count} messages',
-                userName: 'John'
-            })
-
-            // Replace parameters
-            const result = i18n.t('message', {
-                name: 'John',
-                count: '5'
-            })
-            // "Hello John, you have 5 messages"
+        > When you use [@cruxjs/app](https://github.com/cruxjs-org/app).
 
-            // Parameters can reference other translation keys
-            const greeting = i18n.t('message', {
-                name: 'userName',  // References i18n.t('userName')
-                count: '3'
-            })
-            ```
+    <br>
+    <br>
 
-        - ### 3. Nested Translations
+- ## Quick Start 🔥
 
-            ```typescript
-            const i18n = new I18nManager()
-
-            // Deeply nested structures are flattened automatically
-            i18n.loadLanguage('en', {
-                app: {
-                    title: 'My App',
-                    pages: {
-                        home: {
-                            title: 'Home',
-                            description: 'Welcome to home page'
-                        },
-                        about: {
-                            title: 'About Us'
-                        }
-                    }
-                }
-            })
-
-            console.log(i18n.t('app.title')) // "My App"
-            console.log(i18n.t('app.pages.home.title')) // "Home"
-            console.log(i18n.t('app.pages.home.description')) // "Welcome to home page"
-            ```
+    > install [`hmm`](https://github.com/minejs-org/hmm) first.
 
-        - ### 4. Parse HTML Tags
+    ```bash
+    # in your terminal
+    hmm i @minejs/i18n
+    ```
 
-            ```typescript
-            const i18n = new I18nManager()
+    <div align="center"> <img src="./assets/img/line.png" alt="line" style="display: block; margin-top:20px;margin-bottom:20px;width:500px;"/> </div>
 
-            i18n.loadLanguage('en', {
-                message: 'Hello <strong>World</strong>'
-            })
+    - #### Setup
 
-            // Parse HTML tags into tokens
-            const tokens = i18n.tParse('message')
-            // [
-            //   { type: 'text', content: 'Hello ' },
-            //   { type: 'tag', tag: 'strong', content: 'World' }
-            // ]
+      - ##### JSON
 
-            // Convert newlines to <br> tags
-            i18n.loadLanguage('en', {
-                multiline: 'Line 1\\nLine 2\\nLine 3'
-            })
+        > Save the translation **keys and their values** ​​in `.json` files.
 
-            const lines = i18n.tParse('multiline')
-            // Includes <br> tags for newlines
-            ```
+        ```jsonc
+        // ./src/shared/dist/u18n/en.json
+        {
+            "key": "value"
+        }
+        ```
 
-        - ### 5. RTL Language Support
+        ```jsonc
+        // ./src/shared/dist/u18n/ar.json
+        {
+            "key": "قيـمة"
+        }
+        ```
 
-            ```typescript
-            const i18n = new I18nManager()
+      - ##### I18n
 
-            i18n.loadLanguage('en', { title: 'My App' })
-            i18n.loadLanguage('ar', { title: 'تطبيقي' })
+        > ***🌟 If you are using [`@cruxjs/app`](https://github.com/cruxjs-org/app) you can skip this step. 🌟***
 
-            // Check if current language is RTL
-            await i18n.setLanguage('ar')
-            console.log(i18n.isRTL()) // true
+        > Then in your project ***(works with any environment: `server`, `browser`, ..)***
+        >
+        > Call the `setupI18n(..)` function **only once** in your application's lifecycle :
 
-            // Check specific language
-            console.log(i18n.isRTLLanguage('ar')) // true
-            console.log(i18n.isRTLLanguage('en')) // false
+        ```ts
+        import { setupI18n } from `@minejs/i18n`;
+        ```
 
-            // Supported RTL languages: ar, he, fa, ur, yi, ji, iw, ku
-            ```
+        ```ts
+        await this.setupI18n({
+            defaultLanguage     : 'en',
+            supportedLanguages  : ['en', 'ar'],
+            basePath            : '/static/dist/i18n',      // for client side (or your custom public url)
+                                : './src/shared/dist/i18n', // for server side (or your custom local path)
+        });
+        ```
 
-        - ### 6. Language Change Events
+        <div align="center"> <img src="./assets/img/line.png" alt="line" style="display: block; margin-top:20px;margin-bottom:20px;width:500px;"/> </div>
+        <br>
 
-            ```typescript
-            const i18n = new I18nManager()
+    - #### Usage
 
-            i18n.loadLanguage('en', { greeting: 'Hello' })
-            i18n.loadLanguage('ar', { greeting: 'مرحبا' })
+        > Now you can call the `t(..)` function anywhere in your project :
 
-            // Subscribe to language changes
-            const unsubscribe = i18n.onChange((lang) => {
-                console.log('Language changed to:', lang)
-            })
+        ```tsx
+        import { t } from `@minejs/i18n`;
+        ```
 
-            await i18n.setLanguage('ar')
-            // Logs: "Language changed to: ar"
+        ```ts
+        t('key', { params }, fallback) // just it !
+        ```
 
-            // Unsubscribe
-            unsubscribe()
-            ```
+        <div align="center"> <img src="./assets/img/line.png" alt="line" style="display: block; margin-top:20px;margin-bottom:20px;width:500px;"/> </div>
 
-        - ### 7. Storage Integration
+        - #### Language Switching
 
             ```typescript
-            import { memoryStorage, browserStorage } from '@minejs/i18n'
-
-            // Use browser localStorage (automatically persists language preference)
-            const i18n = new I18nManager({
-                defaultLanguage: 'en',
-                supportedLanguages: ['en', 'ar', 'fr'],
-                storage: browserStorage  // Or memoryStorage for server
-            })
-
-            // Language preference is saved and restored automatically
-            await i18n.setLanguage('ar')
-            await i18n.init() // Restores 'ar' from storage
-            ```
-
-        - ### 8. Global Instance
+            import { setLanguage, onChange } from '@minejs/i18n';
 
-            ```typescript
-            import {
-                t, tLang, setLanguage, getLanguage,
-                isRTL, hasKey, onChange, loadLanguage,
-                loadTranslations
-            } from '@minejs/i18n'
-
-            // Use global instance with convenience functions
-            loadLanguage('en', {
-                greeting: 'Hello',
-                farewell: 'Goodbye'
-            })
-
-            console.log(t('greeting')) // "Hello"
-            console.log(hasKey('greeting')) // true
-            console.log(getLanguage()) // "en"
-
-            // Translate with specific language
-            loadLanguage('ar', { greeting: 'مرحبا' })
-            console.log(tLang('greeting', 'ar')) // "مرحبا"
-
-            // Listen for changes
+            // Listen to changes
             onChange((lang) => {
-                console.log('Switched to:', lang)
-            })
+                console.log('Language changed to:', lang);
+                document.documentElement.lang = lang;
+                document.dir = isRTL() ? 'rtl' : 'ltr';
+            });
 
-            await setLanguage('ar')
-            ```
-
-        - ### 9. Lazy Loading
-
-            ```typescript
-            import { setupLazy } from '@minejs/i18n'
-
-            // Only load default language at startup
-            const loader = await setupLazy({
-                defaultLanguage: 'en',
-                supportedLanguages: ['en', 'ar', 'fr', 'de', 'zh'],
-                basePath: 'https://cdn.example.com/i18n/'
-            })
-
-            // Later, when user switches language
-            await loader.load('ar')
-            await setLanguage('ar')
-
-            // Check if language is already loaded
-            if (!loader.isLoaded('fr')) {
-                await loader.load('fr')
-            }
+            // Change language
+            await setLanguage('ar');
             ```
 
-        - ### 10. Auto-Setup: Environment-Aware Loading
+        - #### Parameterized Translations
 
-            > Automatically detects browser vs server environment and loads translations from files or URLs
-
-            ```typescript
-            import { setupAuto } from '@minejs/i18n'
-
-            // Browser: Fetches from http://localhost:3000/static/i18n/en.json
-            // Server: Reads from ./static/i18n/en.json
-            const loader = await setupAuto({
-                defaultLanguage: 'en',
-                supportedLanguages: ['en', 'ar', 'fr', 'de'],
-                basePath: 'http://localhost:3000/static/i18n/',
-                // For server-side, use:
-                // basePath: './static/i18n/',
-                fileExtension: 'json' // Optional, defaults to 'json'
-            })
-
-            // Load other languages on-demand
-            await loader.load('ar')
-            await setLanguage('ar')
-
-            // File structure example:
-            // Browser: /public/static/i18n/en.json
-            // Server: ./static/i18n/en.json
-            ```
-
-            **Translation file format** (`en.json`):
             ```json
             {
-                "greeting": "Hello",
-                "welcome": "Welcome to our app",
-                "app": {
-                    "name": "MyApp",
-                    "title": "Welcome"
-                }
+                "greeting": "Hello {name}, you have {count} messages"
             }
             ```
 
-        - ### 11. Utility Functions
-
-            ```typescript
-            import { genPageTitle, plural } from '@minejs/i18n'
-
-            // Generate page title with app name
-            const title = genPageTitle('home', 'page.')
-            // LTR: "Home - MyApp"
-            // RTL: "MyApp - الرئيسية"
-
-            // Pluralization
-            const itemCount = plural(1, 'item.single', 'item.plural')
-            // 1 → "1 item"
-            // 5 → "5 items"
-            ```
-
-
-    <br>
-
-- ## API Reference 🔥
-
-    - ### I18nManager Class
-
-        - #### `constructor(config?: I18nConfig)`
-            > Create a new I18n manager instance.
-
-            ```typescript
-            const i18n = new I18nManager({
-                defaultLanguage: 'en',
-                fallbackLanguage: 'en',
-                supportedLanguages: ['en', 'ar', 'fr'],
-                storage: browserStorage,
-                onLanguageChange: (lang) => console.log('Changed to:', lang)
-            })
-            ```
-
-        - #### `init(): Promise<void>`
-            > Initialize manager and restore language from storage.
-
-            ```typescript
-            const i18n = new I18nManager({ storage: browserStorage })
-            await i18n.init() // Restores saved language
-            ```
-
-        - #### `loadLanguage(lang: LanguageCode, translations: object): void`
-            > Load translations for a specific language. Nested objects are flattened.
-
-            ```typescript
-            i18n.loadLanguage('en', {
-                app: { name: 'MyApp' },
-                greeting: 'Hello'
-            })
-
-            i18n.t('app.name')  // "MyApp"
-            i18n.t('greeting')  // "Hello"
-            ```
-
-        - #### `loadTranslations(translations: TranslationSet): void`
-            > Load multiple languages at once.
-
-            ```typescript
-            i18n.loadTranslations({
-                en: { greeting: 'Hello' },
-                ar: { greeting: 'مرحبا' },
-                fr: { greeting: 'Bonjour' }
-            })
-            ```
-
-        - #### `t(key: string, params?: object): string`
-            > Translate a key with optional parameter replacement.
-
             ```typescript
-            i18n.loadLanguage('en', {
-                greeting: 'Hello {name}'
-            })
-
-            i18n.t('greeting', { name: 'John' }) // "Hello John"
-            i18n.t('missing.key') // "missing.key" (returns key if not found)
+            t('greeting', { name: 'John', count: '5' })
+            // "Hello John, you have 5 messages"
             ```
 
-        - #### `tLang(key: string, lang: LanguageCode, params?: object): string`
-            > Translate a key with a specific language temporarily.
-
-            ```typescript
-            i18n.loadLanguage('ar', { greeting: 'مرحبا' })
+        - #### HTML Tag Parsing
 
-            const result = i18n.tLang('greeting', 'ar')
-            // Returns Arabic translation without changing current language
+            ```json
+            {
+                "terms": "I agree to the <link>Terms of Service</link>"
+            }
             ```
 
-        - #### `tParse(key: string, params?: object): TranslationToken[]`
-            > Parse translation with HTML tags into tokens. Converts \n and /n to <br> tags.
-
             ```typescript
-            i18n.loadLanguage('en', {
-                message: 'Hello <strong>World</strong>\\nLine 2'
-            })
-
-            const tokens = i18n.tParse('message')
+            const tokens = tParse('terms');
             // [
-            //   { type: 'text', content: 'Hello ' },
-            //   { type: 'tag', tag: 'strong', content: 'World' },
-            //   { type: 'tag', tag: 'br', content: '' },
-            //   { type: 'text', content: 'Line 2' }
+            //   { type: 'text', content: 'I agree to the ' },
+            //   { type: 'tag', tag: 'link', content: 'Terms of Service' }
             // ]
             ```
 
-        - #### `setLanguage(lang: LanguageCode): Promise<void>`
-            > Set current language and trigger change listeners.
-
-            ```typescript
-            await i18n.setLanguage('ar')
-            // Language is changed and persisted to storage if available
-            ```
-
-        - #### `getLanguage(): LanguageCode`
-            > Get current language code.
-
-            ```typescript
-            const lang = i18n.getLanguage() // "en"
-            ```
-
-        - #### `getSupportedLanguages(): LanguageCode[]`
-            > Get array of all supported languages.
-
-            ```typescript
-            const langs = i18n.getSupportedLanguages() // ['en', 'ar', 'fr']
-            ```
-
-        - #### `isLanguageSupported(lang: LanguageCode): boolean`
-            > Check if a language is supported.
-
-            ```typescript
-            i18n.isLanguageSupported('ar') // true
-            i18n.isLanguageSupported('unsupported') // false
-            ```
-
-        - #### `hasKey(key: string): boolean`
-            > Check if translation key exists in current or fallback language.
-
-            ```typescript
-            i18n.hasKey('greeting') // true
-            i18n.hasKey('missing') // false
-            ```
-
-        - #### `getTranslations(): Record<string, string>`
-            > Get all translations for current language.
-
-            ```typescript
-            const all = i18n.getTranslations()
-            ```
-
-        - #### `isRTL(): boolean`
-            > Check if current language is right-to-left.
-
-            ```typescript
-            await i18n.setLanguage('ar')
-            i18n.isRTL() // true
-
-            await i18n.setLanguage('en')
-            i18n.isRTL() // false
-            ```
-
-        - #### `isRTLLanguage(lang: LanguageCode): boolean`
-            > Check if specific language is right-to-left.
-
-            ```typescript
-            i18n.isRTLLanguage('ar') // true
-            i18n.isRTLLanguage('he') // true
-            i18n.isRTLLanguage('en') // false
-            ```
-
-        - #### `onChange(callback: (lang: LanguageCode) => void): () => void`
-            > Subscribe to language changes. Returns unsubscribe function.
+        - #### Page Titles (with RTL support)
 
             ```typescript
-            const unsubscribe = i18n.onChange((lang) => {
-                console.log('Language changed to:', lang)
-                updateUI(lang)
-            })
+            import { genPageTitle } from '@minejs/i18n';
 
-            // Unsubscribe later
-            unsubscribe()
+            // en: "Settings - MyApp"
+            // ar: "MyApp - الإعدادات"
+            const title = genPageTitle('settings');
             ```
 
     <br>
+    <br>
 
-    - ### LazyLoader Class
-
-        - #### `constructor(baseUrl: string, manager: I18nManager)`
-            > Create a lazy loader for on-demand language loading.
+- ## Documentation 📑
 
-            ```typescript
-            const manager = new I18nManager({
-                supportedLanguages: ['en', 'ar', 'fr']
-            })
-            const loader = new LazyLoader('https://cdn.com/i18n/', manager)
-            ```
+    - ### API
 
-        - #### `load(lang: LanguageCode): Promise<void>`
-            > Load a language file on-demand. Caches promises to prevent duplicate requests.
+        - #### Types
 
             ```typescript
-            await loader.load('ar')
-            // Expects https://cdn.com/i18n/ar.json
-
-            // Subsequent calls return cached promise
-            await loader.load('ar') // Returns immediately
+            type LanguageCode           = string;
             ```
 
-        - #### `isLoaded(lang: LanguageCode): boolean`
-            > Check if language is already loaded.
-
             ```typescript
-            if (!loader.isLoaded('ar')) {
-                await loader.load('ar')
+            interface I18nConfig {
+                defaultLanguage?        : LanguageCode;
+                supportedLanguages?     : LanguageCode[];
+                fallbackLanguage?       : LanguageCode;
+                onLanguageChange?       : (lang: LanguageCode) => void;
+                storage?                : I18nStorage;
+                basePath?               : string;
+                fileExtension?          : string;
             }
             ```
 
-    <br>
-
-    - ### Storage Adapters
-
-        - #### `browserStorage: I18nStorage`
-            > Store language preference in browser localStorage.
-
             ```typescript
-            import { browserStorage } from '@minejs/i18n'
-
-            const i18n = new I18nManager({
-                storage: browserStorage
-            })
+            interface TranslationToken {
+                type                    : 'text' | 'tag';
+                tag?                    : string;
+                content                 : string;
+            }
             ```
 
-        - #### `memoryStorage: I18nStorage`
-            > In-memory storage (useful for SSR and testing).
+            <div align="center"> <img src="./assets/img/line.png" alt="line" style="display: block; margin-top:20px;margin-bottom:20px;width:500px;"/> </div>
 
-            ```typescript
-            import { memoryStorage } from '@minejs/i18n'
+        - #### Functions
 
-            const i18n = new I18nManager({
-                storage: memoryStorage
-            })
-            ```
+            - #### `setupI18n(config)`
 
-        - #### `fetchTranslations(urls: string | string[], manager: I18nManager): Promise<void>`
-            > Fetch translations from remote URLs. Extracts language from filename (e.g., `en.json`).
+                > Initialize i18n with auto-detection
 
-            ```typescript
-            import { fetchTranslations } from '@minejs/i18n'
+                ```typescript
+                await setupI18n({
+                    defaultLanguage     : 'en',
+                    supportedLanguages  : ['en', 'ar', 'fr'],
+                    basePath            : '/i18n/',  // URL (browser) or path (server)
+                    fileExtension       : 'json' // optional
+                });
+                ```
 
-            const manager = new I18nManager()
+            - #### `t(key, params?)`
 
-            // Single URL
-            await fetchTranslations('https://cdn.com/i18n/en.json', manager)
+                > Translate with parameter replacement
 
-            // Multiple URLs
-            await fetchTranslations([
-                'https://cdn.com/i18n/en.json',
-                'https://cdn.com/i18n/ar.json'
-            ], manager)
-            ```
+                ```typescript
+                t('greeting', { name: 'John' }) // "Hello John"
+                ```
 
-    <br>
+            - #### `tLang(key, lang, params?)`
 
-    - ### Global Instance Functions
+                > Translate with specific language
 
-        - #### `getI18n(): I18nManager`
-            > Get or create global I18n instance.
+                ```typescript
+                tLang('greeting', 'ar', { name: 'أحمد' })
+                ```
 
-            ```typescript
-            const i18n = getI18n()
-            ```
+            - #### `tParse(key, params?)`
 
-        - #### `setupI18n(config: I18nConfig): Promise<I18nManager>`
-            > Initialize global instance with config.
+                > Parse translation with HTML tags
 
-            ```typescript
-            const i18n = await setupI18n({
-                defaultLanguage: 'en',
-                supportedLanguages: ['en', 'ar', 'fr']
-            })
-            ```
+                ```typescript
+                tParse('message') // Returns TokenArray
+                ```
 
-        - #### `createLazyLoader(baseUrl: string, fileExtension?: string): LazyLoader`
-            > Create lazy loader for global instance with support for custom file extensions.
+            - #### `setLanguage(lang)`
 
-            ```typescript
-            const loader = createLazyLoader('https://cdn.com/i18n/', 'json')
-            await loader.load('ar')
-            ```
+                > Change current language
 
-        - #### `setupLazy(config: I18nConfig & {basePath?: string; baseUrl?: string}): Promise<LazyLoader>`
-            > Setup with lazy loading and load default language only. Supports both file paths and URLs.
+                ```typescript
+                await setLanguage('ar')
+                ```
 
-            ```typescript
-            const loader = await setupLazy({
-                defaultLanguage: 'en',
-                supportedLanguages: ['en', 'ar', 'fr'],
-                basePath: '/i18n/'
-            })
-            ```
+            - #### `getLanguage()`
 
-        - #### `setupAuto(config: I18nConfig & {basePath: string}): Promise<LazyLoader>`
-            > Auto-setup with environment detection. Automatically uses fetch in browser and file system on server.
+                > Get current language code
 
-            ```typescript
-            // Works in both browser and Node.js
-            const loader = await setupAuto({
-                defaultLanguage: 'en',
-                supportedLanguages: ['en', 'ar', 'fr'],
-                basePath: 'http://localhost:3000/i18n/',
-                fileExtension: 'json'
-            })
-            ```
+                ```typescript
+                const lang = getLanguage() // 'en'
+                ```
 
-            ```typescript
-            const loader = await setupLazy({
-                defaultLanguage: 'en',
-                supportedLanguages: ['en', 'ar', 'fr'],
-                baseUrl: 'https://cdn.com/i18n/'
-            })
-            ```
+            - #### `getSupportedLanguages()`
 
-    <br>
+                > Get all supported languages
 
-    - ### Convenience Functions (Global Instance)
+                ```typescript
+                const langs = getSupportedLanguages() // ['en', 'ar', 'fr']
+                ```
 
-        - #### `t(key: string, params?: object): string`
-            > Translate using global instance.
+            - #### `isRTL()`
 
-        - #### `tLang(key: string, lang: LanguageCode, params?: object): string`
-            > Translate with specific language using global instance.
+                > Check if current language is RTL
 
-        - #### `tParse(key: string, params?: object): TranslationToken[]`
-            > Parse translation using global instance.
+                ```typescript
+                if (isRTL()) { /* Handle RTL layout */ }
+                ```
 
-        - #### `setLanguage(lang: LanguageCode): Promise<void>`
-            > Set language on global instance.
+            - #### `onChange(callback)`
 
-        - #### `getLanguage(): LanguageCode`
-            > Get current language from global instance.
+                > Subscribe to language changes
 
-        - #### `getSupportedLanguages(): LanguageCode[]`
-            > Get supported languages from global instance.
+                ```typescript
+                const unsubscribe = onChange((lang) => console.log('Changed to:', lang))
+                ```
 
-        - #### `hasKey(key: string): boolean`
-            > Check if key exists in global instance.
+            - #### `genPageTitle(key, prefix?)`
 
-        - #### `isRTL(): boolean`
-            > Check if current language is RTL on global instance.
+                > Generate page title with app name
 
-        - #### `isRTLLanguage(lang: LanguageCode): boolean`
-            > Check if specific language is RTL.
+                ```typescript
+                genPageTitle('home') // "Home - MyApp" or "MyApp - الرئيسية"
+                ```
 
-        - #### `onChange(callback: (lang: LanguageCode) => void): () => void`
-            > Subscribe to language changes on global instance.
+            - #### `plural(count, singleKey, pluralKey)`
 
-        - #### `loadLanguage(lang: LanguageCode, translations: object): void`
-            > Load translations using global instance.
+                > Handle pluralization
 
-        - #### `loadTranslations(translations: TranslationSet): void`
-            > Load multiple languages using global instance.
+                ```typescript
+                plural(5, 'item.single', 'item.plural') // "5 items"
+                ```
 
-    <br>
+            - #### `hasKey(key)`
 
-    - ### Utility Functions
+                > Check if translation exists
 
-        - #### `genPageTitle(key: string, prefix?: string): string`
-            > Generate page title with app name and proper RTL formatting.
+                ```typescript
+                if (hasKey('settings.theme')) { /* ... */ }
+                ```
 
-            ```typescript
-            // LTR: "Page Name - App Name"
-            // RTL: "App Name - Page Name"
+            - #### `loadLanguage(lang, translations)`
 
-            const title = genPageTitle('home', 'page.')
-            // Translates 'page.home' and 'app.name'
-            ```
+                > Load translations for a language
 
-        - #### `plural(count: number, singleKey: string, pluralKey: string): string`
-            > Select translation based on count and replace {count} parameter.
+                ```typescript
+                loadLanguage('en', { greeting: 'Hello' })
+                ```
 
-            ```typescript
-            loadLanguage('en', {
-                'item.single': '1 item',
-                'item.plural': '{count} items'
-            })
+            - #### `loadTranslations(translations)`
 
-            plural(1, 'item.single', 'item.plural') // "1 item"
-            plural(5, 'item.single', 'item.plural') // "5 items"
-            ```
+                > Load multiple languages at once
 
-    <br>
+                ```typescript
+                loadTranslations({
+                    en: { greeting: 'Hello' },
+                    ar: { greeting: 'مرحبا' }
+                })
+                ```
 
-- ## Types 📘
-
-    ```typescript
-    type LanguageCode = string
-
-    interface I18nConfig {
-        defaultLanguage?: LanguageCode
-        supportedLanguages?: LanguageCode[]
-        fallbackLanguage?: LanguageCode
-        onLanguageChange?: (lang: LanguageCode) => void
-        storage?: I18nStorage
-        basePath?: string
-        fileExtension?: string
-    }
-
-    interface I18nStorage {
-        get(key: string): string | null | Promise<string | null>
-        set(key: string, value: string): void | Promise<void>
-    }
-
-    interface TranslationToken {
-        type: 'text' | 'tag'
-        tag?: string
-        content: string
-    }
-
-    type TranslationSet = Record<string, Record<string, string>>
-    ```
+            <div align="center"> <img src="./assets/img/line.png" alt="line" style="display: block; margin-top:20px;margin-bottom:20px;width:500px;"/> </div>
 
-    <br>
+        - #### Related
+
+            - ##### [@cruxjs/app](https://github.com/cruxjs-org/app)
 
 <!-- ╚═════════════════════════════════════════════════════════════════╝ -->
 
@@ -725,6 +329,7 @@
 
 <!-- ╔══════════════════════════════ END ══════════════════════════════╗ -->
 
+<br>
 <br>
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@minejs/i18n",
-	"version": "0.0.4",
+	"version": "0.0.6",
 	"description": "A lightweight, production-ready internationalization (i18n) library with zero dependencies.",
 	"keywords": ["minejs", "i18n"],
 	"license": "MIT",
@@ -41,7 +41,7 @@
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.39.2",
-		"@stylistic/eslint-plugin": "^5.6.1",
+		"@stylistic/eslint-plugin": "^5.7.0",
 		"@types/bun": "^1.3.5",
 		"@types/node": "^20.19.27",
 		"bun-plugin-dts": "^0.3.0",
@@ -49,6 +49,6 @@
 		"ts-node": "^10.9.2",
 		"tsup": "^8.5.1",
 		"typescript": "^5.9.3",
-		"typescript-eslint": "^8.51.0"
+		"typescript-eslint": "^8.52.0"
 	}
 }