@rimori/client 1.0.5 → 1.1.1

package/dist/plugin/ContextMenu.d.ts

@@ -0,0 +1,17 @@
+import React from "react";
+interface Props {
+    iframeRef: React.RefObject<HTMLIFrameElement | null>;
+}
+export interface ContextMenuInfo {
+    x: number;
+    y: number;
+    text: string;
+    open: boolean;
+}
+export interface ContextMenuAction {
+    text: string;
+    pluginId: string;
+    actionKey: string;
+}
+declare const ContextMenu: ({ iframeRef }: Props) => import("react/jsx-runtime").JSX.Element | null;
+export default ContextMenu;

package/dist/plugin/ContextMenu.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { EventBus } from "@/lib/handler/EventBus";
+import { useState, useEffect } from "react";
+import { SupabaseClient } from "@/integrations/supabase/client";
+const ContextMenu = ({ iframeRef }) => {
+    const [showMenu, setMenuVisibility] = useState(false);
+    const [constextActions, setContextMenuActions] = useState([]);
+    const [contextMenu, setContextMenu] = useState({ x: 0, y: 0, open: false, text: "" });
+    useEffect(() => {
+        SupabaseClient.getPlugins().then(plugins => {
+            setContextMenuActions(plugins.flatMap(p => p.context_menu_actions));
+        });
+    }, []);
+    useEffect(() => {
+        // Hide the menu on click outside
+        const handleClick = () => setMenuVisibility(false);
+        document.addEventListener("click", handleClick);
+        return () => document.removeEventListener("click", handleClick);
+    }, []);
+    useEffect(() => {
+        EventBus.on("global.contextMenu.createActions", ({ data }) => {
+            console.log("addContextMenuActions", data.actions);
+            setContextMenuActions([...data.actions, ...constextActions]);
+        });
+        EventBus.on("global.contextMenu.trigger", ({ data }) => {
+            if (!iframeRef.current)
+                return;
+            const { x, y, open, text } = data;
+            const rect = iframeRef.current.getBoundingClientRect();
+            setContextMenu({ x: x + rect.left, y: y + rect.top, open, text });
+            setMenuVisibility(open);
+        });
+    }, []);
+    if (!showMenu) {
+        return null;
+    }
+    return (_jsx("div", { className: "fixed bg-gray-400 dark:bg-gray-700 shadow-lg border border-gray-400 rounded-md overflow-hidden dark:text-white", style: { top: contextMenu.y, left: contextMenu.x }, children: constextActions.map((action, index) => (_jsx(MenuEntryItem, { icon: action.icon, text: action.text, onClick: () => {
+                setMenuVisibility(false);
+                EventBus.emit("global.contextMenu", "global.sidebar.triggerAction", Object.assign(Object.assign({}, action), { text: contextMenu.text }));
+            } }, index))) }));
+};
+function MenuEntryItem(props) {
+    return _jsxs("button", { onClick: props.onClick, className: "px-4 py-2 text-left hover:bg-gray-500 dark:hover:bg-gray-600 w-full flex flex-row", children: [_jsx("span", { className: "flex-grow", children: props.icon }), _jsx("span", { className: "flex-grow", children: props.text })] });
+}
+export default ContextMenu;

package/dist/plugin/PluginController.js

@@ -93,7 +93,7 @@ export class PluginController {
         return this.supabaseInfo.url;
     }
     getGlobalEventTopic(preliminaryTopic) {
-        var _a, _b, _c;
+        var _a, _b;
         if (preliminaryTopic.startsWith("global.")) {
             return preliminaryTopic;
         }
@@ -102,12 +102,15 @@ export class PluginController {
         }
         const topicParts = preliminaryTopic.split(".");
         if (topicParts.length === 3) {
-            if (![(_a = this.supabaseInfo) === null || _a === void 0 ? void 0 : _a.pluginId, "global"].includes(topicParts[0])) {
+            if (!topicParts[0].startsWith("pl") && topicParts[0] !== "global") {
                 throw new Error("The event topic must start with the plugin id or 'global'.");
             }
             return preliminaryTopic;
         }
-        const topicRoot = (_c = (_b = this.supabaseInfo) === null || _b === void 0 ? void 0 : _b.pluginId) !== null && _c !== void 0 ? _c : "global";
+        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}`;
     }
 }

package/dist/plugin/RimoriClient.d.ts

@@ -1,30 +1,34 @@
-import { PluginController } from "./PluginController";
+import { PostgrestQueryBuilder } from "@supabase/postgrest-js";
 import { SupabaseClient } from "@supabase/supabase-js";
-import { EventBusMessage, EventPayload } from "./fromRimori/EventBus";
 import { GenericSchema } from "@supabase/supabase-js/dist/module/lib/types";
-import { PostgrestQueryBuilder, PostgrestFilterBuilder } from "@supabase/postgrest-js";
-import { BasicAssignment } from "../controller/SharedContentController";
-import { Message, Tool, OnLLMResponse } from "../controller/AIController";
+import { Message, OnLLMResponse, Tool } from "../controller/AIController";
 import { ObjectRequest } from "../controller/ObjectController";
-import { Plugin } from "../controller/SidePluginController";
 import { UserInfo } from "../controller/SettingsController";
-import { EventHandler } from "./fromRimori/EventBus";
+import { BasicAssignment, SharedContent, SharedContentFilter, SharedContentObjectRequest } from "../controller/SharedContentController";
+import { AccomplishmentPayload } from "./AccomplishmentHandler";
+import { EventBusMessage, EventHandler, EventPayload } from "./fromRimori/EventBus";
+import { Plugin } from "./fromRimori/PluginTypes";
+import { PluginController } from "./PluginController";
 interface Db {
     from: {
         <TableName extends string & keyof GenericSchema['Tables'], Table extends GenericSchema['Tables'][TableName]>(relation: TableName): PostgrestQueryBuilder<GenericSchema, Table, TableName>;
         <ViewName extends string & keyof GenericSchema['Views'], View extends GenericSchema['Views'][ViewName]>(relation: ViewName): PostgrestQueryBuilder<GenericSchema, View, ViewName>;
     };
-    rpc: <Fn extends GenericSchema['Functions'][string], FnName extends string & keyof GenericSchema['Functions']>(functionName: FnName, args?: Fn["Args"], options?: {
-        head?: boolean;
-        get?: boolean;
-        count?: "exact" | "planned" | "estimated";
-    }) => PostgrestFilterBuilder<GenericSchema, Fn["Returns"] extends any[] ? Fn["Returns"][number] extends Record<string, unknown> ? Fn["Returns"][number] : never : never, Fn["Returns"], string, null>;
-    functions: SupabaseClient["functions"];
     storage: SupabaseClient["storage"];
+    /**
+     * 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;
 }
 interface PluginInterface {
     pluginId: string;
-    tablePrefix: string;
     setSettings: (settings: any) => Promise<void>;
     /**
      * Get the settings for the plugin. T can be any type of settings, UserSettings or SystemSettings.
@@ -46,6 +50,7 @@ export declare class RimoriClient {
     private pluginController;
     private settingsController;
     private sharedContentController;
+    private accomplishmentHandler;
     private supabaseUrl;
     db: Db;
     plugin: PluginInterface;
@@ -61,7 +66,7 @@ export declare class RimoriClient {
          * @param data The data to emit.
          * @param eventId The event id.
          */
-        emit: (topic: string, data: any, eventId?: number) => void;
+        emit: (topic: string, data?: any, eventId?: number) => void;
         /**
          * Request an event.
          * @param topic The topic to request the event on.
@@ -73,8 +78,9 @@ export declare 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: <T = EventPayload>(topic: string, callback: EventHandler<T>) => void;
+        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.
@@ -87,33 +93,27 @@ export declare class RimoriClient {
          * @param data The data to respond with.
          */
         respond: <T = EventPayload>(topic: 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;
     };
     static getInstance(pluginController: PluginController): Promise<RimoriClient>;
     private from;
-    /**
-    * 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.
-    */
-    private rpc;
     private getTableName;
     llm: {
         getText: (messages: Message[], tools?: Tool[]) => Promise<string>;
@@ -122,30 +122,57 @@ export declare class RimoriClient {
         getTextFromVoice: (file: Blob) => Promise<string>;
         getObject: (request: ObjectRequest) => Promise<any>;
     };
-    /**
-     * 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<T, R = T & BasicAssignment>(type: string, generatorInstructions: (reservedTopics: string[]) => Promise<ObjectRequest> | ObjectRequest, filter?: {
-        column: string;
-        value: string | number | boolean;
-    }): Promise<R[]>;
-    /**
-     * 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<T extends BasicAssignment>(type: string, id: string): Promise<T>;
-    /**
-     * 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: string, assignmentId: string): Promise<void>;
-    triggerSidebarAction(pluginId: string, actionKey: string, text?: string): void;
+    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<BasicAssignment<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<BasicAssignment<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 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: <T = any>(contentType: string, generatorInstructions: SharedContentObjectRequest, filter?: SharedContentFilter, privateTopic?: boolean) => Promise<BasicAssignment<T>>;
+            /**
+             * Create a new shared content item.
+             * @param content The content to create.
+             * @returns The new shared content item.
+             */
+            create: <T = any>(content: SharedContent<T>) => Promise<BasicAssignment<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<BasicAssignment<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>;
+        };
+    };
 }
 export {};

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

@@ -4,10 +4,10 @@ export function setTheme() {
     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.setAttribute("data-theme", "dark");
-        document.documentElement.classList.add('dark', "bg-gray-950");
+        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.