/** * Outside-interaction policy shared by `DialogContent` and `SheetContent`. * * Radix dismisses an overlay surface when an outside interaction is not * default-prevented. That loses whatever the user typed, and a stray click on * the page behind a form is easy to make. So by default the surface decides * from its own contents: while it holds a form field, an outside interaction * keeps it open; a surface with nothing to lose (a confirmation, a picker, a * read-only panel) closes. Escape and the close button are unaffected — they * still close. * * `dismissOnOutsideClick` overrides the detection in either direction. */ /** base-ui popups (combobox/select) portal their list OUTSIDE the surface, so a *  click on an option reads as an interaction outside it. Such a click must *  never dismiss, even when the surface opts in. */export const PORTALED_POPUP_SELECTOR =  "[data-slot='combobox-content'],[data-slot='select-content']"; /** True when the interaction started inside a popup this surface portals out. */export const isInsidePortaledPopup = (target: unknown): boolean =>  typeof Element !== "undefined" &&  target instanceof Element &&  target.closest(PORTALED_POPUP_SELECTOR) !== null; /** * Controls whose presence means an outside click could discard user state. * * Tag selectors alone are not enough: base-ui and Radix render select and * combobox triggers, checkboxes, switches, radios, and sliders as `button` * elements carrying only an ARIA role, so the roles have to be matched too. */export const FORM_FIELD_SELECTOR = [  "input",  "textarea",  "select",  "[contenteditable]:not([contenteditable='false'])",  "[role='checkbox']",  "[role='combobox']",  "[role='listbox']",  "[role='radio']",  "[role='searchbox']",  "[role='slider']",  "[role='spinbutton']",  "[role='switch']",  "[role='textbox']",].join(","); /** The one Element method the policy needs, so tests can stub it without a DOM. */type SurfaceLike = { querySelector(selectors: string): unknown }; /** True when the surface currently holds a form field. */export const containsFormField = (surface: SurfaceLike | null): boolean =>  surface !== null && surface.querySelector(FORM_FIELD_SELECTOR) !== null; /** * Whether an outside interaction should close the surface. * * Pure so the decision is testable without a DOM: the caller does the element * lookups and passes the answers in. `dismissOnOutsideClick` left undefined * means "decide from the contents". */export const dismissesOnOutsideInteraction = (input: {  readonly dismissOnOutsideClick: boolean | undefined;  readonly insidePortaledPopup: boolean;  readonly containsFormField: boolean;}): boolean =>  !input.insidePortaledPopup && (input.dismissOnOutsideClick ?? !input.containsFormField); /** The shape Radix hands to `onInteractOutside` and `onPointerDownOutside`. */type OutsideInteractionEvent = {  readonly detail: { readonly originalEvent: { readonly target: unknown } };  readonly preventDefault: () => void;}; /** Apply the policy to a Radix outside-interaction event. Radix dispatches the *  event on the OUTSIDE element, so the surface node must be passed in. A *  missing node cannot prove the surface is safe to discard, so it stays open. */export const applyOutsideDismissPolicy = (  event: OutsideInteractionEvent,  dismissOnOutsideClick: boolean | undefined,  surface: SurfaceLike | null,): void => {  const dismisses =    surface !== null &&    dismissesOnOutsideInteraction({      dismissOnOutsideClick,      insidePortaledPopup: isInsidePortaledPopup(event.detail.originalEvent.target),      containsFormField: containsFormField(surface),    });  if (!dismisses) event.preventDefault();};