Skip to content

An open source design system that's fully customizable and agent ready

TypeScript

fix(core): stop popup triggers from fighting their own light dismiss (#5004) (#5018)

Cindy Zhang009bcb37fa59
diff --git a/.changeset/layer-dismiss-gesture.md b/.changeset/layer-dismiss-gesture.md
new file mode 100644
index 0000000000..eb0fdda9f2
--- /dev/null
+++ b/.changeset/layer-dismiss-gesture.md
@@ -0,0 +1,7 @@
+---
+'@astryxdesign/core': patch
+---
+
+[fix] Popup triggers no longer fight the browser's own light dismiss: pressing the button of an open Selector, MultiSelector, ComplexSelector, DropdownMenu or Popover closes it once instead of closing and reopening, and a clear or status button sitting on the trigger no longer dismisses the popup it belongs to
+
+@cixzhang
diff --git a/packages/core/src/ComplexSelector/ComplexSelector.test.tsx b/packages/core/src/ComplexSelector/ComplexSelector.test.tsx
index 079a234514..73cf3ec02c 100644
--- a/packages/core/src/ComplexSelector/ComplexSelector.test.tsx
+++ b/packages/core/src/ComplexSelector/ComplexSelector.test.tsx
@@ -353,6 +353,7 @@ describe('ComplexSelector', () => {
.closest('[popover]');
expect(popover).not.toBeNull();
+ fireEvent.pointerDown(trigger);
const closeEvent = new Event('toggle');
Object.defineProperty(closeEvent, 'newState', {value: 'closed'});
fireEvent(popover as HTMLElement, closeEvent);
@@ -417,4 +418,35 @@ describe('ComplexSelector popup theme target', () => {
document.querySelector('.astryx-complex-selector-popup'),
).not.toBeNull();
});
+
+ it('stays closed when the trigger click follows its own light dismiss (#5004)', async () => {
+ const user = userEvent.setup();
+ render(
+ <ComplexSelector label="Fruit blend" value="Apple" triggerLabel="Apple">
+ {() => <button type="button">Done</button>}
+ </ComplexSelector>,
+ );
+ const trigger = screen.getByRole('button', {name: 'Fruit blend'});
+ await user.click(trigger);
+ expect(trigger).toHaveAttribute('aria-expanded', 'true');
+
+ // The browser dismissed the popup on pointerup and queued the toggle. When
+ // that event lands before the click — WebKit, or any engine under load —
+ // the click used to read a closed popup and reopen it.
+ fireEvent.pointerDown(trigger);
+ const popover = document.querySelector('[popover]') as HTMLElement;
+ act(() => {
+ popover.dispatchEvent(
+ Object.assign(new Event('toggle'), {
+ oldState: 'open',
+ newState: 'closed',
+ }),
+ );
+ });
+ // Synchronously: the click falls inside the one gesture the guard covers,
+ // as it does in a browser a few milliseconds behind the dismissal.
+ fireEvent.click(trigger);
+
+ expect(trigger).toHaveAttribute('aria-expanded', 'false');
+ });
});
diff --git a/packages/core/src/ComplexSelector/ComplexSelector.tsx b/packages/core/src/ComplexSelector/ComplexSelector.tsx
index c6f27f2777..2ab4af58d4 100644
--- a/packages/core/src/ComplexSelector/ComplexSelector.tsx
+++ b/packages/core/src/ComplexSelector/ComplexSelector.tsx
@@ -373,14 +373,12 @@ export function ComplexSelector<Value>({
.join(' ') || undefined;
const triggerRef = useRef<HTMLButtonElement>(null);
- const lastHideTimeRef = useRef(0);
const [isPending, startTransition] = useTransition();
const [optimisticValue, setOptimisticValue] = useOptimistic(value);
const isBusy = isLoading || isPending;
const handlePopoverHide = useCallback(() => {
- lastHideTimeRef.current = Date.now();
triggerRef.current?.focus();
}, []);
@@ -395,7 +393,7 @@ export function ComplexSelector<Value>({
const isOpen = popover.isOpen;
const handleTriggerClick = useCallback(() => {
- if (isDisabled || Date.now() - lastHideTimeRef.current < 50) {
+ if (isDisabled) {
return;
}
if (popover.isOpen) {
diff --git a/packages/core/src/DropdownMenu/DropdownMenu.test.tsx b/packages/core/src/DropdownMenu/DropdownMenu.test.tsx
index c876adf252..13582f5374 100644
--- a/packages/core/src/DropdownMenu/DropdownMenu.test.tsx
+++ b/packages/core/src/DropdownMenu/DropdownMenu.test.tsx
@@ -10,7 +10,7 @@
*/
import {describe, it, expect, vi, beforeEach} from 'vitest';
-import {render, screen, fireEvent, waitFor} from '@testing-library/react';
+import {render, screen, fireEvent, waitFor, act} from '@testing-library/react';
import userEvent from '@testing-library/user-event';
import {useState} from 'react';
import {DropdownMenu} from './DropdownMenu';
@@ -315,10 +315,7 @@ describe('DropdownMenu', () => {
});
describe('DropdownMenu light-dismiss race', () => {
- it('does not re-open the menu when a click follows a hide within the guard window', () => {
- // Reproduces the iOS Safari race: pointerdown fires light-dismiss before
- // the subsequent click on the trigger; without the guard, the click would
- // immediately re-open the menu in the same tap.
+ function openMenu() {
render(
<DropdownMenu
button={{label: 'Actions'}}
@@ -326,13 +323,50 @@ describe('DropdownMenu light-dismiss race', () => {
data-testid="astryx-dropdown-menu"
/>,
);
-
const trigger = screen.getByTestId('astryx-dropdown-menu');
- fireEvent.click(trigger); // open
- fireEvent.click(trigger); // close (stamps guard)
- fireEvent.click(trigger); // would re-open without guard
+ fireEvent.pointerDown(trigger);
+ fireEvent.click(trigger);
expect(HTMLElement.prototype.showPopover).toHaveBeenCalledTimes(1);
- expect(HTMLElement.prototype.hidePopover).toHaveBeenCalledTimes(1);
+ return trigger;
+ }
+
+ /**
+ * The browser dismisses the menu on pointerup and queues the `toggle` event;
+ * on the engines that lose the race it reaches React before the trigger's
+ * own click, which then reads a closed menu.
+ */
+ function lightDismiss() {
+ const popover = document.querySelector('[popover]') as HTMLElement;
+ act(() => {
+ popover.dispatchEvent(
+ Object.assign(new Event('toggle'), {
+ oldState: 'open',
+ newState: 'closed',
+ }),
+ );
+ });
+ }
+
+ it('does not re-open when the trigger click follows its own light dismiss', () => {
+ const trigger = openMenu();
+
+ fireEvent.pointerDown(trigger);
+ lightDismiss();
+ fireEvent.click(trigger);
+
+ expect(HTMLElement.prototype.showPopover).toHaveBeenCalledTimes(1);
+ });
+
+ it('re-opens on a press of its own after a light dismiss', () => {
+ const trigger = openMenu();
+
+ fireEvent.pointerDown(trigger);
+ lightDismiss();
+ fireEvent.click(trigger);
+ fireEvent.pointerDown(trigger);
+ fireEvent.click(trigger);
+
+ expect(HTMLElement.prototype.showPopover).toHaveBeenCalledTimes(2);
});
});
diff --git a/packages/core/src/DropdownMenu/DropdownMenu.tsx b/packages/core/src/DropdownMenu/DropdownMenu.tsx
index 78600c22d5..105dc1ca29 100644
--- a/packages/core/src/DropdownMenu/DropdownMenu.tsx
+++ b/packages/core/src/DropdownMenu/DropdownMenu.tsx
@@ -37,7 +37,7 @@ import React, {
type ReactNode,
} from 'react';
import * as stylex from '@stylexjs/stylex';
-import {usePopover} from '../Popover/usePopover';
+import {usePopoverInternal} from '../Popover/usePopover';
import {Button, type ButtonProps} from '../Button';
import {Icon} from '../Icon';
@@ -261,14 +261,8 @@ export function DropdownMenu({
const isControlled = controlledIsOpen !== undefined;
const isOpen = isControlled ? controlledIsOpen : internalIsOpen;
- // Track when the menu was last hidden so a near-simultaneous trigger
- // click — e.g. on iOS Safari where pointerdown fires light-dismiss
- // before the trigger's click event — can't immediately re-open it.
- const lastHideTimeRef = useRef(0);
-
// Close menu + return focus to trigger
const handleLayerHide = useCallback(() => {
- lastHideTimeRef.current = Date.now();
onOpenChange?.(false);
if (!isControlled) {
setInternalIsOpen(false);
@@ -294,7 +288,7 @@ export function DropdownMenu({
}
}, [isControlled, onOpenChange]);
- const popover = usePopover({
+ const popover = usePopoverInternal({
onHide: handleLayerHide,
onShow: handleLayerShow,
hasLightDismiss: true,
@@ -422,11 +416,8 @@ export function DropdownMenu({
const handleButtonClick = useCallback(
(e: React.MouseEvent<HTMLButtonElement>) => {
- // If the menu was just closed by light dismiss (e.g. iOS Safari fires
- // pointerdown → hide before the trigger's click), the click would
- // otherwise immediately re-open it. Short-circuit within the guard
- // window.
- if (Date.now() - lastHideTimeRef.current < 50) {
+ // The click that light-dismissed the menu is not a request to reopen it.
+ if (popover.wasJustDismissed()) {
return;
}
onClick?.();
diff --git a/packages/core/src/Field/InputClearButton.test.tsx b/packages/core/src/Field/InputClearButton.test.tsx
index 2f71a8d899..37469d9f2f 100644
--- a/packages/core/src/Field/InputClearButton.test.tsx
+++ b/packages/core/src/Field/InputClearButton.test.tsx
@@ -15,7 +15,7 @@ import {readFileSync} from 'node:fs';
import path from 'node:path';
import {describe, it, expect, vi} from 'vitest';
import {render, screen, fireEvent} from '@testing-library/react';
-import {InputClearButton} from './InputClearButton';
+import {InputClearButton, type InputClearButtonProps} from './InputClearButton';
import {Icon} from '../Icon';
import {defineTheme} from '../theme/defineTheme';
import {generateThemeCSS} from '../theme/generateThemeRules';
@@ -67,6 +67,20 @@ const getGlyph = (): HTMLElement => {
return icon as HTMLElement;
};
+describe('InputClearButton public props', () => {
+ it('keep popup invoker handlers internal', () => {
+ const hasPointerDown: 'onPointerDown' extends keyof InputClearButtonProps
+ ? true
+ : false = false;
+ const hasClickCapture: 'onClickCapture' extends keyof InputClearButtonProps
+ ? true
+ : false = false;
+
+ expect(hasPointerDown).toBe(false);
+ expect(hasClickCapture).toBe(false);
+ });
+});
+
describe('InputClearButton', () => {
it('renders a real button with the given accessible label', () => {
render(<InputClearButton label="Clear" onClick={() => {}} />);
diff --git a/packages/core/src/Field/InputClearButton.tsx b/packages/core/src/Field/InputClearButton.tsx
index 448d252a05..04560bd8ed 100644
--- a/packages/core/src/Field/InputClearButton.tsx
+++ b/packages/core/src/Field/InputClearButton.tsx
@@ -5,8 +5,7 @@
/**
* @file InputClearButton.tsx
* @input Uses React, Button, Icon
- * @output Exports InputClearButton, the shared clear (✕) button rendered by
- * every clearable input in the family.
+ * @output Exports the public InputClearButton and an internal popup-aware variant.
* @position Shared primitive. Every input that renders a clear affordance —
* TextInput, NumberInput, TimeInput, DateInput, DateTimeInput,
* DateRangeInput, Selector, MultiSelector, Typeahead, Tokenizer, FileInput —
@@ -80,12 +79,24 @@ export interface InputClearButtonProps {
iconClassName?: string;
}
-export function InputClearButton({
+interface InternalInputClearButtonProps extends InputClearButtonProps {
+ onPointerDown: React.PointerEventHandler<HTMLElement>;
+ onClickCapture: React.MouseEventHandler<HTMLElement>;
+}
+
+type InputClearButtonRenderProps = InputClearButtonProps &
+ Partial<
+ Pick<InternalInputClearButtonProps, 'onPointerDown' | 'onClickCapture'>
+ >;
+
+function renderInputClearButton({
label,
onClick,
+ onPointerDown,
+ onClickCapture,
xstyle,
iconClassName,
-}: InputClearButtonProps): ReactNode {
+}: InputClearButtonRenderProps): ReactNode {
const {className: iconTargetClassName} = themeProps('input-clear-icon');
const {className: buttonTargetClassName} = themeProps('input-clear-button');
return (
@@ -107,10 +118,23 @@ export function InputClearButton({
/>
}
onClick={onClick}
+ onPointerDown={onPointerDown}
+ onClickCapture={onClickCapture}
isIconOnly
xstyle={[styles.button, xstyle]}
/>
);
}
+export function InputClearButton(props: InputClearButtonProps): ReactNode {
+ return renderInputClearButton(props);
+}
+
+/** Internal variant used while popup-aware clear behavior is rolled out. */
+export function InternalInputClearButton(
+ props: InternalInputClearButtonProps,
+): ReactNode {
+ return renderInputClearButton(props);
+}
+
InputClearButton.displayName = 'InputClearButton';
diff --git a/packages/core/src/Layer/gestureCounter.ts b/packages/core/src/Layer/gestureCounter.ts
new file mode 100644
index 0000000000..972d444703
--- /dev/null
+++ b/packages/core/src/Layer/gestureCounter.ts
@@ -0,0 +1,57 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+'use client';
+
+/**
+ * @file gestureCounter.ts
+ * @input Listens for pointerdown, keydown, and click on the document
+ * @output Exports the current gesture identity and whether its click has run
+ * @position Internal to Layer; used by useLayer to tell a click that belongs
+ * to a dismissing press from a fresh one
+ *
+ * A browser light-dismiss and the trigger's own click come from ONE press, and
+ * which of them React sees first is a race. Comparing timestamps against a
+ * window guesses; counting gestures does not. The counter advances on every
+ * new press or keystroke, so "the click from the gesture that dismissed the
+ * layer" is exactly "the click while the counter still reads what it read at
+ * the dismissal", no matter how long the main thread was blocked in between.
+ */
+
+let gesture = 0;
+let clickedGesture: number | null = null;
+let isListening = false;
+
+function advance() {
+ gesture += 1;
+}
+
+function markClicked() {
+ clickedGesture = gesture;
+}
+
+function listen() {
+ if (isListening || typeof document === 'undefined') {
+ return;
+ }
+ isListening = true;
+ // Capture phase: the count must advance before any handler reads it.
+ document.addEventListener('pointerdown', advance, true);
+ document.addEventListener('keydown', advance, true);
+ // Capture phase observes the click even when a consumer stops propagation.
+ document.addEventListener('click', markClicked, true);
+}
+
+/**
+ * Identifies the user gesture in flight. Two reads returning the same value
+ * happened within one press (or one keystroke).
+ */
+export function currentGesture(): number {
+ listen();
+ return gesture;
+}
+
+/** Whether the click belonging to the current gesture already bubbled. */
+export function currentGestureHasClicked(): boolean {
+ listen();
+ return clickedGesture === gesture;
+}
diff --git a/packages/core/src/Layer/useLayer.test.tsx b/packages/core/src/Layer/useLayer.test.tsx
index fc31eb8322..31d3d1677b 100644
--- a/packages/core/src/Layer/useLayer.test.tsx
+++ b/packages/core/src/Layer/useLayer.test.tsx
@@ -13,12 +13,19 @@ import {describe, it, expect, vi, afterEach} from 'vitest';
import {render, act, fireEvent, waitFor} from '@testing-library/react';
import userEvent from '@testing-library/user-event';
import * as stylex from '@stylexjs/stylex';
-import {useLayer, getPositionTryFallbacks} from './useLayer';
+import {
+ useKeepLayerOpenProps,
+ useLayer,
+ useLayerInternal,
+ getPositionTryFallbacks,
+} from './useLayer';
import {typeScaleVars} from '../theme/tokens.stylex';
import type {
LayerPlacement,
LayerAlignment,
ContextRenderProps,
+ ContextLayerReturn,
+ FixedLayerReturn,
} from './useLayer';
function mockCSSStyleDeclaration(
@@ -921,3 +928,257 @@ describe('useLayer context positioning', () => {
expect(style).not.toContain('position-anchor');
});
});
+
+describe('useLayer public return types', () => {
+ it('keeps dismissal helpers internal', () => {
+ const contextHasKeepOpenProps: 'keepOpenProps' extends keyof ContextLayerReturn
+ ? true
+ : false = false;
+ const fixedHasKeepOpenProps: 'keepOpenProps' extends keyof FixedLayerReturn
+ ? true
+ : false = false;
+ const contextHasGuard: 'wasJustDismissed' extends keyof ContextLayerReturn
+ ? true
+ : false = false;
+ const fixedHasGuard: 'wasJustDismissed' extends keyof FixedLayerReturn
+ ? true
+ : false = false;
+
+ expect(contextHasKeepOpenProps).toBe(false);
+ expect(fixedHasKeepOpenProps).toBe(false);
+ expect(contextHasGuard).toBe(false);
+ expect(fixedHasGuard).toBe(false);
+ });
+});
+
+describe('internal keep-open props (controls on the trigger, #5004)', () => {
+ function ClearableTriggerHarness() {
+ const layer = useLayer({mode: 'context'});
+ const keepOpenProps = useKeepLayerOpenProps(layer.id, layer.isOpen);
+ return (
+ <>
+ <button type="button" ref={layer.ref} onClick={layer.show}>
+ Trigger
+ </button>
+ <button type="button" {...keepOpenProps}>
+ Clear
+ </button>
+ {layer.render(<span>Layer content</span>, {placement: 'below'})}
+ </>
+ );
+ }
+
+ it('names the control an invoker for the duration of the press', async () => {
+ const user = userEvent.setup();
+ const {container, getByRole} = render(<ClearableTriggerHarness />);
+ const clear = getByRole('button', {name: 'Clear'});
+
+ await user.click(getByRole('button', {name: 'Trigger'}));
+ const popover = container.querySelector('[popover]') as HTMLElement;
+
+ await user.pointer({keys: '[MouseLeft>]', target: clear});
+ expect(clear.getAttribute('popovertarget')).toBe(popover.id);
+
+ await user.pointer({keys: '[/MouseLeft]', target: clear});
+ expect(clear).not.toHaveAttribute('popovertarget');
+ });
+
+ it('takes the invoker off when the press ends in pointercancel', async () => {
+ const user = userEvent.setup();
+ const {container, getByRole} = render(<ClearableTriggerHarness />);
+ const clear = getByRole('button', {name: 'Clear'});
+
+ await user.click(getByRole('button', {name: 'Trigger'}));
+ const popover = container.querySelector('[popover]') as HTMLElement;
+
+ await user.pointer({keys: '[MouseLeft>]', target: clear});
+ expect(clear.getAttribute('popovertarget')).toBe(popover.id);
+
+ // A touch the browser claims — for a scroll, for the platform's long-press
+ // menu — ends here, and no pointerup ever arrives.
+ await act(async () => {
+ document.dispatchEvent(new Event('pointercancel'));
+ await new Promise(resolve => {
+ window.setTimeout(resolve, 0);
+ });
+ });
+
+ expect(clear).not.toHaveAttribute('popovertarget');
+ });
+
+ it('leaves the control alone while the layer is closed', async () => {
+ const user = userEvent.setup();
+ const {getByRole} = render(<ClearableTriggerHarness />);
+ const clear = getByRole('button', {name: 'Clear'});
+
+ await user.click(clear);
+
+ expect(clear).not.toHaveAttribute('popovertarget');
+ });
+
+ it("cancels the invoker's own toggle so the press cannot close the layer", async () => {
+ const user = userEvent.setup();
+ const {container, getByRole} = render(<ClearableTriggerHarness />);
+ await user.click(getByRole('button', {name: 'Trigger'}));
+ const popover = container.querySelector('[popover]') as HTMLElement;
+ const clear = getByRole('button', {name: 'Clear'});
+
+ const click = new MouseEvent('click', {bubbles: true, cancelable: true});
+ await act(async () => {
+ clear.setAttribute('popovertarget', popover.id);
+ clear.dispatchEvent(click);
+ });
+
+ expect(click.defaultPrevented).toBe(true);
+ expect(clear).not.toHaveAttribute('popovertarget');
+ });
+});
+
+describe('wasJustDismissed (light dismiss vs. the trigger click, #5004)', () => {
+ function GuardedTriggerHarness() {
+ const layer = useLayerInternal({mode: 'context'});
+ return (
+ <>
+ <button
+ type="button"
+ ref={layer.ref}
+ onClick={() => {
+ if (layer.wasJustDismissed()) {
+ return;
+ }
+ if (layer.isOpen) {
+ layer.hide();
+ } else {
+ layer.show();
+ }
+ }}>
+ Trigger
+ </button>
+ <span data-testid="state">{layer.isOpen ? 'open' : 'closed'}</span>
+ {layer.render(<span>Layer content</span>, {placement: 'below'})}
+ </>
+ );
+ }
+
+ /**
+ * The browser closing the layer itself: it hides the element and queues a
+ * `toggle` event, which is what reaches React — before the click, on the
+ * engines that lose the race.
+ */
+ function lightDismiss(container: HTMLElement) {
+ const popover = container.querySelector('[popover]') as HTMLElement;
+ act(() => {
+ popover.dispatchEvent(
+ Object.assign(new Event('toggle'), {
+ oldState: 'open',
+ newState: 'closed',
+ }),
+ );
+ });
+ }
+
+ it('absorbs the trigger click that follows a light dismiss', async () => {
+ const user = userEvent.setup();
+ const {container, getByRole, getByTestId} = render(
+ <GuardedTriggerHarness />,
+ );
+ const trigger = getByRole('button', {name: 'Trigger'});
+
+ await user.click(trigger);
+ expect(getByTestId('state')).toHaveTextContent('open');
+
+ // The next press reaches the browser dismissal before its click.
+ fireEvent.pointerDown(trigger);
+ lightDismiss(container);
+ fireEvent.click(trigger);
+
+ expect(getByTestId('state')).toHaveTextContent('closed');
+ });
+
+ it('acts on a deliberate second press', async () => {
+ const user = userEvent.setup();
+ const {container, getByRole, getByTestId} = render(
+ <GuardedTriggerHarness />,
+ );
+ const trigger = getByRole('button', {name: 'Trigger'});
+
+ await user.click(trigger);
+ fireEvent.pointerDown(trigger);
+ lightDismiss(container);
+ fireEvent.click(trigger);
+ // A press of its own — a new gesture, however soon it lands.
+ await user.click(trigger);
+
+ expect(getByTestId('state')).toHaveTextContent('open');
+ });
+
+ it('leaves a programmatic hide unguarded', async () => {
+ const user = userEvent.setup();
+ const {getByRole, getByTestId} = render(<GuardedTriggerHarness />);
+ const trigger = getByRole('button', {name: 'Trigger'});
+
+ // Three presses with no browser-initiated close between them.
+ await user.click(trigger);
+ await user.click(trigger);
+ await user.click(trigger);
+
+ expect(getByTestId('state')).toHaveTextContent('open');
+ });
+
+ it('acts on a synthesized click after a stopped click-first dismissal', async () => {
+ const user = userEvent.setup();
+ const {container, getByRole, getByTestId} = render(
+ <GuardedTriggerHarness />,
+ );
+ const trigger = getByRole('button', {name: 'Trigger'});
+
+ await user.click(trigger);
+ fireEvent.pointerDown(document.body);
+ document.body.addEventListener('click', event => event.stopPropagation(), {
+ once: true,
+ });
+ fireEvent.click(document.body);
+ lightDismiss(container);
+ expect(getByTestId('state')).toHaveTextContent('closed');
+
+ // Chromium delivers the dismissing click before the queued toggle. A later
+ // bare click is a new activation even though it has no pointerdown.
+ act(() => {
+ trigger.click();
+ });
+
+ expect(getByTestId('state')).toHaveTextContent('open');
+ });
+
+ /** A trigger that calls show()/hide() directly, checking nothing. */
+ function PlainTriggerHarness() {
+ const layer = useLayerInternal({mode: 'context'});
+ return (
+ <>
+ <button
+ type="button"
+ ref={layer.ref}
+ onClick={() => (layer.isOpen ? layer.hide() : layer.show())}>
+ Trigger
+ </button>
+ <span data-testid="state">{layer.isOpen ? 'open' : 'closed'}</span>
+ {layer.render(<span>Layer content</span>, {placement: 'below'})}
+ </>
+ );
+ }
+
+ it('absorbs the click for a trigger that never calls wasJustDismissed', async () => {
+ const user = userEvent.setup();
+ const {container, getByRole, getByTestId} = render(<PlainTriggerHarness />);
+ const trigger = getByRole('button', {name: 'Trigger'});
+
+ await user.click(trigger);
+ expect(getByTestId('state')).toHaveTextContent('open');
+
+ fireEvent.pointerDown(trigger);
+ lightDismiss(container);
+ fireEvent.click(trigger);
+
+ expect(getByTestId('state')).toHaveTextContent('closed');
+ });
+});
diff --git a/packages/core/src/Layer/useLayer.tsx b/packages/core/src/Layer/useLayer.tsx
index 20b50aa82e..02ecaf523d 100644
--- a/packages/core/src/Layer/useLayer.tsx
+++ b/packages/core/src/Layer/useLayer.tsx
@@ -5,7 +5,7 @@
/**
* @file useLayer.tsx
* @input Uses React hooks, Popover API, CSS anchor positioning, typography tokens
- * @output Exports useLayer hook for layer positioning and visibility
+ * @output Exports the public useLayer hook plus internal trigger helpers.
* @position Core layer utility; used by useHoverCard, useTooltip, etc.
*
* SYNC: When modified, update:
@@ -18,6 +18,7 @@ import React, {
useCallback,
useEffect,
useId,
+ useMemo,
useRef,
useState,
type ReactNode,
@@ -27,6 +28,7 @@ import * as stylex from '@stylexjs/stylex';
import type {StyleXStyles} from '@stylexjs/stylex';
import {createPortal} from 'react-dom';
import {addAnchorName, removeAnchorName} from './anchorName';
+import {currentGesture, currentGestureHasClicked} from './gestureCounter';
import {resolveLayerPortalTarget} from './layerHost';
import {typeScaleVars, typographyVars} from '../theme/tokens.stylex';
import {overlayPaddingReset} from '../Layout/padding.stylex';
@@ -72,6 +74,18 @@ const styles = stylex.create({
}),
});
+/**
+ * Props for a control that sits on the trigger but must not dismiss the layer.
+ */
+interface KeepLayerOpenProps {
+ onPointerDown: React.PointerEventHandler<HTMLElement>;
+ /**
+ * Capture phase, so spreading these props never collides with the control's
+ * own `onClick`.
+ */
+ onClickCapture: React.MouseEventHandler<HTMLElement>;
+}
+
/**
* Position placement relative to anchor.
* Logical: start/end resolve against the popover's own inherited direction
@@ -326,6 +340,13 @@ export interface FixedLayerReturn {
render: (children: ReactNode, props: FixedRenderProps) => ReactNode;
}
+interface InternalLayerFields {
+ wasJustDismissed: () => boolean;
+}
+
+type InternalContextLayerReturn = ContextLayerReturn & InternalLayerFields;
+type InternalFixedLayerReturn = FixedLayerReturn & InternalLayerFields;
+
function toCssLength(value: number | string): string {
return typeof value === 'number' ? `${value}px` : value;
}
@@ -437,6 +458,51 @@ export function getPositionTryFallbacks(
return `${flips}, ${same} span-top, ${same} span-bottom, ${opposite} span-top, ${opposite} span-bottom`;
}
+/**
+ * Internal props for controls that sit beside an open layer. This stays out of
+ * the public useLayer/usePopover return types until the input family adopts it.
+ */
+export function useKeepLayerOpenProps(
+ id: string,
+ isOpen: boolean,
+): KeepLayerOpenProps {
+ const isOpenRef = useRef(isOpen);
+ isOpenRef.current = isOpen;
+
+ return useMemo(
+ () => ({
+ onPointerDown: (event: React.PointerEvent<HTMLElement>) => {
+ if (!isOpenRef.current) {
+ return;
+ }
+ // The browser reads the invoker relationship at both ends of the press.
+ const control = event.currentTarget;
+ const doc = control.ownerDocument;
+ control.setAttribute('popovertarget', id);
+ const onPressEnd = () => {
+ doc.removeEventListener('pointerup', onPressEnd);
+ doc.removeEventListener('pointercancel', onPressEnd);
+ // Light dismiss runs as the pointerup default action after listeners.
+ doc.defaultView?.setTimeout(() => {
+ control.removeAttribute('popovertarget');
+ }, 0);
+ };
+ doc.addEventListener('pointerup', onPressEnd);
+ doc.addEventListener('pointercancel', onPressEnd);
+ },
+ onClickCapture: (event: React.MouseEvent<HTMLElement>) => {
+ const control = event.currentTarget;
+ if (control.hasAttribute('popovertarget')) {
+ // Being an invoker would otherwise toggle the layer shut.
+ event.preventDefault();
+ control.removeAttribute('popovertarget');
+ }
+ },
+ }),
+ [id],
+ );
+}
+
/**
* Core layer hook that handles popover behavior and positioning.
*
@@ -451,11 +517,9 @@ export function getPositionTryFallbacks(
* {layer.render(<Content />, { placement: 'above', alignment: 'center' })}
* ```
*/
-export function useLayer(options: ContextLayerOptions): ContextLayerReturn;
-export function useLayer(options: FixedLayerOptions): FixedLayerReturn;
-export function useLayer(
+function useLayerImplementation(
options: ContextLayerOptions | FixedLayerOptions,
-): ContextLayerReturn | FixedLayerReturn {
+): InternalContextLayerReturn | InternalFixedLayerReturn {
const {mode, onShow, onHide, lightDismiss = false} = options;
const lazyMount = mode === 'context' ? (options.lazyMount ?? false) : false;
const id = useId();
@@ -485,6 +549,17 @@ export function useLayer(
// stale-closure reads of the previous isOpen value.
const isOpenRef = useRef(false);
+ // The gesture during which the browser last closed this layer on its own.
+ // Read through wasJustDismissed by triggers deciding whether a click is
+ // theirs to act on.
+ const dismissedByGestureRef = useRef<number | null>(null);
+ const forgetDismissalRef = useRef<(() => void) | null>(null);
+
+ const wasJustDismissed = useCallback(() => {
+ const gesture = currentGesture();
+ return dismissedByGestureRef.current === gesture;
+ }, []);
+
const showPopoverElement = useCallback((popover: HTMLElement) => {
// Finding infra-4: the Popover API is unsupported on Safari <17 and
// Firefox <125. On those browsers `showPopover` does not exist, so fall
@@ -548,6 +623,11 @@ export function useLayer(
}, [mode, lazyMount]);
const show = useCallback(() => {
+ // Every caller lands here, so this is where the dismissing press is
+ // absorbed: opening now would reopen the popup that same press closed.
+ if (wasJustDismissed()) {
+ return;
+ }
// A context popover left over until React commits a previous hide must not
// be reopened. The synchronous mount ref is the source of truth.
const candidate = popoverRef.current;
@@ -569,12 +649,18 @@ export function useLayer(
requestContextMount,
showPopoverElement,
isCurrentContextPopover,
+ wasJustDismissed,
]);
const hide = useCallback(() => {
pendingShowRef.current = false;
if (isOpenRef.current) {
const el = popoverRef.current;
+ // Clear the open state BEFORE hiding: hidePopover fires `toggle`, and
+ // the reconciler below reads this ref to tell the browser's own
+ // dismissals from ours.
+ openedPopoverRef.current = null;
+ isOpenRef.current = false;
// See finding infra-4 note in `show`: mirror the same guard on hide so
// unsupported browsers degrade gracefully instead of throwing.
if (el) {
@@ -584,8 +670,6 @@ export function useLayer(
el.style.display = 'none';
}
}
- openedPopoverRef.current = null;
- isOpenRef.current = false;
setIsOpen(false);
onHide?.();
}
@@ -610,6 +694,51 @@ export function useLayer(
}
: undefined;
+ // Arm only when the dismissing gesture's click is still ahead of us. Some
+ // engines deliver click first; in that order there is nothing left to absorb.
+ const rememberDismissal = useCallback((doc: Document) => {
+ forgetDismissalRef.current?.();
+ if (currentGestureHasClicked()) {
+ return;
+ }
+ dismissedByGestureRef.current = currentGesture();
+ const view = doc.defaultView;
+ let forgetTimer: number | null = null;
+ const forget = () => {
+ dismissedByGestureRef.current = null;
+ doc.removeEventListener('click', scheduleForget, true);
+ if (forgetTimer !== null) {
+ view?.clearTimeout(forgetTimer);
+ forgetTimer = null;
+ }
+ if (forgetDismissalRef.current === forget) {
+ forgetDismissalRef.current = null;
+ }
+ };
+ const scheduleForget = () => {
+ doc.removeEventListener('click', scheduleForget, true);
+ // The next task keeps the dismissal armed through React's click handler.
+ if (view) {
+ forgetTimer = view.setTimeout(() => {
+ forgetTimer = null;
+ if (forgetDismissalRef.current === forget) {
+ forget();
+ }
+ }, 0);
+ } else {
+ forget();
+ }
+ };
+ doc.addEventListener('click', scheduleForget, true);
+ forgetDismissalRef.current = forget;
+ }, []);
+
+ useEffect(() => {
+ // Install capture-phase gesture tracking before the first interaction.
+ currentGesture();
+ return () => forgetDismissalRef.current?.();
+ }, []);
+
// Reconcile browser-initiated closes (light-dismiss, popover="auto" stack
// eviction). These are the only cases where the DOM mutates without going
// through our show/hide — we sync React state back to match.
@@ -626,12 +755,15 @@ export function useLayer(
if (toggleEvent.newState === 'closed' && isOpenRef.current) {
openedPopoverRef.current = null;
isOpenRef.current = false;
+ rememberDismissal(
+ (e.currentTarget as HTMLElement | null)?.ownerDocument ?? document,
+ );
setIsOpen(false);
onHide?.();
clearContextMount();
}
},
- [onHide, clearContextMount],
+ [onHide, clearContextMount, rememberDismissal],
);
// Ref callback for popover element — sets up the `toggle` listener.
@@ -872,6 +1004,7 @@ export function useLayer(
show,
hide,
isOpen,
+ wasJustDismissed,
id,
render: renderContext,
};
@@ -882,7 +1015,30 @@ export function useLayer(
show,
hide,
isOpen,
+ wasJustDismissed,
id,
render: renderFixed,
};
}
+
+export function useLayer(options: ContextLayerOptions): ContextLayerReturn;
+export function useLayer(options: FixedLayerOptions): FixedLayerReturn;
+export function useLayer(
+ options: ContextLayerOptions | FixedLayerOptions,
+): ContextLayerReturn | FixedLayerReturn {
+ const {wasJustDismissed: _, ...layer} = useLayerImplementation(options);
+ return layer;
+}
+
+/** @internal Shared with usePopover; not exported from the package barrel. */
+export function useLayerInternal(
+ options: ContextLayerOptions,
+): InternalContextLayerReturn;
+export function useLayerInternal(
+ options: FixedLayerOptions,
+): InternalFixedLayerReturn;
+export function useLayerInternal(
+ options: ContextLayerOptions | FixedLayerOptions,
+): InternalContextLayerReturn | InternalFixedLayerReturn {
+ return useLayerImplementation(options);
+}
diff --git a/packages/core/src/MultiSelector/MultiSelector.test.tsx b/packages/core/src/MultiSelector/MultiSelector.test.tsx
index 1718dc6481..ca801038bd 100644
--- a/packages/core/src/MultiSelector/MultiSelector.test.tsx
+++ b/packages/core/src/MultiSelector/MultiSelector.test.tsx
@@ -2660,4 +2660,38 @@ describe('MultiSelector popup theme target', () => {
expect(popup).not.toBe(layer);
expect(layer.contains(popup)).toBe(true);
});
+
+ it('stays closed when the trigger click follows its own light dismiss (#5004)', async () => {
+ const user = userEvent.setup();
+ render(
+ <MultiSelector
+ label="Fruit"
+ options={['Apple', 'Banana', 'Cherry']}
+ value={[]}
+ onChange={() => {}}
+ />,
+ );
+ const trigger = screen.getByRole('combobox');
+ await user.click(trigger);
+ expect(trigger).toHaveAttribute('aria-expanded', 'true');
+
+ // The browser dismissed the popup on pointerup and queued the toggle. When
+ // that event lands before the click — WebKit, or any engine under load —
+ // the click used to read a closed popup and reopen it.
+ fireEvent.pointerDown(trigger);
+ const popover = document.querySelector('[popover]') as HTMLElement;
+ act(() => {
+ popover.dispatchEvent(
+ Object.assign(new Event('toggle'), {
+ oldState: 'open',
+ newState: 'closed',
+ }),
+ );
+ });
+ // Synchronously: the click falls inside the one gesture the guard covers,
+ // as it does in a browser a few milliseconds behind the dismissal.
+ fireEvent.click(trigger);
+
+ expect(trigger).toHaveAttribute('aria-expanded', 'false');
+ });
});
diff --git a/packages/core/src/MultiSelector/MultiSelector.tsx b/packages/core/src/MultiSelector/MultiSelector.tsx
index 579c4d4377..56ee792200 100644
--- a/packages/core/src/MultiSelector/MultiSelector.tsx
+++ b/packages/core/src/MultiSelector/MultiSelector.tsx
@@ -28,18 +28,19 @@ import React, {
type ReactNode,
} from 'react';
import * as stylex from '@stylexjs/stylex';
-import {usePopover} from '../Popover/usePopover';
+import {usePopoverInternal} from '../Popover/usePopover';
import {useTooltip} from '../Tooltip';
import {Icon, renderIconSlot, type IconType} from '../Icon';
import type {IconName} from '../Icon';
import {
Field,
- InputClearButton,
inputStatusBorderStyles,
inputStatusHoverShadowStyles,
inputWrapperStyles,
type FieldStatusVariant,
} from '../Field';
+import {useKeepLayerOpenProps} from '../Layer/useLayer';
+import {InternalInputClearButton} from '../Field/InputClearButton';
import {Divider} from '../Divider';
import {Spinner} from '../Spinner';
import {PanelSearchInput} from '../Field/PanelSearchInput';
@@ -943,7 +944,7 @@ export function MultiSelector<T extends MultiSelectorOptionType>({
triggerRef.current?.focus();
}, [announce]);
- const popover = usePopover({
+ const popover = usePopoverInternal({
hasLightDismiss: true,
onHide: handleLayerHide,
hasCloseButton: false,
@@ -955,6 +956,7 @@ export function MultiSelector<T extends MultiSelectorOptionType>({
// `usePopover` owns — not on the scrolling list inside it.
surfaceTarget: 'multi-selector-popup',
});
+ const keepOpenProps = useKeepLayerOpenProps(popover.id, popover.isOpen);
// Open dropdown on mount when isDefaultOpen is true
useEffect(() => {
@@ -1162,6 +1164,7 @@ export function MultiSelector<T extends MultiSelectorOptionType>({
onKeyDown,
onItemMouseEnter,
} = useMultiCombobox({
+ wasJustDismissed: popover.wasJustDismissed,
selectableItems: sortedItems,
isDisabled,
isOpen: popover.isOpen,
@@ -1704,7 +1707,8 @@ export function MultiSelector<T extends MultiSelectorOptionType>({
))}
{isBusy && <Spinner size="sm" />}
{hasClear && value.length > 0 && !isDisabled && (
- <InputClearButton
+ <InternalInputClearButton
+ {...keepOpenProps}
label={t('@astryx.multiSelector.clearAll', {label})}
onClick={handleClear}
iconClassName={stableClassName('multi-selector-clear-icon')}
@@ -1723,6 +1727,7 @@ export function MultiSelector<T extends MultiSelectorOptionType>({
type="button"
aria-label={t(STATUS_BUTTON_LABEL_KEY[status.type])}
aria-describedby={statusTooltip.describedBy}
+ {...keepOpenProps}
onClick={e => e.stopPropagation()}
{...stylex.props(
focusOutlineStyles.focusVisible,
diff --git a/packages/core/src/MultiSelector/hooks.ts b/packages/core/src/MultiSelector/hooks.ts
index 64977c5f1f..cd0644b2f9 100644
--- a/packages/core/src/MultiSelector/hooks.ts
+++ b/packages/core/src/MultiSelector/hooks.ts
@@ -34,6 +34,12 @@ interface UseMultiComboboxOptions {
* The Delete/Backspace clear path is skipped when false.
*/
hasValue?: boolean;
+ /**
+ * Whether the browser's light dismiss just closed the popup. The trigger
+ * click that follows belongs to that same press, so acting on it would
+ * reopen the popup the user just closed.
+ */
+ wasJustDismissed?: () => boolean;
listboxId: string;
}
@@ -62,6 +68,7 @@ export function useMultiCombobox({
onToggle,
onClear,
hasValue = false,
+ wasJustDismissed,
listboxId,
}: UseMultiComboboxOptions): UseMultiComboboxResult {
const [highlightedIndex, setHighlightedIndex] = useState<number>(-1);
@@ -87,7 +94,7 @@ export function useMultiCombobox({
}, [onClose]);
const onTriggerClick = useCallback(() => {
- if (isDisabled) {
+ if (isDisabled || wasJustDismissed?.()) {
return;
}
if (isOpen) {
@@ -98,7 +105,7 @@ export function useMultiCombobox({
setHighlightedIndex(0);
}
}
- }, [isDisabled, isOpen, onOpen, closeAndReset, hasSearch]);
+ }, [isDisabled, wasJustDismissed, isOpen, onOpen, closeAndReset, hasSearch]);
const onItemMouseEnter = useCallback(
(item: MultiSelectorOptionData, index: number) => {
diff --git a/packages/core/src/Popover/Popover.test.tsx b/packages/core/src/Popover/Popover.test.tsx
index d688d27530..8a31f53769 100644
--- a/packages/core/src/Popover/Popover.test.tsx
+++ b/packages/core/src/Popover/Popover.test.tsx
@@ -14,6 +14,7 @@ import {describe, it, expect, vi, beforeAll, afterAll} from 'vitest';
import {render, screen, fireEvent} from '@testing-library/react';
import React, {useRef} from 'react';
import {Popover} from './Popover';
+import type {UsePopoverReturn} from './usePopover';
import {Dialog} from '../Dialog';
import {SegmentedControl, SegmentedControlItem} from '../SegmentedControl';
@@ -55,6 +56,19 @@ afterAll(() => {
(HTMLElement.prototype as any).matches = originalMatches;
});
+describe('usePopover public return type', () => {
+ it('keeps dismissal internals out of the public contract', () => {
+ const hasKeepOpenProps: 'keepOpenProps' extends keyof UsePopoverReturn
+ ? true
+ : false = false;
+ const hasDismissalGuard: 'wasJustDismissed' extends keyof UsePopoverReturn
+ ? true
+ : false = false;
+ expect(hasKeepOpenProps).toBe(false);
+ expect(hasDismissalGuard).toBe(false);
+ });
+});
+
describe('Popover', () => {
it('renders trigger element', () => {
render(
diff --git a/packages/core/src/Popover/Popover.tsx b/packages/core/src/Popover/Popover.tsx
index e676dd2304..ba082561fd 100644
--- a/packages/core/src/Popover/Popover.tsx
+++ b/packages/core/src/Popover/Popover.tsx
@@ -322,16 +322,12 @@ export function Popover({
}: PopoverProps): ReactElement {
const wrapperRef = useRef<HTMLDivElement>(null);
const isControlled = isOpen !== undefined;
- // Track when the popover was last hidden by light dismiss to prevent
- // the trigger click from immediately re-opening it.
- const lastHideTimeRef = useRef(0);
const handlePopoverShow = useCallback(() => {
onOpenChange?.(true);
}, [onOpenChange]);
const handlePopoverHide = useCallback(() => {
- lastHideTimeRef.current = Date.now();
onOpenChange?.(false);
}, [onOpenChange]);
@@ -353,11 +349,7 @@ export function Popover({
if (!isEnabled) {
return;
}
- // If the popover was just closed by light dismiss (clicking outside),
- // the trigger click fires in the same event — skip re-opening.
- if (Date.now() - lastHideTimeRef.current < 50) {
- return;
- }
+ // `toggle` absorbs a click that belongs to its own light dismiss.
popover.toggle();
}, [isEnabled, popover]);
diff --git a/packages/core/src/Popover/usePopover.tsx b/packages/core/src/Popover/usePopover.tsx
index 00ce13d9b0..d332a1c3f5 100644
--- a/packages/core/src/Popover/usePopover.tsx
+++ b/packages/core/src/Popover/usePopover.tsx
@@ -5,7 +5,7 @@
/**
* @file usePopover.tsx
* @input Uses useLayer, useFocusTrap, React hooks
- * @output Exports usePopover hook for popover dialogs with focus trapping
+ * @output Exports usePopover and a package-internal trigger-aware variant.
* @position Higher-level layer utility; used by DatePicker, Combobox, etc.
*
* Combines popover layer behavior with focus trap for dialog-like popovers.
@@ -17,7 +17,7 @@
import React, {useCallback, useEffect, useRef, type ReactNode} from 'react';
import * as stylex from '@stylexjs/stylex';
-import {useLayer, type ContextRenderProps} from '../Layer/useLayer';
+import {useLayerInternal, type ContextRenderProps} from '../Layer/useLayer';
import {useFocusTrap} from '../hooks/useFocusTrap';
import {LayerDepthProvider} from '../Layer/LayerDepthContext';
import type {StyleXStyles} from '@stylexjs/stylex';
@@ -283,6 +283,10 @@ export interface UsePopoverReturn {
};
}
+interface InternalUsePopoverReturn extends UsePopoverReturn {
+ wasJustDismissed: () => boolean;
+}
+
/**
* Hook for creating popover dialogs with focus trapping.
*
@@ -323,7 +327,9 @@ export interface UsePopoverReturn {
* }
* ```
*/
-export function usePopover(options: UsePopoverOptions = {}): UsePopoverReturn {
+function usePopoverImplementation(
+ options: UsePopoverOptions = {},
+): InternalUsePopoverReturn {
const {
onShow,
onHide,
@@ -351,7 +357,7 @@ export function usePopover(options: UsePopoverOptions = {}): UsePopoverReturn {
const skipAutoFocusRef = useRef(false);
// Core layer for popover positioning
- const layer = useLayer({
+ const layer = useLayerInternal({
mode: 'context',
lightDismiss: hasLightDismiss,
onShow,
@@ -400,6 +406,9 @@ export function usePopover(options: UsePopoverOptions = {}): UsePopoverReturn {
// Toggle function
const toggle = useCallback(() => {
+ if (layer.wasJustDismissed()) {
+ return;
+ }
if (layer.isOpen) {
layer.hide();
} else {
@@ -491,9 +500,22 @@ export function usePopover(options: UsePopoverOptions = {}): UsePopoverReturn {
show,
hide: layer.hide,
toggle,
+ wasJustDismissed: layer.wasJustDismissed,
isOpen: layer.isOpen,
id: layer.id,
render,
triggerProps,
};
}
+
+export function usePopover(options: UsePopoverOptions = {}): UsePopoverReturn {
+ const {wasJustDismissed: _, ...popover} = usePopoverImplementation(options);
+ return popover;
+}
+
+/** @internal Used by trigger components; not exported from package barrels. */
+export function usePopoverInternal(
+ options: UsePopoverOptions = {},
+): InternalUsePopoverReturn {
+ return usePopoverImplementation(options);
+}
diff --git a/packages/core/src/Selector/Selector.test.tsx b/packages/core/src/Selector/Selector.test.tsx
index c9189a5b62..899a615999 100644
--- a/packages/core/src/Selector/Selector.test.tsx
+++ b/packages/core/src/Selector/Selector.test.tsx
@@ -3305,6 +3305,41 @@ describe('Selector popup theme target', () => {
expect(popup?.querySelector('[role="listbox"]')).not.toBeNull();
},
);
+
+ it('stays closed when the trigger click follows its own light dismiss (#5004)', async () => {
+ const user = userEvent.setup();
+ render(
+ <Selector
+ label="Fruit"
+ options={OPTIONS}
+ value="Banana"
+ onChange={() => {}}
+ placement="below"
+ />,
+ );
+ const trigger = screen.getByRole('combobox');
+ await user.click(trigger);
+ expect(trigger).toHaveAttribute('aria-expanded', 'true');
+
+ // The browser dismissed the popup on pointerup and queued the toggle. When
+ // that event lands before the click — WebKit, or any engine under load —
+ // the click used to read a closed popup and reopen it.
+ fireEvent.pointerDown(trigger);
+ const popover = document.querySelector('[popover]') as HTMLElement;
+ act(() => {
+ popover.dispatchEvent(
+ Object.assign(new Event('toggle'), {
+ oldState: 'open',
+ newState: 'closed',
+ }),
+ );
+ });
+ // Synchronously: the click falls inside the one gesture the guard covers,
+ // as it does in a browser a few milliseconds behind the dismissal.
+ fireEvent.click(trigger);
+
+ expect(trigger).toHaveAttribute('aria-expanded', 'false');
+ });
});
describe('Selector option-row theme target', () => {
diff --git a/packages/core/src/Selector/Selector.tsx b/packages/core/src/Selector/Selector.tsx
index 21deaaf47e..3dbb9d4c6b 100644
--- a/packages/core/src/Selector/Selector.tsx
+++ b/packages/core/src/Selector/Selector.tsx
@@ -29,7 +29,7 @@ import React, {
type ReactNode,
} from 'react';
import * as stylex from '@stylexjs/stylex';
-import {usePopover} from '../Popover/usePopover';
+import {usePopoverInternal} from '../Popover/usePopover';
import {useTooltip} from '../Tooltip';
import {Icon, renderIconSlot, type IconType} from '../Icon';
import {useIndicator} from '../Indicator';
@@ -37,7 +37,6 @@ import type {IndicatorPosition} from '../Indicator';
import type {IconName} from '../Icon';
import {
Field,
- InputClearButton,
inputStatusBorderStyles,
inputStatusHoverShadowStyles,
inputWrapperStyles,
@@ -45,7 +44,8 @@ import {
} from '../Field';
import {Divider} from '../Divider';
import {layerAnimations} from '../Layer/layerAnimations.stylex';
-import type {LayerPlacement} from '../Layer/useLayer';
+import {useKeepLayerOpenProps, type LayerPlacement} from '../Layer/useLayer';
+import {InternalInputClearButton} from '../Field/InputClearButton';
import {Spinner} from '../Spinner';
import {PanelSearchInput} from '../Field/PanelSearchInput';
import {useAnnounce} from '../hooks/useAnnounce';
@@ -957,7 +957,7 @@ export function Selector<T extends SelectorOptionType>(
triggerRef.current?.focus();
}, [announce]);
- const popover = usePopover({
+ const popover = usePopoverInternal({
onHide: handleLayerHide,
hasLightDismiss: true,
hasCloseButton: false,
@@ -969,6 +969,7 @@ export function Selector<T extends SelectorOptionType>(
// `usePopover` owns — not on the scrolling list inside it.
surfaceTarget: 'selector-popup',
});
+ const keepOpenProps = useKeepLayerOpenProps(popover.id, popover.isOpen);
// Open dropdown on mount when isDefaultOpen is true
useEffect(() => {
@@ -1122,6 +1123,7 @@ export function Selector<T extends SelectorOptionType>(
onItemMouseEnter,
} = useCombobox({
selectableItems: filteredItems,
+ wasJustDismissed: popover.wasJustDismissed,
// The optimistic value, not the raw prop: with a pending changeAction the
// prop still holds the old selection, so the popup would open with the
// highlight on it and Delete/Backspace could clear a value the action has
@@ -1652,7 +1654,8 @@ export function Selector<T extends SelectorOptionType>(
)}
{isBusy && <Spinner size="sm" />}
{hasClear && value != null && !isDisabled && (
- <InputClearButton
+ <InternalInputClearButton
+ {...keepOpenProps}
label={t('@astryx.selector.clearLabel', {label})}
onClick={handleClear}
iconClassName={stableClassName('selector-clear-icon')}
@@ -1671,6 +1674,7 @@ export function Selector<T extends SelectorOptionType>(
type="button"
aria-label={t(STATUS_BUTTON_LABEL_KEY[status.type])}
aria-describedby={statusTooltip.describedBy}
+ {...keepOpenProps}
onClick={e => e.stopPropagation()}
{...stylex.props(
focusOutlineStyles.focusVisible,
diff --git a/packages/core/src/Selector/hooks.ts b/packages/core/src/Selector/hooks.ts
index f5f467c489..648ff1e0c3 100644
--- a/packages/core/src/Selector/hooks.ts
+++ b/packages/core/src/Selector/hooks.ts
@@ -176,6 +176,12 @@ interface UseComboboxOptions {
* lands in the search input, which then owns its own typing.
*/
onSearchSeed?: (char: string) => void;
+ /**
+ * Whether the browser's light dismiss just closed the popup. The trigger
+ * click that follows belongs to that same press, so acting on it would
+ * reopen the popup the user just closed.
+ */
+ wasJustDismissed?: () => boolean;
listboxId: string;
}
@@ -208,6 +214,7 @@ export function useCombobox({
onSelect,
onClear,
onSearchSeed,
+ wasJustDismissed,
listboxId,
}: UseComboboxOptions): UseComboboxResult {
const [highlightedIndex, setHighlightedIndex] = useState<number>(-1);
@@ -244,7 +251,7 @@ export function useCombobox({
);
const onTriggerClick = useCallback(() => {
- if (isDisabled) {
+ if (isDisabled || wasJustDismissed?.()) {
return;
}
if (isOpen) {
@@ -256,7 +263,15 @@ export function useCombobox({
setHighlightedIndex(selectedIndex >= 0 ? selectedIndex : 0);
}
}
- }, [isDisabled, isOpen, onOpen, closeAndReset, findSelectedIndex, hasSearch]);
+ }, [
+ isDisabled,
+ wasJustDismissed,
+ isOpen,
+ onOpen,
+ closeAndReset,
+ findSelectedIndex,
+ hasSearch,
+ ]);
const onItemMouseEnter = useCallback(
(item: SelectorOptionData, index: number) => {