@rimori/react-client 0.1.0

package/dist/rimori-client/src/plugin/RimoriClient.d.ts

@@ -0,0 +1,258 @@
+import { PostgrestQueryBuilder } from '@supabase/postgrest-js';
+import { GenericSchema } from '@supabase/supabase-js/dist/module/lib/types';
+import { Message, OnLLMResponse } from '../controller/AIController';
+import { ObjectRequest } from '../controller/ObjectController';
+import { UserInfo } from '../controller/SettingsController';
+import { SharedContent, SharedContentFilter, SharedContentObjectRequest } from '../controller/SharedContentController';
+import { CreateExerciseParams } from '../controller/ExerciseController';
+import { EventBusMessage, EventHandler, EventPayload } from '../fromRimori/EventBus';
+import { ActivePlugin, MainPanelAction, Plugin, Tool } from '../fromRimori/PluginTypes';
+import { AccomplishmentPayload } from '../controller/AccomplishmentController';
+import { Translator } from '../controller/TranslationController';
+export declare class RimoriClient {
+    private static instance;
+    private superbase;
+    private pluginController;
+    private settingsController;
+    private sharedContentController;
+    private exerciseController;
+    private accomplishmentHandler;
+    private rimoriInfo;
+    private translator;
+    private constructor();
+    get plugin(): {
+        pluginId: string;
+        /**
+         * Set the settings for the plugin.
+         * @param settings The settings to set.
+         */
+        setSettings: (settings: any) => Promise<void>;
+        /**
+         * Get the settings for the plugin. T can be any type of settings, UserSettings or SystemSettings.
+         * @param defaultSettings The default settings to use if no settings are found.
+         * @param genericSettings The type of settings to get.
+         * @returns The settings for the plugin.
+         */
+        getSettings: <T extends object>(defaultSettings: T) => Promise<T>;
+        getUserInfo: () => UserInfo;
+        /**
+         * Retrieves information about plugins, including:
+         * - All installed plugins
+         * - The currently active plugin in the main panel
+         * - The currently active plugin in the side panel
+         */
+        getPluginInfo: () => {
+            /**
+             * All installed plugins.
+             */
+            installedPlugins: Plugin[];
+            /**
+             * The plugin that is loaded in the main panel.
+             */
+            mainPanelPlugin?: ActivePlugin;
+            /**
+             * The plugin that is loaded in the side panel.
+             */
+            sidePanelPlugin?: ActivePlugin;
+        };
+        /**
+         * Get the translator for the plugin.
+         * @returns The translator for the plugin.
+         */
+        getTranslator: () => Promise<Translator>;
+    };
+    get db(): {
+        from: (relation: string) => PostgrestQueryBuilder<GenericSchema, any, any>;
+        /**
+         * The table prefix for of database tables of the plugin.
+         */
+        tablePrefix: string;
+        /**
+         * Get the table name for a given plugin table.
+         * Internally all tables are prefixed with the plugin id. This function is used to get the correct table name for a given public table.
+         * @param table The plugin table name to get the full table name for.
+         * @returns The full table name.
+         */
+        getTableName: (table: string) => string;
+    };
+    event: {
+        /**
+         * Emit an event to Rimori or a plugin.
+         * The topic schema is:
+         * {pluginId}.{eventId}
+         * Check out the event bus documentation for more information.
+         * For triggering events from Rimori like context menu actions use the "global" keyword.
+         * @param topic The topic to emit the event on.
+         * @param data The data to emit.
+         * @param eventId The event id.
+         */
+        emit: (topic: string, data?: any, eventId?: number) => void;
+        /**
+         * Request an event.
+         * @param topic The topic to request the event on.
+         * @param data The data to request.
+         * @returns The response from the event.
+         */
+        request: <T>(topic: string, data?: any) => Promise<EventBusMessage<T>>;
+        /**
+         * Subscribe to an event.
+         * @param topic The topic to subscribe to.
+         * @param callback The callback to call when the event is emitted.
+         * @returns An EventListener object containing an off() method to unsubscribe the listeners.
+         */
+        on: <T = EventPayload>(topic: string | string[], callback: EventHandler<T>) => import("../fromRimori/EventBus").EventListener;
+        /**
+         * Subscribe to an event once.
+         * @param topic The topic to subscribe to.
+         * @param callback The callback to call when the event is emitted.
+         */
+        once: <T = EventPayload>(topic: string, callback: EventHandler<T>) => void;
+        /**
+         * Respond to an event.
+         * @param topic The topic to respond to.
+         * @param data The data to respond with.
+         */
+        respond: <T = EventPayload>(topic: string | string[], data: EventPayload | ((data: EventBusMessage<T>) => EventPayload | Promise<EventPayload>)) => void;
+        /**
+         * Emit an accomplishment.
+         * @param payload The payload to emit.
+         */
+        emitAccomplishment: (payload: AccomplishmentPayload) => void;
+        /**
+         * Subscribe to an accomplishment.
+         * @param accomplishmentTopic The topic to subscribe to.
+         * @param callback The callback to call when the accomplishment is emitted.
+         */
+        onAccomplishment: (accomplishmentTopic: string, callback: (payload: EventBusMessage<AccomplishmentPayload>) => void) => void;
+        /**
+         * Trigger an action that opens the sidebar and triggers an action in the designated plugin.
+         * @param pluginId The id of the plugin to trigger the action for.
+         * @param actionKey The key of the action to trigger.
+         * @param text Optional text to be used for the action like for example text that the translator would look up.
+         */
+        emitSidebarAction: (pluginId: string, actionKey: string, text?: string) => void;
+        onMainPanelAction: (callback: (data: MainPanelAction) => void, actionsToListen?: string[]) => void;
+    };
+    navigation: {
+        toDashboard: () => void;
+    };
+    /**
+     * Get a query parameter value that was passed via MessageChannel
+     * @param key The query parameter key
+     * @returns The query parameter value or null if not found
+     */
+    getQueryParam(key: string): string | null;
+    static getInstance(pluginId?: string): Promise<RimoriClient>;
+    ai: {
+        getText: (messages: Message[], tools?: Tool[]) => Promise<string>;
+        getSteamedText: (messages: Message[], onMessage: OnLLMResponse, tools?: Tool[]) => Promise<void>;
+        getVoice: (text: string, voice?: string, speed?: number, language?: string) => Promise<Blob>;
+        getTextFromVoice: (file: Blob) => Promise<string>;
+        getObject: <T = any>(request: ObjectRequest) => Promise<T>;
+    };
+    runtime: {
+        fetchBackend: (url: string, options: RequestInit) => Promise<Response>;
+    };
+    community: {
+        /**
+         * Shared content is a way to share completable content with other users using this plugin.
+         * Typical examples are assignments, exercises, stories, etc.
+         * Users generate new shared content items and others can complete the content too.
+         */
+        sharedContent: {
+            /**
+             * Get one dedicated shared content item by id. It does not matter if it is completed or not.
+             * @param contentType The type of shared content to get. E.g. assignments, exercises, etc.
+             * @param id The id of the shared content item.
+             * @returns The shared content item.
+             */
+            get: <T = any>(contentType: string, id: string) => Promise<SharedContent<T>>;
+            /**
+             * Get a list of shared content items.
+             * @param contentType The type of shared content to get. E.g. assignments, exercises, etc.
+             * @param filter The optional additional filter for checking new shared content based on a column and value. This is useful if the aditional information stored on the shared content is used to further narrow down the kind of shared content wanted to be received. E.g. only adjective grammar exercises.
+             * @param limit The optional limit for the number of results.
+             * @returns The list of shared content items.
+             */
+            getList: <T = any>(contentType: string, filter?: SharedContentFilter, limit?: number) => Promise<SharedContent<T>[]>;
+            /**
+             * Get new shared content.
+             * @param contentType The type of shared content to fetch. E.g. assignments, exercises, etc.
+             * @param generatorInstructions The instructions for the creation of new shared content. The object will automatically be extended with a tool property with a topic and keywords property to let a new unique topic be generated.
+             * @param filter The optional additional filter for checking new shared content based on a column and value. This is useful if the aditional information stored on the shared content is used to further narrow down the kind of shared content wanted to be received. E.g. only adjective grammar exercises.
+             * @param options An optional object with options for the new shared content.
+             * @param options.privateTopic An optional flag to indicate if the topic should be private and only be visible to the user. This is useful if the topic is not meant to be shared with other users. Like for personal topics or if the content is based on the personal study goal.
+             * @param options.skipDbSave An optional flag to indicate if the new shared content should not be saved to the database. This is useful if the new shared content is not meant to be saved to the database.
+             * @param options.alwaysGenerateNew An optional flag to indicate if the new shared content should always be generated even if there is already a content with the same filter. This is useful if the new shared content is not meant to be saved to the database.
+             * @param options.excludeIds An optional list of ids to exclude from the selection. This is useful if the new shared content is not meant to be saved to the database.
+             * @returns The new shared content.
+             */
+            getNew: <T = any>(contentType: string, generatorInstructions: SharedContentObjectRequest, filter?: SharedContentFilter, options?: {
+                privateTopic?: boolean;
+                skipDbSave?: boolean;
+                alwaysGenerateNew?: boolean;
+                excludeIds?: string[];
+            }) => Promise<SharedContent<T>>;
+            /**
+             * Create a new shared content item.
+             * @param content The content to create.
+             * @returns The new shared content item.
+             */
+            create: <T = any>(content: Omit<SharedContent<T>, "id">) => Promise<SharedContent<T>>;
+            /**
+             * Update a shared content item.
+             * @param id The id of the shared content item to update.
+             * @param content The content to update.
+             * @returns The updated shared content item.
+             */
+            update: <T = any>(id: string, content: Partial<SharedContent<T>>) => Promise<SharedContent<T>>;
+            /**
+             * Complete a shared content item.
+             * @param contentType The type of shared content to complete. E.g. assignments, exercises, etc.
+             * @param assignmentId The id of the shared content item to complete.
+             */
+            complete: (contentType: string, assignmentId: string) => Promise<void>;
+            /**
+             /**
+              * Update the state of a shared content item for a specific user.
+              * Useful for marking content as completed, ongoing, hidden, liked, disliked, or bookmarked.
+              */
+            updateState: (params: {
+                contentType: string;
+                id: string;
+                state?: "completed" | "ongoing" | "hidden";
+                reaction?: "liked" | "disliked" | null;
+                bookmarked?: boolean;
+            }) => Promise<void>;
+            /**
+             * Remove a shared content item.
+             * @param id The id of the shared content item to remove.
+             * @returns The removed shared content item.
+             */
+            remove: (id: string) => Promise<SharedContent<any>>;
+        };
+    };
+    exercise: {
+        /**
+         * Fetches weekly exercises from the weekly_exercises view.
+         * Shows exercises for the current week that haven't expired.
+         * @returns Array of exercise objects.
+         */
+        view: () => Promise<import("../controller/ExerciseController").Exercise[]>;
+        /**
+         * Creates a new exercise via the backend API.
+         * @param params Exercise creation parameters.
+         * @returns Created exercise object.
+         */
+        add: (params: CreateExerciseParams) => Promise<import("../controller/ExerciseController").Exercise>;
+        /**
+         * Deletes an exercise via the backend API.
+         * @param id The exercise ID to delete.
+         * @returns Success status.
+         */
+        delete: (id: string) => Promise<{
+            success: boolean;
+            message: string;
+        }>;
+    };
+}

package/dist/rimori-client/src/plugin/RimoriClient.js

@@ -0,0 +1,375 @@
+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 { generateText, streamChatGPT } from '../controller/AIController';
+import { generateObject } from '../controller/ObjectController';
+import { SettingsController } from '../controller/SettingsController';
+import { SharedContentController, } from '../controller/SharedContentController';
+import { getSTTResponse, getTTSResponse } from '../controller/VoiceController';
+import { ExerciseController } from '../controller/ExerciseController';
+import { EventBus } from '../fromRimori/EventBus';
+import { AccomplishmentController } from '../controller/AccomplishmentController';
+import { RimoriCommunicationHandler } from './CommunicationHandler';
+import { Translator } from '../controller/TranslationController';
+import { Logger } from './Logger';
+export class RimoriClient {
+    constructor(controller, supabase, info) {
+        this.event = {
+            /**
+             * Emit an event to Rimori or a plugin.
+             * The topic schema is:
+             * {pluginId}.{eventId}
+             * Check out the event bus documentation for more information.
+             * For triggering events from Rimori like context menu actions use the "global" keyword.
+             * @param topic The topic to emit the event on.
+             * @param data The data to emit.
+             * @param eventId The event id.
+             */
+            emit: (topic, data, eventId) => {
+                const globalTopic = this.pluginController.getGlobalEventTopic(topic);
+                EventBus.emit(this.plugin.pluginId, globalTopic, data, eventId);
+            },
+            /**
+             * Request an event.
+             * @param topic The topic to request the event on.
+             * @param data The data to request.
+             * @returns The response from the event.
+             */
+            request: (topic, data) => {
+                const globalTopic = this.pluginController.getGlobalEventTopic(topic);
+                return EventBus.request(this.plugin.pluginId, globalTopic, data);
+            },
+            /**
+             * Subscribe to an event.
+             * @param topic The topic to subscribe to.
+             * @param callback The callback to call when the event is emitted.
+             * @returns An EventListener object containing an off() method to unsubscribe the listeners.
+             */
+            on: (topic, callback) => {
+                const topics = Array.isArray(topic) ? topic : [topic];
+                return EventBus.on(topics.map((t) => this.pluginController.getGlobalEventTopic(t)), callback);
+            },
+            /**
+             * Subscribe to an event once.
+             * @param topic The topic to subscribe to.
+             * @param callback The callback to call when the event is emitted.
+             */
+            once: (topic, callback) => {
+                EventBus.once(this.pluginController.getGlobalEventTopic(topic), callback);
+            },
+            /**
+             * Respond to an event.
+             * @param topic The topic to respond to.
+             * @param data The data to respond with.
+             */
+            respond: (topic, data) => {
+                const topics = Array.isArray(topic) ? topic : [topic];
+                EventBus.respond(this.plugin.pluginId, topics.map((t) => this.pluginController.getGlobalEventTopic(t)), data);
+            },
+            /**
+             * Emit an accomplishment.
+             * @param payload The payload to emit.
+             */
+            emitAccomplishment: (payload) => {
+                this.accomplishmentHandler.emitAccomplishment(payload);
+            },
+            /**
+             * Subscribe to an accomplishment.
+             * @param accomplishmentTopic The topic to subscribe to.
+             * @param callback The callback to call when the accomplishment is emitted.
+             */
+            onAccomplishment: (accomplishmentTopic, callback) => {
+                this.accomplishmentHandler.subscribe(accomplishmentTopic, callback);
+            },
+            /**
+             * Trigger an action that opens the sidebar and triggers an action in the designated plugin.
+             * @param pluginId The id of the plugin to trigger the action for.
+             * @param actionKey The key of the action to trigger.
+             * @param text Optional text to be used for the action like for example text that the translator would look up.
+             */
+            emitSidebarAction: (pluginId, actionKey, text) => {
+                this.event.emit('global.sidebar.triggerAction', { plugin_id: pluginId, action_key: actionKey, text });
+            },
+            onMainPanelAction: (callback, actionsToListen = []) => {
+                // this needs to be a emit and on because the main panel action is triggered by the user and not by the plugin
+                this.event.emit('action.requestMain');
+                this.event.on('action.requestMain', ({ data }) => {
+                    if (actionsToListen.includes(data.action)) {
+                        callback(data);
+                    }
+                });
+            },
+        };
+        this.navigation = {
+            toDashboard: () => {
+                this.event.emit('global.navigation.triggerToDashboard');
+            },
+        };
+        this.ai = {
+            getText: (messages, tools) => __awaiter(this, void 0, void 0, function* () {
+                const token = yield this.pluginController.getToken();
+                return generateText(this.pluginController.getBackendUrl(), messages, tools || [], token).then(({ messages }) => messages[0].content[0].text);
+            }),
+            getSteamedText: (messages, onMessage, tools) => __awaiter(this, void 0, void 0, function* () {
+                const token = yield this.pluginController.getToken();
+                streamChatGPT(this.pluginController.getBackendUrl(), messages, tools || [], onMessage, token);
+            }),
+            getVoice: (text_1, ...args_1) => __awaiter(this, [text_1, ...args_1], void 0, function* (text, voice = 'alloy', speed = 1, language) {
+                const token = yield this.pluginController.getToken();
+                return getTTSResponse(this.pluginController.getBackendUrl(), { input: text, voice, speed, language }, token);
+            }),
+            getTextFromVoice: (file) => __awaiter(this, void 0, void 0, function* () {
+                const token = yield this.pluginController.getToken();
+                return getSTTResponse(this.pluginController.getBackendUrl(), file, token);
+            }),
+            getObject: (request) => __awaiter(this, void 0, void 0, function* () {
+                const token = yield this.pluginController.getToken();
+                return generateObject(this.pluginController.getBackendUrl(), request, token);
+            }),
+            // getSteamedObject: this.generateObjectStream,
+        };
+        this.runtime = {
+            fetchBackend: (url, options) => __awaiter(this, void 0, void 0, function* () {
+                const token = yield this.pluginController.getToken();
+                return fetch(this.pluginController.getBackendUrl() + url, Object.assign(Object.assign({}, options), { headers: Object.assign(Object.assign({}, options.headers), { Authorization: `Bearer ${token}` }) }));
+            }),
+        };
+        this.community = {
+            /**
+             * Shared content is a way to share completable content with other users using this plugin.
+             * Typical examples are assignments, exercises, stories, etc.
+             * Users generate new shared content items and others can complete the content too.
+             */
+            sharedContent: {
+                /**
+                 * Get one dedicated shared content item by id. It does not matter if it is completed or not.
+                 * @param contentType The type of shared content to get. E.g. assignments, exercises, etc.
+                 * @param id The id of the shared content item.
+                 * @returns The shared content item.
+                 */
+                get: (contentType, id) => __awaiter(this, void 0, void 0, function* () {
+                    return yield this.sharedContentController.getSharedContent(contentType, id);
+                }),
+                /**
+                 * Get a list of shared content items.
+                 * @param contentType The type of shared content to get. E.g. assignments, exercises, etc.
+                 * @param filter The optional additional filter for checking new shared content based on a column and value. This is useful if the aditional information stored on the shared content is used to further narrow down the kind of shared content wanted to be received. E.g. only adjective grammar exercises.
+                 * @param limit The optional limit for the number of results.
+                 * @returns The list of shared content items.
+                 */
+                getList: (contentType, filter, limit) => __awaiter(this, void 0, void 0, function* () {
+                    return yield this.sharedContentController.getSharedContentList(contentType, filter, limit);
+                }),
+                /**
+                 * Get new shared content.
+                 * @param contentType The type of shared content to fetch. E.g. assignments, exercises, etc.
+                 * @param generatorInstructions The instructions for the creation of new shared content. The object will automatically be extended with a tool property with a topic and keywords property to let a new unique topic be generated.
+                 * @param filter The optional additional filter for checking new shared content based on a column and value. This is useful if the aditional information stored on the shared content is used to further narrow down the kind of shared content wanted to be received. E.g. only adjective grammar exercises.
+                 * @param options An optional object with options for the new shared content.
+                 * @param options.privateTopic An optional flag to indicate if the topic should be private and only be visible to the user. This is useful if the topic is not meant to be shared with other users. Like for personal topics or if the content is based on the personal study goal.
+                 * @param options.skipDbSave An optional flag to indicate if the new shared content should not be saved to the database. This is useful if the new shared content is not meant to be saved to the database.
+                 * @param options.alwaysGenerateNew An optional flag to indicate if the new shared content should always be generated even if there is already a content with the same filter. This is useful if the new shared content is not meant to be saved to the database.
+                 * @param options.excludeIds An optional list of ids to exclude from the selection. This is useful if the new shared content is not meant to be saved to the database.
+                 * @returns The new shared content.
+                 */
+                getNew: (contentType, generatorInstructions, filter, options) => __awaiter(this, void 0, void 0, function* () {
+                    return yield this.sharedContentController.getNewSharedContent(contentType, generatorInstructions, filter, options);
+                }),
+                /**
+                 * Create a new shared content item.
+                 * @param content The content to create.
+                 * @returns The new shared content item.
+                 */
+                create: (content) => __awaiter(this, void 0, void 0, function* () {
+                    return yield this.sharedContentController.createSharedContent(content);
+                }),
+                /**
+                 * Update a shared content item.
+                 * @param id The id of the shared content item to update.
+                 * @param content The content to update.
+                 * @returns The updated shared content item.
+                 */
+                update: (id, content) => __awaiter(this, void 0, void 0, function* () {
+                    return yield this.sharedContentController.updateSharedContent(id, content);
+                }),
+                /**
+                 * Complete a shared content item.
+                 * @param contentType The type of shared content to complete. E.g. assignments, exercises, etc.
+                 * @param assignmentId The id of the shared content item to complete.
+                 */
+                complete: (contentType, assignmentId) => __awaiter(this, void 0, void 0, function* () {
+                    return yield this.sharedContentController.completeSharedContent(contentType, assignmentId);
+                }),
+                /**
+                 /**
+                  * Update the state of a shared content item for a specific user.
+                  * Useful for marking content as completed, ongoing, hidden, liked, disliked, or bookmarked.
+                  */
+                updateState: (params) => __awaiter(this, void 0, void 0, function* () {
+                    return yield this.sharedContentController.updateSharedContentState(params);
+                }),
+                /**
+                 * Remove a shared content item.
+                 * @param id The id of the shared content item to remove.
+                 * @returns The removed shared content item.
+                 */
+                remove: (id) => __awaiter(this, void 0, void 0, function* () {
+                    return yield this.sharedContentController.removeSharedContent(id);
+                }),
+            },
+        };
+        this.exercise = {
+            /**
+             * Fetches weekly exercises from the weekly_exercises view.
+             * Shows exercises for the current week that haven't expired.
+             * @returns Array of exercise objects.
+             */
+            view: () => __awaiter(this, void 0, void 0, function* () {
+                return this.exerciseController.viewWeeklyExercises();
+            }),
+            /**
+             * Creates a new exercise via the backend API.
+             * @param params Exercise creation parameters.
+             * @returns Created exercise object.
+             */
+            add: (params) => __awaiter(this, void 0, void 0, function* () {
+                const token = yield this.pluginController.getToken();
+                const backendUrl = this.pluginController.getBackendUrl();
+                return this.exerciseController.addExercise(token, backendUrl, params);
+            }),
+            /**
+             * Deletes an exercise via the backend API.
+             * @param id The exercise ID to delete.
+             * @returns Success status.
+             */
+            delete: (id) => __awaiter(this, void 0, void 0, function* () {
+                const token = yield this.pluginController.getToken();
+                const backendUrl = this.pluginController.getBackendUrl();
+                return this.exerciseController.deleteExercise(token, backendUrl, id);
+            }),
+        };
+        this.rimoriInfo = info;
+        this.superbase = supabase;
+        this.pluginController = controller;
+        this.exerciseController = new ExerciseController(supabase);
+        this.accomplishmentHandler = new AccomplishmentController(info.pluginId);
+        this.settingsController = new SettingsController(supabase, info.pluginId, info.guild);
+        this.sharedContentController = new SharedContentController(supabase, this);
+        this.translator = new Translator(info.profile.mother_tongue.code);
+        //only init logger in workers and on main plugin pages
+        if (this.getQueryParam('applicationMode') !== 'sidebar') {
+            Logger.getInstance(this);
+        }
+    }
+    get plugin() {
+        return {
+            pluginId: this.rimoriInfo.pluginId,
+            /**
+             * Set the settings for the plugin.
+             * @param settings The settings to set.
+             */
+            setSettings: (settings) => __awaiter(this, void 0, void 0, function* () {
+                yield this.settingsController.setSettings(settings);
+            }),
+            /**
+             * Get the settings for the plugin. T can be any type of settings, UserSettings or SystemSettings.
+             * @param defaultSettings The default settings to use if no settings are found.
+             * @param genericSettings The type of settings to get.
+             * @returns The settings for the plugin.
+             */
+            getSettings: (defaultSettings) => __awaiter(this, void 0, void 0, function* () {
+                return yield this.settingsController.getSettings(defaultSettings);
+            }),
+            getUserInfo: () => {
+                return this.rimoriInfo.profile;
+            },
+            /**
+             * Retrieves information about plugins, including:
+             * - All installed plugins
+             * - The currently active plugin in the main panel
+             * - The currently active plugin in the side panel
+             */
+            getPluginInfo: () => {
+                return {
+                    installedPlugins: this.rimoriInfo.installedPlugins,
+                    mainPanelPlugin: this.rimoriInfo.mainPanelPlugin,
+                    sidePanelPlugin: this.rimoriInfo.sidePanelPlugin,
+                };
+            },
+            /**
+             * Get the translator for the plugin.
+             * @returns The translator for the plugin.
+             */
+            getTranslator: () => __awaiter(this, void 0, void 0, function* () {
+                yield this.translator.initialize();
+                return this.translator;
+            }),
+        };
+    }
+    get db() {
+        return {
+            //     private from<
+            //   TableName extends string & keyof GenericSchema['Tables'],
+            //   Table extends GenericSchema['Tables'][TableName],
+            // >(relation: TableName): PostgrestQueryBuilder<GenericSchema, Table, TableName>;
+            // private from<ViewName extends string & keyof GenericSchema['Views'], View extends GenericSchema['Views'][ViewName]>(
+            //   relation: ViewName,
+            // ): PostgrestQueryBuilder<GenericSchema, View, ViewName>;
+            from: (relation) => {
+                return this.superbase.from(this.db.getTableName(relation));
+            },
+            // storage: this.superbase.storage,
+            // functions: this.superbase.functions,
+            /**
+             * The table prefix for of database tables of the plugin.
+             */
+            tablePrefix: this.rimoriInfo.tablePrefix,
+            /**
+             * Get the table name for a given plugin table.
+             * Internally all tables are prefixed with the plugin id. This function is used to get the correct table name for a given public table.
+             * @param table The plugin table name to get the full table name for.
+             * @returns The full table name.
+             */
+            getTableName: (table) => {
+                if (/[A-Z]/.test(table)) {
+                    throw new Error('Table name cannot include uppercase letters. Please use snake_case for table names.');
+                }
+                if (table.startsWith('global_')) {
+                    return table.replace('global_', '');
+                }
+                return this.db.tablePrefix + '_' + table;
+            },
+        };
+    }
+    /**
+     * Get a query parameter value that was passed via MessageChannel
+     * @param key The query parameter key
+     * @returns The query parameter value or null if not found
+     */
+    getQueryParam(key) {
+        return this.pluginController.getQueryParam(key);
+    }
+    static getInstance(pluginId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!RimoriClient.instance) {
+                if (!pluginId)
+                    throw new Error('Plugin ID is required');
+                const controller = new RimoriCommunicationHandler(pluginId, false);
+                if (typeof WorkerGlobalScope === 'undefined') {
+                    // In standalone mode, use URL fallback. In iframe mode, theme will be set after MessageChannel init
+                    // setTheme();
+                    // await StandaloneClient.initListeners(pluginId);
+                }
+                const client = yield controller.getClient();
+                RimoriClient.instance = new RimoriClient(controller, client.supabase, client.info);
+            }
+            return RimoriClient.instance;
+        });
+    }
+}

package/dist/rimori-client/src/plugin/StandaloneClient.d.ts

@@ -0,0 +1,17 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+export interface StandaloneConfig {
+    url: string;
+    key: string;
+    backendUrl?: string;
+}
+export declare class StandaloneClient {
+    private static instance;
+    private config;
+    private supabase;
+    private constructor();
+    static getInstance(): Promise<StandaloneClient>;
+    getClient(): Promise<SupabaseClient>;
+    needsLogin(): Promise<boolean>;
+    login(email: string, password: string): Promise<boolean>;
+    static initListeners(pluginId: string): Promise<void>;
+}