@parhelia/core 0.3.12763 → 0.3.12767

package/dist/editor/page-viewer/PageViewerFrame.js

@@ -7,6 +7,7 @@ import { useSlotContext } from "../views/editorSlotContext";
 import { useDebouncedCallback, useThrottledCallback } from "use-debounce";
 import { PageEditorChrome } from "../page-editor-chrome/PageEditorChrome";
 import { useBridgeInlineEditing, } from "../page-editor-chrome/useBridgeInlineEditing";
+import { createBridgeInlineEditSessionCoordinator, } from "./bridgeInlineEditSession";
 import { getInlineAiAnchorFromBridgeToolbar, getVisibleBridgeToolbarRect, waitForVisibleBridgeToolbarRect, } from "../page-editor-chrome/bridgeInlineFormatToolbarLayout";
 import { IFRAME_OVERLAY_BRIDGE_DRAG_GESTURE_EVENT, IFRAME_OVERLAY_BRIDGE_GEOMETRY_EVENT, IFRAME_OVERLAY_BRIDGE_SCROLL_EVENT, IframeOverlayProvider, } from "../page-editor-chrome/overlay/IframeOverlayProvider";
 import { CANVAS_REFRESH_COMPLETED_EVENT, DEVICE_CHANGE_EVENT, useViewportChangeSignal, } from "./pageViewContext";
@@ -29,8 +30,8 @@ import { toSitecoreDate } from "../utils/sitecoreDate";
 import { pickVersionAtDate } from "../utils/versionAtDate";
 import { BridgeClient } from "../bridge/BridgeClient";
 import { beginPerfTrace, isPerfTraceActive, isPerfTraceEnabled, perfTraceStep, } from "../perfTrace";
-import { getSuggestionDisplayValue } from "../reviews/suggestionDisplayValue";
-import { buildBridgeFieldPatchPayload, getBridgeFieldPatchValue, isBridgePatchableTextField, reduceActiveBridgeInlineEditForRefreshEvent, } from "./bridgeFieldPatch";
+import { getPendingFieldSuggestions, getSuggestionDisplayValue, } from "../reviews/suggestionDisplayValue";
+import { buildBridgeFieldPatchPayload, buildBridgeFieldPatchSignature, buildRemoteCaretFieldPatches, getBridgeFieldPatchValue, hasRemoteCaretDraftForField, isBridgePatchableTextField, isSuggestionPreviewPatchSignature, } from "./bridgeFieldPatch";
 import { bridgeSelectionMatchesInteraction, resolveBridgeTextCompletionInput, } from "./bridgeTextCompletion";
 import { logFieldValueDiagnostic, summarizeField, summarizeFieldDescriptor, summarizeFieldValue, } from "../fieldValueDiagnostics";
 import { createKeyboardEventFromBridgeInteraction } from "./bridgeKeyboardShortcuts";
@@ -618,18 +619,21 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
     const bridgeTextRangeSourcesRef = useRef(new Map());
     const activeBridgeInlineEditRef = useRef(null);
     const [isBridgeInlineEditing, setIsBridgeInlineEditing] = useState(false);
+    const bridgeInlineEditSessionRef = useRef(null);
+    if (!bridgeInlineEditSessionRef.current) {
+        bridgeInlineEditSessionRef.current =
+            createBridgeInlineEditSessionCoordinator({
+                stateRef: activeBridgeInlineEditRef,
+                onStateChange: (state) => setIsBridgeInlineEditing(!!state),
+            });
+    }
+    const bridgeInlineEditSession = bridgeInlineEditSessionRef.current;
     const clearActiveBridgeInlineEdit = useCallback(() => {
-        activeBridgeInlineEditRef.current = null;
-        setIsBridgeInlineEditing(false);
-    }, []);
+        bridgeInlineEditSession.clear();
+    }, [bridgeInlineEditSession]);
     const reconcileActiveBridgeInlineEdit = useCallback((event) => {
-        const current = activeBridgeInlineEditRef.current;
-        const reconciled = reduceActiveBridgeInlineEditForRefreshEvent(current, event);
-        if (reconciled === current)
-            return;
-        activeBridgeInlineEditRef.current = reconciled;
-        setIsBridgeInlineEditing(!!reconciled);
-    }, []);
+        bridgeInlineEditSession.reconcileForRefreshEvent(event);
+    }, [bridgeInlineEditSession]);
     const bridgeTextCompletionRef = useRef(null);
     const bridgeTextCompletionAbortRef = useRef(null);
     const bridgeTextCompletionRequestIdRef = useRef(0);
@@ -897,7 +901,7 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
     }, []);
     const { beginInlineEdit: beginBridgeInlineEdit, clearInlineDedupe: clearBridgeInlineDedupe, endFieldFocus: endBridgeFieldFocus, handleFieldValueChanged: handleBridgeFieldValueChanged, handleInlineEditEnded: handleBridgeInlineEditEnded, } = useBridgeInlineEditing({
         pageViewContextRef,
-        activeBridgeInlineEditRef,
+        inlineEditSession: bridgeInlineEditSession,
         blockIframeBlurUntil,
         sendBeginInlineEdit,
         sendCancelInlineEdit,
@@ -916,30 +920,27 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
                 selectionEndOffset: interaction.selectionEndOffset,
             },
         });
-        clearActiveBridgeInlineEdit();
-        const started = await beginBridgeInlineEdit(interaction);
-        if (started && interaction.elementKey && interaction.fieldId) {
-            const interactionItem = interaction.item?.id &&
-                interaction.item.language &&
-                typeof interaction.item.version === "number"
-                ? {
-                    id: interaction.item.id,
-                    language: interaction.item.language,
-                    version: interaction.item.version,
-                    name: interaction.item.name,
-                    displayName: interaction.item.displayName,
-                    path: interaction.item.path,
-                    database: interaction.item.database,
-                }
-                : undefined;
-            activeBridgeInlineEditRef.current = {
-                elementKey: interaction.elementKey,
-                fieldId: interaction.fieldId,
-                item: interactionItem,
-                modeAtStart: editContextRef.current?.mode ?? editContext.mode,
-            };
-            setIsBridgeInlineEditing(true);
-        }
+        if (!interaction.elementKey || !interaction.fieldId)
+            return false;
+        const interactionItem = interaction.item?.id &&
+            interaction.item.language &&
+            typeof interaction.item.version === "number"
+            ? {
+                id: interaction.item.id,
+                language: interaction.item.language,
+                version: interaction.item.version,
+                name: interaction.item.name,
+                displayName: interaction.item.displayName,
+                path: interaction.item.path,
+                database: interaction.item.database,
+            }
+            : undefined;
+        const started = await bridgeInlineEditSession.beginSession({
+            elementKey: interaction.elementKey,
+            fieldId: interaction.fieldId,
+            item: interactionItem,
+            modeAtStart: editContextRef.current?.mode ?? editContext.mode,
+        }, ({ isCurrent, sessionId }) => beginBridgeInlineEdit(interaction, { isCurrent, sessionId }));
         logFieldValueDiagnostic("bridge-frame", "tracked inline edit result", {
             started,
             nextActiveInlineEdit: activeBridgeInlineEditRef.current,
@@ -947,7 +948,7 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
         return started;
     }, [
         beginBridgeInlineEdit,
-        clearActiveBridgeInlineEdit,
+        bridgeInlineEditSession,
         editContext.mode,
         editContextRef,
     ]);
@@ -1086,12 +1087,7 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
     }, []);
     const sendBridgeFieldPatch = useCallback((bridge, patch, observedTextContent) => {
         const cacheKey = `${patch.elementKey}:${patch.fieldId}`;
-        const signature = JSON.stringify({
-            value: patch.value,
-            isRichText: !!patch.isRichText,
-            source: patch.source ?? "",
-            observedTextContent: observedTextContent ?? "",
-        });
+        const signature = buildBridgeFieldPatchSignature(patch, observedTextContent);
         const previousSignature = bridgePatchSignatureRef.current.get(cacheKey);
         if (previousSignature === signature) {
             logFieldValueDiagnostic("bridge-patch", "skipped duplicate send", {
@@ -1133,6 +1129,7 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
         const offset = selection.startOffset ?? selection.endOffset;
         if (!editor ||
             !activeField?.fieldId ||
+            activeField.inlineEditing !== true ||
             !selection.collapsed ||
             offset == null) {
             clearBridgeRemoteCaretPosition();
@@ -1153,19 +1150,50 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
             ...sourceItem,
             version,
         };
-        const nextKey = `${activeField.fieldId}:${item.id}:${item.language}:${item.version}:${offset}`;
+        const nextKey = JSON.stringify({
+            fieldId: activeField.fieldId,
+            item,
+            offset,
+            value: activeField.value,
+        });
         if (lastSentBridgeCaretRef.current === nextKey)
             return;
+        logFieldValueDiagnostic("bridge-caret", "sending position", {
+            fieldId: activeField.fieldId,
+            item,
+            offset,
+            value: summarizeFieldValue(activeField.value),
+        });
         editor.sendSocketMessage({
             type: "caret-position",
             payload: {
                 fieldId: activeField.fieldId,
                 item,
                 offset,
+                value: activeField.value,
             },
         });
         lastSentBridgeCaretRef.current = nextKey;
     }, [clearBridgeRemoteCaretPosition, editContextRef, pageViewContextRef]);
+    useEffect(() => {
+        const bridge = bridgeClientRef.current;
+        const structureFields = pageViewContext.bridgeStructure?.fields ?? [];
+        if (!bridge || structureFields.length === 0)
+            return;
+        const patches = buildRemoteCaretFieldPatches({
+            remoteCarets: editContext.remoteCarets,
+            structureFields,
+            activeInlineEdit: activeBridgeInlineEditRef.current,
+        });
+        for (const patch of patches) {
+            const structureField = structureFields.find((field) => field.elementKey === patch.elementKey);
+            sendBridgeFieldPatch(bridge, patch, structureField?.textContent);
+        }
+    }, [
+        editContext.remoteCarets,
+        pageViewContext.bridgeStructure,
+        sendBridgeFieldPatch,
+    ]);
     const handleBridgeSelection = useCallback((selection, iframe) => {
         const editor = editContextRef.current;
         if (!editor)
@@ -1305,8 +1333,27 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
         addCandidateItem(component?.datasourceItem);
         component?.items.forEach(addCandidateItem);
         addCandidateItem(fallbackItem);
+        const fallbackDescriptorItem = candidateItems[0];
+        if (!fallbackDescriptorItem)
+            return undefined;
+        // Limited-preview users only need read-only actions such as comments.
+        // The bridge already provides the reviewed item's field descriptor, while
+        // repository hydration may be intentionally denied by preview access.
+        if (editContextRef.current?.user?.isLimitedPreviewUser) {
+            return { fieldId, item: fallbackDescriptorItem };
+        }
         for (const item of candidateItems) {
-            const repositoryItem = await editContextRef.current?.itemsRepository.getItem(item);
+            let repositoryItem;
+            try {
+                repositoryItem =
+                    await editContextRef.current?.itemsRepository.getItem(item);
+            }
+            catch {
+                // Review-preview access may allow the rendered page while denying a
+                // repository candidate. Keep trying and fall back to the bridge
+                // descriptor so read-only context-menu actions can still load.
+                continue;
+            }
             const repositoryField = repositoryItem?.fields.find((field) => fieldIdentifierMatches(field, fieldId));
             if (repositoryField) {
                 return {
@@ -1315,9 +1362,6 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
                 };
             }
         }
-        const fallbackDescriptorItem = candidateItems[0];
-        if (!fallbackDescriptorItem)
-            return undefined;
         return {
             fieldId,
             item: fallbackDescriptorItem,
@@ -1774,41 +1818,61 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
                     },
                 ]);
             }, 100);
-            const field = await resolveBridgeFieldDescriptor(effectiveInteraction);
-            const fieldButtons = field ? await loadFieldButtons(field) : [];
-            const handleParameterizedActionWithPosition = (field, action) => {
-                setContextMenuField(field);
-                setContextMenuFieldButtons([action]);
-                setPreSelectedAction(action);
-                window.setTimeout(() => {
-                    const tempElement = document.createElement("div");
-                    tempElement.style.position = "fixed";
-                    tempElement.style.left = menuPosition.x + "px";
-                    tempElement.style.top = menuPosition.y + "px";
-                    tempElement.style.width = "1px";
-                    tempElement.style.height = "1px";
-                    tempElement.style.visibility = "hidden";
-                    tempElement.style.pointerEvents = "none";
-                    document.body.appendChild(tempElement);
-                    const positionedEvent = new MouseEvent("click", {
-                        bubbles: true,
-                        cancelable: true,
-                        view: window,
-                        clientX: menuPosition.x,
-                        clientY: menuPosition.y,
-                    });
-                    Object.defineProperty(positionedEvent, "target", {
-                        value: tempElement,
-                        enumerable: true,
-                    });
-                    fieldActionsOverlay.current?.show(positionedEvent, action);
+            let items = [];
+            try {
+                const field = await resolveBridgeFieldDescriptor(effectiveInteraction);
+                const canLoadFieldButtons = !!field &&
+                    !editor.readonly &&
+                    !editor.user?.isLimitedPreviewUser;
+                const fieldButtons = canLoadFieldButtons
+                    ? await loadFieldButtons(field)
+                    : [];
+                const handleParameterizedActionWithPosition = (field, action) => {
+                    setContextMenuField(field);
+                    setContextMenuFieldButtons([action]);
+                    setPreSelectedAction(action);
                     window.setTimeout(() => {
-                        tempElement.remove();
-                    }, 1000);
-                }, 100);
-            };
-            const items = await buildComponentContextMenuItems(selectedComponents, editor, field, fieldButtons, handleParameterizedActionWithPosition);
-            window.clearTimeout(loadingTimer);
+                        const tempElement = document.createElement("div");
+                        tempElement.style.position = "fixed";
+                        tempElement.style.left = menuPosition.x + "px";
+                        tempElement.style.top = menuPosition.y + "px";
+                        tempElement.style.width = "1px";
+                        tempElement.style.height = "1px";
+                        tempElement.style.visibility = "hidden";
+                        tempElement.style.pointerEvents = "none";
+                        document.body.appendChild(tempElement);
+                        const positionedEvent = new MouseEvent("click", {
+                            bubbles: true,
+                            cancelable: true,
+                            view: window,
+                            clientX: menuPosition.x,
+                            clientY: menuPosition.y,
+                        });
+                        Object.defineProperty(positionedEvent, "target", {
+                            value: tempElement,
+                            enumerable: true,
+                        });
+                        fieldActionsOverlay.current?.show(positionedEvent, action);
+                        window.setTimeout(() => {
+                            tempElement.remove();
+                        }, 1000);
+                    }, 100);
+                };
+                items = await buildComponentContextMenuItems(selectedComponents, editor, field, fieldButtons, handleParameterizedActionWithPosition);
+            }
+            catch (error) {
+                console.error("Failed to build component context menu:", error);
+                items = [
+                    {
+                        id: "context-menu-error",
+                        label: "Unable to load menu",
+                        disabled: true,
+                    },
+                ];
+            }
+            finally {
+                window.clearTimeout(loadingTimer);
+            }
             if (loadingShown) {
                 editor.updateContextMenu(items);
             }
@@ -2148,9 +2212,6 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
                         handleBridgeSelection(event.payload.selection, iframe);
                         break;
                     case "fieldValueChanged":
-                        if (event.payload.elementKey && event.payload.fieldId) {
-                            setIsBridgeInlineEditing(true);
-                        }
                         logFieldValueDiagnostic("bridge-frame", "fieldValueChanged event", {
                             elementKey: event.payload.elementKey,
                             fieldId: event.payload.fieldId,
@@ -2171,9 +2232,15 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
                             value: summarizeFieldValue(event.payload.value),
                             activeInlineEdit: activeBridgeInlineEditRef.current,
                         });
-                        handleBridgeInlineEditEnded(event.payload);
-                        clearActiveBridgeInlineEdit();
-                        logFieldValueDiagnostic("bridge-frame", "active inline edit cleared after end", {
+                        const inlineEditEnd = bridgeInlineEditSession.end(event.payload);
+                        handleBridgeInlineEditEnded(event.payload, {
+                            recordSession: false,
+                            releaseFocus: inlineEditEnd.matched,
+                            endedModeAtStart: inlineEditEnd.endedState?.modeAtStart,
+                        });
+                        logFieldValueDiagnostic("bridge-frame", inlineEditEnd.matched
+                            ? "active inline edit cleared after end"
+                            : "non-current inline edit end persisted", {
                             fieldId: event.payload.fieldId,
                             reason: event.payload.reason,
                         });
@@ -2273,6 +2340,7 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
         clearBridgeTextCompletion,
         clearBridgePatchSignatures,
         clearActiveBridgeInlineEdit,
+        bridgeInlineEditSession,
         reconcileActiveBridgeInlineEdit,
         pageViewContext.editUrl,
         pageViewContext.previewUrl,
@@ -2310,6 +2378,17 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
                     if (!bridgeFieldMatchesChangedField(structureField.fieldId, changedFieldId, field)) {
                         continue;
                     }
+                    // A remote session is live-syncing this field: its draft is
+                    // authoritative, and the saved-value echo behind this change is
+                    // stale mid-typing — applying it would roll the canvas text back
+                    // and make the remote caret jump against the shorter text.
+                    if (hasRemoteCaretDraftForField({
+                        remoteCarets: editContextRef.current?.remoteCarets,
+                        fieldId: structureField.fieldId,
+                        item: structureField.item,
+                    })) {
+                        continue;
+                    }
                     const patch = buildBridgeFieldPatch({
                         field,
                         structureField,
@@ -2431,7 +2510,22 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
                     itemDescriptor: itemDescriptor,
                     dirtyOnly: true,
                 });
-                if (!showSuggestions && !dirtyModifiedField) {
+                // When suggestion display turns off, a field can still show suggestion
+                // text even though nothing is dirty: either its last patch was a
+                // suggestion preview, or an inline edit typed the suggestion into the
+                // DOM and the recorded suggestion only lands after the toggle. Both
+                // need an explicit restore patch back to the baseline value.
+                const needsSuggestionRestore = !showSuggestions &&
+                    (isSuggestionPreviewPatchSignature(bridgePatchSignatureRef.current.get(`${structureField.elementKey}:${structureField.fieldId}`)) ||
+                        getPendingFieldSuggestions(editContext.suggestedEdits, {
+                            fieldId: field.id || structureField.fieldId,
+                            itemId: itemDescriptor.id,
+                            language: itemDescriptor.language,
+                            version: itemDescriptor.version,
+                            pageItemId: pageViewContextRef.current?.pageItemDescriptor?.id,
+                            pageItemVersion: pageViewContextRef.current?.pageItemDescriptor?.version,
+                        }).length > 0);
+                if (!showSuggestions && !dirtyModifiedField && !needsSuggestionRestore) {
                     continue;
                 }
                 const patch = buildBridgeFieldPatch({