@rimori/client 2.4.0-next.6 → 2.4.0-next.7

package/src/plugin/RimoriClient.ts

@@ -1,199 +0,0 @@
-import {
-  SharedContent,
-  SharedContentController,
-  SharedContentFilter,
-  SharedContentObjectRequest,
-} from '../controller/SharedContentController';
-import { RimoriCommunicationHandler, RimoriInfo } from './CommunicationHandler';
-import { Logger } from './Logger';
-import { PluginModule } from './module/PluginModule';
-import { DbModule } from './module/DbModule';
-import { EventModule } from './module/EventModule';
-import { AIModule } from './module/AIModule';
-import { ExerciseModule } from './module/ExerciseModule';
-import { PostgrestClient } from '@supabase/postgrest-js';
-
-// Add declaration for WorkerGlobalScope
-declare const WorkerGlobalScope: any;
-
-export class RimoriClient {
-  private static instance: RimoriClient;
-  private pluginController: RimoriCommunicationHandler;
-  private sharedContentController: SharedContentController;
-  public db: DbModule;
-  public event: EventModule;
-  public plugin: PluginModule;
-  public ai: AIModule;
-  public exercise: ExerciseModule;
-  private rimoriInfo: RimoriInfo;
-
-  private constructor(controller: RimoriCommunicationHandler, supabase: PostgrestClient, info: RimoriInfo) {
-    this.rimoriInfo = info;
-    this.pluginController = controller;
-    this.sharedContentController = new SharedContentController(supabase, this);
-    this.ai = new AIModule(controller, info);
-    this.event = new EventModule(info.pluginId);
-    this.db = new DbModule(supabase, controller, info);
-    this.plugin = new PluginModule(supabase, controller, info);
-    this.exercise = new ExerciseModule(supabase, controller, info, this.event);
-
-    controller.onUpdate((updatedInfo) => {
-      this.rimoriInfo = updatedInfo;
-    });
-
-    //only init logger in workers and on main plugin pages
-    if (this.plugin.applicationMode !== 'sidebar') {
-      Logger.getInstance(this);
-    }
-  }
-
-  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
-   * @deprecated Use the plugin.applicationMode and plugin.theme properties instead
-   * @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 runtime = {
-    fetchBackend: async (url: string, options: RequestInit) => {
-      return fetch(this.rimoriInfo.backendUrl + url, {
-        ...options,
-        headers: {
-          ...options.headers,
-          Authorization: `Bearer ${this.rimoriInfo.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);
-      },
-    },
-  };
-}

package/src/plugin/StandaloneClient.ts

@@ -1,127 +0,0 @@
-import { SupabaseClient } from './CommunicationHandler';
-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 & { auth: any }; // TODO: remove any
-
-  private constructor(config: StandaloneConfig) {
-    throw new Error('Authentication is disabled until new developer platform is released.');
-    // this.supabase = createClient(config.url, config.key);
-    this.supabase = {} as any;
-    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/plugin/module/AIModule.ts

@@ -1,77 +0,0 @@
-import { RimoriCommunicationHandler, RimoriInfo } from '../CommunicationHandler';
-import { generateText, Message, OnLLMResponse, streamChatGPT } from '../../controller/AIController';
-import { generateObject, ObjectRequest } from '../../controller/ObjectController';
-import { getSTTResponse, getTTSResponse } from '../../controller/VoiceController';
-import { Tool } from '../../fromRimori/PluginTypes';
-
-/**
- * Controller for AI-related operations.
- * Provides access to text generation, voice synthesis, and object generation.
- */
-export class AIModule {
-  private communicationHandler: RimoriCommunicationHandler;
-  private backendUrl: string;
-  private token: string;
-
-  constructor(communicationHandler: RimoriCommunicationHandler, info: RimoriInfo) {
-    this.token = info.token;
-    this.backendUrl = info.backendUrl;
-    this.communicationHandler = communicationHandler;
-
-    this.communicationHandler.onUpdate((updatedInfo) => {
-      this.token = updatedInfo.token;
-    });
-  }
-
-  /**
-   * Generate text from messages using AI.
-   * @param messages The messages to generate text from.
-   * @param tools Optional tools to use for generation.
-   * @returns The generated text.
-   */
-  async getText(messages: Message[], tools?: Tool[]): Promise<string> {
-    return generateText(this.backendUrl, messages, tools || [], this.token).then(
-      ({ messages }) => messages[0].content[0].text,
-    );
-  }
-
-  /**
-   * Stream text generation from messages using AI.
-   * @param messages The messages to generate text from.
-   * @param onMessage Callback for each message chunk.
-   * @param tools Optional tools to use for generation.
-   */
-  async getSteamedText(messages: Message[], onMessage: OnLLMResponse, tools?: Tool[]): Promise<void> {
-    streamChatGPT(this.backendUrl, messages, tools || [], onMessage, this.token);
-  }
-
-  /**
-   * Generate voice audio from text using AI.
-   * @param text The text to convert to voice.
-   * @param voice The voice to use (default: 'alloy').
-   * @param speed The speed of the voice (default: 1).
-   * @param language Optional language for the voice.
-   * @returns The generated audio as a Blob.
-   */
-  async getVoice(text: string, voice = 'alloy', speed = 1, language?: string): Promise<Blob> {
-    return getTTSResponse(this.backendUrl, { input: text, voice, speed, language }, this.token);
-  }
-
-  /**
-   * Convert voice audio to text using AI.
-   * @param file The audio file to convert.
-   * @returns The transcribed text.
-   */
-  async getTextFromVoice(file: Blob): Promise<string> {
-    return getSTTResponse(this.backendUrl, file, this.token);
-  }
-
-  /**
-   * Generate a structured object from a request using AI.
-   * @param request The object generation request.
-   * @returns The generated object.
-   */
-  async getObject<T = any>(request: ObjectRequest): Promise<T> {
-    return generateObject<T>(this.backendUrl, request, this.token);
-  }
-}

package/src/plugin/module/DbModule.ts

@@ -1,67 +0,0 @@
-import { PostgrestClientOptions, PostgrestQueryBuilder } from '@supabase/postgrest-js';
-import { SupabaseClient } from '../CommunicationHandler';
-// import { GenericSchema } from '@supabase/postgrest-js/dist/module/lib/types';
-import { RimoriCommunicationHandler, RimoriInfo } from '../CommunicationHandler';
-import { GenericSchema, GenericTable } from '@supabase/postgrest-js/dist/cjs/types/common/common';
-
-/**
- * Database module for plugin database operations.
- * Provides access to plugin tables with automatic prefixing and schema management.
- */
-export class DbModule {
-  private supabase: SupabaseClient;
-  private rimoriInfo: RimoriInfo;
-  public tablePrefix: string;
-  public schema: string;
-
-  constructor(supabase: SupabaseClient, communicationHandler: RimoriCommunicationHandler, info: RimoriInfo) {
-    this.supabase = supabase;
-    this.rimoriInfo = info;
-    this.tablePrefix = info.tablePrefix;
-    this.schema = info.dbSchema;
-
-    communicationHandler.onUpdate((updatedInfo) => {
-      this.rimoriInfo = updatedInfo;
-      this.tablePrefix = updatedInfo.tablePrefix;
-      this.schema = updatedInfo.dbSchema;
-    });
-  }
-
-  /**
-   * Query a database table.
-   * Global tables (starting with 'global_') remain in public schema.
-   * Plugin tables use the schema provided by rimori-main (plugins or plugins_alpha).
-   * @param relation The table name (without prefix for plugin tables, with 'global_' for global tables).
-   * @returns A Postgrest query builder for the table.
-   */
-  from<ViewName extends string & keyof GenericSchema['Views'], View extends GenericSchema['Views'][ViewName]>(
-    relation: string,
-  ): PostgrestQueryBuilder<PostgrestClientOptions, GenericSchema, GenericTable, ViewName, View> {
-    const tableName = this.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.supabase.from(tableName);
-    }
-    // Plugin tables go to the schema provided by rimori-main
-    return this.supabase.schema(this.rimoriInfo.dbSchema).from(tableName);
-  }
-
-  /**
-   * 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.tablePrefix + '_' + table;
-  }
-}

package/src/plugin/module/EventModule.ts

@@ -1,192 +0,0 @@
-import { MainPanelAction } from '../../fromRimori/PluginTypes';
-import { AccomplishmentController, AccomplishmentPayload } from '../../controller/AccomplishmentController';
-import { EventBus, EventBusMessage, EventHandler, EventPayload, EventListener } from '../../fromRimori/EventBus';
-
-/**
- * Event module for plugin event bus operations.
- * Provides methods for emitting, listening to, and responding to events.
- */
-export class EventModule {
-  private pluginId: string;
-  private accomplishmentController: AccomplishmentController;
-
-  constructor(pluginId: string) {
-    this.pluginId = pluginId;
-    this.accomplishmentController = new AccomplishmentController(pluginId);
-  }
-
-  public getGlobalEventTopic(preliminaryTopic: string): string {
-    if (preliminaryTopic.startsWith('global.')) {
-      return preliminaryTopic;
-    }
-    if (preliminaryTopic.startsWith('self.')) {
-      return preliminaryTopic;
-    }
-    const topicParts = preliminaryTopic.split('.');
-    if (topicParts.length === 3) {
-      if (!topicParts[0].startsWith('pl') && topicParts[0] !== 'global') {
-        throw new Error("The event topic must start with the plugin id or 'global'.");
-      }
-      return preliminaryTopic;
-    } else if (topicParts.length > 3) {
-      throw new Error(
-        `The event topic must consist of 3 parts. <pluginId>.<topic area>.<action>. Received: ${preliminaryTopic}`,
-      );
-    }
-
-    const topicRoot = this.pluginId ?? 'global';
-    return `${topicRoot}.${preliminaryTopic}`;
-  }
-
-  /**
-   * Emit an event to Rimori or a plugin.
-   * The topic schema is:
-   * {pluginId}.{eventId}
-   * Check out the event bus documentation for more information.
-   * For triggering events from Rimori like context menu actions use the "global" keyword.
-   * @param topic The topic to emit the event on.
-   * @param data The data to emit.
-   * @param eventId The event id.
-   */
-  emit(topic: string, data?: any, eventId?: number): void {
-    const globalTopic = this.getGlobalEventTopic(topic);
-    EventBus.emit(this.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.getGlobalEventTopic(topic);
-    return EventBus.request<T>(this.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.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>): void {
-    EventBus.once<T>(this.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>),
-  ): void {
-    const topics = Array.isArray(topic) ? topic : [topic];
-    EventBus.respond(
-      this.pluginId,
-      topics.map((t) => this.getGlobalEventTopic(t)),
-      data,
-    );
-  }
-
-  /**
-   * Emit an accomplishment.
-   * @param payload The payload to emit.
-   */
-  emitAccomplishment(payload: AccomplishmentPayload): void {
-    this.accomplishmentController.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,
-  ): void {
-    this.accomplishmentController.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): void {
-    this.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.emit('action.requestMain');
-    return this.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);
-      }
-    });
-  }
-
-  /**
-   * Subscribe to side 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.
-   */
-  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.emit('action.requestSidebar');
-    return this.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);
-      }
-    });
-  }
-}