@rimori/client 2.4.0 → 2.5.0-next.1

package/src/plugin/RimoriClient.ts

@@ -1,530 +0,0 @@
-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 } from '../controller/AIController';
-import { generateObject, ObjectRequest } from '../controller/ObjectController';
-import { SettingsController, UserInfo } from '../controller/SettingsController';
-import {
-  SharedContent,
-  SharedContentController,
-  SharedContentFilter,
-  SharedContentObjectRequest,
-} from '../controller/SharedContentController';
-import { getSTTResponse, getTTSResponse } from '../controller/VoiceController';
-import { ExerciseController, CreateExerciseParams } from '../controller/ExerciseController';
-import { EventBus, EventBusMessage, EventHandler, EventPayload, EventListener } from '../fromRimori/EventBus';
-import { ActivePlugin, MainPanelAction, Plugin, Tool } from '../fromRimori/PluginTypes';
-import { AccomplishmentController, AccomplishmentPayload } from '../controller/AccomplishmentController';
-import { RimoriCommunicationHandler, RimoriInfo } from './CommunicationHandler';
-import { Translator } from '../controller/TranslationController';
-import { Logger } from './Logger';
-// import { setTheme } from '../../../react-client/src/plugin/ThemeSetter';
-// import { StandaloneClient } from './StandaloneClient';
-
-// Add declaration for WorkerGlobalScope
-declare const WorkerGlobalScope: any;
-
-export class RimoriClient {
-  private static instance: RimoriClient;
-  private superbase: SupabaseClient;
-  private pluginController: RimoriCommunicationHandler;
-  private settingsController: SettingsController;
-  private sharedContentController: SharedContentController;
-  private exerciseController: ExerciseController;
-  private accomplishmentHandler: AccomplishmentController;
-  private rimoriInfo: RimoriInfo;
-  private translator: Translator;
-
-  private constructor(controller: RimoriCommunicationHandler, supabase: SupabaseClient, info: RimoriInfo) {
-    this.rimoriInfo = info;
-    this.superbase = supabase;
-    this.pluginController = controller;
-    this.exerciseController = new ExerciseController(supabase, this);
-    this.accomplishmentHandler = new AccomplishmentController(info.pluginId);
-    this.settingsController = new SettingsController(supabase, info.pluginId, info.guild);
-    this.sharedContentController = new SharedContentController(supabase, this);
-    const currentPlugin = info.installedPlugins.find((plugin) => plugin.id === info.pluginId);
-    this.translator = new Translator(info.interfaceLanguage, currentPlugin?.endpoint || '');
-
-    //only init logger in workers and on main plugin pages
-    if (this.getQueryParam('applicationMode') !== 'sidebar') {
-      Logger.getInstance(this);
-    }
-  }
-
-  public get plugin() {
-    return {
-      pluginId: this.rimoriInfo.pluginId,
-      /**
-       * The release channel of this plugin installation.
-       * Determines which database schema is used for plugin tables.
-       */
-      releaseChannel: this.rimoriInfo.releaseChannel,
-      /**
-       * Set the settings for the plugin.
-       * @param settings The settings to set.
-       */
-      setSettings: async (settings: any): Promise<void> => {
-        await 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: async <T extends object>(defaultSettings: T): Promise<T> => {
-        return await this.settingsController.getSettings<T>(defaultSettings);
-      },
-      getUserInfo: (): UserInfo => {
-        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: (): {
-        /**
-         * 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;
-      } => {
-        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: async (): Promise<Translator> => {
-        await this.translator.initialize();
-        return this.translator;
-      },
-    };
-  }
-
-  public 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: <ViewName extends string & keyof GenericSchema['Views'], View extends GenericSchema['Views'][ViewName]>(
-        relation: string,
-      ): PostgrestQueryBuilder<GenericSchema, View, ViewName> => {
-        const tableName = this.db.getTableName(relation);
-        // Use the schema determined by rimori-main based on release channel
-        // Global tables (starting with 'global_') remain in public schema
-        // Plugin tables use the schema provided by rimori-main (plugins or plugins_alpha)
-        if (relation.startsWith('global_')) {
-          // Global tables stay in public schema
-          return this.superbase.from(tableName);
-        }
-        // Plugin tables go to the schema provided by rimori-main
-        return this.superbase.schema(this.rimoriInfo.dbSchema).from(tableName);
-      },
-      // storage: this.superbase.storage,
-      // functions: this.superbase.functions,
-      /**
-       * The table prefix for of database tables of the plugin.
-       */
-      tablePrefix: this.rimoriInfo.tablePrefix,
-      /**
-       * The database schema used for plugin tables.
-       * Determined by rimori-main based on release channel:
-       * - 'plugins_alpha' for alpha release channel
-       * - 'plugins' for beta and stable release channels
-       */
-      schema: this.rimoriInfo.dbSchema,
-      /**
-       * 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 => {
-        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 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) => {
-      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: <T>(topic: string, data?: any): Promise<EventBusMessage<T>> => {
-      const globalTopic = this.pluginController.getGlobalEventTopic(topic);
-      return EventBus.request<T>(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: <T = EventPayload>(topic: string | string[], callback: EventHandler<T>): EventListener => {
-      const topics = Array.isArray(topic) ? topic : [topic];
-      return EventBus.on<T>(
-        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: <T = EventPayload>(topic: string, callback: EventHandler<T>) => {
-      EventBus.once<T>(this.pluginController.getGlobalEventTopic(topic), callback);
-    },
-    /**
-     * 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>),
-    ) => {
-      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: AccomplishmentPayload) => {
-      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: string,
-      callback: (payload: EventBusMessage<AccomplishmentPayload>) => void,
-    ) => {
-      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: string, actionKey: string, text?: string) => {
-      this.event.emit('global.sidebar.triggerAction', { plugin_id: pluginId, action_key: actionKey, text });
-    },
-
-    /**
-     * Subscribe to main panel actions triggered by the user from the dashboard.
-     * @param callback Handler function that receives the action data when a matching action is triggered.
-     * @param actionsToListen Optional filter to listen only to specific action keys. If empty or not provided, all actions will trigger the callback.
-     * @returns An EventListener object with an `off()` method for cleanup.
-     *
-     * @example
-     * ```ts
-     * const listener = client.event.onMainPanelAction((data) => {
-     *   console.log('Action received:', data.action_key);
-     * }, ['startSession', 'pauseSession']);
-     *
-     * // Clean up when component unmounts to prevent events from firing
-     * // when navigating away or returning to the page
-     * useEffect(() => {
-     *   return () => listener.off();
-     * }, []);
-     * ```
-     *
-     * **Important:** Always call `listener.off()` when your component unmounts or when you no longer need to listen.
-     * This prevents the event handler from firing when navigating away from or returning to the page, which could
-     * cause unexpected behavior or duplicate event handling.
-     */
-    onMainPanelAction: (
-      callback: (data: MainPanelAction) => void,
-      actionsToListen: string | string[] = [],
-    ): EventListener => {
-      const listeningActions = Array.isArray(actionsToListen) ? actionsToListen : [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');
-      return this.event.on<MainPanelAction>('action.requestMain', ({ data }) => {
-        // console.log('Received action for main panel ' + data.action_key);
-        // console.log('Listening to actions', listeningActions);
-        if (listeningActions.length === 0 || listeningActions.includes(data.action_key)) {
-          callback(data);
-        }
-      });
-    },
-
-    onSidePanelAction: (
-      callback: (data: MainPanelAction) => void,
-      actionsToListen: string | string[] = [],
-    ): EventListener => {
-      const listeningActions = Array.isArray(actionsToListen) ? actionsToListen : [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.requestSidebar');
-      return this.event.on<MainPanelAction>('action.requestSidebar', ({ data }) => {
-        // console.log("eventHandler .onSidePanelAction", data);
-        // console.log('Received action for sidebar ' + data.action);
-        // console.log('Listening to actions', listeningActions);
-        if (listeningActions.length === 0 || listeningActions.includes(data.action)) {
-          callback(data);
-        }
-      });
-    },
-  };
-
-  public navigation = {
-    toDashboard: (): void => {
-      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(pluginId?: string): Promise<RimoriClient> {
-    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 = await controller.getClient();
-      RimoriClient.instance = new RimoriClient(controller, client.supabase, client.info);
-    }
-    return RimoriClient.instance;
-  }
-
-  public ai = {
-    getText: async (messages: Message[], tools?: Tool[]): Promise<string> => {
-      const token = await this.pluginController.getToken();
-      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.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.pluginController.getBackendUrl(), { input: text, voice, speed, language }, token);
-    },
-    getTextFromVoice: async (file: Blob): Promise<string> => {
-      const token = await this.pluginController.getToken();
-      return getSTTResponse(this.pluginController.getBackendUrl(), file, token);
-    },
-    getObject: async <T = any>(request: ObjectRequest): Promise<T> => {
-      const token = await this.pluginController.getToken();
-      return generateObject<T>(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.
-     * 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: async <T = any>(contentType: string, id: string): Promise<SharedContent<T>> => {
-        return await 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: async <T = any>(
-        contentType: string,
-        filter?: SharedContentFilter,
-        limit?: number,
-      ): Promise<SharedContent<T>[]> => {
-        return await 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: async <T = any>(
-        contentType: string,
-        generatorInstructions: SharedContentObjectRequest,
-        filter?: SharedContentFilter,
-        options?: { privateTopic?: boolean; skipDbSave?: boolean; alwaysGenerateNew?: boolean; excludeIds?: string[] },
-      ): Promise<SharedContent<T>> => {
-        return await 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: async <T = any>(content: Omit<SharedContent<T>, 'id'>): Promise<SharedContent<T>> => {
-        return await 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: async <T = any>(id: string, content: Partial<SharedContent<T>>): Promise<SharedContent<T>> => {
-        return await 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: 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.
-       * @returns The removed shared content item.
-       */
-      remove: async (id: string): Promise<SharedContent<any>> => {
-        return await this.sharedContentController.removeSharedContent(id);
-      },
-    },
-  };
-
-  public 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: async () => {
-      return this.exerciseController.viewWeeklyExercises();
-    },
-
-    /**
-     * Creates a new exercise or multiple exercises via the backend API.
-     * When creating multiple exercises, all requests are made in parallel but only one event is emitted.
-     * @param params Exercise creation parameters (single or array).
-     * @returns Created exercise objects.
-     */
-    add: async (params: CreateExerciseParams | CreateExerciseParams[]) => {
-      const token = await this.pluginController.getToken();
-      const backendUrl = this.pluginController.getBackendUrl();
-      const exercises = Array.isArray(params) ? params : [params];
-      return this.exerciseController.addExercise(token, backendUrl, exercises);
-    },
-
-    /**
-     * Deletes an exercise via the backend API.
-     * @param id The exercise ID to delete.
-     * @returns Success status.
-     */
-    delete: async (id: string) => {
-      const token = await this.pluginController.getToken();
-      const backendUrl = this.pluginController.getBackendUrl();
-      return this.exerciseController.deleteExercise(token, backendUrl, id);
-    },
-  };
-}

package/src/plugin/StandaloneClient.ts

@@ -1,125 +0,0 @@
-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;
-  backendUrl?: string;
-}
-
-export class StandaloneClient {
-  private static instance: StandaloneClient;
-  private config: StandaloneConfig;
-  private supabase: SupabaseClient;
-
-  private constructor(config: StandaloneConfig) {
-    this.supabase = createClient(config.url, config.key);
-    this.config = config;
-  }
-
-  public static async getInstance(): Promise<StandaloneClient> {
-    if (!StandaloneClient.instance) {
-      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);
-        });
-      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;
-  }
-
-  public async getClient(): Promise<SupabaseClient> {
-    return this.supabase;
-  }
-
-  public async needsLogin(): Promise<boolean> {
-    const { error } = await this.supabase.auth.getUser();
-    return error !== null;
-  }
-
-  public async login(email: string, password: string) {
-    const { error } = await this.supabase.auth.signInWithPassword({ email, password });
-    if (error) {
-      console.error('Login failed:', error);
-      return false;
-    }
-    console.log('Successfully logged in');
-    return true;
-  }
-
-  public static async initListeners(pluginId: string) {
-    console.warn(
-      'The plugin seams to not be running inside the Rimori platform. Switching to development standalone mode.',
-    );
-    // console.log("event that needs to be handled", event);
-    const { supabase, config } = await StandaloneClient.getInstance();
-
-    // EventBus.on("*", async (event) => {
-    EventBus.respond('standalone', 'global.supabase.requestAccess', async () => {
-      const session = await supabase.auth.getSession();
-      console.log('session', session);
-
-      // Call the NestJS backend endpoint instead of the Supabase edge function
-      // get current guild id if any
-      let guildId: string | null = null;
-      try {
-        const {
-          data: { user },
-        } = await supabase.auth.getUser();
-        if (user) {
-          const { data: profile } = await supabase
-            .from('profiles')
-            .select('current_guild_id')
-            .eq('user_id', user.id)
-            .maybeSingle();
-          guildId = (profile as { current_guild_id?: string | null } | null)?.current_guild_id || null;
-        }
-      } catch (_) {
-        guildId = null;
-      }
-
-      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,
-          guildId: guildId,
-        }),
-      });
-
-      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
-      };
-    });
-
-    EventBus.on(
-      '*',
-      async (event) => {
-        console.log('[standalone] would send event to parent', event);
-      },
-      ['standalone'],
-    );
-  }
-}

package/src/utils/difficultyConverter.ts

@@ -1,15 +0,0 @@
-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;
-}
-
-export function getDifficultyLabel(difficulty: number): LanguageLevel {
-  return codes[difficulty] as LanguageLevel;
-}
-
-export function getNeighborDifficultyLevel(difficulty: LanguageLevel, difficultyAdjustment: number): LanguageLevel {
-  return getDifficultyLabel(getDifficultyLevel(difficulty) + difficultyAdjustment - 1);
-}

package/src/utils/endpoint.ts

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