@parhelia/core 0.1.12883 → 0.1.12886

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

@@ -355,6 +355,16 @@ export function deriveSelectorState(params) {
     }
     return "disabled";
 }
+// 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").
+const activeHighlightFinishers = new Set();
+// Remove all active highlight overlays right now (resolving their lifetimes).
+function clearActiveHighlightOverlays() {
+    for (const finish of [...activeHighlightFinishers]) {
+        finish();
+    }
+}
 // Create a temporary highlight overlay. Resolves when its finite "life"
 // animation ends and the overlay has been removed (event-driven, not a timer).
 function showHighlightOverlay(x, y, width, height, duration) {
@@ -415,6 +425,7 @@ function showHighlightOverlay(x, y, width, height, duration) {
             if (finished)
                 return;
             finished = true;
+            activeHighlightFinishers.delete(finish);
             overlay.removeEventListener("animationend", onAnimationEnd);
             overlay.remove();
             resolve();
@@ -426,6 +437,8 @@ function showHighlightOverlay(x, y, width, height, duration) {
             }
         };
         overlay.addEventListener("animationend", onAnimationEnd);
+        // Allow a superseding reveal to wipe this overlay immediately.
+        activeHighlightFinishers.add(finish);
         // Guardrail: if animationend is ever missed, remove shortly after duration.
         window.setTimeout(finish, duration + 500);
     });
@@ -463,13 +476,80 @@ function clearActiveReveal(id) {
         activeRevealController = null;
     }
 }
+// The surface key for the Agents panel depends on HOW it opens (mirrors the
+// open logic in config.tsx `openAgentsPanel`): the dedicated far-right panel on
+// desktop ("agents-panel") vs. a left sidebar stack on mobile / contexts without
+// `setShowAgentsPanel` ("sidebar:agents-panel"). Used for de-duplication within
+// a reveal and to keep the surface key self-documenting.
+function agentsPanelSurfaceKey(editContext) {
+    if (editContext &&
+        !editContext.isMobile &&
+        typeof editContext.setShowAgentsPanel === "function") {
+        return "agents-panel";
+    }
+    return "sidebar:agents-panel";
+}
 // Close the More-panels flyout if it is currently open (inverse of open-more-sidebars).
+function isMorePanelsExpanded() {
+    return !!document.querySelector('[data-testid="more-sidebars-button"][aria-expanded="true"]');
+}
 function closeMorePanelsIfOpen() {
-    if (!isElementPresent("@more-sidebars-panel"))
+    if (!isMorePanelsExpanded())
         return;
     const trigger = document.querySelector('[data-testid="more-sidebars-button"]');
     trigger?.click();
 }
+function closeVersionSelectorIfOpen() {
+    if (!isElementPresent("@version-selector-list"))
+        return;
+    const list = document.querySelector('[data-testid="version-selector-list"]');
+    if (list) {
+        list.dispatchEvent(new KeyboardEvent("keydown", {
+            key: "Escape",
+            code: "Escape",
+            bubbles: true,
+            cancelable: true,
+        }));
+        return;
+    }
+    const trigger = document.querySelector('[data-testid="version-selector"][aria-expanded="true"]') ??
+        document.querySelector('[data-testid="version-selector"]');
+    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
+// present-but-closing menu items.
+async function waitForMorePanelsClosed(timeoutMs = 1000) {
+    const isStillOpen = () => isElementPresent("@more-sidebars-panel") || isMorePanelsExpanded();
+    const waitUntilClosed = async () => {
+        const startedAt = Date.now();
+        while (Date.now() - startedAt < timeoutMs && isStillOpen()) {
+            await waitForDelay(50);
+        }
+        return !isStillOpen();
+    };
+    if (await waitUntilClosed())
+        return;
+    // If the first close signal was missed, try one guarded close again. The
+    // guard prevents toggling a panel that is already closing or closed.
+    closeMorePanelsIfOpen();
+    await waitForSelectorAnimations('[data-testid="more-sidebars-panel"]');
+    await waitUntilClosed();
+}
+// Resolve once the version-selector popover is fully closed: its list is gone
+// AND the trigger no longer reports aria-expanded="true". The supersede close
+// awaits this so the next reveal's open-version-selector (which early-returns
+// when it believes the popover is still open/visible) always starts from a
+// truly closed state, making the close-then-reopen deterministic.
+async function waitForVersionSelectorClosed(timeoutMs = 1000) {
+    const startedAt = Date.now();
+    const isStillOpen = () => isElementPresent("@version-selector-list") ||
+        !!document.querySelector('[data-testid="version-selector"][aria-expanded="true"]');
+    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" ||
@@ -529,21 +609,32 @@ function SelectorButton({ selectorDef, keyProp, }) {
         revealRef.current = null;
         setIsActiveReveal(false);
     }, []);
-    // Run the undo steps and reset. Used for explicit close (2nd click, auto
-    // timer, or being superseded by another reveal via mutual exclusion).
+    // Fully tear down this reveal: wipe its highlight, close every owned surface
+    // (reverse open order so nested surfaces close first) and reset the button.
+    // Used for explicit close (2nd click, auto timer), external-close handling,
+    // and being superseded by another reveal.
     const runRestore = useCallback(async () => {
         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.
+        clearActiveHighlightOverlays();
         // Reset button state immediately (button turns blue) while the surface
-        // teardown animation plays out; the returned promise resolves once settled.
+        // teardown animation plays out; the promise resolves once settled.
         clearActiveReveal(reveal?.id ?? controllerIdRef.current);
         revealRef.current = null;
         setIsActiveReveal(false);
-        if (reveal) {
+        if (!reveal)
+            return;
+        // 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;
             try {
-                await reveal.restore();
+                await op.close();
             }
             catch {
-                // ignore restore failures
+                // ignore individual close failures
             }
         }
     }, []);
@@ -630,7 +721,7 @@ function SelectorButton({ selectorDef, keyProp, }) {
         : isDisabled
             ? selectorDef.notFoundMessage || selectorDef.description
             : selectorDef.description;
-    return (_jsxs(Tooltip, { children: [_jsx(TooltipTrigger, { asChild: true, children: _jsxs("button", { "aria-label": isActiveReveal ? CLOSE_PANE_LABEL : "Show me", onClick: async () => {
+    return (_jsxs(Tooltip, { children: [_jsx(TooltipTrigger, { asChild: true, children: _jsxs("button", { "data-manual-show-me": "true", "data-manual-show-me-before-action": selectorDef.beforeAction || undefined, "aria-label": isActiveReveal ? CLOSE_PANE_LABEL : "Show me", onClick: async () => {
                         // Second click while active -> restore (close=click behaviour).
                         if (isActiveReveal) {
                             runRestore();
@@ -658,16 +749,17 @@ function SelectorButton({ selectorDef, keyProp, }) {
                                 return;
                             }
                             // State-machine semantics: any new Show-me action supersedes the
-                            // currently active State 3 reveal from another button, restoring
-                            // its UI first. Await the teardown 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).
+                            // 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
+                            // 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).
                             const superseded = supersedeActiveReveal(controllerIdRef.current);
                             if (superseded) {
                                 try {
-                                    // Await the close so A's surface finishes its teardown
-                                    // animation before B starts revealing (event-driven, not timed).
                                     await superseded.close();
                                 }
                                 catch {
@@ -694,28 +786,40 @@ function SelectorButton({ selectorDef, keyProp, }) {
                                 };
                                 await action(actionProps);
                             };
-                            // Undo steps captured as we reveal, plus predicates telling
-                            // whether the revealed container is still open.
-                            const undoSteps = [];
-                            const openPredicates = [];
+                            // 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 = [];
+                            // Register a surface unless one with the same key was already
+                            // pushed by an earlier step in this same reveal.
+                            const pushSurface = (op) => {
+                                if (surfaceOps.some((existing) => existing.key === op.key)) {
+                                    return;
+                                }
+                                surfaceOps.push(op);
+                            };
                             // 1. Sidebar-only: open the sidebar.
                             if (isSidebarOnly &&
                                 editContext?.openSidebar &&
                                 selectorDef.location) {
                                 const sidebarId = selectorDef.location;
+                                const surfaceKey = `sidebar:${sidebarId}`;
                                 const wasOpen = !!editContext.openSidebars?.includes(sidebarId);
                                 if (!wasOpen) {
                                     editContext.openSidebar(sidebarId);
-                                    undoSteps.push(async () => {
-                                        editContextRef.current?.toggleSidebar?.(sidebarId, {
-                                            forceClose: true,
-                                        });
-                                        await editContextRef.current?.waitForSurfaceSettled?.(`sidebar:${sidebarId}`);
+                                    pushSurface({
+                                        key: surfaceKey,
+                                        close: async () => {
+                                            editContextRef.current?.toggleSidebar?.(sidebarId, {
+                                                forceClose: true,
+                                            });
+                                            await editContextRef.current?.waitForSurfaceSettled?.(`sidebar:${sidebarId}`);
+                                        },
+                                        isOpen: () => !!editContextRef.current?.openSidebars?.includes(sidebarId),
                                     });
                                     // Wait for the sidebar's open animation to finish before querying.
                                     await editContext.waitForSurfaceSettled?.(`sidebar:${sidebarId}`);
                                 }
-                                openPredicates.push(() => !!editContextRef.current?.openSidebars?.includes(sidebarId));
                             }
                             const availabilityElements = anchorSelector
                                 ? resolveElements(anchorSelector)
@@ -734,11 +838,14 @@ function SelectorButton({ selectorDef, keyProp, }) {
                             if (shouldOpenEditorForm && editContext) {
                                 const slotId = editContext.getActiveSlotId();
                                 editContext.setEditorFormHiddenForSlot(slotId, false);
-                                undoSteps.push(async () => {
-                                    editContextRef.current?.setEditorFormHiddenForSlot(slotId, true);
-                                    await editContextRef.current?.waitForSurfaceSettled?.("editor-form");
+                                pushSurface({
+                                    key: "editor-form",
+                                    close: async () => {
+                                        editContextRef.current?.setEditorFormHiddenForSlot(slotId, true);
+                                        await editContextRef.current?.waitForSurfaceSettled?.("editor-form");
+                                    },
+                                    isOpen: () => !isEditorFormSliderHidden(getEditorFormSlider()),
                                 });
-                                openPredicates.push(() => !isEditorFormSliderHidden(getEditorFormSlider()));
                                 await editContext.waitForSurfaceSettled?.("editor-form");
                             }
                             else if (selectorDef.tab) {
@@ -752,6 +859,7 @@ function SelectorButton({ selectorDef, keyProp, }) {
                                 ? resolvedElements
                                 : availabilityElements;
                             const morePanelsWasOpen = isElementPresent("@more-sidebars-panel");
+                            const versionSelectorWasOpen = isElementPresent("@version-selector-list");
                             // Capture pre-reveal state for the AI Assistant reveals so we only
                             // restore (close) what THIS button actually opened.
                             const agentsPanelWasOpen = isAgentsPanelOpen();
@@ -762,11 +870,32 @@ function SelectorButton({ selectorDef, keyProp, }) {
                             if (selectorDef.beforeAction === "open-more-sidebars") {
                                 const morePanelsNowOpen = isElementPresent("@more-sidebars-panel");
                                 if (!morePanelsWasOpen && morePanelsNowOpen) {
-                                    undoSteps.push(async () => {
-                                        closeMorePanelsIfOpen();
-                                        await waitForSelectorAnimations('[data-testid="more-sidebars-panel"]');
+                                    pushSurface({
+                                        key: "more-sidebars-panel",
+                                        close: async () => {
+                                            closeMorePanelsIfOpen();
+                                            await waitForSelectorAnimations('[data-testid="more-sidebars-panel"]');
+                                            await waitForMorePanelsClosed();
+                                        },
+                                        isOpen: () => isElementPresent("@more-sidebars-panel"),
+                                    });
+                                }
+                            }
+                            if (selectorDef.beforeAction === "open-version-selector") {
+                                const versionSelectorNowOpen = isElementPresent("@version-selector-list");
+                                if (!versionSelectorWasOpen && versionSelectorNowOpen) {
+                                    pushSurface({
+                                        key: "version-selector",
+                                        close: async () => {
+                                            closeVersionSelectorIfOpen();
+                                            await waitForSelectorAnimations('[data-testid="version-selector-list"]');
+                                            // Gate until the popover is truly gone so the next
+                                            // reveal's open-version-selector reopens from a closed
+                                            // state (deterministic close-then-reopen).
+                                            await waitForVersionSelectorClosed();
+                                        },
+                                        isOpen: () => isElementPresent("@version-selector-list"),
                                     });
-                                    openPredicates.push(() => isElementPresent("@more-sidebars-panel"));
                                 }
                             }
                             if (selectorDef.beforeAction === "open-agents-panel" ||
@@ -775,46 +904,59 @@ function SelectorButton({ selectorDef, keyProp, }) {
                                 // animation (see config openAgentsPanel/openAgentSettings), so
                                 // no polling here.
                                 const agentsPanelNowOpen = isAgentsPanelOpen();
-                                // Push the panel-close undo first so that, since undo steps run
-                                // in reverse, the settings popover is closed before the panel.
+                                // Push the panel surface first so that, since surfaces close in
+                                // reverse, the settings popover is closed before the panel.
                                 if (!agentsPanelWasOpen && agentsPanelNowOpen) {
-                                    undoSteps.push(async () => {
-                                        if (editContextRef.current?.isMobile) {
-                                            editContextRef.current?.toggleSidebar?.("agents-panel", {
-                                                forceClose: true,
-                                            });
-                                            await editContextRef.current?.waitForSurfaceSettled?.("sidebar:agents-panel");
-                                        }
-                                        else {
-                                            editContextRef.current?.setShowAgentsPanel?.(false);
-                                            await editContextRef.current?.waitForSurfaceSettled?.("agents-panel");
-                                        }
+                                    pushSurface({
+                                        key: agentsPanelSurfaceKey(editContext),
+                                        close: async () => {
+                                            if (editContextRef.current?.isMobile) {
+                                                editContextRef.current?.toggleSidebar?.("agents-panel", {
+                                                    forceClose: true,
+                                                });
+                                                await editContextRef.current?.waitForSurfaceSettled?.("sidebar:agents-panel");
+                                            }
+                                            else {
+                                                editContextRef.current?.setShowAgentsPanel?.(false);
+                                                await editContextRef.current?.waitForSurfaceSettled?.("agents-panel");
+                                            }
+                                        },
+                                        isOpen: () => isAgentsPanelOpen(),
                                     });
-                                    openPredicates.push(() => isAgentsPanelOpen());
                                 }
                                 if (selectorDef.beforeAction === "open-agent-settings") {
                                     const settingsTargetNowOpen = !!selectorDef.selector &&
                                         isElementPresent(selectorDef.selector);
                                     if (!agentSettingsWasOpen && settingsTargetNowOpen) {
-                                        undoSteps.push(async () => {
-                                            const trigger = document.querySelector('[data-testid="agent-settings-popover-trigger"]');
-                                            if (trigger &&
-                                                selectorDef.selector &&
-                                                isElementPresent(selectorDef.selector)) {
-                                                trigger.click();
-                                                await waitForSelectorAnimations('[data-testid="agent-settings-popover-content"]');
-                                            }
+                                        pushSurface({
+                                            key: "agent-settings",
+                                            close: async () => {
+                                                const trigger = document.querySelector('[data-testid="agent-settings-popover-trigger"]');
+                                                if (trigger &&
+                                                    selectorDef.selector &&
+                                                    isElementPresent(selectorDef.selector)) {
+                                                    trigger.click();
+                                                    await waitForSelectorAnimations('[data-testid="agent-settings-popover-content"]');
+                                                }
+                                            },
+                                            isOpen: () => selectorDef.selector
+                                                ? isElementPresent(selectorDef.selector)
+                                                : false,
                                         });
-                                        openPredicates.push(() => selectorDef.selector
-                                            ? isElementPresent(selectorDef.selector)
-                                            : false);
                                     }
                                 }
                             }
-                            // afterAction is the declared inverse for custom reveals (e.g. field actions).
+                            // afterAction is the declared inverse for custom reveals (e.g.
+                            // field actions). It is a restore-only step with no open surface,
+                            // so it uses a "custom:" key and is excluded from the still-open
+                            // check below.
                             if (selectorDef.afterAction) {
-                                undoSteps.push(async () => {
-                                    await runManualAction(selectorDef.afterAction, !isSidebarOnly ? resolveElements() : availabilityElements);
+                                pushSurface({
+                                    key: "custom:afterAction",
+                                    close: async () => {
+                                        await runManualAction(selectorDef.afterAction, !isSidebarOnly ? resolveElements() : availabilityElements);
+                                    },
+                                    isOpen: () => true,
                                 });
                             }
                             // Highlight the target. For sidebar-only selectors there is no
@@ -838,26 +980,22 @@ function SelectorButton({ selectorDef, keyProp, }) {
                                     highlightLifetime = highlightElement(highlightSelector, HIGHLIGHT_DURATION_MS);
                                 }
                             }
-                            // If we opened/undid anything, this was a State-3 reveal: keep the
+                            // If we opened any surface, this was a State-3 reveal: keep the
                             // button active (green) and register it for mutual exclusion.
-                            if (undoSteps.length > 0) {
+                            if (surfaceOps.length > 0) {
                                 const id = ++revealControllerSeq;
                                 controllerIdRef.current = id;
                                 revealRef.current = {
                                     id,
-                                    restore: async () => {
-                                        for (let i = undoSteps.length - 1; i >= 0; i -= 1) {
-                                            try {
-                                                await undoSteps[i]?.();
-                                            }
-                                            catch {
-                                                // ignore individual undo failures
-                                            }
-                                        }
+                                    surfaceOps,
+                                    // Restore-only "custom:" surfaces (e.g. afterAction) have no
+                                    // open state and must not keep the reveal "open" forever.
+                                    isStillOpen: () => {
+                                        const tracked = surfaceOps.filter((op) => !op.key.startsWith("custom:"));
+                                        return tracked.length === 0
+                                            ? true
+                                            : tracked.some((op) => op.isOpen());
                                     },
-                                    isStillOpen: () => openPredicates.length === 0
-                                        ? true
-                                        : openPredicates.some((predicate) => predicate()),
                                 };
                                 registerActiveReveal({
                                     id,