@promptbook/components 0.113.0-6 → 0.113.0-8

package/esm/index.es.js

@@ -41,7 +41,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.113.0-6';
+const PROMPTBOOK_ENGINE_VERSION = '0.113.0-8';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -31165,9 +31165,9 @@ function useChatInputAreaComposer(props) {
  * @private function of `useChatInputAreaDictation`
  */
 function insertDictationChunk(params) {
-    const { currentValue, dictatedText, selectionStart, selectionEnd, shouldReplaceSelection } = params;
+    const { currentValue, dictatedText, selectionStart, selectionEnd, isReplacingSelection } = params;
     const replaceStart = selectionStart;
-    const replaceEnd = shouldReplaceSelection ? selectionEnd : selectionStart;
+    const replaceEnd = isReplacingSelection ? selectionEnd : selectionStart;
     const prefix = currentValue.slice(0, replaceStart);
     const suffix = currentValue.slice(replaceEnd);
     const previousCharacter = prefix.slice(-1);
@@ -31209,7 +31209,7 @@ function learnDictationDictionary(previousChunk, correctedChunk, previousDiction
             if (!previousWord || !correctedWord) {
                 continue;
             }
-            if (previousWord.toLowerCase() !== correctedWord.toLowerCase()) {
+            if (previousWord !== correctedWord) {
                 nextDictionary[previousWord.toLowerCase()] = correctedWord;
             }
         }
@@ -31703,17 +31703,73 @@ function clearPendingStopFallbackTimeout(pendingStopFallbackRef) {
     pendingStopFallbackRef.current = null;
 }
 /**
- * Captures whether the next finalized chunk should replace the current selection.
+ * Captures where the next finalized chunk should be inserted.
  *
  * @private function of `useChatInputAreaDictation`
  */
-function captureSelectionReplacementIntent(textareaRef, replaceSelectionOnNextFinalRef) {
+function captureDictationInsertionSelection(textareaRef, dictationInsertionSelectionRef) {
     const textarea = textareaRef.current;
     if (!textarea) {
         return;
     }
-    const { selectionStart, selectionEnd } = resolveTextareaSelection(textarea, 0);
-    replaceSelectionOnNextFinalRef.current = selectionStart !== selectionEnd;
+    const { selectionStart, selectionEnd } = resolveTextareaSelection(textarea, textarea.value.length);
+    dictationInsertionSelectionRef.current = {
+        selectionStart,
+        selectionEnd,
+        isReplacingSelection: selectionStart !== selectionEnd,
+    };
+}
+/**
+ * Resolves the insertion range for one finalized dictation chunk.
+ *
+ * @private function of `useChatInputAreaDictation`
+ */
+function resolveDictationInsertionSelection(textareaElement, messageContentLength, dictationInsertionSelection) {
+    if (dictationInsertionSelection) {
+        return dictationInsertionSelection;
+    }
+    const { selectionStart, selectionEnd } = resolveTextareaSelection(textareaElement, messageContentLength);
+    return {
+        selectionStart,
+        selectionEnd,
+        isReplacingSelection: selectionStart !== selectionEnd,
+    };
+}
+/**
+ * Removes one tracked dictated chunk from the current composer value.
+ *
+ * @private function of `useChatInputAreaDictation`
+ */
+function removeTrackedDictationChunk(currentValue, chunk) {
+    const trackedText = currentValue.slice(chunk.start, chunk.start + chunk.finalText.length);
+    if (trackedText === chunk.finalText) {
+        return `${currentValue.slice(0, chunk.start)}${currentValue.slice(chunk.start + chunk.finalText.length)}`;
+    }
+    return replaceLastOccurrence(currentValue, chunk.finalText, '');
+}
+/**
+ * Replaces one tracked dictated chunk inside the current composer value.
+ *
+ * @private function of `useChatInputAreaDictation`
+ */
+function replaceTrackedDictationChunk(currentValue, chunk, correctedChunk) {
+    const trackedText = currentValue.slice(chunk.start, chunk.start + chunk.finalText.length);
+    if (trackedText === chunk.finalText) {
+        return `${currentValue.slice(0, chunk.start)}${correctedChunk}${currentValue.slice(chunk.start + chunk.finalText.length)}`;
+    }
+    return replaceLastOccurrence(currentValue, chunk.finalText, correctedChunk);
+}
+/**
+ * Stores the next append position after a programmatic dictation edit.
+ *
+ * @private function of `useChatInputAreaDictation`
+ */
+function updateDictationInsertionCaret(dictationInsertionSelectionRef, caret) {
+    dictationInsertionSelectionRef.current = {
+        selectionStart: caret,
+        selectionEnd: caret,
+        isReplacingSelection: false,
+    };
 }
 /**
  * Produces the corrected chunk value only when a real correction should be applied.
@@ -31794,7 +31850,7 @@ function useTextareaSelectionFocus(textareaRef) {
  *
  * @private function of `useChatInputAreaDictation`
  */
-function useChatInputAreaDictationFinalResultHandler({ textareaRef, messageContentRef, applyMessageContent, dictationSettings, dictationDictionary, replaceSelectionOnNextFinalRef, focusTextareaSelection, state, }) {
+function useChatInputAreaDictationFinalResultHandler({ textareaRef, messageContentRef, applyMessageContent, dictationSettings, dictationDictionary, dictationInsertionSelectionRef, focusTextareaSelection, state, }) {
     const { setDictationUiState, setDictationInterimText, setDictationError, setDictationLastFinalChunk, setDictationEditableChunk, setDictationChunks, setIsDictationPanelExpanded, } = state;
     return useCallback((rawText) => {
         const textarea = textareaRef.current;
@@ -31806,15 +31862,15 @@ function useChatInputAreaDictationFinalResultHandler({ textareaRef, messageConte
         if (!refinedText) {
             return;
         }
-        const { selectionStart, selectionEnd } = resolveTextareaSelection(textarea, previousMessageContent.length);
+        const { selectionStart, selectionEnd, isReplacingSelection } = resolveDictationInsertionSelection(textarea, previousMessageContent.length, dictationInsertionSelectionRef.current);
         const insertion = insertDictationChunk({
             currentValue: previousMessageContent,
             dictatedText: refinedText,
             selectionStart,
             selectionEnd,
-            shouldReplaceSelection: replaceSelectionOnNextFinalRef.current,
+            isReplacingSelection,
         });
-        replaceSelectionOnNextFinalRef.current = false;
+        updateDictationInsertionCaret(dictationInsertionSelectionRef, insertion.caret);
         setDictationInterimText('');
         setDictationError(null);
         setDictationUiState('listening');
@@ -31834,10 +31890,10 @@ function useChatInputAreaDictationFinalResultHandler({ textareaRef, messageConte
     }, [
         applyMessageContent,
         dictationDictionary,
+        dictationInsertionSelectionRef,
         dictationSettings,
         focusTextareaSelection,
         messageContentRef,
-        replaceSelectionOnNextFinalRef,
         setDictationChunks,
         setDictationEditableChunk,
         setDictationError,
@@ -31885,7 +31941,7 @@ function useChatInputAreaDictationSpeechRecognitionEventHandler({ clearPendingSt
                 return;
             case 'STOP':
                 clearPendingStopFallback();
-                setDictationUiState((currentState) => (currentState === 'disabled' ? currentState : 'idle'));
+                setDictationUiState((currentState) => currentState === 'disabled' || currentState === 'error' ? currentState : 'idle');
                 setDictationInterimText('');
                 return;
         }
@@ -31926,13 +31982,13 @@ function useChatInputAreaDictationSpeechRecognitionLifecycle({ speechRecognition
  *
  * @private function of `useChatInputAreaDictation`
  */
-function useChatInputAreaDictationVoiceInputControls({ speechRecognition, textareaRef, resolvedSpeechRecognitionLanguage, whisperMode, pendingStopFallbackRef, replaceSelectionOnNextFinalRef, clearPendingStopFallback, state, }) {
+function useChatInputAreaDictationVoiceInputControls({ speechRecognition, textareaRef, resolvedSpeechRecognitionLanguage, whisperMode, pendingStopFallbackRef, dictationInsertionSelectionRef, clearPendingStopFallback, state, }) {
     const { dictationUiState, setDictationUiState, setDictationInterimText, setDictationError } = state;
     const startVoiceInput = useCallback(() => {
         if (!speechRecognition) {
             return;
         }
-        captureSelectionReplacementIntent(textareaRef, replaceSelectionOnNextFinalRef);
+        captureDictationInsertionSelection(textareaRef, dictationInsertionSelectionRef);
         setDictationError(null);
         setDictationInterimText('');
         setDictationUiState('listening');
@@ -31942,7 +31998,7 @@ function useChatInputAreaDictationVoiceInputControls({ speechRecognition, textar
             whisperMode,
         });
     }, [
-        replaceSelectionOnNextFinalRef,
+        dictationInsertionSelectionRef,
         resolvedSpeechRecognitionLanguage,
         setDictationError,
         setDictationInterimText,
@@ -31994,7 +32050,7 @@ function useChatInputAreaDictationVoiceInputControls({ speechRecognition, textar
  *
  * @private function of `useChatInputAreaDictation`
  */
-function useChatInputAreaDictationCorrectionHandlers({ dictationChunks, dictationLastFinalChunk, dictationEditableChunk, dictationDictionary, messageContentRef, applyMessageContent, focusTextareaSelection, setDictationChunks, setDictationLastFinalChunk, setDictationEditableChunk, setDictationDictionary, }) {
+function useChatInputAreaDictationCorrectionHandlers({ dictationChunks, dictationLastFinalChunk, dictationEditableChunk, dictationDictionary, dictationInsertionSelectionRef, messageContentRef, applyMessageContent, focusTextareaSelection, setDictationChunks, setDictationLastFinalChunk, setDictationEditableChunk, setDictationDictionary, }) {
     const handleBacktrackLastChunk = useCallback(() => {
         var _a;
         const previousChunks = [...dictationChunks];
@@ -32002,35 +32058,51 @@ function useChatInputAreaDictationCorrectionHandlers({ dictationChunks, dictatio
         if (!lastChunk) {
             return;
         }
+        const nextMessageContent = removeTrackedDictationChunk(messageContentRef.current, lastChunk);
+        const nextCaret = Math.min(lastChunk.start, nextMessageContent.length);
         setDictationChunks(previousChunks);
-        applyMessageContent(lastChunk.beforeValue);
+        applyMessageContent(nextMessageContent);
         const previousFinalChunk = ((_a = previousChunks[previousChunks.length - 1]) === null || _a === void 0 ? void 0 : _a.finalText) || '';
         setDictationLastFinalChunk(previousFinalChunk);
         setDictationEditableChunk(previousFinalChunk);
-        focusTextareaSelection(lastChunk.start, lastChunk.start);
+        updateDictationInsertionCaret(dictationInsertionSelectionRef, nextCaret);
+        focusTextareaSelection(nextCaret, nextCaret);
     }, [
         applyMessageContent,
+        dictationInsertionSelectionRef,
         dictationChunks,
         focusTextareaSelection,
+        messageContentRef,
         setDictationChunks,
         setDictationEditableChunk,
         setDictationLastFinalChunk,
     ]);
     const handleApplyCorrection = useCallback(() => {
+        var _a;
         const correctedChunk = resolveCorrectedDictationChunk(dictationEditableChunk, dictationLastFinalChunk);
         if (!correctedChunk) {
             return;
         }
-        const nextMessageContent = replaceLastOccurrence(messageContentRef.current, dictationLastFinalChunk, correctedChunk);
+        const lastChunk = dictationChunks[dictationChunks.length - 1];
+        const nextMessageContent = lastChunk
+            ? replaceTrackedDictationChunk(messageContentRef.current, lastChunk, correctedChunk)
+            : replaceLastOccurrence(messageContentRef.current, dictationLastFinalChunk, correctedChunk);
+        const correctionStart = (_a = lastChunk === null || lastChunk === void 0 ? void 0 : lastChunk.start) !== null && _a !== void 0 ? _a : nextMessageContent.length;
+        const correctionCaret = Math.min(correctionStart + correctedChunk.length, nextMessageContent.length);
         applyMessageContent(nextMessageContent);
         setDictationLastFinalChunk(correctedChunk);
         setDictationChunks((previousChunks) => replaceLastDictationChunk(previousChunks, correctedChunk));
         setDictationDictionary(learnDictationDictionary(dictationLastFinalChunk, correctedChunk, dictationDictionary));
+        updateDictationInsertionCaret(dictationInsertionSelectionRef, correctionCaret);
+        focusTextareaSelection(correctionCaret, correctionCaret);
     }, [
         applyMessageContent,
         dictationDictionary,
         dictationEditableChunk,
+        dictationChunks,
+        dictationInsertionSelectionRef,
         dictationLastFinalChunk,
+        focusTextareaSelection,
         messageContentRef,
         setDictationChunks,
         setDictationDictionary,
@@ -32048,7 +32120,7 @@ function useChatInputAreaDictationCorrectionHandlers({ dictationChunks, dictatio
  */
 function useChatInputAreaDictation({ speechRecognition, speechRecognitionLanguage, textareaRef, messageContentRef, applyMessageContent, }) {
     const pendingStopFallbackRef = useRef(null);
-    const replaceSelectionOnNextFinalRef = useRef(false);
+    const dictationInsertionSelectionRef = useRef(null);
     const [dictationUiState, setDictationUiState] = useState('idle');
     const [dictationInterimText, setDictationInterimText] = useState('');
     const [dictationError, setDictationError] = useState(null);
@@ -32081,7 +32153,7 @@ function useChatInputAreaDictation({ speechRecognition, speechRecognitionLanguag
         applyMessageContent,
         dictationSettings,
         dictationDictionary,
-        replaceSelectionOnNextFinalRef,
+        dictationInsertionSelectionRef,
         focusTextareaSelection,
         state: dictationState,
     });
@@ -32101,7 +32173,7 @@ function useChatInputAreaDictation({ speechRecognition, speechRecognitionLanguag
         resolvedSpeechRecognitionLanguage,
         whisperMode: dictationSettings.whisperMode,
         pendingStopFallbackRef,
-        replaceSelectionOnNextFinalRef,
+        dictationInsertionSelectionRef,
         clearPendingStopFallback,
         state: {
             dictationUiState,
@@ -32115,6 +32187,7 @@ function useChatInputAreaDictation({ speechRecognition, speechRecognitionLanguag
         dictationLastFinalChunk,
         dictationEditableChunk,
         dictationDictionary,
+        dictationInsertionSelectionRef,
         messageContentRef,
         applyMessageContent,
         focusTextareaSelection,