Skip to content

The open alternative to Salesforce, designed for AI.

Capture Slider drags on the host in front components (#28061)

Raphaël Bosi5c962fd9fb69
diff --git a/packages/twenty-front-component-renderer/scripts/front-component-stories/native-tests/layout-gestures.ts b/packages/twenty-front-component-renderer/scripts/front-component-stories/native-tests/layout-gestures.ts
new file mode 100644
index 00000000000..1fa3ee5a74f
--- /dev/null
+++ b/packages/twenty-front-component-renderer/scripts/front-component-stories/native-tests/layout-gestures.ts
@@ -0,0 +1,407 @@
+import { expect, type Locator, type Page, test } from 'playwright/test';
+import { MOUNT_TIMEOUT } from '../../../src/__stories__/shared/test-utils/timeouts';
+import { readBounds } from './readBounds';
+
+const BASE_UI_HIDDEN_EDGE_THUMB_ISSUE =
+ 'Base UI 1.8 and 1.9 keep edge-aligned Slider thumbs hidden in React front components (mui/base-ui#5995)';
+
+const markReactSliderAsKnownBaseUiFailure = (runtime: string) => {
+ test.fail(runtime === 'react', BASE_UI_HIDDEN_EDGE_THUMB_ISSUE);
+};
+
+const openFixture = async ({ page, story }: { page: Page; story: string }) => {
+ await page.goto(
+ `/iframe.html?id=frontcomponent-twenty-ui-gallery--${story}`,
+ { waitUntil: 'domcontentloaded' },
+ );
+ await expect(page.getByTestId('front-component-mounted')).toBeVisible({
+ timeout: MOUNT_TIMEOUT,
+ });
+};
+
+const openVolumeSlider = async ({
+ page,
+ runtime,
+}: {
+ page: Page;
+ runtime: string;
+}) => {
+ await openFixture({ page, story: `slider-gestures-${runtime}` });
+ const slider = page.getByRole('slider', { name: 'Volume', exact: true });
+ const control = page.getByTestId('volume-control');
+
+ await expect(slider).toBeVisible();
+
+ return { slider, control };
+};
+
+const startDrag = async ({ page, handle }: { page: Page; handle: Locator }) => {
+ await handle.scrollIntoViewIfNeeded();
+ const bounds = await readBounds(handle);
+ const origin = {
+ x: bounds.x + bounds.width / 2,
+ y: bounds.y + bounds.height / 2,
+ };
+
+ await page.mouse.move(origin.x, origin.y);
+ await page.mouse.down();
+
+ return origin;
+};
+
+const readPointerXForSliderValue = async ({
+ control,
+ thumb,
+ value,
+ min,
+ max,
+}: {
+ control: Locator;
+ thumb: Locator;
+ value: number;
+ min: number;
+ max: number;
+}) => {
+ const controlBounds = await readBounds(control);
+ const thumbInset = (await readBounds(thumb)).width / 2;
+
+ return (
+ controlBounds.x +
+ thumbInset +
+ ((value - min) / (max - min)) * (controlBounds.width - thumbInset * 2)
+ );
+};
+
+for (const runtime of ['react', 'preact']) {
+ test.describe(runtime, () => {
+ test('ResizeHandle captures moves beyond its widget and commits only on release', async ({
+ page,
+ }) => {
+ await openFixture({ page, story: `resize-handle-gestures-${runtime}` });
+ const handle = page.getByRole('separator', { name: 'Resize edge panel' });
+ const origin = await startDrag({ page, handle });
+
+ await page.mouse.move(origin.x - 60, origin.y - 160);
+ await expect(handle).toHaveAttribute('aria-valuenow', '220');
+ await expect(page.getByText('Committed edge: 160')).toBeVisible();
+ await expect(page.getByText('Resize result: Resizing')).toBeVisible();
+ await expect
+ .poll(() => handle.evaluate((element) => element.hasPointerCapture(1)))
+ .toBe(true);
+ await page.mouse.up();
+ await expect(page.getByText('Committed edge: 220')).toBeVisible();
+ await expect(page.getByText('Resize result: Finished')).toBeVisible();
+ await expect(page.getByText('Collapse count: 0')).toBeVisible();
+ await expect
+ .poll(() => handle.evaluate((element) => element.hasPointerCapture(1)))
+ .toBe(false);
+ await page.mouse.move(origin.x + 100, origin.y);
+ await expect(handle).toHaveAttribute('aria-valuenow', '220');
+ });
+
+ test('ResizeHandle cancels unexpected capture loss and Escape without committing', async ({
+ page,
+ }) => {
+ await openFixture({ page, story: `resize-handle-gestures-${runtime}` });
+ const handle = page.getByRole('separator', { name: 'Resize edge panel' });
+ let origin = await startDrag({ page, handle });
+
+ await page.mouse.move(origin.x + 30, origin.y);
+ await expect(handle).toHaveAttribute('aria-valuenow', '130');
+ await handle.evaluate((element) => element.releasePointerCapture(1));
+ await page.mouse.move(origin.x + 40, origin.y);
+ await expect(handle).toHaveAttribute('aria-valuenow', '160');
+ await expect(page.getByText('Resize result: Cancelled')).toBeVisible();
+ await page.mouse.up();
+ origin = await startDrag({ page, handle });
+ await page.mouse.move(origin.x - 30, origin.y);
+ await expect(handle).toHaveAttribute('aria-valuenow', '190');
+ await page.keyboard.press('Escape');
+ await expect(handle).toHaveAttribute('aria-valuenow', '160');
+ await page.mouse.up();
+ await expect(page.getByText('Committed edge: 160')).toBeVisible();
+ await expect(page.getByText('Collapse count: 0')).toBeVisible();
+ });
+
+ test('ResizeHandle respects bounds, scale, keyboard changes and click activation', async ({
+ page,
+ }) => {
+ await openFixture({ page, story: `resize-handle-gestures-${runtime}` });
+ const edge = page.getByRole('separator', { name: 'Resize edge panel' });
+ let origin = await startDrag({ page, handle: edge });
+
+ await page.mouse.move(origin.x + 200, origin.y);
+ await expect(edge).toHaveAttribute('aria-valuenow', '100');
+ await page.mouse.up();
+ await expect(page.getByText('Committed edge: 100')).toBeVisible();
+ await edge.focus();
+ await page.keyboard.press('End');
+ await expect(edge).toHaveAttribute('aria-valuenow', '240');
+ await page.keyboard.press('ArrowLeft');
+ await expect(edge).toHaveAttribute('aria-valuenow', '240');
+ await page.keyboard.press('Home');
+ await page.keyboard.press('ArrowLeft');
+ await expect(page.getByText('Committed edge: 110')).toBeVisible();
+ await page.keyboard.press('Enter');
+ await expect(page.getByText('Collapse count: 1')).toBeVisible();
+ const gap = page.getByRole('separator', { name: 'Resize gap panel' });
+
+ origin = await startDrag({ page, handle: gap });
+ await page.mouse.move(origin.x, origin.y - 80);
+ await expect(gap).toHaveAttribute('aria-valuenow', '140');
+ await expect(page.getByText('Committed gap: 100')).toBeVisible();
+ await page.mouse.up();
+ await expect(page.getByText('Committed gap: 140')).toBeVisible();
+ await expect(page.getByText('Collapse count: 1')).toBeVisible();
+ });
+
+ for (const action of ['Disable edge resizing', 'Hide edge handle']) {
+ test(`ResizeHandle cancels when ${action.toLowerCase()} during a drag`, async ({
+ page,
+ }) => {
+ await openFixture({ page, story: `resize-handle-gestures-${runtime}` });
+ const handle = page.getByRole('separator', {
+ name: 'Resize edge panel',
+ });
+ const origin = await startDrag({ page, handle });
+
+ await page.mouse.move(origin.x - 30, origin.y);
+ await expect(handle).toHaveAttribute('aria-valuenow', '190');
+ await page.getByRole('button', { name: action }).focus();
+ await page.keyboard.press('Enter');
+ await page.mouse.move(origin.x - 40, origin.y);
+ await page.mouse.up();
+ await expect(page.getByText('Committed edge: 160')).toBeVisible();
+ await expect(page.getByText('Resize result: Cancelled')).toBeVisible();
+ await expect(page.getByText('Edge size: 160')).toBeVisible();
+ await expect(page.getByText('Collapse count: 0')).toBeVisible();
+ });
+ }
+
+ test('Slider displays its thumb and supports keyboard commits and disabled controls', async ({
+ page,
+ }) => {
+ markReactSliderAsKnownBaseUiFailure(runtime);
+ const { slider } = await openVolumeSlider({ page, runtime });
+
+ await expect(slider).toHaveAttribute('min', '10');
+ await expect(slider).toHaveAttribute('max', '90');
+ await expect(slider).toHaveAttribute('step', '5');
+ await slider.focus();
+ await page.keyboard.press('ArrowRight');
+ await expect(slider).toHaveValue('45');
+ await expect(page.getByText('Volume: 45; Committed: 45')).toBeVisible();
+ await page.keyboard.press('Home');
+ await expect(slider).toHaveValue('10');
+ await page.keyboard.press('End');
+ await expect(slider).toHaveValue('90');
+ await expect(page.getByText('Volume: 90; Committed: 90')).toBeVisible();
+ await expect(
+ page.getByRole('slider', { name: 'Disabled volume' }),
+ ).toBeDisabled();
+ });
+
+ test('Slider commits a quick track press released before the worker answers', async ({
+ page,
+ }) => {
+ markReactSliderAsKnownBaseUiFailure(runtime);
+ const { control } = await openVolumeSlider({ page, runtime });
+ const bounds = await readBounds(control);
+
+ await page.mouse.move(
+ bounds.x + bounds.width * 0.8,
+ bounds.y + bounds.height / 2,
+ );
+ await page.mouse.down();
+ await page.mouse.up();
+ const volumeStatus = page.getByText(/^Volume: \d+; Committed: \d+$/);
+
+ await expect(volumeStatus).not.toHaveText('Volume: 40; Committed: 40');
+ await expect(volumeStatus).toHaveText(/^Volume: (\d+); Committed: \1$/);
+ await expect(control).not.toHaveAttribute('data-dragging');
+ });
+
+ test('Slider follows native pointer moves beyond the widget and commits the bounded final value', async ({
+ page,
+ }) => {
+ markReactSliderAsKnownBaseUiFailure(runtime);
+ const { slider, control } = await openVolumeSlider({ page, runtime });
+
+ await page
+ .getByRole('button', { name: 'Parent action', exact: true })
+ .click();
+ await expect(page.getByText('Parent actions: 1')).toBeVisible();
+ await expect(page.getByText('Parent presses: 1')).toBeVisible();
+ const origin = await startDrag({ page, handle: slider });
+ await expect(control).toHaveAttribute('data-dragging', '');
+ await expect
+ .poll(() => control.evaluate((element) => element.hasPointerCapture(1)))
+ .toBe(true);
+ await expect(page.getByText('Parent presses: 2')).toBeVisible();
+ const bounds = await readBounds(control);
+
+ await page.mouse.move(bounds.x + bounds.width + 80, origin.y - 150);
+ await expect(slider).toHaveValue('90');
+ await expect(page.getByText('Volume: 90; Committed: 40')).toBeVisible();
+ await page.mouse.up();
+ await expect(page.getByText('Volume: 90; Committed: 90')).toBeVisible();
+ await expect(page.getByText('Parent presses: 2')).toBeVisible();
+ await expect(page.getByText('Parent actions: 1')).toBeVisible();
+ await expect
+ .poll(() => control.evaluate((element) => element.hasPointerCapture(1)))
+ .toBe(false);
+ await page.mouse.move(bounds.x - 80, origin.y);
+ await expect(slider).toHaveValue('90');
+ });
+
+ test('Slider continues its native document drag and commits after unexpected capture loss', async ({
+ page,
+ }) => {
+ markReactSliderAsKnownBaseUiFailure(runtime);
+ const { slider, control } = await openVolumeSlider({ page, runtime });
+ const worker = page.workers()[0];
+
+ await worker.evaluate(() => {
+ let ownedButton: HTMLButtonElement | undefined;
+
+ document.querySelectorAll('button').forEach((button) => {
+ if (button.textContent === 'Disable volume') {
+ ownedButton = button;
+ }
+ });
+ const pointerMoves: { clientX: number; clientY: number }[] = [];
+
+ Object.assign(globalThis, { capturedPointerMoveProbe: pointerMoves });
+ ownedButton!.addEventListener('pointermove', () => undefined);
+ document.addEventListener('pointermove', (event) => {
+ pointerMoves.push({ clientX: event.clientX, clientY: event.clientY });
+ });
+ });
+ const origin = await startDrag({ page, handle: slider });
+ await expect(control).toHaveAttribute('data-dragging', '');
+ const bounds = await readBounds(control);
+
+ await page.mouse.move(
+ await readPointerXForSliderValue({
+ control,
+ thumb: slider.locator('..'),
+ value: 70,
+ min: 10,
+ max: 90,
+ }),
+ origin.y,
+ );
+ await expect(slider).toHaveValue('70');
+ await control.evaluate((element) => element.releasePointerCapture(1));
+ const ownedButtonBounds = await readBounds(
+ page.getByRole('button', { name: 'Disable volume' }),
+ );
+ const crossingPosition = {
+ clientX: ownedButtonBounds.x + ownedButtonBounds.width / 2,
+ clientY: ownedButtonBounds.y + ownedButtonBounds.height / 2,
+ };
+
+ await page.mouse.move(crossingPosition.clientX, crossingPosition.clientY);
+ await expect(slider).toHaveValue('50');
+ await page.mouse.move(bounds.x + bounds.width + 80, origin.y);
+ await expect(slider).toHaveValue('90');
+ await expect(page.getByText('Volume: 90; Committed: 40')).toBeVisible();
+ await page.mouse.up();
+ await expect(page.getByText('Volume: 90; Committed: 90')).toBeVisible();
+ await expect(control).not.toHaveAttribute('data-dragging');
+ const deliveredCrossingMoves = await worker.evaluate((position) => {
+ const { capturedPointerMoveProbe } = globalThis as typeof globalThis & {
+ capturedPointerMoveProbe: { clientX: number; clientY: number }[];
+ };
+
+ return capturedPointerMoveProbe.filter(
+ (event) =>
+ Math.abs(event.clientX - position.clientX) < 1 &&
+ Math.abs(event.clientY - position.clientY) < 1,
+ ).length;
+ }, crossingPosition);
+
+ expect(deliveredCrossingMoves).toBe(1);
+ });
+
+ test('Slider preserves its public Escape behavior and measures scaled pointer movement', async ({
+ page,
+ }) => {
+ markReactSliderAsKnownBaseUiFailure(runtime);
+ await openFixture({ page, story: `slider-gestures-${runtime}` });
+ await page.getByRole('button', { name: 'Scale volume' }).click();
+ const slider = page.getByRole('slider', { name: 'Volume', exact: true });
+ const control = page.getByTestId('volume-control');
+
+ await expect(slider).toBeVisible();
+ const origin = await startDrag({ page, handle: slider });
+ await expect(control).toHaveAttribute('data-dragging', '');
+ const bounds = await readBounds(control);
+
+ await page.mouse.move(bounds.x + bounds.width / 2, origin.y);
+ await expect(slider).toHaveValue('50');
+ await page.keyboard.press('Escape');
+ await expect(slider).toHaveValue('50');
+ await expect(page.getByText('Volume: 50; Committed: 40')).toBeVisible();
+ await page.mouse.up();
+ await expect(page.getByText('Volume: 50; Committed: 50')).toBeVisible();
+ });
+
+ for (const action of ['Disable volume', 'Hide volume']) {
+ test(`Slider stops an active drag when ${action.toLowerCase()}`, async ({
+ page,
+ }) => {
+ markReactSliderAsKnownBaseUiFailure(runtime);
+ const { slider, control } = await openVolumeSlider({ page, runtime });
+ const origin = await startDrag({ page, handle: slider });
+ await expect(control).toHaveAttribute('data-dragging', '');
+ const bounds = await readBounds(control);
+
+ await page.mouse.move(bounds.x + bounds.width + 60, origin.y);
+ await expect(page.getByText('Volume: 90; Committed: 40')).toBeVisible();
+ await page.getByRole('button', { name: action }).focus();
+ await page.keyboard.press('Enter');
+ await page.mouse.move(bounds.x - 60, origin.y);
+ await page.mouse.up();
+ await expect(page.getByText('Volume: 90; Committed: 40')).toBeVisible();
+ await expect(page.getByText(/FrontComponent error/)).toHaveCount(0);
+ });
+ }
+
+ test('Slider range changes and commits the active public thumb without moving its neighbor', async ({
+ page,
+ }) => {
+ markReactSliderAsKnownBaseUiFailure(runtime);
+ await openFixture({ page, story: `slider-range-gestures-${runtime}` });
+ const minimum = page.getByRole('slider', { name: 'Minimum price' });
+ const maximum = page.getByRole('slider', { name: 'Maximum price' });
+
+ await expect(minimum).toBeVisible();
+ await expect(maximum).toBeVisible();
+ await minimum.focus();
+ await page.keyboard.press('ArrowRight');
+ await expect(minimum).toHaveValue('21');
+ await expect(maximum).toHaveValue('80');
+ await expect(
+ page.getByText('Range: 21, 80; Committed range: 21, 80'),
+ ).toBeVisible();
+ const origin = await startDrag({ page, handle: maximum });
+ await expect(page.getByTestId('range-control')).toHaveAttribute(
+ 'data-dragging',
+ '',
+ );
+ const bounds = await readBounds(page.getByTestId('range-control'));
+
+ await page.mouse.move(bounds.x + bounds.width + 80, origin.y);
+ await expect(maximum).toHaveValue('100');
+ await expect(minimum).toHaveValue('21');
+ await expect(
+ page.getByText('Range: 21, 100; Committed range: 21, 80'),
+ ).toBeVisible();
+ await page.mouse.up();
+ await expect(
+ page.getByText('Range: 21, 100; Committed range: 21, 100'),
+ ).toBeVisible();
+ });
+ });
+}
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 e50e4fa88a4..354ce8375be 100644
--- a/packages/twenty-front-component-renderer/src/__stories__/TwentyUiGallery.stories.tsx
+++ b/packages/twenty-front-component-renderer/src/__stories__/TwentyUiGallery.stories.tsx
@@ -833,6 +833,31 @@ const galleryInstancesMountOnlyPlay = createMountOnlyPlay({
expectedCount: 2,
});
+export const ResizeHandleGesturesReact: Story = {
+ ...ResizeHandleReact,
+ play: galleryMountOnlyPlay,
+};
+export const ResizeHandleGesturesPreact: Story = {
+ ...ResizeHandlePreact,
+ play: galleryMountOnlyPlay,
+};
+export const SliderGesturesReact: Story = {
+ ...SliderReact,
+ play: galleryMountOnlyPlay,
+};
+export const SliderGesturesPreact: Story = {
+ ...SliderPreact,
+ play: galleryMountOnlyPlay,
+};
+export const SliderRangeGesturesReact: Story = {
+ ...SliderRangeReact,
+ play: galleryMountOnlyPlay,
+};
+export const SliderRangeGesturesPreact: Story = {
+ ...SliderRangePreact,
+ play: galleryMountOnlyPlay,
+};
+
export const PortalGeometryReact: Story = {
...PortalBoundsReact,
play: galleryMountOnlyPlay,
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 73baccad841..31d24a6eab1 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
@@ -8,6 +8,8 @@ regular prop like React 19. Preact 10 hands that ref to the component instance,
so Dropdown-based popups never open there.
The layout fixtures mirror a bounded set of stylesheet and inherited layout properties, including logical paddings, borders and margins and individual transforms, for elements the worker already measures, plus native positioned ancestors and size observations. Reading a computed style enrolls an element only when one of its children is already measured, so container properties such as gaps follow the host. Theme custom properties are not mirrored, so they keep resolving through `var()` on the host, while inline custom properties still read back from the element's own style. Worker `ResizeObserver` entries report content, border and device-pixel content boxes from owned host snapshots, and `document.body` and `document.documentElement` report the renderer root box. They deliver the first valid measurement and later size changes, report a zero size when a measured target leaves the document, resume after it is reinserted, and stop after unobserve or disconnect. Position-only updates still use the existing geometry update path rather than resize notifications.
+Native Slider range inputs receive their minimum, maximum and step, so browser keyboard defaults and worker callbacks agree. A Slider's own capture remains in place when its parent has a pointer handler.
+
The field-controls fixture checks native input/textarea refs and change targets, typed textarea render composition, Field labels, controlled multiline value updates, positive Textarea height growth and shrink, and reflow after width changes in React and Preact. Auto-resize reads the host's intrinsic content measurement after a local block-size reset and reconciles delayed content measurements through the geometry update listener. Caller sizing overrides and detached controls end that reconciliation.
The standalone Toast countdown fixture checks remaining time after repeated content updates, zero-duration persistence, manual dismissal, progress suppression and restart, and overlapping hover/focus pauses in React and Preact. It does not cover `updateToast`, `ToastProvider` or `Toaster` in the worker. The SDK snackbar stories check the separate host notification API.
@@ -325,9 +327,9 @@ refs. Default panel IDs preserve automatic tab/panel relationships. Base UI 1.8
registers a generated panel ID even when an explicit `id` is supplied, so the
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. Events that happen outside the
-component never reach the worker, so dismissal on a press elsewhere on the page
-is not covered.
+`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.
Once the remaining gaps are fixed, extend the stories to verify keyboard
navigation, dismissal, and focus restoration across overlay components. The fixtures
@@ -345,13 +347,13 @@ Then, from `packages/twenty-front-component-renderer`, run:
npx vitest run --config vitest.storybook.config.ts TwentyUiGallery.stories.tsx
```
-For collision and anchor motion, and independent OverflowingList renderer cleanup, serve the fresh static Storybook on port 6008 and run the suite that CI runs as `storybook:test:layout`:
+For real mouse gestures, collision and anchor motion, and independent OverflowingList renderer cleanup, serve the fresh static Storybook on port 6008 and run the suite that CI runs as `storybook:test:layout`:
```sh
npx playwright test --config playwright.layout.config.ts
```
-Set `STORYBOOK_URL` to use another Storybook URL.
+Set `STORYBOOK_URL` to use another Storybook URL. These Chromium tests operate the actual host controls and browser pointer capture; unit mocks do not replace them. Slider's upstream touch cancellation behavior remains a separate API acceptance issue: a native `pointercancel` currently leaves its dragging state active outside the renderer as well. The React Slider gestures are marked as expected failures until Base UI fixes the hidden edge-aligned thumbs described in the Slider limitation above.
The AvatarGroup, Autocomplete, CountrySelect and reading-directions fixtures
live in their own story files, so run them separately:
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/twenty-ui-resize-handle.front-component.tsx b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/twenty-ui-resize-handle.front-component.tsx
index 309e5fd06cd..d40305659a5 100644
--- a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/twenty-ui-resize-handle.front-component.tsx
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/twenty-ui-resize-handle.front-component.tsx
@@ -1,5 +1,6 @@
import { useId, useState } from 'react';
import { defineFrontComponent } from 'twenty-sdk/define';
+import { Button } from 'twenty-ui/primitives/input';
import { ResizeHandle } from 'twenty-ui/primitives/layout';
import { Card } from 'twenty-ui/primitives/surfaces';
import { Text } from 'twenty-ui/primitives/typography';
@@ -16,6 +17,8 @@ const ResizeHandleExample = () => {
const [collapseCount, setCollapseCount] = useState(0);
const [edgeClickCount, setEdgeClickCount] = useState(0);
const [lastResizeResult, setLastResizeResult] = useState('Ready');
+ const [isEdgeDisabled, setIsEdgeDisabled] = useState(false);
+ const [isEdgeVisible, setIsEdgeVisible] = useState(true);
return (
<TwentyUiGalleryCard title="Panel resize handle interactions">
@@ -24,27 +27,34 @@ const ResizeHandleExample = () => {
style={{ width: edgeSize, height: 100, position: 'relative' }}
>
<Text>Edge size: {edgeSize}</Text>
- <ResizeHandle
- aria-label="Resize edge panel"
- aria-controls={edgeRegionId}
- edge="left"
- value={edgeSize}
- min={100}
- max={240}
- onValueChange={setEdgeSize}
- onValueCommitted={setCommittedEdgeSize}
- onResizeStart={() => setLastResizeResult('Resizing')}
- onResizeEnd={({ cancelled }) =>
- setLastResizeResult(cancelled ? 'Cancelled' : 'Finished')
- }
- onActivate={() => setCollapseCount((count) => count + 1)}
- onClick={() => setEdgeClickCount((count) => count + 1)}
- />
+ {isEdgeVisible && (
+ <ResizeHandle
+ disabled={isEdgeDisabled}
+ aria-label="Resize edge panel"
+ aria-controls={edgeRegionId}
+ edge="left"
+ value={edgeSize}
+ min={100}
+ max={240}
+ onValueChange={setEdgeSize}
+ onValueCommitted={setCommittedEdgeSize}
+ onResizeStart={() => setLastResizeResult('Resizing')}
+ onResizeEnd={({ cancelled }) =>
+ setLastResizeResult(cancelled ? 'Cancelled' : 'Finished')
+ }
+ onActivate={() => setCollapseCount((count) => count + 1)}
+ onClick={() => setEdgeClickCount((count) => count + 1)}
+ />
+ )}
</Card.Root>
<Text>Committed edge: {committedEdgeSize}</Text>
<Text>Collapse count: {collapseCount}</Text>
<Text>Edge clicks: {edgeClickCount}</Text>
<Text>Resize result: {lastResizeResult}</Text>
+ <Button onClick={() => setIsEdgeDisabled(true)}>
+ Disable edge resizing
+ </Button>
+ <Button onClick={() => setIsEdgeVisible(false)}>Hide edge handle</Button>
<ResizeHandle
aria-label="Resize gap panel"
aria-controls={gapRegionId}
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/twenty-ui-slider-range.front-component.tsx b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/twenty-ui-slider-range.front-component.tsx
index 388b8d0ba72..f1920f98547 100644
--- a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/twenty-ui-slider-range.front-component.tsx
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/twenty-ui-slider-range.front-component.tsx
@@ -1,23 +1,39 @@
+import { useState } from 'react';
import { defineFrontComponent } from 'twenty-sdk/define';
import { Slider } from 'twenty-ui/primitives/input';
+import { Text } from 'twenty-ui/primitives/typography';
import { TwentyUiGalleryCard } from '@/__stories__/shared/front-components/twenty-ui-gallery-card';
-const SliderRangeExample = () => (
- <TwentyUiGalleryCard title="Slider range">
- <Slider.Root defaultValue={[20, 80]}>
- <Slider.Label>Price range</Slider.Label>
- <Slider.Value />
- <Slider.Control>
- <Slider.Track>
- <Slider.Indicator />
- <Slider.Thumb index={0} aria-label="Minimum price" />
- <Slider.Thumb index={1} aria-label="Maximum price" />
- </Slider.Track>
- </Slider.Control>
- </Slider.Root>
- </TwentyUiGalleryCard>
-);
+const SliderRangeExample = () => {
+ const [value, setValue] = useState<readonly number[]>([20, 80]);
+ const [committedValue, setCommittedValue] = useState<readonly number[]>([
+ 20, 80,
+ ]);
+
+ return (
+ <TwentyUiGalleryCard title="Slider range">
+ <Slider.Root
+ value={value}
+ onValueChange={setValue}
+ onValueCommitted={setCommittedValue}
+ >
+ <Slider.Label>Price range</Slider.Label>
+ <Slider.Value />
+ <Slider.Control data-testid="range-control">
+ <Slider.Track>
+ <Slider.Indicator />
+ <Slider.Thumb index={0} aria-label="Minimum price" />
+ <Slider.Thumb index={1} aria-label="Maximum price" />
+ </Slider.Track>
+ </Slider.Control>
+ </Slider.Root>
+ <Text>
+ Range: {value.join(', ')}; Committed range: {committedValue.join(', ')}
+ </Text>
+ </TwentyUiGalleryCard>
+ );
+};
export default defineFrontComponent({
universalIdentifier: '4d23e9af-7cb3-4e4a-bbca-8e960f840013',
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/twenty-ui-slider.front-component.tsx b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/twenty-ui-slider.front-component.tsx
index aa740eca23d..8ec7215742e 100644
--- a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/twenty-ui-slider.front-component.tsx
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/twenty-ui-slider.front-component.tsx
@@ -1,32 +1,63 @@
import { useState } from 'react';
import { defineFrontComponent } from 'twenty-sdk/define';
-import { Slider } from 'twenty-ui/primitives/input';
+import { Text } from 'twenty-ui/primitives/typography';
+import { Button, Slider } from 'twenty-ui/primitives/input';
import { TwentyUiGalleryCard } from '@/__stories__/shared/front-components/twenty-ui-gallery-card';
const SliderExample = () => {
const [value, setValue] = useState(40);
const [committedValue, setCommittedValue] = useState(40);
+ const [isVolumeDisabled, setIsVolumeDisabled] = useState(false);
+ const [isVolumeVisible, setIsVolumeVisible] = useState(true);
+ const [isVolumeScaled, setIsVolumeScaled] = useState(false);
+ const [parentPointerDownCount, setParentPointerDownCount] = useState(0);
+ const [parentActionCount, setParentActionCount] = useState(0);
+
+ const handleParentAction = () => {
+ setParentActionCount((count) => count + 1);
+ };
+
+ const handleParentPointerDown = () => {
+ setParentPointerDownCount((count) => count + 1);
+ };
return (
<TwentyUiGalleryCard title="Slider">
- <Slider.Root
- value={value}
- min={10}
- max={90}
- step={5}
- onValueChange={setValue}
- onValueCommitted={setCommittedValue}
- >
- <Slider.Label>Volume</Slider.Label>
- <Slider.Value />
- <Slider.Control>
- <Slider.Track>
- <Slider.Indicator />
- <Slider.Thumb />
- </Slider.Track>
- </Slider.Control>
- </Slider.Root>
+ {isVolumeVisible && (
+ <div
+ data-testid="volume-pointer-parent"
+ onPointerDown={handleParentPointerDown}
+ >
+ <Slider.Root
+ disabled={isVolumeDisabled}
+ style={
+ isVolumeScaled
+ ? { transform: 'scale(0.75)', transformOrigin: 'left center' }
+ : undefined
+ }
+ value={value}
+ min={10}
+ max={90}
+ step={5}
+ onValueChange={setValue}
+ onValueCommitted={setCommittedValue}
+ >
+ <Slider.Label>Volume</Slider.Label>
+ <Slider.Value />
+ <Slider.Control data-testid="volume-control">
+ <Slider.Track>
+ <Slider.Indicator />
+ <Slider.Thumb />
+ </Slider.Track>
+ </Slider.Control>
+ </Slider.Root>
+ <Button onClick={handleParentAction}>Parent action</Button>
+ </div>
+ )}
+ <Button onClick={() => setIsVolumeDisabled(true)}>Disable volume</Button>
+ <Button onClick={() => setIsVolumeVisible(false)}>Hide volume</Button>
+ <Button onClick={() => setIsVolumeScaled(true)}>Scale volume</Button>
<Slider.Root aria-label="Disabled volume" defaultValue={30} disabled>
<Slider.Control>
<Slider.Track>
@@ -35,9 +66,11 @@ const SliderExample = () => {
</Slider.Track>
</Slider.Control>
</Slider.Root>
- <p role="status">
+ <Text role="status">
Volume: {value}; Committed: {committedValue}
- </p>
+ </Text>
+ <Text role="status">Parent presses: {parentPointerDownCount}</Text>
+ <Text role="status">Parent actions: {parentActionCount}</Text>
</TwentyUiGalleryCard>
);
};
diff --git a/packages/twenty-front-component-renderer/src/constants/AllowedHtmlElements.ts b/packages/twenty-front-component-renderer/src/constants/AllowedHtmlElements.ts
index 058cf384338..304bd5abd3d 100644
--- a/packages/twenty-front-component-renderer/src/constants/AllowedHtmlElements.ts
+++ b/packages/twenty-front-component-renderer/src/constants/AllowedHtmlElements.ts
@@ -82,6 +82,9 @@ export const ALLOWED_HTML_ELEMENTS: AllowedHtmlElement[] = [
properties: {
type: { type: 'string', optional: true },
name: { type: 'string', optional: true },
+ min: { type: 'string', optional: true },
+ max: { type: 'string', optional: true },
+ step: { type: 'string', optional: true },
value: { type: 'string', optional: true },
placeholder: { type: 'string', optional: true },
disabled: { type: 'boolean', optional: true },
diff --git a/packages/twenty-front-component-renderer/src/constants/CapturedPointerEventTypes.ts b/packages/twenty-front-component-renderer/src/constants/CapturedPointerEventTypes.ts
new file mode 100644
index 00000000000..7590775d95a
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/constants/CapturedPointerEventTypes.ts
@@ -0,0 +1,5 @@
+export const CAPTURED_POINTER_EVENT_TYPES = [
+ 'pointermove',
+ 'pointerup',
+ 'pointercancel',
+] as const;
diff --git a/packages/twenty-front-component-renderer/src/constants/PointerGestureEndEventTypes.ts b/packages/twenty-front-component-renderer/src/constants/PointerGestureEndEventTypes.ts
new file mode 100644
index 00000000000..ee9c833ff2c
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/constants/PointerGestureEndEventTypes.ts
@@ -0,0 +1,4 @@
+export const POINTER_GESTURE_END_EVENT_TYPES: ReadonlySet<string> = new Set([
+ 'pointerup',
+ 'pointercancel',
+]);
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 8e0d9b80587..c9e7254bf62 100644
--- a/packages/twenty-front-component-renderer/src/host/components/FrontComponentRenderer.tsx
+++ b/packages/twenty-front-component-renderer/src/host/components/FrontComponentRenderer.tsx
@@ -1,5 +1,7 @@
import { ROOT_CONTAINER_STYLE } from '@/host/constants/RootContainerStyle';
import { FrontComponentRemoteRootRenderer } from '@/host/components/FrontComponentRemoteRootRenderer';
+import { FrontComponentPointerCaptureControllerContext } from '@/host/events/contexts/FrontComponentPointerCaptureControllerContext';
+import { createHostPointerCaptureController } from '@/host/events/utils/createHostPointerCaptureController';
import { FrontComponentGeometryTrackerContext } from '@/host/geometry/contexts/FrontComponentGeometryTrackerContext';
import { createGeometryTracker } from '@/host/geometry/utils/createGeometryTracker';
import { FrontComponentHostFocusControllerContext } from '@/host/focus/contexts/FrontComponentHostFocusControllerContext';
@@ -10,6 +12,7 @@ import { FrontComponentFocusTrackerEffect } from '@/host/effect-components/Front
import { FrontComponentGeometryTrackerEffect } from '@/host/effect-components/FrontComponentGeometryTrackerEffect';
import { FrontComponentInitializeHostCommunicationApiEffect } from '@/host/effect-components/FrontComponentInitializeHostCommunicationApiEffect';
import { FrontComponentMediaSessionEffect } from '@/host/effect-components/FrontComponentMediaSessionEffect';
+import { FrontComponentPointerCaptureEffect } from '@/host/effect-components/FrontComponentPointerCaptureEffect';
import { FrontComponentUpdateContextEffect } from '@/host/effect-components/FrontComponentUpdateContextEffect';
import { FrontComponentUpdateHostCommunicationApiEffect } from '@/host/effect-components/FrontComponentUpdateHostCommunicationApiEffect';
import { type FrontComponentMediaSessionHost } from '@/host/media/types/FrontComponentMediaSessionHost';
@@ -73,6 +76,9 @@ export const FrontComponentRenderer = ({
const [hostFocusController] = useState(() =>
createHostFocusController({ geometryTracker }),
);
+ const [pointerCaptureController] = useState(() =>
+ createHostPointerCaptureController({ geometryTracker }),
+ );
const [initialExecutionContext] = useState(executionContext);
const isReady = isDefined(receiver) && isExecutionContextInitialized;
@@ -124,6 +130,10 @@ export const FrontComponentRenderer = ({
thread={thread}
geometryTracker={geometryTracker}
/>
+ <FrontComponentPointerCaptureEffect
+ thread={thread}
+ pointerCaptureController={pointerCaptureController}
+ />
{isDefined(mediaSessionHost) && (
<FrontComponentMediaSessionEffect
thread={thread}
@@ -158,10 +168,14 @@ export const FrontComponentRenderer = ({
<FrontComponentHostFocusControllerContext.Provider
value={hostFocusController}
>
- <FrontComponentRemoteRootRenderer
- receiver={receiver}
- components={fallbackComponentRegistry}
- />
+ <FrontComponentPointerCaptureControllerContext.Provider
+ value={pointerCaptureController}
+ >
+ <FrontComponentRemoteRootRenderer
+ receiver={receiver}
+ components={fallbackComponentRegistry}
+ />
+ </FrontComponentPointerCaptureControllerContext.Provider>
</FrontComponentHostFocusControllerContext.Provider>
</ErrorBoundary>
</ThemeProvider>
diff --git a/packages/twenty-front-component-renderer/src/host/constants/PointerCaptureTransportFailureWarning.ts b/packages/twenty-front-component-renderer/src/host/constants/PointerCaptureTransportFailureWarning.ts
new file mode 100644
index 00000000000..d1530bdfcc1
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/constants/PointerCaptureTransportFailureWarning.ts
@@ -0,0 +1,2 @@
+export const POINTER_CAPTURE_TRANSPORT_FAILURE_WARNING =
+ '[twenty-front-component] Forwarding a captured pointer gesture to the worker failed. A drag inside the front component may stop following the pointer.';
diff --git a/packages/twenty-front-component-renderer/src/host/effect-components/FrontComponentPointerCaptureEffect.tsx b/packages/twenty-front-component-renderer/src/host/effect-components/FrontComponentPointerCaptureEffect.tsx
new file mode 100644
index 00000000000..fa9571a10f6
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/effect-components/FrontComponentPointerCaptureEffect.tsx
@@ -0,0 +1,36 @@
+import { useEffect } from 'react';
+
+import { POINTER_CAPTURE_TRANSPORT_FAILURE_WARNING } from '@/host/constants/PointerCaptureTransportFailureWarning';
+import { type HostPointerCaptureController } from '@/host/events/types/HostPointerCaptureController';
+import { type FrontComponentThread } from '@/types/FrontComponentThread';
+
+type FrontComponentPointerCaptureEffectProps = {
+ thread: FrontComponentThread;
+ pointerCaptureController: HostPointerCaptureController;
+};
+
+export const FrontComponentPointerCaptureEffect = ({
+ thread,
+ pointerCaptureController,
+}: FrontComponentPointerCaptureEffectProps) => {
+ useEffect(() => {
+ let hasWarnedAboutPointerCapturePushFailure = false;
+
+ pointerCaptureController.setPushCapturedPointerEvent((update) => {
+ thread.imports.pushCapturedPointerEvent(update).catch(() => {
+ if (hasWarnedAboutPointerCapturePushFailure) {
+ return;
+ }
+
+ hasWarnedAboutPointerCapturePushFailure = true;
+ console.warn(POINTER_CAPTURE_TRANSPORT_FAILURE_WARNING);
+ });
+ });
+
+ return () => {
+ pointerCaptureController.reset();
+ };
+ }, [thread, pointerCaptureController]);
+
+ return null;
+};
diff --git a/packages/twenty-front-component-renderer/src/host/elements/hooks/useHtmlHostElementProps.ts b/packages/twenty-front-component-renderer/src/host/elements/hooks/useHtmlHostElementProps.ts
index bb965ce8e66..d48fc4ce09f 100644
--- a/packages/twenty-front-component-renderer/src/host/elements/hooks/useHtmlHostElementProps.ts
+++ b/packages/twenty-front-component-renderer/src/host/elements/hooks/useHtmlHostElementProps.ts
@@ -1,6 +1,7 @@
import { useContext } from 'react';
import { FrontComponentInputFocusContext } from '@/host/caret/contexts/FrontComponentInputFocusContext';
+import { FrontComponentPointerCaptureControllerContext } from '@/host/events/contexts/FrontComponentPointerCaptureControllerContext';
import { FrontComponentGeometryTrackerContext } from '@/host/geometry/contexts/FrontComponentGeometryTrackerContext';
import { type SetEditableFocused } from '@/host/caret/types/SetEditableFocused';
import { useComposedElementRef } from '@/host/elements/hooks/useComposedElementRef';
@@ -9,6 +10,7 @@ import { useReactUnsupportedEventListenerRef } from '@/host/events/hooks/useReac
import { type ElementRefCallback } from '@/host/elements/types/ElementRefCallback';
import { buildHostReactPropsFromRemoteProps } from '@/host/elements/utils/buildHostReactPropsFromRemoteProps';
import { createDropTargetGuardProps } from '@/host/elements/utils/createDropTargetGuardProps';
+import { createSliderPointerCaptureProps } from '@/host/elements/utils/createSliderPointerCaptureProps';
import { createResizableSeparatorProps } from '@/host/elements/utils/createResizableSeparatorProps';
import { extractReactUnsupportedEventHandlers } from '@/host/events/utils/extractReactUnsupportedEventHandlers';
import { getRemoteElementIdFromProps } from '@/host/elements/utils/getRemoteElementIdFromProps';
@@ -32,6 +34,9 @@ export const useHtmlHostElementProps = ({
}): HtmlHostElementProps => {
const setEditableFocused = useContext(FrontComponentInputFocusContext);
const geometryTracker = useContext(FrontComponentGeometryTrackerContext);
+ const pointerCaptureController = useContext(
+ FrontComponentPointerCaptureControllerContext,
+ );
const remoteElementId = getRemoteElementIdFromProps(props);
@@ -42,6 +47,8 @@ export const useHtmlHostElementProps = ({
htmlTag,
findRemoteElementIdContainingNode:
geometryTracker?.findRemoteElementIdContainingNode,
+ claimPointerEventForwarding:
+ pointerCaptureController?.claimPointerEventForwarding,
}),
);
@@ -61,6 +68,10 @@ export const useHtmlHostElementProps = ({
const hostEnforcedProps: Record<string, unknown> = {
...createDropTargetGuardProps(reactBindableProps),
...createResizableSeparatorProps(reactBindableProps),
+ ...createSliderPointerCaptureProps({
+ reactBindableProps,
+ pointerCaptureController,
+ }),
...(htmlTag === 'iframe' && {
sandbox: sanitizeIframeSandbox(reactBindableProps.sandbox),
}),
diff --git a/packages/twenty-front-component-renderer/src/host/elements/types/SliderPointerCaptureProps.ts b/packages/twenty-front-component-renderer/src/host/elements/types/SliderPointerCaptureProps.ts
new file mode 100644
index 00000000000..5d3e2dd7c95
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/elements/types/SliderPointerCaptureProps.ts
@@ -0,0 +1,5 @@
+import { type SliderPointerDownEvent } from '@/host/elements/types/SliderPointerDownEvent';
+
+export type SliderPointerCaptureProps = {
+ onPointerDown: (event: SliderPointerDownEvent) => void;
+};
diff --git a/packages/twenty-front-component-renderer/src/host/elements/types/SliderPointerDownEvent.ts b/packages/twenty-front-component-renderer/src/host/elements/types/SliderPointerDownEvent.ts
new file mode 100644
index 00000000000..e3ac87dd566
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/elements/types/SliderPointerDownEvent.ts
@@ -0,0 +1,8 @@
+import { type PointerEvent } from 'react';
+
+export type SliderPointerDownEvent = Pick<
+ PointerEvent<HTMLElement>,
+ 'currentTarget' | 'pointerId' | 'button' | 'defaultPrevented'
+> & {
+ nativeEvent: Pick<Event, 'isTrusted'>;
+};
diff --git a/packages/twenty-front-component-renderer/src/host/elements/utils/__tests__/createSliderPointerCaptureProps.test.ts b/packages/twenty-front-component-renderer/src/host/elements/utils/__tests__/createSliderPointerCaptureProps.test.ts
new file mode 100644
index 00000000000..e074aa589a1
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/elements/utils/__tests__/createSliderPointerCaptureProps.test.ts
@@ -0,0 +1,184 @@
+import { isDefined } from 'twenty-shared/utils';
+
+import { type SliderPointerDownEvent } from '@/host/elements/types/SliderPointerDownEvent';
+import { createHostPointerCaptureControllerStub } from '@/testing/createHostPointerCaptureControllerStub';
+
+import { createSliderPointerCaptureProps } from '../createSliderPointerCaptureProps';
+
+const dragSurfaces = new WeakSet<Element>();
+
+const createPressedElement = ({
+ isDragSurface,
+ hasRangeInput = true,
+ isRangeInputDisabled = false,
+}: {
+ isDragSurface: boolean;
+ hasRangeInput?: boolean;
+ isRangeInputDisabled?: boolean;
+}) => {
+ const element = Object.assign(document.createElement('div'), {
+ setPointerCapture: jest.fn(),
+ });
+
+ if (isDragSurface) {
+ dragSurfaces.add(element);
+ }
+
+ if (hasRangeInput) {
+ const thumb = document.createElement('div');
+ const input = document.createElement('input');
+
+ input.type = 'range';
+ input.disabled = isRangeInputDisabled;
+ thumb.append(input);
+ element.append(thumb);
+ }
+
+ document.body.append(element);
+
+ return element;
+};
+
+const createPointerPress = ({
+ element,
+ isTrusted = true,
+ pointerId = 1,
+ nativeEvent = { isTrusted },
+}: {
+ element: HTMLElement;
+ isTrusted?: boolean;
+ pointerId?: number;
+ nativeEvent?: { isTrusted: boolean };
+}): SliderPointerDownEvent => ({
+ currentTarget: element,
+ pointerId,
+ button: 0,
+ defaultPrevented: false,
+ nativeEvent,
+});
+
+const createPointerDownHandler = (
+ pointerCaptureController = createHostPointerCaptureControllerStub(),
+) => {
+ const remotePointerDown = jest.fn();
+ const sliderPointerCaptureProps = createSliderPointerCaptureProps({
+ reactBindableProps: { onPointerDown: remotePointerDown },
+ pointerCaptureController,
+ });
+
+ if (!isDefined(sliderPointerCaptureProps)) {
+ throw new Error('Expected slider pointer capture props');
+ }
+
+ return {
+ handler: sliderPointerCaptureProps.onPointerDown,
+ remotePointerDown,
+ pointerCaptureController,
+ };
+};
+
+describe('createSliderPointerCaptureProps', () => {
+ beforeEach(() => {
+ const readComputedStyle = window.getComputedStyle.bind(window);
+
+ jest.spyOn(window, 'getComputedStyle').mockImplementation((element) => {
+ const computedStyle = readComputedStyle(element);
+
+ jest
+ .spyOn(computedStyle, 'getPropertyValue')
+ .mockImplementation((propertyName) =>
+ propertyName === 'touch-action' && dragSurfaces.has(element)
+ ? 'none'
+ : 'auto',
+ );
+
+ return computedStyle;
+ });
+ });
+
+ afterEach(() => {
+ jest.restoreAllMocks();
+ document.body.replaceChildren();
+ });
+
+ it('should capture trusted presses on an enabled slider control', () => {
+ const { handler, remotePointerDown, pointerCaptureController } =
+ createPointerDownHandler();
+ const control = createPressedElement({ isDragSurface: true });
+ const disabledControl = createPressedElement({
+ isDragSurface: true,
+ isRangeInputDisabled: true,
+ });
+
+ handler(createPointerPress({ element: control, isTrusted: false }));
+ handler(createPointerPress({ element: disabledControl }));
+
+ expect(control.setPointerCapture).not.toHaveBeenCalled();
+ expect(disabledControl.setPointerCapture).not.toHaveBeenCalled();
+ expect(pointerCaptureController.startPointerCapture).not.toHaveBeenCalled();
+
+ handler(createPointerPress({ element: control, pointerId: 0 }));
+
+ expect(control.setPointerCapture).toHaveBeenCalledWith(0);
+ expect(pointerCaptureController.startPointerCapture).toHaveBeenCalledWith({
+ element: control,
+ pointerId: 0,
+ });
+ expect(remotePointerDown).toHaveBeenCalledTimes(3);
+ });
+
+ it('should leave elements that are not slider controls on their ordinary pointer path', () => {
+ const { handler, remotePointerDown, pointerCaptureController } =
+ createPointerDownHandler();
+ const sliderParent = createPressedElement({ isDragSurface: false });
+ const otherDragSurface = createPressedElement({
+ isDragSurface: true,
+ hasRangeInput: false,
+ });
+
+ handler(createPointerPress({ element: sliderParent }));
+ handler(createPointerPress({ element: otherDragSurface }));
+
+ expect(sliderParent.setPointerCapture).not.toHaveBeenCalled();
+ expect(otherDragSurface.setPointerCapture).not.toHaveBeenCalled();
+ expect(pointerCaptureController.startPointerCapture).not.toHaveBeenCalled();
+ expect(remotePointerDown).toHaveBeenCalledTimes(2);
+ });
+
+ it('should start one capture session for a press that reaches nested slider controls', () => {
+ const { handler, pointerCaptureController } = createPointerDownHandler();
+ const innerControl = createPressedElement({ isDragSurface: true });
+ const outerControl = createPressedElement({ isDragSurface: true });
+ const nativeEvent = { isTrusted: true };
+
+ handler(createPointerPress({ element: innerControl, nativeEvent }));
+ handler(createPointerPress({ element: outerControl, nativeEvent }));
+
+ expect(innerControl.setPointerCapture).toHaveBeenCalledWith(1);
+ expect(outerControl.setPointerCapture).not.toHaveBeenCalled();
+ expect(pointerCaptureController.startPointerCapture).toHaveBeenCalledTimes(
+ 1,
+ );
+ });
+
+ it('should keep separators and renderers without a capture controller on their existing paths', () => {
+ expect(
+ createSliderPointerCaptureProps({
+ reactBindableProps: { role: 'separator', onPointerDown: jest.fn() },
+ pointerCaptureController: createHostPointerCaptureControllerStub(),
+ }),
+ ).toBeUndefined();
+ expect(
+ createSliderPointerCaptureProps({
+ reactBindableProps: { onPointerDown: jest.fn() },
+ pointerCaptureController: null,
+ }),
+ ).toBeUndefined();
+ expect(
+ createSliderPointerCaptureProps({
+ reactBindableProps: {},
+ pointerCaptureController: createHostPointerCaptureControllerStub(),
+ }),
+ ).toBeUndefined();
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/host/elements/utils/buildHostReactEventHandlerProp.ts b/packages/twenty-front-component-renderer/src/host/elements/utils/buildHostReactEventHandlerProp.ts
index a74655d287f..b7bbacc7216 100644
--- a/packages/twenty-front-component-renderer/src/host/elements/utils/buildHostReactEventHandlerProp.ts
+++ b/packages/twenty-front-component-renderer/src/host/elements/utils/buildHostReactEventHandlerProp.ts
@@ -5,6 +5,7 @@ import { DOM_EVENT_TYPE_TO_REACT_PROP } from '@/constants/DomEventTypeToReactPro
import { type HostReactEventHandlerProp } from '@/host/elements/types/HostReactEventHandlerProp';
import { isRemoteEventListenerActive } from '@/host/elements/utils/isRemoteEventListenerActive';
import { LOWERCASE_EVENT_PROP_TO_DOM_EVENT_TYPE } from '@/host/events/constants/LowercaseEventPropToDomEventType';
+import { type ClaimPointerEventForwarding } from '@/host/events/types/ClaimPointerEventForwarding';
import { type RemoteSerializedEventListener } from '@/host/events/types/RemoteSerializedEventListener';
import { wrapEventHandler } from '@/host/events/utils/wrapEventHandler';
import { type FindRemoteElementIdContainingNode } from '@/host/geometry/types/FindRemoteElementIdContainingNode';
@@ -14,11 +15,13 @@ export const buildHostReactEventHandlerProp = ({
remotePropName,
remotePropValue,
findRemoteElementIdContainingNode,
+ claimPointerEventForwarding,
}: {
remoteProps: Record<string, unknown>;
remotePropName: string;
remotePropValue: unknown;
findRemoteElementIdContainingNode?: FindRemoteElementIdContainingNode;
+ claimPointerEventForwarding?: ClaimPointerEventForwarding;
}): HostReactEventHandlerProp | undefined => {
const domEventType =
LOWERCASE_EVENT_PROP_TO_DOM_EVENT_TYPE[remotePropName.toLowerCase()];
@@ -36,6 +39,7 @@ export const buildHostReactEventHandlerProp = ({
hostEventHandler: wrapEventHandler({
remoteListener: remotePropValue as RemoteSerializedEventListener,
findRemoteElementIdContainingNode,
+ claimPointerEventForwarding,
}),
};
};
diff --git a/packages/twenty-front-component-renderer/src/host/elements/utils/buildHostReactPropsFromRemoteProps.ts b/packages/twenty-front-component-renderer/src/host/elements/utils/buildHostReactPropsFromRemoteProps.ts
index 6feab344780..5f4ed27e505 100644
--- a/packages/twenty-front-component-renderer/src/host/elements/utils/buildHostReactPropsFromRemoteProps.ts
+++ b/packages/twenty-front-component-renderer/src/host/elements/utils/buildHostReactPropsFromRemoteProps.ts
@@ -5,6 +5,7 @@ import { buildHostReactEventHandlerProp } from '@/host/elements/utils/buildHostR
import { hasDangerousUrlScheme } from '@/host/elements/utils/hasDangerousUrlScheme';
import { isNavigationUrlAttribute } from '@/host/elements/utils/isNavigationUrlAttribute';
import { parseCssString } from '@/host/elements/utils/parseCssString';
+import { type ClaimPointerEventForwarding } from '@/host/events/types/ClaimPointerEventForwarding';
import { isEventHandlerKey } from '@/host/events/utils/isEventHandlerKey';
import { type FindRemoteElementIdContainingNode } from '@/host/geometry/types/FindRemoteElementIdContainingNode';
@@ -15,10 +16,12 @@ export const buildHostReactPropsFromRemoteProps = ({
remoteProps,
htmlTag,
findRemoteElementIdContainingNode,
+ claimPointerEventForwarding,
}: {
remoteProps: Record<string, unknown>;
htmlTag: string;
findRemoteElementIdContainingNode?: FindRemoteElementIdContainingNode;
+ claimPointerEventForwarding?: ClaimPointerEventForwarding;
}): Record<string, unknown> => {
const hostReactProps: Record<string, unknown> = {};
@@ -46,6 +49,7 @@ export const buildHostReactPropsFromRemoteProps = ({
remotePropName,
remotePropValue,
findRemoteElementIdContainingNode,
+ claimPointerEventForwarding,
});
if (isDefined(hostReactEventHandlerProp)) {
diff --git a/packages/twenty-front-component-renderer/src/host/elements/utils/createSliderPointerCaptureProps.ts b/packages/twenty-front-component-renderer/src/host/elements/utils/createSliderPointerCaptureProps.ts
new file mode 100644
index 00000000000..39736e6e00b
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/elements/utils/createSliderPointerCaptureProps.ts
@@ -0,0 +1,58 @@
+import { isFunction } from '@sniptt/guards';
+import { isDefined } from 'twenty-shared/utils';
+
+import { type SliderPointerCaptureProps } from '@/host/elements/types/SliderPointerCaptureProps';
+import { type SliderPointerDownEvent } from '@/host/elements/types/SliderPointerDownEvent';
+import { type HostPointerCaptureController } from '@/host/events/types/HostPointerCaptureController';
+import { readComputedStyleProperties } from '@/host/geometry/utils/readComputedStyleProperties';
+
+const ENABLED_RANGE_INPUT_SELECTOR = 'input[type="range"]:not(:disabled)';
+
+const nativeEventsWithStartedPointerCapture = new WeakSet<object>();
+
+const isSliderControl = (element: HTMLElement): boolean =>
+ readComputedStyleProperties({
+ node: element,
+ propertyNames: ['touch-action'],
+ })['touch-action'] === 'none' &&
+ isDefined(element.querySelector(ENABLED_RANGE_INPUT_SELECTOR));
+
+export const createSliderPointerCaptureProps = ({
+ reactBindableProps,
+ pointerCaptureController,
+}: {
+ reactBindableProps: Record<string, unknown>;
+ pointerCaptureController: HostPointerCaptureController | null;
+}): SliderPointerCaptureProps | undefined => {
+ const remotePointerDown = reactBindableProps.onPointerDown;
+
+ if (
+ !isFunction(remotePointerDown) ||
+ !isDefined(pointerCaptureController) ||
+ reactBindableProps.role === 'separator'
+ ) {
+ return undefined;
+ }
+
+ return {
+ onPointerDown: (event: SliderPointerDownEvent) => {
+ const shouldStartPointerCapture =
+ event.nativeEvent.isTrusted &&
+ event.button === 0 &&
+ !event.defaultPrevented &&
+ !nativeEventsWithStartedPointerCapture.has(event.nativeEvent) &&
+ isSliderControl(event.currentTarget);
+
+ if (shouldStartPointerCapture) {
+ nativeEventsWithStartedPointerCapture.add(event.nativeEvent);
+ event.currentTarget.setPointerCapture(event.pointerId);
+ pointerCaptureController.startPointerCapture({
+ element: event.currentTarget,
+ pointerId: event.pointerId,
+ });
+ }
+
+ remotePointerDown(event);
+ },
+ };
+};
diff --git a/packages/twenty-front-component-renderer/src/host/events/contexts/FrontComponentPointerCaptureControllerContext.ts b/packages/twenty-front-component-renderer/src/host/events/contexts/FrontComponentPointerCaptureControllerContext.ts
new file mode 100644
index 00000000000..d180aa346e6
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/events/contexts/FrontComponentPointerCaptureControllerContext.ts
@@ -0,0 +1,6 @@
+import { createContext } from 'react';
+
+import { type HostPointerCaptureController } from '@/host/events/types/HostPointerCaptureController';
+
+export const FrontComponentPointerCaptureControllerContext =
+ createContext<HostPointerCaptureController | null>(null);
diff --git a/packages/twenty-front-component-renderer/src/host/events/types/ClaimPointerEventForwarding.ts b/packages/twenty-front-component-renderer/src/host/events/types/ClaimPointerEventForwarding.ts
new file mode 100644
index 00000000000..c0165dc9e46
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/events/types/ClaimPointerEventForwarding.ts
@@ -0,0 +1 @@
+export type ClaimPointerEventForwarding = (nativeEvent: object) => boolean;
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
new file mode 100644
index 00000000000..4959e8f01c1
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/events/types/HostPointerCaptureController.ts
@@ -0,0 +1,14 @@
+import { type ClaimPointerEventForwarding } from '@/host/events/types/ClaimPointerEventForwarding';
+import { type PushCapturedPointerEvent } from '@/host/events/types/PushCapturedPointerEvent';
+
+export type HostPointerCaptureController = {
+ startPointerCapture: (input: {
+ element: HTMLElement;
+ pointerId: number;
+ }) => void;
+ claimPointerEventForwarding: ClaimPointerEventForwarding;
+ setPushCapturedPointerEvent: (
+ pushCapturedPointerEvent: PushCapturedPointerEvent | null,
+ ) => void;
+ reset: () => void;
+};
diff --git a/packages/twenty-front-component-renderer/src/host/events/types/PushCapturedPointerEvent.ts b/packages/twenty-front-component-renderer/src/host/events/types/PushCapturedPointerEvent.ts
new file mode 100644
index 00000000000..480c190742b
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/events/types/PushCapturedPointerEvent.ts
@@ -0,0 +1,5 @@
+import { type CapturedPointerEventUpdate } from '@/types/CapturedPointerEventUpdate';
+
+export type PushCapturedPointerEvent = (
+ update: CapturedPointerEventUpdate,
+) => void;
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
new file mode 100644
index 00000000000..cd46441e9a1
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/events/utils/__tests__/createHostPointerCaptureController.test.ts
@@ -0,0 +1,390 @@
+import { wrapEventHandler } from '@/host/events/utils/wrapEventHandler';
+import { createGeometryTracker } from '@/host/geometry/utils/createGeometryTracker';
+
+import { createHostPointerCaptureController } from '../createHostPointerCaptureController';
+
+const createCaptureFixture = () => {
+ const element = Object.assign(document.createElement('div'), {
+ hasPointerCapture: jest.fn(() => true),
+ });
+ const geometryTracker = createGeometryTracker();
+ const pushCapturedPointerEvent = jest.fn();
+
+ document.body.append(element);
+ geometryTracker.registerNode('owned', element);
+ const controller = createHostPointerCaptureController({ geometryTracker });
+
+ controller.setPushCapturedPointerEvent(pushCapturedPointerEvent);
+
+ return { element, geometryTracker, pushCapturedPointerEvent, controller };
+};
+
+const startCapturedGesture = ({
+ controller,
+ element,
+ pointerId = 1,
+}: {
+ controller: ReturnType<typeof createHostPointerCaptureController>;
+ element: HTMLElement;
+ pointerId?: number;
+}) => {
+ const addDocumentListener = jest.spyOn(document, 'addEventListener');
+ const addElementListener = jest.spyOn(element, 'addEventListener');
+
+ 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,
+ eventType: 'pointermove',
+ }),
+ handlePointerUp: findListener({
+ addListener: addDocumentListener,
+ eventType: 'pointerup',
+ }),
+ handleCapturingElementPointerMove: findListener({
+ addListener: addElementListener,
+ eventType: 'pointermove',
+ }),
+ handleCapturingElementPointerUp: findListener({
+ addListener: addElementListener,
+ eventType: 'pointerup',
+ }),
+ handleCaptureLoss: findListener({
+ addListener: addElementListener,
+ eventType: 'lostpointercapture',
+ }),
+ };
+
+ addDocumentListener.mockRestore();
+ addElementListener.mockRestore();
+
+ return capturedGestureListeners;
+};
+
+const createNativePointerEvent = (
+ overrides: Partial<Record<string, unknown>>,
+) =>
+ ({
+ type: 'pointermove',
+ pointerId: 1,
+ isTrusted: true,
+ target: document.body,
+ ...overrides,
+ }) as unknown as PointerEvent;
+
+describe('createHostPointerCaptureController', () => {
+ afterEach(() => {
+ jest.restoreAllMocks();
+ document.body.replaceChildren();
+ });
+
+ it('should forward every event of the captured pointer, inside or outside the element, until its release', () => {
+ const { controller, element, pushCapturedPointerEvent } =
+ createCaptureFixture();
+ const removeDocumentListener = jest.spyOn(document, 'removeEventListener');
+ const { handlePointerMove, handlePointerUp } = startCapturedGesture({
+ controller,
+ element,
+ });
+ const hostTarget = document.createElement('input');
+
+ hostTarget.value = 'private host value';
+ handlePointerMove(createNativePointerEvent({ pointerId: 2 }));
+ handlePointerMove(createNativePointerEvent({ isTrusted: false }));
+ expect(pushCapturedPointerEvent).not.toHaveBeenCalled();
+
+ handlePointerMove(
+ createNativePointerEvent({ target: element, clientX: 40, buttons: 1 }),
+ );
+ handlePointerMove(
+ createNativePointerEvent({ target: hostTarget, clientX: 80, buttons: 1 }),
+ );
+ handlePointerUp(
+ createNativePointerEvent({
+ type: 'pointerup',
+ target: hostTarget,
+ clientX: 90,
+ buttons: 0,
+ }),
+ );
+
+ expect(pushCapturedPointerEvent.mock.calls).toEqual([
+ [
+ {
+ remoteElementId: 'owned',
+ eventData: {
+ type: 'pointermove',
+ bubbles: true,
+ pointerId: 1,
+ clientX: 40,
+ buttons: 1,
+ },
+ },
+ ],
+ [
+ {
+ remoteElementId: 'owned',
+ eventData: {
+ type: 'pointermove',
+ bubbles: true,
+ pointerId: 1,
+ clientX: 80,
+ buttons: 1,
+ },
+ },
+ ],
+ [
+ {
+ remoteElementId: 'owned',
+ eventData: {
+ type: 'pointerup',
+ bubbles: true,
+ pointerId: 1,
+ clientX: 90,
+ buttons: 0,
+ },
+ },
+ ],
+ [
+ {
+ remoteElementId: 'owned',
+ eventData: {
+ type: 'lostpointercapture',
+ bubbles: true,
+ pointerId: 1,
+ clientX: 90,
+ buttons: 0,
+ },
+ },
+ ],
+ ]);
+ expect(removeDocumentListener).toHaveBeenCalledTimes(3);
+ });
+
+ it('should not report a capture release when the element no longer holds the pointer at the gesture end', () => {
+ const { controller, element, pushCapturedPointerEvent } =
+ createCaptureFixture();
+ const { handlePointerUp } = startCapturedGesture({ controller, element });
+
+ element.hasPointerCapture.mockReturnValue(false);
+ handlePointerUp(createNativePointerEvent({ type: 'pointerup' }));
+
+ expect(pushCapturedPointerEvent.mock.calls).toEqual([
+ [
+ {
+ remoteElementId: 'owned',
+ eventData: { type: 'pointerup', bubbles: true, pointerId: 1 },
+ },
+ ],
+ ]);
+ });
+
+ it('should forward captured events at the capturing element before host ancestors handle them', () => {
+ const { controller, element, pushCapturedPointerEvent } =
+ createCaptureFixture();
+ const {
+ handleCapturingElementPointerMove,
+ handleCapturingElementPointerUp,
+ handlePointerUp,
+ } = startCapturedGesture({ controller, element });
+ const child = document.createElement('span');
+ const pointerUp = createNativePointerEvent({
+ type: 'pointerup',
+ target: element,
+ clientX: 70,
+ });
+
+ element.append(child);
+ handleCapturingElementPointerMove(
+ createNativePointerEvent({ target: child, clientX: 20 }),
+ );
+ handleCapturingElementPointerMove(
+ createNativePointerEvent({ target: element, clientX: 40 }),
+ );
+ handleCapturingElementPointerUp(pointerUp);
+ handlePointerUp(pointerUp);
+
+ expect(
+ pushCapturedPointerEvent.mock.calls.map(
+ ([{ eventData }]) => `${eventData.type}:${eventData.clientX}`,
+ ),
+ ).toEqual(['pointermove:40', 'pointerup:70', 'lostpointercapture:70']);
+ });
+
+ it('should keep independent capture sessions for several pointers of one element', () => {
+ const { controller, element, pushCapturedPointerEvent } =
+ createCaptureFixture();
+ const firstPointer = startCapturedGesture({ controller, element });
+ const secondPointer = startCapturedGesture({
+ controller,
+ element,
+ pointerId: 2,
+ });
+
+ firstPointer.handlePointerUp(
+ createNativePointerEvent({ type: 'pointerup', clientX: 10 }),
+ );
+ secondPointer.handlePointerMove(
+ createNativePointerEvent({ pointerId: 2, clientX: 30 }),
+ );
+
+ expect(
+ pushCapturedPointerEvent.mock.calls.map(
+ ([{ eventData }]) =>
+ `${eventData.pointerId}:${eventData.type}:${eventData.clientX}`,
+ ),
+ ).toEqual([
+ '1:pointerup:10',
+ '1:lostpointercapture:10',
+ '2:pointermove:30',
+ ]);
+ });
+
+ it('should forward a captured gesture whose pointer id is zero', () => {
+ const { controller, element, pushCapturedPointerEvent } =
+ createCaptureFixture();
+ const { handlePointerMove } = startCapturedGesture({
+ controller,
+ element,
+ pointerId: 0,
+ });
+
+ handlePointerMove(createNativePointerEvent({ pointerId: 0, clientX: 12 }));
+
+ expect(pushCapturedPointerEvent).toHaveBeenCalledWith({
+ remoteElementId: 'owned',
+ eventData: {
+ type: 'pointermove',
+ bubbles: true,
+ pointerId: 0,
+ clientX: 12,
+ },
+ });
+ });
+
+ it.each([
+ { eventType: 'pointermove', firstRecipient: 'owned listener' },
+ { eventType: 'pointermove', firstRecipient: 'capture session' },
+ { eventType: 'pointerup', firstRecipient: 'owned listener' },
+ { eventType: 'pointerup', firstRecipient: 'capture session' },
+ ])(
+ 'should deliver a captured $eventType once when the $firstRecipient receives it first',
+ ({ eventType, firstRecipient }) => {
+ const { controller, element, geometryTracker, pushCapturedPointerEvent } =
+ createCaptureFixture();
+ const { handlePointerMove, handlePointerUp } = startCapturedGesture({
+ controller,
+ element,
+ });
+ const ownedListener = jest.fn();
+ const ownedHandler = wrapEventHandler({
+ remoteListener: ownedListener,
+ findRemoteElementIdContainingNode:
+ geometryTracker.findRemoteElementIdContainingNode,
+ claimPointerEventForwarding: controller.claimPointerEventForwarding,
+ });
+ const nativeEvent = createNativePointerEvent({
+ type: eventType,
+ target: element,
+ clientX: 80,
+ });
+ const deliverOwnedEvent = () =>
+ ownedHandler({ ...nativeEvent, bubbles: true, nativeEvent });
+ const deliverCaptureSessionEvent = () =>
+ eventType === 'pointerup'
+ ? handlePointerUp(nativeEvent)
+ : handlePointerMove(nativeEvent);
+
+ if (firstRecipient === 'owned listener') {
+ deliverOwnedEvent();
+ deliverCaptureSessionEvent();
+ }
+
+ if (firstRecipient === 'capture session') {
+ deliverCaptureSessionEvent();
+ deliverOwnedEvent();
+ }
+
+ const forwardedSessionEvents = pushCapturedPointerEvent.mock.calls.filter(
+ ([{ eventData }]) => eventData.type === eventType,
+ );
+
+ expect(
+ ownedListener.mock.calls.length + forwardedSessionEvents.length,
+ ).toBe(1);
+ },
+ );
+
+ it('should forward a host capture loss while the gesture continues', () => {
+ const { controller, element, pushCapturedPointerEvent } =
+ createCaptureFixture();
+ const { handleCaptureLoss, handlePointerMove } = startCapturedGesture({
+ controller,
+ element,
+ });
+
+ handleCaptureLoss(
+ createNativePointerEvent({ type: 'lostpointercapture', target: element }),
+ );
+ handlePointerMove(createNativePointerEvent({ clientX: 30 }));
+
+ expect(pushCapturedPointerEvent.mock.calls).toEqual([
+ [
+ {
+ remoteElementId: 'owned',
+ eventData: {
+ type: 'lostpointercapture',
+ bubbles: true,
+ pointerId: 1,
+ },
+ },
+ ],
+ [
+ {
+ remoteElementId: 'owned',
+ eventData: {
+ type: 'pointermove',
+ bubbles: true,
+ pointerId: 1,
+ clientX: 30,
+ },
+ },
+ ],
+ ]);
+ });
+
+ it('should end capture sessions when the captured node is detached and on controller reset', () => {
+ const { controller, element, pushCapturedPointerEvent } =
+ createCaptureFixture();
+ const removeDocumentListener = jest.spyOn(document, 'removeEventListener');
+
+ const { handlePointerMove } = startCapturedGesture({ controller, element });
+ element.remove();
+ handlePointerMove(createNativePointerEvent({ clientX: 30 }));
+ expect(pushCapturedPointerEvent).not.toHaveBeenCalled();
+ expect(removeDocumentListener).toHaveBeenCalledTimes(3);
+
+ document.body.append(element);
+ startCapturedGesture({ controller, element });
+ controller.reset();
+ expect(removeDocumentListener).toHaveBeenCalledTimes(6);
+
+ const { handlePointerMove: handleMoveAfterReset } = startCapturedGesture({
+ controller,
+ element,
+ });
+ handleMoveAfterReset(createNativePointerEvent({ clientX: 50 }));
+ expect(pushCapturedPointerEvent).not.toHaveBeenCalled();
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/host/events/utils/applyEventModifierKeys.ts b/packages/twenty-front-component-renderer/src/host/events/utils/applyEventModifierKeys.ts
index ad2b4fba680..eaf70b1efdf 100644
--- a/packages/twenty-front-component-renderer/src/host/events/utils/applyEventModifierKeys.ts
+++ b/packages/twenty-front-component-renderer/src/host/events/utils/applyEventModifierKeys.ts
@@ -7,7 +7,12 @@ export const applyEventModifierKeys = ({
domEvent,
}: {
serializedEvent: SerializedEventData;
- domEvent: Record<string, unknown>;
+ domEvent: {
+ altKey?: unknown;
+ ctrlKey?: unknown;
+ metaKey?: unknown;
+ shiftKey?: unknown;
+ };
}): void => {
if (isBoolean(domEvent.altKey)) {
serializedEvent.altKey = domEvent.altKey;
diff --git a/packages/twenty-front-component-renderer/src/host/events/utils/applyMouseEventProperties.ts b/packages/twenty-front-component-renderer/src/host/events/utils/applyMouseEventProperties.ts
index b343fd3d8a9..d29f3e7e153 100644
--- a/packages/twenty-front-component-renderer/src/host/events/utils/applyMouseEventProperties.ts
+++ b/packages/twenty-front-component-renderer/src/host/events/utils/applyMouseEventProperties.ts
@@ -8,7 +8,7 @@ export const applyMouseEventProperties = ({
domEvent,
}: {
serializedEvent: SerializedEventData;
- domEvent: Record<string, unknown>;
+ domEvent: Partial<Record<keyof MouseEvent | 'changedTouches', unknown>>;
}): void => {
if (isNumber(domEvent.clientX)) {
serializedEvent.clientX = domEvent.clientX;
diff --git a/packages/twenty-front-component-renderer/src/host/events/utils/applyPointerEventProperties.ts b/packages/twenty-front-component-renderer/src/host/events/utils/applyPointerEventProperties.ts
index f4770af437f..46b34d7f116 100644
--- a/packages/twenty-front-component-renderer/src/host/events/utils/applyPointerEventProperties.ts
+++ b/packages/twenty-front-component-renderer/src/host/events/utils/applyPointerEventProperties.ts
@@ -7,7 +7,7 @@ export const applyPointerEventProperties = ({
domEvent,
}: {
serializedEvent: SerializedEventData;
- domEvent: Record<string, unknown>;
+ domEvent: Partial<Record<keyof PointerEvent, unknown>>;
}): void => {
if (isNumber(domEvent.pointerId)) {
serializedEvent.pointerId = domEvent.pointerId;
diff --git a/packages/twenty-front-component-renderer/src/host/events/utils/createCapturedPointerEventForwarder.ts b/packages/twenty-front-component-renderer/src/host/events/utils/createCapturedPointerEventForwarder.ts
new file mode 100644
index 00000000000..9dd1e3d8140
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/events/utils/createCapturedPointerEventForwarder.ts
@@ -0,0 +1,103 @@
+import { CAPTURED_POINTER_EVENT_TYPES } from '@/constants/CapturedPointerEventTypes';
+import { POINTER_GESTURE_END_EVENT_TYPES } from '@/constants/PointerGestureEndEventTypes';
+import { type ClaimPointerEventForwarding } from '@/host/events/types/ClaimPointerEventForwarding';
+import { applyEventModifierKeys } from '@/host/events/utils/applyEventModifierKeys';
+import { applyMouseEventProperties } from '@/host/events/utils/applyMouseEventProperties';
+import { applyPointerEventProperties } from '@/host/events/utils/applyPointerEventProperties';
+import { type SerializedEventData } from '@/types/SerializedEventData';
+
+const serializeCapturedPointerEvent = (
+ event: PointerEvent,
+): SerializedEventData => {
+ const serializedEvent: SerializedEventData = {
+ type: event.type,
+ bubbles: true,
+ };
+
+ applyEventModifierKeys({ serializedEvent, domEvent: event });
+ applyMouseEventProperties({ serializedEvent, domEvent: event });
+ applyPointerEventProperties({ serializedEvent, domEvent: event });
+
+ return serializedEvent;
+};
+
+export const createCapturedPointerEventForwarder = ({
+ element,
+ pointerId,
+ claimPointerEventForwarding,
+ forwardEvent,
+ onEnd,
+}: {
+ element: HTMLElement;
+ pointerId: number;
+ claimPointerEventForwarding: ClaimPointerEventForwarding;
+ forwardEvent: (eventData: SerializedEventData) => void;
+ onEnd: () => void;
+}): (() => void) => {
+ const documentTarget = element.ownerDocument;
+ let hasEnded = false;
+
+ const end = () => {
+ if (hasEnded) {
+ return;
+ }
+
+ hasEnded = true;
+ for (const eventType of CAPTURED_POINTER_EVENT_TYPES) {
+ element.removeEventListener(eventType, handleCapturingElementEvent);
+ documentTarget.removeEventListener(eventType, handlePointerEvent);
+ }
+ element.removeEventListener('lostpointercapture', handleCaptureLoss);
+ onEnd();
+ };
+
+ const handlePointerEvent = (event: PointerEvent) => {
+ if (hasEnded || !event.isTrusted || event.pointerId !== pointerId) {
+ return;
+ }
+
+ if (!element.isConnected) {
+ end();
+ return;
+ }
+
+ if (claimPointerEventForwarding(event)) {
+ forwardEvent(serializeCapturedPointerEvent(event));
+ }
+
+ if (!POINTER_GESTURE_END_EVENT_TYPES.has(event.type)) {
+ return;
+ }
+
+ if (element.hasPointerCapture(pointerId)) {
+ forwardEvent({
+ ...serializeCapturedPointerEvent(event),
+ type: 'lostpointercapture',
+ });
+ }
+
+ end();
+ };
+
+ const handleCapturingElementEvent = (event: PointerEvent) => {
+ if (event.target === element) {
+ handlePointerEvent(event);
+ }
+ };
+
+ const handleCaptureLoss = (event: PointerEvent) => {
+ if (!event.isTrusted || event.pointerId !== pointerId) {
+ return;
+ }
+
+ forwardEvent(serializeCapturedPointerEvent(event));
+ };
+
+ for (const eventType of CAPTURED_POINTER_EVENT_TYPES) {
+ element.addEventListener(eventType, handleCapturingElementEvent);
+ documentTarget.addEventListener(eventType, handlePointerEvent);
+ }
+ element.addEventListener('lostpointercapture', handleCaptureLoss);
+
+ return end;
+};
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
new file mode 100644
index 00000000000..f05b91d0c60
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/events/utils/createHostPointerCaptureController.ts
@@ -0,0 +1,79 @@
+import { isDefined } from 'twenty-shared/utils';
+
+import { CAPTURED_POINTER_EVENT_TYPES } from '@/constants/CapturedPointerEventTypes';
+import { type HostPointerCaptureController } from '@/host/events/types/HostPointerCaptureController';
+import { type PushCapturedPointerEvent } from '@/host/events/types/PushCapturedPointerEvent';
+import { createCapturedPointerEventForwarder } from '@/host/events/utils/createCapturedPointerEventForwarder';
+import { type GeometryTracker } from '@/host/geometry/types/GeometryTracker';
+
+const isCapturedPointerEvent = (nativeEvent: object): boolean =>
+ 'type' in nativeEvent &&
+ CAPTURED_POINTER_EVENT_TYPES.some(
+ (capturedEventType) => capturedEventType === nativeEvent.type,
+ );
+
+export const createHostPointerCaptureController = ({
+ geometryTracker,
+}: {
+ geometryTracker: GeometryTracker;
+}): HostPointerCaptureController => {
+ const endSessionByPointerId = new Map<number, () => void>();
+ const forwardedPointerEvents = new WeakSet<object>();
+ let pushCapturedPointerEvent: PushCapturedPointerEvent | null = null;
+
+ const claimPointerEventForwarding = (nativeEvent: object): boolean => {
+ if (forwardedPointerEvents.has(nativeEvent)) {
+ return false;
+ }
+
+ if (endSessionByPointerId.size > 0 && isCapturedPointerEvent(nativeEvent)) {
+ forwardedPointerEvents.add(nativeEvent);
+ }
+
+ return true;
+ };
+
+ const startPointerCapture = ({
+ element,
+ pointerId,
+ }: {
+ element: HTMLElement;
+ pointerId: number;
+ }) => {
+ endSessionByPointerId.get(pointerId)?.();
+
+ const remoteElementId =
+ geometryTracker.findRemoteElementIdContainingNode(element);
+
+ if (!isDefined(remoteElementId)) {
+ return;
+ }
+
+ endSessionByPointerId.set(
+ pointerId,
+ createCapturedPointerEventForwarder({
+ element,
+ pointerId,
+ claimPointerEventForwarding,
+ forwardEvent: (eventData) =>
+ pushCapturedPointerEvent?.({ remoteElementId, eventData }),
+ onEnd: () => endSessionByPointerId.delete(pointerId),
+ }),
+ );
+ };
+
+ return {
+ startPointerCapture,
+ claimPointerEventForwarding,
+ setPushCapturedPointerEvent: (nextPushCapturedPointerEvent) => {
+ pushCapturedPointerEvent = nextPushCapturedPointerEvent;
+ },
+ reset: () => {
+ pushCapturedPointerEvent = null;
+
+ for (const endSession of [...endSessionByPointerId.values()]) {
+ endSession();
+ }
+ },
+ };
+};
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 e7b7ba684a7..c6d74aa6883 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,4 +1,7 @@
+import { isDefined } from 'twenty-shared/utils';
+
import { FORM_CONTROL_STATE_SERIALIZED_EVENT_KEYS } from '@/host/events/constants/FormControlStateSerializedEventKeys';
+import { type ClaimPointerEventForwarding } from '@/host/events/types/ClaimPointerEventForwarding';
import { type RemoteSerializedEventListener } from '@/host/events/types/RemoteSerializedEventListener';
import { applyEventDispatchProperties } from '@/host/events/utils/applyEventDispatchProperties';
import { resolveNativeHostEvent } from '@/host/events/utils/resolveNativeHostEvent';
@@ -13,9 +16,11 @@ export const wrapEventHandler =
({
remoteListener,
findRemoteElementIdContainingNode,
+ claimPointerEventForwarding,
}: {
remoteListener: RemoteSerializedEventListener;
findRemoteElementIdContainingNode?: FindRemoteElementIdContainingNode;
+ claimPointerEventForwarding?: ClaimPointerEventForwarding;
}) =>
(hostEvent: object): void => {
if (forwardedBubblingHostEvents.has(hostEvent)) {
@@ -24,6 +29,13 @@ export const wrapEventHandler =
const nativeHostEvent = resolveNativeHostEvent(hostEvent);
+ if (
+ isDefined(claimPointerEventForwarding) &&
+ !claimPointerEventForwarding(nativeHostEvent)
+ ) {
+ return;
+ }
+
const serializedEvent = serializeEvent(hostEvent, {
includesFormControlState:
!nativeHostEventsWithForwardedFormControlState.has(nativeHostEvent),
@@ -46,7 +58,7 @@ export const wrapEventHandler =
nativeHostEventsWithForwardedFormControlState.add(nativeHostEvent);
}
- if (serializedEvent.bubbles === true) {
+ if (serializedEvent.bubbles) {
forwardedBubblingHostEvents.add(hostEvent);
}
};
diff --git a/packages/twenty-front-component-renderer/src/polyfills/events/types/WorkerPointerCapture.ts b/packages/twenty-front-component-renderer/src/polyfills/events/types/WorkerPointerCapture.ts
new file mode 100644
index 00000000000..10126f834bb
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/events/types/WorkerPointerCapture.ts
@@ -0,0 +1,6 @@
+import { type CapturedPointerEventUpdate } from '@/types/CapturedPointerEventUpdate';
+
+export type WorkerPointerCapture = {
+ dispatchCapturedPointerEvent: (update: CapturedPointerEventUpdate) => void;
+ scheduleDetachedCaptureSweep: () => void;
+};
diff --git a/packages/twenty-front-component-renderer/src/polyfills/events/utils/__tests__/installPointerCapturePolyfill.test.ts b/packages/twenty-front-component-renderer/src/polyfills/events/utils/__tests__/installPointerCapturePolyfill.test.ts
new file mode 100644
index 00000000000..2975d9e04d3
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/events/utils/__tests__/installPointerCapturePolyfill.test.ts
@@ -0,0 +1,170 @@
+import { connectRemoteNode, remoteId } from '@remote-dom/core/elements';
+import { Window } from '@remote-dom/polyfill';
+
+import { installPointerCapturePolyfill } from '../installPointerCapturePolyfill';
+
+const createCaptureFixture = () => {
+ const polyfillWindow = new Window();
+ const documentTarget = polyfillWindow.document as unknown as Document;
+ const connection = { mutate: jest.fn(), call: jest.fn() };
+ const workerPointerCapture = installPointerCapturePolyfill({
+ elementPrototype: polyfillWindow.Element.prototype,
+ documentTarget,
+ });
+ const element = documentTarget.createElement('div');
+
+ connectRemoteNode(documentTarget.body, connection);
+ documentTarget.body.append(element);
+ connectRemoteNode(element, connection);
+
+ return {
+ documentTarget,
+ connection,
+ element,
+ remoteElementId: remoteId(element),
+ workerPointerCapture,
+ };
+};
+
+describe('installPointerCapturePolyfill', () => {
+ it('should capture only connected elements without sending anything to the host', () => {
+ const { documentTarget, connection, element } = createCaptureFixture();
+ const detachedElement = documentTarget.createElement('div');
+
+ connection.mutate.mockClear();
+ detachedElement.setPointerCapture(1);
+ element.setPointerCapture(2);
+
+ expect(detachedElement.hasPointerCapture(1)).toBe(false);
+ expect(element.hasPointerCapture(2)).toBe(true);
+
+ element.releasePointerCapture(1);
+ expect(element.hasPointerCapture(2)).toBe(true);
+ element.releasePointerCapture(2);
+ expect(element.hasPointerCapture(2)).toBe(false);
+ expect(connection.call).not.toHaveBeenCalled();
+ expect(connection.mutate).not.toHaveBeenCalled();
+ });
+
+ it('should dispatch host-forwarded gesture events to document listeners without a worker capture', () => {
+ const { documentTarget, remoteElementId, workerPointerCapture } =
+ createCaptureFixture();
+ const deliveredMoves: number[] = [];
+
+ documentTarget.addEventListener('pointermove', (event) =>
+ deliveredMoves.push(event.clientX),
+ );
+ workerPointerCapture.dispatchCapturedPointerEvent({
+ remoteElementId,
+ eventData: {
+ type: 'pointermove',
+ bubbles: true,
+ pointerId: 0,
+ clientX: 80,
+ },
+ });
+ workerPointerCapture.dispatchCapturedPointerEvent({
+ remoteElementId: 'unknown',
+ eventData: { type: 'pointermove', bubbles: true, clientX: 100 },
+ });
+
+ expect(deliveredMoves).toEqual([80]);
+ });
+
+ it('should keep the capture through the gesture end until the host reports its release', () => {
+ const { documentTarget, element, remoteElementId, workerPointerCapture } =
+ createCaptureFixture();
+ const capturedDuringPointerUp: boolean[] = [];
+
+ element.setPointerCapture(1);
+ documentTarget.addEventListener('pointerup', () =>
+ capturedDuringPointerUp.push(element.hasPointerCapture(1)),
+ );
+ workerPointerCapture.dispatchCapturedPointerEvent({
+ remoteElementId,
+ eventData: { type: 'pointerup', bubbles: true, pointerId: 1 },
+ });
+
+ expect(capturedDuringPointerUp).toEqual([true]);
+
+ workerPointerCapture.dispatchCapturedPointerEvent({
+ remoteElementId,
+ eventData: { type: 'lostpointercapture', bubbles: true, pointerId: 1 },
+ });
+
+ expect(element.hasPointerCapture(1)).toBe(false);
+ });
+
+ it('should keep separate captures for several pointers and move a pointer to its latest capturing element', () => {
+ const { documentTarget, element } = createCaptureFixture();
+ const otherElement = documentTarget.createElement('div');
+
+ documentTarget.body.append(otherElement);
+ element.setPointerCapture(1);
+ element.setPointerCapture(2);
+ element.releasePointerCapture(2);
+
+ expect(element.hasPointerCapture(1)).toBe(true);
+ expect(element.hasPointerCapture(2)).toBe(false);
+
+ otherElement.setPointerCapture(1);
+
+ expect(element.hasPointerCapture(1)).toBe(false);
+ expect(otherElement.hasPointerCapture(1)).toBe(true);
+ });
+
+ it('should clear capture when the host reports a capture loss and keep delivering the gesture', () => {
+ const { documentTarget, element, remoteElementId, workerPointerCapture } =
+ createCaptureFixture();
+ const deliveredMoves: number[] = [];
+ const capturedDuringCaptureLoss: boolean[] = [];
+
+ element.setPointerCapture(1);
+ element.addEventListener('lostpointercapture', () =>
+ capturedDuringCaptureLoss.push(element.hasPointerCapture(1)),
+ );
+ documentTarget.addEventListener('pointermove', (event) =>
+ deliveredMoves.push(event.clientX),
+ );
+ workerPointerCapture.dispatchCapturedPointerEvent({
+ remoteElementId,
+ eventData: { type: 'lostpointercapture', bubbles: true, pointerId: 1 },
+ });
+
+ expect(capturedDuringCaptureLoss).toEqual([false]);
+
+ workerPointerCapture.dispatchCapturedPointerEvent({
+ remoteElementId,
+ eventData: {
+ type: 'pointermove',
+ bubbles: true,
+ pointerId: 1,
+ clientX: 60,
+ },
+ });
+
+ expect(deliveredMoves).toEqual([60]);
+ });
+
+ it('should forget a removed capturing element after the detach sweep and keep a moved one', async () => {
+ const { documentTarget, element, workerPointerCapture } =
+ createCaptureFixture();
+ const movedElement = documentTarget.createElement('div');
+
+ documentTarget.body.append(movedElement);
+ element.setPointerCapture(1);
+ movedElement.setPointerCapture(2);
+ element.remove();
+ movedElement.remove();
+ workerPointerCapture.scheduleDetachedCaptureSweep();
+ documentTarget.body.append(movedElement);
+
+ expect(element.hasPointerCapture(1)).toBe(false);
+
+ await Promise.resolve();
+ documentTarget.body.append(element);
+
+ expect(element.hasPointerCapture(1)).toBe(false);
+ expect(movedElement.hasPointerCapture(2)).toBe(true);
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/polyfills/events/utils/installPointerCapturePolyfill.ts b/packages/twenty-front-component-renderer/src/polyfills/events/utils/installPointerCapturePolyfill.ts
new file mode 100644
index 00000000000..debb7f192c6
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/events/utils/installPointerCapturePolyfill.ts
@@ -0,0 +1,139 @@
+import { remoteId } from '@remote-dom/core/elements';
+import { isInteger } from '@sniptt/guards';
+import { isDefined } from 'twenty-shared/utils';
+
+import { POINTER_GESTURE_END_EVENT_TYPES } from '@/constants/PointerGestureEndEventTypes';
+import { findElementByRemoteId } from '@/polyfills/dom/utils/findElementByRemoteId';
+import { isElementNode } from '@/polyfills/dom/utils/isElementNode';
+import { type WorkerPointerCapture } from '@/polyfills/events/types/WorkerPointerCapture';
+import { isElementUnderRemoteRoot } from '@/polyfills/geometry/utils/isElementUnderRemoteRoot';
+import { definePolyfillMethod } from '@/polyfills/utils/definePolyfillMethod';
+import { createWorkerEventFromSerializedEvent } from '@/remote/elements/utils/createWorkerEventFromSerializedEvent';
+import { type CapturedPointerEventUpdate } from '@/types/CapturedPointerEventUpdate';
+
+export const installPointerCapturePolyfill = ({
+ elementPrototype,
+ documentTarget,
+}: {
+ elementPrototype: object;
+ documentTarget: Document;
+}): WorkerPointerCapture => {
+ const capturingElementByPointerId = new Map<number, Element>();
+ let gesturePointerTarget: Element | null = null;
+ let hasScheduledDetachedCaptureSweep = false;
+
+ const sweepDetachedCaptures = () => {
+ hasScheduledDetachedCaptureSweep = false;
+
+ for (const [pointerId, element] of capturingElementByPointerId) {
+ if (!isElementUnderRemoteRoot(element, documentTarget.body)) {
+ capturingElementByPointerId.delete(pointerId);
+ }
+ }
+ };
+
+ const releasePointerCapture = ({
+ element,
+ pointerId,
+ }: {
+ element: Element;
+ pointerId: number;
+ }) => {
+ if (capturingElementByPointerId.get(pointerId) === element) {
+ capturingElementByPointerId.delete(pointerId);
+ }
+ };
+
+ definePolyfillMethod<Element>({
+ target: elementPrototype,
+ methodName: 'setPointerCapture',
+ method: (element, pointerId) => {
+ if (
+ isInteger(pointerId) &&
+ isElementUnderRemoteRoot(element, documentTarget.body)
+ ) {
+ capturingElementByPointerId.set(pointerId, element);
+ }
+ },
+ });
+ definePolyfillMethod<Element>({
+ target: elementPrototype,
+ methodName: 'releasePointerCapture',
+ method: (element, pointerId) => {
+ if (isInteger(pointerId)) {
+ releasePointerCapture({ element, pointerId });
+ }
+ },
+ });
+ definePolyfillMethod<Element>({
+ target: elementPrototype,
+ methodName: 'hasPointerCapture',
+ method: (element, pointerId) =>
+ isInteger(pointerId) &&
+ capturingElementByPointerId.get(pointerId) === element &&
+ isElementUnderRemoteRoot(element, documentTarget.body),
+ });
+
+ const findGesturePointerTarget = (
+ remoteElementId: string,
+ ): Element | null => {
+ if (
+ isDefined(gesturePointerTarget) &&
+ gesturePointerTarget.isConnected &&
+ remoteId(gesturePointerTarget) === remoteElementId
+ ) {
+ return gesturePointerTarget;
+ }
+
+ const element = findElementByRemoteId({
+ rootNode: documentTarget.body,
+ remoteElementId,
+ });
+ gesturePointerTarget = isElementNode(element) ? element : null;
+
+ return gesturePointerTarget;
+ };
+
+ return {
+ dispatchCapturedPointerEvent: ({
+ remoteElementId,
+ eventData,
+ }: CapturedPointerEventUpdate) => {
+ const element = findGesturePointerTarget(remoteElementId);
+
+ if (POINTER_GESTURE_END_EVENT_TYPES.has(eventData.type)) {
+ gesturePointerTarget = null;
+ }
+
+ if (!isDefined(element)) {
+ return;
+ }
+
+ if (
+ eventData.type === 'lostpointercapture' &&
+ isDefined(eventData.pointerId)
+ ) {
+ releasePointerCapture({ element, pointerId: eventData.pointerId });
+ }
+
+ element.dispatchEvent(
+ createWorkerEventFromSerializedEvent({
+ listeningElement: element,
+ eventType: eventData.type,
+ eventData,
+ }),
+ );
+ },
+ scheduleDetachedCaptureSweep: () => {
+ if (
+ hasScheduledDetachedCaptureSweep ||
+ capturingElementByPointerId.size === 0
+ ) {
+ return;
+ }
+
+ hasScheduledDetachedCaptureSweep = true;
+ queueMicrotask(sweepDetachedCaptures);
+ },
+ };
+};
diff --git a/packages/twenty-front-component-renderer/src/remote/generated/remote-elements.ts b/packages/twenty-front-component-renderer/src/remote/generated/remote-elements.ts
index 03811372420..3d3c07d3dae 100644
--- a/packages/twenty-front-component-renderer/src/remote/generated/remote-elements.ts
+++ b/packages/twenty-front-component-renderer/src/remote/generated/remote-elements.ts
@@ -529,6 +529,9 @@ export const HtmlLabelElement = createRemoteElement<
export type HtmlInputProperties = HtmlCommonProperties & {
type?: string;
name?: string;
+ min?: string;
+ max?: string;
+ step?: string;
value?: string;
placeholder?: string;
disabled?: boolean;
@@ -558,6 +561,9 @@ export const HtmlInputElement = createRemoteElement<
...HTML_COMMON_PROPERTIES_CONFIG,
type: { type: String },
name: { type: String },
+ min: { type: String },
+ max: { type: String },
+ step: { type: String },
value: { type: String },
placeholder: { type: String },
disabled: { type: Boolean },
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 78595f7689b..2eff4be684e 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
@@ -38,6 +38,7 @@ import { installLocalStyleOnBaseElements } from '@/polyfills/dom/utils/installLo
import { installMutationObserver } from '@/polyfills/dom/utils/installMutationObserver';
import { installNodeContainsPolyfill } from '@/polyfills/dom/utils/installNodeContainsPolyfill';
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 { installSelectorMethodsPolyfill } from '@/polyfills/selectors/utils/installSelectorMethodsPolyfill';
@@ -124,6 +125,10 @@ installDocumentActiveElementPolyfill({
documentTarget: document,
activeElementStore: workerActiveElementStore,
});
+const workerPointerCapture = installPointerCapturePolyfill({
+ elementPrototype: HTMLElement.prototype,
+ documentTarget: document,
+});
installActiveElementDetachmentHook({
hooks: resolvePolyfillHooks(
resolveGlobalScopeInstallTargets(toGlobalScopeRecord(globalThis)),
@@ -132,6 +137,7 @@ installActiveElementDetachmentHook({
onRemoveSubtree: (node) => {
workerFocusTransport.blurFocusedElementWithinSubtree(node);
workerInputSelectionStore.scheduleDetachedElementSweep();
+ workerPointerCapture.scheduleDetachedCaptureSweep();
},
});
installHostEventRetargetingPolyfill(HTMLElement.prototype);
@@ -271,6 +277,9 @@ const workerExports: WorkerExports = {
isFocusVisible,
});
},
+ pushCapturedPointerEvent: async (update) => {
+ workerPointerCapture.dispatchCapturedPointerEvent(update);
+ },
pushMediaSessionEvents: async (batch) => {
workerMediaBridge.dispatchEvents(batch);
},
diff --git a/packages/twenty-front-component-renderer/src/testing/createHostPointerCaptureControllerStub.ts b/packages/twenty-front-component-renderer/src/testing/createHostPointerCaptureControllerStub.ts
new file mode 100644
index 00000000000..89d3af3aa63
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/testing/createHostPointerCaptureControllerStub.ts
@@ -0,0 +1,9 @@
+import { type HostPointerCaptureController } from '@/host/events/types/HostPointerCaptureController';
+
+export const createHostPointerCaptureControllerStub =
+ (): HostPointerCaptureController => ({
+ startPointerCapture: jest.fn(),
+ claimPointerEventForwarding: jest.fn(() => true),
+ setPushCapturedPointerEvent: jest.fn(),
+ reset: jest.fn(),
+ });
diff --git a/packages/twenty-front-component-renderer/src/types/CapturedPointerEventUpdate.ts b/packages/twenty-front-component-renderer/src/types/CapturedPointerEventUpdate.ts
new file mode 100644
index 00000000000..9ba6d0f6ae3
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/types/CapturedPointerEventUpdate.ts
@@ -0,0 +1,6 @@
+import { type SerializedEventData } from '@/types/SerializedEventData';
+
+export type CapturedPointerEventUpdate = {
+ remoteElementId: string;
+ eventData: SerializedEventData;
+};
diff --git a/packages/twenty-front-component-renderer/src/types/WorkerExports.ts b/packages/twenty-front-component-renderer/src/types/WorkerExports.ts
index 8bca5c20915..3f09fab6f27 100644
--- a/packages/twenty-front-component-renderer/src/types/WorkerExports.ts
+++ b/packages/twenty-front-component-renderer/src/types/WorkerExports.ts
@@ -3,6 +3,7 @@ import {
type CommandConfirmationModalResult,
type FrontComponentExecutionContext,
} from 'twenty-sdk/front-component';
+import { type CapturedPointerEventUpdate } from '@/types/CapturedPointerEventUpdate';
import { type FocusUpdate } from '@/types/FocusUpdate';
import { type GeometryUpdateBatch } from '@/types/GeometryUpdateBatch';
import { type HostToWorkerRenderContext } from '@/types/HostToWorkerRenderContext';
@@ -20,5 +21,8 @@ export type WorkerExports = {
) => Promise<void>;
pushGeometryUpdates: (batch: GeometryUpdateBatch) => Promise<void>;
pushFocusUpdate: (update: FocusUpdate) => Promise<void>;
+ pushCapturedPointerEvent: (
+ update: CapturedPointerEventUpdate,
+ ) => Promise<void>;
pushMediaSessionEvents: (batch: MediaSessionEventBatch) => Promise<void>;
};