@rimori/react-client 0.1.0

package/dist/components/ai/EmbeddedAssistent/TTS/Player.js

@@ -0,0 +1,185 @@
+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 ChunkedAudioPlayer {
+    constructor() {
+        this.chunkQueue = [];
+        this.isPlaying = false;
+        this.shouldMonitorLoudness = true;
+        this.isMonitoring = false;
+        this.handle = 0;
+        this.volume = 1.0;
+        this.loudnessCallback = () => { };
+        this.currentIndex = 0;
+        this.startedPlaying = false;
+        this.onEndOfSpeech = () => { };
+        this.init();
+    }
+    init() {
+        this.audioContext = new AudioContext();
+        this.analyser = this.audioContext.createAnalyser();
+        this.analyser.fftSize = 256; // Set the FFT size (smaller values provide faster updates, larger ones give better resolution)
+        const bufferLength = this.analyser.frequencyBinCount;
+        this.dataArray = new Uint8Array(bufferLength); // Array to hold frequency data
+    }
+    setOnLoudnessChange(callback) {
+        this.loudnessCallback = callback;
+    }
+    setVolume(volume) {
+        this.volume = volume;
+    }
+    addChunk(chunk, position) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('Adding chunk', position, chunk);
+            this.chunkQueue[position] = chunk;
+            // console.log("received chunk", {
+            //     chunkQueue: this.chunkQueue.length,
+            //     isPlaying: this.isPlaying,
+            // })
+            if (position === 0 && !this.startedPlaying) {
+                this.startedPlaying = true;
+                this.playChunks();
+            }
+        });
+    }
+    playChunks() {
+        // console.log({ isPlaying: this.isPlaying });
+        if (this.isPlaying)
+            return;
+        if (!this.chunkQueue[this.currentIndex]) {
+            // wait until the correct chunk arrives
+            setTimeout(() => this.playChunks(), 10);
+        }
+        this.isPlaying = true;
+        this.playChunk(this.chunkQueue[this.currentIndex]).then(() => {
+            this.isPlaying = false;
+            this.currentIndex++;
+            if (this.chunkQueue[this.currentIndex]) {
+                this.shouldMonitorLoudness = true;
+                this.playChunks();
+            }
+            else {
+                // console.log('Playback finished', { currentIndex: this.currentIndex, chunkQueue: this.chunkQueue });
+                setTimeout(() => {
+                    // console.log('Check again if really playback finished', { currentIndex: this.currentIndex, chunkQueue: this.chunkQueue });
+                    if (this.chunkQueue.length > this.currentIndex) {
+                        this.playChunks();
+                    }
+                    else {
+                        this.startedPlaying = false;
+                        this.shouldMonitorLoudness = false;
+                    }
+                }, 1000);
+            }
+        });
+    }
+    stopPlayback() {
+        // console.log('Stopping playback');
+        // Implement logic to stop the current playback
+        this.isPlaying = false;
+        this.chunkQueue = [];
+        this.startedPlaying = false;
+        this.shouldMonitorLoudness = false;
+        cancelAnimationFrame(this.handle);
+    }
+    playChunk(chunk) {
+        // console.log({queue: this.chunkQueue})
+        if (!chunk) {
+            return Promise.resolve();
+        }
+        // console.log('Playing chunk', chunk);
+        return new Promise((resolve) => {
+            const source = this.audioContext.createBufferSource();
+            this.audioContext.decodeAudioData(chunk.slice(0)).then((audioBuffer) => {
+                source.buffer = audioBuffer;
+                // Create a GainNode for volume control
+                const gainNode = this.audioContext.createGain();
+                gainNode.gain.value = this.volume;
+                // Connect the source to the GainNode, then to the analyser node, then to the destination (speakers)
+                source.connect(gainNode);
+                gainNode.connect(this.analyser);
+                this.analyser.connect(this.audioContext.destination);
+                source.start(0);
+                // console.log('Playing chunk', this.currentIndex);
+                gainNode.gain.value = this.volume;
+                source.onended = () => {
+                    // console.log('Chunk ended');
+                    resolve();
+                };
+                // Start monitoring loudness only once
+                if (!this.isMonitoring) {
+                    this.isMonitoring = true;
+                    this.shouldMonitorLoudness = true;
+                    this.monitorLoudness();
+                }
+            });
+        });
+    }
+    playAgain() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('Playing again');
+            if (this.chunkQueue.length > 0 && !this.isPlaying) {
+                this.playChunks();
+            }
+        });
+    }
+    monitorLoudness() {
+        // Stop monitoring when the flag is false
+        if (!this.shouldMonitorLoudness) {
+            // console.log('Loudness monitoring stopped.');
+            cancelAnimationFrame(this.handle);
+            this.loudnessCallback(0);
+            this.onEndOfSpeech();
+            return;
+        }
+        // Get the time domain data from the analyser (this is a snapshot of the waveform)
+        this.analyser.getByteTimeDomainData(this.dataArray);
+        // Calculate the RMS (root mean square) of the waveform values to get the perceived loudness
+        let sum = 0;
+        for (let i = 0; i < this.dataArray.length; i++) {
+            const value = this.dataArray[i] / 128.0 - 1.0; // Normalize between -1 and 1
+            sum += value * value;
+        }
+        const rms = Math.sqrt(sum / this.dataArray.length);
+        // Handle the case where RMS is 0 to avoid log10(0)
+        if (rms === 0) {
+            // console.log('Current loudness: Silent');
+        }
+        else {
+            let loudnessInDb = 20 * Math.log10(rms); // Convert to dB
+            // console.log('Current loudness:' + loudnessInDb);
+            const minDb = -57;
+            const maxDb = -15;
+            if (loudnessInDb < minDb) {
+                loudnessInDb = minDb;
+            }
+            if (loudnessInDb > maxDb) {
+                loudnessInDb = maxDb;
+            }
+            const loudnessScale = ((loudnessInDb - minDb) / (maxDb - minDb)) * 100;
+            // console.log("root:corrent loudness", loudnessScale);
+            this.loudnessCallback(loudnessScale);
+        }
+        // Call this method again at regular intervals if you want continuous loudness monitoring
+        this.handle = requestAnimationFrame(() => this.monitorLoudness());
+    }
+    reset() {
+        // console.log('Resetting player');
+        this.stopPlayback();
+        this.currentIndex = 0;
+        this.shouldMonitorLoudness = true;
+        //reset to the beginning when the class gets initialized
+        this.isMonitoring = false;
+        this.isPlaying = false;
+        this.init();
+    }
+    setOnEndOfSpeech(callback) {
+        this.onEndOfSpeech = callback;
+    }
+}

package/dist/components/ai/EmbeddedAssistent/VoiceRecoder.d.ts

@@ -0,0 +1,11 @@
+interface Props {
+    iconSize?: string;
+    className?: string;
+    disabled?: boolean;
+    loading?: boolean;
+    enablePushToTalk?: boolean;
+    onRecordingStatusChange: (running: boolean) => void;
+    onVoiceRecorded: (message: string) => void;
+}
+export declare const VoiceRecorder: import("react").ForwardRefExoticComponent<Props & import("react").RefAttributes<unknown>>;
+export {};

package/dist/components/ai/EmbeddedAssistent/VoiceRecoder.js

@@ -0,0 +1,95 @@
+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 } from "react/jsx-runtime";
+import { useRimori } from '../../../components';
+import { FaMicrophone, FaSpinner } from 'react-icons/fa6';
+import { AudioController } from '../../../plugin/AudioController';
+import { useState, useRef, forwardRef, useImperativeHandle, useEffect } from 'react';
+export const VoiceRecorder = forwardRef(({ onVoiceRecorded, iconSize, className, disabled, loading, onRecordingStatusChange, enablePushToTalk = false, }, ref) => {
+    const [isRecording, setIsRecording] = useState(false);
+    const [internalIsProcessing, setInternalIsProcessing] = useState(false);
+    const audioControllerRef = useRef(null);
+    const { ai, plugin } = useRimori();
+    // Ref for latest onVoiceRecorded callback
+    const onVoiceRecordedRef = useRef(onVoiceRecorded);
+    useEffect(() => {
+        onVoiceRecordedRef.current = onVoiceRecorded;
+    }, [onVoiceRecorded]);
+    const startRecording = () => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            if (!audioControllerRef.current) {
+                audioControllerRef.current = new AudioController(plugin.pluginId);
+            }
+            yield audioControllerRef.current.startRecording();
+            setIsRecording(true);
+            onRecordingStatusChange(true);
+        }
+        catch (error) {
+            console.error('Failed to start recording:', error);
+            // Handle permission denied or other errors
+        }
+    });
+    const stopRecording = () => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            if (audioControllerRef.current && isRecording) {
+                const audioResult = yield audioControllerRef.current.stopRecording();
+                // console.log("audioResult: ", audioResult);
+                setInternalIsProcessing(true);
+                // Play the recorded audio from the Blob
+                // const blobUrl = URL.createObjectURL(audioResult.recording);
+                // const audioRef = new Audio(blobUrl);
+                // audioRef.onended = () => URL.revokeObjectURL(blobUrl);
+                // audioRef.play().catch((e) => console.error('Playback error:', e));
+                // console.log("audioBlob: ", audioResult.recording);
+                const text = yield ai.getTextFromVoice(audioResult.recording);
+                // console.log("stt result", text);
+                // throw new Error("test");
+                setInternalIsProcessing(false);
+                onVoiceRecordedRef.current(text);
+            }
+        }
+        catch (error) {
+            console.error('Failed to stop recording:', error);
+        }
+        finally {
+            setIsRecording(false);
+            onRecordingStatusChange(false);
+        }
+    });
+    useImperativeHandle(ref, () => ({
+        startRecording,
+        stopRecording,
+    }));
+    // push to talk feature
+    const spacePressedRef = useRef(false);
+    useEffect(() => {
+        if (!enablePushToTalk)
+            return;
+        const handleKeyDown = (event) => __awaiter(void 0, void 0, void 0, function* () {
+            if (event.code === 'Space' && !spacePressedRef.current) {
+                spacePressedRef.current = true;
+                yield startRecording();
+            }
+        });
+        const handleKeyUp = (event) => {
+            if (event.code === 'Space' && spacePressedRef.current) {
+                spacePressedRef.current = false;
+                stopRecording();
+            }
+        };
+        window.addEventListener('keydown', handleKeyDown);
+        window.addEventListener('keyup', handleKeyUp);
+        return () => {
+            window.removeEventListener('keydown', handleKeyDown);
+            window.removeEventListener('keyup', handleKeyUp);
+        };
+    }, [enablePushToTalk]);
+    return (_jsx("button", { className: 'flex flex-row justify-center items-center rounded-full mx-auto disabled:opacity-50 ' + className, onClick: isRecording ? stopRecording : startRecording, disabled: disabled || loading || internalIsProcessing, children: loading || internalIsProcessing ? (_jsx(FaSpinner, { className: "animate-spin" })) : (_jsx(FaMicrophone, { size: iconSize, className: isRecording ? 'text-red-600' : '' })) }));
+});

package/dist/components/ai/utils.d.ts

@@ -0,0 +1,6 @@
+export interface FirstMessages {
+    instructions?: string;
+    userMessage?: string;
+    assistantMessage?: string;
+}
+export declare function getFirstMessages(instructions: FirstMessages): any[];

package/dist/components/ai/utils.js

@@ -0,0 +1,13 @@
+export function getFirstMessages(instructions) {
+    const messages = [];
+    if (instructions.instructions) {
+        messages.push({ id: '1', role: 'system', content: instructions.instructions });
+    }
+    if (instructions.userMessage) {
+        messages.push({ id: '2', role: 'user', content: instructions.userMessage });
+    }
+    if (instructions.assistantMessage) {
+        messages.push({ id: '3', role: 'assistant', content: instructions.assistantMessage });
+    }
+    return messages;
+}

package/dist/components/audio/Playbutton.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+type AudioPlayerProps = {
+    text: string;
+    voice?: string;
+    language?: string;
+    hide?: boolean;
+    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/components/audio/Playbutton.js

@@ -0,0 +1,80 @@
+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 { useRimori } from '../../providers/PluginProvider';
+import { Spinner } from '../Spinner';
+import { EventBus } from '../../fromRimori/EventBus';
+export const AudioPlayOptions = [0.8, 0.9, 1.0, 1.1, 1.2, 1.5];
+let isFetchingAudio = false;
+export const AudioPlayer = ({ text, voice, language, hide, 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 { ai } = useRimori();
+    useEffect(() => {
+        if (!playListenerEvent)
+            return;
+        EventBus.on(playListenerEvent, () => togglePlayback());
+    }, [playListenerEvent]);
+    useEffect(() => {
+        audioUrl && setAudioUrl(null);
+        return () => {
+            audioUrl && URL.revokeObjectURL(audioUrl);
+        };
+    }, [text]);
+    // Function to generate audio from text using API
+    const generateAudio = () => __awaiter(void 0, void 0, void 0, function* () {
+        setIsLoading(true);
+        const blob = yield ai.getVoice(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();
+        };
+    }, [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: [!hide && (_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/components/ContextMenu.d.ts

@@ -0,0 +1,10 @@
+import { RimoriClient } from '../../plugin/RimoriClient';
+export interface Position {
+    x: number;
+    y: number;
+    text?: string;
+}
+declare const ContextMenu: ({ client }: {
+    client: RimoriClient;
+}) => import("react/jsx-runtime").JSX.Element | null;
+export default ContextMenu;

package/dist/components/components/ContextMenu.js

@@ -0,0 +1,135 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect, useRef } from 'react';
+import { EventBus } from '../../fromRimori/EventBus';
+const ContextMenu = ({ client }) => {
+    const [isOpen, setIsOpen] = useState(false);
+    const [actions, setActions] = useState([]);
+    const [position, setPosition] = useState({ x: 0, y: 0 });
+    const [openOnTextSelect, setOpenOnTextSelect] = useState(false);
+    const [menuWidth, setMenuWidth] = useState(0);
+    const menuRef = useRef(null);
+    const isMobile = window.innerWidth < 768;
+    /**
+     * Calculates position for mobile context menu based on selected text bounds.
+     * Centers the menu horizontally over the selected text and positions it 30px below the text's end.
+     * @param selectedText - The currently selected text
+     * @param menuWidth - The width of the menu to center properly
+     * @returns Position object with x and y coordinates
+     */
+    const calculateMobilePosition = (selectedText, menuWidth = 0) => {
+        const selection = window.getSelection();
+        if (!selection || !selectedText) {
+            return { x: 0, y: 0, text: selectedText };
+        }
+        const range = selection.getRangeAt(0);
+        const rect = range.getBoundingClientRect();
+        // Center horizontally over the selected text, accounting for menu width
+        const centerX = rect.left + rect.width / 2 - menuWidth / 2;
+        // Position 12px below where the text ends vertically
+        const textEndY = rect.bottom + 12;
+        return { x: centerX, y: textEndY, text: selectedText };
+    };
+    useEffect(() => {
+        const actions = client.plugin
+            .getPluginInfo()
+            .installedPlugins.flatMap((p) => p.context_menu_actions)
+            .filter(Boolean);
+        setActions(actions);
+        setOpenOnTextSelect(client.plugin.getUserInfo().context_menu_on_select);
+        EventBus.on('global.contextMenu.createActions', ({ data }) => {
+            setActions([...data.actions, ...actions]);
+        });
+    }, []);
+    // Update menu width when menu is rendered
+    useEffect(() => {
+        if (isOpen && menuRef.current) {
+            setMenuWidth(menuRef.current.offsetWidth);
+        }
+    }, [isOpen, actions]);
+    useEffect(() => {
+        // Track mouse position globally
+        const handleMouseMove = (e) => {
+            var _a;
+            const selectedText = (_a = window.getSelection()) === null || _a === void 0 ? void 0 : _a.toString().trim();
+            if (isOpen && selectedText === position.text)
+                return;
+            if (isMobile && selectedText) {
+                setPosition(calculateMobilePosition(selectedText, menuWidth));
+            }
+            else {
+                setPosition({ x: e.clientX, y: e.clientY, text: selectedText });
+            }
+        };
+        const handleMouseUp = (e) => {
+            var _a, _b;
+            const selectedText = (_a = window.getSelection()) === null || _a === void 0 ? void 0 : _a.toString().trim();
+            // Check if click is inside the context menu
+            if (menuRef.current && menuRef.current.contains(e.target)) {
+                // Don't close the menu if clicking inside
+                return;
+            }
+            // Prevent context menu on textarea or text input selection
+            const target = e.target;
+            const isTextInput = target &&
+                (target.tagName === 'TEXTAREA' || (target.tagName === 'INPUT' && target.type === 'text'));
+            if (isTextInput) {
+                setIsOpen(false);
+                return;
+            }
+            if (e.button === 0 && isOpen) {
+                setIsOpen(false);
+                (_b = window.getSelection()) === null || _b === void 0 ? void 0 : _b.removeAllRanges();
+            }
+            else if (selectedText && (openOnTextSelect || e.button === 2)) {
+                if (e.button === 2) {
+                    e.preventDefault();
+                }
+                if (isMobile) {
+                    setPosition(calculateMobilePosition(selectedText, menuWidth));
+                }
+                else {
+                    setPosition({ x: e.clientX, y: e.clientY, text: selectedText });
+                }
+                setIsOpen(true);
+            }
+            else {
+                setIsOpen(false);
+            }
+        };
+        // Add selectionchange listener to close menu if selection is cleared and update position for mobile
+        const handleSelectionChange = () => {
+            var _a;
+            const selectedText = (_a = window.getSelection()) === null || _a === void 0 ? void 0 : _a.toString().trim();
+            if (!selectedText && isOpen) {
+                setIsOpen(false);
+            }
+            else if (selectedText && isOpen && isMobile) {
+                // Update position in real-time as text selection changes on mobile
+                setPosition(calculateMobilePosition(selectedText, menuWidth));
+            }
+        };
+        document.addEventListener('mouseup', handleMouseUp);
+        window.addEventListener('mousemove', handleMouseMove);
+        document.addEventListener('contextmenu', handleMouseUp);
+        document.addEventListener('selectionchange', handleSelectionChange);
+        return () => {
+            document.removeEventListener('mouseup', handleMouseUp);
+            window.removeEventListener('mousemove', handleMouseMove);
+            document.removeEventListener('contextmenu', handleMouseUp);
+            document.removeEventListener('selectionchange', handleSelectionChange);
+        };
+    }, [openOnTextSelect, isOpen, position.text]);
+    if (!isOpen) {
+        return null;
+    }
+    return (_jsx("div", { ref: menuRef, className: "fixed bg-gray-400 dark:bg-gray-700 shadow-lg border border-gray-400 rounded-md overflow-hidden dark:text-white z-50", style: { top: position.y, left: position.x }, children: actions.map((action, index) => (_jsx(MenuEntryItem, { icon: action.icon, text: action.text, onClick: () => {
+                var _a;
+                setIsOpen(false);
+                (_a = window.getSelection()) === null || _a === void 0 ? void 0 : _a.removeAllRanges();
+                client.event.emitSidebarAction(action.plugin_id, action.action_key, position.text);
+            } }, index))) }));
+};
+function MenuEntryItem(props) {
+    return (_jsxs("button", { onClick: props.onClick, className: "px-4 py-2 text-left hover:bg-gray-500 dark:hover:bg-gray-600 w-full flex flex-row", children: [_jsx("span", { className: "flex-grow", children: props.icon }), _jsx("span", { className: "flex-grow", children: props.text })] }));
+}
+export default ContextMenu;

package/dist/hooks/I18nHooks.d.ts

@@ -0,0 +1,11 @@
+import { TOptions } from 'i18next';
+type TranslatorFn = (key: string, options?: TOptions) => string;
+/**
+ * Custom useTranslation hook that provides a translation function and indicates readiness
+ * @returns An object containing the translation function (`t`) and a boolean (`ready`) indicating if the translator is initialized.
+ */
+export declare function useTranslation(): {
+    t: TranslatorFn;
+    ready: boolean;
+};
+export {};

package/dist/hooks/I18nHooks.js

@@ -0,0 +1,25 @@
+import { useEffect, useState } from 'react';
+import { useRimori } from '../providers/PluginProvider';
+/**
+ * Custom useTranslation hook that provides a translation function and indicates readiness
+ * @returns An object containing the translation function (`t`) and a boolean (`ready`) indicating if the translator is initialized.
+ */
+export function useTranslation() {
+    const { plugin } = useRimori();
+    const [translatorInstance, setTranslatorInstance] = useState(null);
+    useEffect(() => {
+        void plugin.getTranslator().then(setTranslatorInstance);
+    }, [plugin]);
+    const safeT = (key, options) => {
+        // return zero-width space if translator is not initialized to keep text space occupied
+        if (!translatorInstance)
+            return '\u200B'; // zero-width space
+        const result = translatorInstance.t(key, options);
+        if (!result) {
+            console.error(`Translation key not found: ${key}`);
+            return '\u200B'; // zero-width space
+        }
+        return result;
+    };
+    return { t: safeT, ready: translatorInstance !== null };
+}

package/dist/hooks/UseChatHook.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { Tool } from '../fromRimori/PluginTypes';
+import { Message } from '../core/controller/AIController';
+export declare function useChat(tools?: Tool[]): {
+    messages: Message[];
+    append: (appendMessages: Message[]) => void;
+    isLoading: boolean;
+    setMessages: React.Dispatch<React.SetStateAction<Message[]>>;
+    lastMessage: Message | undefined;
+};

package/dist/hooks/UseChatHook.js

@@ -0,0 +1,29 @@
+import React from 'react';
+import { useRimori } from '../providers/PluginProvider';
+export function useChat(tools) {
+    const [messages, setMessages] = React.useState([]);
+    const [isLoading, setIsLoading] = React.useState(false);
+    const { ai } = useRimori();
+    const append = (appendMessages) => {
+        const allMessages = [...messages, ...appendMessages];
+        setMessages(allMessages);
+        ai.getSteamedText(allMessages, (id, message, finished, toolInvocations) => {
+            const lastMessage = messages[messages.length - 1];
+            setIsLoading(!finished);
+            if ((lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.id) === id) {
+                lastMessage.content = message;
+                setMessages([...messages, lastMessage]);
+            }
+            else {
+                setMessages([...allMessages, { id, role: 'assistant', content: message, toolCalls: toolInvocations }]);
+            }
+        }, tools);
+    };
+    return {
+        messages,
+        append,
+        isLoading,
+        setMessages,
+        lastMessage: messages[messages.length - 1],
+    };
+}

package/dist/providers/PluginProvider.d.ts

@@ -0,0 +1,11 @@
+import React, { ReactNode } from 'react';
+interface PluginProviderProps {
+    children: ReactNode;
+    pluginId: string;
+    settings?: {
+        disableContextMenu?: boolean;
+    };
+}
+export declare const PluginProvider: React.FC<PluginProviderProps>;
+export declare const useRimori: () => any;
+export {};