@rimori/client 1.0.2 → 1.0.4

package/dist/plugin/RimoriClient.d.ts

@@ -1,24 +1,95 @@
 import { PluginController } from "./PluginController";
 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 { ObjectRequest } from "../controller/ObjectController";
-export declare class RimoriClient {
-    private static instance;
-    private superbase;
-    private plugin;
+import { Plugin } from "../controller/SidePluginController";
+import { UserInfo } from "../controller/SettingsController";
+import { EventHandler } from "./fromRimori/EventBus";
+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"];
+}
+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.
+     * @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: <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>;
+}
+export declare class RimoriClient {
+    private static instance;
+    private superbase;
+    private pluginController;
     private settingsController;
     private sharedContentController;
+    private supabaseUrl;
+    db: Db;
+    plugin: PluginInterface;
     private constructor();
+    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) => void;
+        /**
+         * 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>>;
+        /**
+         * Subscribe to an event.
+         * @param topic The topic to subscribe to.
+         * @param callback The callback to call when the event is emitted.
+         */
+        on: <T = EventPayload>(topic: string, callback: EventHandler<T>) => void;
+        /**
+         * 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;
+        /**
+         * Respond to an event.
+         * @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>)) => void;
+    };
     static getInstance(pluginController: PluginController): Promise<RimoriClient>;
-    from<TableName extends string & keyof GenericSchema['Tables'], Table extends GenericSchema['Tables'][TableName]>(relation: TableName): PostgrestQueryBuilder<GenericSchema, Table, TableName>;
-    from<ViewName extends string & keyof GenericSchema['Views'], View extends GenericSchema['Views'][ViewName]>(relation: ViewName): PostgrestQueryBuilder<GenericSchema, View, ViewName>;
+    private from;
     /**
     * Perform a function call.
     *
@@ -42,28 +113,15 @@ export declare class RimoriClient {
     * `"estimated"`: Uses exact count for low numbers and planned count for high
     * numbers.
     */
-    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>;
+    private rpc;
     private getTableName;
-    subscribe(eventName: string, callback: (_id: number, data: any) => void): void;
-    request<T>(eventName: string, data?: any): Promise<T>;
-    emit(eventName: string, data: any): void;
-    /**
-    * 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<T extends object>(defaultSettings: T, genericSettings?: "user" | "system"): Promise<T>;
-    setSettings(settings: any, genericSettings?: "user" | "system"): Promise<void>;
-    getAIResponse(messages: Message[], tools?: Tool[]): Promise<string>;
-    getAIResponseStream(messages: Message[], onMessage: OnLLMResponse, tools?: Tool[]): Promise<void>;
-    getVoiceResponse(text: string, voice?: string, speed?: number, language?: string): Promise<Blob>;
-    getVoiceToTextResponse(file: Blob): Promise<string>;
-    generateObject(request: ObjectRequest): Promise<any>;
+    llm: {
+        getText: (messages: Message[], tools?: Tool[]) => Promise<string>;
+        getSteamedText: (messages: Message[], onMessage: OnLLMResponse, tools?: Tool[]) => Promise<void>;
+        getVoice: (text: string, voice?: string, speed?: number, language?: string) => Promise<Blob>;
+        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.
@@ -88,4 +146,6 @@ export declare class RimoriClient {
      * @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;
 }
+export {};

package/dist/plugin/RimoriClient.js

@@ -12,28 +12,110 @@ 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 { EventBus } from "./fromRimori/EventBus";
 export class RimoriClient {
     constructor(options) {
+        this.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, data, eventId) => {
+                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: (topic, data) => {
+                const globalTopic = this.pluginController.getGlobalEventTopic(topic);
+                return EventBus.request(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.
+             */
+            on: (topic, callback) => {
+                EventBus.on(this.pluginController.getGlobalEventTopic(topic), 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: (topic, callback) => {
+                EventBus.once(this.pluginController.getGlobalEventTopic(topic), callback);
+            },
+            /**
+             * Respond to an event.
+             * @param topic The topic to respond to.
+             * @param data The data to respond with.
+             */
+            respond: (topic, data) => {
+                EventBus.respond(this.plugin.pluginId, this.pluginController.getGlobalEventTopic(topic), data);
+            }
+        };
+        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);
+            }),
+            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());
+            }),
+            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);
+            }),
+            // getSteamedObject: this.generateObjectStream,
+        };
         this.superbase = options.supabase;
-        this.pluginId = options.pluginId;
-        this.plugin = options.pluginController;
-        this.tablePrefix = options.tablePrefix;
-        this.storage = this.superbase.storage;
-        this.functions = this.superbase.functions;
+        this.pluginController = options.pluginController;
         this.settingsController = new SettingsController(options.supabase, options.pluginId);
         this.sharedContentController = new SharedContentController(this);
+        this.supabaseUrl = this.pluginController.getSupabaseUrl();
         this.rpc = this.rpc.bind(this);
         this.from = this.from.bind(this);
-        this.emit = this.emit.bind(this);
-        this.request = this.request.bind(this);
-        this.subscribe = this.subscribe.bind(this);
-        this.getSettings = this.getSettings.bind(this);
-        this.setSettings = this.setSettings.bind(this);
-        this.getAIResponse = this.getAIResponse.bind(this);
-        this.generateObject = this.generateObject.bind(this);
-        this.getVoiceResponse = this.getVoiceResponse.bind(this);
-        this.getAIResponseStream = this.getAIResponseStream.bind(this);
-        this.getVoiceToTextResponse = this.getVoiceToTextResponse.bind(this);
+        this.db = {
+            rpc: this.rpc,
+            from: this.from,
+            storage: this.superbase.storage,
+            functions: this.superbase.functions,
+        };
+        this.plugin = {
+            pluginId: options.pluginId,
+            tablePrefix: options.tablePrefix,
+            setSettings: (settings) => __awaiter(this, void 0, void 0, function* () {
+                yield this.settingsController.setSettings(settings);
+            }),
+            getSettings: (defaultSettings) => __awaiter(this, void 0, void 0, function* () {
+                return yield this.settingsController.getSettings(defaultSettings);
+            }),
+            getInstalled: () => __awaiter(this, void 0, void 0, function* () {
+                return getPlugins(this.superbase);
+            }),
+            getUserInfo: () => __awaiter(this, void 0, void 0, function* () {
+                return this.settingsController.getUserInfo();
+            })
+        };
     }
     static getInstance(pluginController) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -74,58 +156,7 @@ export class RimoriClient {
         return this.superbase.rpc(this.getTableName(functionName), args, options);
     }
     getTableName(type) {
-        return this.tablePrefix + "_" + type;
-    }
-    subscribe(eventName, callback) {
-        this.plugin.subscribe(eventName, callback);
-    }
-    request(eventName, data) {
-        return this.plugin.request(eventName, data);
-    }
-    emit(eventName, data) {
-        this.plugin.emit(eventName, data);
-    }
-    /**
-    * 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(defaultSettings, genericSettings) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.settingsController.getSettings(defaultSettings, genericSettings);
-        });
-    }
-    setSettings(settings, genericSettings) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.settingsController.setSettings(settings, genericSettings);
-        });
-    }
-    getAIResponse(messages, tools) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const token = yield this.plugin.getToken();
-            return generateText(messages, tools || [], token).then(response => response.messages[0].content[0].text);
-        });
-    }
-    getAIResponseStream(messages, onMessage, tools) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const token = yield this.plugin.getToken();
-            streamChatGPT(messages, tools || [], onMessage, token);
-        });
-    }
-    getVoiceResponse(text_1) {
-        return __awaiter(this, arguments, void 0, function* (text, voice = "alloy", speed = 1, language) {
-            return getTTSResponse(this.plugin.getSupabaseUrl(), { input: text, voice, speed, language }, yield this.plugin.getToken());
-        });
-    }
-    getVoiceToTextResponse(file) {
-        return getSTTResponse(this.superbase, file);
-    }
-    generateObject(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const token = yield this.plugin.getToken();
-            return generateObjectFunction(request, token);
-        });
+        return this.plugin.tablePrefix + "_" + type;
     }
     /**
      * Fetch new shared content.
@@ -160,4 +191,7 @@ export class RimoriClient {
             return this.sharedContentController.completeSharedContent(type, assignmentId);
         });
     }
+    triggerSidebarAction(pluginId, actionKey, text) {
+        this.event.emit("global.sidebar.triggerAction", { pluginId, actionKey, text });
+    }
 }

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

@@ -0,0 +1,98 @@
+export type EventPayload = Record<string, any>;
+/**
+ * Interface representing a message sent through the EventBus
+ *
+ * Debug capabilities:
+ * - System-wide debugging: Send an event to "global.system.requestDebug"
+ *   Example: `EventBus.emit("yourPluginId", "global.system.requestDebug");`
+ */
+export interface EventBusMessage<T = EventPayload> {
+    timestamp: string;
+    eventId: number;
+    sender: string;
+    topic: string;
+    data: T;
+    debug: boolean;
+}
+export type EventHandler<T = EventPayload> = (event: EventBusMessage<T>) => void | Promise<void>;
+export declare class EventBusHandler {
+    private listeners;
+    private responseResolvers;
+    private static instance;
+    private debugEnabled;
+    private evName;
+    private constructor();
+    static getInstance(name?: string): EventBusHandler;
+    private createEvent;
+    /**
+     * Emits an event to the event bus. Can be a new event or a response to a request.
+     * @param sender - The sender of the event.
+     * @param topic - The topic of the event.
+     * @param data - The data of the event.
+     * @param eventId - The event id of the event.
+     *
+     * The topic format is: **pluginId.area.action**
+     *
+     * Example topics:
+     * - pl1234.card.requestHard
+     * - pl1234.card.requestNew
+     * - pl1234.card.requestAll
+     * - pl1234.card.create
+     * - pl1234.card.update
+     * - pl1234.card.delete
+     * - pl1234.card.triggerBackup
+     */
+    emit<T = EventPayload>(sender: string, topic: string, data?: T, eventId?: number): void;
+    private emitInternal;
+    /**
+     * Subscribes to an event on the event bus.
+     * @param topics - The topic of the event.
+     * @param handler - The handler to be called when the event is emitted.
+     * @param ignoreSender - The senders to ignore.
+     * @returns The ids of the listeners.
+     */
+    on<T = EventPayload>(topics: string | string[], handler: EventHandler<T>, ignoreSender?: string[]): string[];
+    /**
+     * Subscribes to an event, processes the data and emits a response on the event bus.
+     * @param sender - The sender of the event.
+     * @param topic - The topic of the event.
+     * @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[];
+    /**
+     * Subscribes to an event on the event bus. The handler will be called once and then removed.
+     * @param topic - The topic of the event.
+     * @param handler - The handler to be called when the event is emitted.
+     */
+    once<T = EventPayload>(topic: string, handler: EventHandler<T>): void;
+    /**
+     * Unsubscribes from an event on the event bus.
+     * @param listenerIds - The ids of the listeners to unsubscribe from.
+     */
+    off(listenerIds: string | string[]): void;
+    private toArray;
+    /**
+     * Requests data from the event bus.
+     * @param sender - The sender of the event.
+     * @param topic - The topic of the event.
+     * @param data - The data of the event.
+     * @returns A promise that resolves to the event.
+     */
+    request<T = EventPayload>(sender: string, topic: string, data?: EventPayload): Promise<EventBusMessage<T>>;
+    /**
+     * Gets the matching handlers for an event.
+     * @param topic - The topic of the event.
+     * @returns A set of handlers that match the event type.
+     */
+    private getMatchingHandlers;
+    /**
+     * Validates the topic of an event.
+     * @param topic - The topic of the event.
+     * @returns True if the topic is valid, false otherwise.
+     */
+    private validateTopic;
+    private logIfDebug;
+    private logAndThrowError;
+}
+export declare const EventBus: EventBusHandler;

package/dist/plugin/fromRimori/EventBus.js

@@ -0,0 +1,240 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export class EventBusHandler {
+    constructor() {
+        this.listeners = new Map();
+        this.responseResolvers = new Map();
+        this.debugEnabled = false;
+        this.evName = "";
+        //private constructor
+    }
+    static getInstance(name) {
+        if (!EventBusHandler.instance) {
+            EventBusHandler.instance = new EventBusHandler();
+            EventBusHandler.instance.on("global.system.requestDebug", () => {
+                EventBusHandler.instance.debugEnabled = true;
+                console.log(`[${EventBusHandler.instance.evName}] Debug mode enabled. Make sure debugging messages are enabled in the browser console.`);
+            });
+        }
+        if (name && EventBusHandler.instance.evName === "") {
+            EventBusHandler.instance.evName = name;
+        }
+        return EventBusHandler.instance;
+    }
+    createEvent(sender, topic, data, eventId) {
+        const generatedEventId = eventId || Math.floor(Math.random() * 10000000000);
+        return {
+            eventId: generatedEventId,
+            timestamp: new Date().toISOString(),
+            sender,
+            topic,
+            data,
+            debug: this.debugEnabled,
+        };
+    }
+    /**
+     * Emits an event to the event bus. Can be a new event or a response to a request.
+     * @param sender - The sender of the event.
+     * @param topic - The topic of the event.
+     * @param data - The data of the event.
+     * @param eventId - The event id of the event.
+     *
+     * The topic format is: **pluginId.area.action**
+     *
+     * Example topics:
+     * - pl1234.card.requestHard
+     * - pl1234.card.requestNew
+     * - pl1234.card.requestAll
+     * - pl1234.card.create
+     * - pl1234.card.update
+     * - pl1234.card.delete
+     * - pl1234.card.triggerBackup
+     */
+    emit(sender, topic, data, eventId) {
+        this.emitInternal(sender, topic, data || {}, eventId);
+    }
+    emitInternal(sender, topic, data, eventId, skipResponseTrigger = false) {
+        if (!this.validateTopic(topic)) {
+            this.logAndThrowError(false, `Invalid topic: ` + topic);
+            return;
+        }
+        const event = this.createEvent(sender, topic, data, eventId);
+        const handlers = this.getMatchingHandlers(event.topic);
+        handlers.forEach(handler => {
+            if (handler.ignoreSender && handler.ignoreSender.includes(sender)) {
+                // console.log("ignore event as its in the ignoreSender list", { event, ignoreList: handler.ignoreSender });
+                return;
+            }
+            handler.handler(event);
+        });
+        this.logIfDebug(`Emitting event to ` + topic, event);
+        if (handlers.size === 0) {
+            this.logAndThrowError(false, `No handlers found for topic: ` + topic);
+        }
+        // If it's a response to a request
+        if (eventId && this.responseResolvers.has(eventId) && !skipResponseTrigger) {
+            // console.log("[Rimori] Resolving response to request: " + eventId, event.data);
+            this.responseResolvers.get(eventId)(event);
+            this.responseResolvers.delete(eventId);
+        }
+    }
+    /**
+     * Subscribes to an event on the event bus.
+     * @param topics - The topic of the event.
+     * @param handler - The handler to be called when the event is emitted.
+     * @param ignoreSender - The senders to ignore.
+     * @returns The ids of the listeners.
+     */
+    on(topics, handler, ignoreSender = []) {
+        return this.toArray(topics).map(topic => {
+            if (!this.validateTopic(topic)) {
+                this.logAndThrowError(true, `Invalid topic: ` + topic);
+            }
+            if (!this.listeners.has(topic)) {
+                this.listeners.set(topic, new Set());
+            }
+            const id = Math.floor(Math.random() * 10000000000);
+            // Type assertion to handle the generic type mismatch
+            const eventHandler = handler;
+            this.listeners.get(topic).add({ id, handler: eventHandler, ignoreSender });
+            this.logIfDebug(`Subscribed to ` + topic, { listenerId: id, ignoreSender });
+            return btoa(JSON.stringify({ topic, id }));
+        });
+    }
+    /**
+     * Subscribes to an event, processes the data and emits a response on the event bus.
+     * @param sender - The sender of the event.
+     * @param topic - The topic of the event.
+     * @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, topic, handler) {
+        const ids = this.on(topic, (data) => __awaiter(this, void 0, void 0, function* () {
+            const response = typeof handler === "function" ? yield handler(data) : handler;
+            this.emit(sender, topic, response, data.eventId);
+        }), [sender]);
+        this.logIfDebug(`Added respond listener ` + sender + " to topic " + topic, { listenerIds: ids, sender });
+        return ids;
+    }
+    /**
+     * Subscribes to an event on the event bus. The handler will be called once and then removed.
+     * @param topic - The topic of the event.
+     * @param handler - The handler to be called when the event is emitted.
+     */
+    once(topic, handler) {
+        if (!this.validateTopic(topic)) {
+            this.logAndThrowError(false, `Invalid topic: ` + topic);
+            return;
+        }
+        let ids = [];
+        const wrapper = (event) => {
+            handler(event);
+            this.off(ids);
+        };
+        ids = this.on(topic, wrapper);
+        this.logIfDebug(`Added once listener ` + topic, { listenerIds: ids, topic });
+    }
+    /**
+     * Unsubscribes from an event on the event bus.
+     * @param listenerIds - The ids of the listeners to unsubscribe from.
+     */
+    off(listenerIds) {
+        this.toArray(listenerIds).forEach(fullId => {
+            const { topic, id } = JSON.parse(atob(fullId));
+            const listeners = this.listeners.get(topic) || new Set();
+            listeners.forEach(listener => {
+                if (listener.id === Number(id)) {
+                    listeners.delete(listener);
+                    this.logIfDebug(`Removed listener ` + fullId, { topic, listenerId: id });
+                }
+            });
+        });
+    }
+    toArray(item) {
+        return Array.isArray(item) ? item : [item];
+    }
+    /**
+     * Requests data from the event bus.
+     * @param sender - The sender of the event.
+     * @param topic - The topic of the event.
+     * @param data - The data of the event.
+     * @returns A promise that resolves to the event.
+     */
+    request(sender, topic, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.validateTopic(topic)) {
+                this.logAndThrowError(true, `Invalid topic: ` + topic);
+            }
+            const event = this.createEvent(sender, topic, data || {});
+            this.logIfDebug(`Requesting data from ` + topic, { event });
+            return new Promise(resolve => {
+                this.responseResolvers.set(event.eventId, (value) => resolve(value));
+                this.emitInternal(sender, topic, data || {}, event.eventId, true);
+            });
+        });
+    }
+    /**
+     * Gets the matching handlers for an event.
+     * @param topic - The topic of the event.
+     * @returns A set of handlers that match the event type.
+     */
+    getMatchingHandlers(topic) {
+        const exact = this.listeners.get(topic) || new Set();
+        // Find wildcard matches
+        const wildcard = [...this.listeners.entries()]
+            .filter(([key]) => key.endsWith("*") && topic.startsWith(key.slice(0, -1)))
+            .flatMap(([_, handlers]) => [...handlers]);
+        return new Set([...exact, ...wildcard]);
+    }
+    /**
+     * Validates the topic of an event.
+     * @param topic - The topic of the event.
+     * @returns True if the topic is valid, false otherwise.
+     */
+    validateTopic(topic) {
+        // Split event type into parts
+        const parts = topic.split(".");
+        const [plugin, area, action] = parts;
+        if (parts.length !== 3) {
+            if (parts.length === 1 && plugin === "*") {
+                return true;
+            }
+            if (parts.length === 2 && plugin !== "*" && area === "*") {
+                return true;
+            }
+            this.logAndThrowError(false, `Event type must have 3 parts separated by dots. Received: ` + topic);
+            return false;
+        }
+        if (action === "*") {
+            return true;
+        }
+        // Validate action part
+        const validActions = ["request", "create", "update", "delete", "trigger"];
+        if (validActions.some(a => action.startsWith(a))) {
+            return true;
+        }
+        this.logAndThrowError(false, `Invalid event topic name. The action: ` + action + ". Must be or start with one of: " + validActions.join(", "));
+        return false;
+    }
+    logIfDebug(...args) {
+        if (this.debugEnabled) {
+            console.debug(`[${this.evName}] ` + args[0], ...args.slice(1));
+        }
+    }
+    logAndThrowError(throwError, ...args) {
+        const message = `[${this.evName}] ` + args[0];
+        console.error(message, ...args.slice(1));
+        if (throwError) {
+            throw new Error(message);
+        }
+    }
+}
+EventBusHandler.instance = null;
+export const EventBus = EventBusHandler.getInstance();