react-scoped-i18n 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Amer Kočan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,148 @@
+# react-scoped-i18n 🌐
+
+`react-scoped-i18n 🌐` is a **fully type-safe** i18n solution for **React**.
+
+It encourages writing translations right next to the components that use them.
+
+---
+
+## Getting started:
+
+### [Installation & Usage](/docs/usage.md)
+
+### [API](/docs/api.md)
+
+###### Note: You can use this with both React and React Native (+ Expo) projects. 🚀
+
+
+---
+
+## Why `react-scoped-i18n 🌐`?
+
+### Key features:
+- Very minimal setup with out-of-the-box number & date formatting
+- Fully type-safe:
+- - missing translations or unsupported languages are compile-time errors
+- - return types of `t()` are inferred from translation values
+- Utilize the widely supported [Internationalization API (Intl)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl) for number, currency, date and time formatting
+- Usage is entirely in the runtime; no build-time transforms, no new syntax is required for string interpolation or dynamic translations generated at runtime, everything is plain JS/TS
+
+### The focus is on dev experience:
+- Translations are colocated with the components that use them; looking up translations in the codebase always immediately leads to the relevant component code
+- No context switching between component code and translation files when developing UI
+- No tedious naming of translation keys, as they usually provide little value
+- Ditch restrictive translation file formats (JSON, YAML); use the full power of JS/TS
+- Runs within React's context system. No additional build steps, changes can be hot-reloaded, language switches reflected immediately
+
+---
+
+## What does it look like?
+
+##### Very Basic Example:
+
+```tsx
+import { useI18n } from "@/i18n";
+import { Heading, Button } from "@/components";
+
+export const WelcomeMessage = () => {
+    const { t, commons } = useI18n();
+
+    const name = `John`;
+
+    return (
+        <>
+            <Heading>
+                {t({
+                    // all fully type-safe for all configured languages
+                    en: `Welcome to the website, ${name}!`,
+                    es: `¡Bienvenido al sitio web, ${name}!`,
+                    sl: `Dobrodošli na spletno stran, ${name}!`,
+                })}
+            </Heading>
+            <Button>{
+                // "commons" object is used for commonly used, shared translations
+                t(commons.continue)
+            }</Button>
+        </>
+    );
+};
+```
+
+<details>
+  <summary>
+Number Formatting Basic Example:
+  </summary>
+
+```tsx
+import { useI18n } from "@/i18n";
+import { Text } from "@/components";
+
+export const PriceTag = () => {
+    const { t, format } = useI18n();
+
+    const price = 19.99;
+
+    const currency = `USD`;
+
+    return (
+        <Text>
+            {t({
+                en: `The price is ${format.currency(price, currency)}.`,
+                es: `El precio es ${format.currency(price, currency)}.`,
+                sl: `Cena je ${format.currency(price, currency)}.`,
+            })}
+        </Text>
+    );
+};
+```
+</details>
+
+
+<details>
+  <summary>
+Pluralization Basic Example:
+  </summary>
+
+```tsx
+import { useI18n } from "@/i18n";
+import { Text } from "@/components";
+
+export const Apples = () => {
+    const { tPlural } = useI18n();
+
+    const count = 12;
+
+    return (
+        <Text>
+            {tPlural(count, {
+                en: {
+                    negative: `You are in apple debt...`,
+                    one: `You have one apple.`,
+                    many: `You have ${count} apples.`,
+                    42: `You have the perfect number of apples!`, // ‼️ you can target specific numbers
+                },
+                es: {
+                    one: `Tienes una manzana.`,
+                    many: `Tienes ${count} manzanas.`,
+                },
+                sl: {
+                    one: `Imaš eno jabolko.`,
+                    two: `Imaš dve jabolki.`, // ‼️ handling dual form in Slovenian that English and Spanish don't have
+                    many: `Imaš ${count} jabolk.`,
+                }
+            })}
+        </Text>
+    )
+};
+```
+</details>
+
+----
+
+`react-scoped-i18n 🌐` shines most when devs are the ones adding translations into the app, and when the number of supported languages is small-to-medium sized.
+
+You can find more in-depth examples in the [Installation & Usage](/docs/usage.md) and the API definitions in [API](/docs/api.md)
+
+---
+
+#### [License: MIT](/LICENSE)

package/dist/cjs/createI18nContext/api/createCommons.d.ts

@@ -0,0 +1,6 @@
+import { TranslationMap } from "../type";
+export declare const createCommons: <const Languages extends readonly string[], const Commons extends Record<string, TranslationMap<Languages[number], string>>>({ commons, currentLanguage, fallbackLanguage, }: {
+    commons: Commons;
+    currentLanguage: Languages[number];
+    fallbackLanguage: Languages[number];
+}) => { [K in keyof Commons]?: string | undefined; };

package/dist/cjs/createI18nContext/api/createCommons.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCommons = void 0;
+const env_1 = require("../../env");
+const const_1 = require("../const");
+const createCommons = ({ commons, currentLanguage, fallbackLanguage, }) => {
+    const result = {};
+    for (const key in commons) {
+        const translationMap = commons[key];
+        const targetTranslation = translationMap[currentLanguage];
+        if (targetTranslation) {
+            result[key] = targetTranslation;
+            continue;
+        }
+        const fallbackTranslation = translationMap[fallbackLanguage];
+        if (fallbackTranslation) {
+            if (env_1.IS_DEV) {
+                console.warn(`[i18n] Missing translation for key "${key}" in current language "${currentLanguage}" in "commons". Defaulting to fallback language "${fallbackLanguage}".`);
+            }
+            result[key] = fallbackTranslation;
+            continue;
+        }
+        if (env_1.IS_DEV) {
+            console.warn(`[i18n] Missing translation for key "${key}" in both current language "${currentLanguage}" and fallback language "${fallbackLanguage}" in "commons".`);
+        }
+        result[key] = const_1.MISSING_TRANSLATION;
+    }
+    return result;
+};
+exports.createCommons = createCommons;

package/dist/cjs/createI18nContext/api/createCommons.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/createI18nContext/api/createCommons.test.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const createCommons_1 = require("./createCommons");
+describe(`createCommons`, () => {
+    it(`returns the correct common translations based on current language and fallback`, () => {
+        const result = (0, createCommons_1.createCommons)({
+            commons: {
+                welcome: {
+                    en: `Welcome`,
+                    es: `Bienvenido`,
+                    fr: `Bienvenue`,
+                },
+                goodbye: {
+                    en: `Goodbye`,
+                    es: `Adiós`,
+                },
+            },
+            currentLanguage: `fr`,
+            fallbackLanguage: `en`,
+        });
+        expect(result).toEqual({
+            welcome: `Bienvenue`,
+            goodbye: `Goodbye`,
+        });
+    });
+});

package/dist/cjs/createI18nContext/api/createFormat.d.ts

@@ -0,0 +1,9 @@
+export declare const createFormat: <const Languages extends readonly string[]>({ currentLanguage, }: {
+    currentLanguage: Languages[number];
+}) => {
+    number: (value: number, options?: Intl.NumberFormatOptions) => string;
+    date: (value: Date | number, options?: Intl.DateTimeFormatOptions) => string;
+    time: (value: Date | number, options?: Intl.DateTimeFormatOptions) => string;
+    currency: (value: number, currency: string, options?: Omit<Intl.NumberFormatOptions, `style` | `currency`>) => string;
+    percentage: (value: number, options?: Omit<Intl.NumberFormatOptions, `style`>) => string;
+};

package/dist/cjs/createI18nContext/api/createFormat.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFormat = void 0;
+const createFormat = ({ currentLanguage, }) => {
+    const defaultNumberFormatter = new Intl.NumberFormat(currentLanguage);
+    const defaultDateFormatter = new Intl.DateTimeFormat(currentLanguage);
+    const defaultTimeFormatter = new Intl.DateTimeFormat(currentLanguage, {
+        hour: `numeric`,
+        minute: `numeric`,
+        second: `numeric`,
+    });
+    const defaultPercentageFormatter = new Intl.NumberFormat(currentLanguage, {
+        style: `percent`,
+    });
+    return {
+        number: (value, options) => {
+            if (options) {
+                return new Intl.NumberFormat(currentLanguage, options).format(value);
+            }
+            return defaultNumberFormatter.format(value);
+        },
+        date: (value, options) => {
+            if (options) {
+                return new Intl.DateTimeFormat(currentLanguage, options).format(value);
+            }
+            return defaultDateFormatter.format(value);
+        },
+        time: (value, options) => {
+            if (options) {
+                return new Intl.DateTimeFormat(currentLanguage, {
+                    ...options,
+                }).format(value);
+            }
+            return defaultTimeFormatter.format(value);
+        },
+        currency: (value, currency, options) => {
+            return new Intl.NumberFormat(currentLanguage, {
+                style: `currency`,
+                currency,
+                ...options,
+            }).format(value);
+        },
+        percentage: (value, options) => {
+            if (options) {
+                return new Intl.NumberFormat(currentLanguage, {
+                    style: `percent`,
+                    ...options,
+                }).format(value);
+            }
+            return defaultPercentageFormatter.format(value);
+        },
+    };
+};
+exports.createFormat = createFormat;

package/dist/cjs/createI18nContext/api/createFormat.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/createI18nContext/api/createFormat.test.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const createFormat_1 = require("./createFormat");
+describe(`createFormat`, () => {
+    const format = (0, createFormat_1.createFormat)({
+        currentLanguage: `en-US`,
+    });
+    it(`number formatter returns a formatted value`, () => {
+        const formattedNumber = format.number(1234567.89);
+        expect(formattedNumber).toBe(`1,234,567.89`);
+    });
+    it(`number formatter returns a formatted value with options`, () => {
+        const formattedNumber = format.number(0.1234, {
+            style: `percent`,
+            minimumFractionDigits: 2,
+        });
+        expect(formattedNumber).toBe(`12.34%`);
+    });
+    it(`date formatter returns a formatted value`, () => {
+        const date = new Date(`2024-01-01T12:00:00Z`);
+        const formattedDate = format.date(date);
+        expect(formattedDate).toBe(`1/1/2024`);
+    });
+    it(`date formatter returns a formatted value with options`, () => {
+        const date = new Date(`1999-01-01T12:00:00Z`);
+        const formattedDate = format.date(date, {
+            year: `numeric`,
+            month: `long`,
+            day: `numeric`,
+        });
+        expect(formattedDate).toBe(`January 1, 1999`);
+    });
+    it(`time formatter returns a formatted value`, () => {
+        const date = new Date(`1912-06-23T02:15:00`);
+        const formattedTime = format.time(date);
+        expect(formattedTime).toBe(`2:15:00 AM`);
+    });
+    it(`time formatter returns a formatted value with options`, () => {
+        const date = new Date(`2000-12-31T23:45:30`);
+        const formattedTime = format.time(date, {
+            hour12: false,
+            hour: `2-digit`,
+            minute: `2-digit`,
+        });
+        expect(formattedTime).toBe(`23:45`);
+    });
+    it(`currency formatter returns a formatted value`, () => {
+        const formattedCurrency = format.currency(1234.567, `USD`);
+        expect(formattedCurrency).toBe(`$1,234.57`);
+    });
+    it(`currency formatter returns a formatted value with options`, () => {
+        const formattedCurrency = format.currency(1234.567, `EUR`, {
+            maximumFractionDigits: 1,
+        });
+        expect(formattedCurrency).toBe(`€1,234.6`);
+    });
+    it(`percentage formatter returns a formatted value`, () => {
+        const formattedPercentage = format.percentage(0.1234);
+        expect(formattedPercentage).toBe(`12%`);
+    });
+    it(`percentage formatter returns a formatted value `, () => {
+        const formattedPercentage = format.percentage(0.1234);
+        expect(formattedPercentage).toBe(`12%`);
+    });
+    it(`percentage formatter returns a formatted value with options`, () => {
+        const formattedPercentage = format.percentage(0.1234, {
+            minimumFractionDigits: 2,
+        });
+        expect(formattedPercentage).toBe(`12.34%`);
+    });
+});

package/dist/cjs/createI18nContext/api/createT.d.ts

@@ -0,0 +1,7 @@
+import { TranslationMap, TranslationValue } from "../type";
+import { ReactNode } from "react";
+export declare const createT: <const Languages extends readonly string[]>({ currentLanguage, fallbackLanguage, languages, }: {
+    currentLanguage: Languages[number];
+    fallbackLanguage: Languages[number];
+    languages: Readonly<Languages>;
+}) => <Value extends TranslationValue = ReactNode>(translation: TranslationMap<Languages[number], Value>) => Value;

package/dist/cjs/createI18nContext/api/createT.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createT = void 0;
+const getTranslation_1 = require("../util/getTranslation");
+const createT = ({ currentLanguage, fallbackLanguage, languages, }) => {
+    return (translation) => {
+        return (0, getTranslation_1.getTranslation)({
+            translation,
+            language: currentLanguage,
+            languages,
+            fallbackLanguage,
+        });
+    };
+};
+exports.createT = createT;

package/dist/cjs/createI18nContext/api/createT.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/createI18nContext/api/createT.test.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsx_runtime_1 = require("react/jsx-runtime");
+const createT_1 = require("./createT");
+describe(`createT`, () => {
+    const t = (0, createT_1.createT)({
+        currentLanguage: `fr`,
+        fallbackLanguage: `en`,
+        languages: [`en`, `es`, `fr`],
+    });
+    it(`t helper returns a translation`, () => {
+        expect(t({
+            en: `Hello`,
+            es: `Hola`,
+            fr: `Bonjour`,
+        })).toBe(`Bonjour`);
+        expect(t({
+            en: (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, {}),
+            es: `Hola`,
+            fr: `Bonjour`,
+        })).toBe(`Bonjour`);
+    });
+});

package/dist/cjs/createI18nContext/api/createTGlobal.d.ts

@@ -0,0 +1,8 @@
+import { TranslationMap } from "../type";
+export declare const createTGlobal: <const Language extends string>({ currentLanguage, languages, fallbackLanguage, }: {
+    currentLanguage: {
+        current: Language;
+    };
+    languages: readonly Language[];
+    fallbackLanguage: Language;
+}) => (translation: TranslationMap<Language>) => import("../type").TranslationValue;

package/dist/cjs/createI18nContext/api/createTGlobal.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTGlobal = void 0;
+const type_1 = require("../type");
+const getTranslation_1 = require("../util/getTranslation");
+const env_1 = require("../../env");
+const createTGlobal = ({ currentLanguage, languages, fallbackLanguage, }) => {
+    /**
+     * Module-scoped translation function, to be used outside React components.
+     * Do not use inside React components, use `useI18n` hook instead.
+     */
+    return (translation) => {
+        if (!(0, type_1.isLanguage)(currentLanguage.current, languages)) {
+            throw new Error(`tGlobal cannot be invoked before <I18nProvider> is mounted`);
+        }
+        const isValidLanguage = (0, type_1.isLanguage)(currentLanguage.current, languages);
+        if (!isValidLanguage) {
+            throw new Error(`Invalid current language "${currentLanguage}"`);
+        }
+        if (env_1.IS_DEV) {
+            console.info(`[i18n] Friendly reminder: Make sure you are not using "tGlobal" inside React components. Use "useI18n" hook instead. `);
+        }
+        return (0, getTranslation_1.getTranslation)({
+            translation: translation,
+            language: currentLanguage.current,
+            languages,
+            fallbackLanguage: fallbackLanguage,
+        });
+    };
+};
+exports.createTGlobal = createTGlobal;

package/dist/cjs/createI18nContext/api/createTGlobal.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/createI18nContext/api/createTGlobal.test.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const createTGlobal_1 = require("./createTGlobal");
+describe(`createTGlobal`, () => {
+    const fakeCurrentLanguageRef = { current: `de` };
+    const tGlobal = (0, createTGlobal_1.createTGlobal)({
+        currentLanguage: fakeCurrentLanguageRef,
+        fallbackLanguage: `en`,
+        languages: [`en`, `es`, `fr`, `de`],
+    });
+    it(`tGlobal helper returns a translation`, () => {
+        const translation = {
+            en: `Goodbye`,
+            es: `Adiós`,
+            fr: `Au revoir`,
+            de: `Auf Wiedersehen`,
+        };
+        expect(tGlobal(translation)).toBe(`Auf Wiedersehen`);
+    });
+});

package/dist/cjs/createI18nContext/api/createTPlural.d.ts

@@ -0,0 +1,5 @@
+import { PluralTranslationMap } from "../type";
+export declare const createTPlural: <const Languages extends readonly string[]>({ currentLanguage, fallbackLanguage, }: {
+    currentLanguage: Languages[number];
+    fallbackLanguage: Languages[number];
+}) => (count: number, translations: PluralTranslationMap<Languages[number]>) => string | number | bigint | true | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null | undefined>;

package/dist/cjs/createI18nContext/api/createTPlural.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTPlural = void 0;
+const getPluralTranslation_1 = require("../util/getPluralTranslation");
+const createTPlural = ({ currentLanguage, fallbackLanguage, }) => {
+    /**
+     * Pluralization helper function.
+     * Selects the appropriate translation based on the count provided.
+     */
+    return (count, translations) => {
+        return (0, getPluralTranslation_1.getPluralTranslation)({
+            currentLanguage,
+            fallbackLanguage: fallbackLanguage,
+            count,
+            translations,
+        });
+    };
+};
+exports.createTPlural = createTPlural;

package/dist/cjs/createI18nContext/api/createTPlural.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/createI18nContext/api/createTPlural.test.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const createTPlural_1 = require("./createTPlural");
+describe(`createTPlural`, () => {
+    const tPlural = (0, createTPlural_1.createTPlural)({
+        currentLanguage: `en`,
+        fallbackLanguage: `en`,
+    });
+    it(`tPlural helper returns a translation for specific number`, () => {
+        const count = 2;
+        const translation = tPlural(count, {
+            en: {
+                0: `You have no messages`,
+                one: `You have 1 message`,
+                many: `You have ${count} messages`,
+            },
+            sl: {
+                0: `Nimate sporočil`,
+                one: `Imate 1 sporočilo`,
+                two: `Imate 2 sporočili`,
+                many: `Imate ${count} sporočil`,
+            },
+            pt: {
+                0: `Você não tem mensagens`,
+                one: `Você tem 1 mensagem`,
+                many: `Você tem ${count} mensagens`,
+            },
+        });
+        expect(translation).toBe(`You have 2 messages`);
+    });
+});

package/dist/cjs/createI18nContext/api/createUseI18n.d.ts

@@ -0,0 +1,21 @@
+import { I18nContextType, TranslationMap } from "../type";
+import { Context } from "react";
+export declare const createUseI18n: <const Languages extends readonly string[], const Commons extends Record<string, TranslationMap<Languages[number], string>>>({ I18nContext, languages, fallbackLanguage, commons, }: {
+    I18nContext: Context<I18nContextType<Languages[number]> | null>;
+    languages: Readonly<Languages>;
+    fallbackLanguage: Languages[number];
+    commons?: Commons;
+}) => () => {
+    t: <Value extends import("../type").TranslationValue = import("react").ReactNode>(translation: TranslationMap<Languages[number], Value>) => Value;
+    tPlural: (count: number, translations: import("../type").PluralTranslationMap<Languages[number]>) => string | number | bigint | true | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null | undefined>;
+    setCurrentLanguage: import("react").Dispatch<import("react").SetStateAction<Languages[number]>>;
+    currentLanguage: Languages[number];
+    format: {
+        number: (value: number, options?: Intl.NumberFormatOptions) => string;
+        date: (value: Date | number, options?: Intl.DateTimeFormatOptions) => string;
+        time: (value: Date | number, options?: Intl.DateTimeFormatOptions) => string;
+        currency: (value: number, currency: string, options?: Omit<Intl.NumberFormatOptions, `style` | `currency`>) => string;
+        percentage: (value: number, options?: Omit<Intl.NumberFormatOptions, `style`>) => string;
+    };
+    commons: { [K in keyof Commons]?: string | undefined; };
+};

package/dist/cjs/createI18nContext/api/createUseI18n.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUseI18n = void 0;
+const react_1 = require("react");
+const createT_1 = require("./createT");
+const createTPlural_1 = require("./createTPlural");
+const createFormat_1 = require("./createFormat");
+const createCommons_1 = require("./createCommons");
+const createUseI18n = ({ I18nContext, languages, fallbackLanguage, commons, }) => {
+    /**
+     * Hook to access i18n functions and current language.
+     */
+    return () => {
+        const context = (0, react_1.useContext)(I18nContext);
+        if (!context) {
+            throw new Error(`useI18n must be used inside <Provider>`);
+        }
+        const { currentLanguage, setCurrentLanguage } = context;
+        const t = (0, react_1.useMemo)(() => {
+            return (0, createT_1.createT)({
+                currentLanguage,
+                languages,
+                fallbackLanguage: fallbackLanguage,
+            });
+        }, [currentLanguage]);
+        const tPlural = (0, react_1.useMemo)(() => {
+            return (0, createTPlural_1.createTPlural)({
+                currentLanguage,
+                fallbackLanguage: fallbackLanguage,
+            });
+        }, [currentLanguage]);
+        const format = (0, react_1.useMemo)(() => {
+            return (0, createFormat_1.createFormat)({ currentLanguage });
+        }, [currentLanguage]);
+        const _commons = (0, react_1.useMemo)(() => {
+            return (0, createCommons_1.createCommons)({
+                commons: commons || {},
+                currentLanguage,
+                fallbackLanguage,
+            });
+        }, [currentLanguage]);
+        return {
+            t,
+            tPlural,
+            setCurrentLanguage,
+            currentLanguage,
+            format,
+            commons: _commons,
+        };
+    };
+};
+exports.createUseI18n = createUseI18n;

package/dist/cjs/createI18nContext/api/createUseI18n.test.d.ts

@@ -0,0 +1 @@
+export {};