react-scoped-i18n 0.0.1

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const createUseI18n_1 = require("./createUseI18n");
+describe(`createUseI18n`, () => {
+    const mockedI18nContext = {};
+    it(`prints console.error if used outside of a provider`, () => {
+        const useI18n = (0, createUseI18n_1.createUseI18n)({
+            languages: [`en`, `es`],
+            fallbackLanguage: `en`,
+            commons: undefined,
+            I18nContext: mockedI18nContext,
+        });
+        // expect console.error to be called
+        const consoleErrorSpy = jest
+            .spyOn(console, `error`)
+            .mockImplementation(() => { });
+        try {
+            useI18n();
+        }
+        catch (e) {
+            expect(consoleErrorSpy).toHaveBeenCalled(); // eslint-disable-line unused-imports/no-unused-vars
+        }
+        consoleErrorSpy.mockRestore();
+    });
+    it(`can be initialised with only required parameters`, () => {
+        expect(() => (0, createUseI18n_1.createUseI18n)({
+            languages: [`en`, `es`],
+            fallbackLanguage: `en`,
+            commons: undefined,
+            I18nContext: mockedI18nContext,
+        })).toBeDefined();
+    });
+    it(`should be initialised with all parameters`, () => {
+        expect(() => (0, createUseI18n_1.createUseI18n)({
+            languages: [`en`, `es`],
+            fallbackLanguage: `es`,
+            commons: {
+                accept: {
+                    en: `Accept`,
+                    es: `Aceptar`,
+                },
+            },
+            I18nContext: mockedI18nContext,
+        })).toBeDefined();
+    });
+});

package/dist/cjs/createI18nContext/const/index.d.ts

@@ -0,0 +1 @@
+export declare const MISSING_TRANSLATION = "[MISSING TRANSLATION]";

package/dist/cjs/createI18nContext/const/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MISSING_TRANSLATION = void 0;
+exports.MISSING_TRANSLATION = `[MISSING TRANSLATION]`;

package/dist/cjs/createI18nContext/index.d.ts

@@ -0,0 +1,29 @@
+import { TranslationMap } from "./type";
+export declare function createI18nContext<Languages extends readonly string[], Commons extends Record<string, TranslationMap<Languages[number], string>>>({ languages, fallbackLanguage, commons, }: {
+    languages: Readonly<Languages>;
+    fallbackLanguage: Languages[number];
+    commons?: Readonly<Commons>;
+}): {
+    I18nProvider: {
+        ({ children, initialLanguage, }: {
+            children: import("react").ReactNode;
+            initialLanguage: Languages[number];
+        }): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    useI18n: () => {
+        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 Readonly<Commons>]?: string | undefined; };
+    };
+    tGlobal: (translation: TranslationMap<string>) => import("./type").TranslationValue;
+};

package/dist/cjs/createI18nContext/index.integration.test.d.ts

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

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

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

package/dist/cjs/createI18nContext/index.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createI18nContext = createI18nContext;
+const react_1 = require("react");
+const createI18nProvider_1 = require("./provider/createI18nProvider");
+const createUseI18n_1 = require("./api/createUseI18n");
+const createTGlobal_1 = require("./api/createTGlobal");
+const env_1 = require("../env");
+function createI18nContext({ languages, fallbackLanguage, commons, }) {
+    if (env_1.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 = (0, react_1.createContext)(null);
+    I18nContext.displayName = `I18nContext`;
+    const I18nProvider = (0, createI18nProvider_1.createI18nProvider)({
+        I18nContext,
+        moduleScopedCurrentLanguageRef,
+        fallbackLanguage,
+    });
+    const useI18n = (0, createUseI18n_1.createUseI18n)({
+        I18nContext,
+        languages,
+        fallbackLanguage,
+        commons,
+    });
+    const tGlobal = (0, createTGlobal_1.createTGlobal)({
+        languages,
+        currentLanguage: moduleScopedCurrentLanguageRef,
+        fallbackLanguage,
+    });
+    return { I18nProvider, useI18n, tGlobal };
+}

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

@@ -0,0 +1,15 @@
+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;
+};

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createI18nProvider = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const createI18nProvider = ({ I18nContext, moduleScopedCurrentLanguageRef, fallbackLanguage, }) => {
+    const I18nProvider = ({ children, initialLanguage, }) => {
+        const [currentLanguage, setCurrentLanguage] = (0, react_1.useState)(initialLanguage || fallbackLanguage);
+        (0, react_1.useEffect)(() => {
+            // Used only for tGlobal function outside React components.
+            // Do not rely on this!
+            moduleScopedCurrentLanguageRef.current = currentLanguage;
+        }, [currentLanguage]);
+        return ((0, jsx_runtime_1.jsx)(I18nContext.Provider, { value: {
+                currentLanguage,
+                fallbackLanguage,
+                setCurrentLanguage,
+            }, children: children }));
+    };
+    I18nProvider.displayName = `I18nProvider`;
+    return I18nProvider;
+};
+exports.createI18nProvider = createI18nProvider;

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

@@ -0,0 +1,19 @@
+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>;

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLanguage = void 0;
+const isLanguage = (language, languages) => {
+    return languages.includes(language);
+};
+exports.isLanguage = isLanguage;

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

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

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+describe(`isLanguage`, () => {
+    const languages = [`en`, `es`, `sl`];
+    it(`returns true for supported languages`, () => {
+        expect((0, index_1.isLanguage)(`en`, languages)).toBe(true);
+        expect((0, index_1.isLanguage)(`es`, languages)).toBe(true);
+        expect((0, index_1.isLanguage)(`sl`, languages)).toBe(true);
+    });
+    it(`returns false for unsupported languages`, () => {
+        expect((0, index_1.isLanguage)(`fr`, languages)).toBe(false);
+        expect((0, index_1.isLanguage)(`de`, languages)).toBe(false);
+        expect((0, index_1.isLanguage)(`it`, languages)).toBe(false);
+    });
+});

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

@@ -0,0 +1,7 @@
+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>;

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPluralTranslation = void 0;
+const const_1 = require("../const");
+const env_1 = require("../../env");
+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 (env_1.IS_DEV) {
+            console.warn(`[i18n] Missing plural translation for language "${currentLanguage}" and for default language "${fallbackLanguage}"`);
+        }
+        return const_1.MISSING_TRANSLATION;
+    }
+    if (targetTranslation === undefined) {
+        if (env_1.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 (env_1.IS_DEV) {
+        console.warn(`[i18n] No pluralization match found for count "${count}". Please provide appropriate pluralization translations.`);
+    }
+    return const_1.MISSING_TRANSLATION;
+};
+exports.getPluralTranslation = getPluralTranslation;

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

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

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

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const getPluralTranslation_1 = require("./getPluralTranslation");
+const const_1 = require("../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(() => (0, getPluralTranslation_1.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((0, getPluralTranslation_1.getPluralTranslation)({
+            currentLanguage: `es`,
+            fallbackLanguage: fallbackLanguage,
+            count: -5,
+            translations,
+        })).toBe(`Tienes un conteo negativo.`);
+    });
+    it(`returns the correct translation for zero count`, () => {
+        expect((0, getPluralTranslation_1.getPluralTranslation)({
+            currentLanguage: `en`,
+            fallbackLanguage: fallbackLanguage,
+            count: 0,
+            translations,
+        })).toBe(`You have no items.`);
+    });
+    it(`returns the correct translation for one count`, () => {
+        expect((0, getPluralTranslation_1.getPluralTranslation)({
+            currentLanguage: `es`,
+            fallbackLanguage: fallbackLanguage,
+            count: 1,
+            translations,
+        })).toBe(`Tienes un artículo.`);
+    });
+    it(`returns the correct translation for two count`, () => {
+        expect((0, getPluralTranslation_1.getPluralTranslation)({
+            currentLanguage: `en`,
+            fallbackLanguage: fallbackLanguage,
+            count: 2,
+            translations,
+        })).toBe(`You have two items.`);
+    });
+    it(`returns the correct translation for many count`, () => {
+        expect((0, getPluralTranslation_1.getPluralTranslation)({
+            currentLanguage: `es`,
+            fallbackLanguage: fallbackLanguage,
+            count: 10,
+            translations,
+        })).toBe(`Tienes muchos artículos.`);
+    });
+    it(`returns the correct translation for exact match count`, () => {
+        expect((0, getPluralTranslation_1.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((0, getPluralTranslation_1.getPluralTranslation)({
+            currentLanguage: `es`,
+            fallbackLanguage: fallbackLanguage,
+            count: 1,
+            // @ts-expect-error incomplete translation for testing
+            translations: incompleteTranslations,
+        })).toBe(`You have one item.`);
+    });
+    it(`returns ${const_1.MISSING_TRANSLATION} if translation is missing for both current and default languages`, () => {
+        const incompleteTranslations = {
+            de: {
+                one: `Tienes un artículo.`,
+            },
+        };
+        expect((0, getPluralTranslation_1.getPluralTranslation)({
+            currentLanguage: `en`,
+            fallbackLanguage: fallbackLanguage,
+            count: 1,
+            // @ts-expect-error incomplete translation for testing
+            translations: incompleteTranslations,
+        })).toBe(const_1.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.`,
+            },
+        };
+        (0, getPluralTranslation_1.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/cjs/createI18nContext/util/getTranslation.d.ts

@@ -0,0 +1,7 @@
+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;

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTranslation = void 0;
+const const_1 = require("../const");
+const env_1 = require("../../env");
+const getTranslation = ({ translation, language, languages, fallbackLanguage, }) => {
+    if (!translation) {
+        throw new Error(`[i18n] Translation object is undefined or null`);
+    }
+    if (env_1.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 (env_1.IS_DEV) {
+            console.warn(`[i18n] Missing translation for language "${language}". Falling back to default language "${fallbackLanguage}"`);
+        }
+        return fallbackTranslation;
+    }
+    if (env_1.IS_DEV) {
+        console.warn(`[i18n] Missing translation for language "${language}" and for default language "${fallbackLanguage}"`);
+    }
+    return const_1.MISSING_TRANSLATION;
+};
+exports.getTranslation = getTranslation;

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

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

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

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const getTranslation_1 = require("./getTranslation");
+const const_1 = require("../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((0, getTranslation_1.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
+        (0, getTranslation_1.getTranslation)({
+            translation,
+            languages,
+            fallbackLanguage: fallbackLanguage,
+        })).toBe(`¡Hola!`);
+    });
+    it(`falls back to the default language if the specified language is not supported`, () => {
+        expect((0, getTranslation_1.getTranslation)({
+            // @ts-expect-error unsupported language
+            translation,
+            language: `fr`,
+            languages,
+            fallbackLanguage: fallbackLanguage,
+        })).toBe(`¡Hola!`);
+    });
+    it(`returns ${const_1.MISSING_TRANSLATION} if the translation is missing for both the specified and default languages`, () => {
+        const incompleteTranslation = {
+            en: `Hello!`,
+        };
+        expect((0, getTranslation_1.getTranslation)({
+            // @ts-expect-error incomplete translation
+            translation: incompleteTranslation,
+            languages,
+            fallbackLanguage: fallbackLanguage,
+            language: `de`,
+        })).toBe(const_1.MISSING_TRANSLATION);
+    });
+    it(`Error: Translation object is undefined or null`, () => {
+        expect(() => {
+            (0, getTranslation_1.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();
+        (0, getTranslation_1.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();
+        (0, getTranslation_1.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();
+        (0, getTranslation_1.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/cjs/env.d.ts

@@ -0,0 +1 @@
+export declare const IS_DEV: boolean;

package/dist/cjs/env.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IS_DEV = void 0;
+const rawNodeEnv = typeof process !== `undefined` &&
+    process.env &&
+    typeof process.env.NODE_ENV === `string`
+    ? process.env.NODE_ENV
+    : undefined;
+exports.IS_DEV = typeof __DEV__ !== `undefined` ? __DEV__ : rawNodeEnv === `development`;

package/dist/cjs/index.d.ts

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

package/dist/cjs/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createI18nContext = void 0;
+var createI18nContext_1 = require("./createI18nContext");
+Object.defineProperty(exports, "createI18nContext", { enumerable: true, get: function () { return createI18nContext_1.createI18nContext; } });