i18n-keyless-react 1.8.0 → 1.9.1

package/dist/I18nKeylessText.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import { TranslationOptions } from "i18n-keyless-core";
+import { type TranslationOptions } from "i18n-keyless-core";
 export interface I18nKeylessTextProps {
     /**
      * The `children` prop must be a string.

package/dist/I18nKeylessText.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import React, { useEffect, useMemo } from "react";
+import { getTranslation } from "i18n-keyless-core";
 import { useI18nKeyless } from "./store";
 const warnAboutWhitespace = (text) => {
     if (process.env.NODE_ENV === "development" && text !== text.trim()) {
@@ -11,15 +12,14 @@ export const I18nKeylessText = ({ children, replace, context, debug = false, for
     const translations = useI18nKeyless((store) => store.translations);
     const currentLanguage = useI18nKeyless((store) => store.currentLanguage);
     const config = useI18nKeyless((store) => store.config);
-    const translateKey = useI18nKeyless((store) => store.translateKey);
     // Trim the source text immediately
     const sourceText = children.trim();
     useEffect(() => {
         warnAboutWhitespace(children);
     }, [children]);
     useEffect(() => {
-        translateKey(sourceText, { context, debug, forceTemporary });
-        // eslint-disable-next-line react-hooks/exhaustive-deps
+        const store = useI18nKeyless.getState();
+        getTranslation(sourceText, store, { context, debug, forceTemporary });
     }, [sourceText, currentLanguage, context, debug, forceTemporary]);
     const translatedText = currentLanguage === config.languages.primary
         ? sourceText

package/dist/__tests__/I18nKeylessText.test.d.ts

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

package/dist/__tests__/I18nKeylessText.test.js

@@ -0,0 +1,144 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, screen } from "@testing-library/react";
+import { I18nKeylessText } from "../I18nKeylessText";
+import { vi, beforeEach, describe, it, expect, afterEach } from "vitest";
+// Create a mock store before vi.mock call using vi.hoisted
+const mockStore = vi.hoisted(() => {
+    const store = {
+        config: null,
+        currentLanguage: "en",
+        translations: {},
+        uniqueId: null,
+        lastRefresh: null,
+        setTranslations: vi.fn(),
+        setLanguage: vi.fn((lang) => {
+            store.currentLanguage = lang;
+        }),
+    };
+    // Create a function that supports the selector pattern
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const useI18nKeylessMock = (selectorOrStore) => {
+        // If it's a function (selector), call it with the store
+        if (typeof selectorOrStore === "function") {
+            return selectorOrStore(store);
+        }
+        // Otherwise return the store
+        return store;
+    };
+    // Add the getState and setState methods to the mock function
+    useI18nKeylessMock.getState = vi.fn(() => store);
+    useI18nKeylessMock.setState = vi.fn((newState) => Object.assign(store, newState));
+    return useI18nKeylessMock;
+});
+// Mock the store module - this is hoisted to the top of the file
+vi.mock("../store", () => {
+    return {
+        useI18nKeyless: mockStore,
+        // Add any other exports from the store that might be needed
+        getTranslation: vi.fn(),
+    };
+});
+// Mock utils module to avoid errors with getTranslation
+vi.mock("../utils", () => ({
+    getTranslation: vi.fn(),
+    validateLanguage: vi.fn((lang) => lang),
+}));
+describe("I18nKeylessText", () => {
+    // Save original console methods
+    const originalConsoleWarn = console.warn;
+    const originalConsoleLog = console.log;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Mock console methods for testing
+        console.warn = vi.fn();
+        console.log = vi.fn();
+        // Reset store to default state
+        mockStore.setState({
+            translations: {},
+            currentLanguage: "en",
+            config: {
+                languages: {
+                    primary: "en",
+                    supported: ["en", "fr"],
+                },
+            },
+        });
+    });
+    afterEach(() => {
+        // Restore original console methods
+        console.warn = originalConsoleWarn;
+        console.log = originalConsoleLog;
+    });
+    it("renders the original text when language is primary", () => {
+        render(_jsx(I18nKeylessText, { children: "Hello World" }));
+        expect(screen.getByText("Hello World")).toBeInTheDocument();
+    });
+    it("renders translated text when available", () => {
+        mockStore.setState({
+            currentLanguage: "fr",
+            translations: {
+                "Hello World": "Bonjour le monde",
+            },
+        });
+        render(_jsx(I18nKeylessText, { children: "Hello World" }));
+        expect(screen.getByText("Bonjour le monde")).toBeInTheDocument();
+    });
+    it("handles whitespace trimming and warns in development", () => {
+        const originalNodeEnv = process.env.NODE_ENV;
+        process.env.NODE_ENV = "development";
+        render(_jsx(I18nKeylessText, { children: " Hello World " }));
+        expect(screen.getByText("Hello World")).toBeInTheDocument();
+        expect(console.warn).toHaveBeenCalledWith(expect.stringContaining("received text with leading/trailing whitespace"));
+        process.env.NODE_ENV = originalNodeEnv;
+    });
+    it("handles text replacement", () => {
+        render(_jsx(I18nKeylessText, { replace: { "{{name}}": "John" }, children: `Hello {{name}}` }));
+        expect(screen.getByText("Hello John")).toBeInTheDocument();
+    });
+    it("handles context-specific translations", () => {
+        mockStore.setState({
+            currentLanguage: "fr",
+            translations: {
+                Welcome__header: "Bienvenue",
+            },
+        });
+        render(_jsx(I18nKeylessText, { context: "header", children: "Welcome" }));
+        expect(screen.getByText("Bienvenue")).toBeInTheDocument();
+    });
+    it("logs debug information when debug is true", () => {
+        render(_jsx(I18nKeylessText, { debug: true, children: "Hello World" }));
+        expect(console.log).toHaveBeenCalledWith(expect.objectContaining({
+            children: "Hello World",
+            sourceText: "Hello World",
+            currentLanguage: "en",
+        }));
+    });
+    it("handles force temporary translations", () => {
+        const forceTemp = {
+            fr: "Bonjour temporaire",
+        };
+        render(_jsx(I18nKeylessText, { forceTemporary: forceTemp, children: "Hello World" }));
+        expect(screen.getByText("Hello World")).toBeInTheDocument();
+    });
+    it("falls back to source text when translation is missing", () => {
+        mockStore.setState({
+            currentLanguage: "fr",
+            translations: {}, // Empty translations
+        });
+        render(_jsx(I18nKeylessText, { children: "Hello World" }));
+        expect(screen.getByText("Hello World")).toBeInTheDocument();
+    });
+    it("handles multiple replacements in text", () => {
+        render(_jsx(I18nKeylessText, { replace: {
+                "{{name}}": "John",
+                "{{age}}": "30",
+            }, children: `{{name}} is {{age}} years old` }));
+        expect(screen.getByText("John is 30 years old")).toBeInTheDocument();
+    });
+    it("preserves special characters in replacements", () => {
+        render(_jsx(I18nKeylessText, { replace: {
+                "{{special}}": "$@#!",
+            }, children: `Special chars: {{special}}` }));
+        expect(screen.getByText("Special chars: $@#!")).toBeInTheDocument();
+    });
+});

package/dist/__tests__/__mocks__/store.d.ts

@@ -0,0 +1,9 @@
+import { type TranslationStore } from "i18n-keyless-core";
+export declare const store: TranslationStore;
+export declare const mockStore: any;
+export declare const mockStorage: {
+    getItem: import("vitest").Mock<(...args: any[]) => any>;
+    setItem: import("vitest").Mock<(...args: any[]) => any>;
+    removeItem: import("vitest").Mock<(...args: any[]) => any>;
+    clearAll: import("vitest").Mock<(...args: any[]) => any>;
+};

package/dist/__tests__/__mocks__/store.js

@@ -0,0 +1,33 @@
+import { validateLanguage } from "i18n-keyless-core";
+import { vi } from "vitest";
+export const store = {
+    config: null,
+    currentLanguage: "fr",
+    translations: {},
+    uniqueId: null,
+    lastRefresh: null,
+    setTranslations: vi.fn(),
+    setLanguage: vi.fn((lang) => {
+        const validated = validateLanguage(lang, store.config);
+        store.currentLanguage = validated;
+    }),
+};
+// Create a function that supports the selector pattern
+const useI18nKeylessMock = ((selectorOrStore) => {
+    // If it's a function (selector), call it with the store
+    if (typeof selectorOrStore === "function") {
+        return selectorOrStore(store);
+    }
+    // Otherwise return the store
+    return store;
+});
+// Add the getState and setState methods to the mock function
+useI18nKeylessMock.getState = vi.fn(() => store);
+useI18nKeylessMock.setState = vi.fn((newState) => Object.assign(store, newState));
+export const mockStore = useI18nKeylessMock;
+export const mockStorage = {
+    getItem: vi.fn(),
+    setItem: vi.fn(),
+    removeItem: vi.fn(),
+    clearAll: vi.fn(),
+};

package/dist/__tests__/__mocks__/zustand.js

@@ -0,0 +1,70 @@
+"use strict";
+// // __mocks__/zustand.ts
+// import { act } from '@testing-library/react'
+// import type * as ZustandExportedTypes from 'zustand'
+// export * from 'zustand'
+// const { create: actualCreate, createStore: actualCreateStore } =
+//   await vi.importActual<typeof ZustandExportedTypes>('zustand')
+// // a variable to hold reset functions for all stores declared in the app
+// export const storeResetFns = new Set<() => void>()
+// const createUncurried = <T>(
+//   stateCreator: ZustandExportedTypes.StateCreator<T>,
+// ) => {
+//   const store = actualCreate(stateCreator)
+//   const initialState = store.getInitialState()
+//   storeResetFns.add(() => {
+//     store.setState(initialState, true)
+//   })
+//   return store
+// }
+// // when creating a store, we get its initial state, create a reset function and add it in the set
+// export const create = (<T>(
+//   stateCreator: ZustandExportedTypes.StateCreator<T>,
+// ) => {
+//   console.log('zustand create mock')
+//   // to support curried version of create
+//   return typeof stateCreator === 'function'
+//     ? createUncurried(stateCreator)
+//     : createUncurried
+// }) as typeof ZustandExportedTypes.create
+// const createStoreUncurried = <T>(
+//   stateCreator: ZustandExportedTypes.StateCreator<T>,
+// ) => {
+//   const store = actualCreateStore(stateCreator)
+//   const initialState = store.getInitialState()
+//   storeResetFns.add(() => {
+//     store.setState(initialState, true)
+//   })
+//   return store
+// }
+// // when creating a store, we get its initial state, create a reset function and add it in the set
+// export const createStore = (<T>(
+//   stateCreator: ZustandExportedTypes.StateCreator<T>,
+// ) => {
+//   console.log('zustand createStore mock')
+//   // to support curried version of createStore
+//   return typeof stateCreator === 'function'
+//     ? createStoreUncurried(stateCreator)
+//     : createStoreUncurried
+// }) as typeof ZustandExportedTypes.createStore
+// // reset all stores after each test run
+// afterEach(() => {
+//   act(() => {
+//     storeResetFns.forEach((resetFn) => {
+//       resetFn()
+//     })
+//   })
+// })
+// export const createStore = (<T>(stateCreator: ZustandExportedTypes.StateCreator<T>) => {
+//   console.log("zustand createStore mock");
+//   // to support curried version of createStore
+//   return typeof stateCreator === "function" ? createStoreUncurried(stateCreator) : createStoreUncurried;
+// }) as typeof ZustandExportedTypes.createStore;
+// // reset all stores after each test run
+// afterEach(() => {
+//   act(() => {
+//     storeResetFns.forEach((resetFn) => {
+//       resetFn();
+//     });
+//   });
+// });

package/dist/__tests__/setup.d.ts

@@ -0,0 +1 @@
+import "@testing-library/jest-dom";

package/dist/__tests__/setup.js

@@ -0,0 +1,3 @@
+import "@testing-library/jest-dom";
+import { vi } from "vitest";
+vi.mock("zustand");

package/dist/__tests__/store.test.d.ts

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

package/dist/__tests__/store.test.js

@@ -0,0 +1,361 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { act } from "@testing-library/react";
+import { mockStore, mockStorage } from "./__mocks__/store";
+import { useI18nKeyless, init } from "../store";
+import { getTranslation, queue } from "i18n-keyless-core";
+// These vi.mock calls must be at the top level, outside of any function or block
+vi.mock("zustand", () => ({
+    create: () => ({
+        getState: mockStore.getState,
+        setState: mockStore.setState,
+        subscribe: mockStore.subscribe,
+    }),
+}));
+vi.mock("../store", async () => {
+    const actual = await vi.importActual("../store");
+    return {
+        useI18nKeyless: mockStore,
+        useCurrentLanguage: vi.fn(),
+        getTranslation: vi.fn(),
+        setCurrentLanguage: vi.fn(),
+        fetchAllTranslations: vi.fn(),
+        clearI18nKeylessStorage: vi.fn(),
+        init: actual.init,
+    };
+});
+// Mock fetch for API calls
+global.fetch = vi.fn();
+describe("i18n-keyless store", () => {
+    // Save original console methods
+    const originalConsoleError = console.error;
+    const originalConsoleWarn = console.warn;
+    const originalConsoleLog = console.log;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        console.error = vi.fn();
+        console.warn = vi.fn();
+        console.log = vi.fn();
+        useI18nKeyless.setState({ translations: {} });
+        // The store is automatically reset by the zustand mock
+    });
+    afterEach(() => {
+        // Restore original console methods
+        console.error = originalConsoleError;
+        console.warn = originalConsoleWarn;
+        console.log = originalConsoleLog;
+    });
+    describe("init function", () => {
+        it("should throw an error if languages is not provided", async () => {
+            // @ts-expect-error Testing invalid config
+            await expect(init({ storage: mockStorage })).rejects.toThrow("i18n-keyless: languages is required");
+        });
+        it("should throw an error if primary language is not provided", async () => {
+            await expect(
+            // @ts-expect-error Testing invalid config
+            init({ languages: { supported: ["en", "fr"] }, storage: mockStorage })).rejects.toThrow("i18n-keyless: primary is required");
+        });
+        it("should throw an error if storage is not provided", async () => {
+            await expect(
+            // @ts-expect-error Testing invalid config
+            init({ languages: { primary: "en", supported: ["en", "fr"] } })).rejects.toThrow("i18n-keyless: storage is required");
+        });
+        it("should throw an error if no API or custom handlers are provided", async () => {
+            await expect(
+            // @ts-expect-error Testing invalid config
+            init({
+                languages: { primary: "en", supported: ["en", "fr"] },
+                storage: mockStorage,
+            })).rejects.toThrow("i18n-keyless: you didn't provide an API_KEY nor an API_URL nor a handleTranslate + getAllTranslations function");
+        });
+        it("should initialize with API_KEY correctly", async () => {
+            await init({
+                languages: {
+                    primary: "en",
+                    supported: ["en", "fr"],
+                },
+                storage: mockStorage,
+                API_KEY: "test-api-key",
+            });
+            expect(useI18nKeyless.getState().config).toEqual({
+                addMissingTranslations: true,
+                languages: {
+                    fallback: "en",
+                    initWithDefault: "en",
+                    primary: "en",
+                    supported: ["en", "fr"],
+                },
+                storage: mockStorage,
+                API_KEY: "test-api-key",
+            });
+        });
+        it("should initialize with custom handlers correctly", async () => {
+            const handleTranslate = vi.fn();
+            const getAllTranslations = vi.fn();
+            await init({
+                languages: {
+                    primary: "en",
+                    supported: ["en", "fr"],
+                },
+                API_KEY: "test-api-key",
+                storage: mockStorage,
+                handleTranslate,
+                getAllTranslations,
+            });
+            expect(useI18nKeyless.getState().config).toEqual({
+                API_KEY: "test-api-key",
+                addMissingTranslations: true,
+                languages: {
+                    fallback: "en",
+                    initWithDefault: "en",
+                    primary: "en",
+                    supported: ["en", "fr"],
+                },
+                storage: mockStorage,
+                handleTranslate,
+                getAllTranslations,
+            });
+        });
+        it("should add initWithDefault to supported languages if not already included", async () => {
+            await init({
+                languages: {
+                    primary: "en",
+                    supported: ["fr"],
+                    initWithDefault: "en",
+                },
+                API_KEY: "test-api-key",
+                storage: mockStorage,
+            });
+            expect(useI18nKeyless.getState().config?.languages.supported).toContain("en");
+        });
+        it("should call onInit callback with current language", async () => {
+            const onInit = vi.fn().mockImplementation((lang) => lang);
+            const onInitReturned = onInit("fr");
+            await act(async () => {
+                await init({
+                    languages: {
+                        primary: "en",
+                        supported: ["en", "fr"],
+                    },
+                    storage: mockStorage,
+                    API_KEY: "test-api-key",
+                    onInit,
+                });
+            });
+            expect(onInit.mock.calls[0][0]).toBe("fr");
+            expect(onInitReturned).toBe("fr");
+        });
+    });
+    describe("hydration", () => {
+        it("should hydrate from storage correctly", async () => {
+            mockStorage.getItem.mockImplementation((key) => {
+                if (key === "i18n-keyless-current-language")
+                    return "fr";
+                if (key === "i18n-keyless-translations")
+                    return JSON.stringify({ Hello: { fr: "Bonjour" } });
+                return Promise.resolve(null);
+            });
+            await init({
+                languages: {
+                    primary: "en",
+                    supported: ["en", "fr"],
+                },
+                storage: mockStorage,
+                API_KEY: "test-api-key",
+            });
+            expect(useI18nKeyless.getState().currentLanguage).toBe("fr");
+            expect(useI18nKeyless.getState().translations).toEqual({ Hello: { fr: "Bonjour" } });
+        });
+        it("should use initWithDefault when no language is stored", async () => {
+            mockStorage.getItem.mockResolvedValue(null);
+            await init({
+                languages: {
+                    primary: "en",
+                    supported: ["en", "fr"],
+                    initWithDefault: "fr",
+                },
+                storage: mockStorage,
+                API_KEY: "test-api-key",
+            });
+            expect(useI18nKeyless.getState().currentLanguage).toBe("fr");
+        });
+    });
+    describe("Translation functionality", () => {
+        beforeEach(async () => {
+            // Reset store and initialize with basic config
+            await init({
+                languages: {
+                    primary: "en",
+                    supported: ["en", "fr", "es"],
+                },
+                storage: mockStorage,
+                API_KEY: "test-api-key",
+            });
+        });
+        it("should return original text when current language is primary language", () => {
+            useI18nKeyless.setState({ currentLanguage: "en" });
+            const store = useI18nKeyless.getState();
+            const result = getTranslation("Hello World", store);
+            expect(result).toBe("Hello World");
+        });
+        it("should return original text when current language is primary language whatever context there is", () => {
+            useI18nKeyless.setState({ currentLanguage: "en" });
+            const store = useI18nKeyless.getState();
+            const result = getTranslation("Hello World again", store, { context: "whatever" });
+            expect(result).toBe("Hello World again");
+        });
+        it("should handle translations with context", () => {
+            useI18nKeyless.setState({
+                currentLanguage: "fr",
+                translations: {
+                    Welcome__header: "Bienvenue",
+                    "Good bye__footer": "Au revoir",
+                },
+            });
+            const store = useI18nKeyless.getState();
+            const headerResult = getTranslation("Welcome", store, { context: "header" });
+            const footerResult = getTranslation("Good bye", store, { context: "footer" });
+            expect(headerResult).toBe("Bienvenue");
+            expect(footerResult).toBe("Au revoir");
+        });
+        it("forceTemporary should works when no translation is available", () => {
+            useI18nKeyless.setState({ currentLanguage: "fr" });
+            const store = useI18nKeyless.getState();
+            // Mock fetch for API calls
+            global.fetch = vi.fn().mockResolvedValue({
+                json: () => Promise.resolve({ ok: true, data: { translations: {} } }),
+            });
+            const result = getTranslation("Hungry", store, {
+                forceTemporary: {
+                    fr: "J'ai faim",
+                },
+            });
+            // return Hello because translation is not available in fr
+            expect(result).toBe("Hungry");
+            // expect fetch to have been called with the correct params
+            expect(fetch).toHaveBeenCalledWith("https://api.i18n-keyless.com/translate", {
+                body: JSON.stringify({
+                    key: "Hungry",
+                    forceTemporary: {
+                        fr: "J'ai faim",
+                    },
+                    languages: ["en", "fr", "es"],
+                    primaryLanguage: "en",
+                }),
+                headers: {
+                    Authorization: "Bearer test-api-key",
+                    "Content-Type": "application/json",
+                    Version: "1.9.1",
+                    unique_id: "",
+                },
+                method: "POST",
+            });
+        });
+        it("forceTemporary should works when translation is available", () => {
+            useI18nKeyless.setState({ currentLanguage: "fr", translations: { Happiness: "Joie" } });
+            const store = useI18nKeyless.getState();
+            // Mock fetch for API calls
+            global.fetch = vi.fn().mockResolvedValue({
+                json: () => Promise.resolve({ ok: true }),
+            });
+            const result = getTranslation("Happiness", store, {
+                forceTemporary: {
+                    fr: "Joie temporaire",
+                },
+            });
+            // return Joie because translation forced is not there yet
+            expect(result).toBe("Joie");
+            // expect fetch to have been called with the correct params
+            expect(fetch).toHaveBeenCalledWith("https://api.i18n-keyless.com/translate", {
+                body: JSON.stringify({
+                    key: "Happiness",
+                    forceTemporary: {
+                        fr: "Joie temporaire",
+                    },
+                    languages: ["en", "fr", "es"],
+                    primaryLanguage: "en",
+                }),
+                headers: {
+                    Authorization: "Bearer test-api-key",
+                    "Content-Type": "application/json",
+                    Version: "1.9.1",
+                    unique_id: "",
+                },
+                method: "POST",
+            });
+        });
+        it("should queue translation requests when translation is missing", () => {
+            useI18nKeyless.setState({ currentLanguage: "fr" });
+            const store = useI18nKeyless.getState();
+            const queueSpy = vi.spyOn(queue, "add");
+            getTranslation("Missing Translation", store);
+            expect(queueSpy).toHaveBeenCalled();
+        });
+        it("should handle API translation errors gracefully", async () => {
+            useI18nKeyless.setState({ currentLanguage: "fr" });
+            const store = useI18nKeyless.getState();
+            // Mock a failed API call
+            global.fetch = vi.fn().mockRejectedValue(new Error("API Error"));
+            useI18nKeyless.setState({ currentLanguage: "fr" });
+            getTranslation("Test Error", store);
+            // Wait for async queue to process
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            expect(console.error).toHaveBeenCalledWith(expect.stringContaining("i18n-keyless: fetch all translations error:"), new Error("API Error"));
+        });
+        it("should not translate empty strings", () => {
+            useI18nKeyless.setState({ currentLanguage: "fr" });
+            const store = useI18nKeyless.getState();
+            const queueSpy = vi.spyOn(queue, "add");
+            getTranslation("", store);
+            expect(queueSpy).not.toHaveBeenCalled();
+        });
+        it("should handle debug mode logging", async () => {
+            // Clear any previous async operations
+            vi.clearAllMocks();
+            useI18nKeyless.setState({ currentLanguage: "fr" });
+            const store = useI18nKeyless.getState();
+            getTranslation("Debug Test", store, { debug: true });
+            // Wait for any async operations to complete
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            expect(console.log).toHaveBeenCalled();
+        });
+    });
+    describe("Storage operations", () => {
+        it("should handle malformed JSON in storage", async () => {
+            vi.clearAllMocks();
+            mockStorage.getItem.mockImplementation((key) => {
+                if (key === "i18n-keyless-translations")
+                    return "invalid json";
+                return null;
+            });
+            await init({
+                languages: {
+                    primary: "en",
+                    supported: ["en", "fr"],
+                },
+                storage: mockStorage,
+                API_KEY: "test-api-key",
+            });
+            expect(useI18nKeyless.getState().translations).toEqual({});
+        });
+    });
+    describe("Language fallback behavior", () => {
+        it("should use fallback language when current language is not supported", () => {
+            useI18nKeyless.setState({
+                currentLanguage: "fr",
+                translations: {},
+                config: {
+                    languages: {
+                        primary: "en",
+                        supported: ["en", "fr", "es"],
+                        fallback: "es",
+                    },
+                    API_KEY: "test-api-key",
+                    storage: mockStorage,
+                },
+            });
+            useI18nKeyless.getState().setLanguage("pt"); // pt is not supported
+            const store = useI18nKeyless.getState();
+            expect(store.currentLanguage).toBe("es");
+        });
+    });
+});

package/dist/api.d.ts

@@ -0,0 +1,4 @@
+export declare const api: {
+    fetchTranslations: (url: string, options: RequestInit) => Promise<any>;
+    fetchTranslation: (url: string, options: RequestInit) => Promise<any>;
+};