Skip to content

Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.

fix(ui): keep Select Escape from dismissing parent overlays (#8632)

Andrew Huang02ae9d1599bf
diff --git a/frontend/src/components/v3/generic/Select/Select.tsx b/frontend/src/components/v3/generic/Select/Select.tsx
index 3a610f2cfe..6b8231f741 100644
--- a/frontend/src/components/v3/generic/Select/Select.tsx
+++ b/frontend/src/components/v3/generic/Select/Select.tsx
@@ -5,9 +5,45 @@ import { Select as SelectPrimitive } from "radix-ui";
import { twMerge } from "tailwind-merge";
import { cn } from "../../utils";
+import { useOverlayPopupRegistration } from "../../utils/overlay-layer";
-function Select({ ...props }: React.ComponentProps<typeof SelectPrimitive.Root>) {
- return <SelectPrimitive.Root data-slot="select" {...props} />;
+const SelectPopupContext = React.createContext<{
+ open: boolean;
+ onOpenChange: (open: boolean) => void;
+ escapeEvents: WeakSet<KeyboardEvent>;
+} | null>(null);
+
+function Select({
+ open: controlledOpen,
+ defaultOpen = false,
+ onOpenChange,
+ ...props
+}: React.ComponentProps<typeof SelectPrimitive.Root>) {
+ const [uncontrolledOpen, setUncontrolledOpen] = React.useState(defaultOpen);
+ const open = controlledOpen ?? uncontrolledOpen;
+ const escapeEvents = React.useRef(new WeakSet<KeyboardEvent>());
+ const handleOpenChange = React.useCallback(
+ (nextOpen: boolean) => {
+ if (controlledOpen === undefined) setUncontrolledOpen(nextOpen);
+ onOpenChange?.(nextOpen);
+ },
+ [controlledOpen, onOpenChange]
+ );
+ const contextValue = React.useMemo(
+ () => ({ open, onOpenChange: handleOpenChange, escapeEvents: escapeEvents.current }),
+ [open, handleOpenChange]
+ );
+
+ return (
+ <SelectPopupContext.Provider value={contextValue}>
+ <SelectPrimitive.Root
+ data-slot="select"
+ {...props}
+ open={open}
+ onOpenChange={handleOpenChange}
+ />
+ </SelectPopupContext.Provider>
+ );
}
function SelectScrollUpButton({
@@ -112,10 +148,32 @@ function SelectContent({
align = "center",
collisionPadding = 8,
portalContainer,
+ onEscapeKeyDown,
...props
}: React.ComponentProps<typeof SelectPrimitive.Content> & {
portalContainer?: React.ComponentProps<typeof SelectPrimitive.Portal>["container"];
}) {
+ const select = React.useContext(SelectPopupContext);
+ const handleEscapeKeyDown = React.useCallback(
+ (event: KeyboardEvent) => {
+ if (select?.escapeEvents.has(event)) return false;
+ select?.escapeEvents.add(event);
+ onEscapeKeyDown?.(event);
+ return !event.defaultPrevented;
+ },
+ [select, onEscapeKeyDown]
+ );
+ const handleRegisteredEscape = React.useCallback(
+ (event: KeyboardEvent) => {
+ if (handleEscapeKeyDown(event)) select?.onOpenChange(false);
+ },
+ [select, handleEscapeKeyDown]
+ );
+ const markPopupDismissEvent = useOverlayPopupRegistration(
+ select?.open ?? false,
+ handleRegisteredEscape
+ );
+
return (
<SelectPrimitive.Portal container={portalContainer}>
<SelectPrimitive.Content
@@ -130,6 +188,9 @@ function SelectContent({
position={position}
align={align}
collisionPadding={collisionPadding}
+ onEscapeKeyDown={(event) => {
+ if (handleEscapeKeyDown(event)) markPopupDismissEvent(event);
+ }}
{...props}
>
<SelectScrollUpButton />
diff --git a/frontend/src/components/v3/utils/overlay-layer.test.ts b/frontend/src/components/v3/utils/overlay-layer.test.ts
new file mode 100644
index 0000000000..0550bc5c09
--- /dev/null
+++ b/frontend/src/components/v3/utils/overlay-layer.test.ts
@@ -0,0 +1,89 @@
+import { createElement, type ReactNode } from "react";
+import { renderToString } from "react-dom/server";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { OverlayLayerContext, useOverlayLayer } from "./overlay-layer";
+
+const createLayers = () => {
+ const layers: ReturnType<typeof useOverlayLayer>[] = [];
+ const Probe = ({ children }: { children?: ReactNode }) => {
+ const layer = useOverlayLayer(false);
+ layers.push(layer);
+ return createElement(OverlayLayerContext.Provider, { value: layer.contextValue }, children);
+ };
+ renderToString(createElement(Probe, null, createElement(Probe)));
+ return layers;
+};
+
+const escape = () =>
+ Object.assign(new Event("keydown", { cancelable: true }), { key: "Escape" }) as KeyboardEvent;
+
+beforeEach(() => vi.stubGlobal("KeyboardEvent", Event));
+afterEach(() => vi.unstubAllGlobals());
+
+describe("overlay popup bookkeeping", () => {
+ it.each([false, true])("consumes ancestor-first Escape once with cancellation %s", (cancel) => {
+ const [ancestor, child] = createLayers();
+ const parentHandler = vi.fn();
+ const onOpenChange = vi.fn();
+ const onEscape = vi.fn((event: KeyboardEvent) => {
+ if (cancel) event.preventDefault();
+ else {
+ onOpenChange(false);
+ child.contextValue.registerPopup("choice", false);
+ }
+ });
+ child.contextValue.registerPopup("choice", true, onEscape);
+ const event = escape();
+ ancestor.guardDismiss(event, parentHandler);
+ child.guardDismiss(event, parentHandler);
+ ancestor.guardDismiss(event, parentHandler);
+ expect(onEscape).toHaveBeenCalledTimes(1);
+ expect(onOpenChange.mock.calls).toEqual(cancel ? [] : [[false]]);
+ expect(parentHandler).not.toHaveBeenCalled();
+ expect(event.defaultPrevented).toBe(true);
+ });
+
+ it("keeps the original popup-first event consumed through ancestor cleanup", () => {
+ const [ancestor, child] = createLayers();
+ const delegate = vi.fn();
+ const parentHandler = vi.fn();
+ child.contextValue.registerPopup("choice", true, delegate);
+ const event = escape();
+ const wrapped = Object.assign(new Event("outside"), { detail: { originalEvent: event } });
+ child.contextValue.markPopupDismissEvent(wrapped);
+ child.contextValue.registerPopup("choice", false);
+ child.guardDismiss(event, parentHandler);
+ ancestor.guardDismiss(event, parentHandler);
+ expect(delegate).not.toHaveBeenCalled();
+ expect(parentHandler).not.toHaveBeenCalled();
+ expect(event.defaultPrevented).toBe(true);
+ });
+
+ it("preserves insertion order and removes descendant registrations from ancestors", () => {
+ const [ancestor, child] = createLayers();
+ const first = vi.fn();
+ const latest = vi.fn();
+ const updated = vi.fn();
+ child.contextValue.registerPopup("first", true, first);
+ child.contextValue.registerPopup("latest", true, latest);
+ child.contextValue.registerPopup("first", true, updated);
+ ancestor.guardDismiss(escape());
+ expect(latest).toHaveBeenCalledTimes(1);
+ expect(updated).not.toHaveBeenCalled();
+ child.contextValue.registerPopup("latest", false);
+ ancestor.guardDismiss(escape());
+ expect(updated).toHaveBeenCalledTimes(1);
+ expect(first).not.toHaveBeenCalled();
+ child.contextValue.registerPopup("first", false);
+ const parentHandler = vi.fn();
+ ancestor.guardDismiss(escape(), parentHandler);
+ expect(parentHandler).toHaveBeenCalledTimes(1);
+ child.contextValue.registerPopup("legacy", true);
+ ancestor.guardDismiss(escape(), parentHandler);
+ expect(parentHandler).toHaveBeenCalledTimes(1);
+ child.contextValue.registerPopup("legacy", false);
+ ancestor.guardDismiss(escape(), parentHandler);
+ expect(parentHandler).toHaveBeenCalledTimes(2);
+ });
+});
diff --git a/frontend/src/components/v3/utils/overlay-layer.ts b/frontend/src/components/v3/utils/overlay-layer.ts
index 5406382a28..d52c13e2ba 100644
--- a/frontend/src/components/v3/utils/overlay-layer.ts
+++ b/frontend/src/components/v3/utils/overlay-layer.ts
@@ -2,7 +2,11 @@ import * as React from "react";
type OverlayLayerContextValue = {
isPending: boolean;
- registerPopup: (id: string, open: boolean) => void;
+ registerPopup: (
+ id: string,
+ open: boolean,
+ onEscapeKeyDown?: (event: KeyboardEvent) => void
+ ) => void;
markPopupDismissEvent: (event: Event) => void;
};
@@ -18,18 +22,40 @@ const getOriginalEvent = (event: Event) =>
(event as CustomEvent<{ originalEvent?: Event } | undefined>).detail?.originalEvent ?? event;
const useOverlayLayer = (isPending: boolean) => {
- const openPopups = React.useRef(new Set<string>());
+ const parentLayer = React.useContext(OverlayLayerContext);
+ const parentRegisterPopup = parentLayer?.registerPopup;
+ const parentMarkPopupDismissEvent = parentLayer?.markPopupDismissEvent;
+ const openPopups = React.useRef(new Map<string, ((event: KeyboardEvent) => void) | undefined>());
const popupDismissEvents = React.useRef(new WeakSet<Event>());
const focusReturnTarget = React.useRef<HTMLElement | null>(null);
- const registerPopup = React.useCallback((id: string, open: boolean) => {
- if (open) openPopups.current.add(id);
- else openPopups.current.delete(id);
- }, []);
+ const markPopupDismissEvent = React.useCallback(
+ (event: Event) => {
+ const originalEvent = getOriginalEvent(event);
+ popupDismissEvents.current.add(originalEvent);
+ parentMarkPopupDismissEvent?.(originalEvent);
+ },
+ [parentMarkPopupDismissEvent]
+ );
- const markPopupDismissEvent = React.useCallback((event: Event) => {
- popupDismissEvents.current.add(event);
- }, []);
+ const registerPopup = React.useCallback(
+ (id: string, open: boolean, onEscapeKeyDown?: (event: KeyboardEvent) => void) => {
+ if (!open) {
+ openPopups.current.delete(id);
+ parentRegisterPopup?.(id, false);
+ return;
+ }
+ const handleEscapeKeyDown = onEscapeKeyDown
+ ? (event: KeyboardEvent) => {
+ markPopupDismissEvent(event);
+ onEscapeKeyDown(event);
+ }
+ : undefined;
+ openPopups.current.set(id, handleEscapeKeyDown);
+ parentRegisterPopup?.(id, true, handleEscapeKeyDown);
+ },
+ [markPopupDismissEvent, parentRegisterPopup]
+ );
const contextValue = React.useMemo(
() => ({ isPending, registerPopup, markPopupDismissEvent }),
@@ -37,11 +63,22 @@ const useOverlayLayer = (isPending: boolean) => {
);
const guardDismiss = <TEvent extends Event>(event: TEvent, handler?: (event: TEvent) => void) => {
- if (
- isPending ||
- openPopups.current.size > 0 ||
- popupDismissEvents.current.has(getOriginalEvent(event))
- ) {
+ const originalEvent = getOriginalEvent(event);
+ if (!popupDismissEvents.current.has(originalEvent) && openPopups.current.size > 0) {
+ markPopupDismissEvent(originalEvent);
+ const escapeHandlers = Array.from(openPopups.current.values());
+ const onEscapeKeyDown = escapeHandlers[escapeHandlers.length - 1];
+ if (
+ onEscapeKeyDown &&
+ originalEvent instanceof KeyboardEvent &&
+ originalEvent.key === "Escape"
+ ) {
+ onEscapeKeyDown(originalEvent);
+ }
+ event.preventDefault();
+ return;
+ }
+ if (isPending || popupDismissEvents.current.has(originalEvent)) {
event.preventDefault();
return;
}
@@ -75,16 +112,29 @@ const useOverlayIsPending = () => Boolean(React.useContext(OverlayLayerContext)?
const noop = () => undefined;
-const useOverlayPopupRegistration = (open: boolean) => {
+const useOverlayPopupRegistration = (
+ open: boolean,
+ onEscapeKeyDown?: (event: KeyboardEvent) => void
+) => {
const layer = React.useContext(OverlayLayerContext);
const registerPopup = layer?.registerPopup;
const id = React.useId();
+ const escapeHandler = React.useRef(onEscapeKeyDown);
+ const hasEscapeHandler = Boolean(onEscapeKeyDown);
+
+ React.useLayoutEffect(() => {
+ escapeHandler.current = onEscapeKeyDown;
+ });
+
+ const handleEscapeKeyDown = React.useCallback((event: KeyboardEvent) => {
+ escapeHandler.current?.(event);
+ }, []);
React.useLayoutEffect(() => {
if (!open || !registerPopup) return undefined;
- registerPopup(id, true);
+ registerPopup(id, true, hasEscapeHandler ? handleEscapeKeyDown : undefined);
return () => registerPopup(id, false);
- }, [id, open, registerPopup]);
+ }, [id, open, registerPopup, hasEscapeHandler, handleEscapeKeyDown]);
return layer?.markPopupDismissEvent ?? noop;
};