@rimori/client 1.0.4 → 1.1.0

package/dist/plugin/RimoriClient.js

@@ -7,12 +7,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+import { generateText, streamChatGPT } from "../controller/AIController";
+import { generateObject as generateObjectFunction } from "../controller/ObjectController";
 import { SettingsController } from "../controller/SettingsController";
-import { getSTTResponse, getTTSResponse } from "../controller/VoiceController";
 import { SharedContentController } from "../controller/SharedContentController";
-import { streamChatGPT, generateText } from "../controller/AIController";
-import { generateObject as generateObjectFunction } from "../controller/ObjectController";
 import { getPlugins } from "../controller/SidePluginController";
+import { getSTTResponse, getTTSResponse } from "../controller/VoiceController";
+import { AccomplishmentHandler } from "./AccomplishmentHandler";
 import { EventBus } from "./fromRimori/EventBus";
 export class RimoriClient {
     constructor(options) {
@@ -45,9 +46,11 @@ export class RimoriClient {
              * Subscribe to an event.
              * @param topic The topic to subscribe to.
              * @param callback The callback to call when the event is emitted.
+             * @returns The unsubscribe ids.
              */
             on: (topic, callback) => {
-                EventBus.on(this.pluginController.getGlobalEventTopic(topic), callback);
+                const topics = Array.isArray(topic) ? topic : [topic];
+                return topics.map(topic => EventBus.on(this.pluginController.getGlobalEventTopic(topic), callback));
             },
             /**
              * Subscribe to an event once.
@@ -64,45 +67,134 @@ export class RimoriClient {
              */
             respond: (topic, data) => {
                 EventBus.respond(this.plugin.pluginId, this.pluginController.getGlobalEventTopic(topic), 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", { pluginId, actionKey, text });
             }
         };
         this.llm = {
             getText: (messages, tools) => __awaiter(this, void 0, void 0, function* () {
                 const token = yield this.pluginController.getToken();
-                return generateText(this.supabaseUrl, messages, tools || [], token).then(response => response.messages[0].content[0].text);
+                return generateText(this.supabaseUrl, 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.supabaseUrl, messages, tools || [], onMessage, token);
             }),
             getVoice: (text_1, ...args_1) => __awaiter(this, [text_1, ...args_1], void 0, function* (text, voice = "alloy", speed = 1, language) {
-                return getTTSResponse(this.pluginController.getSupabaseUrl(), { input: text, voice, speed, language }, yield this.pluginController.getToken());
+                const token = yield this.pluginController.getToken();
+                return getTTSResponse(this.supabaseUrl, { input: text, voice, speed, language }, token);
             }),
             getTextFromVoice: (file) => {
                 return getSTTResponse(this.superbase, file);
             },
             getObject: (request) => __awaiter(this, void 0, void 0, function* () {
                 const token = yield this.pluginController.getToken();
-                return generateObjectFunction(this.pluginController.getSupabaseUrl(), request, token);
+                return generateObjectFunction(this.supabaseUrl, request, token);
             }),
             // getSteamedObject: this.generateObjectStream,
         };
+        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 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.
+                 * @returns The new shared content.
+                 */
+                getNew: (contentType, generatorInstructions, filter, privateTopic) => __awaiter(this, void 0, void 0, function* () {
+                    return yield this.sharedContentController.getNewSharedContent(contentType, generatorInstructions, filter, privateTopic);
+                }),
+                /**
+                 * 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);
+                })
+            }
+        };
         this.superbase = options.supabase;
         this.pluginController = options.pluginController;
         this.settingsController = new SettingsController(options.supabase, options.pluginId);
-        this.sharedContentController = new SharedContentController(this);
+        this.sharedContentController = new SharedContentController(this.superbase, this);
         this.supabaseUrl = this.pluginController.getSupabaseUrl();
-        this.rpc = this.rpc.bind(this);
+        this.accomplishmentHandler = new AccomplishmentHandler(options.pluginId);
         this.from = this.from.bind(this);
         this.db = {
-            rpc: this.rpc,
             from: this.from,
             storage: this.superbase.storage,
-            functions: this.superbase.functions,
+            // functions: this.superbase.functions,
+            tablePrefix: options.tablePrefix,
+            getTableName: this.getTableName.bind(this),
         };
         this.plugin = {
             pluginId: options.pluginId,
-            tablePrefix: options.tablePrefix,
             setSettings: (settings) => __awaiter(this, void 0, void 0, function* () {
                 yield this.settingsController.setSettings(settings);
             }),
@@ -129,69 +221,7 @@ export class RimoriClient {
     from(relation) {
         return this.superbase.from(this.getTableName(relation));
     }
-    /**
-    * Perform a function call.
-    *
-    * @param functionName - The function name to call
-    * @param args - The arguments to pass to the function call
-    * @param options - Named parameters
-    * @param options.head - When set to `true`, `data` will not be returned.
-    * Useful if you only need the count.
-    * @param options.get - When set to `true`, the function will be called with
-    * read-only access mode.
-    * @param options.count - Count algorithm to use to count rows returned by the
-    * function. Only applicable for [set-returning
-    * functions](https://www.postgresql.org/docs/current/functions-srf.html).
-    *
-    * `"exact"`: Exact but slow count algorithm. Performs a `COUNT(*)` under the
-    * hood.
-    *
-    * `"planned"`: Approximated but fast count algorithm. Uses the Postgres
-    * statistics under the hood.
-    *
-    * `"estimated"`: Uses exact count for low numbers and planned count for high
-    * numbers.
-    */
-    rpc(functionName, args = {}, options = {}) {
-        return this.superbase.rpc(this.getTableName(functionName), args, options);
-    }
     getTableName(type) {
-        return this.plugin.tablePrefix + "_" + type;
-    }
-    /**
-     * Fetch new shared content.
-     * @param type The type of shared content to fetch. E.g. assignments, exercises, etc.
-     * @param generatorInstructions The instructions for the generator.
-     * @param filter The filter for the shared content.
-     * @returns The new shared content.
-     */
-    fetchNewSharedContent(type, generatorInstructions, filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.sharedContentController.fetchNewSharedContent(type, generatorInstructions, filter);
-        });
-    }
-    /**
-     * Get a shared content item by id.
-     * @param type 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.
-     */
-    getSharedContent(type, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.sharedContentController.getSharedContent(type, id);
-        });
-    }
-    /**
-     * Complete a shared content item.
-     * @param type The type of shared content to complete. E.g. assignments, exercises, etc.
-     * @param assignmentId The id of the shared content item to complete.
-     */
-    completeSharedContent(type, assignmentId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.sharedContentController.completeSharedContent(type, assignmentId);
-        });
-    }
-    triggerSidebarAction(pluginId, actionKey, text) {
-        this.event.emit("global.sidebar.triggerAction", { pluginId, actionKey, text });
+        return this.db.tablePrefix + "_" + type;
     }
 }

package/dist/plugin/ThemeSetter.js

@@ -1,13 +1,13 @@
 export function setTheme() {
     const urlParams = new URLSearchParams(window.location.search);
     let theme = urlParams.get('theme');
-    const isSidebar = urlParams.get('applicationMode') === "sidebar";
     if (!theme || theme === 'system') {
         theme = window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
     }
-    document.documentElement.classList.add("dark:text-gray-200", "bg-white");
+    document.documentElement.classList.add("dark:text-gray-200");
     if (theme === 'dark') {
-        document.documentElement.classList.add('dark', isSidebar ? "bg-gray-920" : "bg-gray-950");
-        document.documentElement.style.background = isSidebar ? "rgb(6, 12, 30)" : "rgb(3, 7, 18)";
+        document.documentElement.setAttribute("data-theme", "dark");
+        document.documentElement.classList.add('dark', "dark:bg-gray-950");
+        document.documentElement.style.background = "hsl(var(--background))";
     }
 }

package/dist/plugin/fromRimori/EventBus.d.ts

@@ -15,6 +15,9 @@ export interface EventBusMessage<T = EventPayload> {
     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;
@@ -51,7 +54,7 @@ export declare class EventBusHandler {
      * @param ignoreSender - The senders to ignore.
      * @returns The ids of the listeners.
      */
-    on<T = EventPayload>(topics: string | string[], handler: EventHandler<T>, ignoreSender?: string[]): string[];
+    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.
@@ -59,7 +62,7 @@ export declare class EventBusHandler {
      * @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 The ids of the listeners.
      */
-    respond(sender: string, topic: string, handler: EventPayload | ((data: EventBusMessage) => EventPayload | Promise<EventPayload>)): string[];
+    respond(sender: string, topic: 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.
@@ -70,7 +73,7 @@ export declare class EventBusHandler {
      * Unsubscribes from an event on the event bus.
      * @param listenerIds - The ids of the listeners to unsubscribe from.
      */
-    off(listenerIds: string | string[]): void;
+    private off;
     private toArray;
     /**
      * Requests data from the event bus.

package/dist/plugin/fromRimori/EventBus.js

@@ -11,7 +11,7 @@ export class EventBusHandler {
     constructor() {
         this.listeners = new Map();
         this.responseResolvers = new Map();
-        this.debugEnabled = false;
+        this.debugEnabled = true;
         this.evName = "";
         //private constructor
     }
@@ -93,7 +93,8 @@ export class EventBusHandler {
      * @returns The ids of the listeners.
      */
     on(topics, handler, ignoreSender = []) {
-        return this.toArray(topics).map(topic => {
+        const ids = this.toArray(topics).map(topic => {
+            this.logIfDebug(`Subscribing to ` + topic, { ignoreSender });
             if (!this.validateTopic(topic)) {
                 this.logAndThrowError(true, `Invalid topic: ` + topic);
             }
@@ -107,6 +108,9 @@ export class EventBusHandler {
             this.logIfDebug(`Subscribed to ` + topic, { listenerId: id, ignoreSender });
             return btoa(JSON.stringify({ topic, id }));
         });
+        return {
+            off: () => this.off(ids)
+        };
     }
     /**
      * Subscribes to an event, processes the data and emits a response on the event bus.
@@ -116,12 +120,14 @@ export class EventBusHandler {
      * @returns The ids of the listeners.
      */
     respond(sender, topic, handler) {
-        const ids = this.on(topic, (data) => __awaiter(this, void 0, void 0, function* () {
+        const listener = this.on(topic, (data) => __awaiter(this, void 0, void 0, function* () {
             const response = typeof handler === "function" ? yield handler(data) : handler;
             this.emit(sender, topic, response, data.eventId);
         }), [sender]);
-        this.logIfDebug(`Added respond listener ` + sender + " to topic " + topic, { listenerIds: ids, sender });
-        return ids;
+        this.logIfDebug(`Added respond listener ` + sender + " to topic " + topic, { listener, sender });
+        return {
+            off: () => listener.off()
+        };
     }
     /**
      * Subscribes to an event on the event bus. The handler will be called once and then removed.
@@ -133,13 +139,13 @@ export class EventBusHandler {
             this.logAndThrowError(false, `Invalid topic: ` + topic);
             return;
         }
-        let ids = [];
+        let listener;
         const wrapper = (event) => {
             handler(event);
-            this.off(ids);
+            listener === null || listener === void 0 ? void 0 : listener.off();
         };
-        ids = this.on(topic, wrapper);
-        this.logIfDebug(`Added once listener ` + topic, { listenerIds: ids, topic });
+        listener = this.on(topic, wrapper);
+        this.logIfDebug(`Added once listener ` + topic, { listener, topic });
     }
     /**
      * Unsubscribes from an event on the event bus.

package/dist/plugin/fromRimori/PluginTypes.d.ts

@@ -0,0 +1,51 @@
+export interface Plugin {
+    id: string;
+    title: string;
+    description: string;
+    git_repository: string;
+    website: string;
+    icon_url: string;
+    version: string;
+    author: string;
+    endpoint: string;
+    context_menu_actions: MenuEntry[];
+    plugin_pages: PluginPage[];
+    sidebar_pages: SidebarPage[];
+    settings_page: string;
+    worker?: {
+        url: string;
+        topics?: string[];
+    };
+}
+export interface PluginPage {
+    name: string;
+    url: string;
+    show: boolean;
+    description: string;
+    root: string;
+    action?: (Record<string, string> & {
+        key: string;
+    });
+}
+export interface SidebarPage {
+    name: string;
+    url: string;
+    iconUrl: string;
+    description: string;
+    actionKey: string;
+}
+export interface MenuEntry {
+    text: string;
+    pluginId: string;
+    actionKey: string;
+    icon?: React.ReactNode;
+}
+export type MainPanelAction = {
+    pluginId: string;
+    actionKey: string;
+} & Record<string, string>;
+export interface ContextMenuAction {
+    text: string;
+    pluginId: string;
+    actionKey: string;
+}

package/dist/plugin/fromRimori/PluginTypes.js

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

package/dist/providers/PluginController.d.ts

@@ -0,0 +1,21 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+import { RimoriClient } from "../plugin/RimoriClient";
+export declare class PluginController {
+    private static client;
+    private static instance;
+    private communicationSecret;
+    private supabase;
+    private supabaseInfo;
+    private pluginId;
+    private constructor();
+    static getInstance(sender: string): Promise<RimoriClient>;
+    private getSecret;
+    getClient(): Promise<{
+        supabase: SupabaseClient;
+        tablePrefix: string;
+        pluginId: string;
+    }>;
+    getToken(): Promise<string>;
+    getSupabaseUrl(): string;
+    getGlobalEventTopic(preliminaryTopic: string): string;
+}

package/dist/providers/PluginController.js

@@ -0,0 +1,116 @@
+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 { createClient } from '@supabase/supabase-js';
+import { EventBus } from '../plugin/fromRimori/EventBus';
+import { RimoriClient } from "../plugin/RimoriClient";
+import { setTheme } from '../plugin/ThemeSetter';
+export class PluginController {
+    constructor(pluginId) {
+        this.communicationSecret = null;
+        this.supabase = null;
+        this.supabaseInfo = null;
+        this.pluginId = pluginId;
+        this.getClient = this.getClient.bind(this);
+        if (typeof WorkerGlobalScope === 'undefined') {
+            setTheme();
+        }
+        window.addEventListener("message", (event) => {
+            // console.log("client: message received", event);
+            const { topic, sender, data, eventId } = event.data.event;
+            // skip forwarding messages from own plugin
+            if (sender === pluginId)
+                return;
+            EventBus.emit(sender, topic, data, eventId);
+        });
+        EventBus.on("*", (event) => {
+            // skip messages which are not from the own plugin
+            if (event.sender !== this.pluginId)
+                return;
+            if (event.topic.startsWith("self."))
+                return;
+            window.parent.postMessage({ event, secret: this.getSecret() }, "*");
+        });
+    }
+    static getInstance(sender) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!PluginController.instance) {
+                PluginController.instance = new PluginController(sender);
+                PluginController.client = yield RimoriClient.getInstance(PluginController.instance);
+            }
+            return PluginController.client;
+        });
+    }
+    getSecret() {
+        if (!this.communicationSecret) {
+            const secret = new URLSearchParams(window.location.search).get("secret");
+            if (!secret) {
+                throw new Error("Communication secret not found in URL as query parameter");
+            }
+            this.communicationSecret = secret;
+        }
+        return this.communicationSecret;
+    }
+    getClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.supabase &&
+                this.supabaseInfo &&
+                this.supabaseInfo.expiration > new Date()) {
+                return { supabase: this.supabase, tablePrefix: this.supabaseInfo.tablePrefix, pluginId: this.supabaseInfo.pluginId };
+            }
+            const { data } = yield EventBus.request(this.pluginId, "global.supabase.requestAccess");
+            this.supabaseInfo = data;
+            this.supabase = createClient(this.supabaseInfo.url, this.supabaseInfo.key, {
+                accessToken: () => Promise.resolve(this.getToken())
+            });
+            return { supabase: this.supabase, tablePrefix: this.supabaseInfo.tablePrefix, pluginId: this.supabaseInfo.pluginId };
+        });
+    }
+    getToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.supabaseInfo && this.supabaseInfo.expiration && this.supabaseInfo.expiration > new Date()) {
+                return this.supabaseInfo.token;
+            }
+            const { data } = yield EventBus.request(this.pluginId, "global.supabase.requestAccess");
+            if (!this.supabaseInfo) {
+                throw new Error("Supabase info not found");
+            }
+            this.supabaseInfo.token = data.token;
+            this.supabaseInfo.expiration = data.expiration;
+            return this.supabaseInfo.token;
+        });
+    }
+    getSupabaseUrl() {
+        if (!this.supabaseInfo) {
+            throw new Error("Supabase info not found");
+        }
+        return this.supabaseInfo.url;
+    }
+    getGlobalEventTopic(preliminaryTopic) {
+        var _a, _b;
+        if (preliminaryTopic.startsWith("global.")) {
+            return preliminaryTopic;
+        }
+        if (preliminaryTopic.startsWith("self.")) {
+            return preliminaryTopic;
+        }
+        const topicParts = preliminaryTopic.split(".");
+        if (topicParts.length === 3) {
+            if (!topicParts[0].startsWith("pl") && topicParts[0] !== "global") {
+                throw new Error("The event topic must start with the plugin id or 'global'.");
+            }
+            return preliminaryTopic;
+        }
+        else if (topicParts.length > 3) {
+            throw new Error(`The event topic must consist of 3 parts. <pluginId>.<topic area>.<action>. Received: ${preliminaryTopic}`);
+        }
+        const topicRoot = (_b = (_a = this.supabaseInfo) === null || _a === void 0 ? void 0 : _a.pluginId) !== null && _b !== void 0 ? _b : "global";
+        return `${topicRoot}.${preliminaryTopic}`;
+    }
+}