react-scoped-i18n 0.0.1

package/dist/esm/createI18nContext/index.integration.test.js

@@ -0,0 +1,39 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * @jest-environment jsdom
+ */
+import { act } from "react";
+import { render, screen } from "@testing-library/react";
+import { createI18nContext } from "./index";
+test(`very basic integration test`, () => {
+    const { I18nProvider, useI18n } = createI18nContext({
+        languages: [`en`, `es`],
+        fallbackLanguage: `en`,
+        commons: {
+            continue: {
+                en: `Continue`,
+                es: `Continuar`,
+            },
+        },
+    });
+    const TestComponent = () => {
+        const { t, currentLanguage, setCurrentLanguage, commons, format } = useI18n();
+        return (_jsxs(_Fragment, { children: [_jsx("h1", { "data-testid": `current-language`, children: currentLanguage }), _jsx("div", { "data-testid": `test-component`, children: t({ en: `Hello`, es: `Hola` }) }), _jsx("button", { "data-testid": `switch-to-english-button`, onClick: () => {
+                        setCurrentLanguage(`en`);
+                    } }), _jsx("div", { "data-testid": `formatted-number`, children: format.number(10000.555, {
+                        maximumFractionDigits: 2,
+                    }) }), _jsx("button", { "data-testid": `continue-button`, children: commons.continue })] }));
+    };
+    render(_jsx(I18nProvider, { initialLanguage: `es`, children: _jsx(TestComponent, {}) }));
+    expect(screen.getByTestId(`current-language`).textContent).toBe(`es`);
+    expect(screen.getByTestId(`test-component`).textContent).toBe(`Hola`);
+    expect(screen.getByTestId(`continue-button`).textContent).toBe(`Continuar`);
+    expect(screen.getByTestId(`formatted-number`).textContent).toBe(`10.000,56`);
+    act(() => {
+        screen.getByTestId(`switch-to-english-button`).click();
+    });
+    expect(screen.getByTestId(`current-language`).textContent).toBe(`en`);
+    expect(screen.getByTestId(`test-component`).textContent).toBe(`Hello`);
+    expect(screen.getByTestId(`continue-button`).textContent).toBe(`Continue`);
+    expect(screen.getByTestId(`formatted-number`).textContent).toBe(`10,000.56`);
+});

package/dist/esm/createI18nContext/index.js

@@ -0,0 +1,42 @@
+import { createContext } from "react";
+import { createI18nProvider } from "./provider/createI18nProvider";
+import { createUseI18n } from "./api/createUseI18n";
+import { createTGlobal } from "./api/createTGlobal";
+import { IS_DEV } from "../env";
+export function createI18nContext({ languages, fallbackLanguage, commons, }) {
+    if (IS_DEV) {
+        if (commons) {
+            Object.freeze(commons);
+        }
+        Object.freeze(languages);
+    }
+    const moduleScopedCurrentLanguageRef = 
+    /**
+     * Module-scoped variable to hold the current language for tGlobal function.
+     * This is updated by the I18nProvider component.
+     * Don't rely on this
+     */
+    { current: fallbackLanguage };
+    if (!fallbackLanguage || !languages.includes(fallbackLanguage)) {
+        throw new Error(`Default language "${fallbackLanguage}" must be one of the supported languages: [${languages.join(`, `)}]`);
+    }
+    const I18nContext = createContext(null);
+    I18nContext.displayName = `I18nContext`;
+    const I18nProvider = createI18nProvider({
+        I18nContext,
+        moduleScopedCurrentLanguageRef,
+        fallbackLanguage,
+    });
+    const useI18n = createUseI18n({
+        I18nContext,
+        languages,
+        fallbackLanguage,
+        commons,
+    });
+    const tGlobal = createTGlobal({
+        languages,
+        currentLanguage: moduleScopedCurrentLanguageRef,
+        fallbackLanguage,
+    });
+    return { I18nProvider, useI18n, tGlobal };
+}

package/dist/esm/createI18nContext/provider/createI18nProvider.d.ts

@@ -0,0 +1,16 @@
+import { Context, ReactNode } from "react";
+import { I18nContextType } from "../type";
+export declare const createI18nProvider: <const Language extends string>({ I18nContext, moduleScopedCurrentLanguageRef, fallbackLanguage, }: {
+    I18nContext: Context<I18nContextType<Language> | null>;
+    moduleScopedCurrentLanguageRef: {
+        current: Language;
+    };
+    fallbackLanguage: Language;
+}) => {
+    ({ children, initialLanguage, }: {
+        children: ReactNode;
+        initialLanguage: Language;
+    }): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+//# sourceMappingURL=createI18nProvider.d.ts.map

package/dist/esm/createI18nContext/provider/createI18nProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createI18nProvider.d.ts","sourceRoot":"","sources":["../../../../src/createI18nContext/provider/createI18nProvider.tsx"],"names":[],"mappings":"AAAA,OAAc,EAAE,OAAO,EAAE,SAAS,EAAuB,MAAM,OAAO,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE1C,eAAO,MAAM,kBAAkB,GAAI,KAAK,CAAC,QAAQ,SAAS,MAAM,EAAE,oEAI/D;IACD,WAAW,EAAE,OAAO,CAAC,eAAe,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,CAAC;IACvD,8BAA8B,EAAE;QAAE,OAAO,EAAE,QAAQ,CAAA;KAAE,CAAC;IACtD,gBAAgB,EAAE,QAAQ,CAAC;CAC5B;qCAII;QACD,QAAQ,EAAE,SAAS,CAAC;QACpB,eAAe,EAAE,QAAQ,CAAC;KAC3B;;CA2BF,CAAC"}

package/dist/esm/createI18nContext/provider/createI18nProvider.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+export const createI18nProvider = ({ I18nContext, moduleScopedCurrentLanguageRef, fallbackLanguage, }) => {
+    const I18nProvider = ({ children, initialLanguage, }) => {
+        const [currentLanguage, setCurrentLanguage] = useState(initialLanguage || fallbackLanguage);
+        useEffect(() => {
+            // Used only for tGlobal function outside React components.
+            // Do not rely on this!
+            moduleScopedCurrentLanguageRef.current = currentLanguage;
+        }, [currentLanguage]);
+        return (_jsx(I18nContext.Provider, { value: {
+                currentLanguage,
+                fallbackLanguage,
+                setCurrentLanguage,
+            }, children: children }));
+    };
+    I18nProvider.displayName = `I18nProvider`;
+    return I18nProvider;
+};

package/dist/esm/createI18nContext/type/index.d.ts

@@ -0,0 +1,20 @@
+import { Dispatch, ReactNode, SetStateAction } from "react";
+export type TranslationValue = ReactNode | string | number;
+export type TranslationMap<Language extends string, Value = TranslationValue> = Record<Language, Value>;
+export type Languages = readonly string[];
+export declare const isLanguage: (language: string, languages: Languages) => language is Languages[number];
+export type I18nContextType<Language extends string> = {
+    currentLanguage: Language;
+    fallbackLanguage: Language;
+    setCurrentLanguage: Dispatch<SetStateAction<Language>>;
+};
+export type PluralTranslation = {
+    negative?: ReactNode;
+    zero?: ReactNode;
+    one?: ReactNode;
+    two?: ReactNode;
+    many: ReactNode;
+    [key: number]: ReactNode;
+};
+export type PluralTranslationMap<Language extends string> = Record<Language, PluralTranslation>;
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/createI18nContext/type/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/createI18nContext/type/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAE5D,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,CAAC;AAE3D,MAAM,MAAM,cAAc,CACxB,QAAQ,SAAS,MAAM,EACvB,KAAK,GAAG,gBAAgB,IACtB,MAAM,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;AAE5B,MAAM,MAAM,SAAS,GAAG,SAAS,MAAM,EAAE,CAAC;AAE1C,eAAO,MAAM,UAAU,GACrB,UAAU,MAAM,EAChB,WAAW,SAAS,KACnB,QAAQ,IAAI,SAAS,CAAC,MAAM,CAE9B,CAAC;AAEF,MAAM,MAAM,eAAe,CAAC,QAAQ,SAAS,MAAM,IAAI;IACrD,eAAe,EAAE,QAAQ,CAAC;IAC1B,gBAAgB,EAAE,QAAQ,CAAC;IAC3B,kBAAkB,EAAE,QAAQ,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,CAAC;CACxD,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,GAAG,CAAC,EAAE,SAAS,CAAC;IAChB,GAAG,CAAC,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,SAAS,CAAC;IAChB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,oBAAoB,CAAC,QAAQ,SAAS,MAAM,IAAI,MAAM,CAChE,QAAQ,EACR,iBAAiB,CAClB,CAAC"}

package/dist/esm/createI18nContext/type/index.js

@@ -0,0 +1,3 @@
+export const isLanguage = (language, languages) => {
+    return languages.includes(language);
+};

package/dist/esm/createI18nContext/type/isLanguage.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=isLanguage.test.d.ts.map

package/dist/esm/createI18nContext/type/isLanguage.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isLanguage.test.d.ts","sourceRoot":"","sources":["../../../../src/createI18nContext/type/isLanguage.test.ts"],"names":[],"mappings":""}

package/dist/esm/createI18nContext/type/isLanguage.test.js

@@ -0,0 +1,14 @@
+import { isLanguage } from "./index";
+describe(`isLanguage`, () => {
+    const languages = [`en`, `es`, `sl`];
+    it(`returns true for supported languages`, () => {
+        expect(isLanguage(`en`, languages)).toBe(true);
+        expect(isLanguage(`es`, languages)).toBe(true);
+        expect(isLanguage(`sl`, languages)).toBe(true);
+    });
+    it(`returns false for unsupported languages`, () => {
+        expect(isLanguage(`fr`, languages)).toBe(false);
+        expect(isLanguage(`de`, languages)).toBe(false);
+        expect(isLanguage(`it`, languages)).toBe(false);
+    });
+});

package/dist/esm/createI18nContext/util/getPluralTranslation.d.ts

@@ -0,0 +1,8 @@
+import { PluralTranslationMap } from "../type";
+export declare const getPluralTranslation: <const Language extends string>({ currentLanguage, fallbackLanguage, count, translations, }: {
+    currentLanguage: Language;
+    fallbackLanguage: Language;
+    count: number;
+    translations: PluralTranslationMap<Language[][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>;
+//# sourceMappingURL=getPluralTranslation.d.ts.map

package/dist/esm/createI18nContext/util/getPluralTranslation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPluralTranslation.d.ts","sourceRoot":"","sources":["../../../../src/createI18nContext/util/getPluralTranslation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAI/C,eAAO,MAAM,oBAAoB,GAAI,KAAK,CAAC,QAAQ,SAAS,MAAM,EAAE,6DAKjE;IACD,eAAe,EAAE,QAAQ,CAAC;IAC1B,gBAAgB,EAAE,QAAQ,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,oBAAoB,CAAC,QAAQ,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC;CACxD,yYA8DA,CAAC"}

package/dist/esm/createI18nContext/util/getPluralTranslation.js

@@ -0,0 +1,44 @@
+import { MISSING_TRANSLATION } from "../const";
+import { IS_DEV } from "../../env";
+export const getPluralTranslation = ({ currentLanguage, fallbackLanguage, count, translations, }) => {
+    if (!translations) {
+        throw new Error(`[i18n] Translations object is undefined or null`);
+    }
+    const targetTranslation = translations[currentLanguage];
+    const defaultTranslation = translations[fallbackLanguage];
+    if (targetTranslation == undefined && defaultTranslation === undefined) {
+        if (IS_DEV) {
+            console.warn(`[i18n] Missing plural translation for language "${currentLanguage}" and for default language "${fallbackLanguage}"`);
+        }
+        return MISSING_TRANSLATION;
+    }
+    if (targetTranslation === undefined) {
+        if (IS_DEV) {
+            console.warn(`[i18n] Missing plural translation for language "${currentLanguage}". Falling back to default language "${fallbackLanguage}"`);
+        }
+    }
+    const translation = targetTranslation || defaultTranslation;
+    const exactMatch = translation[count];
+    if (exactMatch) {
+        return exactMatch;
+    }
+    if (count < 0 && translation.negative) {
+        return translation.negative;
+    }
+    if (count === 0 && translation.zero) {
+        return translation.zero;
+    }
+    if (count === 1 && translation.one) {
+        return translation.one;
+    }
+    if (count === 2 && translation.two) {
+        return translation.two;
+    }
+    if (translation.many) {
+        return translation.many;
+    }
+    if (IS_DEV) {
+        console.warn(`[i18n] No pluralization match found for count "${count}". Please provide appropriate pluralization translations.`);
+    }
+    return MISSING_TRANSLATION;
+};

package/dist/esm/createI18nContext/util/getPluralTranslation.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=getPluralTranslation.test.d.ts.map

package/dist/esm/createI18nContext/util/getPluralTranslation.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPluralTranslation.test.d.ts","sourceRoot":"","sources":["../../../../src/createI18nContext/util/getPluralTranslation.test.ts"],"names":[],"mappings":""}

package/dist/esm/createI18nContext/util/getPluralTranslation.test.js

@@ -0,0 +1,124 @@
+import { getPluralTranslation } from "./getPluralTranslation";
+import { MISSING_TRANSLATION } from "../const";
+describe(`getPluralTranslation`, () => {
+    const fallbackLanguage = `en`;
+    const translations = {
+        en: {
+            negative: `You have a negative count.`,
+            zero: `You have no items.`,
+            one: `You have one item.`,
+            two: `You have two items.`,
+            many: `You have many items.`,
+            42: `You have the perfect count of items!`,
+        },
+        es: {
+            negative: `Tienes un conteo negativo.`,
+            zero: `No tienes artículos.`,
+            one: `Tienes un artículo.`,
+            two: `Tienes dos artículos.`,
+            many: `Tienes muchos artículos.`,
+        },
+    };
+    it(`Error: Translations object is undefined or null`, () => {
+        expect(() => getPluralTranslation({
+            currentLanguage: `es`,
+            fallbackLanguage: fallbackLanguage,
+            count: -5,
+            // @ts-expect-error testing undefined translations
+            translations: undefined,
+        })).toThrow(`[i18n] Translations object is undefined or null`);
+    });
+    it(`returns the correct translation for negative count`, () => {
+        expect(getPluralTranslation({
+            currentLanguage: `es`,
+            fallbackLanguage: fallbackLanguage,
+            count: -5,
+            translations,
+        })).toBe(`Tienes un conteo negativo.`);
+    });
+    it(`returns the correct translation for zero count`, () => {
+        expect(getPluralTranslation({
+            currentLanguage: `en`,
+            fallbackLanguage: fallbackLanguage,
+            count: 0,
+            translations,
+        })).toBe(`You have no items.`);
+    });
+    it(`returns the correct translation for one count`, () => {
+        expect(getPluralTranslation({
+            currentLanguage: `es`,
+            fallbackLanguage: fallbackLanguage,
+            count: 1,
+            translations,
+        })).toBe(`Tienes un artículo.`);
+    });
+    it(`returns the correct translation for two count`, () => {
+        expect(getPluralTranslation({
+            currentLanguage: `en`,
+            fallbackLanguage: fallbackLanguage,
+            count: 2,
+            translations,
+        })).toBe(`You have two items.`);
+    });
+    it(`returns the correct translation for many count`, () => {
+        expect(getPluralTranslation({
+            currentLanguage: `es`,
+            fallbackLanguage: fallbackLanguage,
+            count: 10,
+            translations,
+        })).toBe(`Tienes muchos artículos.`);
+    });
+    it(`returns the correct translation for exact match count`, () => {
+        expect(getPluralTranslation({
+            currentLanguage: `en`,
+            fallbackLanguage: fallbackLanguage,
+            count: 42,
+            translations,
+        })).toBe(`You have the perfect count of items!`);
+    });
+    it(`falls back to default language if translation is missing for current language`, () => {
+        const incompleteTranslations = {
+            en: {
+                one: `You have one item.`,
+            },
+        };
+        expect(getPluralTranslation({
+            currentLanguage: `es`,
+            fallbackLanguage: fallbackLanguage,
+            count: 1,
+            // @ts-expect-error incomplete translation for testing
+            translations: incompleteTranslations,
+        })).toBe(`You have one item.`);
+    });
+    it(`returns ${MISSING_TRANSLATION} if translation is missing for both current and default languages`, () => {
+        const incompleteTranslations = {
+            de: {
+                one: `Tienes un artículo.`,
+            },
+        };
+        expect(getPluralTranslation({
+            currentLanguage: `en`,
+            fallbackLanguage: fallbackLanguage,
+            count: 1,
+            // @ts-expect-error incomplete translation for testing
+            translations: incompleteTranslations,
+        })).toBe(MISSING_TRANSLATION);
+    });
+    it(`Warn: No pluralization match found for count`, () => {
+        const consoleWarnSpy = jest.spyOn(console, `warn`).mockImplementation();
+        const incompleteTranslations = {
+            en: {
+                one: `You have one item.`,
+            },
+        };
+        getPluralTranslation({
+            currentLanguage: `en`,
+            fallbackLanguage: fallbackLanguage,
+            count: 5,
+            // @ts-expect-error incomplete translation for testing
+            translations: incompleteTranslations,
+        });
+        expect(consoleWarnSpy).toHaveBeenCalledWith(`[i18n] No pluralization match found for count "5". Please provide appropriate pluralization translations.`);
+        consoleWarnSpy.mockRestore();
+    });
+});

package/dist/esm/createI18nContext/util/getTranslation.d.ts

@@ -0,0 +1,8 @@
+import { TranslationMap, TranslationValue } from "../type";
+export declare const getTranslation: <const Language extends string, Value = TranslationValue>({ translation, language, languages, fallbackLanguage, }: {
+    translation: TranslationMap<Language, Value>;
+    language: Language;
+    languages: readonly Language[];
+    fallbackLanguage: Language;
+}) => Value;
+//# sourceMappingURL=getTranslation.d.ts.map

package/dist/esm/createI18nContext/util/getTranslation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getTranslation.d.ts","sourceRoot":"","sources":["../../../../src/createI18nContext/util/getTranslation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAI3D,eAAO,MAAM,cAAc,GACzB,KAAK,CAAC,QAAQ,SAAS,MAAM,EAC7B,KAAK,GAAG,gBAAgB,EACxB,yDAKC;IACD,WAAW,EAAE,cAAc,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IAC7C,QAAQ,EAAE,QAAQ,CAAC;IACnB,SAAS,EAAE,SAAS,QAAQ,EAAE,CAAC;IAC/B,gBAAgB,EAAE,QAAQ,CAAC;CAC5B,KAAG,KAwCH,CAAC"}

package/dist/esm/createI18nContext/util/getTranslation.js

@@ -0,0 +1,28 @@
+import { MISSING_TRANSLATION } from "../const";
+import { IS_DEV } from "../../env";
+export const getTranslation = ({ translation, language, languages, fallbackLanguage, }) => {
+    if (!translation) {
+        throw new Error(`[i18n] Translation object is undefined or null`);
+    }
+    if (IS_DEV) {
+        const missing = languages.filter((l) => !(l in translation));
+        if (missing.length > 0) {
+            console.warn(`[i18n] Missing languages: ${missing.join(`, `)} in ${Object.keys(translation)}`);
+        }
+    }
+    const targetTranslation = translation[language];
+    if (targetTranslation !== undefined) {
+        return targetTranslation;
+    }
+    const fallbackTranslation = translation[fallbackLanguage];
+    if (fallbackTranslation !== undefined) {
+        if (IS_DEV) {
+            console.warn(`[i18n] Missing translation for language "${language}". Falling back to default language "${fallbackLanguage}"`);
+        }
+        return fallbackTranslation;
+    }
+    if (IS_DEV) {
+        console.warn(`[i18n] Missing translation for language "${language}" and for default language "${fallbackLanguage}"`);
+    }
+    return MISSING_TRANSLATION;
+};

package/dist/esm/createI18nContext/util/getTranslation.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=getTranslation.test.d.ts.map

package/dist/esm/createI18nContext/util/getTranslation.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getTranslation.test.d.ts","sourceRoot":"","sources":["../../../../src/createI18nContext/util/getTranslation.test.ts"],"names":[],"mappings":""}

package/dist/esm/createI18nContext/util/getTranslation.test.js

@@ -0,0 +1,94 @@
+import { getTranslation } from "./getTranslation";
+import { MISSING_TRANSLATION } from "../const";
+describe(`getTranslation`, () => {
+    const languages = [`en`, `es`, `sl`];
+    const translation = {
+        en: `Hello!`,
+        es: `¡Hola!`,
+        sl: `Živjo!`,
+    };
+    const fallbackLanguage = `es`;
+    it(`returns the correct translation for the specified language`, () => {
+        expect(getTranslation({
+            translation,
+            language: `sl`,
+            languages,
+            fallbackLanguage: fallbackLanguage,
+        })).toBe(`Živjo!`);
+    });
+    it(`falls back to the default language if the specified language translation is missing`, () => {
+        expect(
+        // @ts-expect-error testing missing language
+        getTranslation({
+            translation,
+            languages,
+            fallbackLanguage: fallbackLanguage,
+        })).toBe(`¡Hola!`);
+    });
+    it(`falls back to the default language if the specified language is not supported`, () => {
+        expect(getTranslation({
+            // @ts-expect-error unsupported language
+            translation,
+            language: `fr`,
+            languages,
+            fallbackLanguage: fallbackLanguage,
+        })).toBe(`¡Hola!`);
+    });
+    it(`returns ${MISSING_TRANSLATION} if the translation is missing for both the specified and default languages`, () => {
+        const incompleteTranslation = {
+            en: `Hello!`,
+        };
+        expect(getTranslation({
+            // @ts-expect-error incomplete translation
+            translation: incompleteTranslation,
+            languages,
+            fallbackLanguage: fallbackLanguage,
+            language: `de`,
+        })).toBe(MISSING_TRANSLATION);
+    });
+    it(`Error: Translation object is undefined or null`, () => {
+        expect(() => {
+            getTranslation({
+                // @ts-expect-error testing undefined translation
+                translation: undefined,
+                languages,
+                fallbackLanguage: fallbackLanguage,
+                language: `es`,
+            });
+        }).toThrow(`[i18n] Translation object is undefined or null`);
+    });
+    it(`Warn: Missing languages`, () => {
+        const incompleteLanguages = [`en`, `de`];
+        const consoleWarnSpy = jest.spyOn(console, `warn`).mockImplementation();
+        getTranslation({
+            // @ts-expect-error incomplete languages
+            translation,
+            language: `sl`,
+            languages: incompleteLanguages,
+            fallbackLanguage: fallbackLanguage,
+        });
+        expect(consoleWarnSpy).toHaveBeenCalledWith(`[i18n] Missing languages: de in en,es,sl`);
+    });
+    it(`Warn: Missing translation for language, falling back to default`, () => {
+        const consoleWarnSpy = jest.spyOn(console, `warn`).mockImplementation();
+        getTranslation({
+            // @ts-expect-error testing translation for language
+            translation,
+            language: `pt`,
+            languages,
+            fallbackLanguage: fallbackLanguage,
+        });
+        expect(consoleWarnSpy).toHaveBeenCalledWith(`[i18n] Missing translation for language "pt". Falling back to default language "es"`);
+    });
+    it(`Warn: Missing translation for language and for default language`, () => {
+        const consoleWarnSpy = jest.spyOn(console, `warn`).mockImplementation();
+        getTranslation({
+            // @ts-expect-error testing translation for language and default language
+            translation,
+            language: `ru`,
+            languages,
+            fallbackLanguage: `nl`,
+        });
+        expect(consoleWarnSpy).toHaveBeenCalledWith(`[i18n] Missing translation for language "ru" and for default language "nl"`);
+    });
+});

package/dist/esm/env.d.ts

@@ -0,0 +1,2 @@
+export declare const IS_DEV: boolean;
+//# sourceMappingURL=env.d.ts.map

package/dist/esm/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../src/env.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,MAAM,SACsD,CAAC"}

package/dist/esm/env.js

@@ -0,0 +1,6 @@
+const rawNodeEnv = typeof process !== `undefined` &&
+    process.env &&
+    typeof process.env.NODE_ENV === `string`
+    ? process.env.NODE_ENV
+    : undefined;
+export const IS_DEV = typeof __DEV__ !== `undefined` ? __DEV__ : rawNodeEnv === `development`;

package/dist/esm/index.d.ts

@@ -0,0 +1,2 @@
+export { createI18nContext } from "./createI18nContext";
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/esm/index.js

@@ -0,0 +1 @@
+export { createI18nContext } from "./createI18nContext";

package/dist/esm/index.test.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=index.test.d.ts.map

package/dist/esm/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../src/index.test.ts"],"names":[],"mappings":""}

package/dist/esm/index.test.js

@@ -0,0 +1,7 @@
+"use strict";
+describe(`sanity check: createI18nContext is exported`, () => {
+    test(`it should be defined`, async () => {
+        const { createI18nContext } = await import(`./index`);
+        expect(createI18nContext).toBeDefined();
+    });
+});

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "react-scoped-i18n",
+  "version": "0.0.1",
+  "description": "A scoped internationalization (i18n) library for React applications",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "types": "./dist/esm/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "npm run build:esm && npm run build:cjs",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "prepare": "husky",
+    "lint": "eslint 'src/**/*.{ts,tsx}'",
+    "prettier": "prettier --write 'src/**/*.{ts,tsx,js,jsx,json,css,md}'",
+    "test": "jest --silent",
+    "test:coverage": "jest --coverage --silent",
+    "tsc": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "react": ">=19",
+    "react-dom": ">=19"
+  },
+  "devDependencies": {
+    "@testing-library/react": "^16.3.1",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^25.0.3",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
+    "@typescript-eslint/eslint-plugin": "^8.52.0",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "eslint-plugin-react": "^7.37.5",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "eslint-plugin-unused-imports": "^4.3.0",
+    "husky": "^9.1.7",
+    "jest": "^30.2.0",
+    "jest-environment-jsdom": "^30.2.0",
+    "prettier": "3.5.3",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "ts-jest": "^29.4.5",
+    "typescript": "^5.9.2"
+  }
+}