i18n-keyless-react 1.10.5 → 1.10.7

package/dist/core/api.d.ts

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

package/dist/core/api.js

@@ -0,0 +1,23 @@
+export const api = {
+    fetchTranslation: async (url, options) => {
+        return fetch(url, options)
+            .then((res) => res.json())
+            .catch((err) => {
+            return { ok: false, error: err.message };
+        });
+    },
+    fetchTranslationsForOneLanguage: async (url, options) => {
+        return fetch(url, options)
+            .then((res) => res.json())
+            .catch((err) => {
+            return { ok: false, error: err.message };
+        });
+    },
+    fetchAllTranslationsForAllLanguages: async (url, options) => {
+        return fetch(url, options)
+            .then((res) => res.json())
+            .catch((err) => {
+            return { ok: false, error: err.message };
+        });
+    },
+};

package/dist/core/index.d.ts

@@ -0,0 +1,2 @@
+export type { Lang, PrimaryLang, Translations, HandleTranslateFunction, GetAllTranslationsFunction, GetAllTranslationsForAllLanguagesFunction, LanguagesConfig, LastRefresh, UniqueId, I18nKeylessRequestBody, I18nKeylessResponse, I18nKeylessAllTranslationsResponse, FetchTranslationParams, TranslationOptions, } from "./types";
+export { getTranslationCore, getAllTranslationsFromLanguage, queue } from "./service";

package/dist/core/index.js

@@ -0,0 +1 @@
+export { getTranslationCore, getAllTranslationsFromLanguage, queue } from "./service";

package/dist/core/my-pqueue.d.ts

@@ -0,0 +1,24 @@
+type Task<T> = () => Promise<T>;
+declare class EventEmitter {
+    private events;
+    on(event: string, callback: () => void): void;
+    off(event: string, callback: () => void): void;
+    emit(event: string): void;
+}
+export default class MyPQueue extends EventEmitter {
+    private queue;
+    private pending;
+    private readonly concurrency;
+    private processing;
+    constructor(options?: {
+        concurrency?: number;
+    });
+    add<T>(task: Task<T>, options?: {
+        priority?: number;
+        id?: string;
+    }): Promise<T>;
+    private processNext;
+    get size(): number;
+    get isPaused(): boolean;
+}
+export {};

package/dist/core/my-pqueue.js

@@ -0,0 +1,108 @@
+// https://github.com/sindresorhus/p-queue/issues/145#issuecomment-882068004
+// p-queu import is broken, so here is the smalle implementation of it
+class EventEmitter {
+    constructor() {
+        Object.defineProperty(this, "events", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+    }
+    on(event, callback) {
+        if (!this.events[event]) {
+            this.events[event] = [];
+        }
+        this.events[event].push(callback);
+    }
+    off(event, callback) {
+        if (!this.events[event])
+            return;
+        this.events[event] = this.events[event].filter((cb) => cb !== callback);
+    }
+    emit(event) {
+        if (!this.events[event])
+            return;
+        this.events[event].forEach((callback) => callback());
+    }
+}
+export default class MyPQueue extends EventEmitter {
+    constructor(options = {}) {
+        super();
+        Object.defineProperty(this, "queue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "pending", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "concurrency", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "processing", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        this.concurrency = options.concurrency ?? Infinity;
+    }
+    add(task, options = {}) {
+        const { priority = 0, id = String(Date.now()) } = options;
+        // If task with same ID exists, return its promise
+        const existingTask = this.queue.find((item) => item.id === id);
+        if (existingTask) {
+            return existingTask.task();
+        }
+        return new Promise((resolve, reject) => {
+            const wrappedTask = async () => {
+                try {
+                    const result = await task();
+                    resolve(result);
+                    return result;
+                }
+                catch (error) {
+                    reject(error);
+                    throw error;
+                }
+                finally {
+                    this.pending--;
+                    this.processNext();
+                }
+            };
+            this.queue.push({ task: wrappedTask, priority, id });
+            this.queue.sort((a, b) => b.priority - a.priority);
+            this.processNext();
+        });
+    }
+    async processNext() {
+        if (this.processing)
+            return;
+        this.processing = true;
+        while (this.queue.length > 0 && this.pending < this.concurrency) {
+            const task = this.queue.shift();
+            if (task) {
+                this.pending++;
+                task.task().catch(() => { });
+            }
+        }
+        this.processing = false;
+        if (this.queue.length === 0 && this.pending === 0) {
+            this.emit("empty");
+        }
+    }
+    get size() {
+        return this.queue.length;
+    }
+    get isPaused() {
+        return false;
+    }
+}

package/dist/core/package.json

@@ -0,0 +1,22 @@
+{
+    "name": "i18n-keyless-core",
+    "private": false,
+    "version": "1.10.7",
+    "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 pack",
+        "test": "echo 'no test for core'",
+        "postpublish": "rm -rf ./dist && rm *.tgz"
+    },
+    "devDependencies": {
+        "@types/node": "^22.5.5",
+        "@types/react": "^19.0.8",
+        "@types/react-dom": "^19.0.3"
+    }
+}

package/dist/core/service.d.ts

@@ -0,0 +1,27 @@
+import type { Lang, TranslationOptions, I18nKeylessResponse, FetchTranslationParams } from "./types";
+import MyPQueue from "./my-pqueue";
+export declare const queue: MyPQueue;
+/**
+ * Gets a translation for the specified key from the store
+ * @param key - The translation key (text in primary language)
+ * @param store - The translation store containing translations and config
+ * @param options - Optional parameters for translation retrieval
+ * @returns The translated text or the original key if not found
+ * @throws Error if config is not initialized
+ */
+export declare function getTranslationCore(key: string, store: FetchTranslationParams, options?: TranslationOptions): string;
+/**
+ * Queues a key for translation if not already translated
+ * @param key - The text to translate
+ * @param store - The translation store
+ * @param options - Optional parameters for the translation process
+ * @throws Error if config is not initialized
+ */
+export declare function translateKey(key: string, store: FetchTranslationParams, options?: TranslationOptions): void;
+/**
+ * Fetches all translations for a target language
+ * @param targetLanguage - The language code to fetch translations for
+ * @param store - The translation store
+ * @returns Promise resolving to the translation response or void if failed
+ */
+export declare function getAllTranslationsFromLanguage(targetLanguage: Lang, store: FetchTranslationParams): Promise<I18nKeylessResponse | void>;

package/dist/core/service.js

@@ -0,0 +1,163 @@
+import MyPQueue from "./my-pqueue";
+import packageJson from "./package.json";
+import { api } from "./api";
+export const queue = new MyPQueue({ concurrency: 5 });
+/**
+ * Gets a translation for the specified key from the store
+ * @param key - The translation key (text in primary language)
+ * @param store - The translation store containing translations and config
+ * @param options - Optional parameters for translation retrieval
+ * @returns The translated text or the original key if not found
+ * @throws Error if config is not initialized
+ */
+export function getTranslationCore(key, store, options) {
+    const currentLanguage = store.currentLanguage;
+    const config = store.config;
+    const translations = store.translations;
+    if (!config.API_KEY) {
+        throw new Error("i18n-keyless: config is not initialized");
+    }
+    if (currentLanguage === config.languages.primary) {
+        return key;
+    }
+    if (options?.forceTemporary?.[currentLanguage]) {
+        translateKey(key, store, options);
+    }
+    const context = options?.context;
+    const translation = context ? translations[`${key}__${context}`] : translations[key];
+    if (!translation) {
+        translateKey(key, store, options);
+    }
+    return translation || key;
+}
+const translating = {};
+/**
+ * Queues a key for translation if not already translated
+ * @param key - The text to translate
+ * @param store - The translation store
+ * @param options - Optional parameters for the translation process
+ * @throws Error if config is not initialized
+ */
+export function translateKey(key, store, options) {
+    const currentLanguage = store.currentLanguage;
+    const config = store.config;
+    const translations = store.translations;
+    const uniqueId = store.uniqueId;
+    if (!config.API_KEY) {
+        throw new Error("i18n-keyless: config is not initialized");
+    }
+    const context = options?.context;
+    const debug = options?.debug;
+    // if (key.length > 280) {
+    //   console.error("i18n-keyless: Key length exceeds 280 characters limit:", key);
+    //   return;
+    // }
+    if (!key) {
+        return;
+    }
+    if (debug) {
+        console.log("translateKey", key, context, debug);
+    }
+    const forceTemporaryLang = options?.forceTemporary?.[currentLanguage];
+    const translation = context ? translations[`${key}__${context}`] : translations[key];
+    if (translation && !forceTemporaryLang) {
+        if (debug) {
+            console.log("translation exists", `${key}__${context}`);
+        }
+        return;
+    }
+    queue.add(async () => {
+        try {
+            if (translating[key]) {
+                return;
+            }
+            else {
+                translating[key] = true;
+            }
+            if (config.handleTranslate) {
+                await config.handleTranslate?.(key);
+            }
+            else {
+                const body = {
+                    key,
+                    context,
+                    forceTemporary: options?.forceTemporary,
+                    languages: config.languages.supported,
+                    primaryLanguage: config.languages.primary,
+                };
+                const apiUrl = config.API_URL || "https://api.i18n-keyless.com";
+                const url = `${apiUrl}/translate`;
+                if (debug) {
+                    console.log("fetching translation", url, body);
+                }
+                const response = await api
+                    .fetchTranslation(url, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${config.API_KEY}`,
+                        unique_id: uniqueId || "",
+                        Version: packageJson.version,
+                    },
+                    body: JSON.stringify(body),
+                })
+                    .then((res) => res);
+                if (debug) {
+                    console.log("response", response);
+                }
+                if (response.message) {
+                    console.warn("i18n-keyless: ", response.message);
+                }
+            }
+            translating[key] = false;
+            return;
+        }
+        catch (error) {
+            console.error("i18n-keyless: Error translating key:", error);
+            translating[key] = false;
+        }
+    }, { priority: 1, id: key });
+}
+/**
+ * Fetches all translations for a target language
+ * @param targetLanguage - The language code to fetch translations for
+ * @param store - The translation store
+ * @returns Promise resolving to the translation response or void if failed
+ */
+export async function getAllTranslationsFromLanguage(targetLanguage, store) {
+    const config = store.config;
+    const lastRefresh = store.lastRefresh;
+    const uniqueId = store.uniqueId;
+    if (!config.API_KEY) {
+        console.error("i18n-keyless: No config found");
+        return;
+    }
+    // if (config.languages.primary === targetLanguage) {
+    //   return;
+    // }
+    try {
+        const response = config.getAllTranslations
+            ? await config.getAllTranslations()
+            : await api
+                .fetchTranslationsForOneLanguage(`${config.API_URL || "https://api.i18n-keyless.com"}/translate/${targetLanguage}?last_refresh=${lastRefresh}`, {
+                method: "GET",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${config.API_KEY}`,
+                    Version: packageJson.version,
+                    unique_id: uniqueId || "",
+                },
+            })
+                .then((res) => res);
+        if (!response.ok) {
+            throw new Error(response.error);
+        }
+        if (response.message) {
+            console.warn("i18n-keyless: ", response.message);
+        }
+        return response;
+    }
+    catch (error) {
+        console.error("i18n-keyless: fetch all translations error:", error);
+    }
+}

package/dist/core/types.d.ts

@@ -0,0 +1,94 @@
+export type PrimaryLang = "fr" | "en";
+export type Lang = "fr" | "en" | "nl" | "it" | "de" | "es" | "pl" | "pt" | "ro" | "sv" | "tr" | "ja" | "cn" | "ru" | "ko" | "ar";
+export type Translations = Record<string, string>;
+export type HandleTranslateFunction = (key: string) => Promise<{
+    ok: boolean;
+    message: string;
+}>;
+export type GetAllTranslationsFunction = () => Promise<I18nKeylessResponse>;
+export type GetAllTranslationsForAllLanguagesFunction = () => Promise<I18nKeylessAllTranslationsResponse>;
+export type LastRefresh = string | null;
+export type UniqueId = string | null;
+export type LanguagesConfig = {
+    /**
+     * the language used by the developer
+     */
+    primary: PrimaryLang;
+    /**
+     * the languages supported for the user.
+     * For now we support:
+     * fr, nl, it, de, es, pl, pt, ro, sv, tr, ja, cn, ru, ko, ar
+     *
+     * If you need more, please reach out to @ambroselli_io on X/Twitter or by mail at arnaud.ambroselli.io@gmail.com
+     */
+    supported: Lang[];
+    /**
+     * if the user's langauge is not supported, the fallback language will be used
+     */
+    fallback?: Lang;
+    /**
+     * the language to use when the app is initialized
+     */
+    initWithDefault?: Lang;
+};
+export type TranslationOptions = {
+    /**
+     * The context of the translation.
+     * Useful for ambiguous translations, like "8 heures" in French could be "8 AM" or "8 hours".
+     * You'll find it useful when it occurs to you, don't worry :)
+     */
+    context?: string;
+    /**
+     * Could be helpful if something weird happens with this particular key.
+     */
+    debug?: boolean;
+    /**
+     * If the proposed translation from AI is not satisfactory,
+     * you can use this field to setup your own translation.
+     * You can leave it there forever, or remove it once your translation is saved.
+     */
+    forceTemporary?: Partial<Record<Lang, string>>;
+};
+export interface I18nKeylessRequestBody {
+    key: string;
+    context?: string;
+    forceTemporary?: TranslationOptions["forceTemporary"];
+    languages: LanguagesConfig["supported"];
+    primaryLanguage: LanguagesConfig["primary"];
+}
+export interface I18nKeylessResponse {
+    ok: boolean;
+    data: {
+        translations: Translations;
+        uniqueId: UniqueId;
+        lastRefresh: LastRefresh;
+    };
+    error: string;
+    message: string;
+}
+export interface I18nKeylessAllTranslationsResponse {
+    ok: boolean;
+    data: {
+        translations: Record<Lang, Translations>;
+        uniqueId: UniqueId;
+        lastRefresh: LastRefresh;
+    };
+    error: string;
+    message: string;
+}
+export type FetchTranslationParams = {
+    uniqueId: UniqueId;
+    lastRefresh: LastRefresh;
+    currentLanguage: Lang;
+    config: {
+        API_KEY: string;
+        API_URL?: string;
+        languages: LanguagesConfig;
+        addMissingTranslations?: boolean;
+        debug?: boolean;
+        handleTranslate?: HandleTranslateFunction;
+        getAllTranslations?: GetAllTranslationsFunction;
+        getAllTranslationsForAllLanguages?: GetAllTranslationsForAllLanguagesFunction;
+    };
+    translations: Translations;
+};

package/dist/{__tests__ → react/__tests__}/I18nKeylessText.test.js

@@ -6,7 +6,13 @@ import { getTranslationCore } from "i18n-keyless-core";
 // Create a mock store before vi.mock call using vi.hoisted
 const mockStore = vi.hoisted(() => {
     const store = {
-        config: null,
+        config: {
+            API_KEY: "any-fucking-key",
+            languages: {
+                primary: "en",
+                supported: ["en"],
+            },
+        },
         currentLanguage: "en",
         translations: {},
         uniqueId: null,
@@ -57,9 +63,10 @@ describe("I18nKeylessText", () => {
             translations: {},
             currentLanguage: "en",
             config: {
+                API_KEY: "any-fucking-key",
                 languages: {
                     primary: "en",
-                    supported: ["en", "fr"],
+                    supported: ["en"],
                 },
             },
         });

package/dist/{__tests__ → react/__tests__}/__mocks__/store.d.ts

@@ -1,4 +1,4 @@
-import { type TranslationStore } from "i18n-keyless-core";
+import { type TranslationStore } from "../../types";
 export declare const store: TranslationStore;
 export declare const mockStore: any;
 export declare const mockStorage: {

package/dist/{__tests__ → react/__tests__}/__mocks__/store.js

@@ -1,7 +1,13 @@
-import { validateLanguage } from "i18n-keyless-core";
 import { vi } from "vitest";
+import { validateLanguage } from "../../utils";
 export const store = {
-    config: null,
+    config: {
+        API_KEY: "any-fucking-keyk",
+        languages: {
+            primary: "fr",
+            supported: ["fr"],
+        },
+    },
     currentLanguage: "fr",
     translations: {},
     uniqueId: null,
@@ -13,6 +19,7 @@ export const store = {
     }),
 };
 // 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") {
@@ -20,6 +27,7 @@ const useI18nKeylessMock = ((selectorOrStore) => {
     }
     // 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);

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

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

package/dist/react/index.d.ts

@@ -0,0 +1,6 @@
+export { I18nKeylessText } from "./I18nKeylessText";
+export { init, setCurrentLanguage, useCurrentLanguage, getTranslation } from "./store";
+export { clearI18nKeylessStorage, validateLanguage } from "./utils";
+export type { I18nKeylessTextProps } from "./I18nKeylessText";
+export { type I18nConfig, type TranslationStoreState, type TranslationOptions, type TranslationStore } from "./types";
+export { type Lang, type PrimaryLang, type Translations, type I18nKeylessRequestBody, type I18nKeylessResponse, getAllTranslationsFromLanguage, queue, } from "i18n-keyless-core";

package/dist/react/index.js

@@ -0,0 +1,4 @@
+export { I18nKeylessText } from "./I18nKeylessText";
+export { init, setCurrentLanguage, useCurrentLanguage, getTranslation } from "./store";
+export { clearI18nKeylessStorage, validateLanguage } from "./utils";
+export { getAllTranslationsFromLanguage, queue, } from "i18n-keyless-core";

package/dist/{package.json → react/package.json}

@@ -1,7 +1,7 @@
 {
     "name": "i18n-keyless-react",
     "private": false,
-    "version": "1.10.5",
+    "version": "1.10.7",
     "type": "module",
     "main": "./dist/index.js",
     "module": "./dist/index.js",
@@ -13,7 +13,8 @@
         "prepublishOnly": "rm -rf ./dist && tsc --project tsconfig.json && npm run test && npm pack",
         "test": "vitest run",
         "test:watch": "vitest",
-        "test:coverage": "vitest run --coverage"
+        "test:coverage": "vitest run --coverage",
+        "postpublish": "rm -rf ./dist && rm *.tgz"
     },
     "dependencies": {
         "i18n-keyless-core": "latest",

package/dist/{store.d.ts → react/store.d.ts}

@@ -1,4 +1,5 @@
-import { type I18nConfig, type Lang, type TranslationStore, type TranslationOptions } from "i18n-keyless-core";
+import { type Lang, type TranslationOptions } from "i18n-keyless-core";
+import { type I18nConfig, type TranslationStore } from "./types";
 export declare const useI18nKeyless: import("zustand").UseBoundStore<import("zustand").StoreApi<TranslationStore>>;
 /**
  * Initializes the i18n configuration with defaults and validation
@@ -6,7 +7,7 @@ export declare const useI18nKeyless: import("zustand").UseBoundStore<import("zus
  * @returns The validated and completed configuration
  * @throws Error if required configuration properties are missing
  */
-export declare function init(newConfig: Omit<I18nConfig, "getAllTranslationsForAllLanguages">): Promise<void>;
+export declare function init(newConfig: I18nConfig): Promise<void>;
 export declare function useCurrentLanguage(): Lang | null;
 export declare function getTranslation(key: string, options?: TranslationOptions): string;
 export declare function setCurrentLanguage(lang: I18nConfig["languages"]["supported"][number]): void;

package/dist/{store.js → react/store.js}

@@ -1,23 +1,32 @@
-import { queue, getAllTranslationsFromLanguage, validateLanguage, getTranslationCore, } from "i18n-keyless-core";
+import { queue, getAllTranslationsFromLanguage, getTranslationCore, } from "i18n-keyless-core";
 import { create } from "zustand";
-import { storeKeys, setItem, getItem, clearI18nKeylessStorage } from "./utils";
+import { storeKeys, setItem, getItem, clearI18nKeylessStorage, validateLanguage } from "./utils";
 queue.on("empty", () => {
     // when each word is translated, fetch the translations for the current language
     const store = useI18nKeyless.getState();
-    getAllTranslationsFromLanguage(store.currentLanguage, store).then(store.setTranslations);
+    if (store.config) {
+        getAllTranslationsFromLanguage(store.currentLanguage, store).then(store.setTranslations);
+    }
 });
 export const useI18nKeyless = create((set, get) => ({
     uniqueId: null,
     lastRefresh: null,
     translations: {},
     currentLanguage: "fr",
-    config: null,
+    config: {
+        API_KEY: "",
+        languages: {
+            primary: "fr",
+            supported: ["fr"],
+        },
+        storage: undefined,
+    },
     setTranslations: (response) => {
         if (!response?.ok) {
             return;
         }
         const config = get().config;
-        if (!config) {
+        if (!config.API_KEY) {
             throw new Error(`i18n-keyless: config is not initialized setting translations`);
         }
         const newTranslations = response.data.translations;
@@ -38,12 +47,12 @@ export const useI18nKeyless = create((set, get) => ({
         }
     },
     setLanguage: async (lang) => {
-        const config = get().config;
-        if (!config) {
+        const store = get();
+        if (!store.config) {
             throw new Error(`i18n-keyless: config is not initialized setting translations`);
         }
-        const debug = config.debug;
-        const validatedLang = validateLanguage(lang, config);
+        const debug = store.config.debug;
+        const validatedLang = validateLanguage(lang, store.config);
         if (validatedLang !== lang) {
             if (debug)
                 console.log("i18n-keyless: language", lang, "is not supported, fallback to", validatedLang);
@@ -53,18 +62,18 @@ export const useI18nKeyless = create((set, get) => ({
                 console.log("i18n-keyless: setLanguage", lang);
         }
         set({ currentLanguage: validatedLang });
-        if (config.storage) {
-            setItem(storeKeys.currentLanguage, validatedLang, config.storage);
+        if (store.config.storage) {
+            setItem(storeKeys.currentLanguage, validatedLang, store.config.storage);
         }
         // Only fetch translations if the new language is not the primary language
-        if (lang !== config.languages.primary) {
-            await getAllTranslationsFromLanguage(lang, get()).then(get().setTranslations);
+        if (lang !== store.config.languages.primary) {
+            await getAllTranslationsFromLanguage(lang, store).then(store.setTranslations);
         }
     },
 }));
 async function hydrate() {
     const config = useI18nKeyless.getState().config;
-    if (!config) {
+    if (!config.API_KEY) {
         throw new Error(`i18n-keyless: config is not initialized hydrating`);
     }
     const storage = config.storage;
@@ -139,6 +148,9 @@ export async function init(newConfig) {
         // default to true
         newConfig.addMissingTranslations = true;
     }
+    if (!newConfig.API_KEY) {
+        throw new Error(`i18n-keyless: API_KEY is required`);
+    }
     useI18nKeyless.setState({ config: newConfig });
     await hydrate();
     const currentLanguage = useI18nKeyless.getState().currentLanguage;
@@ -159,7 +171,7 @@ export async function clearI18nKeylessStorageAndStore() {
     useI18nKeyless.setState({
         translations: {},
         currentLanguage: "fr",
-        config: null,
+        config: undefined,
     });
     const config = useI18nKeyless.getState().config;
     if (config?.storage) {

package/dist/react/types.d.ts

@@ -0,0 +1,154 @@
+import type { I18nKeylessResponse, Lang, Translations, HandleTranslateFunction, GetAllTranslationsFunction, UniqueId, LastRefresh, LanguagesConfig } from "i18n-keyless-core";
+type GetStorageFunction = (key: string) => string | null | undefined | Promise<string | null | undefined>;
+type SetStorageFunction = (key: string, value: string) => void | Promise<void>;
+type RemoveStorageFunction = (key: string) => void | Promise<void>;
+type ClearStorageFunction = () => void | Promise<void>;
+export interface I18nConfig {
+    /**
+     * The API key for the i18n-keyless API
+     *
+     * contact @ambroselli_io on X/Twitter or by mail at arnaud.ambroselli.io@gmail.com for getting one
+     */
+    API_KEY: string;
+    /**
+     * Your own API URL for the i18n-keyless API
+     *
+     * You'll need to implement two routes on your server
+     * - GET /translate/:lang
+     * - POST /translate -- with a body of { key: string }
+     */
+    API_URL?: string;
+    /**
+     * The languages config
+     *
+     * primary: the language used by the developer
+     * supported: the languages supported for the user
+     * fallback: if the user's langauge is not supported, the fallback language will be used
+     * initWithDefault: the language to use when the app is initialized for the first time
+     */
+    languages: LanguagesConfig;
+    /**
+     * if true, everytime a primary key is not found
+     * there will be a call to POST /translate -- with a body of { key: string }
+     * which should handle adding the key to the translations and, if needed,
+     * translate the key to all the languages supported by the user
+     *
+     * Two scenarios
+     * 1. Enable it in dev mode only: you'll may add some useless key, but you are 100% sure all the translations are up to date
+     * 2. Enable it in prod mode only: you take a risk taht the translations is not available when required for the first user demanding
+     * Best take: enable it all the time
+     */
+    addMissingTranslations?: boolean;
+    /**
+     * called right after the store is initialized, maybe to hide screensplash. or init specific default langauge for dayjs, or whatever
+     */
+    onInit?: (lang: Lang) => void;
+    /**
+     * if true, all the logs will be displayed in the console
+     */
+    debug?: boolean;
+    /**
+     * called everytime the language is set, maybe to set also the locale to dayjs or whatever
+     */
+    onSetLanguage?: (lang: Lang) => void;
+    /**
+     * if this function exists, it will be called instead of the API call
+     * if this function doesn't exist, the default behavior is to call the API
+     * therefore you would need either to
+     * - use this `handleTranslate` function to handle the translation with your own API
+     * - not use this `handleTranslate` function, and use the built in API call with API_KEY filled
+     * - not use this `handleTranslate` function nor API_KEY key, and provide your own API_URL
+     */
+    handleTranslate?: HandleTranslateFunction;
+    /**
+     * if this function exists, it will be called instead of the API call
+     * if this function doesn't exist, the default behavior is to call the API, with the API_KEY
+     * therefore you need either to
+     * - use this `getAllTranslations` function to handle the translation with your own API
+     * - not use this `getAllTranslations` function, and use the built in API call with the API_KEY filled
+     * - not use this `getAllTranslations` function nor API_KEY key, and provide your own API_URL
+     */
+    getAllTranslations?: GetAllTranslationsFunction;
+    /**
+     * the storage to use for the translations
+     *
+     * you can use react-native-mmkv, @react-native-async-storage/async-storage, or window.localStorage, or idb-keyval for IndexedDB, or any storage that has a getItem, setItem, removeItem, or get, set, and remove method
+     */
+    storage?: {
+        getItem?: GetStorageFunction;
+        get?: GetStorageFunction;
+        getString?: GetStorageFunction;
+        setItem?: SetStorageFunction;
+        set?: SetStorageFunction;
+        removeItem?: RemoveStorageFunction;
+        remove?: RemoveStorageFunction;
+        delete?: RemoveStorageFunction;
+        del?: RemoveStorageFunction;
+        clear?: ClearStorageFunction;
+        clearAll?: ClearStorageFunction;
+    } & {
+        getString?: GetStorageFunction;
+        get?: GetStorageFunction;
+        getItem?: GetStorageFunction;
+    } & {
+        setItem?: SetStorageFunction;
+        set?: SetStorageFunction;
+    } & {
+        removeItem?: RemoveStorageFunction;
+        remove?: RemoveStorageFunction;
+        delete?: RemoveStorageFunction;
+        del?: RemoveStorageFunction;
+    } & ({
+        clear: ClearStorageFunction;
+        clearAll?: never;
+    } | {
+        clearAll: ClearStorageFunction;
+        clear?: never;
+    });
+}
+export interface TranslationStoreState {
+    /**
+     * the unique id of the consumer of i18n-keyless API, to help identify the usage API side
+     */
+    uniqueId: UniqueId;
+    /**
+     * the last refresh of the translations, to only fetch the new ones if any
+     */
+    lastRefresh: LastRefresh;
+    /**
+     * the translations fetched from i18n-keyless' API
+     */
+    translations: Translations;
+    /**
+     * the current language of the user
+     */
+    currentLanguage: Lang;
+    /**
+     * i18n-keyless' config
+     */
+    config: I18nConfig;
+}
+export type TranslationOptions = {
+    /**
+     * The context of the translation.
+     * Useful for ambiguous translations, like "8 heures" in French could be "8 AM" or "8 hours".
+     * You'll find it useful when it occurs to you, don't worry :)
+     */
+    context?: string;
+    /**
+     * Could be helpful if something weird happens with this particular key.
+     */
+    debug?: boolean;
+    /**
+     * If the proposed translation from AI is not satisfactory,
+     * you can use this field to setup your own translation.
+     * You can leave it there forever, or remove it once your translation is saved.
+     */
+    forceTemporary?: Partial<Record<Lang, string>>;
+};
+interface TranslationStoreActions {
+    setTranslations: (translations: I18nKeylessResponse | void) => void;
+    setLanguage: (lang: Lang) => void;
+}
+export type TranslationStore = TranslationStoreState & TranslationStoreActions;
+export {};

package/dist/react/types.js

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

package/dist/{utils.d.ts → react/utils.d.ts}

@@ -1,4 +1,4 @@
-import type { I18nConfig } from "i18n-keyless-core";
+import type { I18nConfig } from "./types";
 /**
  * The keys used to store i18n-keyless data in storage
  */
@@ -36,3 +36,11 @@ export declare function deleteItem(key: string, storage: I18nConfig["storage"]):
  * @param storage - The storage implementation to clear
  */
 export declare function clearI18nKeylessStorage(storage: I18nConfig["storage"]): Promise<void>;
+/**
+ * Validates the language against the supported languages
+ * @param lang - The language to validate
+ * @param config - The configuration object
+ * @returns The validated language or the fallback language if not supported
+ * @throws Error if config is not initialized
+ */
+export declare function validateLanguage(lang: I18nConfig["languages"]["supported"][number], config: I18nConfig): import("i18n-keyless-core").Lang | undefined;

package/dist/{utils.js → react/utils.js}

@@ -99,3 +99,19 @@ export async function clearI18nKeylessStorage(storage) {
         deleteItem(key, storage);
     }
 }
+/**
+ * Validates the language against the supported languages
+ * @param lang - The language to validate
+ * @param config - The configuration object
+ * @returns The validated language or the fallback language if not supported
+ * @throws Error if config is not initialized
+ */
+export function validateLanguage(lang, config) {
+    if (!config.API_KEY) {
+        throw new Error(`i18n-keyless: config is not initialized validating language`);
+    }
+    if (!config.languages.supported.includes(lang)) {
+        return config.languages.fallback;
+    }
+    return lang;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "i18n-keyless-react",
   "private": false,
-  "version": "1.10.5",
+  "version": "1.10.7",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -13,7 +13,8 @@
     "prepublishOnly": "rm -rf ./dist && tsc --project tsconfig.json && npm run test && npm pack",
     "test": "vitest run",
     "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage"
+    "test:coverage": "vitest run --coverage",
+    "postpublish": "rm -rf ./dist && rm *.tgz"
   },
   "dependencies": {
     "i18n-keyless-core": "latest",

package/dist/index.d.ts

@@ -1,5 +0,0 @@
-export { I18nKeylessText } from "./I18nKeylessText";
-export { init, setCurrentLanguage, useCurrentLanguage, getTranslation } from "./store";
-export { clearI18nKeylessStorage } from "./utils";
-export type { I18nKeylessTextProps } from "./I18nKeylessText";
-export { type I18nConfig, type Lang, type PrimaryLang, type Translations, type TranslationStore, type TranslationStoreState, type I18nKeylessRequestBody, type I18nKeylessResponse, type TranslationOptions, getAllTranslationsFromLanguage, validateLanguage, queue, } from "i18n-keyless-core";

package/dist/index.js

@@ -1,4 +0,0 @@
-export { I18nKeylessText } from "./I18nKeylessText";
-export { init, setCurrentLanguage, useCurrentLanguage, getTranslation } from "./store";
-export { clearI18nKeylessStorage } from "./utils";
-export { getAllTranslationsFromLanguage, validateLanguage, queue, } from "i18n-keyless-core";