@rimori/client 1.0.0

package/dist/plugin/PluginController.d.ts

@@ -0,0 +1,29 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+import { RimoriClient } from "./RimoriClient";
+export declare class PluginController {
+    private static instance;
+    private static client;
+    private plugin;
+    private onceListeners;
+    private listeners;
+    private communicationSecret;
+    private initialized;
+    private supabase;
+    private supabaseInfo;
+    private constructor();
+    static getInstance(): Promise<RimoriClient>;
+    init(): Promise<void>;
+    private getSecret;
+    getClient(): Promise<{
+        supabase: SupabaseClient;
+        tablePrefix: string;
+        pluginId: string;
+    }>;
+    getToken(): Promise<string>;
+    getSupabaseUrl(): string;
+    emit(eventName: string, data?: any): void;
+    private internalEmit;
+    subscribe(eventName: string, callback: (_id: number, data: any) => void): void;
+    onOnce(eventName: string, callback: (data: any) => void): void;
+    request<T>(topic: string, data?: any): Promise<T>;
+}

package/dist/plugin/PluginController.js

@@ -0,0 +1,138 @@
+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());
+    });
+};
+import { Child } from "ibridge-flex";
+import { createClient } from '@supabase/supabase-js';
+import { RimoriClient } from "./RimoriClient";
+export class PluginController {
+    constructor() {
+        this.onceListeners = new Map();
+        this.listeners = new Map();
+        this.communicationSecret = null;
+        this.initialized = false;
+        this.supabase = null;
+        this.supabaseInfo = null;
+        // localStorage.debug = "*";
+        this.plugin = new Child({
+            triggerChild: ({ topic, data, _id }) => {
+                var _a, _b;
+                // console.log("trigger child with topic:" + topic + " and data: ", data);
+                (_a = this.onceListeners.get(topic)) === null || _a === void 0 ? void 0 : _a.forEach((callback) => callback(_id, data));
+                this.onceListeners.set(topic, []);
+                (_b = this.listeners.get(topic)) === null || _b === void 0 ? void 0 : _b.forEach((callback) => callback(_id, data));
+            }
+        });
+        this.emit = this.emit.bind(this);
+        this.onOnce = this.onOnce.bind(this);
+        this.getClient = this.getClient.bind(this);
+        this.subscribe = this.subscribe.bind(this);
+        this.internalEmit = this.internalEmit.bind(this);
+        this.request = this.request.bind(this);
+    }
+    static getInstance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!PluginController.instance) {
+                PluginController.instance = new PluginController();
+                yield PluginController.instance.init();
+                PluginController.client = yield RimoriClient.getInstance(PluginController.instance);
+            }
+            return PluginController.client;
+        });
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.initialized)
+                return;
+            // Wait for the plugin to be ready
+            yield this.plugin.handshake().then(() => this.initialized = true).catch((error) => {
+                console.error("Failed to initialize the plugin communication:", error);
+            });
+        });
+    }
+    getSecret() {
+        if (!this.communicationSecret) {
+            const secret = new URLSearchParams(window.location.search).get("secret");
+            if (!secret) {
+                throw new Error("Communication secret not found in URL as query parameter");
+            }
+            this.communicationSecret = secret;
+        }
+        return this.communicationSecret;
+    }
+    getClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.supabase &&
+                this.supabaseInfo &&
+                this.supabaseInfo.expiration > new Date()) {
+                return { supabase: this.supabase, tablePrefix: this.supabaseInfo.tablePrefix, pluginId: this.supabaseInfo.pluginId };
+            }
+            this.supabaseInfo = yield this.request("getSupabaseAccess");
+            this.supabase = createClient(this.supabaseInfo.url, this.supabaseInfo.key, {
+                accessToken: () => Promise.resolve(this.getToken())
+            });
+            return { supabase: this.supabase, tablePrefix: this.supabaseInfo.tablePrefix, pluginId: this.supabaseInfo.pluginId };
+        });
+    }
+    getToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.supabaseInfo && this.supabaseInfo.expiration && this.supabaseInfo.expiration > new Date()) {
+                return this.supabaseInfo.token;
+            }
+            const response = yield this.request("getSupabaseAccess");
+            if (!this.supabaseInfo) {
+                throw new Error("Supabase info not found");
+            }
+            this.supabaseInfo.token = response.token;
+            this.supabaseInfo.expiration = response.expiration;
+            return this.supabaseInfo.token;
+        });
+    }
+    getSupabaseUrl() {
+        if (!this.supabaseInfo) {
+            throw new Error("Supabase info not found");
+        }
+        return this.supabaseInfo.url;
+    }
+    emit(eventName, data) {
+        this.internalEmit(eventName, 0, data);
+    }
+    // the communication needs to have an id to be able to distinguish between different responses
+    internalEmit(eventName, id, data) {
+        this.init().then(() => this.plugin.emitToParent(eventName, { data, _id: id, secret: this.getSecret() }));
+    }
+    subscribe(eventName, callback) {
+        var _a;
+        if (!this.listeners.has(eventName)) {
+            this.listeners.set(eventName, []);
+        }
+        (_a = this.listeners.get(eventName)) === null || _a === void 0 ? void 0 : _a.push(callback);
+    }
+    onOnce(eventName, callback) {
+        var _a;
+        if (!this.onceListeners.has(eventName)) {
+            this.onceListeners.set(eventName, []);
+        }
+        (_a = this.onceListeners.get(eventName)) === null || _a === void 0 ? void 0 : _a.push(callback);
+    }
+    request(topic_1) {
+        return __awaiter(this, arguments, void 0, function* (topic, data = {}) {
+            return yield new Promise((resolve) => {
+                let triggered = false;
+                const id = Math.random();
+                this.internalEmit(topic, id, data);
+                this.subscribe(topic, (_id, data) => {
+                    if (triggered || (_id !== id && _id !== 0))
+                        return;
+                    triggered = true;
+                    resolve(data);
+                });
+            });
+        });
+    }
+}

package/dist/plugin/RimoriClient.d.ts

@@ -0,0 +1,91 @@
+import { PluginController } from "./PluginController";
+import { SupabaseClient } from "@supabase/supabase-js";
+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;
+    functions: SupabaseClient["functions"];
+    storage: SupabaseClient["storage"];
+    pluginId: string;
+    tablePrefix: string;
+    private settingsController;
+    private sharedContentController;
+    private constructor();
+    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>;
+    /**
+    * Perform a function call.
+    *
+    * @param functionName - The function name to call
+    * @param args - The arguments to pass to the function call
+    * @param options - Named parameters
+    * @param options.head - When set to `true`, `data` will not be returned.
+    * Useful if you only need the count.
+    * @param options.get - When set to `true`, the function will be called with
+    * read-only access mode.
+    * @param options.count - Count algorithm to use to count rows returned by the
+    * function. Only applicable for [set-returning
+    * functions](https://www.postgresql.org/docs/current/functions-srf.html).
+    *
+    * `"exact"`: Exact but slow count algorithm. Performs a `COUNT(*)` under the
+    * hood.
+    *
+    * `"planned"`: Approximated but fast count algorithm. Uses the Postgres
+    * statistics under the hood.
+    *
+    * `"estimated"`: Uses exact count for low numbers and planned count for high
+    * numbers.
+    */
+    rpc<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 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>;
+    /**
+     * Fetch new shared content.
+     * @param type The type of shared content to fetch. E.g. assignments, exercises, etc.
+     * @param generatorInstructions The instructions for the generator.
+     * @param filter The filter for the shared content.
+     * @returns The new shared content.
+     */
+    fetchNewSharedContent<T, R = T & BasicAssignment>(type: string, generatorInstructions: (reservedTopics: string[]) => Promise<ObjectRequest> | ObjectRequest, filter?: {
+        column: string;
+        value: string | number | boolean;
+    }): Promise<R[]>;
+    /**
+     * Get a shared content item by id.
+     * @param type The type of shared content to get. E.g. assignments, exercises, etc.
+     * @param id The id of the shared content item.
+     * @returns The shared content item.
+     */
+    getSharedContent<T extends BasicAssignment>(type: string, id: string): Promise<T>;
+    /**
+     * Complete a shared content item.
+     * @param type The type of shared content to complete. E.g. assignments, exercises, etc.
+     * @param assignmentId The id of the shared content item to complete.
+     */
+    completeSharedContent(type: string, assignmentId: string): Promise<void>;
+}

package/dist/plugin/RimoriClient.js

@@ -0,0 +1,163 @@
+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());
+    });
+};
+import { SettingsController } from "../controller/SettingsController";
+import { getSTTResponse, getTTSResponse } from "../controller/VoiceController";
+import { SharedContentController } from "../controller/SharedContentController";
+import { streamChatGPT, generateText } from "../controller/AIController";
+import { generateObject as generateObjectFunction } from "../controller/ObjectController";
+export class RimoriClient {
+    constructor(options) {
+        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.settingsController = new SettingsController(options.supabase, options.pluginId);
+        this.sharedContentController = new SharedContentController(this);
+        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);
+    }
+    static getInstance(pluginController) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!RimoriClient.instance) {
+                const { supabase, tablePrefix, pluginId } = yield pluginController.getClient();
+                RimoriClient.instance = new RimoriClient({ pluginController, supabase, tablePrefix, pluginId });
+            }
+            return RimoriClient.instance;
+        });
+    }
+    from(relation) {
+        return this.superbase.from(this.getTableName(relation));
+    }
+    /**
+    * Perform a function call.
+    *
+    * @param functionName - The function name to call
+    * @param args - The arguments to pass to the function call
+    * @param options - Named parameters
+    * @param options.head - When set to `true`, `data` will not be returned.
+    * Useful if you only need the count.
+    * @param options.get - When set to `true`, the function will be called with
+    * read-only access mode.
+    * @param options.count - Count algorithm to use to count rows returned by the
+    * function. Only applicable for [set-returning
+    * functions](https://www.postgresql.org/docs/current/functions-srf.html).
+    *
+    * `"exact"`: Exact but slow count algorithm. Performs a `COUNT(*)` under the
+    * hood.
+    *
+    * `"planned"`: Approximated but fast count algorithm. Uses the Postgres
+    * statistics under the hood.
+    *
+    * `"estimated"`: Uses exact count for low numbers and planned count for high
+    * numbers.
+    */
+    rpc(functionName, args = {}, options = {}) {
+        return this.superbase.rpc(this.getTableName(functionName), args, options);
+    }
+    getTableName(type) {
+        return this.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);
+        });
+    }
+    /**
+     * Fetch new shared content.
+     * @param type The type of shared content to fetch. E.g. assignments, exercises, etc.
+     * @param generatorInstructions The instructions for the generator.
+     * @param filter The filter for the shared content.
+     * @returns The new shared content.
+     */
+    fetchNewSharedContent(type, generatorInstructions, filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.sharedContentController.fetchNewSharedContent(type, generatorInstructions, filter);
+        });
+    }
+    /**
+     * Get a shared content item by id.
+     * @param type The type of shared content to get. E.g. assignments, exercises, etc.
+     * @param id The id of the shared content item.
+     * @returns The shared content item.
+     */
+    getSharedContent(type, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.sharedContentController.getSharedContent(type, id);
+        });
+    }
+    /**
+     * Complete a shared content item.
+     * @param type The type of shared content to complete. E.g. assignments, exercises, etc.
+     * @param assignmentId The id of the shared content item to complete.
+     */
+    completeSharedContent(type, assignmentId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.sharedContentController.completeSharedContent(type, assignmentId);
+        });
+    }
+}

package/dist/plugin/SettingController.d.ts

@@ -0,0 +1,13 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+declare class SettingsController {
+    private static instance;
+    private supabase;
+    private tablePrefix;
+    private constructor();
+    static getInstance(): SettingsController;
+    initialize(supabase: SupabaseClient, tablePrefix: string): void;
+    getSettings<T>(defaultSettings: T, genericSettings?: "user" | "system"): Promise<T>;
+    setSettings(settings: any, genericSettings?: "user" | "system"): Promise<void>;
+}
+export declare const settingsController: SettingsController;
+export {};

package/dist/plugin/SettingController.js

@@ -0,0 +1,55 @@
+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());
+    });
+};
+class SettingsController {
+    constructor() {
+        this.supabase = null;
+        this.tablePrefix = '';
+    }
+    static getInstance() {
+        if (!SettingsController.instance) {
+            SettingsController.instance = new SettingsController();
+        }
+        return SettingsController.instance;
+    }
+    initialize(supabase, tablePrefix) {
+        this.supabase = supabase;
+        this.tablePrefix = tablePrefix;
+    }
+    getSettings(defaultSettings, genericSettings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // async function getPluginSettings(supabase:SupabaseClient, genericSettings:string) {
+            const response = yield this.plugin.request("get_settings", { genericSettings });
+            if (response === null) {
+                this.setSettings(defaultSettings, genericSettings);
+                return defaultSettings;
+                //if the settings are not the same, merge the settings
+            }
+            else if (Object.keys(response).length !== Object.keys(defaultSettings).length) {
+                const existingKeys = Object.fromEntries(Object.entries(response).filter(([k]) => k in defaultSettings));
+                const mergedSettings = Object.assign(Object.assign({}, defaultSettings), existingKeys);
+                console.warn("Settings mismatch", { response, defaultSettings, mergedSettings });
+                this.setSettings(mergedSettings, genericSettings);
+                return mergedSettings;
+            }
+            return response;
+        });
+    }
+    setSettings(settings, genericSettings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.supabase) {
+                throw new Error("SettingsController not initialized");
+            }
+            yield this.supabase
+                .from(this.tablePrefix + '_settings')
+                .upsert(settings);
+        });
+    }
+}
+export const settingsController = SettingsController.getInstance();

package/dist/plugin/ThemeSetter.d.ts

@@ -0,0 +1 @@
+export declare function setTheme(): void;

package/dist/plugin/ThemeSetter.js

@@ -0,0 +1,13 @@
+export function setTheme() {
+    const urlParams = new URLSearchParams(window.location.search);
+    let theme = urlParams.get('theme');
+    const isSidebar = urlParams.get('applicationMode') === "sidebar";
+    if (!theme || theme === 'system') {
+        theme = window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
+    }
+    document.documentElement.classList.add("dark:text-gray-200", "bg-white");
+    if (theme === 'dark') {
+        document.documentElement.classList.add('dark', isSidebar ? "bg-gray-920" : "bg-gray-950");
+        document.documentElement.style.background = isSidebar ? "rgb(6, 12, 30)" : "rgb(3, 7, 18)";
+    }
+}

package/dist/plugin/VoiceController.d.ts

@@ -0,0 +1,2 @@
+export declare function getSTTResponse(audio: Blob): Promise<any>;
+export declare function getTTSResponse(text: string, voice: string, speed: number, language?: string): Promise<Blob>;

package/dist/plugin/VoiceController.js

@@ -0,0 +1,27 @@
+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 function getSTTResponse(audio) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const formData = new FormData();
+        formData.append('file', audio);
+        return yield fetch('/api/stt', { method: 'POST', body: formData })
+            .then(r => r.json())
+            .then(r => r.text);
+    });
+}
+export function getTTSResponse(text, voice, speed, language) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield fetch('/api/speech', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ input: text, voice, speed, language }),
+        }).then(r => r.blob());
+    });
+}

package/dist/providers/EventEmitter.d.ts

@@ -0,0 +1,11 @@
+type Listener<T = any> = (event: T) => void;
+export declare class EventEmitter {
+    private events;
+    constructor();
+    on<T = any>(eventName: string, listener: Listener<T>): void;
+    once<T = any>(eventName: string, listener: Listener<T>): void;
+    removeListener<T = any>(eventName: string, listener: Listener<T>): void;
+    emit<T = any>(eventName: string, data?: T): void;
+}
+export declare const EmitterSingleton: EventEmitter;
+export {};

package/dist/providers/EventEmitter.js

@@ -0,0 +1,41 @@
+export class EventEmitter {
+    constructor() {
+        this.events = new Map();
+        this.on = this.on.bind(this);
+        this.once = this.once.bind(this);
+        this.emit = this.emit.bind(this);
+        this.removeListener = this.removeListener.bind(this);
+    }
+    // Subscribe to an event
+    on(eventName, listener) {
+        if (!this.events.has(eventName)) {
+            this.events.set(eventName, []);
+        }
+        this.events.get(eventName).push(listener);
+    }
+    // Subscribe to an event for a single invocation
+    once(eventName, listener) {
+        const onceWrapper = (event) => {
+            this.removeListener(eventName, onceWrapper);
+            listener(event);
+        };
+        this.on(eventName, onceWrapper);
+    }
+    // Remove a specific listener
+    removeListener(eventName, listener) {
+        const listeners = this.events.get(eventName);
+        if (!listeners)
+            return;
+        this.events.set(eventName, listeners.filter((l) => l !== listener));
+    }
+    // Emit an event
+    emit(eventName, data) {
+        const listeners = this.events.get(eventName);
+        console.log("emit", eventName, data, listeners);
+        if (!listeners)
+            return;
+        listeners.forEach((listener) => listener(data));
+    }
+}
+const emitter = new EventEmitter();
+export const EmitterSingleton = emitter;

package/dist/providers/EventEmitterContext.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+import { EventEmitter } from "./EventEmitter";
+export declare const EventEmitterProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+export declare const useEventEmitter: () => EventEmitter;

package/dist/providers/EventEmitterContext.js

@@ -0,0 +1,19 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useRef } from "react";
+import { EmitterSingleton } from "./EventEmitter";
+// Create the Context
+const EventEmitterContext = createContext(null);
+// Provider Component
+export const EventEmitterProvider = ({ children }) => {
+    const eventEmitterRef = useRef(EmitterSingleton);
+    return (_jsx(EventEmitterContext.Provider, { value: eventEmitterRef.current, children: children }));
+};
+// Hook to use the EventEmitter
+export const useEventEmitter = () => {
+    const context = useContext(EventEmitterContext);
+    if (!context) {
+        throw new Error("useEventEmitter must be used within an EventEmitterProvider");
+    }
+    return context;
+};

package/dist/providers/PluginProvider.d.ts

@@ -0,0 +1,8 @@
+import React, { ReactNode } from 'react';
+import { RimoriClient } from '../plugin/RimoriClient';
+interface PluginProviderProps {
+    children: ReactNode;
+}
+export declare const PluginProvider: React.FC<PluginProviderProps>;
+export declare const usePlugin: () => RimoriClient;
+export {};