@rimori/client 1.0.3 → 1.0.4

package/src/plugin/fromRimori/EventBus.ts

@@ -0,0 +1,301 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+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 of the event
+  timestamp: string;
+  //unique ID of the event
+  eventId: number;
+  //plugin id or "global" for global events
+  sender: string;
+  //the topic of the event consisting of the plugin id, key area and action e.g. "translator.word.triggerTranslation"
+  topic: string;
+  //any type of data to be transmitted
+  data: T;
+  //indicated if the debug mode is active
+  debug: boolean;
+}
+
+export type EventHandler<T = EventPayload> = (event: EventBusMessage<T>) => void | Promise<void>;
+
+interface Listeners<T = EventPayload> {
+  id: number;
+  handler: EventHandler<T>;
+  ignoreSender?: string[];
+}
+
+export class EventBusHandler {
+  private listeners: Map<string, Set<Listeners<EventPayload>>> = new Map();
+  private responseResolvers: Map<number, (value: EventBusMessage<unknown>) => void> = new Map();
+  private static instance: EventBusHandler | null = null;
+  private debugEnabled: boolean = false;
+  private evName: string = "";
+
+  private constructor() {
+    //private constructor
+  }
+
+  static getInstance(name?: string) {
+    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;
+  }
+
+  private createEvent(sender: string, topic: string, data: EventPayload, eventId?: number): EventBusMessage {
+    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
+   */
+  public emit<T = EventPayload>(sender: string, topic: string, data?: T, eventId?: number): void {
+    this.emitInternal(sender, topic, data || {}, eventId);
+  }
+
+  private emitInternal(sender: string, topic: string, data: EventPayload, eventId?: number, skipResponseTrigger = false): void {
+    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.
+   */
+  public on<T = EventPayload>(topics: string | string[], handler: EventHandler<T>, ignoreSender: string[] = []): string[] {
+    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 as unknown as EventHandler<EventPayload>;
+      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.
+   */
+  public respond(sender: string, topic: string, handler: EventPayload | ((data: EventBusMessage) => EventPayload | Promise<EventPayload>)): string[] {
+    const ids = this.on(topic, async (data: EventBusMessage) => {
+      const response = typeof handler === "function" ? await 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.
+   */
+  public once<T = EventPayload>(topic: string, handler: EventHandler<T>): void {
+    if (!this.validateTopic(topic)) {
+      this.logAndThrowError(false, `Invalid topic: ` + topic);
+      return;
+    }
+
+    let ids: string[] = [];
+    const wrapper = (event: EventBusMessage<T>) => {
+      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.
+   */
+  public off(listenerIds: string | string[]): void {
+    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 });
+        }
+      });
+    });
+  }
+
+  private toArray(item: string | string[]): string[] {
+    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.
+   */
+  public async request<T = EventPayload>(sender: string, topic: string, data?: EventPayload): Promise<EventBusMessage<T>> {
+    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<EventBusMessage<T>>(resolve => {
+      this.responseResolvers.set(event.eventId, (value: EventBusMessage<unknown>) => resolve(value as EventBusMessage<T>));
+      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.
+   */
+  private getMatchingHandlers(topic: string): Set<Listeners<EventPayload>> {
+    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.
+   */
+  private validateTopic(topic: string): boolean {
+    // 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;
+  }
+
+  private logIfDebug(...args: (string | EventPayload)[]) {
+    if (this.debugEnabled) {
+      console.debug(`[${this.evName}] ` + args[0], ...args.slice(1));
+    }
+  }
+
+  private logAndThrowError(throwError: boolean, ...args: (string | EventPayload)[]) {
+    const message = `[${this.evName}] ` + args[0];
+    console.error(message, ...args.slice(1));
+    if (throwError) {
+      throw new Error(message);
+    }
+  }
+}
+
+export const EventBus = EventBusHandler.getInstance();

package/src/plugin/fromRimori/readme.md

@@ -0,0 +1,2 @@
+Files inside this folder are copied from Rimori and should not be changed. 
+If change is needed adapt it in Rimori and copy the file then over.

package/src/providers/PluginProvider.tsx

@@ -1,16 +1,18 @@
 import React, { createContext, useContext, ReactNode, useEffect, useState } from 'react';
 import { PluginController } from '../plugin/PluginController';
 import { RimoriClient } from '../plugin/RimoriClient';
-import { UserSettings } from '../controller/SettingsController';
+import { EventBusHandler } from '../plugin/fromRimori/EventBus';
 
 interface PluginProviderProps {
     children: ReactNode;
+    pluginId: string;
 }
 
-const PluginContext = createContext<RimoriClient | null>(null);
+EventBusHandler.getInstance("Plugin EventBus");
 
+const PluginContext = createContext<RimoriClient | null>(null);
 
-export const PluginProvider: React.FC<PluginProviderProps> = ({ children }) => {
+export const PluginProvider: React.FC<PluginProviderProps> = ({ children, pluginId }) => {
     const [plugin, setPlugin] = useState<RimoriClient | null>(null);
     const [contextMenuOnSelect, setContextMenuOnTextSelection] = useState(false);
 
@@ -22,21 +24,17 @@ export const PluginProvider: React.FC<PluginProviderProps> = ({ children }) => {
             if (lastHash !== window.location.hash) {
                 lastHash = window.location.hash;
                 console.log('url changed:', lastHash);
-                plugin?.emit('urlChange', window.location.hash);
+                plugin?.event.emit('session.triggerUrlChange', window.location.hash);
             }
         }, 100);
-        PluginController.getInstance().then(setPlugin);
+        PluginController.getInstance(pluginId).then(setPlugin);
     }, []);
 
     //check if context menu opens on text selection
     useEffect(() => {
         if (!plugin) return;
-        plugin.getSettings<UserSettings>({
-            languageLevel: "A1",
-            motherTongue: "English",
-            contextMenuOnSelect: false,
-        }, "user").then((settings) => {
-            setContextMenuOnTextSelection(settings.contextMenuOnSelect);
+        plugin.plugin.getUserInfo().then((userInfo) => {
+            setContextMenuOnTextSelection(userInfo.contextMenuOnSelect);
         }).catch(error => {
             console.error('Error fetching settings:', error);
         });
@@ -45,7 +43,7 @@ export const PluginProvider: React.FC<PluginProviderProps> = ({ children }) => {
     //detect page height change
     useEffect(() => {
         const body = document.body;
-        const handleResize = () => plugin?.emit('heightAdjustment', body.clientHeight);
+        const handleResize = () => plugin?.event.emit('session.triggerHeightChange', body.clientHeight);
         body.addEventListener('resize', handleResize);
         handleResize();
         return () => body.removeEventListener('resize', handleResize);
@@ -68,7 +66,7 @@ export const PluginProvider: React.FC<PluginProviderProps> = ({ children }) => {
             if (selection) {
                 e.preventDefault();
                 // console.log('context menu handled', selection);
-                plugin?.emit('contextMenu', { text: selection, x: e.clientX, y: e.clientY, open: true });
+                plugin?.event.emit('global.contextMenu.trigger', { text: selection, x: e.clientX, y: e.clientY, open: true });
             }
         };
 
@@ -77,7 +75,7 @@ export const PluginProvider: React.FC<PluginProviderProps> = ({ children }) => {
             const selection = window.getSelection()?.toString().trim();
             const open = !!selection && isSelecting;
             // console.log('Selection change, contextMenuOnSelect:', contextMenuOnSelect);
-            plugin?.emit('contextMenu', { text: selection, x: lastMouseX, y: lastMouseY, open });
+            plugin?.event.emit('global.contextMenu.trigger', { text: selection, x: lastMouseX, y: lastMouseY, open });
             // }
         };
         const handleMouseUpDown = (e: MouseEvent) => {

package/src/worker/WorkerSetup.ts

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

package/dist/CRUDModal.d.ts

@@ -1,16 +0,0 @@
-interface Props {
-    title: string;
-    show?: boolean;
-    className?: string;
-    closeAble?: boolean;
-    children: React.ReactNode;
-    actionbuttons: ActionButton[];
-    buttonText?: string | React.ReactNode;
-}
-interface ActionButton {
-    text: string;
-    onClick: () => void;
-    closeModal?: boolean;
-}
-export declare function CRUDModal({ actionbuttons, children, title, buttonText, className, closeAble, show }: Props): import("react/jsx-runtime").JSX.Element;
-export {};

package/dist/CRUDModal.js

@@ -1,31 +0,0 @@
-"use client";
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { useEffect, useState, useRef } from "react";
-export function CRUDModal({ actionbuttons, children, title, buttonText, className, closeAble = true, show = false }) {
-    const [openModal, setOpenModal] = useState(show);
-    const dialogRef = useRef(null);
-    useEffect(() => {
-        var _a, _b;
-        if (show) {
-            (_a = dialogRef.current) === null || _a === void 0 ? void 0 : _a.showModal();
-        }
-        else {
-            (_b = dialogRef.current) === null || _b === void 0 ? void 0 : _b.close();
-        }
-        setOpenModal(show);
-    }, [show]);
-    const handleClose = () => {
-        var _a;
-        setOpenModal(false);
-        (_a = dialogRef.current) === null || _a === void 0 ? void 0 : _a.close();
-    };
-    return (_jsxs(_Fragment, { children: [!!buttonText && _jsx("button", { className: className, onClick: () => {
-                    var _a;
-                    setOpenModal(true);
-                    (_a = dialogRef.current) === null || _a === void 0 ? void 0 : _a.showModal();
-                }, children: buttonText }), _jsxs("dialog", { ref: dialogRef, className: "bg-gray-400 rounded-lg font-normal", onClose: handleClose, children: [_jsxs("div", { className: "bg-gray-500 text-xl flex flex-row justify-between p-3 items-start font-bold", children: [_jsx("h2", { children: title }), closeAble && _jsx("button", { onClick: handleClose, children: "\u00D7" })] }), _jsx("div", { className: "modal-body p-2", children: children }), _jsx("div", { className: "modal-footer px-2 py-2 flex flex-row gap-2 border-t-2", children: actionbuttons.map(({ onClick, text, closeModal = true }, index) => (_jsx("button", { className: " bg-blue-500 hover:bg-blue-600 dark:border-gray-900 rounded-md py-2 px-4 dark:text-white font-bold", onClick: () => {
-                                if (closeModal)
-                                    handleClose();
-                                onClick();
-                            }, children: text }, index))) })] })] }));
-}

package/dist/MarkdownEditor.d.ts

@@ -1,8 +0,0 @@
-interface Props {
-    content?: string;
-    editable: boolean;
-    className?: string;
-    onUpdate?: (content: string) => void;
-}
-export declare const MarkdownEditor: (props: Props) => import("react/jsx-runtime").JSX.Element;
-export {};

package/dist/MarkdownEditor.js

@@ -1,46 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Markdown } from 'tiptap-markdown';
-import StarterKit from "@tiptap/starter-kit";
-import { PiCodeBlock } from "react-icons/pi";
-import { TbBlockquote } from "react-icons/tb";
-import { GoListOrdered } from "react-icons/go";
-import { AiOutlineUnorderedList } from "react-icons/ai";
-import { EditorProvider, useCurrentEditor } from "@tiptap/react";
-import { LuHeading1, LuHeading2, LuHeading3 } from "react-icons/lu";
-import { FaBold, FaCode, FaItalic, FaParagraph, FaStrikethrough } from "react-icons/fa";
-const EditorButton = ({ action, isActive, label, disabled }) => {
-    const { editor } = useCurrentEditor();
-    if (!editor) {
-        return null;
-    }
-    if (action.includes("heading")) {
-        const level = parseInt(action[action.length - 1]);
-        return (_jsx("button", { onClick: () => editor.chain().focus().toggleHeading({ level: level }).run(), className: `pl-2 ${isActive ? "is-active" : ""}`, children: label }));
-    }
-    return (_jsx("button", { onClick: () => editor.chain().focus()[action]().run(), disabled: disabled ? !editor.can().chain().focus()[action]().run() : false, className: `pl-2 ${isActive ? "is-active" : ""}`, children: label }));
-};
-const MenuBar = () => {
-    const { editor } = useCurrentEditor();
-    if (!editor) {
-        return null;
-    }
-    return (_jsxs("div", { className: "bg-gray-400 dark:bg-gray-800 dark:text-white text-lg flex flex-row flex-wrap items-center p-1", children: [_jsx(EditorButton, { action: "toggleBold", isActive: editor.isActive("bold"), label: _jsx(FaBold, {}), disabled: true }), _jsx(EditorButton, { action: "toggleItalic", isActive: editor.isActive("italic"), label: _jsx(FaItalic, {}), disabled: true }), _jsx(EditorButton, { action: "toggleStrike", isActive: editor.isActive("strike"), label: _jsx(FaStrikethrough, {}), disabled: true }), _jsx(EditorButton, { action: "toggleCode", isActive: editor.isActive("code"), label: _jsx(FaCode, {}), disabled: true }), _jsx(EditorButton, { action: "setParagraph", isActive: editor.isActive("paragraph"), label: _jsx(FaParagraph, {}) }), _jsx(EditorButton, { action: 'setHeading1', isActive: editor.isActive("heading", { level: 1 }), label: _jsx(LuHeading1, { size: "24px" }) }), _jsx(EditorButton, { action: 'setHeading2', isActive: editor.isActive("heading", { level: 2 }), label: _jsx(LuHeading2, { size: "24px" }) }), _jsx(EditorButton, { action: 'setHeading3', isActive: editor.isActive("heading", { level: 3 }), label: _jsx(LuHeading3, { size: "24px" }) }), _jsx(EditorButton, { action: "toggleBulletList", isActive: editor.isActive("bulletList"), label: _jsx(AiOutlineUnorderedList, { size: "24px" }) }), _jsx(EditorButton, { action: "toggleOrderedList", isActive: editor.isActive("orderedList"), label: _jsx(GoListOrdered, { size: "24px" }) }), _jsx(EditorButton, { action: "toggleCodeBlock", isActive: editor.isActive("codeBlock"), label: _jsx(PiCodeBlock, { size: "24px" }) }), _jsx(EditorButton, { action: "toggleBlockquote", isActive: editor.isActive("blockquote"), label: _jsx(TbBlockquote, { size: "24px" }) })] }));
-};
-const extensions = [
-    StarterKit.configure({
-        bulletList: {
-            keepMarks: true,
-            keepAttributes: false,
-        },
-        orderedList: {
-            keepMarks: true,
-            keepAttributes: false,
-        },
-    }),
-    Markdown,
-];
-export const MarkdownEditor = (props) => {
-    return (_jsx("div", { className: "text-md border border-gray-800 overflow-hidden " + props.className, style: { borderWidth: props.editable ? 1 : 0 }, children: _jsx(EditorProvider, { slotBefore: props.editable ? _jsx(MenuBar, {}) : null, extensions: extensions, content: props.content, editable: props.editable, onUpdate: (e) => {
-                props.onUpdate && props.onUpdate(e.editor.storage.markdown.getMarkdown());
-            } }, (props.editable ? "editable" : "readonly") + props.content) }));
-};

package/dist/audio/Playbutton.d.ts

@@ -1,14 +0,0 @@
-import React from 'react';
-type AudioPlayerProps = {
-    text: string;
-    voice?: string;
-    language?: string;
-    playOnMount?: boolean;
-    initialSpeed?: number;
-    enableSpeedAdjustment?: boolean;
-    playListenerEvent?: string;
-};
-export declare const AudioPlayOptions: number[];
-export type AudioPlayOptionType = 0.8 | 0.9 | 1.0 | 1.1 | 1.2 | 1.5;
-export declare const AudioPlayer: React.FC<AudioPlayerProps>;
-export {};

package/dist/audio/Playbutton.js

@@ -1,73 +0,0 @@
-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 { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState, useEffect } from 'react';
-import { FaPlayCircle, FaStopCircle } from "react-icons/fa";
-import { usePlugin } from "../utils/plugin/providers/PluginProvider";
-import Spinner from '../components/Spinner';
-import { EmitterSingleton } from '../utils/plugin/providers/EventEmitter';
-export const AudioPlayOptions = [0.8, 0.9, 1.0, 1.1, 1.2, 1.5];
-let isFetchingAudio = false;
-export const AudioPlayer = ({ text, voice, language, playListenerEvent, initialSpeed = 1.0, playOnMount = false, enableSpeedAdjustment = false, }) => {
-    const [audioUrl, setAudioUrl] = useState(null);
-    const [speed, setSpeed] = useState(initialSpeed);
-    const [isPlaying, setIsPlaying] = useState(false);
-    const [isLoading, setIsLoading] = useState(false);
-    const { getVoiceResponse, } = usePlugin();
-    const emitter = EmitterSingleton;
-    useEffect(() => {
-        if (!playListenerEvent)
-            return;
-        emitter.on(playListenerEvent, () => togglePlayback());
-    }, [playListenerEvent]);
-    // Function to generate audio from text using API
-    const generateAudio = () => __awaiter(void 0, void 0, void 0, function* () {
-        setIsLoading(true);
-        const blob = yield getVoiceResponse(text, voice || (language ? "aws_default" : "openai_alloy"), 1, language);
-        setAudioUrl(URL.createObjectURL(blob));
-        setIsLoading(false);
-    });
-    // Effect to play audio when audioUrl changes and play state is true
-    useEffect(() => {
-        if (!audioUrl || !isPlaying)
-            return;
-        const audio = new Audio(audioUrl);
-        audio.playbackRate = speed;
-        audio.play().then(() => {
-            audio.onended = () => {
-                setIsPlaying(false);
-                isFetchingAudio = false;
-            };
-        }).catch(e => {
-            console.warn("Error playing audio:", e);
-            setIsPlaying(false);
-        });
-        return () => {
-            audio.pause();
-            URL.revokeObjectURL(audioUrl);
-        };
-    }, [audioUrl, isPlaying, speed]);
-    const togglePlayback = () => {
-        if (!isPlaying && !audioUrl) {
-            generateAudio().then(() => setIsPlaying(true));
-        }
-        else {
-            setIsPlaying((prev) => !prev);
-        }
-    };
-    useEffect(() => {
-        if (!playOnMount || isFetchingAudio)
-            return;
-        isFetchingAudio = true;
-        // console.log("playOnMount", playOnMount);
-        togglePlayback();
-    }, [playOnMount]);
-    return (_jsx("div", { className: "group relative", children: _jsxs("div", { className: 'flex flex-row items-end', children: [_jsx("button", { className: "text-gray-500", onClick: togglePlayback, disabled: isLoading, children: isLoading ? _jsx(Spinner, {}) : isPlaying ? _jsx(FaStopCircle, { size: "25px" }) : _jsx(FaPlayCircle, { size: "25px" }) }), enableSpeedAdjustment && (_jsxs("div", { className: "ml-1 opacity-0 group-hover:opacity-100 transition-opacity duration-300 flex flex-row text-sm text-gray-500", children: [_jsx("span", { className: 'pr-1', children: "Speed: " }), _jsx("select", { value: speed, className: 'appearance-none cursor-pointer pr-0 p-0 rounded shadow leading-tight focus:outline-none focus:bg-gray-800 focus:ring bg-transparent border-0', onChange: (e) => setSpeed(parseFloat(e.target.value)), disabled: isLoading, children: AudioPlayOptions.map((s) => (_jsx("option", { value: s, children: s }, s))) })] }))] }) }));
-};

package/dist/components/hooks/UseChatHook.d.ts

@@ -1,15 +0,0 @@
-import React from "react";
-import { ToolInvocation, Tool } from "../../utils/plugin/PluginController";
-export interface Message {
-    role: string;
-    content: string;
-    id: string | number;
-    toolInvocations?: ToolInvocation[];
-}
-export declare function useChat(tools?: Tool[]): {
-    messages: Message[];
-    append: (appendMessages: Message[]) => void;
-    isLoading: boolean;
-    setMessages: React.Dispatch<React.SetStateAction<Message[]>>;
-    lastMessage: Message | undefined;
-};