@rimori/react-client 0.1.0

package/dist/rimori-client/src/controller/SharedContentController.js

@@ -0,0 +1,285 @@
+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());
+    });
+};
+export class SharedContentController {
+    constructor(supabase, rimoriClient) {
+        this.supabase = supabase;
+        this.rimoriClient = rimoriClient;
+    }
+    /**
+     * Fetch new shared content for a given content type.
+     * @param contentType - The type of content to fetch.
+     * @param generatorInstructions - The instructions for the generator. The object needs to have a tool property with a topic and keywords property to let a new unique topic be generated.
+     * @param filter - An optional filter to apply to the query.
+     * @param options - Optional options.
+     * @param options.privateTopic - If the topic should be private and only be visible to the user.
+     * @param options.skipDbSave - If true, do not persist a newly generated content to the DB (default false).
+     * @param options.alwaysGenerateNew - If true, always generate a new content even if there is already a content with the same filter.
+     * @param options.excludeIds - Optional list of shared_content ids to exclude from selection.
+     * @returns The new shared content.
+     */
+    getNewSharedContent(contentType, generatorInstructions, 
+    //this filter is there if the content should be filtered additionally by a column and value
+    filter, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let query = this.supabase
+                .from('shared_content')
+                .select('*, scc:shared_content_completed(id, state)')
+                .eq('content_type', contentType)
+                .not('scc.state', 'in', '("completed","ongoing","hidden")')
+                .is('deleted_at', null);
+            if ((options === null || options === void 0 ? void 0 : options.excludeIds) && options.excludeIds.length > 0) {
+                const excludeIds = options.excludeIds.filter((id) => !id.startsWith('internal-temp-id-'));
+                // Supabase expects raw PostgREST syntax like '("id1","id2")'.
+                const excludeList = `(${excludeIds.map((id) => `"${id}"`).join(',')})`;
+                query = query.not('id', 'in', excludeList);
+            }
+            if (filter) {
+                query.contains('data', filter);
+            }
+            const { data: newAssignments, error } = yield query.limit(30);
+            if (error) {
+                console.error('error fetching new assignments:', error);
+                throw new Error('error fetching new assignments');
+            }
+            // console.log('newAssignments:', newAssignments);
+            if (!(options === null || options === void 0 ? void 0 : options.alwaysGenerateNew) && newAssignments.length > 0) {
+                const index = Math.floor(Math.random() * newAssignments.length);
+                return newAssignments[index];
+            }
+            const instructions = yield this.generateNewAssignment(contentType, generatorInstructions, filter);
+            console.log('instructions:', instructions);
+            //create the shared content object
+            const data = {
+                id: 'internal-temp-id-' + Math.random().toString(36).substring(2, 15),
+                contentType,
+                title: instructions.title,
+                keywords: instructions.keywords.map(({ text }) => text),
+                data: Object.assign(Object.assign(Object.assign({}, instructions), { title: undefined, keywords: undefined }), generatorInstructions.fixedProperties),
+                privateTopic: options === null || options === void 0 ? void 0 : options.privateTopic,
+            };
+            if (options === null || options === void 0 ? void 0 : options.skipDbSave) {
+                return data;
+            }
+            return yield this.createSharedContent(data);
+        });
+    }
+    generateNewAssignment(contentType, generatorInstructions, filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fullInstructions = yield this.getGeneratorInstructions(contentType, generatorInstructions, filter);
+            console.log('fullInstructions:', fullInstructions);
+            return yield this.rimoriClient.ai.getObject(fullInstructions);
+        });
+    }
+    getGeneratorInstructions(contentType, generatorInstructions, filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const completedTopics = yield this.getCompletedTopics(contentType, filter);
+            generatorInstructions.instructions += `
+    The following topics are already taken: ${completedTopics.join(', ')}`;
+            generatorInstructions.tool.title = {
+                type: 'string',
+                description: 'What the topic is about. Short. ',
+            };
+            generatorInstructions.tool.keywords = {
+                type: [{ text: { type: 'string' } }],
+                description: 'Keywords around the topic of the assignment.',
+            };
+            return generatorInstructions;
+        });
+    }
+    getCompletedTopics(contentType, filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = this.supabase
+                .from('shared_content')
+                .select('title, keywords, scc:shared_content_completed(id)')
+                .eq('content_type', contentType)
+                .not('scc.id', 'is', null)
+                .is('deleted_at', null);
+            if (filter) {
+                query.contains('data', filter);
+            }
+            const { data: oldAssignments, error } = yield query;
+            if (error) {
+                console.error('error fetching old assignments:', error);
+                return [];
+            }
+            return oldAssignments.map(({ title, keywords }) => `${title}(${keywords.join(',')})`);
+        });
+    }
+    getSharedContent(contentType, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data, error } = yield this.supabase
+                .from('shared_content')
+                .select()
+                .eq('content_type', contentType)
+                .eq('id', id)
+                .is('deleted_at', null)
+                .single();
+            if (error) {
+                console.error('error fetching shared content:', error);
+                throw new Error('error fetching shared content');
+            }
+            return data;
+        });
+    }
+    completeSharedContent(contentType, assignmentId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Idempotent completion: upsert on (id, user_id) so repeated calls don't fail
+            const { error } = yield this.supabase
+                .from('shared_content_completed')
+                .upsert({ content_type: contentType, id: assignmentId }, { onConflict: 'id' });
+            if (error) {
+                console.error('error completing shared content:', error);
+                throw new Error('error completing shared content');
+            }
+        });
+    }
+    /**
+     * Update state details for a shared content entry in shared_content_completed.
+     * Assumes table has columns: state ('completed'|'ongoing'|'hidden'), reaction ('liked'|'disliked'|null), bookmarked boolean.
+     * Upserts per (id, content_type, user).
+     * @param param
+     * @param param.contentType - The content type.
+     * @param param.id - The shared content id.
+     * @param param.state - The state to set.
+     * @param param.reaction - Optional reaction.
+     * @param param.bookmarked - Optional bookmark flag.
+     */
+    updateSharedContentState(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ contentType, id, state, reaction, bookmarked, }) {
+            const payload = { content_type: contentType, id };
+            if (state !== undefined)
+                payload.state = state;
+            if (reaction !== undefined)
+                payload.reaction = reaction;
+            if (bookmarked !== undefined)
+                payload.bookmarked = bookmarked;
+            // Prefer upsert, fall back to insert/update if upsert not allowed
+            const { error } = yield this.supabase.from('shared_content_completed').upsert(payload, { onConflict: 'id' });
+            if (error) {
+                console.error('error updating shared content state:', error);
+                throw new Error('error updating shared content state');
+            }
+        });
+    }
+    /**
+     * Fetch shared content from the database based on optional filters.
+     * @param contentType - The type of content to fetch.
+     * @param filter - Optional filter to apply to the query.
+     * @param limit - Optional limit for the number of results.
+     * @returns Array of shared content matching the criteria.
+     */
+    getSharedContentList(contentType, filter, limit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = this.supabase
+                .from('shared_content')
+                .select('*')
+                .eq('content_type', contentType)
+                .is('deleted_at', null)
+                .limit(limit !== null && limit !== void 0 ? limit : 30);
+            if (filter) {
+                query.contains('data', filter);
+            }
+            const { data, error } = yield query;
+            if (error) {
+                console.error('error fetching shared content:', error);
+                throw new Error('error fetching shared content');
+            }
+            return data;
+        });
+    }
+    /**
+     * Insert new shared content into the database.
+     * @param param
+     * @param param.contentType - The type of content to insert.
+     * @param param.title - The title of the content.
+     * @param param.keywords - Keywords associated with the content.
+     * @param param.data - The content data to store.
+     * @param param.privateTopic - Optional flag to indicate if the topic should be private.
+     * @returns The inserted shared content.
+     * @throws {Error} if insertion fails.
+     */
+    createSharedContent(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ contentType, title, keywords, data, privateTopic, }) {
+            const { data: newContent, error } = yield this.supabase
+                .from('shared_content')
+                .insert({
+                private: privateTopic,
+                content_type: contentType,
+                title,
+                keywords,
+                data,
+            })
+                .select();
+            if (error) {
+                console.error('error inserting shared content:', error);
+                throw new Error('error inserting shared content');
+            }
+            return newContent[0];
+        });
+    }
+    /**
+     * Update existing shared content in the database.
+     * @param id - The ID of the content to update.
+     * @param updates - The updates to apply to the shared content.
+     * @returns The updated shared content.
+     * @throws {Error} if update fails.
+     */
+    updateSharedContent(id, updates) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const updateData = {};
+            if (updates.contentType)
+                updateData.content_type = updates.contentType;
+            if (updates.title)
+                updateData.title = updates.title;
+            if (updates.keywords)
+                updateData.keywords = updates.keywords;
+            if (updates.data)
+                updateData.data = updates.data;
+            if (updates.privateTopic !== undefined)
+                updateData.private = updates.privateTopic;
+            const { data: updatedContent, error } = yield this.supabase
+                .from('shared_content')
+                .update(updateData)
+                .eq('id', id)
+                .select();
+            if (error) {
+                console.error('error updating shared content:', error);
+                throw new Error('error updating shared content');
+            }
+            if (!updatedContent || updatedContent.length === 0) {
+                throw new Error('shared content not found');
+            }
+            return updatedContent[0];
+        });
+    }
+    /**
+     * Soft delete shared content by setting the deleted_at timestamp.
+     * @param id - The ID of the content to delete.
+     * @returns The deleted shared content record.
+     * @throws {Error} if deletion fails or content not found.
+     */
+    removeSharedContent(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data: deletedContent, error } = yield this.supabase
+                .from('shared_content')
+                .update({ deleted_at: new Date().toISOString() })
+                .eq('id', id)
+                .select();
+            if (error) {
+                console.error('error deleting shared content:', error);
+                throw new Error('error deleting shared content');
+            }
+            if (!deletedContent || deletedContent.length === 0) {
+                throw new Error('shared content not found or already deleted');
+            }
+            return deletedContent[0];
+        });
+    }
+}

package/dist/rimori-client/src/controller/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/rimori-client/src/controller/TranslationController.js

@@ -0,0 +1,106 @@
+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
+        if (window.location.hostname === 'localhost') {
+            const filename = language !== 'en' ? `local-${language}` : language;
+            return `${window.location.origin}/locales/${filename}.json`;
+        }
+        return `./locales/${language}.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/rimori-client/src/controller/VoiceController.d.ts

@@ -0,0 +1,9 @@
+export declare function getSTTResponse(backendUrl: string, audio: Blob, token: string): Promise<string>;
+export declare function getTTSResponse(backendUrl: string, request: TTSRequest, token: string): Promise<Blob>;
+interface TTSRequest {
+    input: string;
+    voice: string;
+    speed: number;
+    language?: string;
+}
+export {};

package/dist/rimori-client/src/controller/VoiceController.js

@@ -0,0 +1,37 @@
+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());
+    });
+};
+export function getSTTResponse(backendUrl, audio, token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const formData = new FormData();
+        formData.append('file', audio);
+        return yield fetch(`${backendUrl}/voice/stt`, {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${token}` },
+            body: formData,
+        })
+            .then((r) => r.json())
+            .then((r) => {
+            // console.log("STT response: ", r);
+            return r.text;
+        });
+    });
+}
+export function getTTSResponse(backendUrl, request, token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield fetch(`${backendUrl}/voice/tts`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify(request),
+        }).then((r) => r.blob());
+    });
+}

package/dist/rimori-client/src/fromRimori/EventBus.d.ts

@@ -0,0 +1,101 @@
+export type EventPayload = Record<string, any>;
+/**
+ * Interface representing a message sent through the EventBus
+ *
+ * Debug capabilities:
+ * - System-wide debugging: Send an event to "global.system.requestDebug"
+ *   Example: `EventBus.emit("yourPluginId", "global.system.requestDebug");`
+ */
+export interface EventBusMessage<T = EventPayload> {
+    timestamp: string;
+    eventId: number;
+    sender: string;
+    topic: string;
+    data: T;
+    debug: boolean;
+}
+export type EventHandler<T = EventPayload> = (event: EventBusMessage<T>) => void | Promise<void>;
+export interface EventListener {
+    off: () => void;
+}
+export declare class EventBusHandler {
+    private listeners;
+    private responseResolvers;
+    private static instance;
+    private debugEnabled;
+    private evName;
+    private constructor();
+    static getInstance(name?: string): EventBusHandler;
+    private createEvent;
+    /**
+     * Emits an event to the event bus. Can be a new event or a response to a request.
+     * @param sender - The sender of the event.
+     * @param topic - The topic of the event.
+     * @param data - The data of the event.
+     * @param eventId - The event id of the event.
+     *
+     * The topic format is: **pluginId.area.action**
+     *
+     * Example topics:
+     * - pl1234.card.requestHard
+     * - pl1234.card.requestNew
+     * - pl1234.card.requestAll
+     * - pl1234.card.create
+     * - pl1234.card.update
+     * - pl1234.card.delete
+     * - pl1234.card.triggerBackup
+     */
+    emit<T = EventPayload>(sender: string, topic: string, data?: T, eventId?: number): void;
+    private emitInternal;
+    /**
+     * Subscribes to an event on the event bus.
+     * @param topics - The topic of the event.
+     * @param handler - The handler to be called when the event is emitted.
+     * @param ignoreSender - The senders to ignore.
+     * @returns An EventListener object containing an off() method to unsubscribe the listeners.
+     */
+    on<T = EventPayload>(topics: string | string[], handler: EventHandler<T>, ignoreSender?: string[]): EventListener;
+    /**
+     * Subscribes to an event, processes the data and emits a response on the event bus.
+     * @param sender - The sender of the event.
+     * @param topic - The topic of the event.
+     * @param handler - The handler to be called when the event is received. The handler returns the data to be emitted. Can be a static object or a function.
+     * @returns An EventListener object containing an off() method to unsubscribe the listeners.
+     */
+    respond(sender: string, topic: string | string[], handler: EventPayload | ((data: EventBusMessage) => EventPayload | Promise<EventPayload>)): EventListener;
+    /**
+     * Subscribes to an event on the event bus. The handler will be called once and then removed.
+     * @param topic - The topic of the event.
+     * @param handler - The handler to be called when the event is emitted.
+     */
+    once<T = EventPayload>(topic: string, handler: EventHandler<T>): void;
+    /**
+     * Unsubscribes from an event on the event bus.
+     * @param listenerIds - The ids of the listeners to unsubscribe from.
+     */
+    private off;
+    private toArray;
+    /**
+     * Requests data from the event bus.
+     * @param sender - The sender of the event.
+     * @param topic - The topic of the event.
+     * @param data - The data of the event.
+     * @returns A promise that resolves to the event.
+     */
+    request<T = EventPayload>(sender: string, topic: string, data?: EventPayload): Promise<EventBusMessage<T>>;
+    /**
+     * Gets the matching handlers for an event.
+     * @param topic - The topic of the event.
+     * @returns A set of handlers that match the event type.
+     */
+    private getMatchingHandlers;
+    /**
+     * Validates the topic of an event.
+     * @param topic - The topic of the event.
+     * @returns True if the topic is valid, false otherwise.
+     */
+    private validateTopic;
+    private logIfDebug;
+    private logAndThrowError;
+}
+export declare const EventBus: EventBusHandler;