react-native-i18njs 0.0.1 → 0.0.3

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2024-present, wangws
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -1,97 +1,76 @@
 # react-native-i18njs
 
+[![npm version](https://img.shields.io/npm/v/react-native-i18njs.svg)](https://www.npmjs.com/package/react-native-i18njs)
+[![License](https://img.shields.io/npm/l/react-native-i18njs.svg)](https://www.npmjs.com/package/react-native-i18njs)
+[![Platform](https://img.shields.io/badge/platform-react--native-blue.svg)](https://reactnative.dev)
+[![TypeScript](https://img.shields.io/badge/types-included-blue.svg)](https://www.typescriptlang.org)
+
 一个轻量级、类型安全、零心智负担的 React Native 国际化解决方案。
 
-## 特性
+专为 React Native 设计，集成了最佳实践，解决了常见的国际化痛点：繁琐的配置、类型缺失、复杂的 API 以及系统语言跟随问题。
 
-- 🚀 **开箱即用**：专为 React Native 设计，API 简单直观。
-- 📦 **自动语言检测**：基于 `react-native-localize` 自动匹配设备语言。
-- 🔄 **自动重渲染**：语言切换时，UI 自动更新。
-- 🛡️ **TypeScript 支持**：完全使用 TypeScript 编写，提供完整的类型提示。
-- 🧩 **基于 `i18n-js`**：轻量封装，默认使用 `i18n-js` 作为翻译引擎。
-- 🔌 **Hooks 支持**：提供 `useI18n` Hook，方便在组件中使用。
-- 📝 **富文本支持**：支持在翻译中嵌入组件。
-- 🔢 **格式化支持**：基于 JS 内置 `Intl` 的数字/货币/日期格式化（可传 options 自定义；环境不支持会自动降级）。
+## ✨ 特性
 
-## 安装
+- � **零配置启动**：内置智能默认值，安装即用。
+- 🛡️ **极致类型安全**：完全 TypeScript 编写，提供从 Key 到插值参数的完整类型推导。
+- 📱 **自动跟随系统**：基于 `react-native-localize`，自动检测并响应设备语言变更。
+- ⚡ **高性能**：基于 `i18n-js` 核心，轻量高效，无多余运行时开销。
+- 🔌 **灵活 API**：同时支持 Hook (`useI18n`)、高阶组件 (`withI18n`) 和全局函数 (`t`)。
+- 📝 **富文本支持**：`Trans` 组件轻松处理嵌套样式和组件插值。
+- 🌍 **格式化内置**：开箱即用的数字、货币、日期格式化支持。
 
-首先安装本库及其依赖：
+## 📦 安装
 
 ```bash
-npm install react-native-i18njs i18n-js react-native-localize
+npm install react-native-i18njs
 # 或者
-yarn add react-native-i18njs i18n-js react-native-localize
+yarn add react-native-i18njs
 ```
 
-> 插值语法说明：本库基于 `i18n-js`，默认使用 `%{name}`（不是 `{{name}}`）。
-
-## 上手方式（两种都支持）
+> **注意**：本库已内置 `i18n-js` 和 `react-native-localize` 的稳定版本，无需手动安装 peer dependencies。
 
-- **方式 A：不使用 `I18nProvider`（推荐）**：任何地方都能直接 `t()`，没有 React 心智负担；适合工具层/启动阶段/非 UI 代码。
-- **方式 B：使用 `I18nProvider`（可选）**：需要“切换语言后 UI 自动刷新”时再用。
+## 🚀 快速开始
 
-## 模块 1：初始化与全局函数（不需要 Provider）
+### 1. 定义翻译资源
 
-### 1) 准备翻译资源
+建议在单独的文件中管理翻译资源，例如 `src/locales/index.ts`：
 
 ```ts
+// src/locales/index.ts
 export const translations = {
-  en: { welcome: 'Welcome', hello: 'Hello, %{name}!' },
-  zh: { welcome: '欢迎', hello: '你好，%{name}！' },
+  en: {
+    welcome: 'Welcome',
+    hello: 'Hello, %{name}!',
+  },
+  zh: {
+    welcome: '欢迎',
+    hello: '你好，%{name}！',
+  },
 };
-```
-
-### 2) 初始化（只做一次）
-
-```ts
-import { initI18n } from 'react-native-i18njs';
-import { translations } from './locales';
-
-initI18n(translations, { defaultLocale: 'en', enableFallback: true });
-```
 
-### 3) 在任何地方直接使用 `t()`
-
-```ts
-import { t, setLocale, getLocale } from 'react-native-i18njs';
-
-setLocale('zh');
-getLocale(); // 'zh'
-t('hello', { name: 'Trae' }); // '你好，Trae！'
-t('missing.key', { defaultValue: '默认文案' });
+// 导出类型以获得类型提示
+export type Translations = typeof translations.en;
 ```
 
-### 不用 Provider 的典型场景
+### 2. 初始化
 
-- 网络层（如 axios 拦截器）拼接错误文案
-- 表单校验/工具函数/Toast 文案
-- Redux/Saga/Store 初始化阶段
-- React 组件之外（比如 navigation 配置、原生桥接回调）
-
-> 注意：不用 Provider 时，切换语言不会自动触发页面重渲染；如果你需要 UI 自动刷新，请看“模块 2”。
-
-## 模块 2：React 自动重渲染（I18nProvider + useI18n）
+在你的 App 入口文件（如 `App.tsx`）中初始化：
 
 ```tsx
 import React from 'react';
-import { Text, Button } from 'react-native';
-import { I18nProvider, useI18n } from 'react-native-i18njs';
+import { initI18n, I18nProvider } from 'react-native-i18njs';
+import { translations } from './src/locales';
+import Home from './src/Home';
 
-function Home() {
-  const { t, locale, setLocale } = useI18n();
-  return (
-    <>
-      <Text>{t('welcome')}</Text>
-      <Text>{t('hello', { name: 'User' })}</Text>
-      <Text>{locale}</Text>
-      <Button title="EN" onPress={() => setLocale('en')} />
-      <Button title="中文" onPress={() => setLocale('zh')} />
-    </>
-  );
-}
+// 初始化配置
+initI18n(translations, {
+  defaultLocale: 'en',
+  enableFallback: true, // 找不到翻译时回退到默认语言
+});
 
 export default function App() {
   return (
+    // 使用 Provider 以支持语言切换时的自动重渲染
     <I18nProvider>
       <Home />
     </I18nProvider>
@@ -99,149 +78,188 @@ export default function App() {
 }
 ```
 
-### `I18nProvider` 参数
+### 3. 在组件中使用
+
+```tsx
+// src/Home.tsx
+import React from 'react';
+import { Text, Button, View } from 'react-native';
+import { useI18n } from 'react-native-i18njs';
+import { Translations } from './locales';
+
+export default function Home() {
+  // 传入泛型 Translations 以获得 key 的自动补全和类型检查
+  const { t, locale, setLocale } = useI18n<Translations>();
+
+  return (
+    <View>
+      <Text>{t('welcome')}</Text>
+      {/* 这里的 name 参数会有类型提示 */}
+      <Text>{t('hello', { name: 'Trae' })}</Text>
+      
+      <Text>当前语言: {locale}</Text>
+      
+      <Button title="Switch to English" onPress={() => setLocale('en')} />
+      <Button title="切换到中文" onPress={() => setLocale('zh')} />
+    </View>
+  );
+}
+```
+
+## 📖 核心功能详解
+
+### 1. 非组件环境使用（Global API）
 
-- `readyGate?: boolean`：为 `true` 时，未 ready 前不渲染 children
-- `fallback?: React.ReactNode`：`readyGate` 期间显示的占位
+在 Redux、Axios 拦截器、工具函数等非组件环境中，你可以直接使用全局导出的 API。
 
-### `useI18n<T>()`（类型安全 key）
+#### 基础用法
 
 ```ts
-type MyTranslations = typeof translations.en;
-const { t } = useI18n<MyTranslations>();
-t('welcome');
-t('home.title');
+import { t, getLocale, setLocale } from 'react-native-i18njs';
+
+// 获取当前语言
+const current = getLocale();
+
+// 切换语言
+setLocale('zh');
+
+// 直接翻译
+const message = t('errors.network_timeout');
 ```
 
-## 模块 3：动态加载翻译（loadTranslations）
+#### 进阶：监听语言变化
+
+如果你需要在组件外监听语言变更（例如同步更新全局状态），可以使用顶层 `subscribe` 函数：
 
 ```ts
-import { loadTranslations } from 'react-native-i18njs';
+import { subscribe } from 'react-native-i18njs';
 
-loadTranslations({ fr: { welcome: 'Bonjour' } });
+// 订阅语言变更
+const unsubscribe = subscribe((locale) => {
+  console.log('Language changed to:', locale);
+  // 更新 API 默认 Header 或其他全局状态
+});
+
+// 取消订阅
+// unsubscribe();
 ```
 
-## 模块 4：富文本（Trans）
+#### 进阶：重置为跟随系统
 
-```tsx
-import React from 'react';
-import { Text } from 'react-native';
-import { Trans } from 'react-native-i18njs';
+用户手动调用 `setLocale` 后会锁定语言，不再自动跟随系统。如果需要恢复跟随系统语言：
 
-// translations.en:
-// { description: 'This is <bold>bold</bold> text.', agree: 'I agree to %{terms}' }
+```ts
+import { resetToSystem } from 'react-native-i18njs';
 
-<Trans i18nKey="description" components={{ bold: <Text style={{ fontWeight: 'bold' }} /> }} />
-<Trans i18nKey="agree" values={{ terms: <Text style={{ fontWeight: 'bold' }}>Terms</Text> }} />
+// 撤销用户锁定，重新跟随系统语言
+resetToSystem();
 ```
 
-### `Trans` 参数
+#### 进阶：RTL 检测
 
-- `i18nKey: string`
-- `values?: Record<string, any>`：插值值（字符串/数字/ReactElement 都支持）
-- `components?: Record<string, React.ReactNode>`：标签映射（如 `bold/link`）
+```ts
+import { isRTL } from 'react-native-i18njs';
 
-### `Trans` 能覆盖的场景
+if (isRTL()) {
+  // 当前为从右到左语言（如阿拉伯语、希伯来语）
+}
+```
 
-- 句子内局部加粗/斜体/变色/可点击链接（用 `components` 映射 `<bold></bold>` / `<link></link>`）
-- 插值里插入组件（用 `values` 传 ReactElement，例如把 “Terms” 做成可点击文本）
-- 嵌套标签（例如 `<bold>...<italic>...</italic>...</bold>`）
-- 自闭合标签（例如 `<br/>`），可映射成 `components={{ br: <Text>{'\n'}</Text> }}`
+#### 实战示例：Axios 拦截器
 
-### `Trans` 的边界（不适合的场景）
+```ts
+import axios from 'axios';
+import { getLocale } from 'react-native-i18njs';
+
+axios.interceptors.request.use((config) => {
+  // 动态获取当前语言，确保每次请求都携带最新的语言标识
+  config.headers['Accept-Language'] = getLocale();
+  return config;
+});
+```
 
-- 不支持标签属性/HTML（例如 `<a href="...">` / `<span style="...">`），需要你把“样式/点击行为”放到 `components` 或 `values` 传入的组件里
-- `components` 目前接收的是“元素”（例如 `<Text />`），不是组件函数（例如 `Text` / `Bold`），因为内部是 `cloneElement`
-- `Trans` 总是返回一个外层 `<Text>`；并且被插入的组件也必须是 `Text` 可渲染的内容（不要把 `<View>` 直接塞进文本里）
-- 不提供 ICU MessageFormat（select/plural/gender）语法；更复杂的语言结构建议拆 key + 用 JS 逻辑组合，或引入 ICU 方案
-- 翻译里如果出现不成对/不匹配的标签，会按纯文本保留（避免静默吞字），建议在翻译侧保持标签成对
+### 2. 富文本翻译 (`Trans` 组件)
 
-## 模块 5：Class 组件（withI18n）
+当翻译内容中包含样式或组件时，使用 `Trans` 组件：
 
 ```tsx
-import React from 'react';
+import { Trans } from 'react-native-i18njs';
 import { Text } from 'react-native';
-import { withI18n } from 'react-native-i18njs';
 
-class Screen extends React.PureComponent<{ t: any }> {
-  render() {
-    return <Text>{this.props.t('welcome')}</Text>;
-  }
-}
+// 翻译资源:
+// zh: { agreement: '我同意 <link>服务条款</link>' }
 
-export default withI18n(Screen);
+<Trans
+  i18nKey="agreement"
+  components={{
+    link: <Text style={{ color: 'blue' }} onPress={openTerms} />,
+  }}
+/>
 ```
 
-## 模块 6：初始化就绪（readyI18n / isI18nReady）
+### 3. 动态加载翻译
+
+适用于大型应用的分包加载场景：
 
 ```ts
-import { readyI18n, isI18nReady } from 'react-native-i18njs';
+import { loadTranslations } from 'react-native-i18njs';
 
-await readyI18n();
-isI18nReady();
+// 异步加载法语包
+async function loadFrench() {
+  const fr = await import('./locales/fr');
+  loadTranslations({ fr: fr.default });
+}
 ```
 
-## 模块 7：数字/货币/日期格式化（formatNumber / formatCurrency / formatDate）
+### 4. 格式化工具
 
-`Intl` 是 JavaScript 自带的一套“国际化格式化”能力（浏览器和 Node 都有，React Native 取决于引擎/是否带完整 Intl）。
-
-这三个方法基于 `Intl`，默认使用“当前 locale”来格式化，并且都支持传入 `options` 自定义格式。
+利用 `Intl` 标准进行格式化，在组件中通过 Hook 使用：
 
 ```ts
-import { useI18n } from 'react-native-i18njs';
-
 const { formatNumber, formatCurrency, formatDate } = useI18n();
 
-formatNumber(1234567.891, { maximumFractionDigits: 2 });
-formatCurrency(99.9, 'CNY', { currencyDisplay: 'narrowSymbol' });
-formatDate(Date.now(), { dateStyle: 'medium', timeStyle: 'short' });
-```
+// 数字
+formatNumber(1234.56); // "1,234.56"
 
-通用性边界：
+// 货币
+formatCurrency(99.99, 'USD'); // "$99.99"
 
-- 若运行环境没有完整 `Intl`（部分 RN/Hermes 场景），库会自动降级：
-  - number：`String(n)`
-  - currency：``${n} ${currency}``
-  - date：`toISOString()`
-- 如果你希望所有平台表现完全一致，请在你的 App 侧引入 `Intl` polyfill。
-- 如果你想用“非当前 locale”做格式化，请直接使用 `new Intl.NumberFormat('xx', options)` 自行处理。
+// 日期
+formatDate(new Date(), { dateStyle: 'full' }); // "Tuesday, October 10, 2023"
+```
 
-## 配置参数（I18nOptions）
+在非组件环境中，也可以直接使用顶层导出：
 
-### `initI18n(translations, options?)`
+```ts
+import { formatNumber, formatCurrency, formatDate } from 'react-native-i18njs';
 
-- `translations: Record<string, any>`：翻译资源（locale 为 key）
-- `options?`：
-  - `defaultLocale?: string`：默认 `'en'`
-  - `enableFallback?: boolean`：默认 `true`
-  - `followSystem?: boolean`：默认 `true`；用户手动 `setLocale` 后不再跟随系统
-  - `fallbackLocales?: string[] | ((locale: string) => string[])`：自定义回退链（按顺序）
-  - `missingBehavior?: 'key' | 'empty' | 'throw'`：默认 `'key'`
-  - `onMissingKey?: (key: string, locale: string) => void`：缺失 key 回调
-  - `onLocaleChange?: (locale: string) => void`：语言变更回调
+formatNumber(1234.56);
+formatCurrency(99.99, 'USD');
+formatDate(new Date());
+```
 
-## API 速查（按模块）
+## ⚙️ 配置选项 (I18nOptions)
 
-- **初始化/函数**
-  - `initI18n`, `t`, `setLocale`, `getLocale`, `loadTranslations`, `readyI18n`, `isI18nReady`
-- **React 绑定（可选）**
-  - `I18nProvider`, `useI18n`, `I18nContext`, `withI18n`
-- **组件**
-  - `Trans`
-- **类型**
-  - `I18nOptions`, `Translations`, `Path`
-- **默认导出**
-  - `i18nService`：服务单例（`formatNumber/formatCurrency/formatDate/subscribe/updateLocale` 等）
+`initI18n` 接受的第二个参数对象：
 
-## 常见问题
+| 属性 | 类型 | 默认值 | 说明 |
+|------|------|--------|------|
+| `defaultLocale` | `string` | `'en'` | 默认语言 |
+| `enableFallback` | `boolean` | `true` | 是否启用回退机制 |
+| `followSystem` | `boolean` | `true` | 是否初始化时自动跟随系统语言 |
+| `fallbackLocales` | `string[]` \| `func` | - | 自定义回退链 |
+| `missingBehavior` | `'key'` \| `'empty'` \| `'throw'` | `'key'` | 缺失翻译时的行为 |
+| `onMissingKey` | `function` | - | 缺失 key 的回调 |
+| `onLocaleChange` | `function` | - | 语言变更回调 |
 
-### 1) `Invalid hook call` / 多个 React 实例
+## 🧩 常见问题
 
-如果你在 monorepo / workspace 中把本库以源码方式链接到示例或业务 App，可能出现重复 React 导致的 Hook 报错。参考本仓库示例的 Metro 配置做依赖指向与屏蔽：
+### TypeScript 类型提示不工作？
+确保你在使用 `useI18n<MyTranslations>()` 时传入了你的翻译类型定义。
 
-- 示例配置：[example/metro.config.js](./example/metro.config.js)
+### 安卓上语言检测不准确？
+请确保你的 `android/app/src/main/res` 目录下有对应的语言资源文件夹（如 `values-zh`），React Native 有时依赖这些原生配置来正确识别系统语言。
 
-## 平台支持
+## 📄 License
 
-- **iOS / Android**: 完全支持。
-- **Web**: 需要配置 `webpack` 以支持 `react-native-localize`。请参考 [react-native-localize 文档](https://github.com/zoontek/react-native-localize)。
+ISC

package/dist/index.d.mts

@@ -35,6 +35,8 @@ interface I18nEngine {
     formatDate(date: Date | number, options?: Intl.DateTimeFormatOptions): string;
     subscribe(listener: Listener): () => void;
     isRTL(): boolean;
+    /** 重置为跟随系统语言，撤销 setLocale 的用户锁定 */
+    resetToSystem(): void;
     ready(): Promise<void>;
     isReady(): boolean;
 }
@@ -55,12 +57,18 @@ declare class DefaultI18nEngine implements I18nEngine {
     private version;
     private readyPromise;
     private resolveReady?;
+    /** Intl 格式化器缓存，key = locale + JSON(options) */
+    private numberFormatCache;
+    private dateFormatCache;
+    /** locale chain 缓存，locale 或 fallbackLocales 变化时失效 */
+    private localeChainCache;
     constructor();
     init(translations: Translations, options?: I18nOptions): void;
     loadTranslations(translations: Translations): void;
     updateLocale(): void;
     setLocale(locale: string): void;
     getLocale(): string;
+    resetToSystem(): void;
     t(scope: Scope, options?: TranslateOptions): string;
     formatNumber(n: number, options?: Intl.NumberFormatOptions): string;
     formatCurrency(n: number, currency: string, options?: Intl.NumberFormatOptions): string;
@@ -69,11 +77,16 @@ declare class DefaultI18nEngine implements I18nEngine {
     isRTL(): boolean;
     ready(): Promise<void>;
     isReady(): boolean;
+    private invalidateCaches;
+    private getCachedNumberFormat;
+    private getCachedDateFormat;
     private handleRTL;
     private notifyListeners;
     private setLocaleFromSystem;
     private applyLocale;
     private translateAtLocale;
+    /** 将 locale 及其自动降级（如 en-US → en）追加到 chain 中 */
+    private pushWithDegradation;
     private getLocaleChain;
     private hasTranslation;
     private normalizeTranslateResult;
@@ -126,7 +139,14 @@ declare const loadTranslations: (translations: Translations) => void;
 declare const setLocale: (locale: string) => void;
 declare const getLocale: () => string;
 declare const t: (scope: Scope, options?: TranslateOptions) => string;
+declare const formatNumber: (n: number, options?: Intl.NumberFormatOptions) => string;
+declare const formatCurrency: (n: number, currency: string, options?: Intl.NumberFormatOptions) => string;
+declare const formatDate: (date: Date | number, options?: Intl.DateTimeFormatOptions) => string;
+declare const subscribe: (listener: Listener) => (() => void);
+declare const isRTL: () => boolean;
+/** 重置为跟随系统语言，撤销 setLocale 的用户锁定 */
+declare const resetToSystem: () => void;
 declare const readyI18n: () => Promise<void>;
 declare const isI18nReady: () => boolean;
 
-export { I18nContext, type I18nContextType, type I18nOptions, I18nProvider, type I18nProviderProps, type Path, Trans, type Translations, i18nService as default, getLocale, initI18n, isI18nReady, loadTranslations, readyI18n, setLocale, t, useI18n, withI18n };
+export { I18nContext, type I18nContextType, type I18nOptions, I18nProvider, type I18nProviderProps, type Listener, type Path, Trans, type Translations, i18nService as default, formatCurrency, formatDate, formatNumber, getLocale, initI18n, isI18nReady, isRTL, loadTranslations, readyI18n, resetToSystem, setLocale, subscribe, t, useI18n, withI18n };

package/dist/index.d.ts

@@ -35,6 +35,8 @@ interface I18nEngine {
     formatDate(date: Date | number, options?: Intl.DateTimeFormatOptions): string;
     subscribe(listener: Listener): () => void;
     isRTL(): boolean;
+    /** 重置为跟随系统语言，撤销 setLocale 的用户锁定 */
+    resetToSystem(): void;
     ready(): Promise<void>;
     isReady(): boolean;
 }
@@ -55,12 +57,18 @@ declare class DefaultI18nEngine implements I18nEngine {
     private version;
     private readyPromise;
     private resolveReady?;
+    /** Intl 格式化器缓存，key = locale + JSON(options) */
+    private numberFormatCache;
+    private dateFormatCache;
+    /** locale chain 缓存，locale 或 fallbackLocales 变化时失效 */
+    private localeChainCache;
     constructor();
     init(translations: Translations, options?: I18nOptions): void;
     loadTranslations(translations: Translations): void;
     updateLocale(): void;
     setLocale(locale: string): void;
     getLocale(): string;
+    resetToSystem(): void;
     t(scope: Scope, options?: TranslateOptions): string;
     formatNumber(n: number, options?: Intl.NumberFormatOptions): string;
     formatCurrency(n: number, currency: string, options?: Intl.NumberFormatOptions): string;
@@ -69,11 +77,16 @@ declare class DefaultI18nEngine implements I18nEngine {
     isRTL(): boolean;
     ready(): Promise<void>;
     isReady(): boolean;
+    private invalidateCaches;
+    private getCachedNumberFormat;
+    private getCachedDateFormat;
     private handleRTL;
     private notifyListeners;
     private setLocaleFromSystem;
     private applyLocale;
     private translateAtLocale;
+    /** 将 locale 及其自动降级（如 en-US → en）追加到 chain 中 */
+    private pushWithDegradation;
     private getLocaleChain;
     private hasTranslation;
     private normalizeTranslateResult;
@@ -126,7 +139,14 @@ declare const loadTranslations: (translations: Translations) => void;
 declare const setLocale: (locale: string) => void;
 declare const getLocale: () => string;
 declare const t: (scope: Scope, options?: TranslateOptions) => string;
+declare const formatNumber: (n: number, options?: Intl.NumberFormatOptions) => string;
+declare const formatCurrency: (n: number, currency: string, options?: Intl.NumberFormatOptions) => string;
+declare const formatDate: (date: Date | number, options?: Intl.DateTimeFormatOptions) => string;
+declare const subscribe: (listener: Listener) => (() => void);
+declare const isRTL: () => boolean;
+/** 重置为跟随系统语言，撤销 setLocale 的用户锁定 */
+declare const resetToSystem: () => void;
 declare const readyI18n: () => Promise<void>;
 declare const isI18nReady: () => boolean;
 
-export { I18nContext, type I18nContextType, type I18nOptions, I18nProvider, type I18nProviderProps, type Path, Trans, type Translations, i18nService as default, getLocale, initI18n, isI18nReady, loadTranslations, readyI18n, setLocale, t, useI18n, withI18n };
+export { I18nContext, type I18nContextType, type I18nOptions, I18nProvider, type I18nProviderProps, type Listener, type Path, Trans, type Translations, i18nService as default, formatCurrency, formatDate, formatNumber, getLocale, initI18n, isI18nReady, isRTL, loadTranslations, readyI18n, resetToSystem, setLocale, subscribe, t, useI18n, withI18n };

package/dist/index.js

@@ -73,6 +73,12 @@ var DefaultI18nEngine = class {
     __publicField(this, "version");
     __publicField(this, "readyPromise");
     __publicField(this, "resolveReady");
+    // --- 性能缓存 ---
+    /** Intl 格式化器缓存，key = locale + JSON(options) */
+    __publicField(this, "numberFormatCache", /* @__PURE__ */ new Map());
+    __publicField(this, "dateFormatCache", /* @__PURE__ */ new Map());
+    /** locale chain 缓存，locale 或 fallbackLocales 变化时失效 */
+    __publicField(this, "localeChainCache", /* @__PURE__ */ new Map());
     this.i18n = new i18nJs.I18n();
     this.listeners = /* @__PURE__ */ new Set();
     this.i18n.enableFallback = false;
@@ -107,6 +113,7 @@ var DefaultI18nEngine = class {
     this.localeSource = "system";
     this.missingBehavior = missingBehavior;
     this.onMissingKey = onMissingKey;
+    this.invalidateCaches();
     if (this.followSystem) this.updateLocale();
     this.version += 1;
     this.notifyListeners({ type: "translations", version: this.version });
@@ -142,6 +149,10 @@ var DefaultI18nEngine = class {
   getLocale() {
     return this.i18n.locale;
   }
+  resetToSystem() {
+    this.localeSource = "system";
+    this.updateLocale();
+  }
   t(scope, options) {
     var _a, _b, _c;
     if (typeof scope !== "string") {
@@ -175,7 +186,7 @@ var DefaultI18nEngine = class {
       return String(n);
     }
     try {
-      return new Intl.NumberFormat(this.i18n.locale, options).format(n);
+      return this.getCachedNumberFormat(this.i18n.locale, options).format(n);
     } catch {
       return String(n);
     }
@@ -185,7 +196,7 @@ var DefaultI18nEngine = class {
       return `${n} ${currency}`;
     }
     try {
-      return new Intl.NumberFormat(this.i18n.locale, {
+      return this.getCachedNumberFormat(this.i18n.locale, {
         ...options,
         style: "currency",
         currency
@@ -201,7 +212,7 @@ var DefaultI18nEngine = class {
       return d.toISOString();
     }
     try {
-      return new Intl.DateTimeFormat(this.i18n.locale, options).format(d);
+      return this.getCachedDateFormat(this.i18n.locale, options).format(d);
     } catch {
       return d.toISOString();
     }
@@ -222,15 +233,40 @@ var DefaultI18nEngine = class {
   isReady() {
     return this.initialized;
   }
+  // ─── 缓存管理 ────────────────────────────────────────────
+  invalidateCaches() {
+    this.numberFormatCache.clear();
+    this.dateFormatCache.clear();
+    this.localeChainCache.clear();
+  }
+  getCachedNumberFormat(locale, options) {
+    const cacheKey = locale + (options ? JSON.stringify(options) : "");
+    let fmt = this.numberFormatCache.get(cacheKey);
+    if (!fmt) {
+      fmt = new Intl.NumberFormat(locale, options);
+      this.numberFormatCache.set(cacheKey, fmt);
+    }
+    return fmt;
+  }
+  getCachedDateFormat(locale, options) {
+    const cacheKey = locale + (options ? JSON.stringify(options) : "");
+    let fmt = this.dateFormatCache.get(cacheKey);
+    if (!fmt) {
+      fmt = new Intl.DateTimeFormat(locale, options);
+      this.dateFormatCache.set(cacheKey, fmt);
+    }
+    return fmt;
+  }
+  // ─── 私有方法 ────────────────────────────────────────────
   handleRTL(locale) {
     var _a, _b;
-    const isRTL = this.isRTLLocale(locale);
+    const isRTL2 = this.isRTLLocale(locale);
     if (typeof ((_a = reactNative.I18nManager) == null ? void 0 : _a.allowRTL) !== "function" || typeof ((_b = reactNative.I18nManager) == null ? void 0 : _b.forceRTL) !== "function") {
       return;
     }
-    if (reactNative.I18nManager.isRTL !== isRTL) {
-      reactNative.I18nManager.allowRTL(isRTL);
-      reactNative.I18nManager.forceRTL(isRTL);
+    if (reactNative.I18nManager.isRTL !== isRTL2) {
+      reactNative.I18nManager.allowRTL(isRTL2);
+      reactNative.I18nManager.forceRTL(isRTL2);
     }
   }
   notifyListeners(change) {
@@ -245,6 +281,7 @@ var DefaultI18nEngine = class {
     const normalizedLocale = this.normalizeLocaleTag(locale);
     if (this.i18n.locale !== normalizedLocale) {
       this.i18n.locale = normalizedLocale;
+      this.invalidateCaches();
       this.handleRTL(normalizedLocale);
       this.version += 1;
       this.notifyListeners({ type: "locale", version: this.version });
@@ -260,39 +297,36 @@ var DefaultI18nEngine = class {
       this.i18n.locale = prevLocale;
     }
   }
-  getLocaleChain(locale) {
-    const chain = [];
-    const normalizedLocale = this.normalizeLocaleTag(locale);
-    chain.push(normalizedLocale);
-    const parts = normalizedLocale.split("-").filter(Boolean);
+  /** 将 locale 及其自动降级（如 en-US → en）追加到 chain 中 */
+  pushWithDegradation(chain, locale) {
+    const normalized = this.normalizeLocaleTag(locale);
+    chain.push(normalized);
+    const parts = normalized.split("-").filter(Boolean);
     for (let i = parts.length - 1; i >= 1; i -= 1) {
       chain.push(parts.slice(0, i).join("-"));
     }
+  }
+  getLocaleChain(locale) {
+    const cached = this.localeChainCache.get(locale);
+    if (cached) return cached;
+    const chain = [];
+    this.pushWithDegradation(chain, locale);
+    const normalizedLocale = this.normalizeLocaleTag(locale);
     const extra = this.fallbackLocales ? typeof this.fallbackLocales === "function" ? this.fallbackLocales(normalizedLocale) : this.fallbackLocales : [];
     for (const l of extra) {
-      const normalizedFallback = this.normalizeLocaleTag(l);
-      chain.push(normalizedFallback);
-      const fallbackParts = normalizedFallback.split("-").filter(Boolean);
-      for (let i = fallbackParts.length - 1; i >= 1; i -= 1) {
-        chain.push(fallbackParts.slice(0, i).join("-"));
-      }
+      this.pushWithDegradation(chain, l);
     }
     if (this.i18n.defaultLocale) {
-      const normalizedDefault = this.normalizeLocaleTag(this.i18n.defaultLocale);
-      chain.push(normalizedDefault);
-      const defaultParts = normalizedDefault.split("-").filter(Boolean);
-      for (let i = defaultParts.length - 1; i >= 1; i -= 1) {
-        chain.push(defaultParts.slice(0, i).join("-"));
-      }
+      this.pushWithDegradation(chain, this.i18n.defaultLocale);
     }
     const seen = /* @__PURE__ */ new Set();
-    return chain.filter((l) => {
-      if (!l) return false;
-      const normalized = l;
-      if (seen.has(normalized)) return false;
-      seen.add(normalized);
+    const result = chain.filter((l) => {
+      if (!l || seen.has(l)) return false;
+      seen.add(l);
       return true;
     });
+    this.localeChainCache.set(locale, result);
+    return result;
   }
   hasTranslation(locale, key) {
     var _a;
@@ -327,7 +361,7 @@ var DefaultI18nEngine = class {
   }
   isRTLLocale(locale) {
     var _a;
-    const normalized = locale.replace(/_/g, "-");
+    const normalized = this.normalizeLocaleTag(locale);
     const parts = normalized.split("-").filter(Boolean);
     const languageCode = (_a = parts[0]) == null ? void 0 : _a.toLowerCase();
     if (!languageCode) return false;
@@ -427,13 +461,13 @@ function useI18n() {
   }, [context]);
 }
 var escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var TAG_REGEX = /<(\/?)([A-Za-z][\w-]*)(?:\s[^>]*?)?(\/?)>/g;
 var parseString = (input) => {
   var _a;
   const root = { type: "tag", name: "root", children: [] };
   const stack = [root];
-  const tagRegex = /<(\/?)([A-Za-z][\w-]*)(?:\s[^>]*?)?(\/?)>/g;
   let lastIndex = 0;
-  for (const match of input.matchAll(tagRegex)) {
+  for (const match of input.matchAll(TAG_REGEX)) {
     const fullMatch = match[0];
     const isClosing = match[1] === "/";
     const tagName = match[2];
@@ -463,51 +497,57 @@ var parseString = (input) => {
   }
   return root.children;
 };
+var renderAST = (nodes, keyPrefix, components, placeholderToElement) => {
+  return nodes.map((node, index) => {
+    const key = `${keyPrefix}-${index}`;
+    if (node.type === "text") {
+      const placeholders = Object.keys(placeholderToElement);
+      if (placeholders.length === 0) return node.content;
+      const pattern = new RegExp(`(${placeholders.map(escapeRegExp).join("|")})`, "g");
+      const parts = node.content.split(pattern);
+      if (parts.length === 1) return node.content;
+      return /* @__PURE__ */ React__default.default.createElement(React.Fragment, { key }, parts.map((part, i) => {
+        if (placeholderToElement[part]) {
+          return React.cloneElement(placeholderToElement[part], { key: `${key}-${i}` });
+        }
+        return part;
+      }));
+    } else if (node.type === "tag") {
+      const Component = components == null ? void 0 : components[node.name];
+      const children = renderAST(node.children, key, components, placeholderToElement);
+      if (React.isValidElement(Component)) {
+        return React.cloneElement(Component, { key }, children.length > 0 ? children : void 0);
+      }
+      return /* @__PURE__ */ React__default.default.createElement(React.Fragment, { key }, children);
+    }
+    return null;
+  });
+};
 var Trans = ({ i18nKey, values, components, ...props }) => {
   const { t: t2 } = useI18n();
-  const stringValues = {};
-  const placeholderToElement = {};
-  if (values) {
-    Object.keys(values).forEach((key) => {
-      const value = values[key];
-      if (React.isValidElement(value)) {
-        const placeholder = `__ELEMENT_${key}__`;
-        placeholderToElement[placeholder] = value;
-        stringValues[key] = placeholder;
-      } else {
-        stringValues[key] = value == null ? "" : String(value);
-      }
-    });
-  }
-  const translatedText = t2(i18nKey, stringValues);
-  const ast = parseString(translatedText);
-  const renderAST = (nodes, keyPrefix) => {
-    return nodes.map((node, index) => {
-      const key = `${keyPrefix}-${index}`;
-      if (node.type === "text") {
-        const placeholders = Object.keys(placeholderToElement);
-        if (placeholders.length === 0) return node.content;
-        const pattern = new RegExp(`(${placeholders.map(escapeRegExp).join("|")})`, "g");
-        const parts = node.content.split(pattern);
-        if (parts.length === 1) return node.content;
-        return /* @__PURE__ */ React__default.default.createElement(React.Fragment, { key }, parts.map((part, i) => {
-          if (placeholderToElement[part]) {
-            return React.cloneElement(placeholderToElement[part], { key: `${key}-${i}` });
-          }
-          return part;
-        }));
-      } else if (node.type === "tag") {
-        const Component = components == null ? void 0 : components[node.name];
-        const children2 = renderAST(node.children, key);
-        if (React.isValidElement(Component)) {
-          return React.cloneElement(Component, { key }, children2.length > 0 ? children2 : void 0);
+  const { stringValues, placeholderToElement } = React.useMemo(() => {
+    const sv = {};
+    const pte = {};
+    if (values) {
+      for (const key of Object.keys(values)) {
+        const value = values[key];
+        if (React.isValidElement(value)) {
+          const placeholder = `__ELEMENT_${key}__`;
+          pte[placeholder] = value;
+          sv[key] = placeholder;
+        } else {
+          sv[key] = value == null ? "" : String(value);
         }
-        return /* @__PURE__ */ React__default.default.createElement(React.Fragment, { key }, children2);
       }
-      return null;
-    });
-  };
-  const children = renderAST(ast, "trans");
+    }
+    return { stringValues: sv, placeholderToElement: pte };
+  }, [values]);
+  const translatedText = t2(i18nKey, stringValues);
+  const ast = React.useMemo(() => parseString(translatedText), [translatedText]);
+  const children = React.useMemo(
+    () => renderAST(ast, "trans", components, placeholderToElement),
+    [ast, components, placeholderToElement]
+  );
   return /* @__PURE__ */ React__default.default.createElement(reactNative.Text, { ...props }, children);
 };
 
@@ -517,6 +557,12 @@ var loadTranslations = (translations) => i18nService.loadTranslations(translatio
 var setLocale = (locale) => i18nService.setLocale(locale);
 var getLocale = () => i18nService.getLocale();
 var t = (scope, options) => i18nService.t(scope, options);
+var formatNumber = (n, options) => i18nService.formatNumber(n, options);
+var formatCurrency = (n, currency, options) => i18nService.formatCurrency(n, currency, options);
+var formatDate = (date, options) => i18nService.formatDate(date, options);
+var subscribe = (listener) => i18nService.subscribe(listener);
+var isRTL = () => i18nService.isRTL();
+var resetToSystem = () => i18nService.resetToSystem();
 var readyI18n = () => i18nService.ready();
 var isI18nReady = () => i18nService.isReady();
 var index_default = i18nService;
@@ -525,12 +571,18 @@ exports.I18nContext = I18nContext;
 exports.I18nProvider = I18nProvider;
 exports.Trans = Trans;
 exports.default = index_default;
+exports.formatCurrency = formatCurrency;
+exports.formatDate = formatDate;
+exports.formatNumber = formatNumber;
 exports.getLocale = getLocale;
 exports.initI18n = initI18n;
 exports.isI18nReady = isI18nReady;
+exports.isRTL = isRTL;
 exports.loadTranslations = loadTranslations;
 exports.readyI18n = readyI18n;
+exports.resetToSystem = resetToSystem;
 exports.setLocale = setLocale;
+exports.subscribe = subscribe;
 exports.t = t;
 exports.useI18n = useI18n;
 exports.withI18n = withI18n;

package/dist/index.mjs

@@ -46,6 +46,12 @@ var DefaultI18nEngine = class {
     __publicField(this, "version");
     __publicField(this, "readyPromise");
     __publicField(this, "resolveReady");
+    // --- 性能缓存 ---
+    /** Intl 格式化器缓存，key = locale + JSON(options) */
+    __publicField(this, "numberFormatCache", /* @__PURE__ */ new Map());
+    __publicField(this, "dateFormatCache", /* @__PURE__ */ new Map());
+    /** locale chain 缓存，locale 或 fallbackLocales 变化时失效 */
+    __publicField(this, "localeChainCache", /* @__PURE__ */ new Map());
     this.i18n = new I18n();
     this.listeners = /* @__PURE__ */ new Set();
     this.i18n.enableFallback = false;
@@ -80,6 +86,7 @@ var DefaultI18nEngine = class {
     this.localeSource = "system";
     this.missingBehavior = missingBehavior;
     this.onMissingKey = onMissingKey;
+    this.invalidateCaches();
     if (this.followSystem) this.updateLocale();
     this.version += 1;
     this.notifyListeners({ type: "translations", version: this.version });
@@ -115,6 +122,10 @@ var DefaultI18nEngine = class {
   getLocale() {
     return this.i18n.locale;
   }
+  resetToSystem() {
+    this.localeSource = "system";
+    this.updateLocale();
+  }
   t(scope, options) {
     var _a, _b, _c;
     if (typeof scope !== "string") {
@@ -148,7 +159,7 @@ var DefaultI18nEngine = class {
       return String(n);
     }
     try {
-      return new Intl.NumberFormat(this.i18n.locale, options).format(n);
+      return this.getCachedNumberFormat(this.i18n.locale, options).format(n);
     } catch {
       return String(n);
     }
@@ -158,7 +169,7 @@ var DefaultI18nEngine = class {
       return `${n} ${currency}`;
     }
     try {
-      return new Intl.NumberFormat(this.i18n.locale, {
+      return this.getCachedNumberFormat(this.i18n.locale, {
         ...options,
         style: "currency",
         currency
@@ -174,7 +185,7 @@ var DefaultI18nEngine = class {
       return d.toISOString();
     }
     try {
-      return new Intl.DateTimeFormat(this.i18n.locale, options).format(d);
+      return this.getCachedDateFormat(this.i18n.locale, options).format(d);
     } catch {
       return d.toISOString();
     }
@@ -195,15 +206,40 @@ var DefaultI18nEngine = class {
   isReady() {
     return this.initialized;
   }
+  // ─── 缓存管理 ────────────────────────────────────────────
+  invalidateCaches() {
+    this.numberFormatCache.clear();
+    this.dateFormatCache.clear();
+    this.localeChainCache.clear();
+  }
+  getCachedNumberFormat(locale, options) {
+    const cacheKey = locale + (options ? JSON.stringify(options) : "");
+    let fmt = this.numberFormatCache.get(cacheKey);
+    if (!fmt) {
+      fmt = new Intl.NumberFormat(locale, options);
+      this.numberFormatCache.set(cacheKey, fmt);
+    }
+    return fmt;
+  }
+  getCachedDateFormat(locale, options) {
+    const cacheKey = locale + (options ? JSON.stringify(options) : "");
+    let fmt = this.dateFormatCache.get(cacheKey);
+    if (!fmt) {
+      fmt = new Intl.DateTimeFormat(locale, options);
+      this.dateFormatCache.set(cacheKey, fmt);
+    }
+    return fmt;
+  }
+  // ─── 私有方法 ────────────────────────────────────────────
   handleRTL(locale) {
     var _a, _b;
-    const isRTL = this.isRTLLocale(locale);
+    const isRTL2 = this.isRTLLocale(locale);
     if (typeof ((_a = I18nManager) == null ? void 0 : _a.allowRTL) !== "function" || typeof ((_b = I18nManager) == null ? void 0 : _b.forceRTL) !== "function") {
       return;
     }
-    if (I18nManager.isRTL !== isRTL) {
-      I18nManager.allowRTL(isRTL);
-      I18nManager.forceRTL(isRTL);
+    if (I18nManager.isRTL !== isRTL2) {
+      I18nManager.allowRTL(isRTL2);
+      I18nManager.forceRTL(isRTL2);
     }
   }
   notifyListeners(change) {
@@ -218,6 +254,7 @@ var DefaultI18nEngine = class {
     const normalizedLocale = this.normalizeLocaleTag(locale);
     if (this.i18n.locale !== normalizedLocale) {
       this.i18n.locale = normalizedLocale;
+      this.invalidateCaches();
       this.handleRTL(normalizedLocale);
       this.version += 1;
       this.notifyListeners({ type: "locale", version: this.version });
@@ -233,39 +270,36 @@ var DefaultI18nEngine = class {
       this.i18n.locale = prevLocale;
     }
   }
-  getLocaleChain(locale) {
-    const chain = [];
-    const normalizedLocale = this.normalizeLocaleTag(locale);
-    chain.push(normalizedLocale);
-    const parts = normalizedLocale.split("-").filter(Boolean);
+  /** 将 locale 及其自动降级（如 en-US → en）追加到 chain 中 */
+  pushWithDegradation(chain, locale) {
+    const normalized = this.normalizeLocaleTag(locale);
+    chain.push(normalized);
+    const parts = normalized.split("-").filter(Boolean);
     for (let i = parts.length - 1; i >= 1; i -= 1) {
       chain.push(parts.slice(0, i).join("-"));
     }
+  }
+  getLocaleChain(locale) {
+    const cached = this.localeChainCache.get(locale);
+    if (cached) return cached;
+    const chain = [];
+    this.pushWithDegradation(chain, locale);
+    const normalizedLocale = this.normalizeLocaleTag(locale);
     const extra = this.fallbackLocales ? typeof this.fallbackLocales === "function" ? this.fallbackLocales(normalizedLocale) : this.fallbackLocales : [];
     for (const l of extra) {
-      const normalizedFallback = this.normalizeLocaleTag(l);
-      chain.push(normalizedFallback);
-      const fallbackParts = normalizedFallback.split("-").filter(Boolean);
-      for (let i = fallbackParts.length - 1; i >= 1; i -= 1) {
-        chain.push(fallbackParts.slice(0, i).join("-"));
-      }
+      this.pushWithDegradation(chain, l);
     }
     if (this.i18n.defaultLocale) {
-      const normalizedDefault = this.normalizeLocaleTag(this.i18n.defaultLocale);
-      chain.push(normalizedDefault);
-      const defaultParts = normalizedDefault.split("-").filter(Boolean);
-      for (let i = defaultParts.length - 1; i >= 1; i -= 1) {
-        chain.push(defaultParts.slice(0, i).join("-"));
-      }
+      this.pushWithDegradation(chain, this.i18n.defaultLocale);
     }
     const seen = /* @__PURE__ */ new Set();
-    return chain.filter((l) => {
-      if (!l) return false;
-      const normalized = l;
-      if (seen.has(normalized)) return false;
-      seen.add(normalized);
+    const result = chain.filter((l) => {
+      if (!l || seen.has(l)) return false;
+      seen.add(l);
       return true;
     });
+    this.localeChainCache.set(locale, result);
+    return result;
   }
   hasTranslation(locale, key) {
     var _a;
@@ -300,7 +334,7 @@ var DefaultI18nEngine = class {
   }
   isRTLLocale(locale) {
     var _a;
-    const normalized = locale.replace(/_/g, "-");
+    const normalized = this.normalizeLocaleTag(locale);
     const parts = normalized.split("-").filter(Boolean);
     const languageCode = (_a = parts[0]) == null ? void 0 : _a.toLowerCase();
     if (!languageCode) return false;
@@ -400,13 +434,13 @@ function useI18n() {
   }, [context]);
 }
 var escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var TAG_REGEX = /<(\/?)([A-Za-z][\w-]*)(?:\s[^>]*?)?(\/?)>/g;
 var parseString = (input) => {
   var _a;
   const root = { type: "tag", name: "root", children: [] };
   const stack = [root];
-  const tagRegex = /<(\/?)([A-Za-z][\w-]*)(?:\s[^>]*?)?(\/?)>/g;
   let lastIndex = 0;
-  for (const match of input.matchAll(tagRegex)) {
+  for (const match of input.matchAll(TAG_REGEX)) {
     const fullMatch = match[0];
     const isClosing = match[1] === "/";
     const tagName = match[2];
@@ -436,51 +470,57 @@ var parseString = (input) => {
   }
   return root.children;
 };
+var renderAST = (nodes, keyPrefix, components, placeholderToElement) => {
+  return nodes.map((node, index) => {
+    const key = `${keyPrefix}-${index}`;
+    if (node.type === "text") {
+      const placeholders = Object.keys(placeholderToElement);
+      if (placeholders.length === 0) return node.content;
+      const pattern = new RegExp(`(${placeholders.map(escapeRegExp).join("|")})`, "g");
+      const parts = node.content.split(pattern);
+      if (parts.length === 1) return node.content;
+      return /* @__PURE__ */ React.createElement(Fragment, { key }, parts.map((part, i) => {
+        if (placeholderToElement[part]) {
+          return cloneElement(placeholderToElement[part], { key: `${key}-${i}` });
+        }
+        return part;
+      }));
+    } else if (node.type === "tag") {
+      const Component = components == null ? void 0 : components[node.name];
+      const children = renderAST(node.children, key, components, placeholderToElement);
+      if (isValidElement(Component)) {
+        return cloneElement(Component, { key }, children.length > 0 ? children : void 0);
+      }
+      return /* @__PURE__ */ React.createElement(Fragment, { key }, children);
+    }
+    return null;
+  });
+};
 var Trans = ({ i18nKey, values, components, ...props }) => {
   const { t: t2 } = useI18n();
-  const stringValues = {};
-  const placeholderToElement = {};
-  if (values) {
-    Object.keys(values).forEach((key) => {
-      const value = values[key];
-      if (isValidElement(value)) {
-        const placeholder = `__ELEMENT_${key}__`;
-        placeholderToElement[placeholder] = value;
-        stringValues[key] = placeholder;
-      } else {
-        stringValues[key] = value == null ? "" : String(value);
-      }
-    });
-  }
-  const translatedText = t2(i18nKey, stringValues);
-  const ast = parseString(translatedText);
-  const renderAST = (nodes, keyPrefix) => {
-    return nodes.map((node, index) => {
-      const key = `${keyPrefix}-${index}`;
-      if (node.type === "text") {
-        const placeholders = Object.keys(placeholderToElement);
-        if (placeholders.length === 0) return node.content;
-        const pattern = new RegExp(`(${placeholders.map(escapeRegExp).join("|")})`, "g");
-        const parts = node.content.split(pattern);
-        if (parts.length === 1) return node.content;
-        return /* @__PURE__ */ React.createElement(Fragment, { key }, parts.map((part, i) => {
-          if (placeholderToElement[part]) {
-            return cloneElement(placeholderToElement[part], { key: `${key}-${i}` });
-          }
-          return part;
-        }));
-      } else if (node.type === "tag") {
-        const Component = components == null ? void 0 : components[node.name];
-        const children2 = renderAST(node.children, key);
-        if (isValidElement(Component)) {
-          return cloneElement(Component, { key }, children2.length > 0 ? children2 : void 0);
+  const { stringValues, placeholderToElement } = useMemo(() => {
+    const sv = {};
+    const pte = {};
+    if (values) {
+      for (const key of Object.keys(values)) {
+        const value = values[key];
+        if (isValidElement(value)) {
+          const placeholder = `__ELEMENT_${key}__`;
+          pte[placeholder] = value;
+          sv[key] = placeholder;
+        } else {
+          sv[key] = value == null ? "" : String(value);
         }
-        return /* @__PURE__ */ React.createElement(Fragment, { key }, children2);
       }
-      return null;
-    });
-  };
-  const children = renderAST(ast, "trans");
+    }
+    return { stringValues: sv, placeholderToElement: pte };
+  }, [values]);
+  const translatedText = t2(i18nKey, stringValues);
+  const ast = useMemo(() => parseString(translatedText), [translatedText]);
+  const children = useMemo(
+    () => renderAST(ast, "trans", components, placeholderToElement),
+    [ast, components, placeholderToElement]
+  );
   return /* @__PURE__ */ React.createElement(Text, { ...props }, children);
 };
 
@@ -490,8 +530,14 @@ var loadTranslations = (translations) => i18nService.loadTranslations(translatio
 var setLocale = (locale) => i18nService.setLocale(locale);
 var getLocale = () => i18nService.getLocale();
 var t = (scope, options) => i18nService.t(scope, options);
+var formatNumber = (n, options) => i18nService.formatNumber(n, options);
+var formatCurrency = (n, currency, options) => i18nService.formatCurrency(n, currency, options);
+var formatDate = (date, options) => i18nService.formatDate(date, options);
+var subscribe = (listener) => i18nService.subscribe(listener);
+var isRTL = () => i18nService.isRTL();
+var resetToSystem = () => i18nService.resetToSystem();
 var readyI18n = () => i18nService.ready();
 var isI18nReady = () => i18nService.isReady();
 var index_default = i18nService;
 
-export { I18nContext, I18nProvider, Trans, index_default as default, getLocale, initI18n, isI18nReady, loadTranslations, readyI18n, setLocale, t, useI18n, withI18n };
+export { I18nContext, I18nProvider, Trans, index_default as default, formatCurrency, formatDate, formatNumber, getLocale, initI18n, isI18nReady, isRTL, loadTranslations, readyI18n, resetToSystem, setLocale, subscribe, t, useI18n, withI18n };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-i18njs",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "一个轻量级、类型安全、零心智负担的 React Native 国际化解决方案。",
   "repository": {
     "type": "git",
@@ -8,6 +8,17 @@
   },
   "license": "ISC",
   "author": "wangws",
+  "keywords": [
+    "react-native",
+    "i18n",
+    "internationalization",
+    "localization",
+    "l10n",
+    "translation",
+    "locale",
+    "react",
+    "typescript"
+  ],
   "sideEffects": false,
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -32,11 +43,13 @@
     "build": "tsup",
     "prepack": "npm run build"
   },
+  "dependencies": {
+    "i18n-js": "^4.5.1",
+    "react-native-localize": "^3.6.1"
+  },
   "peerDependencies": {
-    "i18n-js": ">=4 <5",
     "react": ">=16.8",
-    "react-native": ">=0.64",
-    "react-native-localize": ">=3 <4"
+    "react-native": ">=0.64"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",
@@ -44,11 +57,9 @@
     "@types/react-native": "^0.72.8",
     "@types/react-test-renderer": "^19.1.0",
     "esbuild": "^0.25.0",
-    "i18n-js": "^4.5.1",
     "jest": "^30.2.0",
     "react": "^19.2.3",
     "react-native": "^0.83.1",
-    "react-native-localize": "^3.6.1",
     "react-native-web": "^0.20.0",
     "react-test-renderer": "^19.2.3",
     "ts-jest": "^29.4.6",