@simplix-react/i18n 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,179 @@
+import { i18n } from 'i18next';
+
+type LocaleCode = string;
+type TranslationValues = Record<string, string | number | boolean>;
+declare const DATE_TIME_STYLES: {
+    readonly FULL: "full";
+    readonly LONG: "long";
+    readonly MEDIUM: "medium";
+    readonly SHORT: "short";
+};
+type DateTimeStyle = (typeof DATE_TIME_STYLES)[keyof typeof DATE_TIME_STYLES];
+declare const NUMBER_FORMAT_STYLES: {
+    readonly DECIMAL: "decimal";
+    readonly CURRENCY: "currency";
+    readonly PERCENT: "percent";
+    readonly UNIT: "unit";
+};
+type NumberFormatStyle = (typeof NUMBER_FORMAT_STYLES)[keyof typeof NUMBER_FORMAT_STYLES];
+declare const TEXT_DIRECTIONS: {
+    readonly LTR: "ltr";
+    readonly RTL: "rtl";
+};
+type TextDirection = (typeof TEXT_DIRECTIONS)[keyof typeof TEXT_DIRECTIONS];
+interface PluralForms {
+    zero?: string;
+    one: string;
+    two?: string;
+    few?: string;
+    many?: string;
+    other: string;
+}
+interface DateTimeFormatOptions {
+    dateStyle?: DateTimeStyle;
+    timeStyle?: DateTimeStyle;
+    hour12?: boolean;
+}
+interface NumberFormatOptions {
+    style?: NumberFormatStyle;
+    currency?: string;
+    unit?: string;
+    minimumFractionDigits?: number;
+    maximumFractionDigits?: number;
+}
+interface LocaleInfo {
+    code: LocaleCode;
+    name: string;
+    englishName: string;
+    direction: TextDirection;
+    dateFormat: string;
+    timeFormat: string;
+    currency: string;
+}
+type TranslationNamespace = string;
+declare const TRANSLATION_LOAD_STATES: {
+    readonly IDLE: "idle";
+    readonly LOADING: "loading";
+    readonly LOADED: "loaded";
+    readonly ERROR: "error";
+};
+type TranslationLoadState = (typeof TRANSLATION_LOAD_STATES)[keyof typeof TRANSLATION_LOAD_STATES];
+
+interface II18nAdapter {
+    readonly id: string;
+    readonly name: string;
+    readonly locale: LocaleCode;
+    readonly fallbackLocale: LocaleCode;
+    readonly availableLocales: LocaleCode[];
+    initialize(defaultLocale?: LocaleCode): Promise<void>;
+    dispose(): Promise<void>;
+    setLocale(locale: LocaleCode): Promise<void>;
+    getLocaleInfo(locale: LocaleCode): LocaleInfo | null;
+    t(key: string, values?: TranslationValues): string;
+    tn(namespace: TranslationNamespace, key: string, values?: TranslationValues): string;
+    tp(key: string, count: number, values?: TranslationValues): string;
+    exists(key: string, namespace?: TranslationNamespace): boolean;
+    formatDate(date: Date, options?: DateTimeFormatOptions): string;
+    formatTime(date: Date, options?: DateTimeFormatOptions): string;
+    formatDateTime(date: Date, options?: DateTimeFormatOptions): string;
+    formatRelativeTime(date: Date): string;
+    formatNumber(value: number, options?: NumberFormatOptions): string;
+    formatCurrency(value: number, currency?: string): string;
+    loadTranslations(locale: LocaleCode, namespace: TranslationNamespace, translations: Record<string, string | PluralForms>): void;
+    getLoadState(locale: LocaleCode, namespace?: TranslationNamespace): TranslationLoadState;
+    onLocaleChange(handler: (locale: LocaleCode) => void): () => void;
+}
+
+interface LocaleConfig {
+    code: LocaleCode;
+    name: string;
+    englishName: string;
+    direction?: "ltr" | "rtl";
+    dateFormat?: string;
+    timeFormat?: string;
+    currency?: string;
+}
+type TranslationResources = Record<LocaleCode, Record<TranslationNamespace, Record<string, unknown>>>;
+interface I18nextAdapterOptions {
+    defaultLocale?: LocaleCode;
+    fallbackLocale?: LocaleCode;
+    locales?: LocaleConfig[];
+    resources?: TranslationResources;
+    i18nextInstance?: i18n;
+    debug?: boolean;
+}
+declare class I18nextAdapter implements II18nAdapter {
+    readonly id = "i18next";
+    readonly name = "i18next Adapter";
+    private i18n;
+    private initialized;
+    private localeConfigs;
+    private defaultLocale;
+    private _fallbackLocale;
+    private resources;
+    private debug;
+    private localeChangeHandlers;
+    constructor(options?: I18nextAdapterOptions);
+    get locale(): LocaleCode;
+    get fallbackLocale(): LocaleCode;
+    get availableLocales(): LocaleCode[];
+    initialize(defaultLocale?: LocaleCode): Promise<void>;
+    dispose(): Promise<void>;
+    setLocale(locale: LocaleCode): Promise<void>;
+    getLocaleInfo(locale: LocaleCode): LocaleInfo | null;
+    t(key: string, values?: TranslationValues): string;
+    tn(namespace: TranslationNamespace, key: string, values?: TranslationValues): string;
+    tp(key: string, count: number, values?: TranslationValues): string;
+    exists(key: string, namespace?: TranslationNamespace): boolean;
+    formatDate(date: Date, options?: DateTimeFormatOptions): string;
+    formatTime(date: Date, options?: DateTimeFormatOptions): string;
+    formatDateTime(date: Date, options?: DateTimeFormatOptions): string;
+    formatRelativeTime(date: Date): string;
+    formatNumber(value: number, options?: NumberFormatOptions): string;
+    formatCurrency(value: number, currency?: string): string;
+    loadTranslations(locale: LocaleCode, namespace: TranslationNamespace, translations: Record<string, string | PluralForms>): void;
+    getLoadState(locale: LocaleCode, namespace?: TranslationNamespace): TranslationLoadState;
+    onLocaleChange(handler: (locale: LocaleCode) => void): () => void;
+    addResources(locale: LocaleCode, namespace: TranslationNamespace, resources: Record<string, unknown>): void;
+    getI18nextInstance(): i18n;
+    private notifyLocaleChange;
+}
+
+interface ComponentTranslations {
+    [locale: string]: () => Promise<{
+        default: Record<string, unknown>;
+    }>;
+}
+interface BuildModuleTranslationsOptions {
+    namespace: string;
+    locales: string[];
+    components: Record<string, ComponentTranslations>;
+}
+interface ModuleTranslations {
+    namespace: string;
+    locales: string[];
+    load: (locale: string) => Promise<Record<string, Record<string, unknown>>>;
+}
+declare function buildModuleTranslations(options: BuildModuleTranslationsOptions): ModuleTranslations;
+
+interface CreateI18nConfigOptions {
+    defaultLocale?: LocaleCode;
+    fallbackLocale?: LocaleCode;
+    supportedLocales?: LocaleConfig[];
+    detection?: {
+        order: string[];
+    };
+    appTranslations?: Record<string, unknown>;
+    moduleTranslations?: ModuleTranslations[];
+    debug?: boolean;
+}
+interface I18nConfigResult {
+    adapter: I18nextAdapter;
+    i18nReady: Promise<void>;
+}
+declare function createI18nConfig(options: CreateI18nConfigOptions): I18nConfigResult;
+
+declare const DEFAULT_LOCALES: LocaleConfig[];
+declare const SUPPORTED_LOCALES: string[];
+
+export { type BuildModuleTranslationsOptions, type ComponentTranslations, type CreateI18nConfigOptions, DATE_TIME_STYLES, DEFAULT_LOCALES, type DateTimeFormatOptions, type DateTimeStyle, type I18nConfigResult, I18nextAdapter, type I18nextAdapterOptions, type II18nAdapter, type LocaleCode, type LocaleConfig, type LocaleInfo, type ModuleTranslations, NUMBER_FORMAT_STYLES, type NumberFormatOptions, type NumberFormatStyle, type PluralForms, SUPPORTED_LOCALES, TEXT_DIRECTIONS, TRANSLATION_LOAD_STATES, type TextDirection, type TranslationLoadState, type TranslationNamespace, type TranslationResources, type TranslationValues, buildModuleTranslations, createI18nConfig };

package/dist/index.js

@@ -0,0 +1,367 @@
+import i18next from 'i18next';
+
+// src/types.ts
+var DATE_TIME_STYLES = {
+  FULL: "full",
+  LONG: "long",
+  MEDIUM: "medium",
+  SHORT: "short"
+};
+var NUMBER_FORMAT_STYLES = {
+  DECIMAL: "decimal",
+  CURRENCY: "currency",
+  PERCENT: "percent",
+  UNIT: "unit"
+};
+var TEXT_DIRECTIONS = {
+  LTR: "ltr",
+  RTL: "rtl"
+};
+var TRANSLATION_LOAD_STATES = {
+  IDLE: "idle",
+  LOADING: "loading",
+  LOADED: "loaded",
+  ERROR: "error"
+};
+var BUILTIN_LOCALES = [
+  {
+    code: "ko",
+    name: "\uD55C\uAD6D\uC5B4",
+    englishName: "Korean",
+    direction: "ltr",
+    dateFormat: "yyyy-MM-dd",
+    timeFormat: "HH:mm:ss",
+    currency: "KRW"
+  },
+  {
+    code: "en",
+    name: "English",
+    englishName: "English",
+    direction: "ltr",
+    dateFormat: "MM/dd/yyyy",
+    timeFormat: "h:mm:ss a",
+    currency: "USD"
+  },
+  {
+    code: "ja",
+    name: "\u65E5\u672C\u8A9E",
+    englishName: "Japanese",
+    direction: "ltr",
+    dateFormat: "yyyy/MM/dd",
+    timeFormat: "HH:mm:ss",
+    currency: "JPY"
+  }
+];
+var I18nextAdapter = class {
+  id = "i18next";
+  name = "i18next Adapter";
+  i18n;
+  initialized = false;
+  localeConfigs;
+  defaultLocale;
+  _fallbackLocale;
+  resources;
+  debug;
+  localeChangeHandlers = /* @__PURE__ */ new Set();
+  constructor(options = {}) {
+    this.defaultLocale = options.defaultLocale ?? "en";
+    this._fallbackLocale = options.fallbackLocale ?? "en";
+    this.resources = options.resources ?? {};
+    this.debug = options.debug ?? false;
+    this.i18n = options.i18nextInstance ?? i18next.createInstance();
+    const locales = options.locales ?? BUILTIN_LOCALES;
+    this.localeConfigs = new Map(locales.map((l) => [l.code, l]));
+  }
+  get locale() {
+    return this.i18n.language ?? this.defaultLocale;
+  }
+  get fallbackLocale() {
+    return this._fallbackLocale;
+  }
+  get availableLocales() {
+    return Array.from(this.localeConfigs.keys());
+  }
+  async initialize(defaultLocale) {
+    if (this.initialized) return;
+    const isAlreadyInitialized = this.i18n.isInitialized;
+    if (!isAlreadyInitialized) {
+      const locale = defaultLocale ?? this.defaultLocale;
+      await this.i18n.init({
+        lng: locale,
+        fallbackLng: this._fallbackLocale,
+        resources: this.resources,
+        interpolation: {
+          escapeValue: false
+        },
+        debug: this.debug,
+        returnNull: false,
+        returnEmptyString: false
+      });
+    }
+    this.i18n.on("languageChanged", (lng) => {
+      this.notifyLocaleChange(lng);
+    });
+    this.initialized = true;
+  }
+  async dispose() {
+    this.localeChangeHandlers.clear();
+    this.initialized = false;
+  }
+  async setLocale(locale) {
+    if (!this.localeConfigs.has(locale)) {
+      throw new Error(`Unsupported locale: ${locale}`);
+    }
+    await this.i18n.changeLanguage(locale);
+  }
+  getLocaleInfo(locale) {
+    const config = this.localeConfigs.get(locale);
+    if (!config) return null;
+    return {
+      code: config.code,
+      name: config.name,
+      englishName: config.englishName,
+      direction: config.direction ?? "ltr",
+      dateFormat: config.dateFormat ?? "yyyy-MM-dd",
+      timeFormat: config.timeFormat ?? "HH:mm:ss",
+      currency: config.currency ?? "USD"
+    };
+  }
+  t(key, values) {
+    return this.i18n.t(key, values) ?? key;
+  }
+  tn(namespace, key, values) {
+    return this.i18n.t(`${namespace}:${key}`, values) ?? key;
+  }
+  tp(key, count, values) {
+    return this.i18n.t(key, { count, ...values }) ?? key;
+  }
+  exists(key, namespace) {
+    const fullKey = namespace ? `${namespace}:${key}` : key;
+    return this.i18n.exists(fullKey);
+  }
+  formatDate(date, options) {
+    const locale = this.locale;
+    const intlOptions = {};
+    if (options?.dateStyle) {
+      intlOptions.dateStyle = options.dateStyle;
+    } else {
+      intlOptions.year = "numeric";
+      intlOptions.month = "2-digit";
+      intlOptions.day = "2-digit";
+    }
+    return new Intl.DateTimeFormat(locale, intlOptions).format(date);
+  }
+  formatTime(date, options) {
+    const locale = this.locale;
+    const intlOptions = {};
+    if (options?.timeStyle) {
+      intlOptions.timeStyle = options.timeStyle;
+    } else {
+      intlOptions.hour = "2-digit";
+      intlOptions.minute = "2-digit";
+      intlOptions.second = "2-digit";
+    }
+    if (options?.hour12 !== void 0) {
+      intlOptions.hour12 = options.hour12;
+    }
+    return new Intl.DateTimeFormat(locale, intlOptions).format(date);
+  }
+  formatDateTime(date, options) {
+    const locale = this.locale;
+    const intlOptions = {};
+    if (options?.dateStyle) {
+      intlOptions.dateStyle = options.dateStyle;
+    }
+    if (options?.timeStyle) {
+      intlOptions.timeStyle = options.timeStyle;
+    }
+    if (options?.hour12 !== void 0) {
+      intlOptions.hour12 = options.hour12;
+    }
+    if (!options?.dateStyle && !options?.timeStyle) {
+      intlOptions.dateStyle = "medium";
+      intlOptions.timeStyle = "medium";
+    }
+    return new Intl.DateTimeFormat(locale, intlOptions).format(date);
+  }
+  formatRelativeTime(date) {
+    const locale = this.locale;
+    const now = /* @__PURE__ */ new Date();
+    const diffMs = date.getTime() - now.getTime();
+    const diffSec = Math.round(diffMs / 1e3);
+    const diffMin = Math.round(diffSec / 60);
+    const diffHour = Math.round(diffMin / 60);
+    const diffDay = Math.round(diffHour / 24);
+    const rtf = new Intl.RelativeTimeFormat(locale, { numeric: "auto" });
+    if (Math.abs(diffSec) < 60) {
+      return rtf.format(diffSec, "second");
+    } else if (Math.abs(diffMin) < 60) {
+      return rtf.format(diffMin, "minute");
+    } else if (Math.abs(diffHour) < 24) {
+      return rtf.format(diffHour, "hour");
+    } else {
+      return rtf.format(diffDay, "day");
+    }
+  }
+  formatNumber(value, options) {
+    const locale = this.locale;
+    const intlOptions = {};
+    if (options?.style) {
+      intlOptions.style = options.style;
+    }
+    if (options?.currency) {
+      intlOptions.currency = options.currency;
+    }
+    if (options?.unit) {
+      intlOptions.unit = options.unit;
+    }
+    if (options?.minimumFractionDigits !== void 0) {
+      intlOptions.minimumFractionDigits = options.minimumFractionDigits;
+    }
+    if (options?.maximumFractionDigits !== void 0) {
+      intlOptions.maximumFractionDigits = options.maximumFractionDigits;
+    }
+    return new Intl.NumberFormat(locale, intlOptions).format(value);
+  }
+  formatCurrency(value, currency) {
+    const locale = this.locale;
+    const localeInfo = this.getLocaleInfo(locale);
+    const currencyCode = currency ?? localeInfo?.currency ?? "USD";
+    return new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency: currencyCode
+    }).format(value);
+  }
+  loadTranslations(locale, namespace, translations) {
+    this.i18n.addResourceBundle(locale, namespace, translations, true, true);
+  }
+  getLoadState(locale, namespace) {
+    if (!this.initialized) return "idle";
+    const hasLocale = this.i18n.hasResourceBundle(
+      locale,
+      namespace ?? "translation"
+    );
+    return hasLocale ? "loaded" : "idle";
+  }
+  onLocaleChange(handler) {
+    this.localeChangeHandlers.add(handler);
+    return () => {
+      this.localeChangeHandlers.delete(handler);
+    };
+  }
+  addResources(locale, namespace, resources) {
+    this.i18n.addResourceBundle(locale, namespace, resources, true, true);
+  }
+  getI18nextInstance() {
+    return this.i18n;
+  }
+  notifyLocaleChange(locale) {
+    for (const handler of this.localeChangeHandlers) {
+      try {
+        handler(locale);
+      } catch (error) {
+        console.error("Error in locale change handler:", error);
+      }
+    }
+  }
+};
+
+// src/module-translations.ts
+function buildModuleTranslations(options) {
+  return {
+    namespace: options.namespace,
+    locales: options.locales,
+    async load(locale) {
+      const result = {};
+      const entries = Object.entries(options.components);
+      const loadPromises = entries.map(async ([componentPath, loaders]) => {
+        const loader = loaders[locale];
+        if (!loader) return;
+        const mod = await loader();
+        const data = mod.default ?? mod;
+        result[componentPath] = data;
+      });
+      await Promise.all(loadPromises);
+      return result;
+    }
+  };
+}
+
+// src/utils/locale-config.ts
+var DEFAULT_LOCALES = [
+  {
+    code: "ko",
+    name: "\uD55C\uAD6D\uC5B4",
+    englishName: "Korean",
+    direction: "ltr",
+    dateFormat: "yyyy-MM-dd",
+    timeFormat: "HH:mm:ss",
+    currency: "KRW"
+  },
+  {
+    code: "en",
+    name: "English",
+    englishName: "English",
+    direction: "ltr",
+    dateFormat: "MM/dd/yyyy",
+    timeFormat: "h:mm:ss a",
+    currency: "USD"
+  },
+  {
+    code: "ja",
+    name: "\u65E5\u672C\u8A9E",
+    englishName: "Japanese",
+    direction: "ltr",
+    dateFormat: "yyyy/MM/dd",
+    timeFormat: "HH:mm:ss",
+    currency: "JPY"
+  }
+];
+var SUPPORTED_LOCALES = DEFAULT_LOCALES.map((l) => l.code);
+
+// src/create-i18n-config.ts
+function createI18nConfig(options) {
+  const {
+    defaultLocale = "en",
+    fallbackLocale = "en",
+    supportedLocales = DEFAULT_LOCALES,
+    moduleTranslations = [],
+    debug = false
+  } = options;
+  const resources = {};
+  if (options.appTranslations) {
+    for (const [filePath, content] of Object.entries(
+      options.appTranslations
+    )) {
+      const match = filePath.match(/\/locales\/(.+?)\/(\w+)\.json$/);
+      if (!match) continue;
+      const namespace = match[1];
+      const locale = match[2];
+      if (!resources[locale]) resources[locale] = {};
+      const mod = content;
+      resources[locale][namespace] = mod.default ?? mod;
+    }
+  }
+  const adapter = new I18nextAdapter({
+    defaultLocale,
+    fallbackLocale,
+    locales: supportedLocales,
+    resources,
+    debug
+  });
+  const i18nReady = (async () => {
+    await adapter.initialize(defaultLocale);
+    for (const mod of moduleTranslations) {
+      for (const locale of mod.locales) {
+        const translations = await mod.load(locale);
+        for (const [componentPath, data] of Object.entries(translations)) {
+          const namespace = `${mod.namespace}/${componentPath}`;
+          adapter.addResources(locale, namespace, data);
+        }
+      }
+    }
+  })();
+  return { adapter, i18nReady };
+}
+
+export { DATE_TIME_STYLES, DEFAULT_LOCALES, I18nextAdapter, NUMBER_FORMAT_STYLES, SUPPORTED_LOCALES, TEXT_DIRECTIONS, TRANSLATION_LOAD_STATES, buildModuleTranslations, createI18nConfig };

package/dist/react.d.ts

@@ -0,0 +1,105 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+
+type LocaleCode = string;
+type TranslationValues = Record<string, string | number | boolean>;
+declare const DATE_TIME_STYLES: {
+    readonly FULL: "full";
+    readonly LONG: "long";
+    readonly MEDIUM: "medium";
+    readonly SHORT: "short";
+};
+type DateTimeStyle = (typeof DATE_TIME_STYLES)[keyof typeof DATE_TIME_STYLES];
+declare const NUMBER_FORMAT_STYLES: {
+    readonly DECIMAL: "decimal";
+    readonly CURRENCY: "currency";
+    readonly PERCENT: "percent";
+    readonly UNIT: "unit";
+};
+type NumberFormatStyle = (typeof NUMBER_FORMAT_STYLES)[keyof typeof NUMBER_FORMAT_STYLES];
+declare const TEXT_DIRECTIONS: {
+    readonly LTR: "ltr";
+    readonly RTL: "rtl";
+};
+type TextDirection = (typeof TEXT_DIRECTIONS)[keyof typeof TEXT_DIRECTIONS];
+interface PluralForms {
+    zero?: string;
+    one: string;
+    two?: string;
+    few?: string;
+    many?: string;
+    other: string;
+}
+interface DateTimeFormatOptions {
+    dateStyle?: DateTimeStyle;
+    timeStyle?: DateTimeStyle;
+    hour12?: boolean;
+}
+interface NumberFormatOptions {
+    style?: NumberFormatStyle;
+    currency?: string;
+    unit?: string;
+    minimumFractionDigits?: number;
+    maximumFractionDigits?: number;
+}
+interface LocaleInfo {
+    code: LocaleCode;
+    name: string;
+    englishName: string;
+    direction: TextDirection;
+    dateFormat: string;
+    timeFormat: string;
+    currency: string;
+}
+type TranslationNamespace = string;
+declare const TRANSLATION_LOAD_STATES: {
+    readonly IDLE: "idle";
+    readonly LOADING: "loading";
+    readonly LOADED: "loaded";
+    readonly ERROR: "error";
+};
+type TranslationLoadState = (typeof TRANSLATION_LOAD_STATES)[keyof typeof TRANSLATION_LOAD_STATES];
+
+interface II18nAdapter {
+    readonly id: string;
+    readonly name: string;
+    readonly locale: LocaleCode;
+    readonly fallbackLocale: LocaleCode;
+    readonly availableLocales: LocaleCode[];
+    initialize(defaultLocale?: LocaleCode): Promise<void>;
+    dispose(): Promise<void>;
+    setLocale(locale: LocaleCode): Promise<void>;
+    getLocaleInfo(locale: LocaleCode): LocaleInfo | null;
+    t(key: string, values?: TranslationValues): string;
+    tn(namespace: TranslationNamespace, key: string, values?: TranslationValues): string;
+    tp(key: string, count: number, values?: TranslationValues): string;
+    exists(key: string, namespace?: TranslationNamespace): boolean;
+    formatDate(date: Date, options?: DateTimeFormatOptions): string;
+    formatTime(date: Date, options?: DateTimeFormatOptions): string;
+    formatDateTime(date: Date, options?: DateTimeFormatOptions): string;
+    formatRelativeTime(date: Date): string;
+    formatNumber(value: number, options?: NumberFormatOptions): string;
+    formatCurrency(value: number, currency?: string): string;
+    loadTranslations(locale: LocaleCode, namespace: TranslationNamespace, translations: Record<string, string | PluralForms>): void;
+    getLoadState(locale: LocaleCode, namespace?: TranslationNamespace): TranslationLoadState;
+    onLocaleChange(handler: (locale: LocaleCode) => void): () => void;
+}
+
+interface I18nProviderProps {
+    children: ReactNode;
+    adapter: II18nAdapter;
+}
+declare function I18nProvider({ children, adapter }: I18nProviderProps): react_jsx_runtime.JSX.Element;
+declare function useI18nAdapter(): II18nAdapter | null;
+
+type TranslateFunction = (key: string, values?: TranslationValues) => string;
+interface UseTranslationReturn {
+    t: TranslateFunction;
+    locale: LocaleCode;
+    exists: (key: string) => boolean;
+}
+declare function useTranslation(namespace: string): UseTranslationReturn;
+declare function useI18n(): II18nAdapter | null;
+declare function useLocale(): LocaleCode;
+
+export { I18nProvider, type I18nProviderProps, type TranslateFunction, type UseTranslationReturn, useI18n, useI18nAdapter, useLocale, useTranslation };

package/dist/react.js

@@ -0,0 +1,68 @@
+import { createContext, useContext, useCallback, useSyncExternalStore, useMemo } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+// src/react/i18n-provider.tsx
+var I18nContext = createContext(null);
+function I18nProvider({ children, adapter }) {
+  return /* @__PURE__ */ jsx(I18nContext.Provider, { value: adapter, children });
+}
+function useI18nAdapter() {
+  return useContext(I18nContext);
+}
+function useTranslation(namespace) {
+  const i18n = useI18nAdapter();
+  const subscribe = useCallback(
+    (onStoreChange) => {
+      if (!i18n) return () => {
+      };
+      return i18n.onLocaleChange(onStoreChange);
+    },
+    [i18n]
+  );
+  const getSnapshot = useCallback(() => {
+    return i18n?.locale ?? "en";
+  }, [i18n]);
+  const locale = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  const t = useCallback(
+    (key, values) => {
+      if (!i18n) return key;
+      return i18n.tn(namespace, key, values);
+    },
+    [i18n, namespace]
+  );
+  const exists = useCallback(
+    (key) => {
+      if (!i18n) return false;
+      return i18n.exists(key, namespace);
+    },
+    [i18n, namespace]
+  );
+  return useMemo(
+    () => ({
+      t,
+      locale,
+      exists
+    }),
+    [t, locale, exists]
+  );
+}
+function useI18n() {
+  return useI18nAdapter();
+}
+function useLocale() {
+  const i18n = useI18nAdapter();
+  const subscribe = useCallback(
+    (onStoreChange) => {
+      if (!i18n) return () => {
+      };
+      return i18n.onLocaleChange(onStoreChange);
+    },
+    [i18n]
+  );
+  const getSnapshot = useCallback(() => {
+    return i18n?.locale ?? "en";
+  }, [i18n]);
+  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+}
+
+export { I18nProvider, useI18n, useI18nAdapter, useLocale, useTranslation };

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@simplix-react/i18n",
+  "version": "0.0.1",
+  "description": "Internationalization framework with i18next adapter",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "import": "./dist/react.js"
+    }
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src",
+    "test": "vitest run --passWithNoTests",
+    "clean": "rm -rf dist .turbo"
+  },
+  "peerDependencies": {
+    "i18next": ">=25.0.0",
+    "react": ">=18.0.0",
+    "react-i18next": ">=16.0.0"
+  },
+  "peerDependenciesMeta": {
+    "i18next": { "optional": true },
+    "react": { "optional": true },
+    "react-i18next": { "optional": true }
+  },
+  "devDependencies": {
+    "@simplix-react/config-typescript": "workspace:*",
+    "@types/react": "^19.0.0",
+    "eslint": "^9.39.2",
+    "i18next": "^25.8.0",
+    "react": "^19.0.0",
+    "react-i18next": "^16.0.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^3.0.0"
+  }
+}