@rimori/client 2.5.32 → 2.5.33

package/dist/cli/scripts/release/release-prompts-upload.js

@@ -1,12 +1,3 @@
-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 fs from 'fs';
 import path from 'path';
 import ts from 'typescript';
@@ -16,73 +7,70 @@ import ts from 'typescript';
  * @param config - Configuration object
  * @param release_id - The release ID
  */
-export default function promptsUpload(config, release_id) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const promptsConfigPath = path.resolve('./rimori/prompts.config.ts');
-        // Check if prompts config file exists — optional, skip if not present
+export default async function promptsUpload(config, release_id) {
+    const promptsConfigPath = path.resolve('./rimori/prompts.config.ts');
+    // Check if prompts config file exists — optional, skip if not present
+    try {
+        await fs.promises.access(promptsConfigPath);
+    }
+    catch (e) {
+        return; // No prompts.config.ts — silently skip
+    }
+    try {
+        // Use TypeScript compiler to transpile and load
+        const promptsContent = await fs.promises.readFile(promptsConfigPath, 'utf8');
+        // Transpile TypeScript to JavaScript
+        const result = ts.transpile(promptsContent, {
+            target: ts.ScriptTarget.ES2020,
+            module: ts.ModuleKind.ES2020,
+        });
+        // Create a temporary file to import the transpiled code
+        const tempFile = path.join(process.cwd(), 'temp_prompts_config.js');
+        await fs.promises.writeFile(tempFile, result);
+        let prompts;
         try {
-            yield fs.promises.access(promptsConfigPath);
+            const promptsModule = await import(`file://${tempFile}`);
+            // Collect all named exports as individual prompt definitions
+            prompts = Object.values(promptsModule);
+            await fs.promises.unlink(tempFile);
         }
-        catch (e) {
-            return; // No prompts.config.ts — silently skip
-        }
-        try {
-            // Use TypeScript compiler to transpile and load
-            const promptsContent = yield fs.promises.readFile(promptsConfigPath, 'utf8');
-            // Transpile TypeScript to JavaScript
-            const result = ts.transpile(promptsContent, {
-                target: ts.ScriptTarget.ES2020,
-                module: ts.ModuleKind.ES2020,
-            });
-            // Create a temporary file to import the transpiled code
-            const tempFile = path.join(process.cwd(), 'temp_prompts_config.js');
-            yield fs.promises.writeFile(tempFile, result);
-            let prompts;
+        catch (error) {
             try {
-                const promptsModule = yield import(`file://${tempFile}`);
-                // Collect all named exports as individual prompt definitions
-                prompts = Object.values(promptsModule);
-                yield fs.promises.unlink(tempFile);
-            }
-            catch (error) {
-                try {
-                    yield fs.promises.unlink(tempFile);
-                }
-                catch (e) { }
-                throw error;
-            }
-            if (!Array.isArray(prompts) || prompts.length === 0) {
-                console.warn('⚠️ prompts.config.ts has no exports. Skipping.');
-                return;
-            }
-            console.log(`📝 Sending ${prompts.length} prompt definitions...`);
-            const requestBody = {
-                prompts,
-                version: config.version,
-                release_channel: config.release_channel,
-                plugin_id: config.plugin_id,
-            };
-            const response = yield fetch(`${config.domain}/release/${release_id}/prompts`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    Authorization: `Bearer ${config.token}`,
-                },
-                body: JSON.stringify(requestBody),
-            });
-            if (response.ok) {
-                const data = yield response.json();
-                console.log(`✅ Prompts uploaded: ${(_b = (_a = data.prompt_names) === null || _a === void 0 ? void 0 : _a.join(', ')) !== null && _b !== void 0 ? _b : 'ok'}`);
+                await fs.promises.unlink(tempFile);
             }
-            else {
-                const text = yield response.text().catch(() => 'unknown error');
-                throw new Error(`Failed to upload prompts: ${text}`);
-            }
-        }
-        catch (error) {
-            console.error('❌ Error uploading prompts:', error.message);
+            catch (e) { }
             throw error;
         }
-    });
+        if (!Array.isArray(prompts) || prompts.length === 0) {
+            console.warn('⚠️ prompts.config.ts has no exports. Skipping.');
+            return;
+        }
+        console.log(`📝 Sending ${prompts.length} prompt definitions...`);
+        const requestBody = {
+            prompts,
+            version: config.version,
+            release_channel: config.release_channel,
+            plugin_id: config.plugin_id,
+        };
+        const response = await fetch(`${config.domain}/release/${release_id}/prompts`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${config.token}`,
+            },
+            body: JSON.stringify(requestBody),
+        });
+        if (response.ok) {
+            const data = await response.json();
+            console.log(`✅ Prompts uploaded: ${data.prompt_names?.join(', ') ?? 'ok'}`);
+        }
+        else {
+            const text = await response.text().catch(() => 'unknown error');
+            throw new Error(`Failed to upload prompts: ${text}`);
+        }
+    }
+    catch (error) {
+        console.error('❌ Error uploading prompts:', error.message);
+        throw error;
+    }
 }

package/dist/cli/scripts/release/release.js

@@ -10,15 +10,6 @@
  * Make sure to install dependencies:
  *   npm install node-fetch form-data ts-node typescript
  */
-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 'dotenv/config';
 import fs from 'fs';
 import path from 'path';
@@ -54,27 +45,25 @@ const config = {
 /**
  * Main release process
  */
-function releaseProcess() {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            console.log(`🚀 Releasing ${config.plugin_id} to ${config.release_channel}...`);
-            console.log(`📡 Deploying to: ${config.domain}`);
-            // First send the configuration
-            const release_id = yield sendConfiguration(config);
-            // Upload prompts (if prompts.config.ts exists)
-            yield promptsUpload(config, release_id);
-            yield dbUpdate(config, release_id);
-            // Then upload the files
-            yield uploadDirectory(config, release_id);
-            // Then release the plugin
-            yield releasePlugin(config, release_id);
-            // Inform user about translation processing
-            console.log('🌐 Hint: The plugin is released but it might take some time until all translations are being processed.');
-        }
-        catch (error) {
-            console.log('❌ Error:', error.message);
-            process.exit(1);
-        }
-    });
+async function releaseProcess() {
+    try {
+        console.log(`🚀 Releasing ${config.plugin_id} to ${config.release_channel}...`);
+        console.log(`📡 Deploying to: ${config.domain}`);
+        // First send the configuration
+        const release_id = await sendConfiguration(config);
+        // Upload prompts (if prompts.config.ts exists)
+        await promptsUpload(config, release_id);
+        await dbUpdate(config, release_id);
+        // Then upload the files
+        await uploadDirectory(config, release_id);
+        // Then release the plugin
+        await releasePlugin(config, release_id);
+        // Inform user about translation processing
+        console.log('🌐 Hint: The plugin is released but it might take some time until all translations are being processed.');
+    }
+    catch (error) {
+        console.log('❌ Error:', error.message);
+        process.exit(1);
+    }
 }
 releaseProcess();

package/dist/controller/AccomplishmentController.js

@@ -1,12 +1,17 @@
 import { EventBus } from '../fromRimori/EventBus';
 export const skillCategories = ['reading', 'listening', 'speaking', 'writing', 'learning', 'community'];
 export class AccomplishmentController {
+    pluginId;
+    eventBus;
     constructor(pluginId, eventBus) {
         this.pluginId = pluginId;
-        this.eventBus = eventBus !== null && eventBus !== void 0 ? eventBus : EventBus;
+        this.eventBus = eventBus ?? EventBus;
     }
     emitAccomplishment(payload) {
-        const accomplishmentPayload = Object.assign(Object.assign({}, payload), { type: 'durationMinutes' in payload ? 'macro' : 'micro' });
+        const accomplishmentPayload = {
+            ...payload,
+            type: 'durationMinutes' in payload ? 'macro' : 'micro',
+        };
         if (!this.validateAccomplishment(accomplishmentPayload)) {
             return;
         }
@@ -40,22 +45,17 @@ export class AccomplishmentController {
         if (payload.type === 'macro' && (payload.errorRatio < 0 || payload.errorRatio > 1)) {
             throw new Error('The error ratio must be between 0 and 1');
         }
-        //regex check meta data key
-        if (payload.meta) {
-            payload.meta.forEach((meta) => {
-                if (!/^[a-z_]+$/.test(meta.key)) {
-                    throw new Error('Invalid meta data key ' + meta.key + ', only lowercase letters and underscores are allowed');
-                }
-            });
-        }
         return true;
     }
     sanitizeAccomplishment(payload) {
-        var _a;
         payload.description = payload.description.replace(/[^\x20-\x7E]/g, '');
-        (_a = payload.meta) === null || _a === void 0 ? void 0 : _a.forEach((meta) => {
+        payload.meta?.forEach((meta) => {
             meta.description = meta.description.replace(/[^\x20-\x7E]/g, '');
         });
+        //convert meta keys to snakecase
+        payload.meta?.forEach((meta) => {
+            meta.key = meta.key.replace(/([A-Z])/g, '_$1').toLowerCase();
+        });
         return payload;
     }
     getDecoupledTopic(topic) {

package/dist/controller/AudioController.js

@@ -1,12 +1,3 @@
-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 { EventBus } from '../fromRimori/EventBus';
 /**
  * AudioController is a class that provides methods to record audio. It is a wrapper around the Capacitor Voice Recorder plugin. For more information, see https://github.com/tchvu3/capacitor-voice-recorder.
@@ -16,6 +7,7 @@ import { EventBus } from '../fromRimori/EventBus';
  * await audioController.startRecording();
  */
 export class AudioController {
+    pluginId;
     constructor(pluginId) {
         this.pluginId = pluginId;
     }
@@ -27,10 +19,8 @@ export class AudioController {
      * await audioController.startRecording();
      * @returns void
      */
-    startRecording() {
-        return __awaiter(this, void 0, void 0, function* () {
-            EventBus.emit(this.pluginId, 'global.microphone.triggerStartRecording');
-        });
+    async startRecording() {
+        EventBus.emit(this.pluginId, 'global.microphone.triggerStartRecording');
     }
     /**
      * Stop the recording and return the audio data.
@@ -41,28 +31,20 @@ export class AudioController {
      * audioRef.oncanplaythrough = () => audioRef.play()
      * audioRef.load()
      */
-    stopRecording() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const result = yield EventBus.request(this.pluginId, 'global.microphone.triggerStopRecording');
-            return result.data;
-        });
+    async stopRecording() {
+        const result = await EventBus.request(this.pluginId, 'global.microphone.triggerStopRecording');
+        return result.data;
     }
-    pauseRecording() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const result = yield EventBus.request(this.pluginId, 'global.microphone.triggerPauseRecording');
-            return result.data;
-        });
+    async pauseRecording() {
+        const result = await EventBus.request(this.pluginId, 'global.microphone.triggerPauseRecording');
+        return result.data;
     }
-    resumeRecording() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const result = yield EventBus.request(this.pluginId, 'global.microphone.triggerResumeRecording');
-            return result.data;
-        });
+    async resumeRecording() {
+        const result = await EventBus.request(this.pluginId, 'global.microphone.triggerResumeRecording');
+        return result.data;
     }
-    getCurrentStatus() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const result = yield EventBus.request(this.pluginId, 'global.microphone.triggerGetCurrentStatus');
-            return result.data;
-        });
+    async getCurrentStatus() {
+        const result = await EventBus.request(this.pluginId, 'global.microphone.triggerGetCurrentStatus');
+        return result.data;
     }
 }

package/dist/controller/TranslationController.js

@@ -1,20 +1,17 @@
-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 {
+    currentLanguage;
+    initializationState;
+    initializationPromise;
+    i18n;
+    translationUrl;
+    ai;
+    aiTranslationCache = new Map();
+    aiTranslationPending = new Map();
     constructor(initialLanguage, translationUrl, ai) {
-        this.aiTranslationCache = new Map();
-        this.aiTranslationPending = new Map();
         this.currentLanguage = initialLanguage;
         this.initializationState = 'not-inited';
         this.initializationPromise = null;
@@ -25,59 +22,56 @@ export class Translator {
      * Initialize translator with user's language
      * @param userLanguage - Language code from user info
      */
-    initialize() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // If already finished, return immediately
-            if (this.initializationState === 'finished') {
-                return;
+    async initialize() {
+        // If already finished, return immediately
+        if (this.initializationState === 'finished') {
+            return;
+        }
+        // If currently initializing, wait for the existing initialization to complete
+        if (this.initializationState === 'initing' && this.initializationPromise) {
+            return this.initializationPromise;
+        }
+        // Start initialization
+        this.initializationState = 'initing';
+        // Create a promise that will be resolved when initialization completes
+        this.initializationPromise = (async () => {
+            try {
+                const translations = await this.fetchTranslations(this.currentLanguage);
+                const instance = createInstance({
+                    lng: this.currentLanguage,
+                    resources: {
+                        [this.currentLanguage]: {
+                            translation: translations,
+                        },
+                    },
+                    debug: false,
+                    showSupportNotice: false,
+                    parseMissingKeyHandler: (key, defaultValue) => {
+                        if (!key.trim())
+                            return '';
+                        if (this.isTranslationKey(key)) {
+                            console.warn(`Translation key not found: ${key}`);
+                            return defaultValue ?? '';
+                        }
+                        void this.fetchTranslation(key).then((translation) => {
+                            this.i18n?.addResource(this.currentLanguage, 'translation', key, translation);
+                            this.i18n?.emit('languageChanged'); // triggers re-render
+                        });
+                        return key;
+                    },
+                });
+                await instance.init();
+                this.i18n = instance;
+                this.initializationState = 'finished';
             }
-            // If currently initializing, wait for the existing initialization to complete
-            if (this.initializationState === 'initing' && this.initializationPromise) {
-                return this.initializationPromise;
+            catch (error) {
+                // Reset state on error so it can be retried
+                this.initializationState = 'not-inited';
+                this.initializationPromise = null;
+                throw error;
             }
-            // Start initialization
-            this.initializationState = 'initing';
-            // Create a promise that will be resolved when initialization completes
-            this.initializationPromise = (() => __awaiter(this, void 0, void 0, function* () {
-                try {
-                    const translations = yield this.fetchTranslations(this.currentLanguage);
-                    const instance = createInstance({
-                        lng: this.currentLanguage,
-                        resources: {
-                            [this.currentLanguage]: {
-                                translation: translations,
-                            },
-                        },
-                        debug: false,
-                        showSupportNotice: false,
-                        parseMissingKeyHandler: (key, defaultValue) => {
-                            if (!key.trim())
-                                return '';
-                            if (this.isTranslationKey(key)) {
-                                console.warn(`Translation key not found: ${key}`);
-                                return defaultValue !== null && defaultValue !== void 0 ? defaultValue : '';
-                            }
-                            void this.fetchTranslation(key).then((translation) => {
-                                var _a, _b;
-                                (_a = this.i18n) === null || _a === void 0 ? void 0 : _a.addResource(this.currentLanguage, 'translation', key, translation);
-                                (_b = this.i18n) === null || _b === void 0 ? void 0 : _b.emit('languageChanged'); // triggers re-render
-                            });
-                            return key;
-                        },
-                    });
-                    yield instance.init();
-                    this.i18n = instance;
-                    this.initializationState = 'finished';
-                }
-                catch (error) {
-                    // Reset state on error so it can be retried
-                    this.initializationState = 'not-inited';
-                    this.initializationPromise = null;
-                    throw error;
-                }
-            }))();
-            return this.initializationPromise;
-        });
+        })();
+        return this.initializationPromise;
     }
     getTranslationUrl(language) {
         const baseUrl = this.translationUrl || window.location.origin;
@@ -105,26 +99,24 @@ export class Translator {
      * @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());
+    async fetchTranslations(language) {
+        try {
+            const response = await fetch(this.getTranslationUrl(language));
+            if (!response.ok) {
+                throw new Error(`Failed to fetch translations for ${language}`);
             }
-            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 {};
-                });
-            }
-        });
+            return (await 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 or freeform text. If the key is not a valid translation key, the freeform text is translated using AI and cached.
@@ -154,43 +146,41 @@ export class Translator {
     isTranslationKey(key) {
         return /^[^\s.]+(\.[^\s.]+)+$/.test(key);
     }
-    fetchTranslation(text, additionalInstructions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const cached = this.aiTranslationCache.get(text);
-            if (cached)
-                return cached;
-            const pending = this.aiTranslationPending.get(text);
-            if (pending)
-                return pending;
-            if (!this.ai || this.currentLanguage === 'en')
-                return text;
-            const promise = (() => __awaiter(this, void 0, void 0, function* () {
-                try {
-                    const response = yield this.ai.getObject({
-                        prompt: 'global.translator.translate',
-                        variables: {
-                            additionalInstructions: additionalInstructions !== null && additionalInstructions !== void 0 ? additionalInstructions : '',
-                            language: this.currentLanguage,
-                            text,
-                        },
-                        cache: true,
-                    });
-                    const translation = response === null || response === void 0 ? void 0 : response.translation;
-                    if (translation) {
-                        this.aiTranslationCache.set(text, translation);
-                        return translation;
-                    }
-                }
-                catch (error) {
-                    console.warn('Failed to translate freeform text:', { text, error });
-                }
-                finally {
-                    this.aiTranslationPending.delete(text);
+    async fetchTranslation(text, additionalInstructions) {
+        const cached = this.aiTranslationCache.get(text);
+        if (cached)
+            return cached;
+        const pending = this.aiTranslationPending.get(text);
+        if (pending)
+            return pending;
+        if (!this.ai || this.currentLanguage === 'en')
+            return text;
+        const promise = (async () => {
+            try {
+                const response = await this.ai.getObject({
+                    prompt: 'global.translator.translate',
+                    variables: {
+                        additionalInstructions: additionalInstructions ?? '',
+                        language: this.currentLanguage,
+                        text,
+                    },
+                    cache: true,
+                });
+                const translation = response?.translation;
+                if (translation) {
+                    this.aiTranslationCache.set(text, translation);
+                    return translation;
                 }
-                return text;
-            }))();
-            this.aiTranslationPending.set(text, promise);
-            return promise;
-        });
+            }
+            catch (error) {
+                console.warn('Failed to translate freeform text:', { text, error });
+            }
+            finally {
+                this.aiTranslationPending.delete(text);
+            }
+            return text;
+        })();
+        this.aiTranslationPending.set(text, promise);
+        return promise;
     }
 }