i18n-keyless-node 1.11.0 → 1.11.2

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

@@ -1,7 +1,7 @@
 {
     "name": "i18n-keyless-node",
     "private": false,
-    "version": "1.11.0",
+    "version": "1.11.2",
     "type": "module",
     "main": "./dist/index.js",
     "module": "./dist/index.js",

package/dist/{node/service.js → service.js}

@@ -1,5 +1,4 @@
-import { queue, getTranslationCore, } from "i18n-keyless-core";
-import { api } from "i18n-keyless-core/api";
+import { queue, getTranslationCore, api, } from "i18n-keyless-core";
 import packageJson from "./package.json";
 const store = {
     translations: {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "i18n-keyless-node",
   "private": false,
-  "version": "1.11.0",
+  "version": "1.11.2",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",

package/dist/core/api.d.ts

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

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

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

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

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

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

@@ -1,108 +0,0 @@
-// 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

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

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

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

@@ -1,94 +0,0 @@
-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/node/types.js

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