@rimori/client 1.4.4 → 1.4.6

package/dist/i18n/I18nHooks.js

@@ -0,0 +1,25 @@
+import { useEffect, useState } from 'react';
+import { useRimori } from '../providers/PluginProvider';
+/**
+ * Custom useTranslation hook that provides a translation function and indicates readiness
+ * @returns An object containing the translation function (`t`) and a boolean (`ready`) indicating if the translator is initialized.
+ */
+export function useTranslation() {
+    const { plugin } = useRimori();
+    const [translatorInstance, setTranslatorInstance] = useState(null);
+    useEffect(() => {
+        void plugin.getTranslator().then(setTranslatorInstance);
+    }, [plugin]);
+    const safeT = (key, options) => {
+        if (!translatorInstance)
+            return '\u200B'; // zero-width space
+        try {
+            return translatorInstance.t(key, options);
+        }
+        catch (error) {
+            console.error('Translation error:', error);
+            return key;
+        }
+    };
+    return { t: safeT, ready: translatorInstance !== null };
+}

package/dist/i18n/Translator.d.ts

@@ -0,0 +1,43 @@
+import { ThirdPartyModule, TOptions } from 'i18next';
+/**
+ * Translator class for handling internationalization
+ */
+export declare class Translator {
+    private currentLanguage;
+    private isInitialized;
+    private i18n;
+    constructor(initialLanguage: string);
+    /**
+     * Initialize translator with user's language
+     * @param userLanguage - Language code from user info
+     */
+    initialize(): Promise<void>;
+    private getTranslationUrl;
+    /**
+     * Initialize i18n with or without React support
+     * @param isReact - Whether to use React-specific features
+     */
+    private getI18n;
+    usePlugin(plugin: ThirdPartyModule): void;
+    /**
+     * Fetch translations manually from the current domain
+     * @param language - Language code to fetch
+     * @returns Promise with translation data
+     */
+    private fetchTranslations;
+    /**
+     * Get translation for a key
+     * @param key - Translation key
+     * @param options - Translation options
+     * @returns Translated string
+     */
+    t(key: string, options?: TOptions): string;
+    /**
+     * Get current language
+     */
+    getCurrentLanguage(): string;
+    /**
+     * Check if translator is initialized
+     */
+    isReady(): boolean;
+}

package/dist/i18n/Translator.js

@@ -0,0 +1,118 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import i18n from './config';
+import { createInstance } from 'i18next';
+/**
+ * Translator class for handling internationalization
+ */
+export class Translator {
+    constructor(initialLanguage) {
+        this.currentLanguage = initialLanguage;
+        this.isInitialized = false;
+        this.i18n = this.getI18n();
+    }
+    /**
+     * Initialize translator with user's language
+     * @param userLanguage - Language code from user info
+     */
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isInitialized) {
+                return;
+            }
+            try {
+                // Fetch translations manually
+                const translations = yield this.fetchTranslations(this.currentLanguage);
+                // Add translations to i18n
+                i18n.addResourceBundle(this.currentLanguage, 'translation', translations);
+                // Change language
+                yield i18n.changeLanguage(this.currentLanguage);
+                this.isInitialized = true;
+            }
+            catch (error) {
+                console.warn('Failed to initialize translator:', error);
+                // Ensure we have at least English fallback
+                if (!this.isInitialized) {
+                    this.currentLanguage = 'en';
+                    yield this.initialize();
+                }
+            }
+        });
+    }
+    getTranslationUrl(language) {
+        return `${window.location.origin}/locales/${language}/translation.json`;
+    }
+    /**
+     * Initialize i18n with or without React support
+     * @param isReact - Whether to use React-specific features
+     */
+    getI18n(isReact = false) {
+        return createInstance({
+            fallbackLng: 'en',
+            debug: window.location.hostname === 'localhost',
+            interpolation: {
+                escapeValue: !isReact,
+            },
+        });
+    }
+    usePlugin(plugin) {
+        this.i18n.use(plugin);
+    }
+    /**
+     * Fetch translations manually from the current domain
+     * @param language - Language code to fetch
+     * @returns Promise with translation data
+     */
+    fetchTranslations(language) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield fetch(this.getTranslationUrl(language));
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch translations for ${language}`);
+                }
+                return yield response.json();
+            }
+            catch (error) {
+                console.warn(`Failed to fetch translations for ${language}:`, error);
+                // Fallback to English if available
+                if (language !== 'en') {
+                    try {
+                        return yield this.fetchTranslations('en');
+                    }
+                    catch (error) {
+                        console.warn('Failed to fetch fallback translations:', error);
+                    }
+                }
+                return {};
+            }
+        });
+    }
+    /**
+     * Get translation for a key
+     * @param key - Translation key
+     * @param options - Translation options
+     * @returns Translated string
+     */
+    t(key, options) {
+        return i18n.t(key, options);
+    }
+    /**
+     * Get current language
+     */
+    getCurrentLanguage() {
+        return this.currentLanguage;
+    }
+    /**
+     * Check if translator is initialized
+     */
+    isReady() {
+        return this.isInitialized;
+    }
+}

package/dist/i18n/config.d.ts

@@ -0,0 +1,7 @@
+import i18n from 'i18next';
+/**
+ * Initialize i18n with or without React support
+ * @param isReact - Whether to use React-specific features
+ */
+export declare function getI18n(isReact?: boolean): import("i18next").i18n;
+export default i18n;

package/dist/i18n/config.js

@@ -0,0 +1,20 @@
+import i18n, { createInstance } from 'i18next';
+import { initReactI18next } from 'react-i18next';
+/**
+ * Initialize i18n with or without React support
+ * @param isReact - Whether to use React-specific features
+ */
+export function getI18n(isReact = false) {
+    const i18n = createInstance({
+        fallbackLng: 'en',
+        debug: window.location.hostname === 'localhost',
+        interpolation: {
+            escapeValue: !isReact,
+        },
+    });
+    if (isReact) {
+        i18n.use(initReactI18next);
+    }
+    return i18n;
+}
+export default i18n;

package/dist/i18n/createI18nInstance.d.ts

@@ -0,0 +1,7 @@
+import { I18nConfig } from './types';
+/**
+ * Creates a configured i18next instance for Rimori plugins
+ * @param config - Configuration options for i18n
+ * @returns Configured i18next instance
+ */
+export declare const createI18nInstance: (config?: I18nConfig) => import("i18next").i18n;

package/dist/i18n/createI18nInstance.js

@@ -0,0 +1,31 @@
+import i18n from 'i18next';
+import { initReactI18next } from 'react-i18next';
+import HttpBackend from 'i18next-http-backend';
+/**
+ * Creates a configured i18next instance for Rimori plugins
+ * @param config - Configuration options for i18n
+ * @returns Configured i18next instance
+ */
+export const createI18nInstance = (config = {}) => {
+    const { fallbackLng = 'en', debug = false, loadPath = './locales/{{lng}}/translation.json', supportedLanguages = ['en', 'es', 'zh', 'hi', 'ar'], namespace = 'translation', } = config;
+    i18n
+        .use(HttpBackend)
+        .use(initReactI18next)
+        .init({
+        fallbackLng,
+        debug,
+        supportedLngs: supportedLanguages,
+        ns: [namespace],
+        defaultNS: namespace,
+        backend: {
+            loadPath,
+        },
+        interpolation: {
+            escapeValue: false, // React already escapes by default
+        },
+        react: {
+            useSuspense: true,
+        },
+    });
+    return i18n;
+};

package/dist/i18n/hooks.d.ts

@@ -0,0 +1,11 @@
+import { TOptions } from 'i18next';
+type TranslatorFn = (key: string, options?: TOptions) => string;
+/**
+ * Custom useTranslation hook that provides a translation function and indicates readiness
+ * @returns An object containing the translation function (`t`) and a boolean (`ready`) indicating if the translator is initialized.
+ */
+export declare function useTranslation(): {
+    t: TranslatorFn;
+    ready: boolean;
+};
+export {};

package/dist/i18n/hooks.js

@@ -0,0 +1,25 @@
+import { useEffect, useState } from 'react';
+import { useRimori } from '../providers/PluginProvider';
+/**
+ * Custom useTranslation hook that provides a translation function and indicates readiness
+ * @returns An object containing the translation function (`t`) and a boolean (`ready`) indicating if the translator is initialized.
+ */
+export function useTranslation() {
+    const { plugin } = useRimori();
+    const [translatorInstance, setTranslatorInstance] = useState(null);
+    useEffect(() => {
+        void plugin.getTranslator().then(setTranslatorInstance);
+    }, [plugin]);
+    const safeT = (key, options) => {
+        if (!translatorInstance)
+            return '\u200B'; // zero-width space
+        try {
+            return translatorInstance.t(key, options);
+        }
+        catch (error) {
+            console.error('Translation error:', error);
+            return key;
+        }
+    };
+    return { t: safeT, ready: translatorInstance !== null };
+}

package/dist/i18n/index.d.ts

@@ -0,0 +1,4 @@
+export { useTranslation } from './hooks';
+export { default as i18n, initializeI18n } from './config';
+export { useTranslation as useI18nTranslation } from 'react-i18next';
+export { Translator } from './Translator';

package/dist/i18n/index.js

@@ -0,0 +1,4 @@
+export { useTranslation } from './hooks';
+export { default as i18n, initializeI18n } from './config';
+export { useTranslation as useI18nTranslation } from 'react-i18next';
+export { Translator } from './Translator';

package/dist/i18n/types.d.ts

@@ -0,0 +1,7 @@
+export interface I18nConfig {
+    fallbackLng?: string;
+    debug?: boolean;
+    loadPath?: string;
+    supportedLanguages?: string[];
+    namespace?: string;
+}

package/dist/i18n/types.js

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

package/dist/i18n/useRimoriI18n.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Custom hook that automatically initializes i18n with user's language
+ * and provides the useTranslation hook functionality
+ * @param namespace - Optional namespace for translations
+ * @returns useTranslation hook result
+ */
+export declare const useRimoriI18n: (namespace?: string) => {
+    t: import("i18next").TFunction<string, undefined>;
+    i18n: import("i18next").i18n;
+    ready: boolean;
+};

package/dist/i18n/useRimoriI18n.js

@@ -0,0 +1,41 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { useEffect } from 'react';
+import { useTranslation } from 'react-i18next';
+import { useRimori } from '../providers/PluginProvider';
+/**
+ * Custom hook that automatically initializes i18n with user's language
+ * and provides the useTranslation hook functionality
+ * @param namespace - Optional namespace for translations
+ * @returns useTranslation hook result
+ */
+export const useRimoriI18n = (namespace) => {
+    const { t, i18n, ready } = useTranslation(namespace);
+    const rimoriClient = useRimori();
+    useEffect(() => {
+        const initializeLanguage = () => __awaiter(void 0, void 0, void 0, function* () {
+            try {
+                const userInfo = rimoriClient.plugin.getUserInfo();
+                const userLanguage = userInfo.mother_tongue.code.toLowerCase();
+                // Only change language if it's different from current
+                if (i18n.language !== userLanguage) {
+                    yield i18n.changeLanguage(userLanguage);
+                }
+            }
+            catch (error) {
+                console.warn('Failed to initialize i18n with user language, using fallback:', error);
+            }
+        });
+        if (ready) {
+            initializeLanguage();
+        }
+    }, [i18n, rimoriClient, ready]);
+    return { t, i18n, ready };
+};

package/dist/index.d.ts

@@ -5,7 +5,7 @@ export * from './providers/PluginProvider';
 export * from './cli/types/DatabaseTypes';
 export * from './utils/difficultyConverter';
 export * from './utils/PluginUtils';
-export * from './utils/Language';
 export * from './fromRimori/PluginTypes';
 export { FirstMessages } from './components/ai/utils';
 export { AudioController } from './plugin/AudioController';
+export { useTranslation } from './hooks/I18nHooks';

package/dist/index.js

@@ -6,6 +6,6 @@ export * from './providers/PluginProvider';
 export * from './cli/types/DatabaseTypes';
 export * from './utils/difficultyConverter';
 export * from './utils/PluginUtils';
-export * from './utils/Language';
 export * from './fromRimori/PluginTypes';
 export { AudioController } from './plugin/AudioController';
+export { useTranslation } from './hooks/I18nHooks';

package/dist/plugin/RimoriClient.d.ts

@@ -9,6 +9,7 @@ import { EventBusMessage, EventHandler, EventPayload } from '../fromRimori/Event
 import { ActivePlugin, MainPanelAction, Plugin, Tool } from '../fromRimori/PluginTypes';
 import { AccomplishmentPayload } from './AccomplishmentHandler';
 import { PluginController } from './PluginController';
+import { Translator } from './TranslationController';
 interface Db {
     from: {
         <TableName extends string & keyof GenericSchema['Tables'], Table extends GenericSchema['Tables'][TableName]>(relation: TableName): PostgrestQueryBuilder<GenericSchema, Table, TableName>;
@@ -57,6 +58,7 @@ interface PluginInterface {
         sidePanelPlugin?: ActivePlugin;
     };
     getUserInfo: () => UserInfo;
+    getTranslator: () => Promise<Translator>;
 }
 export declare class RimoriClient {
     private static instance;
@@ -67,6 +69,7 @@ export declare class RimoriClient {
     private exerciseController;
     private accomplishmentHandler;
     private rimoriInfo;
+    private translator;
     plugin: PluginInterface;
     db: Db;
     private constructor();

package/dist/plugin/RimoriClient.js

@@ -15,6 +15,7 @@ import { getSTTResponse, getTTSResponse } from '../core/controller/VoiceControll
 import { ExerciseController } from '../core/controller/ExerciseController';
 import { EventBus } from '../fromRimori/EventBus';
 import { AccomplishmentHandler } from './AccomplishmentHandler';
+import { Translator } from './TranslationController';
 export class RimoriClient {
     constructor(supabase, info, pluginController) {
         this.event = {
@@ -250,6 +251,7 @@ export class RimoriClient {
         this.sharedContentController = new SharedContentController(this.superbase, this);
         this.exerciseController = new ExerciseController(supabase, pluginController);
         this.accomplishmentHandler = new AccomplishmentHandler(info.pluginId);
+        this.translator = new Translator(info.profile.mother_tongue.code);
         this.from = this.from.bind(this);
         this.getTableName = this.getTableName.bind(this);
         this.db = {
@@ -277,6 +279,10 @@ export class RimoriClient {
                     sidePanelPlugin: this.rimoriInfo.sidePanelPlugin,
                 };
             },
+            getTranslator: () => __awaiter(this, void 0, void 0, function* () {
+                yield this.translator.initialize();
+                return this.translator;
+            }),
         };
     }
     /**

package/dist/plugin/TranslationController.d.ts

@@ -0,0 +1,38 @@
+import { ThirdPartyModule, TOptions } from 'i18next';
+/**
+ * Translator class for handling internationalization
+ */
+export declare class Translator {
+    private currentLanguage;
+    private isInitialized;
+    private i18n;
+    constructor(initialLanguage: string);
+    /**
+     * Initialize translator with user's language
+     * @param userLanguage - Language code from user info
+     */
+    initialize(): Promise<void>;
+    private getTranslationUrl;
+    usePlugin(plugin: ThirdPartyModule): void;
+    /**
+     * Fetch translations manually from the current domain
+     * @param language - Language code to fetch
+     * @returns Promise with translation data
+     */
+    private fetchTranslations;
+    /**
+     * Get translation for a key
+     * @param key - Translation key
+     * @param options - Translation options
+     * @returns Translated string
+     */
+    t(key: string, options?: TOptions): string;
+    /**
+     * Get current language
+     */
+    getCurrentLanguage(): string;
+    /**
+     * Check if translator is initialized
+     */
+    isReady(): boolean;
+}

package/dist/plugin/TranslationController.js

@@ -0,0 +1,105 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { createInstance } from 'i18next';
+/**
+ * Translator class for handling internationalization
+ */
+export class Translator {
+    constructor(initialLanguage) {
+        this.isInitialized = false;
+        this.currentLanguage = initialLanguage;
+    }
+    /**
+     * Initialize translator with user's language
+     * @param userLanguage - Language code from user info
+     */
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isInitialized)
+                return;
+            const translations = yield this.fetchTranslations(this.currentLanguage);
+            const instance = createInstance({
+                lng: this.currentLanguage,
+                resources: {
+                    [this.currentLanguage]: {
+                        translation: translations,
+                    },
+                },
+                debug: window.location.hostname === 'localhost',
+            });
+            yield instance.init();
+            this.i18n = instance;
+            this.isInitialized = true;
+        });
+    }
+    getTranslationUrl(language) {
+        // For localhost development, use local- prefix for non-English languages
+        const isLocalhost = window.location.hostname === 'localhost';
+        const isEnglish = language === 'en';
+        const filename = isLocalhost && !isEnglish ? `local-${language}` : language;
+        return `${window.location.origin}/locales/${filename}.json`;
+    }
+    usePlugin(plugin) {
+        if (!this.i18n) {
+            throw new Error('Translator is not initialized');
+        }
+        this.i18n.use(plugin);
+    }
+    /**
+     * Fetch translations manually from the current domain
+     * @param language - Language code to fetch
+     * @returns Promise with translation data
+     */
+    fetchTranslations(language) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield fetch(this.getTranslationUrl(language));
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch translations for ${language}`);
+                }
+                return (yield response.json());
+            }
+            catch (error) {
+                console.warn(`Failed to fetch translations for ${language}:`, error);
+                if (language === 'en')
+                    return {};
+                // Fallback to English
+                return this.fetchTranslations('en').catch((error) => {
+                    console.error('Failed to fetch fallback translations:', error);
+                    return {};
+                });
+            }
+        });
+    }
+    /**
+     * Get translation for a key
+     * @param key - Translation key
+     * @param options - Translation options
+     * @returns Translated string
+     */
+    t(key, options) {
+        if (!this.i18n) {
+            throw new Error('Translator is not initialized');
+        }
+        return this.i18n.t(key, options);
+    }
+    /**
+     * Get current language
+     */
+    getCurrentLanguage() {
+        return this.currentLanguage;
+    }
+    /**
+     * Check if translator is initialized
+     */
+    isReady() {
+        return this.isInitialized;
+    }
+}

package/dist/plugin/Translator.d.ts

@@ -0,0 +1,38 @@
+import { ThirdPartyModule, TOptions } from 'i18next';
+/**
+ * Translator class for handling internationalization
+ */
+export declare class Translator {
+    private currentLanguage;
+    private isInitialized;
+    private i18n;
+    constructor(initialLanguage: string);
+    /**
+     * Initialize translator with user's language
+     * @param userLanguage - Language code from user info
+     */
+    initialize(): Promise<void>;
+    private getTranslationUrl;
+    usePlugin(plugin: ThirdPartyModule): void;
+    /**
+     * Fetch translations manually from the current domain
+     * @param language - Language code to fetch
+     * @returns Promise with translation data
+     */
+    private fetchTranslations;
+    /**
+     * Get translation for a key
+     * @param key - Translation key
+     * @param options - Translation options
+     * @returns Translated string
+     */
+    t(key: string, options?: TOptions): string;
+    /**
+     * Get current language
+     */
+    getCurrentLanguage(): string;
+    /**
+     * Check if translator is initialized
+     */
+    isReady(): boolean;
+}