i18n-keyless-node 1.10.4 → 1.10.6

package/dist/package.json

@@ -0,0 +1,24 @@
+{
+    "name": "i18n-keyless",
+    "private": false,
+    "type": "module",
+    "version": "1.10.6",
+    "workspaces": [
+        "packages/*"
+    ],
+    "scripts": {
+        "build": "npm run build:core && npm run build:react",
+        "build:core": "npm run build:lib --workspace=i18n-keyless-core",
+        "build:react": "npm run build:lib --workspace=i18n-keyless-react",
+        "clean": "npm run clean:core && npm run clean:react",
+        "clean:core": "rm -rf packages/core/dist",
+        "clean:react": "rm -rf packages/react/dist",
+        "test": "npm run test --workspace=i18n-keyless-react",
+        "test:watch": "npm run test:watch --workspace=i18n-keyless-react",
+        "test:coverage": "npm run test:coverage --workspace=i18n-keyless-react"
+    },
+    "devDependencies": {
+        "typescript": "^5.5.3",
+        "typescript-eslint": "^8.0.1"
+    }
+}

package/dist/packages/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/packages/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/packages/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/packages/core/index.js

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

package/dist/packages/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/packages/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/packages/core/package.json

@@ -0,0 +1,22 @@
+{
+    "name": "i18n-keyless-core",
+    "private": false,
+    "version": "1.10.6",
+    "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/packages/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/packages/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/packages/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/packages/core/types.js

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

package/dist/packages/node/index.d.ts

@@ -0,0 +1,3 @@
+export { init, getTranslation, getAllTranslationsForAllLanguages } from "./service";
+export type { Translations, I18nKeylessNodeConfig, I18nKeylessNodeStore, TranslationOptions, I18nKeylessRequestBody, I18nKeylessAllTranslationsResponse, } from "./types";
+export { type Lang, type PrimaryLang, type I18nKeylessResponse, queue } from "i18n-keyless-core";

package/dist/packages/node/index.js

@@ -0,0 +1,2 @@
+export { init, getTranslation, getAllTranslationsForAllLanguages } from "./service";
+export { queue } from "i18n-keyless-core";

package/dist/packages/node/service.d.ts

@@ -0,0 +1,10 @@
+import { type Lang, type TranslationOptions, I18nKeylessAllTranslationsResponse } from "i18n-keyless-core";
+import { I18nKeylessNodeConfig, I18nKeylessNodeStore } from "types";
+/**
+ * Fetches all translations
+ * @param store - The translation store
+ * @returns Promise resolving to the translation response or void if failed
+ */
+export declare function getAllTranslationsForAllLanguages(store: I18nKeylessNodeStore): Promise<I18nKeylessAllTranslationsResponse | void>;
+export declare function init(newConfig: I18nKeylessNodeConfig): Promise<I18nKeylessNodeConfig>;
+export declare function getTranslation(key: string, currentLanguage: Lang, options?: TranslationOptions): string;

package/dist/packages/node/service.js

@@ -0,0 +1,116 @@
+import { queue, getTranslationCore, } from "i18n-keyless-core";
+import { api } from "i18n-keyless-core/api";
+import packageJson from "../../package.json";
+const store = {
+    translations: {
+        fr: {},
+        en: {},
+        es: {},
+        nl: {},
+        it: {},
+        de: {},
+        pl: {},
+        pt: {},
+        ro: {},
+        sv: {},
+        tr: {},
+        ja: {},
+        cn: {},
+        ru: {},
+        ko: {},
+        ar: {},
+    },
+    uniqueId: "",
+    lastRefresh: "",
+    config: {
+        API_KEY: "",
+        languages: {
+            primary: "fr",
+            supported: ["fr"],
+        },
+    },
+};
+/**
+ * Fetches all translations
+ * @param store - The translation store
+ * @returns Promise resolving to the translation response or void if failed
+ */
+export async function getAllTranslationsForAllLanguages(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.getAllTranslationsForAllLanguages
+            ? await config.getAllTranslationsForAllLanguages()
+            : await api
+                .fetchAllTranslationsForAllLanguages(`${config.API_URL || "https://api.i18n-keyless.com"}/translate/?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);
+    }
+}
+queue.on("empty", () => {
+    // when each word is translated, fetch the translations for the current language
+    getAllTranslationsForAllLanguages(store).then((res) => {
+        if (res?.ok) {
+            store.translations = res.data.translations;
+        }
+    });
+});
+export async function init(newConfig) {
+    if (!newConfig.languages) {
+        throw new Error("i18n-keyless: languages is required");
+    }
+    if (!newConfig.languages.primary) {
+        throw new Error("i18n-keyless: primary is required");
+    }
+    if (!newConfig.getAllTranslationsForAllLanguages || !newConfig.handleTranslate) {
+        if (!newConfig.API_KEY) {
+            if (!newConfig.API_URL) {
+                throw new Error("i18n-keyless: you didn't provide an API_KEY nor an API_URL nor a handleTranslate + getAllTranslationsForAllLanguages function. You need to provide one of them to make i18n-keyless work");
+            }
+        }
+    }
+    newConfig.addMissingTranslations = true;
+    store.config = newConfig;
+    store.config.onInit?.(newConfig.languages.primary);
+    const response = await getAllTranslationsForAllLanguages(store);
+    if (response?.ok) {
+        store.translations = response.data.translations;
+    }
+    return newConfig;
+}
+export function getTranslation(key, currentLanguage, options) {
+    if (options?.debug) {
+        console.log("getTranslation", key, currentLanguage, store.translations);
+    }
+    return getTranslationCore(key, {
+        ...store,
+        config: store.config,
+        currentLanguage,
+        translations: store.translations[currentLanguage],
+    }, options);
+}

package/dist/packages/node/types.d.ts

@@ -0,0 +1,123 @@
+import { Lang, PrimaryLang } from "i18n-keyless-core";
+export type Translations = Record<string, string>;
+export interface I18nKeylessNodeConfig {
+    /**
+     * 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: {
+        /**
+         * 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[];
+    };
+    addMissingTranslations?: true;
+    /**
+     * 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;
+    /**
+     * 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?: (key: string) => Promise<{
+        ok: boolean;
+        message: string;
+    }>;
+    /**
+     * 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 `getAllTranslationsForAllLanguages` function to handle the translation with your own API
+     * - not use this `getAllTranslationsForAllLanguages` function, and use the built in API call with the API_KEY filled
+     * - not use this `getAllTranslationsForAllLanguages` function nor API_KEY key, and provide your own API_URL
+     */
+    getAllTranslationsForAllLanguages?: () => Promise<I18nKeylessAllTranslationsResponse>;
+}
+export interface I18nKeylessNodeStore {
+    /**
+     * the unique id of the consumer of i18n-keyless API, to help identify the usage API side
+     */
+    uniqueId: string | null;
+    /**
+     * the last refresh of the translations, to only fetch the new ones if any
+     */
+    lastRefresh: string | null;
+    /**
+     * the translations fetched from i18n-keyless' API
+     */
+    translations: Record<Lang, Translations>;
+    /**
+     * i18n-keyless' config
+     */
+    config: I18nKeylessNodeConfig;
+}
+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: I18nKeylessNodeConfig["languages"]["supported"];
+    primaryLanguage: I18nKeylessNodeConfig["languages"]["primary"];
+}
+export interface I18nKeylessAllTranslationsResponse {
+    ok: boolean;
+    data: {
+        translations: Record<Lang, Translations>;
+        uniqueId: string | null;
+        lastRefresh: string | null;
+    };
+    error: string;
+    message: string;
+}

package/dist/packages/node/types.js

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "i18n-keyless-node",
   "private": false,
-  "version": "1.10.4",
+  "version": "1.10.6",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -11,7 +11,8 @@
   ],
   "scripts": {
     "prepublishOnly": "rm -rf ./dist && tsc --project tsconfig.json && npm pack",
-    "test": "echo 'no test for node'"
+    "test": "echo 'no test for node'",
+    "postpublish": "rm -rf ./dist && rm *.tgz"
   },
   "dependencies": {
     "i18n-keyless-core": "latest"

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-export { init, getTranslation } from "./service";
-export { type I18nConfig, type Lang, type PrimaryLang, type Translations, type TranslationStore, type TranslationStoreState, type I18nKeylessRequestBody, type I18nKeylessResponse, type TranslationOptions, getAllTranslationsForAllLanguages, validateLanguage, queue, } from "i18n-keyless-core";

package/dist/index.js

@@ -1,2 +0,0 @@
-export { init, getTranslation } from "./service";
-export { getAllTranslationsForAllLanguages, validateLanguage, queue, } from "i18n-keyless-core";

package/dist/service.d.ts

@@ -1,3 +0,0 @@
-import { type Lang, type NodeConfig, type TranslationOptions } from "i18n-keyless-core";
-export declare function init(newConfig: NodeConfig): Promise<NodeConfig>;
-export declare function getTranslation(key: string, currentLanguage: Lang, options?: TranslationOptions): string;

package/dist/service.js

@@ -1,41 +0,0 @@
-import { queue, getTranslationCore, getAllTranslationsForAllLanguages, } from "i18n-keyless-core";
-const store = {
-    translations: {},
-    uniqueId: "",
-    lastRefresh: "",
-    config: null,
-    setTranslations: () => { },
-};
-queue.on("empty", () => {
-    // when each word is translated, fetch the translations for the current language
-    getAllTranslationsForAllLanguages(store).then(store.setTranslations);
-});
-export async function init(newConfig) {
-    if (!newConfig.languages) {
-        throw new Error("i18n-keyless: languages is required");
-    }
-    if (!newConfig.languages.primary) {
-        throw new Error("i18n-keyless: primary is required");
-    }
-    if (!newConfig.languages.fallback) {
-        newConfig.languages.fallback = newConfig.languages.primary;
-    }
-    if (!newConfig.getAllTranslationsForAllLanguages || !newConfig.handleTranslate) {
-        if (!newConfig.API_KEY) {
-            if (!newConfig.API_URL) {
-                throw new Error("i18n-keyless: you didn't provide an API_KEY nor an API_URL nor a handleTranslate + getAllTranslationsForAllLanguages function. You need to provide one of them to make i18n-keyless work");
-            }
-        }
-    }
-    if (newConfig.addMissingTranslations !== false) {
-        // default to true
-        newConfig.addMissingTranslations = true;
-    }
-    store.config = newConfig;
-    store.config.onInit?.(newConfig.languages.primary);
-    getAllTranslationsForAllLanguages(store).then(store.setTranslations);
-    return newConfig;
-}
-export function getTranslation(key, currentLanguage, options) {
-    return getTranslationCore(key, { ...store, currentLanguage }, options);
-}