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.mdnew file mode 100644index 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++@cixzhangdiff --git a/packages/core/src/ComplexSelector/ComplexSelector.test.tsx b/packages/core/src/ComplexSelector/ComplexSelector.test.tsxindex 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.tsxindex 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.tsxindex 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(<DropdownMenubutton={{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.tsxindex 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 triggerconst 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.tsxindex 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.tsxindex 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}isIconOnlyxstyle={[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.tsnew file mode 100644index 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.tsxindex 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.tsxindex 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.tsxindex 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.tsxindex 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 trueuseEffect(() => {@@ -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.tsindex 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.tsxindex 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.tsxindex 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.tsxindex 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 functionconst 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.tsxindex 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.tsxindex 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 trueuseEffect(() => {@@ -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.tsindex 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) => {