i18n-keyless-core 1.8.0 → 1.9.1

package/dist/api.d.ts

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

package/dist/api.js

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

package/dist/index.d.ts

@@ -1 +1,2 @@
-export type { I18nConfig, Lang, PrimaryLang, Translations, TranslationStore, I18nKeylessRequestBody, I18nKeylessResponse, TranslationOptions, } from "./types";
+export type { I18nConfig, Lang, PrimaryLang, Translations, TranslationStore, TranslationStoreState, I18nKeylessRequestBody, I18nKeylessResponse, TranslationOptions, } from "./types";
+export { getTranslation, fetchAllTranslations, validateLanguage, queue } from "./service";

package/dist/index.js

@@ -1 +1 @@
-export {};
+export { getTranslation, fetchAllTranslations, validateLanguage, queue } from "./service";

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

@@ -0,0 +1,20 @@
+{
+    "name": "i18n-keyless-core",
+    "private": false,
+    "version": "1.9.1",
+    "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"
+    },
+    "devDependencies": {
+        "@types/node": "^22.5.5",
+        "@types/react": "^19.0.8",
+        "@types/react-dom": "^19.0.3"
+    }
+}

package/dist/service.d.ts

@@ -0,0 +1,35 @@
+import type { I18nConfig, Lang, TranslationStore, TranslationOptions, I18nKeylessResponse } from "i18n-keyless-core";
+import MyPQueue from "./my-pqueue";
+export declare const queue: MyPQueue;
+/**
+ * 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): Lang | undefined;
+/**
+ * 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 getTranslation(key: string, store: TranslationStore, 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: TranslationStore, 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 fetchAllTranslations(targetLanguage: Lang, store: TranslationStore): Promise<I18nKeylessResponse | void>;

package/dist/service.js

@@ -0,0 +1,179 @@
+import MyPQueue from "./my-pqueue";
+import packageJson from "./package.json";
+import { api } from "./api";
+export const queue = new MyPQueue({ concurrency: 5 });
+/**
+ * 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) {
+        throw new Error(`i18n-keyless: config is not initialized validating language`);
+    }
+    if (!config.languages.supported.includes(lang)) {
+        return config.languages.fallback;
+    }
+    return lang;
+}
+/**
+ * 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 getTranslation(key, store, options) {
+    const currentLanguage = store.currentLanguage;
+    const config = store.config;
+    const translations = store.translations;
+    if (!config) {
+        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) {
+        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 fetchAllTranslations(targetLanguage, store) {
+    const config = store.config;
+    const lastRefresh = store.lastRefresh;
+    const uniqueId = store.uniqueId;
+    if (!config) {
+        console.error("i18n-keyless: No config found");
+        return;
+    }
+    // if (config.languages.primary === targetLanguage) {
+    //   return;
+    // }
+    try {
+        const response = config.getAllTranslations
+            ? await config.getAllTranslations()
+            : await api
+                .fetchTranslations(`${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/types.d.ts

@@ -132,15 +132,27 @@ export interface I18nConfig {
         clear?: never;
     });
 }
-interface TranslationStoreState {
+export interface TranslationStoreState {
+    /**
+     * 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: Translations;
+    /**
+     * the current language of the user
+     */
     currentLanguage: Lang;
+    /**
+     * i18n-keyless' config
+     */
     config: I18nConfig | null;
-    translating: Record<string, boolean>;
-    _hasHydrated: boolean;
-    storage: I18nConfig["storage"] | null;
 }
 export type TranslationOptions = {
     /**
@@ -161,10 +173,7 @@ export type TranslationOptions = {
     forceTemporary?: Partial<Record<Lang, string>>;
 };
 interface TranslationStoreActions {
-    _hydrate: () => Promise<void>;
-    getTranslation: (text: string, options?: TranslationOptions) => string | undefined;
-    setTranslations: (translations: Translations) => void;
-    translateKey: (key: string, options?: TranslationOptions) => void;
+    setTranslations: (translations: I18nKeylessResponse | void) => void;
     setLanguage: (lang: Lang) => void;
 }
 export type TranslationStore = TranslationStoreState & TranslationStoreActions;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "i18n-keyless-core",
   "private": false,
-  "version": "1.8.0",
+  "version": "1.9.1",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",