@parhelia/core 0.1.12895 → 0.1.12901

package/dist/editor/menubar/toolbar-sections/ManualBrowser.js

@@ -355,6 +355,12 @@ export function deriveSelectorState(params) {
     }
     return "disabled";
 }
+export function shouldResetActiveReveal(params) {
+    if (!params.hasReveal || !params.isRevealStillOpen) {
+        return true;
+    }
+    return params.hasAvailabilitySelector && !params.isAnchorPresent;
+}
 // Finishers for every highlight overlay currently on screen. Lets a superseding
 // reveal wipe the previous reveal's highlight immediately so it does not keep
 // pulsing over the close/re-open transition (the "uncoordinated animation").
@@ -443,6 +449,19 @@ function showHighlightOverlay(x, y, width, height, duration) {
         window.setTimeout(finish, duration + 500);
     });
 }
+export function hasStatefulRevealSurface(surfaceKeys) {
+    return surfaceKeys.some((key) => !key.startsWith("custom:"));
+}
+// Whether a superseding reveal should keep (hand off) the previous reveal's
+// already-open editor-form slider instead of closing and reopening it. The
+// slider is a controlled surface (not dismiss-on-outside), so it can persist
+// across reveals: when the incoming reveal is non-sidebar and the slider is
+// already open, we carry the surface forward to avoid a visible close-reopen
+// flicker. Mirrors the `shouldOpenEditorForm` gate but on the "already open"
+// state (there is only something to carry when it is open).
+export function shouldCarryEditorFormSurface(params) {
+    return !params.isSidebarOnly && params.sliderExists && params.isSliderOpen;
+}
 let activeRevealController = null;
 let revealControllerSeq = 0;
 // Serialize Show-me reveal clicks across ALL buttons so overlapping rapid clicks
@@ -516,6 +535,26 @@ function closeVersionSelectorIfOpen() {
         document.querySelector('[data-testid="version-selector"]');
     trigger?.click();
 }
+function isNotificationCenterExpanded() {
+    return !!document.querySelector('[data-testid="notification-center-trigger"][aria-expanded="true"]');
+}
+function closeNotificationCenterIfOpen() {
+    if (!isElementPresent("@notification-center-list"))
+        return;
+    const list = document.querySelector('[data-testid="notification-center-list"]');
+    if (list) {
+        list.dispatchEvent(new KeyboardEvent("keydown", {
+            key: "Escape",
+            code: "Escape",
+            bubbles: true,
+            cancelable: true,
+        }));
+        return;
+    }
+    const trigger = document.querySelector('[data-testid="notification-center-trigger"][aria-expanded="true"]') ??
+        document.querySelector('[data-testid="notification-center-trigger"]');
+    trigger?.click();
+}
 // Resolve once the More-panels popover is fully closed: its list is gone AND
 // the trigger no longer reports aria-expanded="true". This lets a superseding
 // More-panels reveal reopen from a truly closed state instead of sampling
@@ -550,6 +589,14 @@ async function waitForVersionSelectorClosed(timeoutMs = 1000) {
         await waitForDelay(50);
     }
 }
+async function waitForNotificationCenterClosed(timeoutMs = 1000) {
+    const startedAt = Date.now();
+    const isStillOpen = () => isElementPresent("@notification-center-list") ||
+        isNotificationCenterExpanded();
+    while (Date.now() - startedAt < timeoutMs && isStillOpen()) {
+        await waitForDelay(50);
+    }
+}
 function isAgentsPanelOpen() {
     const trigger = document.querySelector('[data-testid="agents-panel-button"]');
     return (trigger?.getAttribute("aria-pressed") === "true" ||
@@ -609,11 +656,13 @@ function SelectorButton({ selectorDef, keyProp, }) {
         revealRef.current = null;
         setIsActiveReveal(false);
     }, []);
-    // Fully tear down this reveal: wipe its highlight, close every owned surface
-    // (reverse open order so nested surfaces close first) and reset the button.
+    // Tear down this reveal: wipe its highlight, reset the button, and close every
+    // owned surface (reverse open order so nested surfaces close first) EXCEPT
+    // those whose key is in `keepKeys`. Kept (still-open) surfaces are returned so
+    // a superseding reveal can adopt them instead of closing+reopening them.
     // Used for explicit close (2nd click, auto timer), external-close handling,
     // and being superseded by another reveal.
-    const runRestore = useCallback(async () => {
+    const runRestoreKeeping = useCallback(async (keepKeys = []) => {
         const reveal = revealRef.current;
         // Remove the highlight immediately so it does not keep pulsing over the
         // close/re-open transition while the next reveal builds up.
@@ -624,12 +673,17 @@ function SelectorButton({ selectorDef, keyProp, }) {
         revealRef.current = null;
         setIsActiveReveal(false);
         if (!reveal)
-            return;
+            return [];
+        const kept = [];
         // Close in reverse open order (nested surfaces close first).
         for (let i = reveal.surfaceOps.length - 1; i >= 0; i -= 1) {
             const op = reveal.surfaceOps[i];
             if (!op)
                 continue;
+            if (keepKeys.includes(op.key) && op.isOpen()) {
+                kept.push(op);
+                continue;
+            }
             try {
                 await op.close();
             }
@@ -637,9 +691,16 @@ function SelectorButton({ selectorDef, keyProp, }) {
                 // ignore individual close failures
             }
         }
+        // Returned in open order so the adopting reveal can splice them back in.
+        return kept.reverse();
     }, []);
+    const runRestore = useCallback(async () => {
+        await runRestoreKeeping([]);
+    }, [runRestoreKeeping]);
     const runRestoreRef = useRef(runRestore);
     runRestoreRef.current = runRestore;
+    const runRestoreKeepingRef = useRef(runRestoreKeeping);
+    runRestoreKeepingRef.current = runRestoreKeeping;
     // Keep the presence/visibility probes fresh.
     useEffect(() => {
         const check = () => {
@@ -688,7 +749,15 @@ function SelectorButton({ selectorDef, keyProp, }) {
             return;
         const check = () => {
             const reveal = revealRef.current;
-            if (!reveal || !reveal.isStillOpen()) {
+            const anchorPresent = anchorSelector
+                ? isElementPresent(anchorSelector)
+                : isAnchorPresent;
+            if (shouldResetActiveReveal({
+                hasReveal: Boolean(reveal),
+                isRevealStillOpen: reveal?.isStillOpen() ?? false,
+                hasAvailabilitySelector,
+                isAnchorPresent: anchorPresent,
+            })) {
                 resetActiveState();
             }
         };
@@ -709,7 +778,13 @@ function SelectorButton({ selectorDef, keyProp, }) {
             observer.disconnect();
             clearInterval(intervalId);
         };
-    }, [isActiveReveal, resetActiveState]);
+    }, [
+        anchorSelector,
+        hasAvailabilitySelector,
+        isActiveReveal,
+        isAnchorPresent,
+        resetActiveState,
+    ]);
     // Clear the global active controller if this button unmounts while active.
     useEffect(() => {
         return () => {
@@ -748,27 +823,45 @@ function SelectorButton({ selectorDef, keyProp, }) {
                             if (clickToken !== revealClickSeq) {
                                 return;
                             }
+                            const resolveElements = (selector = selectorDef.selector) => selector ? getElementsForSelector(selector) : [];
                             // State-machine semantics: any new Show-me action supersedes the
-                            // currently active State 3 reveal from another button, fully
-                            // tearing it down (clearing its highlight and closing its surfaces)
-                            // BEFORE this reveal starts opening. Await the teardown so the close
+                            // currently active State 3 reveal from another button, tearing it
+                            // down (clearing its highlight and closing its surfaces) BEFORE
+                            // this reveal starts opening. Await the teardown so the close
                             // animation completes first - the transition is a clean, sequenced
                             // close-then-open - and so this reveal samples fresh DOM and avoids
                             // a stale "was this surface open?" read. Because clicks are
                             // serialized above, the superseded controller is always the
                             // previous fully-settled reveal (no race here).
+                            //
+                            // Exception: if this reveal would only reopen the same editor-form
+                            // slider, hand the already-open surface off instead of closing it,
+                            // so the slider does not visibly close and reopen. We then own it
+                            // and close it on our own restore.
+                            const carrySlider = getEditorFormSlider([
+                                ...resolveElements(),
+                                ...(anchorSelector ? resolveElements(anchorSelector) : []),
+                            ]);
+                            const keepKeys = shouldCarryEditorFormSurface({
+                                isSidebarOnly,
+                                sliderExists: carrySlider !== null,
+                                isSliderOpen: !isEditorFormSliderHidden(carrySlider),
+                            })
+                                ? ["editor-form"]
+                                : [];
                             const superseded = supersedeActiveReveal(controllerIdRef.current);
+                            let carriedSurfaceOps = [];
                             if (superseded) {
                                 try {
-                                    await superseded.close();
+                                    carriedSurfaceOps = await superseded.closeKeeping(keepKeys);
                                 }
                                 catch {
                                     // ignore supersede failures
+                                    carriedSurfaceOps = [];
                                 }
                             }
                             const runId = globalThis.crypto?.randomUUID?.() ??
                                 `manual-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-                            const resolveElements = (selector = selectorDef.selector) => selector ? getElementsForSelector(selector) : [];
                             const runManualAction = async (actionName, elements) => {
                                 if (!actionName ||
                                     !editContext ||
@@ -786,10 +879,11 @@ function SelectorButton({ selectorDef, keyProp, }) {
                                 };
                                 await action(actionProps);
                             };
-                            // Surfaces this reveal opens, in open order. Closed in reverse on
-                            // restore. The previous reveal was fully torn down above, so we
-                            // always start from an empty set.
-                            const surfaceOps = [];
+                            // Surfaces this reveal owns, in open order. Closed in reverse on
+                            // restore. Any surface handed off by the superseded reveal (the
+                            // already-open editor-form slider) is adopted here, so we keep it
+                            // open instead of reopening it and still close it on our restore.
+                            const surfaceOps = [...carriedSurfaceOps];
                             // Register a surface unless one with the same key was already
                             // pushed by an earlier step in this same reveal.
                             const pushSurface = (op) => {
@@ -844,7 +938,10 @@ function SelectorButton({ selectorDef, keyProp, }) {
                                         editContextRef.current?.setEditorFormHiddenForSlot(slotId, true);
                                         await editContextRef.current?.waitForSurfaceSettled?.("editor-form");
                                     },
-                                    isOpen: () => !isEditorFormSliderHidden(getEditorFormSlider()),
+                                    isOpen: () => {
+                                        const slider = getEditorFormSlider();
+                                        return slider !== null && !isEditorFormSliderHidden(slider);
+                                    },
                                 });
                                 await editContext.waitForSurfaceSettled?.("editor-form");
                             }
@@ -860,6 +957,7 @@ function SelectorButton({ selectorDef, keyProp, }) {
                                 : availabilityElements;
                             const morePanelsWasOpen = isElementPresent("@more-sidebars-panel");
                             const versionSelectorWasOpen = isElementPresent("@version-selector-list");
+                            const notificationCenterWasOpen = isElementPresent("@notification-center-list");
                             // Capture pre-reveal state for the AI Assistant reveals so we only
                             // restore (close) what THIS button actually opened.
                             const agentsPanelWasOpen = isAgentsPanelOpen();
@@ -898,6 +996,20 @@ function SelectorButton({ selectorDef, keyProp, }) {
                                     });
                                 }
                             }
+                            if (selectorDef.beforeAction === "open-notification-center") {
+                                const notificationCenterNowOpen = isElementPresent("@notification-center-list");
+                                if (!notificationCenterWasOpen && notificationCenterNowOpen) {
+                                    pushSurface({
+                                        key: "notification-center",
+                                        close: async () => {
+                                            closeNotificationCenterIfOpen();
+                                            await waitForSelectorAnimations('[data-testid="notification-center-list"]');
+                                            await waitForNotificationCenterClosed();
+                                        },
+                                        isOpen: () => isElementPresent("@notification-center-list"),
+                                    });
+                                }
+                            }
                             if (selectorDef.beforeAction === "open-agents-panel" ||
                                 selectorDef.beforeAction === "open-agent-settings") {
                                 // The beforeAction already awaited the panel/popover open
@@ -970,9 +1082,8 @@ function SelectorButton({ selectorDef, keyProp, }) {
                                     : ""
                                 : selectorDef.selector;
                             // The highlight runs a finite CSS animation; highlightElement
-                            // resolves on its animationend. We do NOT await it before
-                            // registering the reveal (the button must turn green immediately);
-                            // close=auto instead chains its restore onto this lifetime.
+                            // resolves on its animationend. Stateful reveals register below
+                            // without awaiting it; close=auto chains restore onto this lifetime.
                             let highlightLifetime = Promise.resolve();
                             if (highlightSelector) {
                                 const highlightTargets = await waitForVisibleElements(highlightSelector, 1500);
@@ -980,9 +1091,28 @@ function SelectorButton({ selectorDef, keyProp, }) {
                                     highlightLifetime = highlightElement(highlightSelector, HIGHLIGHT_DURATION_MS);
                                 }
                             }
-                            // If we opened any surface, this was a State-3 reveal: keep the
+                            const hasStatefulSurface = hasStatefulRevealSurface(surfaceOps.map((op) => op.key));
+                            if (surfaceOps.length > 0 && !hasStatefulSurface) {
+                                // Restore-only custom actions (for example field action reveals)
+                                // should clean up after the highlight, but they do not represent
+                                // an opened pane/popover that needs a green "close" state.
+                                void highlightLifetime.then(async () => {
+                                    for (let i = surfaceOps.length - 1; i >= 0; i -= 1) {
+                                        const op = surfaceOps[i];
+                                        if (!op)
+                                            continue;
+                                        try {
+                                            await op.close();
+                                        }
+                                        catch {
+                                            // ignore individual restore failures
+                                        }
+                                    }
+                                });
+                            }
+                            // If we opened a real surface, this was a State-3 reveal: keep the
                             // button active (green) and register it for mutual exclusion.
-                            if (surfaceOps.length > 0) {
+                            if (hasStatefulSurface) {
                                 const id = ++revealControllerSeq;
                                 controllerIdRef.current = id;
                                 revealRef.current = {
@@ -1000,6 +1130,7 @@ function SelectorButton({ selectorDef, keyProp, }) {
                                 registerActiveReveal({
                                     id,
                                     close: () => runRestoreRef.current(),
+                                    closeKeeping: (keepKeys) => runRestoreKeepingRef.current(keepKeys),
                                     isStillOpen: () => revealRef.current?.isStillOpen() ?? false,
                                 });
                                 setIsActiveReveal(true);
@@ -1306,8 +1437,10 @@ function flattenNavigableSections(sections) {
     return flattened;
 }
 const MANUAL_SECTION_TEMPLATE_ID = "c5f1e8a2-9b50-4fe2-9b6d-3db00c3b3b8a";
+const MANUAL_SEARCH_DEBOUNCE_MS = 600;
 export function ManualBrowser({ onClose }) {
     const editContext = useEditContext();
+    const editContextRef = useRef(editContext);
     const [toc, setToc] = useState([]);
     const selectedSectionId = editContext?.selectedHelpSectionId ?? null;
     const [currentSection, setCurrentSection] = useState(null);
@@ -1370,6 +1503,7 @@ export function ManualBrowser({ onClose }) {
         }
         return map;
     }, [toc]);
+    const manualSectionsByIdRef = useRef(manualSectionsById);
     const backTargetSectionId = manualBackHistory.length > 0
         ? manualBackHistory[manualBackHistory.length - 1]
         : null;
@@ -1382,6 +1516,8 @@ export function ManualBrowser({ onClose }) {
         ? `Back to ${backTargetSection.title}`
         : "Back to contents";
     const backButtonText = backTargetSectionId === null ? "Contents" : "Back";
+    editContextRef.current = editContext;
+    manualSectionsByIdRef.current = manualSectionsById;
     // Keep selectedSectionId ref in sync
     useEffect(() => {
         selectedSectionIdRef.current = selectedSectionId;
@@ -1502,17 +1638,23 @@ export function ManualBrowser({ onClose }) {
     useEffect(() => {
         let cancelled = false;
         const trimmedQuery = searchQuery.trim();
-        if (!trimmedQuery || !editContext) {
+        if (!trimmedQuery || !editContextRef.current) {
             setSearching(false);
             setSearchResults([]);
             return;
         }
         const timeoutId = window.setTimeout(async () => {
+            const latestEditContext = editContextRef.current;
+            if (!latestEditContext) {
+                setSearching(false);
+                setSearchResults([]);
+                return;
+            }
             setSearching(true);
             try {
                 const result = await executeSearch({
                     query: `${trimmedQuery}|template:${MANUAL_SECTION_TEMPLATE_ID}`,
-                    editContext,
+                    editContext: latestEditContext,
                     maxResults: 20,
                     index: "master",
                     skipValidation: true,
@@ -1521,8 +1663,9 @@ export function ManualBrowser({ onClose }) {
                     return;
                 if (result.type === "success") {
                     const items = result.data || [];
+                    const latestManualSectionsById = manualSectionsByIdRef.current;
                     const mapped = items
-                        .map((item) => manualSectionsById.get(String(item.id || "").toLowerCase()))
+                        .map((item) => latestManualSectionsById.get(String(item.id || "").toLowerCase()))
                         .filter((section) => !!section);
                     const unique = Array.from(new Map(mapped.map((section) => [section.id, section])).values());
                     setSearchResults(unique);
@@ -1543,12 +1686,12 @@ export function ManualBrowser({ onClose }) {
                     setSearching(false);
                 }
             }
-        }, 300);
+        }, MANUAL_SEARCH_DEBOUNCE_MS);
         return () => {
             cancelled = true;
             window.clearTimeout(timeoutId);
         };
-    }, [searchQuery, editContext, manualSectionsById]);
+    }, [searchQuery]);
     // Listen for websocket messages to auto-refresh when manual items change
     // Use ref for selectedSectionId to avoid stale closures and only re-register when selection actually changes
     useEffect(() => {