@rimori/client 1.1.10 → 1.3.0

package/src/plugin/RimoriClient.ts

@@ -1,30 +1,23 @@
 import { PostgrestQueryBuilder } from "@supabase/postgrest-js";
 import { SupabaseClient } from "@supabase/supabase-js";
 import { GenericSchema } from "@supabase/supabase-js/dist/module/lib/types";
-import { generateText, Message, OnLLMResponse, streamChatGPT, Tool } from "../controller/AIController";
-import { generateObject as generateObjectFunction, ObjectRequest } from "../controller/ObjectController";
-import { SettingsController, UserInfo } from "../controller/SettingsController";
-import { SharedContent, SharedContentController, SharedContentFilter, SharedContentObjectRequest } from "../controller/SharedContentController";
-import { getPlugins } from "../controller/SidePluginController";
-import { getSTTResponse, getTTSResponse } from "../controller/VoiceController";
+import { generateText, Message, OnLLMResponse, streamChatGPT } from "../core/controller/AIController";
+import { generateObject, ObjectRequest } from "../core/controller/ObjectController";
+import { SettingsController, UserInfo } from "../core/controller/SettingsController";
+import { SharedContent, SharedContentController, SharedContentFilter, SharedContentObjectRequest } from "../core/controller/SharedContentController";
+import { getSTTResponse, getTTSResponse } from "../core/controller/VoiceController";
+import { EventBus, EventBusMessage, EventHandler, EventPayload } from "../fromRimori/EventBus";
+import { ActivePlugin, MainPanelAction, Plugin, Tool } from "../fromRimori/PluginTypes";
 import { AccomplishmentHandler, AccomplishmentPayload } from "./AccomplishmentHandler";
-import { EventBus, EventBusMessage, EventHandler, EventPayload } from "./fromRimori/EventBus";
-import { Plugin } from "./fromRimori/PluginTypes";
-import { PluginController } from "./PluginController";
+import { PluginController, RimoriInfo } from "./PluginController";
 
-interface RimoriClientOptions {
-  pluginController: PluginController;
-  supabase: SupabaseClient;
-  tablePrefix: string;
-  pluginId: string;
-}
 
 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>;
   };
-  storage: SupabaseClient["storage"];
+  // storage: SupabaseClient["storage"];
 
   // functions: SupabaseClient["functions"];
   /**
@@ -51,11 +44,26 @@ interface PluginInterface {
    */
   getSettings: <T extends object>(defaultSettings: T) => Promise<T>;
   /**
-  * Fetches all installed plugins.
-  * @returns A promise that resolves to an array of plugins
-  */
-  getInstalled: () => Promise<Plugin[]>;
-  getUserInfo: () => Promise<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,
+  };
+  getUserInfo: () => UserInfo;
 }
 
 export class RimoriClient {
@@ -65,40 +73,44 @@ export class RimoriClient {
   private settingsController: SettingsController;
   private sharedContentController: SharedContentController;
   private accomplishmentHandler: AccomplishmentHandler;
-  private supabaseUrl: string;
-  public db: Db;
+  private rimoriInfo: RimoriInfo;
   public plugin: PluginInterface;
+  public db: Db;
 
-  private constructor(options: RimoriClientOptions) {
-    this.superbase = options.supabase;
-    this.pluginController = options.pluginController;
-    this.settingsController = new SettingsController(options.supabase, options.pluginId);
+  private constructor(supabase: SupabaseClient, info: RimoriInfo, pluginController: PluginController) {
+    this.rimoriInfo = info;
+    this.superbase = supabase;
+    this.pluginController = pluginController;
+    this.settingsController = new SettingsController(supabase, info.pluginId);
     this.sharedContentController = new SharedContentController(this.superbase, this);
-    this.supabaseUrl = this.pluginController.getSupabaseUrl();
-    this.accomplishmentHandler = new AccomplishmentHandler(options.pluginId);
+    this.accomplishmentHandler = new AccomplishmentHandler(info.pluginId);
 
     this.from = this.from.bind(this);
 
     this.db = {
       from: this.from,
-      storage: this.superbase.storage,
+      // storage: this.superbase.storage,
       // functions: this.superbase.functions,
-      tablePrefix: options.tablePrefix,
+      tablePrefix: info.tablePrefix,
       getTableName: this.getTableName.bind(this),
     }
     this.plugin = {
-      pluginId: options.pluginId,
+      pluginId: info.pluginId,
       setSettings: async (settings: any) => {
         await this.settingsController.setSettings(settings);
       },
       getSettings: async <T extends object>(defaultSettings: T): Promise<T> => {
         return await this.settingsController.getSettings<T>(defaultSettings);
       },
-      getInstalled: async (): Promise<Plugin[]> => {
-        return getPlugins(this.superbase);
+      getUserInfo: (): UserInfo => {
+        return this.rimoriInfo.profile;
       },
-      getUserInfo: async (): Promise<UserInfo> => {
-        return this.settingsController.getUserInfo();
+      getPluginInfo: () => {
+        return {
+          installedPlugins: this.rimoriInfo.installedPlugins,
+          mainPanelPlugin: this.rimoriInfo.mainPanelPlugin,
+          sidePanelPlugin: this.rimoriInfo.sidePanelPlugin,
+        }
       }
     }
   }
@@ -132,11 +144,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.
+     * @returns An EventListener object containing an off() method to unsubscribe the listeners.
      */
     on: <T = EventPayload>(topic: string | string[], callback: EventHandler<T>) => {
       const topics = Array.isArray(topic) ? topic : [topic];
-      return topics.map(topic => EventBus.on<T>(this.pluginController.getGlobalEventTopic(topic), callback));
+      return EventBus.on<T>(topics.map(t => this.pluginController.getGlobalEventTopic(t)), callback);
     },
     /**
      * Subscribe to an event once.
@@ -151,8 +163,9 @@ export class RimoriClient {
      * @param topic The topic to respond to.
      * @param data The data to respond with.
      */
-    respond: <T = EventPayload>(topic: string, data: EventPayload | ((data: EventBusMessage<T>) => EventPayload | Promise<EventPayload>)) => {
-      EventBus.respond(this.plugin.pluginId, this.pluginController.getGlobalEventTopic(topic), data);
+    respond: <T = EventPayload>(topic: string | string[], data: EventPayload | ((data: EventBusMessage<T>) => EventPayload | Promise<EventPayload>)) => {
+      const topics = Array.isArray(topic) ? topic : [topic];
+      EventBus.respond(this.plugin.pluginId, topics.map(t => this.pluginController.getGlobalEventTopic(t)), data);
     },
     /**
      * Emit an accomplishment.
@@ -176,14 +189,35 @@ export class RimoriClient {
      * @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) => {
-      this.event.emit("global.sidebar.triggerAction", { pluginId, actionKey, text });
+      this.event.emit("global.sidebar.triggerAction", { plugin_id: pluginId, action_key: actionKey, text });
+    },
+
+    onMainPanelAction: (callback: (data: MainPanelAction) => void) => {
+      // 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<MainPanelAction>("action.requestMain", ({ data }) => callback(data));
     }
   }
 
+  public navigation = {
+    toDashboard: () => {
+      this.event.emit("global.navigation.triggerToDashboard");
+    }
+  }
+
+  /**
+   * 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
+   */
+  public getQueryParam(key: string): string | null {
+    return this.pluginController.getQueryParam(key);
+  }
+
   public static async getInstance(pluginController: PluginController): Promise<RimoriClient> {
     if (!RimoriClient.instance) {
-      const { supabase, tablePrefix, pluginId } = await pluginController.getClient();
-      RimoriClient.instance = new RimoriClient({ pluginController, supabase, tablePrefix, pluginId });
+      const client = await pluginController.getClient();
+      RimoriClient.instance = new RimoriClient(client.supabase, client.info, pluginController);
     }
     return RimoriClient.instance;
   }
@@ -200,33 +234,53 @@ export class RimoriClient {
     return this.superbase.from(this.getTableName(relation));
   }
 
-  private getTableName(type: string) {
-    return this.db.tablePrefix + "_" + type;
+  private getTableName(table: string) {
+    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;
   }
 
-  public llm = {
+  public ai = {
     getText: async (messages: Message[], tools?: Tool[]): Promise<string> => {
       const token = await this.pluginController.getToken();
-      return generateText(this.supabaseUrl, messages, tools || [], token).then(({ messages }) => messages[0].content[0].text);
+      return generateText(this.pluginController.getBackendUrl(), messages, tools || [], token).then(({ messages }) => messages[0].content[0].text);
     },
     getSteamedText: async (messages: Message[], onMessage: OnLLMResponse, tools?: Tool[]) => {
       const token = await this.pluginController.getToken();
-      streamChatGPT(this.supabaseUrl, messages, tools || [], onMessage, token);
+      streamChatGPT(this.pluginController.getBackendUrl(), messages, tools || [], onMessage, token);
     },
     getVoice: async (text: string, voice = "alloy", speed = 1, language?: string): Promise<Blob> => {
       const token = await this.pluginController.getToken();
-      return getTTSResponse(this.supabaseUrl, { input: text, voice, speed, language }, token);
+      return getTTSResponse(this.pluginController.getBackendUrl(), { input: text, voice, speed, language }, token);
     },
-    getTextFromVoice: (file: Blob): Promise<string> => {
-      return getSTTResponse(this.superbase, file);
+    getTextFromVoice: async (file: Blob): Promise<string> => {
+      const token = await this.pluginController.getToken();
+      return getSTTResponse(this.pluginController.getBackendUrl(), file, token);
     },
     getObject: async (request: ObjectRequest): Promise<any> => {
       const token = await this.pluginController.getToken();
-      return generateObjectFunction(this.supabaseUrl, request, token);
+      return generateObject(this.pluginController.getBackendUrl(), request, token);
     },
     // getSteamedObject: this.generateObjectStream,
   }
 
+  public runtime = {
+    fetchBackend: async (url: string, options: RequestInit) => {
+      const token = await this.pluginController.getToken();
+      return fetch(this.pluginController.getBackendUrl() + url, {
+        ...options,
+        headers: {
+          ...options.headers,
+          'Authorization': `Bearer ${token}`
+        }
+      });
+    }
+  }
+
   public community = {
     /**
      * Shared content is a way to share completable content with other users using this plugin.
@@ -258,16 +312,20 @@ export class RimoriClient {
        * @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.
+       * @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: async <T = any>(
         contentType: string,
         generatorInstructions: SharedContentObjectRequest,
         filter?: SharedContentFilter,
-        privateTopic?: boolean,
+        options?: { privateTopic?: boolean; skipDbSave?: boolean; alwaysGenerateNew?: boolean; excludeIds?: string[] },
       ): Promise<SharedContent<T>> => {
-        return await this.sharedContentController.getNewSharedContent(contentType, generatorInstructions, filter, privateTopic);
+        return await this.sharedContentController.getNewSharedContent(contentType, generatorInstructions, filter, options);
       },
       /**
        * Create a new shared content item.
@@ -294,6 +352,20 @@ export class RimoriClient {
       complete: async (contentType: string, assignmentId: string) => {
         return await 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: async (params: {
+        contentType: string
+        id: string
+        state?: 'completed' | 'ongoing' | 'hidden'
+        reaction?: 'liked' | 'disliked' | null
+        bookmarked?: boolean
+      }): Promise<void> => {
+        return await this.sharedContentController.updateSharedContentState(params);
+      },
       /**
        * Remove a shared content item.
        * @param id The id of the shared content item to remove.

package/src/plugin/StandaloneClient.ts

@@ -1,9 +1,11 @@
-import { EventBus } from "./fromRimori/EventBus";
 import { createClient, SupabaseClient } from "@supabase/supabase-js";
+import { EventBus } from "../fromRimori/EventBus";
+import { DEFAULT_ANON_KEY, DEFAULT_ENDPOINT } from "../utils/endpoint";
 
 export interface StandaloneConfig {
   url: string,
-  key: string
+  key: string,
+  backendUrl?: string
 }
 
 export class StandaloneClient {
@@ -18,14 +20,14 @@ export class StandaloneClient {
 
   public static async getInstance(): Promise<StandaloneClient> {
     if (!StandaloneClient.instance) {
-      const config = await fetch("http://localhost:3000/config.json").then(res => res.json()).catch(err => {
+      const config = await fetch("https://app.rimori.se/config.json").then(res => res.json()).catch(err => {
         console.warn("Error fetching config.json, using default values", err);
-        return {
-          SUPABASE_URL: "https://pheptqdoqsdnadgoihvr.supabase.co",
-          SUPABASE_ANON_KEY: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InBoZXB0cWRvcXNkbmFkZ29paHZyIiwicm9sZSI6ImFub24iLCJpYXQiOjE3MzE2OTY2ODcsImV4cCI6MjA0NzI3MjY4N30.4GPFAXTF8685FaXISdAPNCIM-H3RGLo8GbyhQpu1mP0",
-        }
       });
-      StandaloneClient.instance = new StandaloneClient({ url: config.SUPABASE_URL, key: config.SUPABASE_ANON_KEY });
+      StandaloneClient.instance = new StandaloneClient({
+        url: config?.SUPABASE_URL || DEFAULT_ENDPOINT,
+        key: config?.SUPABASE_ANON_KEY || DEFAULT_ANON_KEY,
+        backendUrl: config?.BACKEND_URL || 'https://api.rimori.se',
+      });
     }
     return StandaloneClient.instance;
   }
@@ -58,15 +60,32 @@ export class StandaloneClient {
     EventBus.respond("standalone", "global.supabase.requestAccess", async () => {
       const session = await supabase.auth.getSession();
       console.log("session", session);
-      const { data, error } = await supabase.functions.invoke("plugin-token", { headers: { authorization: `Bearer ${session.data.session?.access_token}` } });
-      if (error) {
-        throw new Error("Failed to get plugin token. " + error.message);
+      
+      // Call the NestJS backend endpoint instead of the Supabase edge function
+      const response = await fetch(`${config.backendUrl}/plugin/token`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${session.data.session?.access_token}`
+        },
+        body: JSON.stringify({
+          pluginId: pluginId
+        })
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to get plugin token. ${response.status}: ${errorText}`);
       }
+
+      const data = await response.json();
+      
       return {
         token: data.token,
         pluginId: pluginId,
         url: config.url,
         key: config.key,
+        backendUrl: config.backendUrl,
         tablePrefix: pluginId,
         expiration: new Date(Date.now() + 1000 * 60 * 60 * 1.5), // 1.5 hours
       }

package/src/plugin/ThemeSetter.ts

@@ -1,16 +1,23 @@
-export function setTheme() {
-  const urlParams = new URLSearchParams(window.location.search);
-
-  let theme = urlParams.get('theme');
-  if (!theme || theme === 'system') {
-    theme = window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
-  }
-
+export function setTheme(theme?: string | null) {
   document.documentElement.classList.add("dark:text-gray-200");
 
-  if (theme === 'dark') {
+  if (isDarkTheme(theme)) {
     document.documentElement.setAttribute("data-theme", "dark");
     document.documentElement.classList.add('dark', "dark:bg-gray-950");
     document.documentElement.style.background = "hsl(var(--background))";
   }
+}
+
+export function isDarkTheme(theme?: string | null): boolean {
+  // If no theme provided, try to get from URL as fallback (for standalone mode)
+  if (!theme) {
+    const urlParams = new URLSearchParams(window.location.search);
+    theme = urlParams.get('theme');
+  }
+
+  if (!theme || theme === 'system') {
+    return window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches;
+  }
+
+  return theme === 'dark';
 }

package/src/providers/PluginProvider.tsx

@@ -1,24 +1,35 @@
 import React, { createContext, useContext, ReactNode, useEffect, useState } from 'react';
 import { PluginController } from '../plugin/PluginController';
 import { RimoriClient } from '../plugin/RimoriClient';
-import { EventBusHandler } from '../plugin/fromRimori/EventBus';
-import ContextMenu from '../core/components/ContextMenu';
+import { EventBusHandler } from '../fromRimori/EventBus';
+import ContextMenu from '../components/components/ContextMenu';
 import { StandaloneClient } from '../plugin/StandaloneClient';
 
 interface PluginProviderProps {
   children: ReactNode;
   pluginId: string;
+  settings?: {
+    disableContextMenu?: boolean;
+  }
 }
 
 const PluginContext = createContext<RimoriClient | null>(null);
 
-export const PluginProvider: React.FC<PluginProviderProps> = ({ children, pluginId }) => {
+export const PluginProvider: React.FC<PluginProviderProps> = ({ children, pluginId, settings }) => {
   const [plugin, setPlugin] = useState<RimoriClient | null>(null);
   const [standaloneClient, setStandaloneClient] = useState<StandaloneClient | boolean>(false);
+  const [applicationMode, setApplicationMode] = useState<string | null>(null);
+  const [theme, setTheme] = useState<string | null>(null);
+  
+  const isSidebar = applicationMode === "sidebar";
+  const isSettings = applicationMode === "settings";
 
   useEffect(() => {
     initEventBus(pluginId);
-    const standaloneDetected = new URLSearchParams(window.location.search).get("secret") === null;
+    
+    // Check if we're in an iframe context - if not, we're standalone
+    const standaloneDetected = window === window.parent;
+    
     if (standaloneDetected && !standaloneClient) {
       StandaloneClient.getInstance().then(client => {
         client.needsLogin().then((needLogin) => setStandaloneClient(needLogin ? client : true));
@@ -26,7 +37,16 @@ export const PluginProvider: React.FC<PluginProviderProps> = ({ children, plugin
     }
 
     if ((!standaloneDetected && !plugin) || (standaloneDetected && standaloneClient === true)) {
-      PluginController.getInstance(pluginId, standaloneDetected).then(setPlugin);
+      PluginController.getInstance(pluginId, standaloneDetected).then(client => {
+        setPlugin(client);
+        // Get applicationMode and theme from MessageChannel query params
+        if (!standaloneDetected) {
+          const mode = client.getQueryParam("applicationMode");
+          const themeParam = client.getQueryParam("rm_theme");
+          setApplicationMode(mode);
+          setTheme(themeParam);
+        }
+      });
     }
   }, [pluginId, standaloneClient]);
 
@@ -34,11 +54,10 @@ export const PluginProvider: React.FC<PluginProviderProps> = ({ children, plugin
   useEffect(() => {
     if (!plugin) return;
 
-    const url = new URL(window.location.href);
     //sidebar pages should not report url changes
-    if (url.searchParams.get("applicationMode") === "sidebar") return;
+    if (isSidebar) return;
 
-    let lastHash = url.hash;
+    let lastHash = window.location.hash;
     const emitUrlChange = (url: string) => plugin.event.emit('session.triggerUrlChange', { url });
 
     const interval = setInterval(() => {
@@ -73,23 +92,37 @@ export const PluginProvider: React.FC<PluginProviderProps> = ({ children, plugin
 
   return (
     <PluginContext.Provider value={plugin}>
-      <ContextMenu client={plugin} />
+      {!settings?.disableContextMenu && !isSidebar && !isSettings && <ContextMenu client={plugin} />}
       {children}
     </PluginContext.Provider>
   );
 };
 
-export const usePlugin = () => {
+export const useRimori = () => {
   const context = useContext(PluginContext);
   if (context === null) {
-    throw new Error('usePlugin must be used within an PluginProvider');
+    throw new Error('useRimori must be used within an PluginProvider');
   }
   return context;
 };
 
-function initEventBus(pluginId: string) {
+function getUrlParam(name: string) {
+  // First try to get from URL hash query params (for compatibility)
+  const hashParts = window.location.hash.split('?');
+  if (hashParts.length > 1) {
+    const hashParams = new URLSearchParams(hashParts[1]);
+    const hashValue = hashParams.get(name);
+    if (hashValue) return hashValue;
+  }
+  
+  // Fallback to regular URL search params
   const url = new URL(window.location.href);
-  const isSidebar = url.searchParams.get("applicationMode") === "sidebar";
+  return url.searchParams.get(name);
+}
+
+function initEventBus(pluginId: string) {
+  // For now, use URL fallback for EventBus naming - this will be updated once MessageChannel is ready
+  const isSidebar = getUrlParam("applicationMode") === "sidebar";
   EventBusHandler.getInstance("Plugin EventBus " + pluginId + " " + (isSidebar ? "sidebar" : "main"));
 }
 

package/src/utils/Language.ts

@@ -63,8 +63,10 @@ export type Language = keyof typeof languageKeys;
 /**
  * Get the language name from the language code
  * @param languageCode The code of the language
+ * @param capitalize Whether to capitalize the first letter of the language name
  * @returns The language name
  */
-export function getLanguageName(languageCode: Language): string {
-  return languageKeys[languageCode];
+export function getLanguageName(languageCode: Language, capitalize: boolean = false): string {
+  const lang = languageKeys[languageCode];
+  return capitalize ? lang.charAt(0).toUpperCase() + lang.slice(1) : lang;
 }

package/src/utils/difficultyConverter.ts

@@ -3,13 +3,13 @@ const codes = ["Pre-A1", "A1", "A2", "B1", "B2", "C1", "C2", "Post-C2"];
 export type LanguageLevel = "Pre-A1" | "A1" | "A2" | "B1" | "B2" | "C1" | "C2" | "Post-C2";
 
 export function getDifficultyLevel(difficulty: LanguageLevel): number {
-    return codes.indexOf(difficulty) + 1;
+  return codes.indexOf(difficulty) + 1;
 }
 
 export function getDifficultyLabel(difficulty: number): LanguageLevel {
-    return codes[difficulty] as LanguageLevel;
+  return codes[difficulty] as LanguageLevel;
 }
 
 export function getNeighborDifficultyLevel(difficulty: LanguageLevel, difficultyAdjustment: number): LanguageLevel {
-    return getDifficultyLabel(getDifficultyLevel(difficulty) + difficultyAdjustment);
+  return getDifficultyLabel(getDifficultyLevel(difficulty) + difficultyAdjustment - 1);
 }

package/src/utils/endpoint.ts

@@ -0,0 +1,2 @@
+export const DEFAULT_ENDPOINT = "https://pheptqdoqsdnadgoihvr.supabase.co";
+export const DEFAULT_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InBoZXB0cWRvcXNkbmFkZ29paHZyIiwicm9sZSI6ImFub24iLCJpYXQiOjE3MzE2OTY2ODcsImV4cCI6MjA0NzI3MjY4N30.4GPFAXTF8685FaXISdAPNCIM-H3RGLo8GbyhQpu1mP0";

package/src/worker/WorkerSetup.ts

@@ -1,35 +1,22 @@
 import { RimoriClient } from "../plugin/RimoriClient";
+import { EventBusHandler } from "../fromRimori/EventBus";
 import { PluginController } from "../plugin/PluginController";
-import { EventBus, EventBusHandler, EventBusMessage } from "../plugin/fromRimori/EventBus";
-
-let controller: RimoriClient | null = null;
-const listeners: ((event: { data: { event: EventBusMessage, secret: string } }) => void)[] = [];
-let debugEnabled = false;
 
 /**
  * Sets up the web worker for the plugin to be able receive and send messages to Rimori.
- * @param init - The function containing the subscription logic.
+ * @param pluginId - The id of the plugin to setup the worker for.
+ * @param init - The function containing the initialization logic.
  */
-export function setupWorker(init: (controller: RimoriClient) => void | Promise<void>) {
+export async function setupWorker(pluginId: string, init: (client: RimoriClient) => void | Promise<void>) {
+  
   // Mock of the window object for the worker context to be able to use the PluginController.
   const mockWindow = {
     isWorker: true,
-    location: { search: '?secret=123' },
+    location: {},
     parent: {
-      postMessage: (message: { event: EventBusMessage }) => {
-        message.event.sender = "worker." + message.event.sender;
-        checkDebugMode(message.event);
-        logIfDebug('sending event to Rimori', message.event);
-        self.postMessage(message)
-      }
-    },
-    addEventListener: (_: string, listener: any) => {
-      listeners.push(listener);
-    },
-    APP_CONFIG: {
-      SUPABASE_URL: 'NOT_SET',
-      SUPABASE_ANON_KEY: 'NOT_SET',
+      postMessage: () => { }
     },
+    addEventListener: () => { }
   };
 
   // Assign the mock to globalThis.
@@ -37,45 +24,11 @@ export function setupWorker(init: (controller: RimoriClient) => void | Promise<v
 
   EventBusHandler.getInstance("Worker EventBus");
 
-  // Handle init message from Rimori.
-  self.onmessage = async (response: MessageEvent) => {
-    checkDebugMode(response.data);
-    logIfDebug('Message received', response.data);
-
-    const event = response.data as EventBusMessage;
-
-    if (event.topic === 'global.worker.requestInit') {
-      if (!controller) {
-        mockWindow.APP_CONFIG.SUPABASE_URL = event.data.supabaseUrl;
-        mockWindow.APP_CONFIG.SUPABASE_ANON_KEY = event.data.supabaseAnonKey;
-        controller = await PluginController.getInstance(event.data.pluginId);
-        logIfDebug('Worker initialized.');
-        await init(controller);
-        logIfDebug('Plugin listeners initialized.');
-      }
-      const initEvent: EventBusMessage = {
-        timestamp: new Date().toISOString(),
-        eventId: event.eventId,
-        sender: "worker." + event.sender,
-        topic: 'global.worker.requestInit',
-        data: { success: true },
-        debug: debugEnabled
-      };
-      return self.postMessage({ secret: "123", event: initEvent });
-    }
-    listeners.forEach(listener => listener({ data: { event: response.data, secret: "123" } }));
-  };
-}
+  const rimoriClient = await PluginController.getInstance(pluginId);
+  console.debug('[Worker] RimoriClient initialized.');
 
-function checkDebugMode(event: EventBusMessage) {
-  if (event.topic === 'global.system.requestDebug' || event.debug) {
-    debugEnabled = true;
-    EventBus.emit("worker", "global.system.requestDebug");
-  }
-}
+  await init(rimoriClient);
+  console.debug('[Worker] Worker initialized.');
 
-function logIfDebug(...args: any[]) {
-  if (debugEnabled) {
-    console.debug('[Worker] ' + args[0], ...args.slice(1));
-  }
+  self.postMessage({ type: "rimori:acknowledged", pluginId: pluginId });
 }