Skip to content

The open alternative to Salesforce, designed for AI.

Fix front component dropdown dismissal and reopening (#28982)

Raphaël Bosiabb4e54c77fa
diff --git a/packages/twenty-docs/developers/extend/apps/layout/front-components.mdx b/packages/twenty-docs/developers/extend/apps/layout/front-components.mdx
index 9216e501121..aff4bcdad4c 100644
--- a/packages/twenty-docs/developers/extend/apps/layout/front-components.mdx
+++ b/packages/twenty-docs/developers/extend/apps/layout/front-components.mdx
@@ -992,6 +992,8 @@ Foundational controls are grouped under `twenty-ui/primitives/<family>`. Shared
Use [`MainButton`](/ui/components/input/main-button) for prominent actions and [`LightButton`](/ui/components/input/light-button) for lightweight actions. Use `Button`, `Field`, `Input`, `Select`, and other primitives from `twenty-ui/primitives/input` for foundational controls and forms. Follow each compound control's documented parts, such as `Field.Root`, `Field.Label`, and `Field.Description`.
+Pass `alignItemWithTrigger={false}` to `Select.Positioner`. Aligning the selected item with the trigger, Base UI's default, needs synchronous layout measurements that the sandbox cannot provide, so the popup collapses when it reopens.
+
Use [`Dropdown`](/ui/components/navigation/dropdown) from `twenty-ui/components/navigation` for action menus, option pickers, and nonmodal form panels. Use `enqueueSnackbar` from `twenty-sdk/front-component` for host notifications.
The standalone `Dialog` and `AlertDialog` APIs are also exported by Twenty UI, but direct use in front components is prohibited. Use the [host communication API](#host-communication-api) for dialogs.
@@ -1156,13 +1158,13 @@ Mouse, pointer, touch, drag, keyboard, focus, `input`/`change`/`submit`, `scroll
Handlers receive typed events built from the page event, `PointerEvent`, `MouseEvent`, `KeyboardEvent`, `InputEvent`, `WheelEvent` or `FocusEvent`, and those constructors exist in the sandbox for `dispatchEvent()`. Each forwarded event also carries React's synthetic event surface (`nativeEvent`, `isDefaultPrevented()`, `isPropagationStopped()`, `persist()`), so code written against React events keeps working even though the sandbox hands the event object to your handler directly.
-A page event crosses when the element the user interacted with, or one of its ancestors in your component, has a handler for that event type. It crosses once and then propagates inside the sandbox as it does on the page: `event.target` is the element the user interacted with, `currentTarget` is the element whose handler is running, `stopPropagation()` keeps ancestors' handlers from running, and `relatedTarget` points to the sandbox element focus or the pointer moved from or to, or is `null` when that element is outside your component. Like in React, `onFocus` and `onBlur` also run for focus changes inside the element, and `onClickCapture` and the other capture handlers run during the capture phase.
+A page event crosses when the element the user interacted with, or one of its ancestors in your component, has a handler for that event type, or when it is a press that your `document` listeners are waiting for (see below). It crosses once and then propagates inside the sandbox as it does on the page: `event.target` is the element the user interacted with, `currentTarget` is the element whose handler is running, `stopPropagation()` keeps ancestors' handlers from running, and `relatedTarget` points to the sandbox element focus or the pointer moved from or to, or is `null` when that element is outside your component. Like in React, `onFocus` and `onBlur` also run for focus changes inside the element, and `onClickCapture` and the other capture handlers run during the capture phase.
Handlers a library adds with `React.cloneElement`, such as the ones behind Base UI's `render` prop, run after the element's own handlers instead of replacing them, so passing `onClick: undefined` to `cloneElement` does not remove the element's handler. A handler on a Base UI `render` element can still call `event.preventBaseUIHandler()` to skip Base UI's own handler.
`event.target.value` and `checked` reflect the control once the browser has applied the user's change: in `input`, `change`, `click`, `blur` and `focusout` handlers, and in `keyup` handlers for `value`. In `keydown`, `beforeinput` and pointer handlers they hold the control's value and checked state as of its last edit, whatever your component listens to: an `Enter` handler reads the text typed so far, but a handler for a printable key does not see that key yet, so read live values from a controlled input or an `onChange` handler.
-`document` listeners receive the events that cross from your component, but nothing that happens elsewhere on the page, so to catch shortcuts with `document.addEventListener('keydown', ...)`, put an `onKeyDown` on an element that wraps your component. `window` listeners only receive `error` and `unhandledrejection`. Pointer moves only cross over elements that have a move handler, and pointer capture stays on the page, which is why a drag stops as soon as the pointer leaves those elements. `event.preventDefault()` does not cross either; form submission, `dragover`/`drop` and link clicks are already guarded for you.
+`document` listeners receive the events that cross from your component, with one exception for presses. While your component listens for `pointerdown`, `pointerup`, `pointercancel`, `mousedown`, `mouseup` or `click` on `document`, as an open popup does to close on outside presses, every press reaches those listeners: a press inside your component is dispatched at the element the user pressed even when nothing handles it, and a press elsewhere on the page is dispatched at `document.body` with its button state, click count and pointer type, but no coordinates or modifier keys. Clicks without a press, such as a keyboard activating a control outside your component, and presses on the page's scrollbars are not sent, and a touch swipe outside your component only arrives as `pointerdown` and `pointercancel`, so it does not close an open popup. Nothing else from the rest of the page crosses, so to catch shortcuts with `document.addEventListener('keydown', ...)`, put an `onKeyDown` on an element that wraps your component. `window` listeners only receive `error` and `unhandledrejection`. Pointer moves only cross over elements that have a move handler, and pointer capture stays on the page, which is why a drag stops as soon as the pointer leaves those elements. `event.preventDefault()` does not cross either; form submission, `dragover`/`drop` and link clicks are already guarded for you.
### Attributes and styling
diff --git a/packages/twenty-front-component-renderer/src/__stories__/TwentyUiGallery.stories.tsx b/packages/twenty-front-component-renderer/src/__stories__/TwentyUiGallery.stories.tsx
index abb316ccaeb..588c81fbb3f 100644
--- a/packages/twenty-front-component-renderer/src/__stories__/TwentyUiGallery.stories.tsx
+++ b/packages/twenty-front-component-renderer/src/__stories__/TwentyUiGallery.stories.tsx
@@ -1,6 +1,9 @@
import { badgeTest } from '@/__stories__/twenty-ui-gallery/utils/badgeTest';
import { currencyPickerTest } from '@/__stories__/twenty-ui-gallery/utils/currencyPickerTest';
import { dropdownTest } from '@/__stories__/twenty-ui-gallery/utils/dropdownTest';
+import { dropdownOutsidePreventedTest } from '@/__stories__/twenty-ui-gallery/utils/dropdownOutsidePreventedTest';
+import { dropdownReopeningTest } from '@/__stories__/twenty-ui-gallery/utils/dropdownReopeningTest';
+import { createDropdownOutsideDismissalTest } from '@/__stories__/twenty-ui-gallery/utils/createDropdownOutsideDismissalTest';
import { phoneCountryPickerTest } from '@/__stories__/twenty-ui-gallery/utils/phoneCountryPickerTest';
import { phoneCountryPickerTriggerTest } from '@/__stories__/twenty-ui-gallery/utils/phoneCountryPickerTriggerTest';
import { breadcrumbTest } from '@/__stories__/twenty-ui-gallery/utils/breadcrumbTest';
@@ -45,6 +48,7 @@ import { type TwentyUiGalleryPlayFunction } from '@/__stories__/twenty-ui-galler
import { type TwentyUiGalleryStory as Story } from '@/__stories__/twenty-ui-gallery/types/TwentyUiGalleryStory';
import { statusControlsTest } from '@/__stories__/twenty-ui-gallery/utils/statusControlsTest';
import { tagControlsTest } from '@/__stories__/twenty-ui-gallery/utils/tagControlsTest';
+import { SelectPageDecorator } from '@/__stories__/twenty-ui-gallery/components/SelectPageDecorator';
import { PortalBoundsDecorator } from '@/__stories__/twenty-ui-gallery/components/PortalBoundsDecorator';
import { OverflowingListInstancesDecorator } from '@/__stories__/twenty-ui-gallery/components/OverflowingListInstancesDecorator';
import { portalBoundsTest } from '@/__stories__/twenty-ui-gallery/utils/portalBoundsTest';
@@ -58,6 +62,8 @@ import {
} from '@/__stories__/twenty-ui-gallery/utils/galleryRenderTests';
import { popoverTest } from '@/__stories__/twenty-ui-gallery/utils/popoverTest';
import { selectTest } from '@/__stories__/twenty-ui-gallery/utils/selectTest';
+import { selectLongListTest } from '@/__stories__/twenty-ui-gallery/utils/selectLongListTest';
+import { tooltipFirstHoverTest } from '@/__stories__/twenty-ui-gallery/utils/tooltipFirstHoverTest';
import { switchTest } from '@/__stories__/twenty-ui-gallery/utils/switchTest';
import { tabsTest } from '@/__stories__/twenty-ui-gallery/utils/tabsTest';
import { FrontComponentRenderer } from '@/host/components/FrontComponentRenderer';
@@ -408,6 +414,18 @@ export const TooltipPreact: Story = createGalleryStory({
play: tooltipEscapeDismissalTest,
});
+export const TooltipFirstHoverReact: Story = createGalleryStory({
+ frontComponentBundleName: 'twenty-ui-tooltip-first-hover',
+ runtime: 'react',
+ play: tooltipFirstHoverTest,
+});
+
+export const TooltipFirstHoverPreact: Story = createGalleryStory({
+ frontComponentBundleName: 'twenty-ui-tooltip-first-hover',
+ runtime: 'preact',
+ play: tooltipFirstHoverTest,
+});
+
export const PortalBoundsReact: Story = createGalleryStory({
frontComponentBundleName: 'twenty-ui-portals',
runtime: 'react',
@@ -434,6 +452,82 @@ export const DropdownPreact: Story = createGalleryStory({
play: dropdownTest,
});
+export const DropdownReopeningReact: Story = createGalleryStory({
+ frontComponentBundleName: 'twenty-ui-dropdown-dismissal',
+ runtime: 'react',
+ decorators: [PortalBoundsDecorator],
+ play: dropdownReopeningTest,
+});
+
+export const DropdownReopeningPreact: Story = createGalleryStory({
+ frontComponentBundleName: 'twenty-ui-dropdown-dismissal',
+ runtime: 'preact',
+ decorators: [PortalBoundsDecorator],
+ play: dropdownReopeningTest,
+});
+
+export const DropdownOutsideWorkerReact: Story = createGalleryStory({
+ frontComponentBundleName: 'twenty-ui-dropdown-dismissal',
+ runtime: 'react',
+ decorators: [PortalBoundsDecorator],
+ play: createDropdownOutsideDismissalTest({ target: 'worker' }),
+});
+
+export const DropdownOutsideWorkerPreact: Story = createGalleryStory({
+ frontComponentBundleName: 'twenty-ui-dropdown-dismissal',
+ runtime: 'preact',
+ decorators: [PortalBoundsDecorator],
+ play: createDropdownOutsideDismissalTest({ target: 'worker' }),
+});
+
+export const DropdownOutsideHostReact: Story = createGalleryStory({
+ frontComponentBundleName: 'twenty-ui-dropdown-dismissal',
+ runtime: 'react',
+ decorators: [PortalBoundsDecorator],
+ play: createDropdownOutsideDismissalTest({ target: 'host' }),
+});
+
+export const DropdownOutsideHostPreact: Story = createGalleryStory({
+ frontComponentBundleName: 'twenty-ui-dropdown-dismissal',
+ runtime: 'preact',
+ decorators: [PortalBoundsDecorator],
+ play: createDropdownOutsideDismissalTest({ target: 'host' }),
+});
+
+export const DropdownCustomContainerReact: Story = createGalleryStory({
+ frontComponentBundleName: 'twenty-ui-dropdown-dismissal',
+ runtime: 'react',
+ decorators: [PortalBoundsDecorator],
+ play: createDropdownOutsideDismissalTest({
+ target: 'host',
+ shouldUseCustomContainer: true,
+ }),
+});
+
+export const DropdownCustomContainerPreact: Story = createGalleryStory({
+ frontComponentBundleName: 'twenty-ui-dropdown-dismissal',
+ runtime: 'preact',
+ decorators: [PortalBoundsDecorator],
+ play: createDropdownOutsideDismissalTest({
+ target: 'host',
+ shouldUseCustomContainer: true,
+ }),
+});
+
+export const DropdownOutsidePreventedReact: Story = createGalleryStory({
+ frontComponentBundleName: 'twenty-ui-dropdown-dismissal',
+ runtime: 'react',
+ decorators: [PortalBoundsDecorator],
+ play: dropdownOutsidePreventedTest,
+});
+
+export const DropdownOutsidePreventedPreact: Story = createGalleryStory({
+ frontComponentBundleName: 'twenty-ui-dropdown-dismissal',
+ runtime: 'preact',
+ decorators: [PortalBoundsDecorator],
+ play: dropdownOutsidePreventedTest,
+});
+
export const PhoneCountryPickerTriggersReact: Story = createGalleryStory({
frontComponentBundleName: 'twenty-ui-phone-country-picker',
runtime: 'react',
@@ -469,6 +563,20 @@ export const SelectPreact: Story = createGalleryStory({
play: selectTest,
});
+export const SelectLongListReact: Story = createGalleryStory({
+ frontComponentBundleName: 'twenty-ui-select-long-list',
+ runtime: 'react',
+ decorators: [SelectPageDecorator],
+ play: selectLongListTest,
+});
+
+export const SelectLongListPreact: Story = createGalleryStory({
+ frontComponentBundleName: 'twenty-ui-select-long-list',
+ runtime: 'preact',
+ decorators: [SelectPageDecorator],
+ play: selectLongListTest,
+});
+
export const ToastReact: Story = createGalleryStory({
frontComponentBundleName: 'twenty-ui-toast',
runtime: 'react',
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/README.md b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/README.md
index 45bb23b83ac..b7c2d9c2d5d 100644
--- a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/README.md
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/README.md
@@ -16,7 +16,7 @@ The standalone Toast countdown fixture checks remaining time after repeated cont
NumberField checks locale formatting and localized paste, controlled empty values, uncontrolled typing, bounds, keyboard commits, pointer value changes, callback event details, accessible labels, native forms, refs and render composition in both runtimes. Sequential typing after clearing a formatted value can reset the caret and insert subsequent digits before earlier input. Formatted pointer edits can also restore stale display values when host blur races the worker update. Pointer button release does not emit its commit callback, although host blur can emit an input-blur commit. ScrubArea can enter its scrubbing state, but drag movement and release do not reach the worker window listeners; pointer lock and the custom scrub cursor are also unavailable. These renderer limits apply independently of the standalone React NumberField browser checks.
-Popover composes Portal, Positioner, Popup, Arrow and Viewport. Its focused React/Preact cases check controlled trigger requests, native attributes, Button render composition, DOM refs and callback reasons. These checks do not establish popup visibility, geometry or dismissal support. The omitted-container popup still requires C04/C05/C07 renderer acceptance.
+Popover composes Portal, Positioner, Popup, Arrow and Viewport. Its focused React/Preact cases check controlled trigger requests, native attributes, Button render composition, DOM refs and callback reasons. They also check visible body-portal content, attachment to the trigger, pointer reachability, repeated closing and reopening through the trigger, Close button and Escape, and outside-press dismissal. Full focus restoration, scrolling and collision coverage remain pending.
OverflowingList keeps fitting items in its compact row and shows the complete list in its popup. The original fixture covers full popup contents and default event isolation. The `twenty-ui-overflowing-list-api` fixture exercises controlled and defaultOpen state, callback reasons and native events, cancelable Escape, root/trigger/popup refs with render composition, and public `actionsRef.close()` and `actionsRef.unmount()` in React and Preact. The deferred-close example retains the closed popup after `preventUnmountOnClose()`, releases it when the caller finishes its exit, and opens it again. The trigger and popup block click, mousedown, pointerdown, keydown and keyup by default. Each supplied handler replaces its default, so the API fixture explicitly allows trigger and popup clicks to bubble while recording their native event type. These API cases do not complete the separate C04 portal, C05 measurement/geometry, C06 scrolling or C07 dismissal acceptance. Existing OverflowingList responsive measurement and independent-instance evidence remains with C05.
@@ -24,7 +24,7 @@ In standalone React, when a popup click override allows bubbling, the installed
The SDK registers native handlers on physical elements. The API fixture overrides the default click blocking and asserts native trigger bubbling and popup callback preservation. Logical portal bubbling to a surrounding React ancestor remains a separate C04 gap in React and Preact: the diagnostic parent count reaches 1 after the trigger click and stays at 1 after the popup item click, instead of reaching 2.
-Dropdown checks controlled opening, native action refs and Button render composition, disabled callback suppression, action callbacks, page navigation, option selection and click-to-close in both runtimes. The portal fixture preserves all 16 rows and checks attachment along the physical collision side, overlap with the trigger and confinement to the owner portal area. A temporary constrained long-menu probe passed End-key focus and scrolling in both runtimes: a 128px popup scrolled to 386px and kept the last item visible. Outside-host dismissal remains a C07 renderer limitation. Clicking the host action invokes that action, while Dropdown remains expanded with its popup mounted. Its picker page checks initial search focus, a single Tab stop across option and action rows, arrow navigation and Tab reentry to the last focused row. Search preview clears when focus moves to a row, action or sibling button outside a popup whose outside dismissal is canceled, stays cleared during a keyed reorder, and returns when search regains focus. Nonempty-query Enter selects the first eligible option. Escape and Back focus restoration are not established by these checks.
+Dropdown checks controlled opening, native action refs and Button render composition, disabled callback suppression, action callbacks, page navigation, option selection and click-to-close in both runtimes. The portal fixture preserves all 16 rows and checks attachment along the physical collision side, overlap with the trigger and confinement to the owner portal area. A temporary constrained long-menu probe passed End-key focus and scrolling in both runtimes: a 128px popup scrolled to 386px and kept the last item visible. Separate dismissal stories check repeated reopening after action, trigger and Escape closure, clicks inside the popup, outside clicks within the worker (on a control and on content without handlers) and on a host control, cancellation, and custom portal containers. The outside action still activates when it dismisses the popup. Natively, twenty-ui swallows that click with a `window` capture listener, which worker dispatches never reach; inside the worker the popup can close on focus-out before the click arrives, so the story waits for the action count. Its picker page checks initial search focus, a single Tab stop across option and action rows, arrow navigation and Tab reentry to the last focused row. Search preview clears when focus moves to a row, action or sibling button outside a popup whose outside dismissal is canceled, stays cleared during a keyed reorder, and returns when search regains focus. Nonempty-query Enter selects the first eligible option. Escape and Back focus restoration are not established by these checks.
Typography composition checks constrained text, explicit links, semantic elements, refs and native focus handlers in both runtimes. Overflow tooltip popup acceptance still depends on renderer portal and geometry support.
@@ -85,19 +85,25 @@ effect within the interaction timeout.
| `twenty-ui-card-composition` | Card (native parts and refs, render composition, display semantics, button/link ownership and nested controls) |
| `twenty-ui-dialog` | SDK `openCommandConfirmationModal` confirmation request |
| `twenty-ui-select` | Select |
+| `twenty-ui-select-long-list` | Controlled nonmodal Select with 20 options, anchored positioning, trigger/selection reopening and host outside dismissal |
| `twenty-ui-portals` | Body portal callbacks, removal, nearby overflow, menu placement and confinement |
| `twenty-ui-dropdown` | Dropdown (controlled opening, action refs and callbacks, disabled actions, page navigation, picker Tab stop and selection) |
+| `twenty-ui-dropdown-dismissal` | Dropdown (reopening, clicks inside the popup, worker and host outside dismissal, cancellation and custom portal containers) |
| `twenty-ui-toast` | Toast |
| `twenty-ui-switch` | Switch (interaction coverage in addition to the original input gallery) |
| `twenty-ui-checkbox` | Checkbox |
| `twenty-ui-radio-group` | RadioGroup, Radio Root/Indicator and styled cards, SegmentedControl |
| `twenty-ui-tooltip` | Tooltip (convenience and compound APIs) |
+| `twenty-ui-tooltip-first-hover` | Tooltip on a ghost icon Button, default timing, button/SVG hover, exit and re-entry |
| `twenty-ui-responsive-hooks` | useIsMobile, useIsTouchDevice, Button hotkeys |
| `twenty-ui-reading-directions` | Callout, ButtonGroup, Button, AvatarGroup, ListItem, JsonTree in LTR and RTL side by side (`TwentyUiReadingDirections.stories.tsx`) |
| `twenty-ui-country-select` | CountrySelect (`TwentyUiCountrySelect.stories.tsx`) |
-The focused fixtures import public twenty-ui entry points and use
+Most focused fixtures import public twenty-ui entry points and use
`TwentyUiGalleryCard` for the light theme, mount marker, and `twenty-ui/style.css`.
+`twenty-ui-select-long-list` mirrors the application's scrolling page and toolbar;
+`twenty-ui-tooltip-first-hover` uses `FrontComponentCard`. Both import the
+stylesheet directly without a worker `ThemeProvider`.
`twenty-ui-reading-directions` imports the stylesheet directly instead: its dark
stories rely on the provider-less CSS-variable theme, and its two directions do
not fit the card's width.
@@ -160,11 +166,10 @@ forwarded. Separate React/Preact probes pass basic bottom/start placement with
an 8px offset and nonzero visible host geometry. They do not establish collision
handling or placement under scrolling and zoom.
-Three renderer gaps remain outside that positive coverage. A strict outside-press
-success probe fails in both runtimes: the host button activates once, but the
-popup remains open because events outside the owned component do not reach the
-worker. C07 owns that dismissal transport. A separate strict native-input
-semantics probe also fails in both runtimes after a controlled update while
+Autocomplete outside-press dismissal still needs verification after the renderer
+outside-press transport was added. Its existing stories do not establish that
+behavior. Two other renderer gaps remain outside the positive coverage. A strict
+native-input semantics probe fails in both runtimes after a controlled update while
closed. Base UI compares the registered element's tag name with `INPUT`, while
the worker retains `HTML-INPUT` for remote DOM transport. It consequently treats
the input as a custom control and removes its combobox role and expanded state
@@ -297,13 +302,27 @@ expected-to-fail by the runner.
| Component | Current limitation |
| --------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| Popover, Select (React and Preact) | Body portal content reaches the host inside the component portal area. These fixtures cover opening and visible content; search, selection, dismissal and focus restoration are not covered yet. |
+| Popover (React and Preact) | Full focus restoration, scrolling and collision coverage remain pending. |
+| Select (React and Preact) | Selected-item alignment, Base UI's default, collapses a reopened popup in front-component workers; pass `alignItemWithTrigger={false}`. Full focus restoration, scrolling and collision coverage remain pending. |
| CountrySelect (React and Preact) | Fixtures pass pointer opening, filtering, disabled interaction, translated labels and decorative flags, controlled/uncontrolled shorthand and compound selection, null clearing/reselection, canceled changes, external values, trigger and option-group render/ref targets, and search input props/ref. Search keyboard activation and IME (API-34), page sessions (API-35), and full portal, geometry, scrolling, outside dismissal and focus restoration acceptance (C04-C07) remain open. |
| PhoneCountryPicker (React and Preact) | React interactions and React/Preact trigger cases pass, covering shorthand/compound selection, cancellation, controlled clearing, native refs/render and RTL calling codes. Strict Preact interaction remains failing: typing `"+966"` yields `"966"`, before the clear/replacement assertions run. The input propagation gap remains visible in the active fixture. |
| Slider (React) | Edge-aligned thumbs stay hidden until the value changes. Base UI 1.8 and 1.9 set up the thumb's `ResizeObserver` before React attaches the `Slider.Control` ref, so the thumb never re-measures once the first host geometry arrives ([mui/base-ui#5995](https://github.com/mui/base-ui/issues/5995), fix pending in [mui/base-ui#6000](https://github.com/mui/base-ui/pull/6000)). Preact attaches the ref first, so its thumbs appear. `thumbAlignment="center"` avoids the issue. |
| OverflowingList | Item widths come from the last host layout, because a worker cannot lay out the measuring state synchronously. The truncated last item is measured at its truncated width, so the visible count can differ from a native render when that item's full width decides whether it fits. |
| Responsive hooks | The sandbox `window.matchMedia` answers for the widget's own box, so `useIsMobile` follows the widget width rather than the browser viewport: a widget 768px wide or narrower gets the mobile layout, and Button drops its hotkey hint, on any screen. `useIsTouchDevice` follows the primary input of the host device, so it is `false` under the desktop Chromium that runs these stories. The fixture asserts both at a 1024px and a 400px widget width. |
+`SelectLongList` reproduces the application's 20-option engineer picker with the
+fifth engineer selected, a controlled value, `modal={false}` and a page origin at
+220px left and 48px top. It checks host outside dismissal, reopening through the
+trigger and option selection, with popup dimensions, overlap with the trigger and
+pointer reachability on every open. Selected-item alignment collapses the
+reopened popup to 10px in workers, so the fixture passes
+`alignItemWithTrigger={false}`.
+
+`TooltipFirstHover` uses a direct ghost icon Button and the default hover delay.
+Its play waits one sandbox round trip before the first hover to allow Base UI's
+native listener effects to finish. It checks visible, anchored content when
+hovering the button or its SVG icon, then leaving and re-entering the trigger.
+
The CurrencyPicker fixtures cover shorthand and composed selection in React and
Preact, disabled controls and options, exact no-results/name/symbol search,
callback details and trigger refs, null clearing, external updates, dismissal
@@ -364,7 +383,33 @@ controlled fixture pairs its explicit panel IDs with matching native
`aria-controls` on each tab. Its TabButton controls retain route links with
`aria-current` and adjacent button actions without tab-panel semantics.
-A trusted primary press on a slider control, the innermost pressed element that disables touch gestures with `touch-action: none` and contains an enabled range input, starts a host capture session that forwards every move, release and cancellation of that pointer to the worker until the gesture ends, including a release that arrives before the worker answers, a zero pointer id and movement after capture loss. It forwards pointer coordinates and modifiers without another host target's control values, reports the implicit capture release that follows a release or cancellation, and renderer or node teardown ends the session. Each pointer has its own session, so a second pointer on the same control keeps the first capture. Capture only flows from the host to the worker. The worker's `setPointerCapture`, `hasPointerCapture` and `releasePointerCapture` keep a local record of one capturing element per pointer, which a forwarded capture loss or implicit release clears and which a detached element no longer reports. A worker release therefore never ends the host's capture early. General outside presses and overlay dismissal remain separate compatibility work.
+A trusted primary press on a slider control, the innermost pressed element that disables touch gestures with `touch-action: none` and contains an enabled range input, starts a host capture session that forwards every move, release and cancellation of that pointer to the worker until the gesture ends, including a release that arrives before the worker answers, a zero pointer id and movement after capture loss. It forwards pointer coordinates and modifiers without another host target's control values, reports the implicit capture release that follows a release or cancellation, and renderer or node teardown ends the session. Each pointer has its own session, so a second pointer on the same control keeps the first capture. Capture only flows from the host to the worker. The worker's `setPointerCapture`, `hasPointerCapture` and `releasePointerCapture` keep a local record of one capturing element per pointer, which a forwarded capture loss or implicit release clears and which a detached element no longer reports. A worker release therefore never ends the host's capture early.
+
+Outside presses use a separate transport that forwards only the event type,
+button state, click count and pointer type to worker document listeners. It does
+not expose external DOM nodes, control values or pointer coordinates. The worker
+reports when its `document` has listeners for these press types, such as the
+dismiss listeners of an open Base UI popup, and the host listens for outside
+presses only while it does. Listeners on `<html>` and `<body>` do not count,
+because React leaves permanent delegated listeners on portal containers such as
+`document.body`. A press on an owned element crosses through that element's
+handlers when one exists on its path; while the worker listens, the renderer
+root forwards the remaining owned presses with their full event data at their
+target, so a listener-less backdrop or label still dismisses a popup. A captured
+gesture's release, and the `mouseup` and `click` that follow it, stay off the
+outside-press path. Clicks without a press, such as keyboard activation of a
+host control, are not forwarded: the worker reports `document.body` as active
+whenever host focus is elsewhere, so Base UI would move focus back into the
+component. Presses on host scrollbars are not forwarded either, as Base UI
+ignores them natively. Dispatches of outside presses and of the remaining owned
+presses set `window.event`, so React flushes the resulting close before the next
+forwarded press as it does in a browser. Touch swipes outside the component do
+not dismiss popups, because the worker has no `TouchEvent` touch lists for Base
+UI's touch tracking; taps still close them through their compatibility
+`mousedown`. Dropdown and Popover stories verify the dismissal behavior
+described above; other components still need their own acceptance checks.
+General host keyboard forwarding and full focus restoration remain separate
+work.
Once the remaining gaps are fixed, extend the stories to verify keyboard
navigation, dismissal, and focus restoration across overlay components. The fixtures
@@ -415,5 +460,5 @@ and link composition, DOM refs, keyboard activation and disabled owners in both
runtimes. The same fixtures check intentional link content without automatic
anchors, truncation and custom multiline tooltip content. Escape dismissal is
checked from an explicit button owner with a native keyboard handler, which
-relays the event to the worker. General document-listener forwarding remains
-part of the renderer's dismissal work.
+relays the event to the worker. General host keyboard forwarding to worker
+document listeners remains part of the renderer's dismissal work.
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/components/SelectPageDecorator.tsx b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/components/SelectPageDecorator.tsx
new file mode 100644
index 00000000000..3482e36baae
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/components/SelectPageDecorator.tsx
@@ -0,0 +1,31 @@
+import { type Decorator } from '@storybook/react-vite';
+import { useState } from 'react';
+import { Button } from 'twenty-ui/primitives/input';
+import { Text } from 'twenty-ui/primitives/typography';
+
+export const SelectPageDecorator: Decorator = (Story) => {
+ const [hostActionCount, setHostActionCount] = useState(0);
+
+ return (
+ <div style={{ position: 'absolute', inset: 0 }}>
+ <Button onClick={() => setHostActionCount(hostActionCount + 1)}>
+ Host action
+ </Button>
+ <Text role="status" aria-label="Host actions">
+ Host actions: {hostActionCount}
+ </Text>
+ <div
+ style={{
+ position: 'absolute',
+ left: 220,
+ top: 48,
+ right: 0,
+ bottom: 0,
+ overflow: 'hidden',
+ }}
+ >
+ <Story />
+ </div>
+ </div>
+ );
+};
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/constants/PopupPositionRoundingTolerance.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/constants/PopupPositionRoundingTolerance.ts
new file mode 100644
index 00000000000..2274b9a558f
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/constants/PopupPositionRoundingTolerance.ts
@@ -0,0 +1 @@
+export const POPUP_POSITION_ROUNDING_TOLERANCE = 1;
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/twenty-ui-dropdown-dismissal.front-component.tsx b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/twenty-ui-dropdown-dismissal.front-component.tsx
new file mode 100644
index 00000000000..58fdf95578b
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/twenty-ui-dropdown-dismissal.front-component.tsx
@@ -0,0 +1,93 @@
+import { useEffect, useState } from 'react';
+import { defineFrontComponent } from 'twenty-sdk/define';
+import { Dropdown } from 'twenty-ui/components/navigation';
+import { Button } from 'twenty-ui/primitives/input';
+import { Text } from 'twenty-ui/primitives/typography';
+
+import { TwentyUiGalleryCard } from '@/__stories__/shared/front-components/twenty-ui-gallery-card';
+
+const DropdownDismissalExample = () => {
+ const [selectionCount, setSelectionCount] = useState(0);
+ const [outsideActionCount, setOutsideActionCount] = useState(0);
+ const [container, setContainer] = useState<HTMLDivElement | null>(null);
+ const [shouldUseCustomContainer, setShouldUseCustomContainer] =
+ useState(false);
+ const [shouldPreventOutsideDismissal, setShouldPreventOutsideDismissal] =
+ useState(false);
+ const [outsidePressCount, setOutsidePressCount] = useState(0);
+ const [forwardedPressCount, setForwardedPressCount] = useState(0);
+
+ useEffect(() => {
+ const countForwardedPress = (event: PointerEvent) => {
+ if (event.target === document.body) {
+ setForwardedPressCount((count) => count + 1);
+ }
+ };
+
+ document.body.addEventListener('pointerdown', countForwardedPress);
+
+ return () => {
+ document.body.removeEventListener('pointerdown', countForwardedPress);
+ };
+ }, []);
+
+ return (
+ <TwentyUiGalleryCard title="Dropdown dismissal">
+ <Button onClick={() => setOutsideActionCount((count) => count + 1)}>
+ Outside menu
+ </Button>
+ <Dropdown.Root
+ type="menu"
+ onInteractOutside={(event) => {
+ setOutsidePressCount((count) => count + 1);
+
+ if (shouldPreventOutsideDismissal) {
+ event.preventDefault();
+ }
+ }}
+ >
+ <Dropdown.Trigger render={<Button>Open actions</Button>} />
+ <Dropdown.Content
+ aria-label="Record actions"
+ container={shouldUseCustomContainer ? container : undefined}
+ >
+ <Dropdown.ActionItem
+ onClick={() => setSelectionCount((count) => count + 1)}
+ >
+ Select record
+ </Dropdown.ActionItem>
+ <Dropdown.ActionItem closeOnClick={false}>
+ Keep menu open
+ </Dropdown.ActionItem>
+ </Dropdown.Content>
+ </Dropdown.Root>
+ <div ref={setContainer} />
+ <Button onClick={() => setShouldUseCustomContainer(true)}>
+ Render inside widget
+ </Button>
+ <Button onClick={() => setShouldPreventOutsideDismissal(true)}>
+ Prevent outside dismissal
+ </Button>
+ <Text role="status" aria-label="Selections">
+ Selections: {selectionCount}
+ </Text>
+ <Text role="status" aria-label="Outside actions">
+ Outside actions: {outsideActionCount}
+ </Text>
+ <Text role="status" aria-label="Outside presses">
+ Outside presses: {outsidePressCount}
+ </Text>
+ <Text role="status" aria-label="Forwarded presses">
+ Forwarded presses: {forwardedPressCount}
+ </Text>
+ </TwentyUiGalleryCard>
+ );
+};
+
+export default defineFrontComponent({
+ universalIdentifier: 'fa9e77d4-87ad-47fb-b663-d92643f5c24c',
+ name: 'twenty-ui-dropdown-dismissal',
+ description:
+ 'Dropdown reopening and dismissal inside and outside the sandbox',
+ component: DropdownDismissalExample,
+});
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/twenty-ui-select-long-list.front-component.tsx b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/twenty-ui-select-long-list.front-component.tsx
new file mode 100644
index 00000000000..7875f80cb11
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/twenty-ui-select-long-list.front-component.tsx
@@ -0,0 +1,133 @@
+import { useState } from 'react';
+import { defineFrontComponent } from 'twenty-sdk/define';
+import { IconMessageCircle, IconRefresh } from 'twenty-ui/icon';
+import { Avatar } from 'twenty-ui/primitives/data-display';
+import { Button, Select } from 'twenty-ui/primitives/input';
+import { Text } from 'twenty-ui/primitives/typography';
+import { themeCssVariables } from 'twenty-ui/theme';
+import 'twenty-ui/style.css';
+
+const ENGINEER_COUNT = 19;
+const SELECTED_ENGINEER_INDEX = 4;
+const ENGINEER_OPTIONS = [
+ { value: '', label: 'Pick your name' },
+ ...Array.from({ length: ENGINEER_COUNT }, (_, engineerIndex) => ({
+ value: `engineer-${engineerIndex + 1}`,
+ label: `Engineer ${engineerIndex + 1}`,
+ })),
+];
+
+const LongListSelectExample = () => {
+ const [value, setValue] = useState(`engineer-${SELECTED_ENGINEER_INDEX + 1}`);
+ const selectedEngineer = ENGINEER_OPTIONS.find(
+ (engineer) => engineer.value === value,
+ );
+
+ return (
+ <div
+ data-testid="front-component-root"
+ style={{
+ display: 'flex',
+ flexDirection: 'column',
+ width: '100%',
+ height: 'calc(100dvh - 56px)',
+ minHeight: 0,
+ boxSizing: 'border-box',
+ padding: themeCssVariables.spacing[4],
+ gap: themeCssVariables.spacing[4],
+ overflowY: 'auto',
+ }}
+ >
+ <div
+ data-testid="front-component-mounted"
+ style={{
+ display: 'grid',
+ gap: themeCssVariables.spacing[4],
+ flexShrink: 0,
+ minWidth: 0,
+ }}
+ >
+ <div
+ style={{
+ display: 'flex',
+ alignItems: 'center',
+ justifyContent: 'space-between',
+ flexWrap: 'wrap',
+ gap: themeCssVariables.spacing[2],
+ }}
+ >
+ <div
+ style={{
+ display: 'flex',
+ alignItems: 'center',
+ flex: '1 1 160px',
+ maxWidth: 240,
+ minWidth: 0,
+ gap: themeCssVariables.spacing[2],
+ }}
+ >
+ <Avatar name={selectedEngineer?.label ?? 'Unknown'} size="md" />
+ <div style={{ flex: 1, minWidth: 0 }}>
+ <Select.Root
+ value={value}
+ onValueChange={(nextValue) => setValue(nextValue ?? '')}
+ items={ENGINEER_OPTIONS}
+ modal={false}
+ >
+ <Select.Trigger aria-label="Engineer">
+ <Select.Value />
+ <Select.Icon />
+ </Select.Trigger>
+ <Select.Portal>
+ <Select.Positioner alignItemWithTrigger={false}>
+ <Select.Popup>
+ {ENGINEER_OPTIONS.map((option) => (
+ <Select.Item key={option.value} value={option.value}>
+ <Select.ItemText>{option.label}</Select.ItemText>
+ <Select.ItemIndicator />
+ </Select.Item>
+ ))}
+ </Select.Popup>
+ </Select.Positioner>
+ </Select.Portal>
+ </Select.Root>
+ </div>
+ </div>
+ <div
+ style={{
+ display: 'flex',
+ alignItems: 'center',
+ gap: themeCssVariables.spacing[2],
+ }}
+ >
+ <Button
+ variant="outline"
+ aria-label="Refresh projects"
+ startIcon={<IconRefresh aria-hidden />}
+ />
+ <Button
+ variant="solid"
+ startIcon={<IconMessageCircle aria-hidden />}
+ >
+ Chat with PM
+ </Button>
+ </div>
+ </div>
+ <Text size="sm" color="secondary">
+ Create or update projects and prepare your sync in one chat.
+ </Text>
+ </div>
+ <Text role="status" aria-label="Engineer selection">
+ Engineer: {value}
+ </Text>
+ </div>
+ );
+};
+
+export default defineFrontComponent({
+ universalIdentifier: '9838371d-8013-4484-8f67-12401163c902',
+ name: 'twenty-ui-select-long-list',
+ description:
+ 'Controlled nonmodal Select with a long engineer list and default positioning',
+ component: LongListSelectExample,
+});
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/twenty-ui-tooltip-first-hover.front-component.tsx b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/twenty-ui-tooltip-first-hover.front-component.tsx
new file mode 100644
index 00000000000..da8ade6927d
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/twenty-ui-tooltip-first-hover.front-component.tsx
@@ -0,0 +1,28 @@
+import { defineFrontComponent } from 'twenty-sdk/define';
+import { IconInfoCircle } from 'twenty-ui/icon';
+import { Button } from 'twenty-ui/primitives/input';
+import { Tooltip } from 'twenty-ui/primitives/surfaces';
+import 'twenty-ui/style.css';
+
+import { FrontComponentCard } from '@/__stories__/shared/front-components/front-component-card';
+
+const PROJECT_HELP = 'Project progress is calculated from completed tasks.';
+
+const TooltipFirstHoverExample = () => (
+ <FrontComponentCard title="Project information">
+ <Tooltip content={PROJECT_HELP}>
+ <Button
+ variant="ghost"
+ aria-label={PROJECT_HELP}
+ startIcon={<IconInfoCircle />}
+ />
+ </Tooltip>
+ </FrontComponentCard>
+);
+
+export default defineFrontComponent({
+ universalIdentifier: '5a6ebc64-6e80-4917-b926-b7f80b18058a',
+ name: 'twenty-ui-tooltip-first-hover',
+ description: 'First hover on a ghost icon Button with default Tooltip timing',
+ component: TooltipFirstHoverExample,
+});
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/createDropdownOutsideDismissalTest.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/createDropdownOutsideDismissalTest.ts
new file mode 100644
index 00000000000..47c31e06656
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/createDropdownOutsideDismissalTest.ts
@@ -0,0 +1,51 @@
+import { expect, userEvent, waitFor } from 'storybook/test';
+
+import { errorHandler } from '@/__stories__/shared/test-utils/createFrontComponentStoryMeta';
+import { expectElementToReceivePointer } from '@/__stories__/shared/test-utils/matchers/expectElementToReceivePointer';
+import { INTERACTION_TIMEOUT } from '@/__stories__/shared/test-utils/timeouts';
+import { type TwentyUiGalleryPlayFunction } from '@/__stories__/twenty-ui-gallery/types/TwentyUiGalleryPlayFunction';
+import { createDropdownTestContext } from '@/__stories__/twenty-ui-gallery/utils/createDropdownTestContext';
+
+export const createDropdownOutsideDismissalTest =
+ ({
+ target,
+ shouldUseCustomContainer = false,
+ }: {
+ target: 'worker' | 'host';
+ shouldUseCustomContainer?: boolean;
+ }): TwentyUiGalleryPlayFunction =>
+ async ({ canvasElement }) => {
+ const { canvas, trigger, openMenu, expectMenuClosed } =
+ await createDropdownTestContext(canvasElement);
+ const outsideActionName =
+ target === 'worker' ? 'Outside menu' : 'Host action';
+ const actionStatusName =
+ target === 'worker' ? 'Outside actions' : 'Host actions';
+
+ if (shouldUseCustomContainer) {
+ await userEvent.click(
+ canvas.getByRole('button', { name: 'Render inside widget' }),
+ );
+ }
+
+ await openMenu();
+ const outsideAction = canvas.getByRole('button', {
+ name: outsideActionName,
+ });
+ expectElementToReceivePointer(outsideAction);
+ await userEvent.click(outsideAction);
+ await expectMenuClosed();
+ expect(outsideAction).toHaveFocus();
+ await waitFor(
+ () =>
+ expect(
+ canvas.getByRole('status', { name: actionStatusName }),
+ ).toHaveTextContent(`${actionStatusName}: 1`),
+ { timeout: INTERACTION_TIMEOUT },
+ );
+
+ await openMenu();
+ await userEvent.click(trigger);
+ await expectMenuClosed();
+ expect(errorHandler).not.toHaveBeenCalled();
+ };
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/createDropdownTestContext.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/createDropdownTestContext.ts
new file mode 100644
index 00000000000..f1dec0439c8
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/createDropdownTestContext.ts
@@ -0,0 +1,42 @@
+import { expect, userEvent, waitFor, within } from 'storybook/test';
+
+import { expectElementToReceivePointer } from '@/__stories__/shared/test-utils/matchers/expectElementToReceivePointer';
+import { expectFrontComponentMounted } from '@/__stories__/shared/test-utils/matchers/expectFrontComponentMounted';
+import { INTERACTION_TIMEOUT } from '@/__stories__/shared/test-utils/timeouts';
+
+export const createDropdownTestContext = async (canvasElement: HTMLElement) => {
+ const canvas = within(canvasElement);
+ const page = within(canvasElement.ownerDocument.body);
+ await expectFrontComponentMounted(canvas);
+ const trigger = canvas.getByRole('button', { name: 'Open actions' });
+
+ const openMenu = async () => {
+ await userEvent.click(trigger);
+ await waitFor(
+ () => {
+ expect(trigger).toHaveAttribute('aria-expanded', 'true');
+ expect(
+ page.getByRole('menu', { name: 'Record actions' }),
+ ).toBeVisible();
+ expectElementToReceivePointer(
+ page.getByRole('menuitem', { name: 'Select record' }),
+ );
+ },
+ { timeout: INTERACTION_TIMEOUT },
+ );
+ };
+
+ const expectMenuClosed = async () => {
+ await waitFor(
+ () => {
+ expect(trigger).toHaveAttribute('aria-expanded', 'false');
+ expect(
+ page.queryByRole('menu', { name: 'Record actions' }),
+ ).not.toBeInTheDocument();
+ },
+ { timeout: INTERACTION_TIMEOUT },
+ );
+ };
+
+ return { canvas, page, trigger, openMenu, expectMenuClosed };
+};
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/dropdownOutsidePreventedTest.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/dropdownOutsidePreventedTest.ts
new file mode 100644
index 00000000000..fe5416d23e3
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/dropdownOutsidePreventedTest.ts
@@ -0,0 +1,29 @@
+import { expect, userEvent, waitFor } from 'storybook/test';
+
+import { errorHandler } from '@/__stories__/shared/test-utils/createFrontComponentStoryMeta';
+import { createDropdownTestContext } from '@/__stories__/twenty-ui-gallery/utils/createDropdownTestContext';
+import { type TwentyUiGalleryPlayFunction } from '@/__stories__/twenty-ui-gallery/types/TwentyUiGalleryPlayFunction';
+
+export const dropdownOutsidePreventedTest: TwentyUiGalleryPlayFunction =
+ async ({ canvasElement }) => {
+ const { canvas, page, trigger, openMenu, expectMenuClosed } =
+ await createDropdownTestContext(canvasElement);
+
+ await userEvent.click(
+ canvas.getByRole('button', { name: 'Prevent outside dismissal' }),
+ );
+ await openMenu();
+ const outsideAction = canvas.getByRole('button', { name: 'Host action' });
+ await userEvent.click(outsideAction);
+ await waitFor(() =>
+ expect(
+ canvas.getByRole('status', { name: 'Outside presses' }),
+ ).toHaveTextContent('Outside presses: 1'),
+ );
+ expect(outsideAction).toHaveFocus();
+ expect(trigger).toHaveAttribute('aria-expanded', 'true');
+ expect(page.getByRole('menu', { name: 'Record actions' })).toBeVisible();
+ await userEvent.click(trigger);
+ await expectMenuClosed();
+ expect(errorHandler).not.toHaveBeenCalled();
+ };
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/dropdownReopeningTest.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/dropdownReopeningTest.ts
new file mode 100644
index 00000000000..e9e0771f669
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/dropdownReopeningTest.ts
@@ -0,0 +1,66 @@
+import { expect, userEvent, waitFor } from 'storybook/test';
+
+import { errorHandler } from '@/__stories__/shared/test-utils/createFrontComponentStoryMeta';
+import { INTERACTION_TIMEOUT } from '@/__stories__/shared/test-utils/timeouts';
+import { type TwentyUiGalleryPlayFunction } from '@/__stories__/twenty-ui-gallery/types/TwentyUiGalleryPlayFunction';
+import { createDropdownTestContext } from '@/__stories__/twenty-ui-gallery/utils/createDropdownTestContext';
+
+export const dropdownReopeningTest: TwentyUiGalleryPlayFunction = async ({
+ canvasElement,
+}) => {
+ const { canvas, page, trigger, openMenu, expectMenuClosed } =
+ await createDropdownTestContext(canvasElement);
+
+ await openMenu();
+ await userEvent.click(page.getByRole('menuitem', { name: 'Select record' }));
+ await expectMenuClosed();
+ expect(canvas.getByRole('status', { name: 'Selections' })).toHaveTextContent(
+ 'Selections: 1',
+ );
+
+ await openMenu();
+ await userEvent.click(page.getByRole('menuitem', { name: 'Keep menu open' }));
+ expect(trigger).toHaveAttribute('aria-expanded', 'true');
+ await userEvent.click(trigger);
+ await expectMenuClosed();
+
+ await openMenu();
+ await userEvent.keyboard('{Escape}');
+ await expectMenuClosed();
+
+ await openMenu();
+ await userEvent.click(canvas.getByRole('status', { name: 'Selections' }));
+ await expectMenuClosed();
+
+ await openMenu();
+ await userEvent.click(page.getByRole('menuitem', { name: 'Select record' }));
+ await expectMenuClosed();
+ expect(canvas.getByRole('status', { name: 'Selections' })).toHaveTextContent(
+ 'Selections: 2',
+ );
+
+ const hostAction = canvas.getByRole('button', { name: 'Host action' });
+ const forwardedPresses = canvas.getByRole('status', {
+ name: 'Forwarded presses',
+ });
+
+ await openMenu();
+ await userEvent.click(hostAction);
+ await expectMenuClosed();
+ await waitFor(
+ () => expect(forwardedPresses).toHaveTextContent('Forwarded presses: 1'),
+ { timeout: INTERACTION_TIMEOUT },
+ );
+
+ await userEvent.click(hostAction);
+ await userEvent.click(canvas.getByRole('button', { name: 'Outside menu' }));
+ await waitFor(
+ () =>
+ expect(
+ canvas.getByRole('status', { name: 'Outside actions' }),
+ ).toHaveTextContent('Outside actions: 1'),
+ { timeout: INTERACTION_TIMEOUT },
+ );
+ expect(forwardedPresses).toHaveTextContent('Forwarded presses: 1');
+ expect(errorHandler).not.toHaveBeenCalled();
+};
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/dropdownTest.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/dropdownTest.ts
index 0aff76d63bf..9f4174743e6 100644
--- a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/dropdownTest.ts
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/dropdownTest.ts
@@ -91,7 +91,13 @@ export const dropdownTest: TwentyUiGalleryPlayFunction = async ({
timeout: INTERACTION_TIMEOUT,
});
expect(trigger).toHaveAttribute('aria-expanded', 'true');
- expect(page.getByRole('dialog', { name: 'Assignee actions' })).toBeVisible();
+ await waitFor(
+ () =>
+ expect(
+ page.getByRole('dialog', { name: 'Assignee actions' }),
+ ).toBeVisible(),
+ { timeout: INTERACTION_TIMEOUT },
+ );
await waitFor(
() => expect(search).not.toHaveAttribute('aria-activedescendant'),
{ timeout: INTERACTION_TIMEOUT },
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/expectPopupAttachedToAnchor.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/expectPopupAttachedToAnchor.ts
new file mode 100644
index 00000000000..16a65b20862
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/expectPopupAttachedToAnchor.ts
@@ -0,0 +1,34 @@
+import { expect } from 'storybook/test';
+
+import { MAXIMUM_DROPDOWN_TRIGGER_GAP } from '@/__stories__/twenty-ui-gallery/constants/MaximumDropdownTriggerGap';
+import { POPUP_POSITION_ROUNDING_TOLERANCE } from '@/__stories__/twenty-ui-gallery/constants/PopupPositionRoundingTolerance';
+import { computePopupAnchorGapAndOverlap } from '@/__stories__/twenty-ui-gallery/utils/computePopupAnchorGapAndOverlap';
+
+export const expectPopupAttachedToAnchor = ({
+ popup,
+ anchor,
+}: {
+ popup: Element;
+ anchor: Element;
+}) => {
+ const popupRectangle = popup.getBoundingClientRect();
+ expect(popupRectangle.width).toBeGreaterThan(0);
+ expect(popupRectangle.height).toBeGreaterThan(0);
+ const {
+ popupAnchorGap,
+ popupOverlapStart,
+ popupOverlapEnd,
+ anchorOverlapStart,
+ anchorOverlapEnd,
+ } = computePopupAnchorGapAndOverlap({
+ anchor: anchor.getBoundingClientRect(),
+ popup: popupRectangle,
+ side: popup.getAttribute('data-side'),
+ });
+ expect(popupAnchorGap).toBeGreaterThanOrEqual(
+ -POPUP_POSITION_ROUNDING_TOLERANCE,
+ );
+ expect(popupAnchorGap).toBeLessThanOrEqual(MAXIMUM_DROPDOWN_TRIGGER_GAP);
+ expect(popupOverlapStart).toBeLessThan(anchorOverlapEnd);
+ expect(popupOverlapEnd).toBeGreaterThan(anchorOverlapStart);
+};
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/popoverTest.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/popoverTest.ts
index 2962bd85caa..dfbc6b81da3 100644
--- a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/popoverTest.ts
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/popoverTest.ts
@@ -1,28 +1,70 @@
import { expect, userEvent, waitFor, within } from 'storybook/test';
import { errorHandler } from '@/__stories__/shared/test-utils/createFrontComponentStoryMeta';
+import { expectElementToReceivePointer } from '@/__stories__/shared/test-utils/matchers/expectElementToReceivePointer';
import { expectFrontComponentMounted } from '@/__stories__/shared/test-utils/matchers/expectFrontComponentMounted';
+import { INTERACTION_TIMEOUT } from '@/__stories__/shared/test-utils/timeouts';
import { type TwentyUiGalleryPlayFunction } from '@/__stories__/twenty-ui-gallery/types/TwentyUiGalleryPlayFunction';
+import { expectPopupAttachedToAnchor } from '@/__stories__/twenty-ui-gallery/utils/expectPopupAttachedToAnchor';
export const popoverTest: TwentyUiGalleryPlayFunction = async ({
canvasElement,
}) => {
const canvas = within(canvasElement);
+ const page = within(canvasElement.ownerDocument.body);
await expectFrontComponentMounted(canvas);
const trigger = canvas.getByRole('button', { name: 'Account details' });
+
+ const openPopover = async () => {
+ await userEvent.click(trigger);
+ await waitFor(
+ () => {
+ expect(trigger).toHaveAttribute('aria-expanded', 'true');
+ const popup = page.getByRole('dialog', { name: 'Account owner' });
+ expect(popup).toBeVisible();
+ expectPopupAttachedToAnchor({ popup, anchor: trigger });
+ expectElementToReceivePointer(
+ within(popup).getByRole('button', { name: 'Close details' }),
+ );
+ },
+ { timeout: INTERACTION_TIMEOUT },
+ );
+ };
+
+ const expectPopoverClosed = async () => {
+ await waitFor(
+ () => {
+ expect(trigger).toHaveAttribute('aria-expanded', 'false');
+ expect(
+ page.queryByRole('dialog', { name: 'Account owner' }),
+ ).not.toBeInTheDocument();
+ },
+ { timeout: INTERACTION_TIMEOUT },
+ );
+ };
+
expect(trigger).toHaveAttribute('data-native-trigger', 'account');
expect(trigger).toHaveAttribute('aria-expanded', 'false');
- await userEvent.click(trigger);
- await waitFor(() => expect(trigger).toHaveAttribute('aria-expanded', 'true'));
+ await openPopover();
expect(canvas.getByRole('status')).toHaveTextContent(
'Details: open; reason: trigger-press; target: account',
);
await userEvent.click(trigger);
- await waitFor(() =>
- expect(trigger).toHaveAttribute('aria-expanded', 'false'),
- );
+ await expectPopoverClosed();
expect(canvas.getByRole('status')).toHaveTextContent(
'Details: closed; reason: trigger-press; target: account',
);
+ await openPopover();
+ await userEvent.click(page.getByRole('button', { name: 'Close details' }));
+ await expectPopoverClosed();
+ expect(canvas.getByRole('status')).toHaveTextContent(
+ 'Details: closed; reason: close-press; target: account',
+ );
+ await openPopover();
+ await userEvent.keyboard('{Escape}');
+ await expectPopoverClosed();
+ await openPopover();
+ await userEvent.click(canvasElement);
+ await expectPopoverClosed();
expect(errorHandler).not.toHaveBeenCalled();
};
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/selectLongListTest.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/selectLongListTest.ts
new file mode 100644
index 00000000000..a5327ee109f
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/selectLongListTest.ts
@@ -0,0 +1,91 @@
+import { expect, userEvent, waitFor, within } from 'storybook/test';
+
+import { errorHandler } from '@/__stories__/shared/test-utils/createFrontComponentStoryMeta';
+import { expectElementToReceivePointer } from '@/__stories__/shared/test-utils/matchers/expectElementToReceivePointer';
+import { expectFrontComponentMounted } from '@/__stories__/shared/test-utils/matchers/expectFrontComponentMounted';
+import { INTERACTION_TIMEOUT } from '@/__stories__/shared/test-utils/timeouts';
+import { POPUP_POSITION_ROUNDING_TOLERANCE } from '@/__stories__/twenty-ui-gallery/constants/PopupPositionRoundingTolerance';
+import { type TwentyUiGalleryPlayFunction } from '@/__stories__/twenty-ui-gallery/types/TwentyUiGalleryPlayFunction';
+
+export const selectLongListTest: TwentyUiGalleryPlayFunction = async ({
+ canvasElement,
+}) => {
+ const user = userEvent.setup();
+ const canvas = within(canvasElement);
+ const page = within(canvasElement.ownerDocument.body);
+ await expectFrontComponentMounted(canvas);
+ const trigger = canvas.getByRole('combobox', { name: 'Engineer' });
+
+ const openSelect = async () => {
+ await user.click(trigger);
+ await waitFor(
+ () => {
+ expect(trigger).toHaveAttribute('aria-expanded', 'true');
+ const popup = page.getByRole('listbox');
+ const selectedOption = page.getByRole('option', { selected: true });
+ expect(popup).toBeVisible();
+ const popupRectangle = popup.getBoundingClientRect();
+ const triggerRectangle = trigger.getBoundingClientRect();
+ const selectedOptionRectangle = selectedOption.getBoundingClientRect();
+ expect(popupRectangle.height).toBeGreaterThanOrEqual(
+ selectedOptionRectangle.height,
+ );
+ expect(popupRectangle.width).toBeGreaterThanOrEqual(
+ triggerRectangle.width - POPUP_POSITION_ROUNDING_TOLERANCE,
+ );
+ expect(popupRectangle.left).toBeLessThan(triggerRectangle.right);
+ expect(popupRectangle.right).toBeGreaterThan(triggerRectangle.left);
+ expectElementToReceivePointer(selectedOption);
+ },
+ { timeout: INTERACTION_TIMEOUT },
+ );
+ };
+
+ const expectSelectClosed = async () => {
+ await waitFor(
+ () => {
+ expect(trigger).toHaveAttribute('aria-expanded', 'false');
+ expect(page.queryByRole('listbox')).not.toBeInTheDocument();
+ },
+ { timeout: INTERACTION_TIMEOUT },
+ );
+ };
+
+ const hostAction = canvas.getByRole('button', { name: 'Host action' });
+
+ for (const actionCount of [1, 2]) {
+ await openSelect();
+ expectElementToReceivePointer(hostAction);
+ await user.click(hostAction);
+ await expectSelectClosed();
+ expect(trigger).toHaveTextContent('Engineer 5');
+ expect(
+ canvas.getByRole('status', { name: 'Host actions' }),
+ ).toHaveTextContent(`Host actions: ${actionCount}`);
+ }
+
+ await openSelect();
+ await user.click(trigger);
+ await expectSelectClosed();
+ await openSelect();
+ await user.click(trigger);
+ await expectSelectClosed();
+
+ for (const option of [
+ { label: 'Engineer 4', value: 'engineer-4' },
+ { label: 'Engineer 6', value: 'engineer-6' },
+ { label: 'Engineer 5', value: 'engineer-5' },
+ ]) {
+ await openSelect();
+ const optionElement = page.getByRole('option', { name: option.label });
+ expectElementToReceivePointer(optionElement);
+ await user.click(optionElement);
+ await expectSelectClosed();
+ expect(trigger).toHaveTextContent(option.label);
+ expect(
+ canvas.getByRole('status', { name: 'Engineer selection' }),
+ ).toHaveTextContent(`Engineer: ${option.value}`);
+ }
+
+ expect(errorHandler).not.toHaveBeenCalled();
+};
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/tooltipFirstHoverTest.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/tooltipFirstHoverTest.ts
new file mode 100644
index 00000000000..d32bf523ed8
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/tooltipFirstHoverTest.ts
@@ -0,0 +1,54 @@
+import { expect, userEvent, waitFor, within } from 'storybook/test';
+import { isDefined } from 'twenty-shared/utils';
+
+import { waitForSandboxRoundTrip } from '@/__stories__/shared/test-utils/waitForSandboxRoundTrip';
+import { errorHandler } from '@/__stories__/shared/test-utils/createFrontComponentStoryMeta';
+import { expectFrontComponentMounted } from '@/__stories__/shared/test-utils/matchers/expectFrontComponentMounted';
+import { INTERACTION_TIMEOUT } from '@/__stories__/shared/test-utils/timeouts';
+import { type TwentyUiGalleryPlayFunction } from '@/__stories__/twenty-ui-gallery/types/TwentyUiGalleryPlayFunction';
+import { expectPopupAttachedToAnchor } from '@/__stories__/twenty-ui-gallery/utils/expectPopupAttachedToAnchor';
+
+const PROJECT_HELP = 'Project progress is calculated from completed tasks.';
+
+export const tooltipFirstHoverTest: TwentyUiGalleryPlayFunction = async ({
+ canvasElement,
+}) => {
+ const user = userEvent.setup();
+ const canvas = within(canvasElement);
+ const page = within(canvasElement.ownerDocument.body);
+ await expectFrontComponentMounted(canvas);
+ const trigger = canvas.getByRole('button', { name: PROJECT_HELP });
+ const icon = trigger.querySelector('svg');
+
+ if (!isDefined(icon)) {
+ throw new Error('The project information trigger must contain its icon');
+ }
+
+ const expectTooltipOpen = () =>
+ waitFor(
+ () => {
+ const tooltip = page.getByRole('tooltip');
+ expect(tooltip).toBeVisible();
+ expect(tooltip).toHaveTextContent(PROJECT_HELP);
+ expectPopupAttachedToAnchor({ popup: tooltip, anchor: trigger });
+ },
+ { timeout: INTERACTION_TIMEOUT },
+ );
+
+ const expectTooltipClosed = () =>
+ waitFor(() => expect(page.queryByRole('tooltip')).not.toBeInTheDocument(), {
+ timeout: INTERACTION_TIMEOUT,
+ });
+
+ expect(page.queryByRole('tooltip')).not.toBeInTheDocument();
+ await waitForSandboxRoundTrip();
+
+ for (const hoverTarget of [trigger, icon, icon]) {
+ await user.hover(hoverTarget);
+ await expectTooltipOpen();
+ await user.unhover(hoverTarget);
+ await expectTooltipClosed();
+ }
+
+ expect(errorHandler).not.toHaveBeenCalled();
+};
diff --git a/packages/twenty-front-component-renderer/src/constants/OutsidePressEventTypes.ts b/packages/twenty-front-component-renderer/src/constants/OutsidePressEventTypes.ts
new file mode 100644
index 00000000000..c206bd72d70
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/constants/OutsidePressEventTypes.ts
@@ -0,0 +1,8 @@
+export const OUTSIDE_PRESS_EVENT_TYPES = [
+ 'pointerdown',
+ 'pointerup',
+ 'pointercancel',
+ 'mousedown',
+ 'mouseup',
+ 'click',
+] as const;
diff --git a/packages/twenty-front-component-renderer/src/host/components/FrontComponentRenderer.tsx b/packages/twenty-front-component-renderer/src/host/components/FrontComponentRenderer.tsx
index e266ff00585..b4edc94667b 100644
--- a/packages/twenty-front-component-renderer/src/host/components/FrontComponentRenderer.tsx
+++ b/packages/twenty-front-component-renderer/src/host/components/FrontComponentRenderer.tsx
@@ -1,6 +1,7 @@
import { ROOT_CONTAINER_STYLE } from '@/host/constants/RootContainerStyle';
import { FrontComponentRemoteRootRenderer } from '@/host/components/FrontComponentRemoteRootRenderer';
import { FrontComponentPointerCaptureControllerContext } from '@/host/events/contexts/FrontComponentPointerCaptureControllerContext';
+import { createHostOutsidePressController } from '@/host/events/utils/createHostOutsidePressController';
import { createHostPointerCaptureController } from '@/host/events/utils/createHostPointerCaptureController';
import { FrontComponentGeometryTrackerContext } from '@/host/geometry/contexts/FrontComponentGeometryTrackerContext';
import { createGeometryTracker } from '@/host/geometry/utils/createGeometryTracker';
@@ -15,6 +16,7 @@ import { FrontComponentGeometryTrackerEffect } from '@/host/effect-components/Fr
import { FrontComponentInitializeHostCommunicationApiEffect } from '@/host/effect-components/FrontComponentInitializeHostCommunicationApiEffect';
import { FrontComponentMediaSessionEffect } from '@/host/effect-components/FrontComponentMediaSessionEffect';
import { FrontComponentPointerCaptureEffect } from '@/host/effect-components/FrontComponentPointerCaptureEffect';
+import { FrontComponentOutsidePressEffect } from '@/host/effect-components/FrontComponentOutsidePressEffect';
import { FrontComponentUpdateContextEffect } from '@/host/effect-components/FrontComponentUpdateContextEffect';
import { FrontComponentUpdateHostCommunicationApiEffect } from '@/host/effect-components/FrontComponentUpdateHostCommunicationApiEffect';
import { type FrontComponentMediaSessionHost } from '@/host/media/types/FrontComponentMediaSessionHost';
@@ -84,13 +86,28 @@ export const FrontComponentRenderer = ({
const [pointerCaptureController] = useState(() =>
createHostPointerCaptureController({ geometryTracker }),
);
+ const [outsidePressController] = useState(() =>
+ createHostOutsidePressController({
+ geometryTracker,
+ pointerCaptureController,
+ }),
+ );
const [initialExecutionContext] = useState(executionContext);
const isReady = isDefined(receiver) && isExecutionContextInitialized;
return (
<FrontComponentGeometryTrackerContext.Provider value={geometryTracker}>
- <div ref={geometryTracker.setRoot} style={ROOT_CONTAINER_STYLE}>
+ <div
+ ref={geometryTracker.setRoot}
+ style={ROOT_CONTAINER_STYLE}
+ onPointerDown={outsidePressController.forwardUnhandledOwnedPress}
+ onPointerUp={outsidePressController.forwardUnhandledOwnedPress}
+ onPointerCancel={outsidePressController.forwardUnhandledOwnedPress}
+ onMouseDown={outsidePressController.forwardUnhandledOwnedPress}
+ onMouseUp={outsidePressController.forwardUnhandledOwnedPress}
+ onClick={outsidePressController.forwardUnhandledOwnedPress}
+ >
<FrontComponentWorkerEffect
componentUrl={componentUrl}
applicationAccessToken={applicationAccessToken}
@@ -104,6 +121,7 @@ export const FrontComponentRenderer = ({
geometryTracker={geometryTracker}
hostFocusController={hostFocusController}
hostScrollController={hostScrollController}
+ outsidePressController={outsidePressController}
mediaSessionHost={mediaSessionHost}
setReceiver={setReceiver}
setThread={setThread}
@@ -140,6 +158,10 @@ export const FrontComponentRenderer = ({
thread={thread}
pointerCaptureController={pointerCaptureController}
/>
+ <FrontComponentOutsidePressEffect
+ thread={thread}
+ outsidePressController={outsidePressController}
+ />
{isDefined(mediaSessionHost) && (
<FrontComponentMediaSessionEffect
thread={thread}
diff --git a/packages/twenty-front-component-renderer/src/host/constants/PressTransportFailureWarning.ts b/packages/twenty-front-component-renderer/src/host/constants/PressTransportFailureWarning.ts
new file mode 100644
index 00000000000..809079f1c5f
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/constants/PressTransportFailureWarning.ts
@@ -0,0 +1,2 @@
+export const PRESS_TRANSPORT_FAILURE_WARNING =
+ '[twenty-front-component] Forwarding a press to the worker failed. Popups inside the front component may not close on presses outside them.';
diff --git a/packages/twenty-front-component-renderer/src/host/effect-components/FrontComponentOutsidePressEffect.tsx b/packages/twenty-front-component-renderer/src/host/effect-components/FrontComponentOutsidePressEffect.tsx
new file mode 100644
index 00000000000..4017718e4dc
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/effect-components/FrontComponentOutsidePressEffect.tsx
@@ -0,0 +1,47 @@
+import { useEffect } from 'react';
+
+import { PRESS_TRANSPORT_FAILURE_WARNING } from '@/host/constants/PressTransportFailureWarning';
+import { type HostOutsidePressController } from '@/host/events/types/HostOutsidePressController';
+import { type FrontComponentThread } from '@/types/FrontComponentThread';
+
+type FrontComponentOutsidePressEffectProps = {
+ thread: Pick<FrontComponentThread, 'imports'>;
+ outsidePressController: HostOutsidePressController;
+};
+
+export const FrontComponentOutsidePressEffect = ({
+ thread,
+ outsidePressController,
+}: FrontComponentOutsidePressEffectProps) => {
+ useEffect(() => {
+ let hasWarnedAboutPressPushFailure = false;
+
+ const warnAboutPressPushFailure = () => {
+ if (hasWarnedAboutPressPushFailure) {
+ return;
+ }
+
+ hasWarnedAboutPressPushFailure = true;
+ console.warn(PRESS_TRANSPORT_FAILURE_WARNING);
+ };
+
+ outsidePressController.setPressEventTransport({
+ pushOutsidePressEvent: (eventData) => {
+ thread.imports
+ .pushOutsidePressEvent(eventData)
+ .catch(warnAboutPressPushFailure);
+ },
+ pushOwnedPressEvent: (eventData) => {
+ thread.imports
+ .pushOwnedPressEvent(eventData)
+ .catch(warnAboutPressPushFailure);
+ },
+ });
+
+ return () => {
+ outsidePressController.reset();
+ };
+ }, [thread, outsidePressController]);
+
+ return null;
+};
diff --git a/packages/twenty-front-component-renderer/src/host/effect-components/FrontComponentWorkerEffect.tsx b/packages/twenty-front-component-renderer/src/host/effect-components/FrontComponentWorkerEffect.tsx
index b226f3a0436..6bec2e16073 100644
--- a/packages/twenty-front-component-renderer/src/host/effect-components/FrontComponentWorkerEffect.tsx
+++ b/packages/twenty-front-component-renderer/src/host/effect-components/FrontComponentWorkerEffect.tsx
@@ -7,6 +7,7 @@ import { createFileInputAwareRemoteConnection } from '@/host/file-input/utils/cr
import { createFileInputHost } from '@/host/file-input/utils/createFileInputHost';
import { type HostFocusController } from '@/host/focus/types/HostFocusController';
import { createFocusAwareRemoteConnection } from '@/host/focus/utils/createFocusAwareRemoteConnection';
+import { type HostOutsidePressController } from '@/host/events/types/HostOutsidePressController';
import { type HostScrollController } from '@/host/scroll/types/HostScrollController';
import { buildHostFetchPolicyFromFrontComponentUrls } from '@/host/fetch/utils/buildHostFetchPolicyFromFrontComponentUrls';
import { createFrontComponentHostThread } from '@/host/thread/utils/createFrontComponentHostThread';
@@ -43,6 +44,7 @@ type FrontComponentWorkerEffectProps = {
setReceiver: React.Dispatch<React.SetStateAction<RemoteReceiver | null>>;
hostFocusController: HostFocusController;
hostScrollController: HostScrollController;
+ outsidePressController: HostOutsidePressController;
setThread: React.Dispatch<React.SetStateAction<FrontComponentThread | null>>;
setError: React.Dispatch<React.SetStateAction<Error | null>>;
};
@@ -50,6 +52,7 @@ type FrontComponentWorkerEffectProps = {
export const FrontComponentWorkerEffect = ({
hostFocusController,
hostScrollController,
+ outsidePressController,
componentUrl,
applicationAccessToken,
apiUrl,
@@ -98,6 +101,7 @@ export const FrontComponentWorkerEffect = ({
hostFetch,
imageLoadingHost,
geometryTracker,
+ outsidePressController,
mediaSessionHost,
});
@@ -218,6 +222,7 @@ export const FrontComponentWorkerEffect = ({
geometryTracker,
hostFocusController,
hostScrollController,
+ outsidePressController,
mediaSessionHost,
setError,
setReceiver,
diff --git a/packages/twenty-front-component-renderer/src/host/effect-components/__tests__/FrontComponentWorkerEffect.test.ts b/packages/twenty-front-component-renderer/src/host/effect-components/__tests__/FrontComponentWorkerEffect.test.ts
index eeb80714014..d293c6ddc76 100644
--- a/packages/twenty-front-component-renderer/src/host/effect-components/__tests__/FrontComponentWorkerEffect.test.ts
+++ b/packages/twenty-front-component-renderer/src/host/effect-components/__tests__/FrontComponentWorkerEffect.test.ts
@@ -9,6 +9,7 @@ import { type HostFocusController } from '@/host/focus/types/HostFocusController
import { type HostScrollController } from '@/host/scroll/types/HostScrollController';
import { createFrontComponentHostThread } from '@/host/thread/utils/createFrontComponentHostThread';
import { createGeometryTrackerStub } from '@/testing/createGeometryTrackerStub';
+import { createHostOutsidePressControllerStub } from '@/testing/createHostOutsidePressControllerStub';
import { type FrontComponentThread } from '@/types/FrontComponentThread';
import { FrontComponentWorkerEffect } from '../FrontComponentWorkerEffect';
@@ -121,6 +122,7 @@ describe('FrontComponentWorkerEffect', () => {
geometryTracker: createGeometryTrackerStub(),
hostFocusController: createHostFocusControllerStub(),
hostScrollController: createHostScrollControllerStub(),
+ outsidePressController: createHostOutsidePressControllerStub(),
setReceiver,
setThread: jest.fn(),
setError,
diff --git a/packages/twenty-front-component-renderer/src/host/events/states/forwardedBubblingHostEvents.ts b/packages/twenty-front-component-renderer/src/host/events/states/forwardedBubblingHostEvents.ts
new file mode 100644
index 00000000000..06243b8ffdc
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/events/states/forwardedBubblingHostEvents.ts
@@ -0,0 +1 @@
+export const forwardedBubblingHostEvents = new WeakSet<object>();
diff --git a/packages/twenty-front-component-renderer/src/host/events/types/HostOutsidePressController.ts b/packages/twenty-front-component-renderer/src/host/events/types/HostOutsidePressController.ts
new file mode 100644
index 00000000000..7779a0aa85b
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/events/types/HostOutsidePressController.ts
@@ -0,0 +1,10 @@
+import { type HostEventDispatchFields } from '@/host/events/types/HostEventDispatchFields';
+import { type PressEventTransport } from '@/host/events/types/PressEventTransport';
+
+export type HostOutsidePressController = {
+ observeOutsidePresses: () => void;
+ unobserveOutsidePresses: () => void;
+ setPressEventTransport: (pressEventTransport: PressEventTransport) => void;
+ forwardUnhandledOwnedPress: (hostEvent: HostEventDispatchFields) => void;
+ reset: () => void;
+};
diff --git a/packages/twenty-front-component-renderer/src/host/events/types/HostPointerCaptureController.ts b/packages/twenty-front-component-renderer/src/host/events/types/HostPointerCaptureController.ts
index 4959e8f01c1..3f9c2c33455 100644
--- a/packages/twenty-front-component-renderer/src/host/events/types/HostPointerCaptureController.ts
+++ b/packages/twenty-front-component-renderer/src/host/events/types/HostPointerCaptureController.ts
@@ -7,6 +7,7 @@ export type HostPointerCaptureController = {
pointerId: number;
}) => void;
claimPointerEventForwarding: ClaimPointerEventForwarding;
+ hasActivePointerCaptureForEvent: (event: object) => boolean;
setPushCapturedPointerEvent: (
pushCapturedPointerEvent: PushCapturedPointerEvent | null,
) => void;
diff --git a/packages/twenty-front-component-renderer/src/host/events/types/PressEventTransport.ts b/packages/twenty-front-component-renderer/src/host/events/types/PressEventTransport.ts
new file mode 100644
index 00000000000..d374ad4b765
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/events/types/PressEventTransport.ts
@@ -0,0 +1,7 @@
+import { type PushOutsidePressEvent } from '@/host/events/types/PushOutsidePressEvent';
+import { type PushOwnedPressEvent } from '@/host/events/types/PushOwnedPressEvent';
+
+export type PressEventTransport = {
+ pushOutsidePressEvent: PushOutsidePressEvent;
+ pushOwnedPressEvent: PushOwnedPressEvent;
+};
diff --git a/packages/twenty-front-component-renderer/src/host/events/types/PushOutsidePressEvent.ts b/packages/twenty-front-component-renderer/src/host/events/types/PushOutsidePressEvent.ts
new file mode 100644
index 00000000000..7a12d2fbba0
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/events/types/PushOutsidePressEvent.ts
@@ -0,0 +1,3 @@
+import { type OutsidePressEventData } from '@/types/OutsidePressEventData';
+
+export type PushOutsidePressEvent = (eventData: OutsidePressEventData) => void;
diff --git a/packages/twenty-front-component-renderer/src/host/events/types/PushOwnedPressEvent.ts b/packages/twenty-front-component-renderer/src/host/events/types/PushOwnedPressEvent.ts
new file mode 100644
index 00000000000..15458d367bd
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/events/types/PushOwnedPressEvent.ts
@@ -0,0 +1,3 @@
+import { type SerializedEventData } from '@/types/SerializedEventData';
+
+export type PushOwnedPressEvent = (eventData: SerializedEventData) => void;
diff --git a/packages/twenty-front-component-renderer/src/host/events/utils/__tests__/createHostOutsidePressController.test.ts b/packages/twenty-front-component-renderer/src/host/events/utils/__tests__/createHostOutsidePressController.test.ts
new file mode 100644
index 00000000000..5443daf22f2
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/events/utils/__tests__/createHostOutsidePressController.test.ts
@@ -0,0 +1,169 @@
+import { createHostOutsidePressController } from '@/host/events/utils/createHostOutsidePressController';
+import { wrapEventHandler } from '@/host/events/utils/wrapEventHandler';
+import { createGeometryTracker } from '@/host/geometry/utils/createGeometryTracker';
+import { createHostPointerCaptureControllerStub } from '@/testing/createHostPointerCaptureControllerStub';
+
+const createOutsidePressControllerFixture = () => {
+ const ownedButton = document.createElement('button');
+ const outsideButton = document.createElement('button');
+ const geometryTracker = createGeometryTracker();
+ const pointerCaptureController = createHostPointerCaptureControllerStub();
+
+ document.body.append(ownedButton, outsideButton);
+ geometryTracker.registerNode('owned-button', ownedButton);
+
+ return {
+ ownedButton,
+ outsideButton,
+ pointerCaptureController,
+ controller: createHostOutsidePressController({
+ geometryTracker,
+ pointerCaptureController,
+ }),
+ pressEventTransport: {
+ pushOutsidePressEvent: jest.fn(),
+ pushOwnedPressEvent: jest.fn(),
+ },
+ };
+};
+
+const clickElement = (element: Element) => {
+ element.dispatchEvent(new MouseEvent('click', { bubbles: true, detail: 1 }));
+};
+
+describe('createHostOutsidePressController', () => {
+ afterEach(() => {
+ document.body.replaceChildren();
+ });
+
+ it('forwards outside presses only while the worker observes them', () => {
+ const { ownedButton, outsideButton, controller, pressEventTransport } =
+ createOutsidePressControllerFixture();
+
+ try {
+ controller.setPressEventTransport(pressEventTransport);
+ clickElement(outsideButton);
+
+ expect(pressEventTransport.pushOutsidePressEvent).not.toHaveBeenCalled();
+
+ controller.observeOutsidePresses();
+ controller.observeOutsidePresses();
+ clickElement(ownedButton);
+ clickElement(outsideButton);
+
+ expect(pressEventTransport.pushOutsidePressEvent).toHaveBeenCalledTimes(
+ 1,
+ );
+
+ controller.unobserveOutsidePresses();
+ clickElement(outsideButton);
+
+ expect(pressEventTransport.pushOutsidePressEvent).toHaveBeenCalledTimes(
+ 1,
+ );
+ } finally {
+ controller.reset();
+ }
+ });
+
+ it('waits for the press transport and forgets the observation on reset', () => {
+ const { outsideButton, controller, pressEventTransport } =
+ createOutsidePressControllerFixture();
+
+ try {
+ controller.observeOutsidePresses();
+ controller.setPressEventTransport(pressEventTransport);
+ clickElement(outsideButton);
+
+ expect(pressEventTransport.pushOutsidePressEvent).toHaveBeenCalledTimes(
+ 1,
+ );
+
+ controller.reset();
+ controller.setPressEventTransport(pressEventTransport);
+ clickElement(outsideButton);
+
+ expect(pressEventTransport.pushOutsidePressEvent).toHaveBeenCalledTimes(
+ 1,
+ );
+ } finally {
+ controller.reset();
+ }
+ });
+
+ it('forwards an owned press that no element handler forwarded, at its target, while the worker observes', () => {
+ const { ownedButton, controller, pressEventTransport } =
+ createOutsidePressControllerFixture();
+ const hostEvent = {
+ type: 'pointerdown',
+ bubbles: true,
+ target: ownedButton,
+ clientX: 12,
+ };
+
+ try {
+ controller.setPressEventTransport(pressEventTransport);
+ controller.forwardUnhandledOwnedPress(hostEvent);
+
+ expect(pressEventTransport.pushOwnedPressEvent).not.toHaveBeenCalled();
+
+ controller.observeOutsidePresses();
+ controller.forwardUnhandledOwnedPress(hostEvent);
+ controller.forwardUnhandledOwnedPress(hostEvent);
+
+ expect(pressEventTransport.pushOwnedPressEvent.mock.calls).toEqual([
+ [
+ expect.objectContaining({
+ type: 'pointerdown',
+ bubbles: true,
+ targetRemoteElementId: 'owned-button',
+ clientX: 12,
+ }),
+ ],
+ ]);
+ } finally {
+ controller.reset();
+ }
+ });
+
+ it('leaves presses that an element handler or a capture session forwarded, and presses outside the component', () => {
+ const {
+ ownedButton,
+ outsideButton,
+ pointerCaptureController,
+ controller,
+ pressEventTransport,
+ } = createOutsidePressControllerFixture();
+ const remoteListener = jest.fn();
+ const forwardedHostEvent = {
+ type: 'click',
+ bubbles: true,
+ target: ownedButton,
+ };
+
+ try {
+ controller.setPressEventTransport(pressEventTransport);
+ controller.observeOutsidePresses();
+ wrapEventHandler({ remoteListener })(forwardedHostEvent);
+ controller.forwardUnhandledOwnedPress(forwardedHostEvent);
+ jest
+ .mocked(pointerCaptureController.claimPointerEventForwarding)
+ .mockReturnValueOnce(false);
+ controller.forwardUnhandledOwnedPress({
+ type: 'pointerup',
+ bubbles: true,
+ target: ownedButton,
+ });
+ controller.forwardUnhandledOwnedPress({
+ type: 'click',
+ bubbles: true,
+ target: outsideButton,
+ });
+
+ expect(remoteListener).toHaveBeenCalledTimes(1);
+ expect(pressEventTransport.pushOwnedPressEvent).not.toHaveBeenCalled();
+ } finally {
+ controller.reset();
+ }
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/host/events/utils/__tests__/createHostPointerCaptureController.test.ts b/packages/twenty-front-component-renderer/src/host/events/utils/__tests__/createHostPointerCaptureController.test.ts
index cd46441e9a1..1741d4cc5e7 100644
--- a/packages/twenty-front-component-renderer/src/host/events/utils/__tests__/createHostPointerCaptureController.test.ts
+++ b/packages/twenty-front-component-renderer/src/host/events/utils/__tests__/createHostPointerCaptureController.test.ts
@@ -1,8 +1,28 @@
+import { isDefined } from 'twenty-shared/utils';
+
import { wrapEventHandler } from '@/host/events/utils/wrapEventHandler';
import { createGeometryTracker } from '@/host/geometry/utils/createGeometryTracker';
import { createHostPointerCaptureController } from '../createHostPointerCaptureController';
+const findRegisteredListener = ({
+ addEventListenerCalls,
+ eventType,
+}: {
+ addEventListenerCalls: Parameters<EventTarget['addEventListener']>[];
+ eventType: string;
+}): EventListener => {
+ const listener = addEventListenerCalls.find(
+ ([registeredEventType]) => registeredEventType === eventType,
+ )?.[1];
+
+ if (!isDefined(listener) || 'handleEvent' in listener) {
+ throw new Error(`Expected a ${eventType} listener function`);
+ }
+
+ return listener;
+};
+
const createCaptureFixture = () => {
const element = Object.assign(document.createElement('div'), {
hasPointerCapture: jest.fn(() => true),
@@ -33,35 +53,25 @@ const startCapturedGesture = ({
controller.startPointerCapture({ element, pointerId });
- const findListener = ({
- addListener,
- eventType,
- }: {
- addListener: typeof addDocumentListener | typeof addElementListener;
- eventType: string;
- }) =>
- addListener.mock.calls.find(
- ([listenedEventType]) => listenedEventType === eventType,
- )![1] as (event: PointerEvent) => void;
const capturedGestureListeners = {
- handlePointerMove: findListener({
- addListener: addDocumentListener,
+ handlePointerMove: findRegisteredListener({
+ addEventListenerCalls: addDocumentListener.mock.calls,
eventType: 'pointermove',
}),
- handlePointerUp: findListener({
- addListener: addDocumentListener,
+ handlePointerUp: findRegisteredListener({
+ addEventListenerCalls: addDocumentListener.mock.calls,
eventType: 'pointerup',
}),
- handleCapturingElementPointerMove: findListener({
- addListener: addElementListener,
+ handleCapturingElementPointerMove: findRegisteredListener({
+ addEventListenerCalls: addElementListener.mock.calls,
eventType: 'pointermove',
}),
- handleCapturingElementPointerUp: findListener({
- addListener: addElementListener,
+ handleCapturingElementPointerUp: findRegisteredListener({
+ addEventListenerCalls: addElementListener.mock.calls,
eventType: 'pointerup',
}),
- handleCaptureLoss: findListener({
- addListener: addElementListener,
+ handleCaptureLoss: findRegisteredListener({
+ addEventListenerCalls: addElementListener.mock.calls,
eventType: 'lostpointercapture',
}),
};
@@ -89,6 +99,53 @@ describe('createHostPointerCaptureController', () => {
document.body.replaceChildren();
});
+ it('keeps a release after capture loss on the captured event path until it is forwarded', () => {
+ const { controller, element, pushCapturedPointerEvent } =
+ createCaptureFixture();
+ const { handleCaptureLoss, handlePointerUp } = startCapturedGesture({
+ controller,
+ element,
+ pointerId: 0,
+ });
+
+ try {
+ element.hasPointerCapture.mockReturnValue(false);
+ handleCaptureLoss(
+ createNativePointerEvent({ type: 'lostpointercapture', pointerId: 0 }),
+ );
+ const event = createNativePointerEvent({
+ type: 'pointerup',
+ pointerId: 0,
+ });
+
+ expect(controller.hasActivePointerCaptureForEvent(event)).toBe(true);
+ expect(
+ controller.hasActivePointerCaptureForEvent(
+ createNativePointerEvent({ type: 'pointerup', pointerId: 1 }),
+ ),
+ ).toBe(false);
+ expect(
+ controller.hasActivePointerCaptureForEvent(
+ createNativePointerEvent({
+ type: 'pointerup',
+ pointerId: 0,
+ isTrusted: false,
+ }),
+ ),
+ ).toBe(false);
+ handlePointerUp(event);
+
+ expect(
+ pushCapturedPointerEvent.mock.calls.map(
+ ([update]) => update.eventData.type,
+ ),
+ ).toEqual(['lostpointercapture', 'pointerup']);
+ expect(controller.hasActivePointerCaptureForEvent(event)).toBe(false);
+ } finally {
+ controller.reset();
+ }
+ });
+
it('should forward every event of the captured pointer, inside or outside the element, until its release', () => {
const { controller, element, pushCapturedPointerEvent } =
createCaptureFixture();
diff --git a/packages/twenty-front-component-renderer/src/host/events/utils/__tests__/trackHostOutsidePress.test.ts b/packages/twenty-front-component-renderer/src/host/events/utils/__tests__/trackHostOutsidePress.test.ts
new file mode 100644
index 00000000000..9b79cd876bb
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/events/utils/__tests__/trackHostOutsidePress.test.ts
@@ -0,0 +1,244 @@
+import { OUTSIDE_PRESS_EVENT_TYPES } from '@/constants/OutsidePressEventTypes';
+import { trackHostOutsidePress } from '@/host/events/utils/trackHostOutsidePress';
+import { createGeometryTracker } from '@/host/geometry/utils/createGeometryTracker';
+
+const createOutsidePressTracker = ({
+ ownedElements = [],
+ hasActivePointerCaptureForEvent = () => false,
+}: {
+ ownedElements?: Element[];
+ hasActivePointerCaptureForEvent?: (event: object) => boolean;
+} = {}) => {
+ const geometryTracker = createGeometryTracker();
+
+ for (const [ownedElementIndex, ownedElement] of ownedElements.entries()) {
+ geometryTracker.registerNode(
+ `owned-element-${ownedElementIndex}`,
+ ownedElement,
+ );
+ }
+
+ const pushOutsidePressEvent = jest.fn();
+ const dispose = trackHostOutsidePress({
+ findRemoteElementIdContainingNode:
+ geometryTracker.findRemoteElementIdContainingNode,
+ pushOutsidePressEvent,
+ hasActivePointerCaptureForEvent,
+ });
+
+ return { pushOutsidePressEvent, dispose };
+};
+
+const createPress = (type: string) =>
+ new MouseEvent(type, { bubbles: true, detail: 1 });
+
+const createPressAtHorizontalOffset = ({
+ type,
+ offsetX,
+}: {
+ type: string;
+ offsetX: number;
+}) => {
+ const event = createPress(type);
+
+ Object.defineProperty(event, 'offsetX', { value: offsetX });
+
+ return event;
+};
+
+const readForwardedEventTypes = (pushOutsidePressEvent: jest.Mock) =>
+ pushOutsidePressEvent.mock.calls.map(([eventData]) => eventData.type);
+
+describe('trackHostOutsidePress', () => {
+ afterEach(() => {
+ document.body.replaceChildren();
+ });
+
+ it('forwards press metadata without exposing an outside control or its coordinates', () => {
+ const outsideInput = document.createElement('input');
+ outsideInput.value = 'private host value';
+ document.body.append(outsideInput);
+ const { pushOutsidePressEvent, dispose } = createOutsidePressTracker();
+ const event = new MouseEvent('mousedown', {
+ bubbles: true,
+ cancelable: true,
+ button: 0,
+ buttons: 1,
+ detail: 1,
+ clientX: 420,
+ clientY: 240,
+ altKey: true,
+ });
+
+ try {
+ outsideInput.dispatchEvent(event);
+
+ expect(pushOutsidePressEvent.mock.calls).toEqual([
+ [
+ {
+ type: 'mousedown',
+ button: 0,
+ buttons: 1,
+ detail: 1,
+ pointerType: 'mouse',
+ },
+ ],
+ ]);
+ expect(event.defaultPrevented).toBe(false);
+ expect(outsideInput.value).toBe('private host value');
+ } finally {
+ dispose();
+ }
+ });
+
+ it('leaves owned descendants and portal targets on their existing event path', () => {
+ const root = document.createElement('div');
+ const portal = document.createElement('div');
+ const child = document.createElement('button');
+ const portalChild = document.createElement('button');
+ root.append(child);
+ portal.append(portalChild);
+ document.body.append(root, portal);
+ const { pushOutsidePressEvent, dispose } = createOutsidePressTracker({
+ ownedElements: [root, portal],
+ });
+
+ try {
+ child.dispatchEvent(createPress('click'));
+ portalChild.dispatchEvent(createPress('click'));
+
+ expect(pushOutsidePressEvent).not.toHaveBeenCalled();
+ } finally {
+ dispose();
+ }
+ });
+
+ it('forwards the press sequence during capture without forwarding unrelated events', () => {
+ const outsideButton = document.createElement('button');
+ document.body.append(outsideButton);
+ const { pushOutsidePressEvent, dispose } = createOutsidePressTracker();
+
+ try {
+ for (const eventType of OUTSIDE_PRESS_EVENT_TYPES) {
+ outsideButton.addEventListener(eventType, (event) =>
+ event.stopPropagation(),
+ );
+ outsideButton.dispatchEvent(createPress(eventType));
+ }
+ outsideButton.dispatchEvent(
+ new MouseEvent('mousemove', { bubbles: true }),
+ );
+ outsideButton.dispatchEvent(
+ new KeyboardEvent('keydown', { key: 'a', bubbles: true }),
+ );
+
+ expect(readForwardedEventTypes(pushOutsidePressEvent)).toEqual(
+ OUTSIDE_PRESS_EVENT_TYPES,
+ );
+ } finally {
+ dispose();
+ }
+ });
+
+ it('skips clicks without a press, such as keyboard activation of a host control', () => {
+ const outsideButton = document.createElement('button');
+ document.body.append(outsideButton);
+ const { pushOutsidePressEvent, dispose } = createOutsidePressTracker();
+
+ try {
+ outsideButton.dispatchEvent(
+ new MouseEvent('click', { bubbles: true, detail: 0 }),
+ );
+
+ expect(pushOutsidePressEvent).not.toHaveBeenCalled();
+ } finally {
+ dispose();
+ }
+ });
+
+ it('skips presses on a host scrollbar', () => {
+ const scrollContainer = document.createElement('div');
+ scrollContainer.style.overflowY = 'auto';
+ Object.defineProperties(scrollContainer, {
+ clientWidth: { value: 100 },
+ offsetWidth: { value: 115 },
+ clientHeight: { value: 100 },
+ scrollHeight: { value: 400 },
+ });
+ document.body.append(scrollContainer);
+ const { pushOutsidePressEvent, dispose } = createOutsidePressTracker();
+
+ try {
+ scrollContainer.dispatchEvent(
+ createPressAtHorizontalOffset({ type: 'mousedown', offsetX: 105 }),
+ );
+ scrollContainer.dispatchEvent(
+ createPressAtHorizontalOffset({ type: 'mousedown', offsetX: 50 }),
+ );
+
+ expect(readForwardedEventTypes(pushOutsidePressEvent)).toEqual([
+ 'mousedown',
+ ]);
+ } finally {
+ dispose();
+ }
+ });
+
+ it('keeps the compatibility events after a captured release off the outside path', () => {
+ const outsideButton = document.createElement('button');
+ document.body.append(outsideButton);
+ const firstCapturedRelease = createPress('pointerup');
+ const secondCapturedRelease = createPress('pointerup');
+ const capturedReleases = new Set<object>([
+ firstCapturedRelease,
+ secondCapturedRelease,
+ ]);
+ const { pushOutsidePressEvent, dispose } = createOutsidePressTracker({
+ hasActivePointerCaptureForEvent: (event) => capturedReleases.has(event),
+ });
+
+ try {
+ outsideButton.dispatchEvent(firstCapturedRelease);
+ outsideButton.dispatchEvent(createPress('mouseup'));
+ outsideButton.dispatchEvent(createPress('click'));
+ outsideButton.dispatchEvent(createPress('click'));
+ outsideButton.dispatchEvent(secondCapturedRelease);
+ outsideButton.dispatchEvent(createPress('pointerdown'));
+ outsideButton.dispatchEvent(createPress('mouseup'));
+
+ expect(readForwardedEventTypes(pushOutsidePressEvent)).toEqual([
+ 'click',
+ 'pointerdown',
+ 'mouseup',
+ ]);
+ } finally {
+ dispose();
+ }
+ });
+
+ it('keeps renderer ownership and teardown independent', () => {
+ const firstButton = document.createElement('button');
+ const secondButton = document.createElement('button');
+ document.body.append(firstButton, secondButton);
+ const firstTracker = createOutsidePressTracker({
+ ownedElements: [firstButton],
+ });
+ const secondTracker = createOutsidePressTracker({
+ ownedElements: [secondButton],
+ });
+
+ try {
+ firstButton.dispatchEvent(createPress('click'));
+ expect(firstTracker.pushOutsidePressEvent).not.toHaveBeenCalled();
+ expect(secondTracker.pushOutsidePressEvent).toHaveBeenCalledTimes(1);
+
+ secondTracker.dispose();
+ document.body.dispatchEvent(createPress('click'));
+ expect(firstTracker.pushOutsidePressEvent).toHaveBeenCalledTimes(1);
+ expect(secondTracker.pushOutsidePressEvent).toHaveBeenCalledTimes(1);
+ } finally {
+ firstTracker.dispose();
+ secondTracker.dispose();
+ }
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/host/events/utils/createCapturedGestureEventFilter.ts b/packages/twenty-front-component-renderer/src/host/events/utils/createCapturedGestureEventFilter.ts
new file mode 100644
index 00000000000..52343578a44
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/events/utils/createCapturedGestureEventFilter.ts
@@ -0,0 +1,22 @@
+export const createCapturedGestureEventFilter = (
+ hasActivePointerCaptureForEvent: (event: object) => boolean,
+): ((event: MouseEvent) => boolean) => {
+ let isAwaitingReleaseCompatibilityEvents = false;
+
+ return (event) => {
+ if (hasActivePointerCaptureForEvent(event)) {
+ isAwaitingReleaseCompatibilityEvents = event.type === 'pointerup';
+ return true;
+ }
+
+ const isReleaseCompatibilityEvent =
+ isAwaitingReleaseCompatibilityEvents &&
+ (event.type === 'mouseup' || event.type === 'click');
+
+ if (event.type === 'pointerdown' || event.type === 'click') {
+ isAwaitingReleaseCompatibilityEvents = false;
+ }
+
+ return isReleaseCompatibilityEvent;
+ };
+};
diff --git a/packages/twenty-front-component-renderer/src/host/events/utils/createHostOutsidePressController.ts b/packages/twenty-front-component-renderer/src/host/events/utils/createHostOutsidePressController.ts
new file mode 100644
index 00000000000..fc6b2980b87
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/events/utils/createHostOutsidePressController.ts
@@ -0,0 +1,100 @@
+import { isDefined } from 'twenty-shared/utils';
+
+import { forwardedBubblingHostEvents } from '@/host/events/states/forwardedBubblingHostEvents';
+import { type HostEventDispatchFields } from '@/host/events/types/HostEventDispatchFields';
+import { type HostOutsidePressController } from '@/host/events/types/HostOutsidePressController';
+import { type HostPointerCaptureController } from '@/host/events/types/HostPointerCaptureController';
+import { type PressEventTransport } from '@/host/events/types/PressEventTransport';
+import { applyEventDispatchProperties } from '@/host/events/utils/applyEventDispatchProperties';
+import { resolveNativeHostEvent } from '@/host/events/utils/resolveNativeHostEvent';
+import { serializeEvent } from '@/host/events/utils/serializeEvent';
+import { trackHostOutsidePress } from '@/host/events/utils/trackHostOutsidePress';
+import { type GeometryTracker } from '@/host/geometry/types/GeometryTracker';
+
+export const createHostOutsidePressController = ({
+ geometryTracker,
+ pointerCaptureController,
+}: {
+ geometryTracker: Pick<GeometryTracker, 'findRemoteElementIdContainingNode'>;
+ pointerCaptureController: Pick<
+ HostPointerCaptureController,
+ 'claimPointerEventForwarding' | 'hasActivePointerCaptureForEvent'
+ >;
+}): HostOutsidePressController => {
+ let isObservedByWorker = false;
+ let pressEventTransport: PressEventTransport | null = null;
+ let stopTrackingHostOutsidePress: (() => void) | null = null;
+
+ const syncHostOutsidePressTracking = () => {
+ const shouldTrack = isObservedByWorker && isDefined(pressEventTransport);
+
+ if (!shouldTrack) {
+ stopTrackingHostOutsidePress?.();
+ stopTrackingHostOutsidePress = null;
+ return;
+ }
+
+ if (isDefined(stopTrackingHostOutsidePress)) {
+ return;
+ }
+
+ stopTrackingHostOutsidePress = trackHostOutsidePress({
+ findRemoteElementIdContainingNode:
+ geometryTracker.findRemoteElementIdContainingNode,
+ hasActivePointerCaptureForEvent:
+ pointerCaptureController.hasActivePointerCaptureForEvent,
+ pushOutsidePressEvent: (eventData) =>
+ pressEventTransport?.pushOutsidePressEvent(eventData),
+ });
+ };
+
+ const forwardUnhandledOwnedPress = (hostEvent: HostEventDispatchFields) => {
+ if (
+ !isObservedByWorker ||
+ !isDefined(pressEventTransport) ||
+ forwardedBubblingHostEvents.has(hostEvent) ||
+ !isDefined(
+ geometryTracker.findRemoteElementIdContainingNode(hostEvent.target),
+ ) ||
+ !pointerCaptureController.claimPointerEventForwarding(
+ resolveNativeHostEvent(hostEvent),
+ )
+ ) {
+ return;
+ }
+
+ const serializedEvent = serializeEvent(hostEvent, {
+ includesFormControlState: false,
+ });
+
+ applyEventDispatchProperties({
+ serializedEvent,
+ hostEvent,
+ findRemoteElementIdContainingNode:
+ geometryTracker.findRemoteElementIdContainingNode,
+ });
+ forwardedBubblingHostEvents.add(hostEvent);
+ pressEventTransport.pushOwnedPressEvent(serializedEvent);
+ };
+
+ return {
+ observeOutsidePresses: () => {
+ isObservedByWorker = true;
+ syncHostOutsidePressTracking();
+ },
+ unobserveOutsidePresses: () => {
+ isObservedByWorker = false;
+ syncHostOutsidePressTracking();
+ },
+ setPressEventTransport: (nextPressEventTransport) => {
+ pressEventTransport = nextPressEventTransport;
+ syncHostOutsidePressTracking();
+ },
+ forwardUnhandledOwnedPress,
+ reset: () => {
+ isObservedByWorker = false;
+ pressEventTransport = null;
+ syncHostOutsidePressTracking();
+ },
+ };
+};
diff --git a/packages/twenty-front-component-renderer/src/host/events/utils/createHostPointerCaptureController.ts b/packages/twenty-front-component-renderer/src/host/events/utils/createHostPointerCaptureController.ts
index f05b91d0c60..fac83a2c0c1 100644
--- a/packages/twenty-front-component-renderer/src/host/events/utils/createHostPointerCaptureController.ts
+++ b/packages/twenty-front-component-renderer/src/host/events/utils/createHostPointerCaptureController.ts
@@ -1,3 +1,4 @@
+import { isInteger } from '@sniptt/guards';
import { isDefined } from 'twenty-shared/utils';
import { CAPTURED_POINTER_EVENT_TYPES } from '@/constants/CapturedPointerEventTypes';
@@ -65,6 +66,13 @@ export const createHostPointerCaptureController = ({
return {
startPointerCapture,
claimPointerEventForwarding,
+ hasActivePointerCaptureForEvent: (event) =>
+ isCapturedPointerEvent(event) &&
+ 'isTrusted' in event &&
+ event.isTrusted === true &&
+ 'pointerId' in event &&
+ isInteger(event.pointerId) &&
+ endSessionByPointerId.has(event.pointerId),
setPushCapturedPointerEvent: (nextPushCapturedPointerEvent) => {
pushCapturedPointerEvent = nextPushCapturedPointerEvent;
},
diff --git a/packages/twenty-front-component-renderer/src/host/events/utils/isPressLessClick.ts b/packages/twenty-front-component-renderer/src/host/events/utils/isPressLessClick.ts
new file mode 100644
index 00000000000..0620b374bcc
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/events/utils/isPressLessClick.ts
@@ -0,0 +1,3 @@
+export const isPressLessClick = (
+ event: Pick<MouseEvent, 'type' | 'detail'>,
+): boolean => event.type === 'click' && event.detail === 0;
diff --git a/packages/twenty-front-component-renderer/src/host/events/utils/isScrollbarPress.ts b/packages/twenty-front-component-renderer/src/host/events/utils/isScrollbarPress.ts
new file mode 100644
index 00000000000..a310a539e1f
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/events/utils/isScrollbarPress.ts
@@ -0,0 +1,40 @@
+import { isDefined } from 'twenty-shared/utils';
+
+const SCROLLABLE_OVERFLOW_PATTERN = /auto|scroll/;
+
+export const isScrollbarPress = (event: MouseEvent): boolean => {
+ const { target } = event;
+
+ if (!(target instanceof HTMLElement)) {
+ return false;
+ }
+
+ const { ownerDocument } = target;
+ const computedStyle = ownerDocument.defaultView?.getComputedStyle(target);
+
+ if (!isDefined(computedStyle)) {
+ return false;
+ }
+
+ const isDocumentScroller =
+ target === ownerDocument.documentElement || target === ownerDocument.body;
+ const canScrollHorizontally =
+ (isDocumentScroller ||
+ SCROLLABLE_OVERFLOW_PATTERN.test(computedStyle.overflowX)) &&
+ target.clientWidth > 0 &&
+ target.scrollWidth > target.clientWidth;
+ const canScrollVertically =
+ (isDocumentScroller ||
+ SCROLLABLE_OVERFLOW_PATTERN.test(computedStyle.overflowY)) &&
+ target.clientHeight > 0 &&
+ target.scrollHeight > target.clientHeight;
+ const isPressOnVerticalScrollbar =
+ canScrollVertically &&
+ (computedStyle.direction === 'rtl'
+ ? event.offsetX <= target.offsetWidth - target.clientWidth
+ : event.offsetX > target.clientWidth);
+ const isPressOnHorizontalScrollbar =
+ canScrollHorizontally && event.offsetY > target.clientHeight;
+
+ return isPressOnVerticalScrollbar || isPressOnHorizontalScrollbar;
+};
diff --git a/packages/twenty-front-component-renderer/src/host/events/utils/trackHostOutsidePress.ts b/packages/twenty-front-component-renderer/src/host/events/utils/trackHostOutsidePress.ts
new file mode 100644
index 00000000000..cf47e7c9a3f
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/events/utils/trackHostOutsidePress.ts
@@ -0,0 +1,61 @@
+import { isString } from '@sniptt/guards';
+import { isDefined } from 'twenty-shared/utils';
+
+import { OUTSIDE_PRESS_EVENT_TYPES } from '@/constants/OutsidePressEventTypes';
+import { type PushOutsidePressEvent } from '@/host/events/types/PushOutsidePressEvent';
+import { createCapturedGestureEventFilter } from '@/host/events/utils/createCapturedGestureEventFilter';
+import { isPressLessClick } from '@/host/events/utils/isPressLessClick';
+import { isScrollbarPress } from '@/host/events/utils/isScrollbarPress';
+import { type FindRemoteElementIdContainingNode } from '@/host/geometry/types/FindRemoteElementIdContainingNode';
+import { isOutsidePressEventType } from '@/utils/isOutsidePressEventType';
+
+export const trackHostOutsidePress = ({
+ findRemoteElementIdContainingNode,
+ hasActivePointerCaptureForEvent,
+ pushOutsidePressEvent,
+}: {
+ findRemoteElementIdContainingNode: FindRemoteElementIdContainingNode;
+ hasActivePointerCaptureForEvent: (event: object) => boolean;
+ pushOutsidePressEvent: PushOutsidePressEvent;
+}): (() => void) => {
+ const isCapturedGestureEvent = createCapturedGestureEventFilter(
+ hasActivePointerCaptureForEvent,
+ );
+
+ const handleOutsidePress = (event: MouseEvent) => {
+ if (
+ !isOutsidePressEventType(event.type) ||
+ isCapturedGestureEvent(event) ||
+ isPressLessClick(event) ||
+ event
+ .composedPath()
+ .some((target) =>
+ isDefined(findRemoteElementIdContainingNode(target)),
+ ) ||
+ isScrollbarPress(event)
+ ) {
+ return;
+ }
+
+ pushOutsidePressEvent({
+ type: event.type,
+ button: event.button,
+ buttons: event.buttons,
+ detail: event.detail,
+ pointerType:
+ 'pointerType' in event && isString(event.pointerType)
+ ? event.pointerType
+ : 'mouse',
+ });
+ };
+
+ for (const eventType of OUTSIDE_PRESS_EVENT_TYPES) {
+ document.addEventListener(eventType, handleOutsidePress, true);
+ }
+
+ return () => {
+ for (const eventType of OUTSIDE_PRESS_EVENT_TYPES) {
+ document.removeEventListener(eventType, handleOutsidePress, true);
+ }
+ };
+};
diff --git a/packages/twenty-front-component-renderer/src/host/events/utils/wrapEventHandler.ts b/packages/twenty-front-component-renderer/src/host/events/utils/wrapEventHandler.ts
index c6d74aa6883..39d81a8678d 100644
--- a/packages/twenty-front-component-renderer/src/host/events/utils/wrapEventHandler.ts
+++ b/packages/twenty-front-component-renderer/src/host/events/utils/wrapEventHandler.ts
@@ -1,6 +1,7 @@
import { isDefined } from 'twenty-shared/utils';
import { FORM_CONTROL_STATE_SERIALIZED_EVENT_KEYS } from '@/host/events/constants/FormControlStateSerializedEventKeys';
+import { forwardedBubblingHostEvents } from '@/host/events/states/forwardedBubblingHostEvents';
import { type ClaimPointerEventForwarding } from '@/host/events/types/ClaimPointerEventForwarding';
import { type RemoteSerializedEventListener } from '@/host/events/types/RemoteSerializedEventListener';
import { applyEventDispatchProperties } from '@/host/events/utils/applyEventDispatchProperties';
@@ -8,8 +9,6 @@ import { resolveNativeHostEvent } from '@/host/events/utils/resolveNativeHostEve
import { serializeEvent } from '@/host/events/utils/serializeEvent';
import { type FindRemoteElementIdContainingNode } from '@/host/geometry/types/FindRemoteElementIdContainingNode';
-const forwardedBubblingHostEvents = new WeakSet<object>();
-
const nativeHostEventsWithForwardedFormControlState = new WeakSet<object>();
export const wrapEventHandler =
diff --git a/packages/twenty-front-component-renderer/src/host/thread/utils/createFrontComponentHostThread.ts b/packages/twenty-front-component-renderer/src/host/thread/utils/createFrontComponentHostThread.ts
index b4a34e0d378..5f547dc1c50 100644
--- a/packages/twenty-front-component-renderer/src/host/thread/utils/createFrontComponentHostThread.ts
+++ b/packages/twenty-front-component-renderer/src/host/thread/utils/createFrontComponentHostThread.ts
@@ -2,6 +2,7 @@ import { ThreadMessagePort } from '@quilted/threads';
import { isDefined } from 'twenty-shared/utils';
import { FRONT_COMPONENT_HOST_COMMUNICATION_API_NOOP } from '@/host/thread/constants/FrontComponentHostCommunicationApiNoop';
+import { type HostOutsidePressController } from '@/host/events/types/HostOutsidePressController';
import { type GeometryTracker } from '@/host/geometry/types/GeometryTracker';
import { type FrontComponentMediaSessionHost } from '@/host/media/types/FrontComponentMediaSessionHost';
import { type FrontComponentHostThreadExports } from '@/types/FrontComponentHostThreadExports';
@@ -17,6 +18,7 @@ type CreateFrontComponentHostThreadInput = {
hostFetch: HostFetchFunction;
imageLoadingHost: ImageLoadingHost;
geometryTracker: GeometryTracker;
+ outsidePressController: HostOutsidePressController;
mediaSessionHost?: FrontComponentMediaSessionHost;
};
@@ -59,6 +61,7 @@ export const createFrontComponentHostThread = ({
hostFetch,
imageLoadingHost,
geometryTracker,
+ outsidePressController,
mediaSessionHost,
}: CreateFrontComponentHostThreadInput): FrontComponentThread => {
const thread = new ThreadMessagePort<
@@ -77,6 +80,12 @@ export const createFrontComponentHostThread = ({
unobserveElementGeometry: async (remoteElementIds) => {
geometryTracker.unobserve(remoteElementIds);
},
+ observeOutsidePresses: async () => {
+ outsidePressController.observeOutsidePresses();
+ },
+ unobserveOutsidePresses: async () => {
+ outsidePressController.unobserveOutsidePresses();
+ },
},
serialization: createClonableErrorThreadSerialization(),
});
diff --git a/packages/twenty-front-component-renderer/src/polyfills/events/constants/OutsidePressObservationTransportFailureWarning.ts b/packages/twenty-front-component-renderer/src/polyfills/events/constants/OutsidePressObservationTransportFailureWarning.ts
new file mode 100644
index 00000000000..f3939e04130
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/events/constants/OutsidePressObservationTransportFailureWarning.ts
@@ -0,0 +1,2 @@
+export const OUTSIDE_PRESS_OBSERVATION_TRANSPORT_FAILURE_WARNING =
+ '[twenty-front-component] Reporting outside-press listeners to the host failed. Popups inside the front component may not close on presses outside it.';
diff --git a/packages/twenty-front-component-renderer/src/polyfills/events/types/OutsidePressObservationTransport.ts b/packages/twenty-front-component-renderer/src/polyfills/events/types/OutsidePressObservationTransport.ts
new file mode 100644
index 00000000000..edd24ed36dc
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/events/types/OutsidePressObservationTransport.ts
@@ -0,0 +1,6 @@
+import { type FrontComponentHostThreadExports } from '@/types/FrontComponentHostThreadExports';
+
+export type OutsidePressObservationTransport = Pick<
+ FrontComponentHostThreadExports,
+ 'observeOutsidePresses' | 'unobserveOutsidePresses'
+>;
diff --git a/packages/twenty-front-component-renderer/src/polyfills/events/types/WorkerOutsidePressObservation.ts b/packages/twenty-front-component-renderer/src/polyfills/events/types/WorkerOutsidePressObservation.ts
new file mode 100644
index 00000000000..83c6c5cd3b8
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/events/types/WorkerOutsidePressObservation.ts
@@ -0,0 +1,5 @@
+import { type OutsidePressObservationTransport } from '@/polyfills/events/types/OutsidePressObservationTransport';
+
+export type WorkerOutsidePressObservation = {
+ connectTransport: (transport: OutsidePressObservationTransport) => void;
+};
diff --git a/packages/twenty-front-component-renderer/src/polyfills/events/utils/__tests__/installOutsidePressObservation.test.ts b/packages/twenty-front-component-renderer/src/polyfills/events/utils/__tests__/installOutsidePressObservation.test.ts
new file mode 100644
index 00000000000..5af5b17d570
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/events/utils/__tests__/installOutsidePressObservation.test.ts
@@ -0,0 +1,111 @@
+import { Window } from '@remote-dom/polyfill';
+
+import { resolvePolyfillHooks } from '@/polyfills/dom/utils/resolvePolyfillHooks';
+import { installOutsidePressObservation } from '@/polyfills/events/utils/installOutsidePressObservation';
+import { toGlobalScopeRecord } from '@/polyfills/utils/toGlobalScopeRecord';
+
+const createObservationFixture = () => {
+ const polyfillWindow = new Window();
+ const documentTarget = polyfillWindow.document as unknown as Document;
+ const observation = installOutsidePressObservation({
+ hooks: resolvePolyfillHooks([toGlobalScopeRecord(polyfillWindow)]),
+ documentTarget,
+ });
+ const transport = {
+ observeOutsidePresses: jest.fn().mockResolvedValue(undefined),
+ unobserveOutsidePresses: jest.fn().mockResolvedValue(undefined),
+ };
+
+ return { polyfillWindow, documentTarget, observation, transport };
+};
+
+const flushObservationReports = () => Promise.resolve();
+
+describe('installOutsidePressObservation', () => {
+ it('observes outside presses while the document has a press listener', async () => {
+ const { documentTarget, observation, transport } =
+ createObservationFixture();
+ const handlePointerDown = jest.fn();
+ const handleMouseUp = jest.fn();
+ observation.connectTransport(transport);
+
+ documentTarget.addEventListener('pointerdown', handlePointerDown, true);
+ documentTarget.addEventListener('mouseup', handleMouseUp);
+ await flushObservationReports();
+
+ expect(transport.observeOutsidePresses).toHaveBeenCalledTimes(1);
+
+ documentTarget.removeEventListener('pointerdown', handlePointerDown, true);
+ await flushObservationReports();
+
+ expect(transport.unobserveOutsidePresses).not.toHaveBeenCalled();
+
+ documentTarget.removeEventListener('mouseup', handleMouseUp);
+ await flushObservationReports();
+
+ expect(transport.observeOutsidePresses).toHaveBeenCalledTimes(1);
+ expect(transport.unobserveOutsidePresses).toHaveBeenCalledTimes(1);
+ });
+
+ it('ignores other event types and listeners on other targets', async () => {
+ const { documentTarget, observation, transport } =
+ createObservationFixture();
+ const popup = documentTarget.createElement('div');
+ documentTarget.body.append(popup);
+ observation.connectTransport(transport);
+
+ documentTarget.addEventListener('keydown', jest.fn());
+ documentTarget.documentElement.addEventListener('mouseup', jest.fn());
+ documentTarget.body.addEventListener('pointerdown', jest.fn());
+ popup.addEventListener('pointerdown', jest.fn());
+ await flushObservationReports();
+
+ expect(transport.observeOutsidePresses).not.toHaveBeenCalled();
+ });
+
+ it('keeps observing when a listener is replaced within one task', async () => {
+ const { documentTarget, observation, transport } =
+ createObservationFixture();
+ const previousListener = jest.fn();
+ observation.connectTransport(transport);
+ documentTarget.addEventListener('mousedown', previousListener, true);
+ await flushObservationReports();
+
+ documentTarget.removeEventListener('mousedown', previousListener, true);
+ documentTarget.addEventListener('mousedown', jest.fn(), true);
+ await flushObservationReports();
+
+ expect(transport.observeOutsidePresses).toHaveBeenCalledTimes(1);
+ expect(transport.unobserveOutsidePresses).not.toHaveBeenCalled();
+ });
+
+ it('reports listeners registered before the transport connects', async () => {
+ const { documentTarget, observation, transport } =
+ createObservationFixture();
+ documentTarget.addEventListener('pointerup', jest.fn());
+ await flushObservationReports();
+
+ observation.connectTransport(transport);
+
+ expect(transport.observeOutsidePresses).toHaveBeenCalledTimes(1);
+ });
+
+ it('stops observing once a one-shot listener runs and an aborted listener is removed', async () => {
+ const { polyfillWindow, documentTarget, observation, transport } =
+ createObservationFixture();
+ const abortController = new AbortController();
+ observation.connectTransport(transport);
+ documentTarget.addEventListener('mouseup', jest.fn(), { once: true });
+ documentTarget.addEventListener('click', jest.fn(), {
+ signal: abortController.signal,
+ });
+ await flushObservationReports();
+
+ polyfillWindow.document.dispatchEvent(new polyfillWindow.Event('mouseup'));
+ abortController.abort();
+ await flushObservationReports();
+
+ expect(transport.observeOutsidePresses).toHaveBeenCalledTimes(1);
+ expect(transport.unobserveOutsidePresses).toHaveBeenCalledTimes(1);
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/polyfills/events/utils/installOutsidePressObservation.ts b/packages/twenty-front-component-renderer/src/polyfills/events/utils/installOutsidePressObservation.ts
new file mode 100644
index 00000000000..4fce01fc2f1
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/events/utils/installOutsidePressObservation.ts
@@ -0,0 +1,148 @@
+import { type Hooks } from '@remote-dom/polyfill';
+import { CustomError, isDefined } from 'twenty-shared/utils';
+
+import { OUTSIDE_PRESS_OBSERVATION_TRANSPORT_FAILURE_WARNING } from '@/polyfills/events/constants/OutsidePressObservationTransportFailureWarning';
+import { type OutsidePressObservationTransport } from '@/polyfills/events/types/OutsidePressObservationTransport';
+import { type WorkerOutsidePressObservation } from '@/polyfills/events/types/WorkerOutsidePressObservation';
+import { resolveAddEventListenerOptions } from '@/polyfills/utils/resolveAddEventListenerOptions';
+import { isOutsidePressEventType } from '@/utils/isOutsidePressEventType';
+
+type ListenerRegistration = {
+ target: EventTarget;
+ eventType: string;
+ listener: EventListenerOrEventListenerObject | null;
+ options?: boolean | EventListenerOptions;
+};
+
+export const installOutsidePressObservation = ({
+ hooks,
+ documentTarget,
+}: {
+ hooks: Partial<Hooks> | null;
+ documentTarget: Document;
+}): WorkerOutsidePressObservation => {
+ if (!isDefined(hooks)) {
+ throw new CustomError(
+ 'Outside-press observation requires DOM event listener hooks',
+ 'FRONT_COMPONENT_EVENT_LISTENER_HOOKS_UNAVAILABLE',
+ );
+ }
+
+ const registrationKeysByListener = new WeakMap<object, Set<string>>();
+ let registrationCount = 0;
+ let isObservationReported = false;
+ let hasScheduledObservationFlush = false;
+ let hasWarnedAboutTransportFailure = false;
+ let transport: OutsidePressObservationTransport | null = null;
+
+ const warnAboutTransportFailure = (): void => {
+ if (hasWarnedAboutTransportFailure) {
+ return;
+ }
+
+ hasWarnedAboutTransportFailure = true;
+ console.warn(OUTSIDE_PRESS_OBSERVATION_TRANSPORT_FAILURE_WARNING);
+ };
+
+ const flushObservation = (): void => {
+ hasScheduledObservationFlush = false;
+
+ const isObserved = registrationCount > 0;
+
+ if (!isDefined(transport) || isObserved === isObservationReported) {
+ return;
+ }
+
+ isObservationReported = isObserved;
+
+ const observationRequest = isObserved
+ ? transport.observeOutsidePresses()
+ : transport.unobserveOutsidePresses();
+
+ observationRequest.catch(warnAboutTransportFailure);
+ };
+
+ const scheduleObservationFlush = (): void => {
+ if (hasScheduledObservationFlush) {
+ return;
+ }
+
+ hasScheduledObservationFlush = true;
+ queueMicrotask(flushObservation);
+ };
+
+ const resolveRegistrationKey = ({
+ target,
+ eventType,
+ options,
+ }: Omit<ListenerRegistration, 'listener'>): string | undefined => {
+ if (target !== documentTarget || !isOutsidePressEventType(eventType)) {
+ return undefined;
+ }
+
+ const isCapture = resolveAddEventListenerOptions(options).capture === true;
+
+ return `${eventType}:${isCapture}`;
+ };
+
+ const trackAddedListener = ({
+ listener,
+ ...registration
+ }: ListenerRegistration): void => {
+ const registrationKey = resolveRegistrationKey(registration);
+
+ if (!isDefined(registrationKey) || !isDefined(listener)) {
+ return;
+ }
+
+ const registrationKeys =
+ registrationKeysByListener.get(listener) ?? new Set<string>();
+
+ if (registrationKeys.has(registrationKey)) {
+ return;
+ }
+
+ registrationKeys.add(registrationKey);
+ registrationKeysByListener.set(listener, registrationKeys);
+ registrationCount += 1;
+ scheduleObservationFlush();
+ };
+
+ const trackRemovedListener = ({
+ listener,
+ ...registration
+ }: ListenerRegistration): void => {
+ const registrationKey = resolveRegistrationKey(registration);
+
+ if (
+ !isDefined(registrationKey) ||
+ !isDefined(listener) ||
+ !registrationKeysByListener.get(listener)?.delete(registrationKey)
+ ) {
+ return;
+ }
+
+ registrationCount -= 1;
+ scheduleObservationFlush();
+ };
+
+ const previousAddEventListenerHook = hooks.addEventListener;
+ const previousRemoveEventListenerHook = hooks.removeEventListener;
+
+ hooks.addEventListener = (target, eventType, listener, options) => {
+ trackAddedListener({ target, eventType, listener, options });
+ previousAddEventListenerHook?.(target, eventType, listener, options);
+ };
+
+ hooks.removeEventListener = (target, eventType, listener, options) => {
+ trackRemovedListener({ target, eventType, listener, options });
+ previousRemoveEventListenerHook?.(target, eventType, listener, options);
+ };
+
+ return {
+ connectTransport: (nextTransport) => {
+ transport = nextTransport;
+ flushObservation();
+ },
+ };
+};
diff --git a/packages/twenty-front-component-renderer/src/remote/elements/utils/__tests__/dispatchOutsidePressEvent.test.ts b/packages/twenty-front-component-renderer/src/remote/elements/utils/__tests__/dispatchOutsidePressEvent.test.ts
new file mode 100644
index 00000000000..549b78c4eee
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/remote/elements/utils/__tests__/dispatchOutsidePressEvent.test.ts
@@ -0,0 +1,100 @@
+import { Window } from '@remote-dom/polyfill';
+
+import { installEventConstructorPolyfills } from '@/polyfills/events/utils/installEventConstructorPolyfills';
+import { isHostOriginatedEvent } from '@/polyfills/events/utils/isHostOriginatedEvent';
+import { toGlobalScopeRecord } from '@/polyfills/utils/toGlobalScopeRecord';
+import { dispatchOutsidePressEvent } from '@/remote/elements/utils/dispatchOutsidePressEvent';
+
+describe('dispatchOutsidePressEvent', () => {
+ it('dispatches through document capture and the body target without visiting owned descendants', () => {
+ const polyfillWindow = new Window();
+ installEventConstructorPolyfills({
+ globalScope: toGlobalScopeRecord(polyfillWindow),
+ });
+ const documentTarget = polyfillWindow.document as unknown as Document;
+ const popup = documentTarget.createElement('div');
+ documentTarget.body.append(popup);
+ const popupListener = jest.fn();
+ popup.addEventListener('pointerdown', popupListener);
+ const receivedPhases: string[] = [];
+ const receivedEvents: Event[] = [];
+
+ documentTarget.addEventListener(
+ 'pointerdown',
+ (event) => {
+ receivedPhases.push('document-capture');
+ receivedEvents.push(event);
+ expect(isHostOriginatedEvent(event)).toBe(true);
+ event.target?.addEventListener('pointerdown', () => {
+ receivedPhases.push('body-target');
+ });
+ },
+ true,
+ );
+ documentTarget.addEventListener('pointerdown', () => {
+ receivedPhases.push('document-bubble');
+ });
+
+ dispatchOutsidePressEvent({
+ documentTarget,
+ eventData: {
+ type: 'pointerdown',
+ button: 0,
+ buttons: 1,
+ detail: 1,
+ pointerType: 'mouse',
+ },
+ });
+ const [receivedEvent] = receivedEvents;
+
+ expect(receivedPhases).toEqual([
+ 'document-capture',
+ 'body-target',
+ 'document-bubble',
+ ]);
+ expect(receivedEvent?.target).toBe(documentTarget.body);
+ expect(receivedEvent).toMatchObject({
+ pointerType: 'mouse',
+ button: 0,
+ buttons: 1,
+ detail: 1,
+ clientX: 0,
+ clientY: 0,
+ });
+ expect(popupListener).not.toHaveBeenCalled();
+ });
+
+ it('exposes the press as the current window event while it is dispatched', () => {
+ const polyfillWindow = new Window();
+ installEventConstructorPolyfills({
+ globalScope: toGlobalScopeRecord(polyfillWindow),
+ });
+ const documentTarget = polyfillWindow.document as unknown as Document;
+ const receivedPresses: { event: Event; windowEvent: Event | undefined }[] =
+ [];
+
+ documentTarget.addEventListener('mousedown', (event) => {
+ receivedPresses.push({
+ event,
+ windowEvent: Reflect.get(polyfillWindow, 'event'),
+ });
+ });
+
+ dispatchOutsidePressEvent({
+ documentTarget,
+ eventData: {
+ type: 'mousedown',
+ button: 0,
+ buttons: 1,
+ detail: 1,
+ pointerType: 'mouse',
+ },
+ });
+
+ const [receivedPress] = receivedPresses;
+
+ expect(receivedPresses).toHaveLength(1);
+ expect(receivedPress?.windowEvent).toBe(receivedPress?.event);
+ expect(Reflect.get(polyfillWindow, 'event')).toBeUndefined();
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/remote/elements/utils/__tests__/dispatchOwnedPressEvent.test.ts b/packages/twenty-front-component-renderer/src/remote/elements/utils/__tests__/dispatchOwnedPressEvent.test.ts
new file mode 100644
index 00000000000..85f7ea82040
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/remote/elements/utils/__tests__/dispatchOwnedPressEvent.test.ts
@@ -0,0 +1,88 @@
+import { connectRemoteNode, remoteId } from '@remote-dom/core/elements';
+import { Window } from '@remote-dom/polyfill';
+
+import { installEventConstructorPolyfills } from '@/polyfills/events/utils/installEventConstructorPolyfills';
+import { toGlobalScopeRecord } from '@/polyfills/utils/toGlobalScopeRecord';
+import { dispatchOwnedPressEvent } from '@/remote/elements/utils/dispatchOwnedPressEvent';
+
+const createOwnedPressFixture = () => {
+ const polyfillWindow = new Window();
+ installEventConstructorPolyfills({
+ globalScope: toGlobalScopeRecord(polyfillWindow),
+ });
+ const documentTarget = polyfillWindow.document as unknown as Document;
+ const connection = { mutate: jest.fn(), call: jest.fn() };
+ const backdrop = documentTarget.createElement('div');
+
+ connectRemoteNode(documentTarget.body, connection);
+ documentTarget.body.append(backdrop);
+ connectRemoteNode(backdrop, connection);
+
+ return {
+ polyfillWindow,
+ documentTarget,
+ backdrop,
+ backdropRemoteElementId: remoteId(backdrop),
+ };
+};
+
+describe('dispatchOwnedPressEvent', () => {
+ it('dispatches the press at its owned target with its event data, as the current window event', () => {
+ const {
+ polyfillWindow,
+ documentTarget,
+ backdrop,
+ backdropRemoteElementId,
+ } = createOwnedPressFixture();
+ const receivedPresses: { event: Event; windowEvent: Event | undefined }[] =
+ [];
+
+ documentTarget.addEventListener(
+ 'pointerdown',
+ (event) => {
+ receivedPresses.push({
+ event,
+ windowEvent: Reflect.get(polyfillWindow, 'event'),
+ });
+ },
+ true,
+ );
+
+ dispatchOwnedPressEvent({
+ documentTarget,
+ eventData: {
+ type: 'pointerdown',
+ bubbles: true,
+ targetRemoteElementId: backdropRemoteElementId,
+ clientX: 12,
+ button: 0,
+ },
+ });
+
+ const [receivedPress] = receivedPresses;
+
+ expect(receivedPresses).toHaveLength(1);
+ expect(receivedPress?.event.target).toBe(backdrop);
+ expect(receivedPress?.event).toMatchObject({ bubbles: true, clientX: 12 });
+ expect(receivedPress?.windowEvent).toBe(receivedPress?.event);
+ expect(Reflect.get(polyfillWindow, 'event')).toBeUndefined();
+ });
+
+ it('drops a press whose target is no longer in the document', () => {
+ const { documentTarget } = createOwnedPressFixture();
+ const documentListener = jest.fn();
+
+ documentTarget.addEventListener('click', documentListener);
+
+ dispatchOwnedPressEvent({
+ documentTarget,
+ eventData: {
+ type: 'click',
+ bubbles: true,
+ targetRemoteElementId: 'removed-element',
+ },
+ });
+
+ expect(documentListener).not.toHaveBeenCalled();
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/remote/elements/utils/dispatchAsCurrentWindowEvent.ts b/packages/twenty-front-component-renderer/src/remote/elements/utils/dispatchAsCurrentWindowEvent.ts
new file mode 100644
index 00000000000..0d7b56c7895
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/remote/elements/utils/dispatchAsCurrentWindowEvent.ts
@@ -0,0 +1,20 @@
+import { resolveOwnerWindowOfNode } from '@/polyfills/dom/utils/resolveOwnerWindowOfNode';
+
+export const dispatchAsCurrentWindowEvent = ({
+ eventTarget,
+ event,
+}: {
+ eventTarget: Element;
+ event: Event;
+}): void => {
+ const ownerWindow = resolveOwnerWindowOfNode(eventTarget);
+ const previousWindowEvent = Reflect.get(ownerWindow, 'event');
+
+ Reflect.set(ownerWindow, 'event', event);
+
+ try {
+ eventTarget.dispatchEvent(event);
+ } finally {
+ Reflect.set(ownerWindow, 'event', previousWindowEvent);
+ }
+};
diff --git a/packages/twenty-front-component-renderer/src/remote/elements/utils/dispatchOutsidePressEvent.ts b/packages/twenty-front-component-renderer/src/remote/elements/utils/dispatchOutsidePressEvent.ts
new file mode 100644
index 00000000000..046d4411c3e
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/remote/elements/utils/dispatchOutsidePressEvent.ts
@@ -0,0 +1,20 @@
+import { createWorkerEventFromSerializedEvent } from '@/remote/elements/utils/createWorkerEventFromSerializedEvent';
+import { dispatchAsCurrentWindowEvent } from '@/remote/elements/utils/dispatchAsCurrentWindowEvent';
+import { type OutsidePressEventData } from '@/types/OutsidePressEventData';
+
+export const dispatchOutsidePressEvent = ({
+ documentTarget,
+ eventData,
+}: {
+ documentTarget: Document;
+ eventData: OutsidePressEventData;
+}): void => {
+ dispatchAsCurrentWindowEvent({
+ eventTarget: documentTarget.body,
+ event: createWorkerEventFromSerializedEvent({
+ listeningElement: documentTarget.body,
+ eventType: eventData.type,
+ eventData: { ...eventData, bubbles: true },
+ }),
+ });
+};
diff --git a/packages/twenty-front-component-renderer/src/remote/elements/utils/dispatchOwnedPressEvent.ts b/packages/twenty-front-component-renderer/src/remote/elements/utils/dispatchOwnedPressEvent.ts
new file mode 100644
index 00000000000..7877199857b
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/remote/elements/utils/dispatchOwnedPressEvent.ts
@@ -0,0 +1,37 @@
+import { isDefined } from 'twenty-shared/utils';
+
+import { findElementByRemoteId } from '@/polyfills/dom/utils/findElementByRemoteId';
+import { isElementNode } from '@/polyfills/dom/utils/isElementNode';
+import { createWorkerEventFromSerializedEvent } from '@/remote/elements/utils/createWorkerEventFromSerializedEvent';
+import { dispatchAsCurrentWindowEvent } from '@/remote/elements/utils/dispatchAsCurrentWindowEvent';
+import { type SerializedEventData } from '@/types/SerializedEventData';
+
+export const dispatchOwnedPressEvent = ({
+ documentTarget,
+ eventData,
+}: {
+ documentTarget: Document;
+ eventData: SerializedEventData;
+}): void => {
+ if (!isDefined(eventData.targetRemoteElementId)) {
+ return;
+ }
+
+ const targetElement = findElementByRemoteId({
+ rootNode: documentTarget.body,
+ remoteElementId: eventData.targetRemoteElementId,
+ });
+
+ if (!isElementNode(targetElement)) {
+ return;
+ }
+
+ dispatchAsCurrentWindowEvent({
+ eventTarget: targetElement,
+ event: createWorkerEventFromSerializedEvent({
+ listeningElement: targetElement,
+ eventType: eventData.type,
+ eventData,
+ }),
+ });
+};
diff --git a/packages/twenty-front-component-renderer/src/remote/worker/remote-worker.ts b/packages/twenty-front-component-renderer/src/remote/worker/remote-worker.ts
index f3372256e23..9ec9624b059 100644
--- a/packages/twenty-front-component-renderer/src/remote/worker/remote-worker.ts
+++ b/packages/twenty-front-component-renderer/src/remote/worker/remote-worker.ts
@@ -41,6 +41,7 @@ import { resolvePolyfillHooks } from '@/polyfills/dom/utils/resolvePolyfillHooks
import { installPointerCapturePolyfill } from '@/polyfills/events/utils/installPointerCapturePolyfill';
import { installEventConstructorPolyfills } from '@/polyfills/events/utils/installEventConstructorPolyfills';
import { installHostEventRetargetingPolyfill } from '@/polyfills/events/utils/installHostEventRetargetingPolyfill';
+import { installOutsidePressObservation } from '@/polyfills/events/utils/installOutsidePressObservation';
import { installSelectorMethodsPolyfill } from '@/polyfills/selectors/utils/installSelectorMethodsPolyfill';
import { workerGeometryStore } from '@/polyfills/geometry/states/workerGeometryStore';
import { installElementGeometryPolyfill } from '@/polyfills/geometry/utils/installElementGeometryPolyfill';
@@ -63,6 +64,8 @@ import { exposeGlobals } from '@/utils/exposeGlobals';
import { installAriaBooleanPropertyAccessors } from '@/remote/elements/utils/installAriaBooleanPropertyAccessors';
import { installStylePropertyOnRemoteElements } from '@/remote/elements/utils/installStylePropertyOnRemoteElements';
import { patchRemoteElementAttributes } from '@/remote/elements/utils/patchRemoteElementAttributes';
+import { dispatchOutsidePressEvent } from '@/remote/elements/utils/dispatchOutsidePressEvent';
+import { dispatchOwnedPressEvent } from '@/remote/elements/utils/dispatchOwnedPressEvent';
import { resolveRemoteElementPrototypes } from '@/remote/elements/utils/resolveRemoteElementPrototypes';
import { buildFrontComponentHostCommunicationApiFromThreadImports } from '@/remote/worker/thread/utils/buildFrontComponentHostCommunicationApiFromThreadImports';
import { handleCommandConfirmationModalResult } from '@/remote/worker/thread/utils/handleCommandConfirmationModalResult';
@@ -132,10 +135,11 @@ const workerPointerCapture = installPointerCapturePolyfill({
elementPrototype: HTMLElement.prototype,
documentTarget: document,
});
+const polyfillHooks = resolvePolyfillHooks(
+ resolveGlobalScopeInstallTargets(toGlobalScopeRecord(globalThis)),
+);
installActiveElementDetachmentHook({
- hooks: resolvePolyfillHooks(
- resolveGlobalScopeInstallTargets(toGlobalScopeRecord(globalThis)),
- ),
+ hooks: polyfillHooks,
activeElementStore: workerActiveElementStore,
onRemoveSubtree: (node) => {
workerFocusTransport.blurFocusedElementWithinSubtree(node);
@@ -144,6 +148,10 @@ installActiveElementDetachmentHook({
workerPointerCapture.scheduleDetachedCaptureSweep();
},
});
+const workerOutsidePressObservation = installOutsidePressObservation({
+ hooks: polyfillHooks,
+ documentTarget: document,
+});
installHostEventRetargetingPolyfill(HTMLElement.prototype);
installElementClickMethodPolyfill(HTMLElement.prototype);
installInputClickActivationPolyfill(HtmlInputElement.prototype);
@@ -293,6 +301,12 @@ const workerExports: WorkerExports = {
pushCapturedPointerEvent: async (update) => {
workerPointerCapture.dispatchCapturedPointerEvent(update);
},
+ pushOutsidePressEvent: async (eventData) => {
+ dispatchOutsidePressEvent({ documentTarget: document, eventData });
+ },
+ pushOwnedPressEvent: async (eventData) => {
+ dispatchOwnedPressEvent({ documentTarget: document, eventData });
+ },
pushMediaSessionEvents: async (batch) => {
workerMediaBridge.dispatchEvents(batch);
},
@@ -316,6 +330,7 @@ self.addEventListener('message', (event) => {
workerGeometryStore.connectTransport(nextHostThread.imports);
workerMediaBridge.connectTransport(nextHostThread.imports);
+ workerOutsidePressObservation.connectTransport(nextHostThread.imports);
transferredPort.start();
});
diff --git a/packages/twenty-front-component-renderer/src/testing/createHostOutsidePressControllerStub.ts b/packages/twenty-front-component-renderer/src/testing/createHostOutsidePressControllerStub.ts
new file mode 100644
index 00000000000..c91a2fecdd0
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/testing/createHostOutsidePressControllerStub.ts
@@ -0,0 +1,10 @@
+import { type HostOutsidePressController } from '@/host/events/types/HostOutsidePressController';
+
+export const createHostOutsidePressControllerStub =
+ (): HostOutsidePressController => ({
+ observeOutsidePresses: jest.fn(),
+ unobserveOutsidePresses: jest.fn(),
+ setPressEventTransport: jest.fn(),
+ forwardUnhandledOwnedPress: jest.fn(),
+ reset: jest.fn(),
+ });
diff --git a/packages/twenty-front-component-renderer/src/testing/createHostPointerCaptureControllerStub.ts b/packages/twenty-front-component-renderer/src/testing/createHostPointerCaptureControllerStub.ts
index 89d3af3aa63..79b3ded94d2 100644
--- a/packages/twenty-front-component-renderer/src/testing/createHostPointerCaptureControllerStub.ts
+++ b/packages/twenty-front-component-renderer/src/testing/createHostPointerCaptureControllerStub.ts
@@ -4,6 +4,7 @@ export const createHostPointerCaptureControllerStub =
(): HostPointerCaptureController => ({
startPointerCapture: jest.fn(),
claimPointerEventForwarding: jest.fn(() => true),
+ hasActivePointerCaptureForEvent: jest.fn(() => false),
setPushCapturedPointerEvent: jest.fn(),
reset: jest.fn(),
});
diff --git a/packages/twenty-front-component-renderer/src/types/FrontComponentHostThreadExports.ts b/packages/twenty-front-component-renderer/src/types/FrontComponentHostThreadExports.ts
index 4997e8359d9..fcf06418905 100644
--- a/packages/twenty-front-component-renderer/src/types/FrontComponentHostThreadExports.ts
+++ b/packages/twenty-front-component-renderer/src/types/FrontComponentHostThreadExports.ts
@@ -10,4 +10,6 @@ export type FrontComponentHostThreadExports =
hostFetch: HostFetchFunction;
observeElementGeometry: (remoteElementIds: string[]) => Promise<void>;
unobserveElementGeometry: (remoteElementIds: string[]) => Promise<void>;
+ observeOutsidePresses: () => Promise<void>;
+ unobserveOutsidePresses: () => Promise<void>;
};
diff --git a/packages/twenty-front-component-renderer/src/types/OutsidePressEventData.ts b/packages/twenty-front-component-renderer/src/types/OutsidePressEventData.ts
new file mode 100644
index 00000000000..4f18c75be70
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/types/OutsidePressEventData.ts
@@ -0,0 +1,9 @@
+import { type OUTSIDE_PRESS_EVENT_TYPES } from '@/constants/OutsidePressEventTypes';
+
+export type OutsidePressEventData = {
+ type: (typeof OUTSIDE_PRESS_EVENT_TYPES)[number];
+ button: number;
+ buttons: number;
+ detail: number;
+ pointerType: string;
+};
diff --git a/packages/twenty-front-component-renderer/src/types/WorkerExports.ts b/packages/twenty-front-component-renderer/src/types/WorkerExports.ts
index 3f09fab6f27..43d027dd900 100644
--- a/packages/twenty-front-component-renderer/src/types/WorkerExports.ts
+++ b/packages/twenty-front-component-renderer/src/types/WorkerExports.ts
@@ -8,6 +8,8 @@ import { type FocusUpdate } from '@/types/FocusUpdate';
import { type GeometryUpdateBatch } from '@/types/GeometryUpdateBatch';
import { type HostToWorkerRenderContext } from '@/types/HostToWorkerRenderContext';
import { type MediaSessionEventBatch } from '@/types/MediaSession';
+import { type OutsidePressEventData } from '@/types/OutsidePressEventData';
+import { type SerializedEventData } from '@/types/SerializedEventData';
export type WorkerExports = {
render: (
@@ -24,5 +26,7 @@ export type WorkerExports = {
pushCapturedPointerEvent: (
update: CapturedPointerEventUpdate,
) => Promise<void>;
+ pushOutsidePressEvent: (eventData: OutsidePressEventData) => Promise<void>;
+ pushOwnedPressEvent: (eventData: SerializedEventData) => Promise<void>;
pushMediaSessionEvents: (batch: MediaSessionEventBatch) => Promise<void>;
};
diff --git a/packages/twenty-front-component-renderer/src/utils/isOutsidePressEventType.ts b/packages/twenty-front-component-renderer/src/utils/isOutsidePressEventType.ts
new file mode 100644
index 00000000000..933f04858db
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/utils/isOutsidePressEventType.ts
@@ -0,0 +1,9 @@
+import { OUTSIDE_PRESS_EVENT_TYPES } from '@/constants/OutsidePressEventTypes';
+import { type OutsidePressEventData } from '@/types/OutsidePressEventData';
+
+export const isOutsidePressEventType = (
+ eventType: string,
+): eventType is OutsidePressEventData['type'] =>
+ OUTSIDE_PRESS_EVENT_TYPES.some(
+ (outsidePressEventType) => outsidePressEventType === eventType,
+ );