@parhelia/core 0.1.10745

package/dist/editor/page-editor-chrome/useInlineAICompletion.js

@@ -0,0 +1,699 @@
+import { useEffect, useCallback, useState, useMemo, useRef, } from "react";
+import { useDebouncedCallback } from "use-debounce";
+import { useEditContext, useFieldsEditContext } from "../client/editContext";
+import { executePrompt } from "../services/aiService";
+import { generatePageContext, getCachedContext, } from "../services/contextService";
+export function useInlineAiCompletion({ pageViewContext, cursorSpanId, isUpdatingRef, }) {
+    const editContext = useEditContext();
+    const fieldsContext = useFieldsEditContext();
+    const [currentCompletion, setCurrentCompletion] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const abortControllerRef = useRef(null);
+    const loadingAnimationRef = useRef(null);
+    // Clean up hint element on unmount
+    useEffect(() => {
+        return () => {
+            const hintElement = document.getElementById(`${cursorSpanId}-hint`);
+            if (hintElement) {
+                hintElement.remove();
+            }
+            if (loadingAnimationRef.current) {
+                cancelAnimationFrame(loadingAnimationRef.current);
+            }
+        };
+    }, [cursorSpanId]);
+    const lastCaretPosRef = useRef(null);
+    // Simple function to track caret position without inserting spans
+    const positionCursorSpan = () => {
+        if (isUpdatingRef.current)
+            return;
+        isUpdatingRef.current = true;
+        try {
+            const iframeWindow = pageViewContext.editorIframe?.contentWindow;
+            const iframeDocument = iframeWindow?.document;
+            const editableElement = fieldsContext?.inlineEditingFieldElement;
+            if (!iframeWindow || !iframeDocument || !editableElement)
+                return;
+            // Get current selection
+            const selection = iframeWindow.getSelection();
+            if (!selection || selection.rangeCount === 0)
+                return;
+            const range = selection.getRangeAt(0);
+            // Only proceed if selection is within our editing element
+            if (!editableElement.contains(range.commonAncestorContainer))
+                return;
+            // Save detailed information about the cursor position
+            const currentNode = range.startContainer;
+            const currentOffset = range.startOffset;
+            // Create a temporary range to get text up to cursor
+            const tempRange = document.createRange();
+            tempRange.selectNodeContents(editableElement);
+            tempRange.setEnd(currentNode, currentOffset);
+            const textUpToCursor = tempRange.toString();
+            // Check if cursor position has changed
+            const cursorMoved = !lastCaretPosRef.current ||
+                lastCaretPosRef.current.node !== currentNode ||
+                lastCaretPosRef.current.offset !== currentOffset ||
+                textUpToCursor.length !== (lastCaretPosRef.current.textLength || 0);
+            if (cursorMoved) {
+                // Reset completion if cursor position changed
+                lastCaretPosRef.current = {
+                    node: currentNode,
+                    offset: currentOffset,
+                    textLength: textUpToCursor.length,
+                };
+            }
+            // Save a copy of the current range
+            const originalRange = range.cloneRange();
+            // Remove any existing cursor spans
+            const existingSpan = iframeDocument.getElementById(cursorSpanId);
+            if (existingSpan) {
+                existingSpan.parentNode?.removeChild(existingSpan);
+            }
+            // Create our cursor span
+            const cursorSpan = existingSpan ?? iframeDocument.createElement("span");
+            cursorSpan.id = cursorSpanId;
+            cursorSpan.style.fontWeight = "bold";
+            cursorSpan.style.display = "inline";
+            cursorSpan.style.pointerEvents = "none";
+            cursorSpan.contentEditable = "false";
+            cursorSpan.setAttribute("data-cursor-indicator", "true");
+            // Get a working range for insertion
+            const workingRange = range.cloneRange();
+            workingRange.collapse(true);
+            // Insert the span at cursor position
+            workingRange.insertNode(cursorSpan);
+            // Restore original selection
+            selection.removeAllRanges();
+            selection.addRange(originalRange);
+            // setTimeout(() => {
+            //   getCompletionDebounced();
+            // }, 100);
+        }
+        catch (error) {
+            console.error("Error updating cursor:", error);
+        }
+        finally {
+            setTimeout(() => {
+                isUpdatingRef.current = false;
+            }, 10);
+        }
+    };
+    useEffect(() => {
+        // Handle keydown events - especially for cursor movement
+        const keyHandler = (e) => {
+            if (e.key === "ArrowLeft" ||
+                e.key === "ArrowRight" ||
+                e.key === "ArrowUp" ||
+                e.key === "ArrowDown" ||
+                e.key === " " ||
+                e.key === "Tab" ||
+                e.key === "End" ||
+                e.key === "Backspace" ||
+                e.key === "Delete" // Add Delete key handling
+            ) {
+                // Clear the completion when arrow keys are used
+                setCurrentCompletion(null);
+                clearCursorSpan();
+                // Let the browser handle the cursor movement/deletion
+                // Then update our cursor span after a small delay
+                setTimeout(() => {
+                    if (!isUpdatingRef.current) {
+                        positionCursorSpan();
+                    }
+                }, 10);
+                // Special handling for right arrow and delete which seems to have issues
+                if (e.key === "ArrowRight" || e.key === "Delete") {
+                    // Make sure the cursor span doesn't block the movement/deletion
+                    const cursorSpan = pageViewContext.editorIframe?.contentWindow?.document.getElementById(cursorSpanId);
+                    if (cursorSpan) {
+                        // Temporarily make it display none so it doesn't interfere with selection
+                        const originalDisplay = cursorSpan.style.display;
+                        cursorSpan.style.display = "none";
+                        // Restore after the browser has processed the movement/deletion
+                        setTimeout(() => {
+                            if (cursorSpan.parentNode) {
+                                cursorSpan.style.display = originalDisplay;
+                            }
+                        }, 0);
+                    }
+                }
+            }
+        };
+        pageViewContext.editorIframe?.contentWindow?.document.addEventListener("keydown", keyHandler);
+        return () => {
+            pageViewContext.editorIframe?.contentWindow?.document.removeEventListener("keydown", keyHandler);
+        };
+    }, [currentCompletion, pageViewContext.page]);
+    // Extracts the text up to the cursor position in the editable element
+    const getContentUpToCursor = (element) => {
+        const iframeWindow = pageViewContext.editorIframe?.contentWindow;
+        const selection = iframeWindow?.getSelection();
+        if (!element || !selection || selection.rangeCount === 0)
+            return null;
+        const range = selection.getRangeAt(0);
+        const cursorPosition = range.startOffset;
+        let contentUpToCursor = "";
+        if (element.childNodes.length === 0) {
+            contentUpToCursor = "";
+        }
+        else if (element.childNodes.length === 1 &&
+            element.firstChild?.nodeType === Node.TEXT_NODE) {
+            const full = element.innerText || "";
+            contentUpToCursor = full.substring(0, Math.min(cursorPosition, full.length));
+        }
+        else {
+            const tempRange = document.createRange();
+            tempRange.selectNodeContents(element);
+            tempRange.setEnd(range.startContainer, range.startOffset);
+            contentUpToCursor = tempRange.toString();
+        }
+        return contentUpToCursor;
+    };
+    // Loading animation with three dots changing color
+    const startLoadingAnimation = () => {
+        const doc = pageViewContext.editorIframe?.contentWindow?.document;
+        const span = doc?.getElementById(cursorSpanId);
+        if (!doc || !span)
+            return;
+        // Create dots container
+        span.innerHTML = "";
+        span.style.display = "inline-flex";
+        span.style.gap = "4px";
+        span.style.alignItems = "center";
+        // Create three dots
+        for (let i = 0; i < 3; i++) {
+            const dot = doc.createElement("span");
+            dot.textContent = "•";
+            dot.style.transition = "color 0.3s ease";
+            dot.style.color = "#ccc";
+            dot.style.fontSize = "16px";
+            span.appendChild(dot);
+        }
+        // Animate dots
+        let step = 0;
+        const animate = () => {
+            const dots = span.querySelectorAll("span");
+            dots.forEach((dot, index) => {
+                if (index === step % 3) {
+                    dot.style.color = "#666";
+                }
+                else {
+                    dot.style.color = "#ccc";
+                }
+            });
+            step++;
+            loadingAnimationRef.current = requestAnimationFrame(() => {
+                // Slow down animation by only updating every 15 frames (~250ms at 60fps)
+                if (step % 15 === 0) {
+                    animate();
+                }
+                else {
+                    loadingAnimationRef.current = requestAnimationFrame(animate);
+                }
+            });
+        };
+        animate();
+    };
+    const stopLoadingAnimation = () => {
+        if (loadingAnimationRef.current) {
+            cancelAnimationFrame(loadingAnimationRef.current);
+            loadingAnimationRef.current = null;
+        }
+    };
+    const getCompletion = async (element, isManualTrigger = false) => {
+        const contentUpToCursor = getContentUpToCursor(element);
+        if (!contentUpToCursor?.trim())
+            return null;
+        // Abort any in-flight request
+        if (abortControllerRef.current) {
+            abortControllerRef.current.abort();
+        }
+        // Create a new abort controller for this request
+        abortControllerRef.current = new AbortController();
+        const signal = abortControllerRef.current.signal;
+        // Get field attributes
+        const fieldId = element.getAttribute("data-fieldid");
+        const fieldName = element.getAttribute("data-fieldname");
+        const itemId = element.getAttribute("data-itemid");
+        const language = element.getAttribute("data-language");
+        const version = element.getAttribute("data-version");
+        if (!fieldId || !itemId || !language || !version)
+            return null;
+        // Only trigger completion after a space for automatic completions
+        // Manual triggers (Ctrl+Space) can work anywhere
+        if (!isManualTrigger) {
+            const lastChar = contentUpToCursor.slice(-1);
+            if (lastChar !== " " && lastChar !== "\u00A0") {
+                return null;
+            }
+        }
+        if (!editContext)
+            return null;
+        // Get page context for better completions
+        let pageContext = getCachedContext(editContext);
+        if (!pageContext) {
+            try {
+                pageContext = await generatePageContext(editContext, pageViewContext);
+            }
+            catch (error) {
+                console.warn("Failed to generate page context:", error);
+                // Continue without context
+            }
+        }
+        // Create context-aware completion prompt
+        const systemPrompt = pageContext
+            ? `You are a content completion tool for a ${pageContext.pageType} page titled "${pageContext.pageTitle}". 
+
+Page context: ${pageContext.abstract}
+
+Field being edited: ${fieldName || fieldId}
+
+ONLY provide the completion text (what comes after the user's text), never repeat any part of what the user wrote. Your completion should flow naturally from the user's text and be relevant to the page context and field being edited.`
+            : "You are a sentence completion tool. ONLY provide the completion text (what comes after the user's text), never repeat any part of what the user wrote. Your completion should flow naturally from the user's text.";
+        const messages = [
+            {
+                name: "system",
+                role: "system",
+                content: systemPrompt,
+                id: crypto.randomUUID(), // Use proper UUID instead of Date.now()
+            },
+            {
+                name: "user",
+                role: "user",
+                content: `Complete this text. ONLY provide the completion (do not repeat my text): ${contentUpToCursor}`,
+                id: crypto.randomUUID(), // Use proper UUID instead of Date.now()
+            },
+        ];
+        // Show loading indicator
+        setIsLoading(true);
+        startLoadingAnimation();
+        try {
+            const result = await executePrompt(messages, {
+                promptData: {
+                    itemid: itemId,
+                    language,
+                    version,
+                    fieldid: fieldId,
+                    fieldname: fieldName,
+                    content: contentUpToCursor,
+                },
+            }, { model: "gpt-4.1-nano", sessionId: editContext.sessionId }, { signal });
+            return result;
+        }
+        catch (error) {
+            // Ignore AbortError as it's expected when cancelling
+            if (error instanceof Error && error.name !== "AbortError") {
+                console.error("Error getting completion:", error);
+            }
+            return null;
+        }
+        finally {
+            // Hide loading indicator
+            setIsLoading(false);
+            stopLoadingAnimation();
+        }
+    };
+    // Debounced AI call: recompute the sentence, call getCompletion, and extract only the "tail" for the ghost text
+    const getCompletionDebounced = useDebouncedCallback(async (isManualTrigger = false) => {
+        const el = fieldsContext?.inlineEditingFieldElement;
+        if (!el)
+            return;
+        // 1) Recompute the exact sentence at this moment
+        const full = getContentUpToCursor(el) || "";
+        const sentence = full.split(/[.?!]\s*/).pop() || "";
+        // 2) Ask AI for a completion
+        const result = await getCompletion(el, isManualTrigger);
+        const rawSuggestion = result?.messages?.[0]?.content;
+        if (!rawSuggestion) {
+            setCurrentCompletion(null);
+            clearCursorSpan();
+            return;
+        }
+        // 3) Strip off the already-typed sentence to leave just the "completion tail"
+        const suggestion = rawSuggestion.startsWith(sentence)
+            ? rawSuggestion
+            : sentence + rawSuggestion;
+        setCurrentCompletion(suggestion);
+        updateCursorSpan(suggestion.substring(sentence.length));
+    }, 250);
+    // Manual completion trigger (non-debounced for immediate response)
+    const getCompletionManual = async () => {
+        const el = fieldsContext?.inlineEditingFieldElement;
+        if (!el)
+            return;
+        // 1) Recompute the exact sentence at this moment
+        const full = getContentUpToCursor(el) || "";
+        const sentence = full.split(/[.?!]\s*/).pop() || "";
+        // 2) Ask AI for a completion
+        const result = await getCompletion(el, true);
+        const rawSuggestion = result?.messages?.[0]?.content;
+        if (!rawSuggestion) {
+            setCurrentCompletion(null);
+            clearCursorSpan();
+            return;
+        }
+        // 3) Strip off the already-typed sentence to leave just the "completion tail"
+        const suggestion = rawSuggestion.startsWith(sentence)
+            ? rawSuggestion
+            : sentence + rawSuggestion;
+        setCurrentCompletion(suggestion);
+        updateCursorSpan(suggestion.substring(sentence.length));
+    };
+    // Inserts or clears the ghost text inside the cursor span
+    const updateCursorSpan = (text) => {
+        const doc = pageViewContext.editorIframe?.contentWindow?.document;
+        const span = doc?.getElementById(cursorSpanId);
+        if (!doc || !span)
+            return;
+        // Update the completion text
+        if (text) {
+            //   // Create a temporary span to measure the text width
+            //   const measureSpan = doc.createElement("span");
+            //   measureSpan.style.visibility = "hidden";
+            //   measureSpan.style.position = "absolute";
+            //   measureSpan.style.whiteSpace = "pre"; // Preserve whitespace
+            //   measureSpan.style.font = window.getComputedStyle(span).font; // Match the font
+            //   measureSpan.textContent = text;
+            //   doc.body.appendChild(measureSpan);
+            //   const textWidth = measureSpan.getBoundingClientRect().width;
+            //   measureSpan.remove();
+            span.textContent = text;
+            span.style.color = "#888";
+            span.style.fontStyle = "italic";
+            //span.innerHTML = "hello";
+            // Create or update hint element in the main document
+            let hintElement = document.getElementById(`${cursorSpanId}-hint`);
+            if (!hintElement) {
+                hintElement = document.createElement("div");
+                hintElement.id = `${cursorSpanId}-hint`;
+                document.body.appendChild(hintElement);
+            }
+            hintElement.textContent = "Press Tab to accept ⇥";
+            // Apply styles that match Tailwind's utility classes
+            Object.assign(hintElement.style, {
+                position: "fixed",
+                fontSize: "12px",
+                fontWeight: "normal",
+                color: "rgb(75, 85, 99)",
+                backgroundColor: "white",
+                padding: "0.5rem",
+                marginLeft: "0.25rem",
+                marginRight: "0.25rem",
+                borderRadius: "0.25rem",
+                border: "1px solid rgb(229, 231, 235)",
+                fontStyle: "normal",
+                display: "block",
+                lineHeight: "1.4",
+                zIndex: "9999",
+                pointerEvents: "none",
+                boxShadow: "0 2px 4px rgba(0,0,0,0.1)",
+            });
+            // Position the hint element relative to the iframe and cursor span
+            const iframeRect = pageViewContext.editorIframe?.getBoundingClientRect();
+            const spanRect = span.getBoundingClientRect();
+            if (iframeRect) {
+                // Create a range for the last character to get proper position
+                const textLength = span.textContent?.length || 0;
+                if (textLength > 0 && span.firstChild) {
+                    const range = doc.createRange();
+                    range.setStart(span.firstChild, Math.max(0, textLength - 1));
+                    range.setEnd(span.firstChild, textLength);
+                    const rangeRect = range.getBoundingClientRect();
+                    // Position at the end of the actual text
+                    const absoluteLeft = iframeRect.left + rangeRect.right;
+                    const absoluteTop = iframeRect.top + rangeRect.top;
+                    hintElement.style.left = `${absoluteLeft}px`;
+                    hintElement.style.top = `${absoluteTop}px`;
+                }
+                else {
+                    // Fallback to the old positioning if there's no text
+                    const absoluteLeft = iframeRect.left + spanRect.right;
+                    const absoluteTop = iframeRect.top + spanRect.top;
+                    hintElement.style.left = `${absoluteLeft}px`;
+                    hintElement.style.top = `${absoluteTop}px`;
+                }
+            }
+        }
+        else {
+            span.textContent = "";
+            // Remove hint element if it exists
+            const hintElement = document.getElementById(`${cursorSpanId}-hint`);
+            if (hintElement) {
+                hintElement.remove();
+            }
+        }
+    };
+    const clearCursorSpan = () => {
+        const doc = pageViewContext.editorIframe?.contentWindow?.document;
+        if (!doc)
+            return;
+        // Clear the completion text
+        updateCursorSpan("");
+    };
+    // On every input: either reuse the existing suggestion or fire a new one
+    const handleInput = useCallback((e) => {
+        const el = fieldsContext?.inlineEditingFieldElement;
+        if (!el)
+            return;
+        // Clear completion when Escape is pressed
+        if (e.key === "Escape") {
+            e.preventDefault();
+            e.stopPropagation();
+            setCurrentCompletion(null);
+            clearCursorSpan();
+            return;
+        }
+        // Request new completion when Ctrl+Space is pressed
+        if (e.key === " " && (e.ctrlKey || e.metaKey)) {
+            e.preventDefault();
+            e.stopPropagation();
+            setCurrentCompletion(null);
+            clearCursorSpan();
+            getCompletionManual();
+            return;
+        }
+        // Apply completion when Tab is pressed
+        if (e.key === "Tab") {
+            // Check if there's an actual completion in the cursor span
+            const cursorSpan = pageViewContext.editorIframe?.contentWindow?.document.getElementById(cursorSpanId);
+            if (cursorSpan &&
+                cursorSpan.textContent &&
+                cursorSpan.textContent.trim() !== "") {
+                e.preventDefault();
+                e.stopPropagation();
+                applyCompletion();
+                return;
+            }
+        }
+        const full = getContentUpToCursor(el) || "";
+        const sentence = full.split(/[.?!]\s*/).pop() || "";
+        // If we already have a suggestion, check if the user is still typing along it
+        // Normalize spaces to handle both regular and non-breaking spaces
+        const normalizedSentence = sentence.replace(/\s/g, " ");
+        const normalizedCompletion = currentCompletion?.replace(/\s/g, " ");
+        if (normalizedCompletion &&
+            normalizedCompletion.startsWith(normalizedSentence)) {
+            // user is still matching the suggestion → update the remaining tail
+            const remaining = normalizedCompletion.slice(normalizedSentence.length);
+            updateCursorSpan(remaining);
+            return;
+        }
+        // else: user diverged → drop it
+        setCurrentCompletion(null);
+        clearCursorSpan();
+        // No active suggestion → fire new request once they've typed 2+ words
+        const words = sentence.trim().split(/\s+/).filter(Boolean);
+        // Check if cursor is at the end of the text
+        const isAtEnd = () => {
+            const el = fieldsContext?.inlineEditingFieldElement;
+            if (!el)
+                return false;
+            const iframeWindow = pageViewContext.editorIframe?.contentWindow;
+            const selection = iframeWindow?.getSelection();
+            if (!selection || selection.rangeCount === 0)
+                return false;
+            const range = selection.getRangeAt(0);
+            // Create a range for the whole editable element
+            const fullRange = document.createRange();
+            fullRange.selectNodeContents(el);
+            // Get the full text content
+            const fullText = el.textContent || "";
+            // Get text up to cursor
+            const tempRange = document.createRange();
+            tempRange.selectNodeContents(el);
+            tempRange.setEnd(range.startContainer, range.startOffset);
+            const textUpToCursor = tempRange.toString();
+            // Cursor is at the end if the text up to cursor equals the full text
+            // (accounting for whitespace differences)
+            return (textUpToCursor.trim() === fullText.trim() ||
+                (fullText.trim().startsWith(textUpToCursor.trim()) &&
+                    fullText.trim().length === textUpToCursor.trim().length));
+        };
+        if (words.length >= 2 && isAtEnd()) {
+            getCompletionDebounced();
+        }
+        else {
+            setCurrentCompletion(null);
+            clearCursorSpan();
+        }
+    }, [
+        fieldsContext?.inlineEditingFieldElement,
+        currentCompletion,
+        getCompletionDebounced,
+        getCompletionManual,
+    ]);
+    // Wire up the input listener
+    useEffect(() => {
+        if (!editContext?.enableCompletions)
+            return;
+        const el = fieldsContext?.inlineEditingFieldElement;
+        if (!el)
+            return;
+        el.addEventListener("keydown", handleInput);
+        return () => el.removeEventListener("keydown", handleInput);
+    }, [
+        fieldsContext?.inlineEditingFieldElement,
+        handleInput,
+        editContext?.enableCompletions,
+    ]);
+    // Add mouse click handler to update cursor span position
+    useEffect(() => {
+        if (!editContext?.enableCompletions)
+            return;
+        const el = fieldsContext?.inlineEditingFieldElement;
+        if (!el)
+            return;
+        const handleMouseUp = () => {
+            setTimeout(() => {
+                if (!isUpdatingRef.current) {
+                    positionCursorSpan();
+                    // Clear existing completion when cursor position changes via mouse
+                    setCurrentCompletion(null);
+                    clearCursorSpan();
+                }
+            }, 10);
+        };
+        el.addEventListener("mouseup", handleMouseUp);
+        return () => el.removeEventListener("mouseup", handleMouseUp);
+    }, [
+        fieldsContext?.inlineEditingFieldElement,
+        editContext?.enableCompletions,
+    ]);
+    // Clean up abort controller on unmount
+    useEffect(() => {
+        return () => {
+            if (abortControllerRef.current) {
+                abortControllerRef.current.abort();
+                abortControllerRef.current = null;
+            }
+            if (loadingAnimationRef.current) {
+                cancelAnimationFrame(loadingAnimationRef.current);
+                loadingAnimationRef.current = null;
+            }
+        };
+    }, []);
+    // Function to apply the completion
+    const applyCompletion = () => {
+        // Get the cursor span to read the most up-to-date completion
+        const iframeWindow = pageViewContext.editorIframe?.contentWindow;
+        const iframeDocument = iframeWindow?.document;
+        if (!iframeWindow ||
+            !iframeDocument ||
+            !fieldsContext?.inlineEditingFieldElement)
+            return;
+        const cursorSpan = iframeDocument.getElementById(cursorSpanId);
+        if (!cursorSpan)
+            return;
+        // Get the completion text directly from the cursor span, which should be the most current
+        const completionToApply = cursorSpan.textContent || "";
+        if (!completionToApply)
+            return;
+        const element = fieldsContext?.inlineEditingFieldElement;
+        // Get the current selection position
+        const selection = iframeWindow.getSelection();
+        if (!selection || selection.rangeCount === 0)
+            return;
+        // Get the text up to the cursor to analyze current word
+        const range = selection.getRangeAt(0);
+        const tempRange = document.createRange();
+        tempRange.selectNodeContents(element);
+        tempRange.setEnd(range.startContainer, range.startOffset);
+        const textUpToCursor = tempRange.toString();
+        // Get the current partial word by finding text from the last word boundary to cursor
+        // Look for last word boundary (space, punctuation, etc.)
+        const wordBoundaryRegex = /[\s.,;:!?"'()[\]{}<>\/\\|=+\-*&^%$#@~`](?=[^\s.,;:!?"'()[\]{}<>\/\\|=+\-*&^%$#@~`]*$)/;
+        const match = textUpToCursor.match(wordBoundaryRegex);
+        const lastWordBoundaryIndex = match && match.index !== undefined ? match.index + 1 : 0;
+        const currentPartialWord = textUpToCursor
+            .substring(lastWordBoundaryIndex)
+            .trim();
+        // Check if completion overlaps with current partial word
+        // (e.g., if user typed "int" and completion is "integer")
+        const isOverlapping = currentPartialWord.length > 0 &&
+            completionToApply
+                .toLowerCase()
+                .startsWith(currentPartialWord.toLowerCase());
+        console.log("Is overlapping:", isOverlapping);
+        // If there's overlap, we need to delete the current partial word
+        if (isOverlapping) {
+            // Create a range to select the current partial word
+            const wordRange = document.createRange();
+            // Position where the current word starts
+            let startContainer = range.startContainer;
+            let startOffset = range.startOffset - currentPartialWord.length;
+            // We need to handle the case where the word spans multiple text nodes
+            // For simplicity, we'll try to handle the common case first
+            if (startOffset >= 0 && startContainer.nodeType === Node.TEXT_NODE) {
+                // Simple case: word is in the same text node as cursor
+                wordRange.setStart(startContainer, startOffset);
+                wordRange.setEnd(range.startContainer, range.startOffset);
+                wordRange.deleteContents(); // Delete the partial word
+            }
+            else {
+                // Complex case: use a simpler approach - just insert, user can delete manually if needed
+                // This is a fallback for complex DOM structures
+                // Add a space if we're in the middle of a sentence
+                if (textUpToCursor.length > 0 && !textUpToCursor.endsWith(" ")) {
+                    const spaceNode = document.createTextNode(" ");
+                    range.insertNode(spaceNode);
+                    range.setStartAfter(spaceNode);
+                    range.setEndAfter(spaceNode);
+                }
+            }
+        }
+        else {
+            // Not overlapping, add a space if we're in the middle of text
+            // and not already at the beginning of text or after a space
+            if (textUpToCursor.length > 0 &&
+                !textUpToCursor.endsWith(" ") &&
+                // Don't add space at the start of a line or after punctuation that shouldn't have a space
+                !textUpToCursor.endsWith("\n") &&
+                !/[.!?\-—:;({[\s]$/.test(textUpToCursor)) {
+                const spaceNode = document.createTextNode(" ");
+                range.insertNode(spaceNode);
+                range.setStartAfter(spaceNode);
+                range.setEndAfter(spaceNode);
+            }
+        }
+        // Now insert the completion text
+        const textNode = document.createTextNode(isOverlapping
+            ? completionToApply // If overlapping, use the full completion
+            : completionToApply);
+        range.insertNode(textNode);
+        // Move the cursor after the inserted text
+        range.setStartAfter(textNode);
+        range.setEndAfter(textNode);
+        selection.removeAllRanges();
+        selection.addRange(range);
+        setCurrentCompletion(null);
+        clearCursorSpan();
+    };
+    // Exposed manual trigger (if needed)
+    return useMemo(() => () => {
+        setCurrentCompletion(null);
+        clearCursorSpan();
+        getCompletionManual();
+    }, [getCompletionManual]);
+}
+//# sourceMappingURL=useInlineAICompletion.js.map