i18n-keyless-react 1.17.0 → 1.17.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "i18n-keyless-react",
   "private": false,
-  "version": "1.17.0",
+  "version": "1.17.2",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -17,7 +17,7 @@
     "postpublish": "rm -rf ./dist && rm *.tgz"
   },
   "dependencies": {
-    "i18n-keyless-core": "1.17.0",
+    "i18n-keyless-core": "1.17.2",
     "zustand": "^5.0.3"
   },
   "peerDependencies": {
@@ -34,8 +34,9 @@
     "eslint": "^9.9.0",
     "eslint-plugin-react-hooks": "^5.1.0-rc.0",
     "eslint-plugin-react-refresh": "^0.4.9",
-    "happy-dom": "^17.4.4",
+    "happy-dom": "^20.0.11",
     "jsdom": "^26.0.0",
+    "typescript": "^5.9.3",
     "vitest": "^3.1.1"
   }
 }

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

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

package/dist/__tests__/I18nKeylessText.test.js

@@ -1,151 +0,0 @@
-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";
-import { getTranslationCore } from "i18n-keyless-core";
-// Create a mock store before vi.mock call using vi.hoisted
-const mockStore = vi.hoisted(() => {
-    const store = {
-        config: {
-            API_KEY: "any-fucking-key",
-            languages: {
-                primary: "en",
-                supported: ["en"],
-            },
-        },
-        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", async () => {
-    return {
-        useI18nKeyless: mockStore,
-        getTranslation: vi.fn((key, options) => {
-            return getTranslationCore(key, mockStore.getState(), options);
-        }),
-    };
-});
-vi.mock("../utils", () => ({
-    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: {
-                API_KEY: "any-fucking-key",
-                languages: {
-                    primary: "en",
-                    supported: ["en"],
-                },
-            },
-        });
-    });
-    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

@@ -1,9 +0,0 @@
-import { type TranslationStore } from "../../types";
-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

@@ -1,44 +0,0 @@
-import { vi } from "vitest";
-import { validateLanguage } from "../../utils";
-export const store = {
-    config: {
-        API_KEY: "any-fucking-keyk",
-        languages: {
-            primary: "fr",
-            supported: ["fr"],
-        },
-    },
-    currentLanguage: "fr",
-    translations: {},
-    translationsUsage: {},
-    uniqueId: null,
-    lastRefresh: null,
-    setTranslations: vi.fn(),
-    setLanguage: vi.fn((lang) => {
-        const validated = validateLanguage(lang, store.config);
-        store.currentLanguage = validated;
-    }),
-    sendTranslationsUsage: vi.fn(),
-    setTranslationUsage: vi.fn(),
-};
-// 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;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-});
-// 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

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

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

package/dist/__tests__/setup.js

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

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

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

package/dist/__tests__/store.test.js

@@ -1,362 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { act } from "@testing-library/react";
-import packageJson from "../package.json";
-import { mockStore, mockStorage } from "./__mocks__/store";
-import { useI18nKeyless, init } from "../store";
-import { getTranslationCore, 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(),
-        getTranslationCore: vi.fn(),
-        setCurrentLanguage: vi.fn(),
-        getAllTranslationsFromLanguage: 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 = getTranslationCore("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 = getTranslationCore("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 = getTranslationCore("Welcome", store, { context: "header" });
-            const footerResult = getTranslationCore("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 = getTranslationCore("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: packageJson.version,
-                    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 = getTranslationCore("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: packageJson.version,
-                    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");
-            getTranslationCore("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" });
-            getTranslationCore("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");
-            getTranslationCore("", 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();
-            getTranslationCore("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/package.json

@@ -1,41 +0,0 @@
-{
-    "name": "i18n-keyless-react",
-    "private": false,
-    "version": "1.17.0",
-    "type": "module",
-    "main": "./dist/index.js",
-    "module": "./dist/index.js",
-    "types": "./dist/index.d.ts",
-    "files": [
-        "dist"
-    ],
-    "scripts": {
-        "prepublishOnly": "rm -rf ./dist && tsc --project tsconfig.json && npm run test && npm pack",
-        "test": "vitest run",
-        "test:watch": "vitest",
-        "test:coverage": "vitest run --coverage",
-        "postpublish": "rm -rf ./dist && rm *.tgz"
-    },
-    "dependencies": {
-        "i18n-keyless-core": "1.17.0",
-        "zustand": "^5.0.3"
-    },
-    "peerDependencies": {
-        "react": ">=18.0.0"
-    },
-    "devDependencies": {
-        "@eslint/js": "^9.9.0",
-        "@testing-library/jest-dom": "^6.6.3",
-        "@testing-library/react": "^16.2.0",
-        "@types/node": "^22.5.5",
-        "@types/react": "^19.0.8",
-        "@vitejs/plugin-react": "^4.3.4",
-        "@vitest/coverage-v8": "^3.1.1",
-        "eslint": "^9.9.0",
-        "eslint-plugin-react-hooks": "^5.1.0-rc.0",
-        "eslint-plugin-react-refresh": "^0.4.9",
-        "happy-dom": "^17.4.4",
-        "jsdom": "^26.0.0",
-        "vitest": "^3.1.1"
-    }
-}