Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.
TypeScript acmeagentsai-agentscertificate-managementdevsecopsenvironment-variableskubernetesopen-sourcepampkipostgresprivate-caprivileged-access-managementsecret-managementsecret-managersecretssecrets-managementsecuritysecurity-toolsvault
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.tsxindex 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.tsnew file mode 100644index 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.tsindex 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;};