react-scoped-i18n 0.0.1

package/dist/cjs/index.test.js

@@ -0,0 +1,40 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+describe(`sanity check: createI18nContext is exported`, () => {
+    test(`it should be defined`, async () => {
+        const { createI18nContext } = await Promise.resolve().then(() => __importStar(require(`./index`)));
+        expect(createI18nContext).toBeDefined();
+    });
+});

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

@@ -0,0 +1,7 @@
+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; };
+//# sourceMappingURL=createCommons.d.ts.map

package/dist/esm/createI18nContext/api/createCommons.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createCommons.d.ts","sourceRoot":"","sources":["../../../../src/createI18nContext/api/createCommons.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAIzC,eAAO,MAAM,aAAa,GACxB,KAAK,CAAC,SAAS,SAAS,SAAS,MAAM,EAAE,EACzC,KAAK,CAAC,OAAO,SAAS,MAAM,CAC1B,MAAM,EACN,cAAc,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAC1C,EACD,iDAIC;IACD,OAAO,EAAE,OAAO,CAAC;IACjB,eAAe,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IACnC,gBAAgB,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;CACrC,QACkB,CAAC,0CAqCnB,CAAC"}

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

@@ -0,0 +1,26 @@
+import { IS_DEV } from "../../env";
+import { MISSING_TRANSLATION } from "../const";
+export 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 (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 (IS_DEV) {
+            console.warn(`[i18n] Missing translation for key "${key}" in both current language "${currentLanguage}" and fallback language "${fallbackLanguage}" in "commons".`);
+        }
+        result[key] = MISSING_TRANSLATION;
+    }
+    return result;
+};

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

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

package/dist/esm/createI18nContext/api/createCommons.test.d.ts.map

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

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

@@ -0,0 +1,24 @@
+import { createCommons } from "./createCommons";
+describe(`createCommons`, () => {
+    it(`returns the correct common translations based on current language and fallback`, () => {
+        const result = 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/esm/createI18nContext/api/createFormat.d.ts

@@ -0,0 +1,10 @@
+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;
+};
+//# sourceMappingURL=createFormat.d.ts.map

package/dist/esm/createI18nContext/api/createFormat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createFormat.d.ts","sourceRoot":"","sources":["../../../../src/createI18nContext/api/createFormat.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,GAAI,KAAK,CAAC,SAAS,SAAS,SAAS,MAAM,EAAE,EAAE,sBAErE;IACD,eAAe,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;CACpC;oBAgBmB,MAAM,YAAY,IAAI,CAAC,mBAAmB;kBAQ5C,IAAI,GAAG,MAAM,YAAY,IAAI,CAAC,qBAAqB;kBAQnD,IAAI,GAAG,MAAM,YAAY,IAAI,CAAC,qBAAqB;sBAWxD,MAAM,YACH,MAAM,YACN,IAAI,CAAC,IAAI,CAAC,mBAAmB,EAAE,OAAO,GAAG,UAAU,CAAC;wBAUvD,MAAM,YACH,IAAI,CAAC,IAAI,CAAC,mBAAmB,EAAE,OAAO,CAAC;CAYtD,CAAC"}

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

@@ -0,0 +1,50 @@
+export 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);
+        },
+    };
+};

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

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

package/dist/esm/createI18nContext/api/createFormat.test.d.ts.map

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

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

@@ -0,0 +1,69 @@
+import { createFormat } from "./createFormat";
+describe(`createFormat`, () => {
+    const format = 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/esm/createI18nContext/api/createT.d.ts

@@ -0,0 +1,8 @@
+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;
+//# sourceMappingURL=createT.d.ts.map

package/dist/esm/createI18nContext/api/createT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createT.d.ts","sourceRoot":"","sources":["../../../../src/createI18nContext/api/createT.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAE3D,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAElC,eAAO,MAAM,OAAO,GAAI,KAAK,CAAC,SAAS,SAAS,SAAS,MAAM,EAAE,EAAE,mDAIhE;IACD,eAAe,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IACnC,gBAAgB,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IACpC,SAAS,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC;CAChC,MAGS,KAAK,SAAS,gBAAgB,GAAG,SAAS,EAChD,aAAa,cAAc,oBAAW,KAAK,CAAC,KAC3C,KAQJ,CAAC"}

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

@@ -0,0 +1,11 @@
+import { getTranslation } from "../util/getTranslation";
+export const createT = ({ currentLanguage, fallbackLanguage, languages, }) => {
+    return (translation) => {
+        return getTranslation({
+            translation,
+            language: currentLanguage,
+            languages,
+            fallbackLanguage,
+        });
+    };
+};

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

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

package/dist/esm/createI18nContext/api/createT.test.d.ts.map

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

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

@@ -0,0 +1,21 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { createT } from "./createT";
+describe(`createT`, () => {
+    const t = 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: _jsx(_Fragment, {}),
+            es: `Hola`,
+            fr: `Bonjour`,
+        })).toBe(`Bonjour`);
+    });
+});

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

@@ -0,0 +1,9 @@
+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;
+//# sourceMappingURL=createTGlobal.d.ts.map

package/dist/esm/createI18nContext/api/createTGlobal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTGlobal.d.ts","sourceRoot":"","sources":["../../../../src/createI18nContext/api/createTGlobal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,cAAc,EAAE,MAAM,SAAS,CAAC;AAIrD,eAAO,MAAM,aAAa,GAAI,KAAK,CAAC,QAAQ,SAAS,MAAM,EAAE,mDAI1D;IACD,eAAe,EAAE;QAAE,OAAO,EAAE,QAAQ,CAAA;KAAE,CAAC;IACvC,SAAS,EAAE,SAAS,QAAQ,EAAE,CAAC;IAC/B,gBAAgB,EAAE,QAAQ,CAAC;CAC5B,MAKS,aAAa,cAAc,CAAC,QAAQ,CAAC,uCA0B9C,CAAC"}

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

@@ -0,0 +1,27 @@
+import { isLanguage } from "../type";
+import { getTranslation } from "../util/getTranslation";
+import { IS_DEV } from "../../env";
+export 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 (!isLanguage(currentLanguage.current, languages)) {
+            throw new Error(`tGlobal cannot be invoked before <I18nProvider> is mounted`);
+        }
+        const isValidLanguage = isLanguage(currentLanguage.current, languages);
+        if (!isValidLanguage) {
+            throw new Error(`Invalid current language "${currentLanguage}"`);
+        }
+        if (IS_DEV) {
+            console.info(`[i18n] Friendly reminder: Make sure you are not using "tGlobal" inside React components. Use "useI18n" hook instead. `);
+        }
+        return getTranslation({
+            translation: translation,
+            language: currentLanguage.current,
+            languages,
+            fallbackLanguage: fallbackLanguage,
+        });
+    };
+};

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

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

package/dist/esm/createI18nContext/api/createTGlobal.test.d.ts.map

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

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

@@ -0,0 +1,18 @@
+import { createTGlobal } from "./createTGlobal";
+describe(`createTGlobal`, () => {
+    const fakeCurrentLanguageRef = { current: `de` };
+    const tGlobal = 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/esm/createI18nContext/api/createTPlural.d.ts

@@ -0,0 +1,6 @@
+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>;
+//# sourceMappingURL=createTPlural.d.ts.map

package/dist/esm/createI18nContext/api/createTPlural.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTPlural.d.ts","sourceRoot":"","sources":["../../../../src/createI18nContext/api/createTPlural.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAG/C,eAAO,MAAM,aAAa,GAAI,KAAK,CAAC,SAAS,SAAS,SAAS,MAAM,EAAE,EAAE,wCAGtE;IACD,eAAe,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IACnC,gBAAgB,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;CACrC,MAMG,OAAO,MAAM,EACb,cAAc,oBAAoB,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,yYASxD,CAAC"}

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

@@ -0,0 +1,15 @@
+import { getPluralTranslation } from "../util/getPluralTranslation";
+export const createTPlural = ({ currentLanguage, fallbackLanguage, }) => {
+    /**
+     * Pluralization helper function.
+     * Selects the appropriate translation based on the count provided.
+     */
+    return (count, translations) => {
+        return getPluralTranslation({
+            currentLanguage,
+            fallbackLanguage: fallbackLanguage,
+            count,
+            translations,
+        });
+    };
+};

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

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

package/dist/esm/createI18nContext/api/createTPlural.test.d.ts.map

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

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

@@ -0,0 +1,29 @@
+import { createTPlural } from "./createTPlural";
+describe(`createTPlural`, () => {
+    const tPlural = 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/esm/createI18nContext/api/createUseI18n.d.ts

@@ -0,0 +1,22 @@
+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; };
+};
+//# sourceMappingURL=createUseI18n.d.ts.map

package/dist/esm/createI18nContext/api/createUseI18n.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createUseI18n.d.ts","sourceRoot":"","sources":["../../../../src/createI18nContext/api/createUseI18n.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAC1D,OAAO,EAAE,OAAO,EAAuB,MAAM,OAAO,CAAC;AAMrD,eAAO,MAAM,aAAa,GACxB,KAAK,CAAC,SAAS,SAAS,SAAS,MAAM,EAAE,EACzC,KAAK,CAAC,OAAO,SAAS,MAAM,CAC1B,MAAM,EACN,cAAc,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAC1C,EACD,wDAKC;IACD,WAAW,EAAE,OAAO,CAAC,eAAe,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAChE,SAAS,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC;IAC/B,gBAAgB,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IACpC,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;;;;;;;;;;;;;CAmDA,CAAC"}

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

@@ -0,0 +1,48 @@
+import { useContext, useMemo } from "react";
+import { createT } from "./createT";
+import { createTPlural } from "./createTPlural";
+import { createFormat } from "./createFormat";
+import { createCommons } from "./createCommons";
+export const createUseI18n = ({ I18nContext, languages, fallbackLanguage, commons, }) => {
+    /**
+     * Hook to access i18n functions and current language.
+     */
+    return () => {
+        const context = useContext(I18nContext);
+        if (!context) {
+            throw new Error(`useI18n must be used inside <Provider>`);
+        }
+        const { currentLanguage, setCurrentLanguage } = context;
+        const t = useMemo(() => {
+            return createT({
+                currentLanguage,
+                languages,
+                fallbackLanguage: fallbackLanguage,
+            });
+        }, [currentLanguage]);
+        const tPlural = useMemo(() => {
+            return createTPlural({
+                currentLanguage,
+                fallbackLanguage: fallbackLanguage,
+            });
+        }, [currentLanguage]);
+        const format = useMemo(() => {
+            return createFormat({ currentLanguage });
+        }, [currentLanguage]);
+        const _commons = useMemo(() => {
+            return createCommons({
+                commons: commons || {},
+                currentLanguage,
+                fallbackLanguage,
+            });
+        }, [currentLanguage]);
+        return {
+            t,
+            tPlural,
+            setCurrentLanguage,
+            currentLanguage,
+            format,
+            commons: _commons,
+        };
+    };
+};

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

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

package/dist/esm/createI18nContext/api/createUseI18n.test.d.ts.map

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

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

@@ -0,0 +1,44 @@
+import { createUseI18n } from "./createUseI18n";
+describe(`createUseI18n`, () => {
+    const mockedI18nContext = {};
+    it(`prints console.error if used outside of a provider`, () => {
+        const useI18n = 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(() => createUseI18n({
+            languages: [`en`, `es`],
+            fallbackLanguage: `en`,
+            commons: undefined,
+            I18nContext: mockedI18nContext,
+        })).toBeDefined();
+    });
+    it(`should be initialised with all parameters`, () => {
+        expect(() => createUseI18n({
+            languages: [`en`, `es`],
+            fallbackLanguage: `es`,
+            commons: {
+                accept: {
+                    en: `Accept`,
+                    es: `Aceptar`,
+                },
+            },
+            I18nContext: mockedI18nContext,
+        })).toBeDefined();
+    });
+});

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

@@ -0,0 +1,2 @@
+export declare const MISSING_TRANSLATION = "[MISSING TRANSLATION]";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/createI18nContext/const/index.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,0BAA0B,CAAC"}

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

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

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

@@ -0,0 +1,30 @@
+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;
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/createI18nContext/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAmB,cAAc,EAAE,MAAM,QAAQ,CAAC;AAOzD,wBAAgB,iBAAiB,CAC/B,SAAS,SAAS,SAAS,MAAM,EAAE,EACnC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,EACzE,EACA,SAAS,EACT,gBAAgB,EAChB,OAAO,GACR,EAAE;IACD,SAAS,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC;IAC/B,gBAAgB,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IACpC,OAAO,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;CAC7B;;;;;;;;;;;;;;;;;;;;;;;EAmDA"}

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

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

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

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