Skip to content

The open alternative to Salesforce, designed for AI.

Support scrolling inside front component controls (#27895)

Raphaël Bosi38c5ca739f67
diff --git a/packages/twenty-docs/developers/extend/apps/layout/front-components.mdx b/packages/twenty-docs/developers/extend/apps/layout/front-components.mdx
index cadcc32a701..cc4fb2c794f 100644
--- a/packages/twenty-docs/developers/extend/apps/layout/front-components.mdx
+++ b/packages/twenty-docs/developers/extend/apps/layout/front-components.mdx
@@ -1059,7 +1059,7 @@ Elements can measure themselves: the host mirrors geometry into the sandbox, so
| API | What happens |
| ---------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
-| `getBoundingClientRect()`, `offsetWidth`, `clientWidth`, `scrollWidth`, `offsetTop`, ... | Work, from the mirror; assigning `scrollTop` / `scrollLeft` is a no-op |
+| `getBoundingClientRect()`, `offsetWidth`, `clientWidth`, `scrollWidth`, `offsetTop`, ... | Work, from the mirror; assigning `scrollTop` / `scrollLeft` scrolls the element on the page (see Scrolling) |
| `getClientRects()` | Throws |
| `window.matchMedia()` | Works for a fixed set of features, with `change` events (see below) |
| `window.innerWidth`, `innerHeight`, `devicePixelRatio`, `scrollX`, `scrollY` | Work, reporting the **browser viewport**; your widget's own size is `document.body.clientWidth` / `clientHeight` |
@@ -1083,6 +1083,18 @@ The height you are handed is your own box as well, and depending on where the ho
animation.
</Note>
+### Scrolling
+
+Assigning `scrollTop` or `scrollLeft`, calling `scrollTo()` or its alias `scroll()`, and calling `scrollIntoView()` scroll the matching element on the page:
+
+- Scroll changes apply after the next render, in the order your code made them. Within one render, input selection changes apply first, so `setSelectionRange()` followed by a `scrollLeft` write keeps the caret visible.
+- Reads return the value you wrote until the page reports the real position, which the browser clamps to the scrollable range. In right-to-left containers, `scrollLeft` is zero or negative, as in browsers.
+- `scrollIntoView()` accepts `block` and `inline` with `start`, `center`, `end` and `nearest`, aligning `block` vertically and `inline` horizontally, so vertical writing modes are not mapped. It only scrolls your component's own scroll containers, never the widget frame, the page or another component. `focus()` still reveals the focused element the way the browser does.
+- Scrolling is instant: `behavior` and the `container` option are ignored, and `scrollBy()` is not available.
+- Writing back a position you just read, such as `element.scrollTop = element.scrollTop`, does nothing, so it cannot undo a scroll the user made in the meantime. This only holds once the page has measured the element; until then the write is applied.
+- Scrolling `document.documentElement`, `document.body` or `window` stays inside the sandbox and never scrolls the page; `window.scrollTo()`, `scroll()` and `scrollBy()` do nothing.
+- The first read of a container that was never measured returns zeros (see Layout and measurement), so a scrollability check made right after the container appears can report it as not scrollable.
+
### Global scope
The worker's own natives are also aliased onto `window`, so they work with or without the `window.` prefix: `fetch`, `setTimeout`/`clearTimeout`, `setInterval`/`clearInterval`, `queueMicrotask`, `console`, `crypto`, `performance`, `structuredClone`, `btoa`/`atob`, `URL`/`URLSearchParams`, `AbortController`/`AbortSignal`, `Headers`/`Request`/`Response`, `Blob`, `File`, `FormData` and `TextEncoder`/`TextDecoder`.
@@ -1091,19 +1103,21 @@ The worker's own natives are also aliased onto `window`, so they work with or wi
A `ref` gives you a sandbox element, not an `HTMLElement`.
-| What you write | What happens | Use instead |
-| ----------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ref.current.focus()`, `.blur()` | Forward to the corresponding element on the page and update the sandbox's active element | `onFocus` / `onBlur` to observe focus changes |
-| `ref.current.click()` | Dispatches a `click` inside the sandbox: a checkbox or radio toggles and its `onChange` runs, but the element on the page is not clicked | Controlled components for anything the page must do |
-| `ref.current.select()`, `.setSelectionRange()`, `.scrollIntoView()`, `video.play()` | Throws | Controlled components; read values from `event.target` |
-| `document.createTreeWalker()` | Throws | `querySelector()` / `querySelectorAll()`, `matches()`, `closest()` (including pseudo-classes such as `:disabled` and `:not()`), `getElementById()`, `contains()` and `compareDocumentPosition()` work; `getElementsByClassName()` works too, but returns a static collection, not a live `HTMLCollection` |
-| `document.activeElement` | Follows the page's focus inside the component and updates when sandbox code calls `focus()` or `blur()` | `onFocus` / `onBlur` to react to the page's focus |
-| `canvas` | Renders nothing, no error | SVG, or draw offscreen and show the result in an `img` element |
-| `createPortal(node, document.body)` | Renders in a host overlay layer bounded to 200px around the component | Keep overlays within this area, or add scrolling for larger content |
+| What you write | What happens | Use instead |
+| ---------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ref.current.focus()`, `.blur()` | Forward to the corresponding element on the page and update the sandbox's active element | `onFocus` / `onBlur` to observe focus changes |
+| `ref.current.click()` | Dispatches a `click` inside the sandbox: a checkbox or radio toggles and its `onChange` runs, but the element on the page is not clicked | Controlled components for anything the page must do |
+| `ref.current.select()`, `.setSelectionRange()` | Work on `input` and `textarea`, applied to the element on the page after the next render | Controlled components for the value itself |
+| `ref.current.scrollTo()`, `.scrollIntoView()` | Scroll the component's own scroll containers on the page (see Scrolling) | `focus()` when you also want to move focus |
+| `video.play()` | Throws | Controlled components; read values from `event.target` |
+| `document.createTreeWalker()` | Throws | `querySelector()` / `querySelectorAll()`, `matches()`, `closest()` (including pseudo-classes such as `:disabled` and `:not()`), `getElementById()`, `contains()` and `compareDocumentPosition()` work; `getElementsByClassName()` works too, but returns a static collection, not a live `HTMLCollection` |
+| `document.activeElement` | Follows the page's focus inside the component and updates when sandbox code calls `focus()` or `blur()` | `onFocus` / `onBlur` to react to the page's focus |
+| `canvas` | Renders nothing, no error | SVG, or draw offscreen and show the result in an `img` element |
+| `createPortal(node, document.body)` | Renders in a host overlay layer bounded to 200px around the component | Keep overlays within this area, or add scrolling for larger content |
`element.classList` works, backed by the `class` attribute: `add`, `remove`, `toggle`, `replace`, `contains`, `item`, `length`, `value` and iteration all behave as they do in a browser, and `className` stays in sync. `element.dataset` works the same way, backed by the `data-*` attributes; write `data-*` names in lowercase, since the sandbox keeps attribute names as written instead of lowercasing them like a browser.
-Body portals can extend up to 200px beyond each edge of your component, including outside a widget's scroll frame. Larger overlays are clipped to this area, so give long menus their own scrolling container. Native top-layer APIs such as `showModal()`, `showPopover()` and `requestFullscreen()` are blocked.
+Body portals can extend up to 200px beyond each edge of your component, including outside a widget's scroll frame. Larger overlays are clipped to this area, so give long menus their own scrolling container. Keyboard navigation in Twenty UI lists such as Autocomplete and Select reveals the highlighted option inside that container. Native top-layer APIs such as `showModal()`, `showPopover()` and `requestFullscreen()` are blocked.
### Events
diff --git a/packages/twenty-front-component-renderer/src/__stories__/ScrollCommands.stories.tsx b/packages/twenty-front-component-renderer/src/__stories__/ScrollCommands.stories.tsx
new file mode 100644
index 00000000000..5a9d9974b1b
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/ScrollCommands.stories.tsx
@@ -0,0 +1,144 @@
+import { type Meta } from '@storybook/react-vite';
+
+import {
+ FRONT_COMPONENT_STORY_DEFAULT_ARGS,
+ resetFrontComponentStoryMocks,
+} from '@/__stories__/shared/test-utils/createFrontComponentStoryMeta';
+import { OverflowingListInstancesDecorator } from '@/__stories__/twenty-ui-gallery/components/OverflowingListInstancesDecorator';
+import { ScrollBoundaryDecorator } from '@/__stories__/twenty-ui-gallery/components/ScrollBoundaryDecorator';
+import { type TwentyUiGalleryStory } from '@/__stories__/twenty-ui-gallery/types/TwentyUiGalleryStory';
+import { createGalleryStory } from '@/__stories__/twenty-ui-gallery/utils/createGalleryStory';
+import { scrollDetachNoReplayTest } from '@/__stories__/twenty-ui-gallery/utils/scrollDetachNoReplayTest';
+import { scrollEchoElisionTest } from '@/__stories__/twenty-ui-gallery/utils/scrollEchoElisionTest';
+import { scrollEventEchoTest } from '@/__stories__/twenty-ui-gallery/utils/scrollEventEchoTest';
+import { scrollInstancesTest } from '@/__stories__/twenty-ui-gallery/utils/scrollInstancesTest';
+import { scrollNestedRevealTest } from '@/__stories__/twenty-ui-gallery/utils/scrollNestedRevealTest';
+import { scrollPageStaysLocalTest } from '@/__stories__/twenty-ui-gallery/utils/scrollPageStaysLocalTest';
+import { scrollPortalRefreshTest } from '@/__stories__/twenty-ui-gallery/utils/scrollPortalRefreshTest';
+import { scrollReadAfterWriteTest } from '@/__stories__/twenty-ui-gallery/utils/scrollReadAfterWriteTest';
+import { scrollRtlRevealTest } from '@/__stories__/twenty-ui-gallery/utils/scrollRtlRevealTest';
+import { FrontComponentRenderer } from '@/host/components/FrontComponentRenderer';
+
+const meta: Meta<typeof FrontComponentRenderer> = {
+ title: 'FrontComponent/Scroll Commands',
+ component: FrontComponentRenderer,
+ parameters: { layout: 'centered' },
+ args: FRONT_COMPONENT_STORY_DEFAULT_ARGS,
+ beforeEach: resetFrontComponentStoryMocks,
+};
+
+export default meta;
+
+export const NestedRevealReact: TwentyUiGalleryStory = createGalleryStory({
+ frontComponentBundleName: 'scroll-commands',
+ runtime: 'react',
+ play: scrollNestedRevealTest,
+ decorators: [ScrollBoundaryDecorator],
+});
+
+export const NestedRevealPreact: TwentyUiGalleryStory = createGalleryStory({
+ frontComponentBundleName: 'scroll-commands',
+ runtime: 'preact',
+ play: scrollNestedRevealTest,
+ decorators: [ScrollBoundaryDecorator],
+});
+
+export const RtlRevealReact: TwentyUiGalleryStory = createGalleryStory({
+ frontComponentBundleName: 'scroll-commands',
+ runtime: 'react',
+ play: scrollRtlRevealTest,
+});
+
+export const RtlRevealPreact: TwentyUiGalleryStory = createGalleryStory({
+ frontComponentBundleName: 'scroll-commands',
+ runtime: 'preact',
+ play: scrollRtlRevealTest,
+});
+
+export const ReadAfterWriteReact: TwentyUiGalleryStory = createGalleryStory({
+ frontComponentBundleName: 'scroll-commands',
+ runtime: 'react',
+ play: scrollReadAfterWriteTest,
+});
+
+export const ReadAfterWritePreact: TwentyUiGalleryStory = createGalleryStory({
+ frontComponentBundleName: 'scroll-commands',
+ runtime: 'preact',
+ play: scrollReadAfterWriteTest,
+});
+
+export const EchoElisionReact: TwentyUiGalleryStory = createGalleryStory({
+ frontComponentBundleName: 'scroll-commands',
+ runtime: 'react',
+ play: scrollEchoElisionTest,
+});
+
+export const EchoElisionPreact: TwentyUiGalleryStory = createGalleryStory({
+ frontComponentBundleName: 'scroll-commands',
+ runtime: 'preact',
+ play: scrollEchoElisionTest,
+});
+
+export const EventEchoReact: TwentyUiGalleryStory = createGalleryStory({
+ frontComponentBundleName: 'scroll-commands',
+ runtime: 'react',
+ play: scrollEventEchoTest,
+});
+
+export const EventEchoPreact: TwentyUiGalleryStory = createGalleryStory({
+ frontComponentBundleName: 'scroll-commands',
+ runtime: 'preact',
+ play: scrollEventEchoTest,
+});
+
+export const DetachNoReplayReact: TwentyUiGalleryStory = createGalleryStory({
+ frontComponentBundleName: 'scroll-commands',
+ runtime: 'react',
+ play: scrollDetachNoReplayTest,
+});
+
+export const DetachNoReplayPreact: TwentyUiGalleryStory = createGalleryStory({
+ frontComponentBundleName: 'scroll-commands',
+ runtime: 'preact',
+ play: scrollDetachNoReplayTest,
+});
+
+export const PortalRefreshReact: TwentyUiGalleryStory = createGalleryStory({
+ frontComponentBundleName: 'scroll-commands',
+ runtime: 'react',
+ play: scrollPortalRefreshTest,
+});
+
+export const PortalRefreshPreact: TwentyUiGalleryStory = createGalleryStory({
+ frontComponentBundleName: 'scroll-commands',
+ runtime: 'preact',
+ play: scrollPortalRefreshTest,
+});
+
+export const PageStaysLocalReact: TwentyUiGalleryStory = createGalleryStory({
+ frontComponentBundleName: 'scroll-commands',
+ runtime: 'react',
+ play: scrollPageStaysLocalTest,
+ decorators: [ScrollBoundaryDecorator],
+});
+
+export const PageStaysLocalPreact: TwentyUiGalleryStory = createGalleryStory({
+ frontComponentBundleName: 'scroll-commands',
+ runtime: 'preact',
+ play: scrollPageStaysLocalTest,
+ decorators: [ScrollBoundaryDecorator],
+});
+
+export const InstancesReact: TwentyUiGalleryStory = createGalleryStory({
+ frontComponentBundleName: 'scroll-commands',
+ runtime: 'react',
+ play: scrollInstancesTest,
+ decorators: [OverflowingListInstancesDecorator],
+});
+
+export const InstancesPreact: TwentyUiGalleryStory = createGalleryStory({
+ frontComponentBundleName: 'scroll-commands',
+ runtime: 'preact',
+ play: scrollInstancesTest,
+ decorators: [OverflowingListInstancesDecorator],
+});
diff --git a/packages/twenty-front-component-renderer/src/__stories__/TwentyUiScrolling.stories.tsx b/packages/twenty-front-component-renderer/src/__stories__/TwentyUiScrolling.stories.tsx
new file mode 100644
index 00000000000..bc945e04d18
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/TwentyUiScrolling.stories.tsx
@@ -0,0 +1,142 @@
+import { type Meta } from '@storybook/react-vite';
+
+import {
+ FRONT_COMPONENT_STORY_DEFAULT_ARGS,
+ resetFrontComponentStoryMocks,
+} from '@/__stories__/shared/test-utils/createFrontComponentStoryMeta';
+import { type TwentyUiGalleryStory } from '@/__stories__/twenty-ui-gallery/types/TwentyUiGalleryStory';
+import { ScrollBoundaryDecorator } from '@/__stories__/twenty-ui-gallery/components/ScrollBoundaryDecorator';
+import { autocompleteFilterResetTest } from '@/__stories__/twenty-ui-gallery/utils/autocompleteFilterResetTest';
+import { autocompleteNestedRevealTest } from '@/__stories__/twenty-ui-gallery/utils/autocompleteNestedRevealTest';
+import { autocompleteRevealTest } from '@/__stories__/twenty-ui-gallery/utils/autocompleteRevealTest';
+import { createAutocompleteLongInputTest } from '@/__stories__/twenty-ui-gallery/utils/createAutocompleteLongInputTest';
+import { createGalleryStory } from '@/__stories__/twenty-ui-gallery/utils/createGalleryStory';
+import { selectAlignedOpenTest } from '@/__stories__/twenty-ui-gallery/utils/selectAlignedOpenTest';
+import { selectRevealTest } from '@/__stories__/twenty-ui-gallery/utils/selectRevealTest';
+import { tabsOverflowTest } from '@/__stories__/twenty-ui-gallery/utils/tabsOverflowTest';
+import { FrontComponentRenderer } from '@/host/components/FrontComponentRenderer';
+
+const meta: Meta<typeof FrontComponentRenderer> = {
+ title: 'FrontComponent/Twenty UI Scrolling',
+ component: FrontComponentRenderer,
+ parameters: { layout: 'centered' },
+ args: FRONT_COMPONENT_STORY_DEFAULT_ARGS,
+ beforeEach: resetFrontComponentStoryMocks,
+};
+
+export default meta;
+
+export const AutocompleteRevealReact: TwentyUiGalleryStory = createGalleryStory(
+ {
+ frontComponentBundleName: 'twenty-ui-autocomplete-scrolling',
+ runtime: 'react',
+ play: autocompleteRevealTest,
+ },
+);
+
+export const AutocompleteRevealPreact: TwentyUiGalleryStory =
+ createGalleryStory({
+ frontComponentBundleName: 'twenty-ui-autocomplete-scrolling',
+ runtime: 'preact',
+ play: autocompleteRevealTest,
+ });
+
+export const AutocompleteNestedRevealReact: TwentyUiGalleryStory =
+ createGalleryStory({
+ frontComponentBundleName: 'twenty-ui-autocomplete-scrolling',
+ runtime: 'react',
+ play: autocompleteNestedRevealTest,
+ decorators: [ScrollBoundaryDecorator],
+ });
+
+export const AutocompleteNestedRevealPreact: TwentyUiGalleryStory =
+ createGalleryStory({
+ frontComponentBundleName: 'twenty-ui-autocomplete-scrolling',
+ runtime: 'preact',
+ play: autocompleteNestedRevealTest,
+ decorators: [ScrollBoundaryDecorator],
+ });
+
+export const AutocompleteFilterResetReact: TwentyUiGalleryStory =
+ createGalleryStory({
+ frontComponentBundleName: 'twenty-ui-autocomplete-scrolling',
+ runtime: 'react',
+ play: autocompleteFilterResetTest,
+ });
+
+export const AutocompleteFilterResetPreact: TwentyUiGalleryStory =
+ createGalleryStory({
+ frontComponentBundleName: 'twenty-ui-autocomplete-scrolling',
+ runtime: 'preact',
+ play: autocompleteFilterResetTest,
+ });
+
+export const AutocompleteLongInputReact: TwentyUiGalleryStory =
+ createGalleryStory({
+ frontComponentBundleName: 'twenty-ui-autocomplete-scrolling',
+ runtime: 'react',
+ play: createAutocompleteLongInputTest({ isTrusted: false }),
+ });
+
+export const AutocompleteLongInputPreact: TwentyUiGalleryStory =
+ createGalleryStory({
+ frontComponentBundleName: 'twenty-ui-autocomplete-scrolling',
+ runtime: 'preact',
+ play: createAutocompleteLongInputTest({ isTrusted: false }),
+ });
+
+export const AutocompleteTrustedLongInputReact: TwentyUiGalleryStory = {
+ ...createGalleryStory({
+ frontComponentBundleName: 'twenty-ui-autocomplete-scrolling',
+ runtime: 'react',
+ play: createAutocompleteLongInputTest({ isTrusted: true }),
+ }),
+ tags: ['!dev'],
+};
+
+export const AutocompleteTrustedLongInputPreact: TwentyUiGalleryStory = {
+ ...createGalleryStory({
+ frontComponentBundleName: 'twenty-ui-autocomplete-scrolling',
+ runtime: 'preact',
+ play: createAutocompleteLongInputTest({ isTrusted: true }),
+ }),
+ tags: ['!dev'],
+};
+
+export const SelectRevealReact: TwentyUiGalleryStory = createGalleryStory({
+ frontComponentBundleName: 'twenty-ui-select-scrolling',
+ runtime: 'react',
+ play: selectRevealTest,
+});
+
+export const SelectRevealPreact: TwentyUiGalleryStory = createGalleryStory({
+ frontComponentBundleName: 'twenty-ui-select-scrolling',
+ runtime: 'preact',
+ play: selectRevealTest,
+});
+
+export const SelectAlignedOpenReact: TwentyUiGalleryStory = createGalleryStory({
+ frontComponentBundleName: 'twenty-ui-select-scrolling',
+ runtime: 'react',
+ play: selectAlignedOpenTest,
+});
+
+export const SelectAlignedOpenPreact: TwentyUiGalleryStory = createGalleryStory(
+ {
+ frontComponentBundleName: 'twenty-ui-select-scrolling',
+ runtime: 'preact',
+ play: selectAlignedOpenTest,
+ },
+);
+
+export const TabsOverflowReact: TwentyUiGalleryStory = createGalleryStory({
+ frontComponentBundleName: 'twenty-ui-tabs-scrolling',
+ runtime: 'react',
+ play: tabsOverflowTest,
+});
+
+export const TabsOverflowPreact: TwentyUiGalleryStory = createGalleryStory({
+ frontComponentBundleName: 'twenty-ui-tabs-scrolling',
+ runtime: 'preact',
+ play: tabsOverflowTest,
+});
diff --git a/packages/twenty-front-component-renderer/src/__stories__/shared/test-utils/matchers/expectElementWithinScrollport.ts b/packages/twenty-front-component-renderer/src/__stories__/shared/test-utils/matchers/expectElementWithinScrollport.ts
new file mode 100644
index 00000000000..8aa652ccebf
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/shared/test-utils/matchers/expectElementWithinScrollport.ts
@@ -0,0 +1,29 @@
+import { expect } from 'storybook/test';
+
+import { readScrollportRectangle } from '@/__stories__/shared/test-utils/readScrollportRectangle';
+
+const SCROLLPORT_TOLERANCE = 1;
+
+export const expectElementWithinScrollport = ({
+ element,
+ scrollContainer,
+}: {
+ element: Element;
+ scrollContainer: Element;
+}): void => {
+ const elementRectangle = element.getBoundingClientRect();
+ const scrollport = readScrollportRectangle(scrollContainer);
+
+ expect(elementRectangle.top).toBeGreaterThanOrEqual(
+ scrollport.top - SCROLLPORT_TOLERANCE,
+ );
+ expect(elementRectangle.bottom).toBeLessThanOrEqual(
+ scrollport.bottom + SCROLLPORT_TOLERANCE,
+ );
+ expect(elementRectangle.left).toBeGreaterThanOrEqual(
+ scrollport.left - SCROLLPORT_TOLERANCE,
+ );
+ expect(elementRectangle.right).toBeLessThanOrEqual(
+ scrollport.right + SCROLLPORT_TOLERANCE,
+ );
+};
diff --git a/packages/twenty-front-component-renderer/src/__stories__/shared/test-utils/matchers/expectFocusedElementWithinScrollport.ts b/packages/twenty-front-component-renderer/src/__stories__/shared/test-utils/matchers/expectFocusedElementWithinScrollport.ts
new file mode 100644
index 00000000000..bc27f4d54d0
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/shared/test-utils/matchers/expectFocusedElementWithinScrollport.ts
@@ -0,0 +1,24 @@
+import { expect, waitFor } from 'storybook/test';
+
+import { expectElementWithinScrollport } from '@/__stories__/shared/test-utils/matchers/expectElementWithinScrollport';
+import { INTERACTION_TIMEOUT } from '@/__stories__/shared/test-utils/timeouts';
+
+export const expectFocusedElementWithinScrollport = ({
+ findElement,
+ findScrollContainer,
+}: {
+ findElement: () => HTMLElement;
+ findScrollContainer: (element: HTMLElement) => Element;
+}): Promise<void> =>
+ waitFor(
+ () => {
+ const element = findElement();
+
+ expect(element).toHaveFocus();
+ expectElementWithinScrollport({
+ element,
+ scrollContainer: findScrollContainer(element),
+ });
+ },
+ { timeout: INTERACTION_TIMEOUT },
+ );
diff --git a/packages/twenty-front-component-renderer/src/__stories__/shared/test-utils/readScrollportRectangle.ts b/packages/twenty-front-component-renderer/src/__stories__/shared/test-utils/readScrollportRectangle.ts
new file mode 100644
index 00000000000..63d9b415ff9
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/shared/test-utils/readScrollportRectangle.ts
@@ -0,0 +1,12 @@
+export const readScrollportRectangle = (scrollContainer: Element) => {
+ const borderBoxRectangle = scrollContainer.getBoundingClientRect();
+ const top = borderBoxRectangle.top + scrollContainer.clientTop;
+ const left = borderBoxRectangle.left + scrollContainer.clientLeft;
+
+ return {
+ top,
+ right: left + scrollContainer.clientWidth,
+ bottom: top + scrollContainer.clientHeight,
+ left,
+ };
+};
diff --git a/packages/twenty-front-component-renderer/src/__stories__/showcase/scroll-commands.front-component.tsx b/packages/twenty-front-component-renderer/src/__stories__/showcase/scroll-commands.front-component.tsx
new file mode 100644
index 00000000000..4130ea06e59
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/showcase/scroll-commands.front-component.tsx
@@ -0,0 +1,330 @@
+import { type CSSProperties, type RefObject, useRef, useState } from 'react';
+import { createPortal } from 'react-dom';
+import { defineFrontComponent } from 'twenty-sdk/define';
+import { isDefined } from 'twenty-shared/utils';
+
+import { createNumberedLabels } from '@/__stories__/twenty-ui-gallery/utils/createNumberedLabels';
+
+const ROW_STYLE: CSSProperties = { blockSize: 24, lineHeight: '24px' };
+
+const CHIP_STYLE: CSSProperties = {
+ display: 'inline-block',
+ inlineSize: 60,
+ marginInlineEnd: 8,
+};
+
+const SCROLLER_STYLE: CSSProperties = {
+ blockSize: 80,
+ inlineSize: 200,
+ overflowY: 'auto',
+};
+
+const CHIP_LABELS = createNumberedLabels({ prefix: 'Chip', count: 20 });
+
+const ScrollRows = ({ prefix, count }: { prefix: string; count: number }) => (
+ <>
+ {createNumberedLabels({ prefix, count }).map((label) => (
+ <div key={label} style={ROW_STYLE}>
+ {label}
+ </div>
+ ))}
+ </>
+);
+
+const findChildByText = ({
+ container,
+ text,
+}: {
+ container: HTMLElement | null;
+ text: string;
+}): Element | undefined =>
+ Array.from(container?.children ?? []).find(
+ (child) => child.textContent === text,
+ );
+
+const writeScrollOffsetAndRecordReads = ({
+ element,
+ property,
+ offset,
+ setReads,
+}: {
+ element: HTMLElement | null;
+ property: 'scrollTop' | 'scrollLeft';
+ offset: number;
+ setReads: (reads: string) => void;
+}) => {
+ if (!isDefined(element)) {
+ return;
+ }
+
+ element[property] = offset;
+ const synchronousRead = element[property];
+
+ requestAnimationFrame(() =>
+ setReads(`sync:${synchronousRead};next:${element[property]}`),
+ );
+};
+
+const ScrollCommandsComponent = () => {
+ const innerScrollerRef = useRef<HTMLDivElement>(null);
+ const rightToLeftChipsRef = useRef<HTMLDivElement>(null);
+ const logRef = useRef<HTMLDivElement>(null);
+ const echoTargetRef = useRef<HTMLDivElement>(null);
+ const portalScrollerRef = useRef<HTMLDivElement>(null);
+ const detachableContainerRef = useRef<HTMLDivElement>(null);
+ const detachableScrollerRef = useRef<HTMLDivElement>(null);
+ const [logReads, setLogReads] = useState('none');
+ const [chipReads, setChipReads] = useState('none');
+ const [portalRead, setPortalRead] = useState('none');
+ const [echoRead, setEchoRead] = useState('none');
+ const [pageScrollStatus, setPageScrollStatus] = useState('none');
+ const [keyboardScrollKeys, setKeyboardScrollKeys] = useState(0);
+
+ const revealButtons: {
+ label: string;
+ containerRef: RefObject<HTMLDivElement | null>;
+ text: string;
+ options: ScrollIntoViewOptions;
+ }[] = [
+ {
+ label: 'Reveal row 25',
+ containerRef: innerScrollerRef,
+ text: 'Row 25',
+ options: { block: 'nearest' },
+ },
+ {
+ label: 'Center row 25',
+ containerRef: innerScrollerRef,
+ text: 'Row 25',
+ options: { block: 'center' },
+ },
+ {
+ label: 'Reveal chip 18',
+ containerRef: rightToLeftChipsRef,
+ text: 'Chip 18',
+ options: { block: 'nearest', inline: 'nearest' },
+ },
+ {
+ label: 'Start chip 18',
+ containerRef: rightToLeftChipsRef,
+ text: 'Chip 18',
+ options: { block: 'nearest', inline: 'start' },
+ },
+ ];
+
+ const tryPageScroll = () => {
+ try {
+ document.documentElement.scrollTop = 500;
+ document.body.scrollTop = 500;
+ window.scrollTo(0, 500);
+ window.scroll(0, 500);
+ window.scrollBy(0, 10);
+ setPageScrollStatus('ok');
+ } catch {
+ setPageScrollStatus('failed');
+ }
+ };
+
+ return (
+ <div
+ data-testid="front-component-mounted"
+ style={{ display: 'grid', gap: 8 }}
+ >
+ <div style={{ display: 'flex', flexWrap: 'wrap', gap: 4 }}>
+ {revealButtons.map(({ label, containerRef, text, options }) => (
+ <button
+ key={label}
+ type="button"
+ onClick={() =>
+ findChildByText({
+ container: containerRef.current,
+ text,
+ })?.scrollIntoView(options)
+ }
+ >
+ {label}
+ </button>
+ ))}
+ <button
+ type="button"
+ onClick={() =>
+ writeScrollOffsetAndRecordReads({
+ element: logRef.current,
+ property: 'scrollTop',
+ offset: 120,
+ setReads: setLogReads,
+ })
+ }
+ >
+ Write log 120
+ </button>
+ <button
+ type="button"
+ onClick={() =>
+ writeScrollOffsetAndRecordReads({
+ element: rightToLeftChipsRef.current,
+ property: 'scrollLeft',
+ offset: -120,
+ setReads: setChipReads,
+ })
+ }
+ >
+ Write chips -120
+ </button>
+ <button
+ type="button"
+ onClick={() => setEchoRead(String(echoTargetRef.current?.scrollTop))}
+ >
+ Read echo position
+ </button>
+ <button
+ type="button"
+ onClick={() => {
+ const echoTarget = echoTargetRef.current;
+
+ if (isDefined(echoTarget)) {
+ echoTarget.scrollTop = echoTarget.scrollTop;
+ }
+ }}
+ >
+ Echo position
+ </button>
+ <button
+ type="button"
+ onClick={() => {
+ const detachableScroller = detachableScrollerRef.current;
+
+ if (!isDefined(detachableScroller)) {
+ return;
+ }
+
+ detachableScroller.scrollTop = 120;
+ detachableScroller.remove();
+ }}
+ >
+ Write and detach
+ </button>
+ <button
+ type="button"
+ onClick={() => {
+ const detachableScroller = detachableScrollerRef.current;
+
+ if (!isDefined(detachableScroller)) {
+ return;
+ }
+
+ detachableContainerRef.current?.append(detachableScroller);
+ }}
+ >
+ Reattach
+ </button>
+ <button
+ type="button"
+ onClick={() =>
+ setPortalRead(String(portalScrollerRef.current?.scrollTop))
+ }
+ >
+ Read portal scroll
+ </button>
+ <button type="button" onClick={tryPageScroll}>
+ Try page scroll
+ </button>
+ </div>
+ <div role="status" aria-label="Log reads">
+ {logReads}
+ </div>
+ <div role="status" aria-label="Chip reads">
+ {chipReads}
+ </div>
+ <div role="status" aria-label="Portal read">
+ {portalRead}
+ </div>
+ <div role="status" aria-label="Echo read">
+ {echoRead}
+ </div>
+ <div role="status" aria-label="Page scroll">
+ {pageScrollStatus}
+ </div>
+ <div role="status" aria-label="Keyboard scroll keys">
+ {keyboardScrollKeys}
+ </div>
+ <div
+ role="region"
+ aria-label="Outer scroller"
+ style={{ ...SCROLLER_STYLE, blockSize: 120 }}
+ >
+ <div style={{ blockSize: 200 }} />
+ <div
+ ref={innerScrollerRef}
+ role="region"
+ aria-label="Inner scroller"
+ style={{ blockSize: 100, overflowY: 'auto' }}
+ >
+ <ScrollRows prefix="Row" count={30} />
+ </div>
+ </div>
+ <div
+ ref={rightToLeftChipsRef}
+ dir="rtl"
+ role="region"
+ aria-label="RTL chips"
+ style={{ inlineSize: 200, overflowX: 'auto', whiteSpace: 'nowrap' }}
+ >
+ {CHIP_LABELS.map((label) => (
+ <span key={label} style={CHIP_STYLE}>
+ {label}
+ </span>
+ ))}
+ </div>
+ <div ref={logRef} role="region" aria-label="Log" style={SCROLLER_STYLE}>
+ <ScrollRows prefix="Log line" count={20} />
+ </div>
+ <div
+ ref={echoTargetRef}
+ role="region"
+ aria-label="Echo target"
+ style={SCROLLER_STYLE}
+ >
+ <ScrollRows prefix="Echo line" count={20} />
+ </div>
+ <div
+ role="region"
+ aria-label="Keyboard scroller"
+ tabIndex={0}
+ style={SCROLLER_STYLE}
+ onKeyDown={() => setKeyboardScrollKeys((count) => count + 1)}
+ >
+ <ScrollRows prefix="Keyboard line" count={20} />
+ </div>
+ <div ref={detachableContainerRef}>
+ <div
+ ref={detachableScrollerRef}
+ role="region"
+ aria-label="Detachable scroller"
+ style={SCROLLER_STYLE}
+ >
+ <ScrollRows prefix="Detachable row" count={20} />
+ </div>
+ </div>
+ {createPortal(
+ <div
+ ref={portalScrollerRef}
+ role="region"
+ aria-label="Portal scroller"
+ style={SCROLLER_STYLE}
+ >
+ <ScrollRows prefix="Portal line" count={20} />
+ </div>,
+ document.body,
+ )}
+ </div>
+ );
+};
+
+export default defineFrontComponent({
+ universalIdentifier: 'f390c7e8-d8ae-4c7d-9b7e-35d9aaabca45',
+ name: 'scroll-commands',
+ description:
+ 'Scroll writes, scrollTo and scrollIntoView on owned scrollers in the sandbox',
+ component: ScrollCommandsComponent,
+});
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 78f0f250137..45bb23b83ac 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
@@ -221,6 +221,41 @@ does not prove native chooser activation.
Direct app-owned `Dialog`/`AlertDialog` modality and native browser dialog/popover activation are prohibited in front components. Their standalone Twenty UI APIs have dedicated unit and browser stories. Front components use SDK `openCommandConfirmationModal`, whose structured title, subtitle and confirm-button options are rendered by the host. The Dialog fixture checks the confirmation request. Result handling and actual host modal focus, restoration, dismissal and teardown acceptance remain part of the renderer integration work. No direct Dialog or AlertDialog gallery fixture is retained as a compatibility target.
+## Scrolling inside controls
+
+Worker `scrollTop`/`scrollLeft` writes, `scrollTo()`/`scroll()` and
+`scrollIntoView()` travel to the host as ordered commands on the owning element.
+The host applies them after the commit that carries them, so input selection
+changes from the same render land first, and acknowledges the resulting
+positions. Reads return the requested value until that acknowledgement or a
+newer geometry snapshot arrives. `scrollIntoView()` is reimplemented on the
+host: it only moves scroll containers rendered by the same renderer and stops at
+the renderer root or its portal layer, so widget frames, the page and other
+renderers never move. `html`, `body` and `window` scrolling stays in the worker.
+
+`TwentyUiScrolling.stories.tsx` checks, in React and Preact, Autocomplete
+keyboard highlight reveal in a portaled popup and in an inline list nested in an
+owned scroller, the filtered-list scroll reset, long LTR and RTL input Home/End
+with synthetic and trusted keys, Select selected-option reveal and keyboard
+navigation, Select trigger alignment stability, and overflowing Tabs in both
+directions. `ScrollCommands.stories.tsx` drives the raw commands: nested and
+RTL reveal, read-after-write, echo elision, keyboard scroll without event echo,
+no replay after detaching and reattaching a node, portal scroll refresh after
+the geometry tracker idles, page scrolling staying local, and two independent
+renderers.
+
+Dropdown and the pickers built on it reveal their items through native host
+`focus()`, unchanged by these commands. The Autocomplete filter reset needs the
+list to have been measured once; it is enrolled when a keyboard reveal scrolls
+it, so a query typed within the same frame as that reveal can miss the reset.
+Base UI list items re-run navigation from forwarded focus events, so several
+arrow keys pressed before the host focus round trip completes can make focus
+cycle between options; the Select stories press one key at a time. Select's
+initial focus differs between runtimes, so its keyboard steps start from `End`.
+Elements created with `document.createElement` for a standard tag name do not
+forward property updates made after insertion, so scroll commands on them never
+reach the host; elements rendered through JSX do.
+
## Known sandbox limitations
An invisible popup is not a compatibility pass.
@@ -355,7 +390,7 @@ npx playwright test --config playwright.layout.config.ts
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
+The AvatarGroup, Autocomplete, CountrySelect, reading-directions and scrolling fixtures
live in their own story files, so run them separately:
```sh
@@ -363,6 +398,8 @@ npx vitest run --config vitest.storybook.config.ts TwentyUiAutocomplete.stories.
npx vitest run --config vitest.storybook.config.ts TwentyUiCountrySelect.stories.tsx
npx vitest run --config vitest.storybook.config.ts TwentyUiReadingDirections.stories.tsx
npx vitest run --config vitest.storybook.config.ts TwentyUiAvatarGroup.stories.tsx
+npx vitest run --config vitest.storybook.config.ts TwentyUiScrolling.stories.tsx
+npx vitest run --config vitest.storybook.config.ts ScrollCommands.stories.tsx
```
Section and CommandBlock composition is checked in the Typography and DataDisplay
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/components/PortalBoundsDecorator.tsx b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/components/PortalBoundsDecorator.tsx
index d0401c59278..c575060b722 100644
--- a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/components/PortalBoundsDecorator.tsx
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/components/PortalBoundsDecorator.tsx
@@ -3,6 +3,8 @@ import { useState } from 'react';
import { Button } from 'twenty-ui/primitives/input';
import { Text } from 'twenty-ui/primitives/typography';
+import { WIDGET_SCROLL_FRAME_LABEL } from '@/__stories__/twenty-ui-gallery/constants/WidgetScrollFrameLabel';
+
export const PortalBoundsDecorator: Decorator = (Story) => {
const [hostActionCount, setHostActionCount] = useState(0);
@@ -29,7 +31,7 @@ export const PortalBoundsDecorator: Decorator = (Story) => {
>
<div
role="region"
- aria-label="Widget scroll frame"
+ aria-label={WIDGET_SCROLL_FRAME_LABEL}
style={{ width: '100%', height: '100%', overflow: 'auto' }}
>
<div role="group" aria-label="Widget" style={{ height: 260 }}>
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/components/ScrollBoundaryDecorator.tsx b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/components/ScrollBoundaryDecorator.tsx
new file mode 100644
index 00000000000..e20f773aa0d
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/components/ScrollBoundaryDecorator.tsx
@@ -0,0 +1,13 @@
+import { type Decorator } from '@storybook/react-vite';
+
+import { WIDGET_SCROLL_FRAME_LABEL } from '@/__stories__/twenty-ui-gallery/constants/WidgetScrollFrameLabel';
+
+export const ScrollBoundaryDecorator: Decorator = (Story) => (
+ <div
+ role="region"
+ aria-label={WIDGET_SCROLL_FRAME_LABEL}
+ style={{ width: 360, height: 150, overflow: 'auto' }}
+ >
+ <Story />
+ </div>
+);
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/constants/LongInputValues.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/constants/LongInputValues.ts
new file mode 100644
index 00000000000..3bd49b75a70
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/constants/LongInputValues.ts
@@ -0,0 +1,6 @@
+export const LONG_INPUT_VALUES = {
+ leftToRight:
+ 'Quarterly pipeline review for the enterprise accounts of the northern region, including renewal risks and expansion plans',
+ rightToLeft:
+ 'مراجعة خط المبيعات الفصلية لحسابات المؤسسات في المنطقة الشمالية مع مخاطر التجديد وخطط التوسع',
+} as const;
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/constants/ScrollingOptionLabels.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/constants/ScrollingOptionLabels.ts
new file mode 100644
index 00000000000..3820b74b7bf
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/constants/ScrollingOptionLabels.ts
@@ -0,0 +1,6 @@
+import { createNumberedLabels } from '@/__stories__/twenty-ui-gallery/utils/createNumberedLabels';
+
+export const SCROLLING_OPTION_LABELS = createNumberedLabels({
+ prefix: 'Option',
+ count: 40,
+});
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/constants/WidgetScrollFrameLabel.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/constants/WidgetScrollFrameLabel.ts
new file mode 100644
index 00000000000..45452578ae3
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/constants/WidgetScrollFrameLabel.ts
@@ -0,0 +1 @@
+export const WIDGET_SCROLL_FRAME_LABEL = 'Widget scroll frame';
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/twenty-ui-autocomplete-scrolling.front-component.tsx b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/twenty-ui-autocomplete-scrolling.front-component.tsx
new file mode 100644
index 00000000000..9ba7ac1909b
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/twenty-ui-autocomplete-scrolling.front-component.tsx
@@ -0,0 +1,88 @@
+import { useState } from 'react';
+import { defineFrontComponent } from 'twenty-sdk/define';
+import { Autocomplete } from 'twenty-ui/primitives/input';
+import { DirectionProvider } from 'twenty-ui/primitives/layout';
+import { Text } from 'twenty-ui/primitives/typography';
+
+import { TwentyUiGalleryCard } from '@/__stories__/shared/front-components/twenty-ui-gallery-card';
+import { LONG_INPUT_VALUES } from '@/__stories__/twenty-ui-gallery/constants/LongInputValues';
+import { SCROLLING_OPTION_LABELS } from '@/__stories__/twenty-ui-gallery/constants/ScrollingOptionLabels';
+
+const LONG_INPUT_STYLE = { inlineSize: 160 };
+
+const renderOption = (option: string) => (
+ <Autocomplete.Item key={option} value={option}>
+ {option}
+ </Autocomplete.Item>
+);
+
+const AutocompleteScrollingExample = () => {
+ const [inlineQuery, setInlineQuery] = useState('');
+
+ return (
+ <TwentyUiGalleryCard title="Autocomplete scrolling">
+ <Autocomplete.Root items={SCROLLING_OPTION_LABELS} autoHighlight={false}>
+ <Autocomplete.Input aria-label="Portal option search" />
+ <Autocomplete.Portal>
+ <Autocomplete.Positioner>
+ <Autocomplete.Popup>
+ <Autocomplete.List aria-label="Portal options">
+ {renderOption}
+ </Autocomplete.List>
+ </Autocomplete.Popup>
+ </Autocomplete.Positioner>
+ </Autocomplete.Portal>
+ </Autocomplete.Root>
+ <div
+ role="region"
+ aria-label="Owned outer scroller"
+ style={{ blockSize: 120, overflowY: 'auto' }}
+ >
+ <div style={{ blockSize: 80 }} />
+ <Autocomplete.Root
+ inline
+ open
+ items={SCROLLING_OPTION_LABELS}
+ autoHighlight={false}
+ value={inlineQuery}
+ onValueChange={setInlineQuery}
+ >
+ <Autocomplete.Input aria-label="Inline option search" />
+ <Autocomplete.List aria-label="Inline options">
+ {renderOption}
+ </Autocomplete.List>
+ </Autocomplete.Root>
+ </div>
+ <Text role="status" aria-label="Inline query">
+ {inlineQuery || 'empty'}
+ </Text>
+ <Autocomplete.Root
+ items={[]}
+ defaultValue={LONG_INPUT_VALUES.leftToRight}
+ >
+ <Autocomplete.Input aria-label="Long value" style={LONG_INPUT_STYLE} />
+ </Autocomplete.Root>
+ <DirectionProvider direction="rtl">
+ <div dir="rtl">
+ <Autocomplete.Root
+ items={[]}
+ defaultValue={LONG_INPUT_VALUES.rightToLeft}
+ >
+ <Autocomplete.Input
+ aria-label="Long value RTL"
+ style={LONG_INPUT_STYLE}
+ />
+ </Autocomplete.Root>
+ </div>
+ </DirectionProvider>
+ </TwentyUiGalleryCard>
+ );
+};
+
+export default defineFrontComponent({
+ universalIdentifier: '8c636214-6059-4776-acba-df2488f5b2f0',
+ name: 'twenty-ui-autocomplete-scrolling',
+ description:
+ 'Autocomplete option reveal, filtered list reset and long input caret scrolling',
+ component: AutocompleteScrollingExample,
+});
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/twenty-ui-select-scrolling.front-component.tsx b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/twenty-ui-select-scrolling.front-component.tsx
new file mode 100644
index 00000000000..9e93a7b1d98
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/twenty-ui-select-scrolling.front-component.tsx
@@ -0,0 +1,59 @@
+import { useState } from 'react';
+import { defineFrontComponent } from 'twenty-sdk/define';
+import { Select } from 'twenty-ui/primitives/input';
+
+import { TwentyUiGalleryCard } from '@/__stories__/shared/front-components/twenty-ui-gallery-card';
+import { SCROLLING_OPTION_LABELS } from '@/__stories__/twenty-ui-gallery/constants/ScrollingOptionLabels';
+
+const SELECTED_OPTION_LABEL = 'Option 30';
+
+const ScrollingSelect = ({
+ label,
+ alignItemWithTrigger,
+}: {
+ label: string;
+ alignItemWithTrigger?: boolean;
+}) => {
+ const [value, setValue] = useState<string | null>(SELECTED_OPTION_LABEL);
+
+ return (
+ <Select.Root value={value} onValueChange={setValue}>
+ <Select.Trigger aria-label={label}>
+ <Select.Value />
+ <Select.Icon />
+ </Select.Trigger>
+ <Select.Portal>
+ <Select.Positioner
+ sideOffset={8}
+ alignItemWithTrigger={alignItemWithTrigger}
+ >
+ <Select.Popup style={{ maxBlockSize: 160 }}>
+ <Select.List aria-label={`${label} options`}>
+ {SCROLLING_OPTION_LABELS.map((optionLabel) => (
+ <Select.Item key={optionLabel} value={optionLabel}>
+ <Select.ItemText>{optionLabel}</Select.ItemText>
+ <Select.ItemIndicator />
+ </Select.Item>
+ ))}
+ </Select.List>
+ </Select.Popup>
+ </Select.Positioner>
+ </Select.Portal>
+ </Select.Root>
+ );
+};
+
+const SelectScrollingExample = () => (
+ <TwentyUiGalleryCard title="Select scrolling">
+ <ScrollingSelect label="Unaligned option" alignItemWithTrigger={false} />
+ <ScrollingSelect label="Aligned option" />
+ </TwentyUiGalleryCard>
+);
+
+export default defineFrontComponent({
+ universalIdentifier: 'a9f0cbce-f475-42b3-acf2-7b7aa7dd7a9a',
+ name: 'twenty-ui-select-scrolling',
+ description:
+ 'Select selected option reveal, keyboard navigation and trigger alignment scrolling',
+ component: SelectScrollingExample,
+});
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/twenty-ui-tabs-scrolling.front-component.tsx b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/twenty-ui-tabs-scrolling.front-component.tsx
new file mode 100644
index 00000000000..8fa0a66f745
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/twenty-ui-tabs-scrolling.front-component.tsx
@@ -0,0 +1,45 @@
+import { defineFrontComponent } from 'twenty-sdk/define';
+import { DirectionProvider } from 'twenty-ui/primitives/layout';
+import { Tabs } from 'twenty-ui/primitives/navigation';
+
+import { TwentyUiGalleryCard } from '@/__stories__/shared/front-components/twenty-ui-gallery-card';
+import { createNumberedLabels } from '@/__stories__/twenty-ui-gallery/utils/createNumberedLabels';
+
+const SECTION_LABELS = createNumberedLabels({ prefix: 'Section', count: 12 });
+
+const OverflowingTabs = ({ label }: { label: string }) => (
+ <Tabs.Root defaultValue={SECTION_LABELS[0]}>
+ <Tabs.List
+ aria-label={label}
+ style={{ maxInlineSize: 240, overflowX: 'auto' }}
+ >
+ {SECTION_LABELS.map((sectionLabel) => (
+ <Tabs.Tab
+ key={sectionLabel}
+ value={sectionLabel}
+ style={{ flexShrink: 0 }}
+ >
+ {sectionLabel}
+ </Tabs.Tab>
+ ))}
+ </Tabs.List>
+ </Tabs.Root>
+);
+
+const TabsScrollingExample = () => (
+ <TwentyUiGalleryCard title="Tabs scrolling">
+ <OverflowingTabs label="Sections" />
+ <DirectionProvider direction="rtl">
+ <div dir="rtl">
+ <OverflowingTabs label="Sections RTL" />
+ </div>
+ </DirectionProvider>
+ </TwentyUiGalleryCard>
+);
+
+export default defineFrontComponent({
+ universalIdentifier: 'e4959d7b-c680-4211-bd2d-6237d6f2b347',
+ name: 'twenty-ui-tabs-scrolling',
+ description: 'Overflowing tab list keyboard navigation in both directions',
+ component: TabsScrollingExample,
+});
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/autocompleteFilterResetTest.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/autocompleteFilterResetTest.ts
new file mode 100644
index 00000000000..c7a2cb6f68b
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/autocompleteFilterResetTest.ts
@@ -0,0 +1,56 @@
+import { expect, userEvent, waitFor, within } from 'storybook/test';
+
+import { errorHandler } from '@/__stories__/shared/test-utils/createFrontComponentStoryMeta';
+import { expectFrontComponentMounted } from '@/__stories__/shared/test-utils/matchers/expectFrontComponentMounted';
+import { INTERACTION_TIMEOUT } from '@/__stories__/shared/test-utils/timeouts';
+import { type TwentyUiGalleryPlayFunction } from '@/__stories__/twenty-ui-gallery/types/TwentyUiGalleryPlayFunction';
+import { focusWithoutScrolling } from '@/__stories__/twenty-ui-gallery/utils/focusWithoutScrolling';
+import { pressKeyUntilOptionHighlightedOrThrow } from '@/__stories__/twenty-ui-gallery/utils/pressKeyUntilOptionHighlightedOrThrow';
+import { waitForGeometryTrackerToIdle } from '@/__stories__/twenty-ui-gallery/utils/waitForGeometryTrackerToIdle';
+import { SCROLLING_OPTION_LABELS } from '@/__stories__/twenty-ui-gallery/constants/ScrollingOptionLabels';
+
+export const autocompleteFilterResetTest: TwentyUiGalleryPlayFunction = async ({
+ canvasElement,
+}) => {
+ const canvas = within(canvasElement);
+ await expectFrontComponentMounted(canvas);
+
+ const input = canvas.getByLabelText('Inline option search');
+ const list = canvas.getByRole('listbox', { name: 'Inline options' });
+ const outerScroller = canvas.getByRole('region', {
+ name: 'Owned outer scroller',
+ });
+
+ await focusWithoutScrolling(input);
+ await pressKeyUntilOptionHighlightedOrThrow({
+ key: '{ArrowUp}',
+ findOption: () => canvas.queryByRole('option', { name: 'Option 40' }),
+ });
+
+ list.scrollTop = list.scrollHeight;
+ await waitFor(() => expect(list.scrollTop).toBeGreaterThan(0), {
+ timeout: INTERACTION_TIMEOUT,
+ });
+
+ await waitForGeometryTrackerToIdle();
+
+ const outerScrollTopBeforeFiltering = outerScroller.scrollTop;
+
+ await userEvent.keyboard('o');
+
+ await waitFor(
+ () =>
+ expect(
+ canvas.getByRole('status', { name: 'Inline query' }),
+ ).toHaveTextContent('o'),
+ { timeout: INTERACTION_TIMEOUT },
+ );
+ await expect(within(list).getAllByRole('option')).toHaveLength(
+ SCROLLING_OPTION_LABELS.length,
+ );
+ await waitFor(() => expect(list.scrollTop).toBe(0), {
+ timeout: INTERACTION_TIMEOUT,
+ });
+ await expect(outerScroller.scrollTop).toBe(outerScrollTopBeforeFiltering);
+ await expect(errorHandler).not.toHaveBeenCalled();
+};
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/autocompleteNestedRevealTest.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/autocompleteNestedRevealTest.ts
new file mode 100644
index 00000000000..3281711fb15
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/autocompleteNestedRevealTest.ts
@@ -0,0 +1,54 @@
+import { expect, waitFor, within } from 'storybook/test';
+
+import { errorHandler } from '@/__stories__/shared/test-utils/createFrontComponentStoryMeta';
+import { expectElementWithinScrollport } from '@/__stories__/shared/test-utils/matchers/expectElementWithinScrollport';
+import { expectFrontComponentMounted } from '@/__stories__/shared/test-utils/matchers/expectFrontComponentMounted';
+import { INTERACTION_TIMEOUT } from '@/__stories__/shared/test-utils/timeouts';
+import { type TwentyUiGalleryPlayFunction } from '@/__stories__/twenty-ui-gallery/types/TwentyUiGalleryPlayFunction';
+import { focusWithoutScrolling } from '@/__stories__/twenty-ui-gallery/utils/focusWithoutScrolling';
+import { pressKeyUntilOptionHighlightedOrThrow } from '@/__stories__/twenty-ui-gallery/utils/pressKeyUntilOptionHighlightedOrThrow';
+import { readHostScrollBoundary } from '@/__stories__/twenty-ui-gallery/utils/readHostScrollBoundary';
+
+export const autocompleteNestedRevealTest: TwentyUiGalleryPlayFunction =
+ async ({ canvasElement }) => {
+ const canvas = within(canvasElement);
+ await expectFrontComponentMounted(canvas);
+
+ const input = canvas.getByLabelText('Inline option search');
+ const list = canvas.getByRole('listbox', { name: 'Inline options' });
+ const outerScroller = canvas.getByRole('region', {
+ name: 'Owned outer scroller',
+ });
+
+ await focusWithoutScrolling(input);
+
+ const hostScrollBoundaryBeforeReveal =
+ readHostScrollBoundary(canvasElement);
+
+ await pressKeyUntilOptionHighlightedOrThrow({
+ key: '{ArrowUp}',
+ findOption: () => canvas.queryByRole('option', { name: 'Option 40' }),
+ });
+
+ const lastOption = canvas.getByRole('option', { name: 'Option 40' });
+
+ await waitFor(
+ () => {
+ expect(list.scrollTop).toBeGreaterThan(0);
+ expect(outerScroller.scrollTop).toBeGreaterThan(0);
+ expectElementWithinScrollport({
+ element: lastOption,
+ scrollContainer: list,
+ });
+ expectElementWithinScrollport({
+ element: lastOption,
+ scrollContainer: outerScroller,
+ });
+ },
+ { timeout: INTERACTION_TIMEOUT },
+ );
+ await expect(readHostScrollBoundary(canvasElement)).toEqual(
+ hostScrollBoundaryBeforeReveal,
+ );
+ await expect(errorHandler).not.toHaveBeenCalled();
+ };
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/autocompleteRevealTest.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/autocompleteRevealTest.ts
new file mode 100644
index 00000000000..a1e989dd5b3
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/autocompleteRevealTest.ts
@@ -0,0 +1,49 @@
+import { expect, userEvent, waitFor, within } from 'storybook/test';
+
+import { errorHandler } from '@/__stories__/shared/test-utils/createFrontComponentStoryMeta';
+import { expectElementWithinScrollport } from '@/__stories__/shared/test-utils/matchers/expectElementWithinScrollport';
+import { expectFrontComponentMounted } from '@/__stories__/shared/test-utils/matchers/expectFrontComponentMounted';
+import { INTERACTION_TIMEOUT } from '@/__stories__/shared/test-utils/timeouts';
+import { type TwentyUiGalleryPlayFunction } from '@/__stories__/twenty-ui-gallery/types/TwentyUiGalleryPlayFunction';
+import { pressKeyUntilOptionHighlightedOrThrow } from '@/__stories__/twenty-ui-gallery/utils/pressKeyUntilOptionHighlightedOrThrow';
+
+export const autocompleteRevealTest: TwentyUiGalleryPlayFunction = async ({
+ canvasElement,
+}) => {
+ const canvas = within(canvasElement);
+ const body = within(canvasElement.ownerDocument.body);
+ await expectFrontComponentMounted(canvas);
+
+ const input = canvas.getByLabelText('Portal option search');
+
+ await userEvent.click(input);
+ await pressKeyUntilOptionHighlightedOrThrow({
+ key: '{ArrowUp}',
+ findOption: () => body.queryByRole('option', { name: 'Option 40' }),
+ });
+
+ const list = body.getByRole('listbox', { name: 'Portal options' });
+ const lastOption = body.getByRole('option', { name: 'Option 40' });
+
+ await expect(input).toHaveAttribute('aria-activedescendant', lastOption.id);
+ await waitFor(
+ () => {
+ expect(list.scrollTop).toBeGreaterThan(0);
+ expectElementWithinScrollport({
+ element: lastOption,
+ scrollContainer: list,
+ });
+ },
+ { timeout: INTERACTION_TIMEOUT },
+ );
+
+ await pressKeyUntilOptionHighlightedOrThrow({
+ key: '{ArrowDown}',
+ findOption: () => body.queryByRole('option', { name: 'Option 01' }),
+ });
+
+ await waitFor(() => expect(list.scrollTop).toBe(0), {
+ timeout: INTERACTION_TIMEOUT,
+ });
+ await expect(errorHandler).not.toHaveBeenCalled();
+};
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/createAutocompleteLongInputTest.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/createAutocompleteLongInputTest.ts
new file mode 100644
index 00000000000..891866ab31c
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/createAutocompleteLongInputTest.ts
@@ -0,0 +1,49 @@
+import { expect, within } from 'storybook/test';
+
+import { errorHandler } from '@/__stories__/shared/test-utils/createFrontComponentStoryMeta';
+import { expectFrontComponentMounted } from '@/__stories__/shared/test-utils/matchers/expectFrontComponentMounted';
+import { LONG_INPUT_VALUES } from '@/__stories__/twenty-ui-gallery/constants/LongInputValues';
+import { type TwentyUiGalleryPlayFunction } from '@/__stories__/twenty-ui-gallery/types/TwentyUiGalleryPlayFunction';
+import { expectCaretAt } from '@/__stories__/twenty-ui-gallery/utils/expectCaretAt';
+import { expectInputScrolledToEdge } from '@/__stories__/twenty-ui-gallery/utils/expectInputScrolledToEdge';
+import { focusWithoutScrolling } from '@/__stories__/twenty-ui-gallery/utils/focusWithoutScrolling';
+import { pressKeyboardKeys } from '@/__stories__/twenty-ui-gallery/utils/pressKeyboardKeys';
+
+const LONG_INPUTS = [
+ {
+ label: 'Long value',
+ value: LONG_INPUT_VALUES.leftToRight,
+ isRightToLeft: false,
+ },
+ {
+ label: 'Long value RTL',
+ value: LONG_INPUT_VALUES.rightToLeft,
+ isRightToLeft: true,
+ },
+];
+
+export const createAutocompleteLongInputTest =
+ ({ isTrusted }: { isTrusted: boolean }): TwentyUiGalleryPlayFunction =>
+ async ({ canvasElement }) => {
+ const canvas = within(canvasElement);
+ await expectFrontComponentMounted(canvas);
+
+ for (const { label, value, isRightToLeft } of LONG_INPUTS) {
+ const input = canvas.getByLabelText<HTMLInputElement>(label);
+
+ await focusWithoutScrolling(input);
+ await pressKeyboardKeys({ keys: '{End}', isTrusted });
+ await expectCaretAt({ input, offset: value.length });
+ await expectInputScrolledToEdge({ input, edge: 'end', isRightToLeft });
+
+ await pressKeyboardKeys({ keys: '{Home}', isTrusted });
+ await expectCaretAt({ input, offset: 0 });
+ await expectInputScrolledToEdge({
+ input,
+ edge: 'start',
+ isRightToLeft,
+ });
+ }
+
+ await expect(errorHandler).not.toHaveBeenCalled();
+ };
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/createNumberedLabels.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/createNumberedLabels.ts
new file mode 100644
index 00000000000..ff13963e165
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/createNumberedLabels.ts
@@ -0,0 +1,11 @@
+export const createNumberedLabels = ({
+ prefix,
+ count,
+}: {
+ prefix: string;
+ count: number;
+}): string[] =>
+ Array.from(
+ { length: count },
+ (_, index) => `${prefix} ${String(index + 1).padStart(2, '0')}`,
+ );
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/expectInputScrolledToEdge.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/expectInputScrolledToEdge.ts
new file mode 100644
index 00000000000..d85923aeae4
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/expectInputScrolledToEdge.ts
@@ -0,0 +1,31 @@
+import { expect, waitFor } from 'storybook/test';
+
+import { INTERACTION_TIMEOUT } from '@/__stories__/shared/test-utils/timeouts';
+
+const SCROLL_EDGE_TOLERANCE = 1;
+
+export const expectInputScrolledToEdge = async ({
+ input,
+ edge,
+ isRightToLeft,
+}: {
+ input: HTMLInputElement;
+ edge: 'start' | 'end';
+ isRightToLeft: boolean;
+}): Promise<void> => {
+ await waitFor(
+ () => {
+ const maximumScrollOffset = input.scrollWidth - input.clientWidth;
+ const endScrollOffset = isRightToLeft
+ ? -maximumScrollOffset
+ : maximumScrollOffset;
+ const expectedScrollOffset = edge === 'start' ? 0 : endScrollOffset;
+
+ expect(maximumScrollOffset).toBeGreaterThan(0);
+ expect(
+ Math.abs(input.scrollLeft - expectedScrollOffset),
+ ).toBeLessThanOrEqual(SCROLL_EDGE_TOLERANCE);
+ },
+ { timeout: INTERACTION_TIMEOUT },
+ );
+};
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/expectScrollPositionStable.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/expectScrollPositionStable.ts
new file mode 100644
index 00000000000..9487dd283bd
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/expectScrollPositionStable.ts
@@ -0,0 +1,17 @@
+import { expect } from 'storybook/test';
+
+import { waitForGeometryTrackerToIdle } from '@/__stories__/twenty-ui-gallery/utils/waitForGeometryTrackerToIdle';
+
+export const expectScrollPositionStable = async (
+ scrollContainer: Element,
+): Promise<void> => {
+ await waitForGeometryTrackerToIdle();
+
+ const settledScrollTop = scrollContainer.scrollTop;
+ const settledScrollLeft = scrollContainer.scrollLeft;
+
+ await waitForGeometryTrackerToIdle();
+
+ expect(scrollContainer.scrollTop).toBe(settledScrollTop);
+ expect(scrollContainer.scrollLeft).toBe(settledScrollLeft);
+};
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/findScrollContainerOrThrow.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/findScrollContainerOrThrow.ts
new file mode 100644
index 00000000000..5de5af1abcc
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/findScrollContainerOrThrow.ts
@@ -0,0 +1,22 @@
+import { isDefined } from 'twenty-shared/utils';
+
+const SCROLLABLE_OVERFLOW_PATTERN = /auto|scroll/;
+
+export const findScrollContainerOrThrow = (element: Element): HTMLElement => {
+ for (
+ let ancestor = element.parentElement;
+ isDefined(ancestor);
+ ancestor = ancestor.parentElement
+ ) {
+ const { overflowY } = getComputedStyle(ancestor);
+
+ if (
+ SCROLLABLE_OVERFLOW_PATTERN.test(overflowY) &&
+ ancestor.scrollHeight > ancestor.clientHeight
+ ) {
+ return ancestor;
+ }
+ }
+
+ throw new Error('The element has no vertical scroll container');
+};
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/focusWithoutScrolling.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/focusWithoutScrolling.ts
new file mode 100644
index 00000000000..90edbeee3fd
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/focusWithoutScrolling.ts
@@ -0,0 +1,7 @@
+import { expect, waitFor } from 'storybook/test';
+
+export const focusWithoutScrolling = async (element: HTMLElement) => {
+ element.focus({ preventScroll: true });
+
+ await waitFor(() => expect(element).toHaveFocus());
+};
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/openSelectListbox.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/openSelectListbox.ts
new file mode 100644
index 00000000000..9508e423c85
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/openSelectListbox.ts
@@ -0,0 +1,27 @@
+import { expect, userEvent, waitFor, type within } from 'storybook/test';
+
+import { INTERACTION_TIMEOUT } from '@/__stories__/shared/test-utils/timeouts';
+
+type Canvas = ReturnType<typeof within>;
+
+export const openSelectListbox = async ({
+ canvas,
+ body,
+ selectName,
+}: {
+ canvas: Canvas;
+ body: Canvas;
+ selectName: string;
+}): Promise<void> => {
+ await userEvent.click(canvas.getByRole('combobox', { name: selectName }));
+
+ const listbox = await body.findByRole(
+ 'listbox',
+ { name: `${selectName} options` },
+ { timeout: INTERACTION_TIMEOUT },
+ );
+
+ await waitFor(() => expect(listbox).toBeVisible(), {
+ timeout: INTERACTION_TIMEOUT,
+ });
+};
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/overflowingListGeometryTest.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/overflowingListGeometryTest.ts
index bc2283812f9..39a8d5164e0 100644
--- a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/overflowingListGeometryTest.ts
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/overflowingListGeometryTest.ts
@@ -2,9 +2,8 @@ import { expect, userEvent, waitFor, within } from 'storybook/test';
import { errorHandler } from '@/__stories__/shared/test-utils/createFrontComponentStoryMeta';
import { expectFrontComponentMounted } from '@/__stories__/shared/test-utils/matchers/expectFrontComponentMounted';
-import { waitForAnimationFrames } from '@/__stories__/shared/test-utils/waitForAnimationFrames';
import { type TwentyUiGalleryPlayFunction } from '@/__stories__/twenty-ui-gallery/types/TwentyUiGalleryPlayFunction';
-import { GEOMETRY_IDLE_FRAME_THRESHOLD } from '@/host/geometry/constants/GeometryIdleFrameThreshold';
+import { waitForGeometryTrackerToIdle } from '@/__stories__/twenty-ui-gallery/utils/waitForGeometryTrackerToIdle';
export const overflowingListGeometryTest: TwentyUiGalleryPlayFunction = async ({
canvasElement,
@@ -36,7 +35,7 @@ export const overflowingListGeometryTest: TwentyUiGalleryPlayFunction = async ({
.getBoundingClientRect().width,
).toBe(208),
);
- await waitForAnimationFrames(GEOMETRY_IDLE_FRAME_THRESHOLD * 2);
+ await waitForGeometryTrackerToIdle();
await expect(
canvas.getByRole('button', { name: /Show all measured items$/ }),
).toHaveTextContent('+2');
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/portalBoundsTest.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/portalBoundsTest.ts
index d590b8aac05..308ec7a898b 100644
--- a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/portalBoundsTest.ts
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/portalBoundsTest.ts
@@ -3,18 +3,15 @@ import { expect, userEvent, waitFor, within } from 'storybook/test';
import { errorHandler } from '@/__stories__/shared/test-utils/createFrontComponentStoryMeta';
import { expectElementToReceivePointer } from '@/__stories__/shared/test-utils/matchers/expectElementToReceivePointer';
import { expectFrontComponentMounted } from '@/__stories__/shared/test-utils/matchers/expectFrontComponentMounted';
-import { waitForAnimationFrames } from '@/__stories__/shared/test-utils/waitForAnimationFrames';
import { MAXIMUM_DROPDOWN_TRIGGER_GAP } from '@/__stories__/twenty-ui-gallery/constants/MaximumDropdownTriggerGap';
+import { WIDGET_SCROLL_FRAME_LABEL } from '@/__stories__/twenty-ui-gallery/constants/WidgetScrollFrameLabel';
import { type TwentyUiGalleryPlayFunction } from '@/__stories__/twenty-ui-gallery/types/TwentyUiGalleryPlayFunction';
import { computePopupAnchorGapAndOverlap } from '@/__stories__/twenty-ui-gallery/utils/computePopupAnchorGapAndOverlap';
+import { waitForGeometryTrackerToIdle } from '@/__stories__/twenty-ui-gallery/utils/waitForGeometryTrackerToIdle';
import { FRONT_COMPONENT_PORTAL_MARGIN } from '@/constants/FrontComponentPortalMargin';
-import { GEOMETRY_IDLE_FRAME_THRESHOLD } from '@/host/geometry/constants/GeometryIdleFrameThreshold';
const WIDGET_SCROLL_OFFSET = 40;
-const waitForGeometryTrackerToIdle = () =>
- waitForAnimationFrames(GEOMETRY_IDLE_FRAME_THRESHOLD * 2);
-
const expectPortalActionAtOwnerBottom = ({
portalAction,
ownerRoot,
@@ -137,7 +134,7 @@ export const portalBoundsTest: TwentyUiGalleryPlayFunction = async ({
);
const scrollFrame = canvas.getByRole('region', {
- name: 'Widget scroll frame',
+ name: WIDGET_SCROLL_FRAME_LABEL,
});
await waitForGeometryTrackerToIdle();
scrollFrame.scrollTop = WIDGET_SCROLL_OFFSET;
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/pressKeyUntilOptionHighlightedOrThrow.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/pressKeyUntilOptionHighlightedOrThrow.ts
new file mode 100644
index 00000000000..4a38b9c6854
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/pressKeyUntilOptionHighlightedOrThrow.ts
@@ -0,0 +1,35 @@
+import { expect, userEvent, waitFor } from 'storybook/test';
+
+const HIGHLIGHT_SETTLE_TIMEOUT = 1500;
+
+export const pressKeyUntilOptionHighlightedOrThrow = async ({
+ key,
+ findOption,
+ maximumKeyPresses = 3,
+}: {
+ key: string;
+ findOption: () => Element | null;
+ maximumKeyPresses?: number;
+}): Promise<void> => {
+ for (
+ let keyPressCount = 0;
+ keyPressCount < maximumKeyPresses;
+ keyPressCount += 1
+ ) {
+ await userEvent.keyboard(key);
+
+ const isOptionHighlighted = await waitFor(
+ () => expect(findOption()).toHaveAttribute('data-highlighted'),
+ { timeout: HIGHLIGHT_SETTLE_TIMEOUT },
+ ).then(
+ () => true,
+ () => false,
+ );
+
+ if (isOptionHighlighted) {
+ return;
+ }
+ }
+
+ throw new Error(`${key} never highlighted the expected option`);
+};
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/pressKeyboardKeys.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/pressKeyboardKeys.ts
new file mode 100644
index 00000000000..adcf0fd8fa2
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/pressKeyboardKeys.ts
@@ -0,0 +1,18 @@
+import { userEvent } from 'storybook/test';
+
+export const pressKeyboardKeys = async ({
+ keys,
+ isTrusted,
+}: {
+ keys: string;
+ isTrusted: boolean;
+}): Promise<void> => {
+ if (!isTrusted) {
+ await userEvent.keyboard(keys);
+ return;
+ }
+
+ const { userEvent: trustedUserEvent } = await import('vitest/browser');
+
+ await trustedUserEvent.keyboard(keys);
+};
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/readHostScrollBoundary.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/readHostScrollBoundary.ts
new file mode 100644
index 00000000000..dbdd856aa52
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/readHostScrollBoundary.ts
@@ -0,0 +1,10 @@
+import { within } from 'storybook/test';
+
+import { WIDGET_SCROLL_FRAME_LABEL } from '@/__stories__/twenty-ui-gallery/constants/WidgetScrollFrameLabel';
+
+export const readHostScrollBoundary = (canvasElement: HTMLElement) => ({
+ widgetScrollTop: within(canvasElement).getByRole('region', {
+ name: WIDGET_SCROLL_FRAME_LABEL,
+ }).scrollTop,
+ windowScrollY: window.scrollY,
+});
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/scrollDetachNoReplayTest.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/scrollDetachNoReplayTest.ts
new file mode 100644
index 00000000000..764c2d63bd2
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/scrollDetachNoReplayTest.ts
@@ -0,0 +1,40 @@
+import { expect, userEvent, within } from 'storybook/test';
+
+import { errorHandler } from '@/__stories__/shared/test-utils/createFrontComponentStoryMeta';
+import { expectFrontComponentMounted } from '@/__stories__/shared/test-utils/matchers/expectFrontComponentMounted';
+import { INTERACTION_TIMEOUT } from '@/__stories__/shared/test-utils/timeouts';
+import { type TwentyUiGalleryPlayFunction } from '@/__stories__/twenty-ui-gallery/types/TwentyUiGalleryPlayFunction';
+import { waitForGeometryTrackerToIdle } from '@/__stories__/twenty-ui-gallery/utils/waitForGeometryTrackerToIdle';
+
+export const scrollDetachNoReplayTest: TwentyUiGalleryPlayFunction = async ({
+ canvasElement,
+}) => {
+ const canvas = within(canvasElement);
+ await expectFrontComponentMounted(canvas);
+
+ await canvas.findByRole(
+ 'region',
+ { name: 'Detachable scroller' },
+ { timeout: INTERACTION_TIMEOUT },
+ );
+ await userEvent.click(
+ canvas.getByRole('button', { name: 'Write and detach' }),
+ );
+ await waitForGeometryTrackerToIdle();
+ await expect(
+ canvas.queryByRole('region', { name: 'Detachable scroller' }),
+ ).toBeNull();
+
+ await userEvent.click(canvas.getByRole('button', { name: 'Reattach' }));
+
+ const reattachedScroller = await canvas.findByRole(
+ 'region',
+ { name: 'Detachable scroller' },
+ { timeout: INTERACTION_TIMEOUT },
+ );
+
+ await waitForGeometryTrackerToIdle();
+
+ await expect(reattachedScroller.scrollTop).toBe(0);
+ await expect(errorHandler).not.toHaveBeenCalled();
+};
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/scrollEchoElisionTest.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/scrollEchoElisionTest.ts
new file mode 100644
index 00000000000..8dd4704702d
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/scrollEchoElisionTest.ts
@@ -0,0 +1,38 @@
+import { expect, userEvent, waitFor, within } from 'storybook/test';
+
+import { errorHandler } from '@/__stories__/shared/test-utils/createFrontComponentStoryMeta';
+import { expectFrontComponentMounted } from '@/__stories__/shared/test-utils/matchers/expectFrontComponentMounted';
+import { INTERACTION_TIMEOUT } from '@/__stories__/shared/test-utils/timeouts';
+import { type TwentyUiGalleryPlayFunction } from '@/__stories__/twenty-ui-gallery/types/TwentyUiGalleryPlayFunction';
+import { waitForGeometryTrackerToIdle } from '@/__stories__/twenty-ui-gallery/utils/waitForGeometryTrackerToIdle';
+
+const HOST_SCROLL_TOP = 200;
+
+export const scrollEchoElisionTest: TwentyUiGalleryPlayFunction = async ({
+ canvasElement,
+}) => {
+ const canvas = within(canvasElement);
+ await expectFrontComponentMounted(canvas);
+
+ const echoTarget = canvas.getByRole('region', { name: 'Echo target' });
+
+ await userEvent.click(
+ canvas.getByRole('button', { name: 'Read echo position' }),
+ );
+ await waitFor(
+ () =>
+ expect(
+ canvas.getByRole('status', { name: 'Echo read' }),
+ ).toHaveTextContent('0'),
+ { timeout: INTERACTION_TIMEOUT },
+ );
+
+ echoTarget.scrollTop = HOST_SCROLL_TOP;
+ await waitForGeometryTrackerToIdle();
+
+ await userEvent.click(canvas.getByRole('button', { name: 'Echo position' }));
+ await waitForGeometryTrackerToIdle();
+
+ await expect(echoTarget.scrollTop).toBe(HOST_SCROLL_TOP);
+ await expect(errorHandler).not.toHaveBeenCalled();
+};
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/scrollEventEchoTest.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/scrollEventEchoTest.ts
new file mode 100644
index 00000000000..6812b805f8c
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/scrollEventEchoTest.ts
@@ -0,0 +1,44 @@
+import { expect, userEvent, waitFor, within } from 'storybook/test';
+
+import { errorHandler } from '@/__stories__/shared/test-utils/createFrontComponentStoryMeta';
+import { expectFrontComponentMounted } from '@/__stories__/shared/test-utils/matchers/expectFrontComponentMounted';
+import { INTERACTION_TIMEOUT } from '@/__stories__/shared/test-utils/timeouts';
+import { type TwentyUiGalleryPlayFunction } from '@/__stories__/twenty-ui-gallery/types/TwentyUiGalleryPlayFunction';
+import { focusWithoutScrolling } from '@/__stories__/twenty-ui-gallery/utils/focusWithoutScrolling';
+import { waitForGeometryTrackerToIdle } from '@/__stories__/twenty-ui-gallery/utils/waitForGeometryTrackerToIdle';
+
+const HOST_SCROLL_TOP = 200;
+
+export const scrollEventEchoTest: TwentyUiGalleryPlayFunction = async ({
+ canvasElement,
+}) => {
+ const canvas = within(canvasElement);
+ await expectFrontComponentMounted(canvas);
+
+ const keyboardScroller = canvas.getByRole('region', {
+ name: 'Keyboard scroller',
+ });
+ const scrollAfterKeydownSerialization = () => {
+ keyboardScroller.scrollTop = HOST_SCROLL_TOP;
+ };
+
+ await focusWithoutScrolling(keyboardScroller);
+ canvasElement.ownerDocument.addEventListener(
+ 'keydown',
+ scrollAfterKeydownSerialization,
+ { once: true },
+ );
+ await userEvent.keyboard('a');
+
+ await waitFor(
+ () =>
+ expect(
+ canvas.getByRole('status', { name: 'Keyboard scroll keys' }),
+ ).toHaveTextContent('1'),
+ { timeout: INTERACTION_TIMEOUT },
+ );
+ await waitForGeometryTrackerToIdle();
+
+ await expect(keyboardScroller.scrollTop).toBe(HOST_SCROLL_TOP);
+ await expect(errorHandler).not.toHaveBeenCalled();
+};
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/scrollInstancesTest.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/scrollInstancesTest.ts
new file mode 100644
index 00000000000..4cf4e8b15c6
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/scrollInstancesTest.ts
@@ -0,0 +1,58 @@
+import { expect, userEvent, waitFor, within } from 'storybook/test';
+
+import { errorHandler } from '@/__stories__/shared/test-utils/createFrontComponentStoryMeta';
+import {
+ INTERACTION_TIMEOUT,
+ MOUNT_TIMEOUT,
+} from '@/__stories__/shared/test-utils/timeouts';
+import { type TwentyUiGalleryPlayFunction } from '@/__stories__/twenty-ui-gallery/types/TwentyUiGalleryPlayFunction';
+import { waitForGeometryTrackerToIdle } from '@/__stories__/twenty-ui-gallery/utils/waitForGeometryTrackerToIdle';
+
+const revealRowInRenderer = async (renderer: HTMLElement) => {
+ await userEvent.click(
+ within(renderer).getByRole('button', { name: 'Reveal row 25' }),
+ );
+};
+
+const readInnerScroller = (renderer: HTMLElement) =>
+ within(renderer).getByRole('region', { name: 'Inner scroller' });
+
+export const scrollInstancesTest: TwentyUiGalleryPlayFunction = async ({
+ canvasElement,
+}) => {
+ const canvas = within(canvasElement);
+
+ await waitFor(
+ () =>
+ expect(canvas.getAllByTestId('front-component-mounted')).toHaveLength(2),
+ { timeout: MOUNT_TIMEOUT },
+ );
+
+ const firstRenderer = canvas.getByRole('group', { name: 'First renderer' });
+ const secondRenderer = canvas.getByRole('group', { name: 'Second renderer' });
+
+ await revealRowInRenderer(firstRenderer);
+ await waitFor(
+ () => expect(readInnerScroller(firstRenderer).scrollTop).toBeGreaterThan(0),
+ { timeout: INTERACTION_TIMEOUT },
+ );
+ await waitForGeometryTrackerToIdle();
+ await expect(readInnerScroller(secondRenderer).scrollTop).toBe(0);
+
+ await userEvent.click(
+ canvas.getByRole('button', { name: 'Remove first renderer' }),
+ );
+ await waitFor(
+ () =>
+ expect(canvas.getAllByTestId('front-component-mounted')).toHaveLength(1),
+ { timeout: INTERACTION_TIMEOUT },
+ );
+
+ await revealRowInRenderer(secondRenderer);
+ await waitFor(
+ () =>
+ expect(readInnerScroller(secondRenderer).scrollTop).toBeGreaterThan(0),
+ { timeout: INTERACTION_TIMEOUT },
+ );
+ await expect(errorHandler).not.toHaveBeenCalled();
+};
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/scrollNestedRevealTest.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/scrollNestedRevealTest.ts
new file mode 100644
index 00000000000..625c10431f3
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/scrollNestedRevealTest.ts
@@ -0,0 +1,60 @@
+import { expect, userEvent, waitFor, within } from 'storybook/test';
+
+import { errorHandler } from '@/__stories__/shared/test-utils/createFrontComponentStoryMeta';
+import { expectElementWithinScrollport } from '@/__stories__/shared/test-utils/matchers/expectElementWithinScrollport';
+import { expectFrontComponentMounted } from '@/__stories__/shared/test-utils/matchers/expectFrontComponentMounted';
+import { readScrollportRectangle } from '@/__stories__/shared/test-utils/readScrollportRectangle';
+import { INTERACTION_TIMEOUT } from '@/__stories__/shared/test-utils/timeouts';
+import { type TwentyUiGalleryPlayFunction } from '@/__stories__/twenty-ui-gallery/types/TwentyUiGalleryPlayFunction';
+import { readHostScrollBoundary } from '@/__stories__/twenty-ui-gallery/utils/readHostScrollBoundary';
+
+const CENTER_TOLERANCE = 1;
+
+export const scrollNestedRevealTest: TwentyUiGalleryPlayFunction = async ({
+ canvasElement,
+}) => {
+ const canvas = within(canvasElement);
+ await expectFrontComponentMounted(canvas);
+
+ const outerScroller = canvas.getByRole('region', { name: 'Outer scroller' });
+ const innerScroller = canvas.getByRole('region', { name: 'Inner scroller' });
+ const row = canvas.getByText('Row 25');
+ const hostScrollBoundaryBeforeReveal = readHostScrollBoundary(canvasElement);
+
+ await userEvent.click(canvas.getByRole('button', { name: 'Reveal row 25' }));
+
+ await waitFor(
+ () => {
+ expect(outerScroller.scrollTop).toBeGreaterThan(0);
+ expectElementWithinScrollport({
+ element: row,
+ scrollContainer: innerScroller,
+ });
+ expectElementWithinScrollport({
+ element: row,
+ scrollContainer: outerScroller,
+ });
+ },
+ { timeout: INTERACTION_TIMEOUT },
+ );
+
+ await userEvent.click(canvas.getByRole('button', { name: 'Center row 25' }));
+
+ await waitFor(
+ () => {
+ const rowRectangle = row.getBoundingClientRect();
+ const { top, bottom } = readScrollportRectangle(innerScroller);
+
+ expect(
+ Math.abs(
+ rowRectangle.top + rowRectangle.height / 2 - (top + bottom) / 2,
+ ),
+ ).toBeLessThanOrEqual(CENTER_TOLERANCE);
+ },
+ { timeout: INTERACTION_TIMEOUT },
+ );
+ await expect(readHostScrollBoundary(canvasElement)).toEqual(
+ hostScrollBoundaryBeforeReveal,
+ );
+ await expect(errorHandler).not.toHaveBeenCalled();
+};
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/scrollPageStaysLocalTest.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/scrollPageStaysLocalTest.ts
new file mode 100644
index 00000000000..347c3821cd8
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/scrollPageStaysLocalTest.ts
@@ -0,0 +1,37 @@
+import { expect, userEvent, waitFor, within } from 'storybook/test';
+
+import { errorHandler } from '@/__stories__/shared/test-utils/createFrontComponentStoryMeta';
+import { expectFrontComponentMounted } from '@/__stories__/shared/test-utils/matchers/expectFrontComponentMounted';
+import { INTERACTION_TIMEOUT } from '@/__stories__/shared/test-utils/timeouts';
+import { type TwentyUiGalleryPlayFunction } from '@/__stories__/twenty-ui-gallery/types/TwentyUiGalleryPlayFunction';
+import { readHostScrollBoundary } from '@/__stories__/twenty-ui-gallery/utils/readHostScrollBoundary';
+import { waitForGeometryTrackerToIdle } from '@/__stories__/twenty-ui-gallery/utils/waitForGeometryTrackerToIdle';
+
+export const scrollPageStaysLocalTest: TwentyUiGalleryPlayFunction = async ({
+ canvasElement,
+}) => {
+ const canvas = within(canvasElement);
+ await expectFrontComponentMounted(canvas);
+
+ const tryPageScrollButton = canvas.getByRole('button', {
+ name: 'Try page scroll',
+ });
+
+ await userEvent.click(tryPageScrollButton);
+
+ const hostScrollBoundaryAfterClick = readHostScrollBoundary(canvasElement);
+
+ await waitFor(
+ () =>
+ expect(
+ canvas.getByRole('status', { name: 'Page scroll' }),
+ ).toHaveTextContent('ok'),
+ { timeout: INTERACTION_TIMEOUT },
+ );
+ await waitForGeometryTrackerToIdle();
+
+ await expect(readHostScrollBoundary(canvasElement)).toEqual(
+ hostScrollBoundaryAfterClick,
+ );
+ await expect(errorHandler).not.toHaveBeenCalled();
+};
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/scrollPortalRefreshTest.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/scrollPortalRefreshTest.ts
new file mode 100644
index 00000000000..3f68d5d597a
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/scrollPortalRefreshTest.ts
@@ -0,0 +1,39 @@
+import { expect, userEvent, waitFor, within } from 'storybook/test';
+
+import { errorHandler } from '@/__stories__/shared/test-utils/createFrontComponentStoryMeta';
+import { expectFrontComponentMounted } from '@/__stories__/shared/test-utils/matchers/expectFrontComponentMounted';
+import { INTERACTION_TIMEOUT } from '@/__stories__/shared/test-utils/timeouts';
+import { type TwentyUiGalleryPlayFunction } from '@/__stories__/twenty-ui-gallery/types/TwentyUiGalleryPlayFunction';
+import { waitForGeometryTrackerToIdle } from '@/__stories__/twenty-ui-gallery/utils/waitForGeometryTrackerToIdle';
+
+const HOST_SCROLL_TOP = 120;
+
+export const scrollPortalRefreshTest: TwentyUiGalleryPlayFunction = async ({
+ canvasElement,
+}) => {
+ const canvas = within(canvasElement);
+ const body = within(canvasElement.ownerDocument.body);
+ await expectFrontComponentMounted(canvas);
+
+ const readPortalButton = canvas.getByRole('button', {
+ name: 'Read portal scroll',
+ });
+ const portalRead = canvas.getByRole('status', { name: 'Portal read' });
+
+ await userEvent.click(readPortalButton);
+ await waitFor(() => expect(portalRead).toHaveTextContent('0'), {
+ timeout: INTERACTION_TIMEOUT,
+ });
+ await waitForGeometryTrackerToIdle();
+
+ body.getByRole('region', { name: 'Portal scroller' }).scrollTop =
+ HOST_SCROLL_TOP;
+ await waitForGeometryTrackerToIdle();
+
+ await userEvent.click(readPortalButton);
+ await waitFor(
+ () => expect(portalRead).toHaveTextContent(String(HOST_SCROLL_TOP)),
+ { timeout: INTERACTION_TIMEOUT },
+ );
+ await expect(errorHandler).not.toHaveBeenCalled();
+};
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/scrollReadAfterWriteTest.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/scrollReadAfterWriteTest.ts
new file mode 100644
index 00000000000..82a9113707f
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/scrollReadAfterWriteTest.ts
@@ -0,0 +1,41 @@
+import { expect, userEvent, waitFor, within } from 'storybook/test';
+
+import { errorHandler } from '@/__stories__/shared/test-utils/createFrontComponentStoryMeta';
+import { expectFrontComponentMounted } from '@/__stories__/shared/test-utils/matchers/expectFrontComponentMounted';
+import { INTERACTION_TIMEOUT } from '@/__stories__/shared/test-utils/timeouts';
+import { type TwentyUiGalleryPlayFunction } from '@/__stories__/twenty-ui-gallery/types/TwentyUiGalleryPlayFunction';
+
+export const scrollReadAfterWriteTest: TwentyUiGalleryPlayFunction = async ({
+ canvasElement,
+}) => {
+ const canvas = within(canvasElement);
+ await expectFrontComponentMounted(canvas);
+
+ await userEvent.click(canvas.getByRole('button', { name: 'Write log 120' }));
+
+ await waitFor(
+ () => {
+ expect(
+ canvas.getByRole('status', { name: 'Log reads' }),
+ ).toHaveTextContent('sync:120;next:120');
+ expect(canvas.getByRole('region', { name: 'Log' }).scrollTop).toBe(120);
+ },
+ { timeout: INTERACTION_TIMEOUT },
+ );
+ await userEvent.click(
+ canvas.getByRole('button', { name: 'Write chips -120' }),
+ );
+
+ await waitFor(
+ () => {
+ expect(
+ canvas.getByRole('status', { name: 'Chip reads' }),
+ ).toHaveTextContent('sync:-120;next:-120');
+ expect(canvas.getByRole('region', { name: 'RTL chips' }).scrollLeft).toBe(
+ -120,
+ );
+ },
+ { timeout: INTERACTION_TIMEOUT },
+ );
+ await expect(errorHandler).not.toHaveBeenCalled();
+};
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/scrollRtlRevealTest.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/scrollRtlRevealTest.ts
new file mode 100644
index 00000000000..17cfc9e2f3d
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/scrollRtlRevealTest.ts
@@ -0,0 +1,44 @@
+import { expect, userEvent, waitFor, within } from 'storybook/test';
+
+import { errorHandler } from '@/__stories__/shared/test-utils/createFrontComponentStoryMeta';
+import { expectElementWithinScrollport } from '@/__stories__/shared/test-utils/matchers/expectElementWithinScrollport';
+import { expectFrontComponentMounted } from '@/__stories__/shared/test-utils/matchers/expectFrontComponentMounted';
+import { readScrollportRectangle } from '@/__stories__/shared/test-utils/readScrollportRectangle';
+import { INTERACTION_TIMEOUT } from '@/__stories__/shared/test-utils/timeouts';
+import { type TwentyUiGalleryPlayFunction } from '@/__stories__/twenty-ui-gallery/types/TwentyUiGalleryPlayFunction';
+
+const EDGE_TOLERANCE = 1;
+
+export const scrollRtlRevealTest: TwentyUiGalleryPlayFunction = async ({
+ canvasElement,
+}) => {
+ const canvas = within(canvasElement);
+ await expectFrontComponentMounted(canvas);
+
+ const chips = canvas.getByRole('region', { name: 'RTL chips' });
+ const chip = canvas.getByText('Chip 18');
+
+ await userEvent.click(canvas.getByRole('button', { name: 'Reveal chip 18' }));
+
+ await waitFor(
+ () => {
+ expect(chips.scrollLeft).toBeLessThan(0);
+ expectElementWithinScrollport({ element: chip, scrollContainer: chips });
+ },
+ { timeout: INTERACTION_TIMEOUT },
+ );
+
+ await userEvent.click(canvas.getByRole('button', { name: 'Start chip 18' }));
+
+ await waitFor(
+ () => {
+ const scrollportRight = readScrollportRectangle(chips).right;
+
+ expect(
+ Math.abs(chip.getBoundingClientRect().right - scrollportRight),
+ ).toBeLessThanOrEqual(EDGE_TOLERANCE);
+ },
+ { timeout: INTERACTION_TIMEOUT },
+ );
+ await expect(errorHandler).not.toHaveBeenCalled();
+};
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/selectAlignedOpenTest.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/selectAlignedOpenTest.ts
new file mode 100644
index 00000000000..c1342343d6a
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/selectAlignedOpenTest.ts
@@ -0,0 +1,45 @@
+import { expect, userEvent, waitFor, within } from 'storybook/test';
+
+import { errorHandler } from '@/__stories__/shared/test-utils/createFrontComponentStoryMeta';
+import { expectElementWithinScrollport } from '@/__stories__/shared/test-utils/matchers/expectElementWithinScrollport';
+import { expectFrontComponentMounted } from '@/__stories__/shared/test-utils/matchers/expectFrontComponentMounted';
+import { INTERACTION_TIMEOUT } from '@/__stories__/shared/test-utils/timeouts';
+import { type TwentyUiGalleryPlayFunction } from '@/__stories__/twenty-ui-gallery/types/TwentyUiGalleryPlayFunction';
+import { expectScrollPositionStable } from '@/__stories__/twenty-ui-gallery/utils/expectScrollPositionStable';
+import { findScrollContainerOrThrow } from '@/__stories__/twenty-ui-gallery/utils/findScrollContainerOrThrow';
+import { openSelectListbox } from '@/__stories__/twenty-ui-gallery/utils/openSelectListbox';
+
+const HOST_SCROLL_POSITIONS = [0, 240, 120];
+
+export const selectAlignedOpenTest: TwentyUiGalleryPlayFunction = async ({
+ canvasElement,
+}) => {
+ const canvas = within(canvasElement);
+ const body = within(canvasElement.ownerDocument.body);
+ await expectFrontComponentMounted(canvas);
+
+ await openSelectListbox({ canvas, body, selectName: 'Aligned option' });
+
+ const selectedOption = body.getByRole('option', { name: 'Option 30' });
+ const scrollContainer = findScrollContainerOrThrow(selectedOption);
+
+ await waitFor(
+ () => {
+ expect(scrollContainer.scrollTop).toBeGreaterThan(0);
+ expectElementWithinScrollport({
+ element: selectedOption,
+ scrollContainer,
+ });
+ },
+ { timeout: INTERACTION_TIMEOUT },
+ );
+ await expectScrollPositionStable(scrollContainer);
+
+ for (const hostScrollPosition of HOST_SCROLL_POSITIONS) {
+ scrollContainer.scrollTop = hostScrollPosition;
+ await expectScrollPositionStable(scrollContainer);
+ }
+
+ await userEvent.keyboard('{Escape}');
+ await expect(errorHandler).not.toHaveBeenCalled();
+};
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/selectRevealTest.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/selectRevealTest.ts
new file mode 100644
index 00000000000..4bb63206564
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/selectRevealTest.ts
@@ -0,0 +1,50 @@
+import { expect, userEvent, waitFor, within } from 'storybook/test';
+
+import { errorHandler } from '@/__stories__/shared/test-utils/createFrontComponentStoryMeta';
+import { expectElementWithinScrollport } from '@/__stories__/shared/test-utils/matchers/expectElementWithinScrollport';
+import { expectFocusedElementWithinScrollport } from '@/__stories__/shared/test-utils/matchers/expectFocusedElementWithinScrollport';
+import { expectFrontComponentMounted } from '@/__stories__/shared/test-utils/matchers/expectFrontComponentMounted';
+import { INTERACTION_TIMEOUT } from '@/__stories__/shared/test-utils/timeouts';
+import { type TwentyUiGalleryPlayFunction } from '@/__stories__/twenty-ui-gallery/types/TwentyUiGalleryPlayFunction';
+import { findScrollContainerOrThrow } from '@/__stories__/twenty-ui-gallery/utils/findScrollContainerOrThrow';
+import { openSelectListbox } from '@/__stories__/twenty-ui-gallery/utils/openSelectListbox';
+
+const KEYBOARD_STEPS = [
+ { key: '{End}', optionName: 'Option 40' },
+ { key: '{ArrowUp}', optionName: 'Option 39' },
+ { key: '{ArrowUp}', optionName: 'Option 38' },
+ { key: '{Home}', optionName: 'Option 01' },
+ { key: '{ArrowDown}', optionName: 'Option 02' },
+];
+
+export const selectRevealTest: TwentyUiGalleryPlayFunction = async ({
+ canvasElement,
+}) => {
+ const canvas = within(canvasElement);
+ const body = within(canvasElement.ownerDocument.body);
+ await expectFrontComponentMounted(canvas);
+
+ await openSelectListbox({ canvas, body, selectName: 'Unaligned option' });
+ await waitFor(
+ () => {
+ const selectedOption = body.getByRole('option', { name: 'Option 30' });
+
+ expectElementWithinScrollport({
+ element: selectedOption,
+ scrollContainer: findScrollContainerOrThrow(selectedOption),
+ });
+ },
+ { timeout: INTERACTION_TIMEOUT },
+ );
+
+ for (const { key, optionName } of KEYBOARD_STEPS) {
+ await userEvent.keyboard(key);
+ await expectFocusedElementWithinScrollport({
+ findElement: () => body.getByRole('option', { name: optionName }),
+ findScrollContainer: findScrollContainerOrThrow,
+ });
+ }
+
+ await userEvent.keyboard('{Escape}');
+ await expect(errorHandler).not.toHaveBeenCalled();
+};
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/tabsOverflowTest.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/tabsOverflowTest.ts
new file mode 100644
index 00000000000..04becc93c14
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/tabsOverflowTest.ts
@@ -0,0 +1,54 @@
+import { expect, userEvent, within } from 'storybook/test';
+
+import { errorHandler } from '@/__stories__/shared/test-utils/createFrontComponentStoryMeta';
+import { expectFocusedElementWithinScrollport } from '@/__stories__/shared/test-utils/matchers/expectFocusedElementWithinScrollport';
+import { expectFrontComponentMounted } from '@/__stories__/shared/test-utils/matchers/expectFrontComponentMounted';
+import { type TwentyUiGalleryPlayFunction } from '@/__stories__/twenty-ui-gallery/types/TwentyUiGalleryPlayFunction';
+import { expectScrollPositionStable } from '@/__stories__/twenty-ui-gallery/utils/expectScrollPositionStable';
+
+const TAB_LISTS = [
+ { label: 'Sections', isRightToLeft: false },
+ { label: 'Sections RTL', isRightToLeft: true },
+];
+
+const expectTabFocusedWithinList = ({
+ tabList,
+ tabName,
+}: {
+ tabList: HTMLElement;
+ tabName: string;
+}) =>
+ expectFocusedElementWithinScrollport({
+ findElement: () => within(tabList).getByRole('tab', { name: tabName }),
+ findScrollContainer: () => tabList,
+ });
+
+export const tabsOverflowTest: TwentyUiGalleryPlayFunction = async ({
+ canvasElement,
+}) => {
+ const canvas = within(canvasElement);
+ await expectFrontComponentMounted(canvas);
+
+ for (const { label, isRightToLeft } of TAB_LISTS) {
+ const tabList = canvas.getByRole('tablist', { name: label });
+
+ await userEvent.click(
+ within(tabList).getByRole('tab', { name: 'Section 01' }),
+ );
+ await userEvent.keyboard('{End}');
+ await expectTabFocusedWithinList({ tabList, tabName: 'Section 12' });
+ await expectScrollPositionStable(tabList);
+ await expect(Math.abs(tabList.scrollLeft)).toBeGreaterThan(0);
+ await expect(tabList.scrollLeft < 0).toBe(isRightToLeft);
+
+ await userEvent.keyboard('{End}');
+ await expectTabFocusedWithinList({ tabList, tabName: 'Section 12' });
+ await expectScrollPositionStable(tabList);
+
+ await userEvent.keyboard('{Home}');
+ await expectTabFocusedWithinList({ tabList, tabName: 'Section 01' });
+ await expectScrollPositionStable(tabList);
+ }
+
+ await expect(errorHandler).not.toHaveBeenCalled();
+};
diff --git a/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/waitForGeometryTrackerToIdle.ts b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/waitForGeometryTrackerToIdle.ts
new file mode 100644
index 00000000000..489104e808c
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/__stories__/twenty-ui-gallery/utils/waitForGeometryTrackerToIdle.ts
@@ -0,0 +1,5 @@
+import { waitForAnimationFrames } from '@/__stories__/shared/test-utils/waitForAnimationFrames';
+import { GEOMETRY_IDLE_FRAME_THRESHOLD } from '@/host/geometry/constants/GeometryIdleFrameThreshold';
+
+export const waitForGeometryTrackerToIdle = () =>
+ waitForAnimationFrames(GEOMETRY_IDLE_FRAME_THRESHOLD * 2);
diff --git a/packages/twenty-front-component-renderer/src/constants/EventScrollStateKeys.ts b/packages/twenty-front-component-renderer/src/constants/EventScrollStateKeys.ts
new file mode 100644
index 00000000000..58c45975995
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/constants/EventScrollStateKeys.ts
@@ -0,0 +1,8 @@
+import { type SerializedEventData } from '@/types/SerializedEventData';
+
+export const EVENT_SCROLL_STATE_KEYS = [
+ 'scrollTop',
+ 'scrollLeft',
+ 'scrollWidth',
+ 'clientWidth',
+] as const satisfies readonly (keyof SerializedEventData)[];
diff --git a/packages/twenty-front-component-renderer/src/constants/MaxPendingScrollCommands.ts b/packages/twenty-front-component-renderer/src/constants/MaxPendingScrollCommands.ts
new file mode 100644
index 00000000000..2acd342708b
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/constants/MaxPendingScrollCommands.ts
@@ -0,0 +1 @@
+export const MAX_PENDING_SCROLL_COMMANDS = 32;
diff --git a/packages/twenty-front-component-renderer/src/constants/ScrollAxes.ts b/packages/twenty-front-component-renderer/src/constants/ScrollAxes.ts
new file mode 100644
index 00000000000..303bdd2dd80
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/constants/ScrollAxes.ts
@@ -0,0 +1 @@
+export const SCROLL_AXES = ['top', 'left'] as const;
diff --git a/packages/twenty-front-component-renderer/src/constants/ScrollBridgeProperties.ts b/packages/twenty-front-component-renderer/src/constants/ScrollBridgeProperties.ts
new file mode 100644
index 00000000000..a61fc713ecc
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/constants/ScrollBridgeProperties.ts
@@ -0,0 +1,4 @@
+export const SCROLL_BRIDGE_PROPERTIES = {
+ request: '__twentyScrollRequest',
+ update: '__twentyScrollUpdate',
+} as const;
diff --git a/packages/twenty-front-component-renderer/src/constants/ScrollIntoViewAlignments.ts b/packages/twenty-front-component-renderer/src/constants/ScrollIntoViewAlignments.ts
new file mode 100644
index 00000000000..0057b6ff90f
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/constants/ScrollIntoViewAlignments.ts
@@ -0,0 +1,6 @@
+export const SCROLL_INTO_VIEW_ALIGNMENTS = [
+ 'start',
+ 'center',
+ 'end',
+ 'nearest',
+] as const;
diff --git a/packages/twenty-front-component-renderer/src/host/components/FrontComponentRenderer.tsx b/packages/twenty-front-component-renderer/src/host/components/FrontComponentRenderer.tsx
index c9e7254bf62..e266ff00585 100644
--- a/packages/twenty-front-component-renderer/src/host/components/FrontComponentRenderer.tsx
+++ b/packages/twenty-front-component-renderer/src/host/components/FrontComponentRenderer.tsx
@@ -6,6 +6,8 @@ import { FrontComponentGeometryTrackerContext } from '@/host/geometry/contexts/F
import { createGeometryTracker } from '@/host/geometry/utils/createGeometryTracker';
import { FrontComponentHostFocusControllerContext } from '@/host/focus/contexts/FrontComponentHostFocusControllerContext';
import { createHostFocusController } from '@/host/focus/utils/createHostFocusController';
+import { FrontComponentHostScrollControllerContext } from '@/host/scroll/contexts/FrontComponentHostScrollControllerContext';
+import { createHostScrollController } from '@/host/scroll/utils/createHostScrollController';
import { FrontComponentConfirmationModalResultEffect } from '@/host/effect-components/FrontComponentConfirmationModalResultEffect';
import { FrontComponentErrorEffect } from '@/host/effect-components/FrontComponentErrorEffect';
import { FrontComponentFocusTrackerEffect } from '@/host/effect-components/FrontComponentFocusTrackerEffect';
@@ -76,6 +78,9 @@ export const FrontComponentRenderer = ({
const [hostFocusController] = useState(() =>
createHostFocusController({ geometryTracker }),
);
+ const [hostScrollController] = useState(() =>
+ createHostScrollController({ geometryTracker }),
+ );
const [pointerCaptureController] = useState(() =>
createHostPointerCaptureController({ geometryTracker }),
);
@@ -98,6 +103,7 @@ export const FrontComponentRenderer = ({
initialExecutionContext={initialExecutionContext}
geometryTracker={geometryTracker}
hostFocusController={hostFocusController}
+ hostScrollController={hostScrollController}
mediaSessionHost={mediaSessionHost}
setReceiver={setReceiver}
setThread={setThread}
@@ -168,14 +174,18 @@ export const FrontComponentRenderer = ({
<FrontComponentHostFocusControllerContext.Provider
value={hostFocusController}
>
- <FrontComponentPointerCaptureControllerContext.Provider
- value={pointerCaptureController}
+ <FrontComponentHostScrollControllerContext.Provider
+ value={hostScrollController}
>
- <FrontComponentRemoteRootRenderer
- receiver={receiver}
- components={fallbackComponentRegistry}
- />
- </FrontComponentPointerCaptureControllerContext.Provider>
+ <FrontComponentPointerCaptureControllerContext.Provider
+ value={pointerCaptureController}
+ >
+ <FrontComponentRemoteRootRenderer
+ receiver={receiver}
+ components={fallbackComponentRegistry}
+ />
+ </FrontComponentPointerCaptureControllerContext.Provider>
+ </FrontComponentHostScrollControllerContext.Provider>
</FrontComponentHostFocusControllerContext.Provider>
</ErrorBoundary>
</ThemeProvider>
diff --git a/packages/twenty-front-component-renderer/src/host/effect-components/FrontComponentWorkerEffect.tsx b/packages/twenty-front-component-renderer/src/host/effect-components/FrontComponentWorkerEffect.tsx
index d60ba4617f8..5392f1ebfc1 100644
--- a/packages/twenty-front-component-renderer/src/host/effect-components/FrontComponentWorkerEffect.tsx
+++ b/packages/twenty-front-component-renderer/src/host/effect-components/FrontComponentWorkerEffect.tsx
@@ -7,6 +7,7 @@ import { createFileInputAwareRemoteConnection } from '@/host/file-input/utils/cr
import { createFileInputHost } from '@/host/file-input/utils/createFileInputHost';
import { type HostFocusController } from '@/host/focus/types/HostFocusController';
import { createFocusAwareRemoteConnection } from '@/host/focus/utils/createFocusAwareRemoteConnection';
+import { type HostScrollController } from '@/host/scroll/types/HostScrollController';
import { buildHostFetchPolicyFromFrontComponentUrls } from '@/host/fetch/utils/buildHostFetchPolicyFromFrontComponentUrls';
import { createFrontComponentHostThread } from '@/host/thread/utils/createFrontComponentHostThread';
import { createImageLoadingHost } from '@/host/image-loading/utils/createImageLoadingHost';
@@ -41,12 +42,14 @@ type FrontComponentWorkerEffectProps = {
mediaSessionHost?: FrontComponentMediaSessionHost;
setReceiver: React.Dispatch<React.SetStateAction<RemoteReceiver | null>>;
hostFocusController: HostFocusController;
+ hostScrollController: HostScrollController;
setThread: React.Dispatch<React.SetStateAction<FrontComponentThread | null>>;
setError: React.Dispatch<React.SetStateAction<Error | null>>;
};
export const FrontComponentWorkerEffect = ({
hostFocusController,
+ hostScrollController,
componentUrl,
applicationAccessToken,
apiUrl,
@@ -192,6 +195,7 @@ export const FrontComponentWorkerEffect = ({
imageLoadingHost.dispose();
fileInputHost.dispose();
hostFocusController.reset();
+ hostScrollController.reset();
window.removeEventListener('message', handleSandboxMessage);
setThread(null);
channel.port1.close();
@@ -210,6 +214,7 @@ export const FrontComponentWorkerEffect = ({
initialExecutionContext,
geometryTracker,
hostFocusController,
+ hostScrollController,
mediaSessionHost,
setError,
setReceiver,
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 d48fc4ce09f..b90ad041142 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,5 +1,6 @@
import { useContext } from 'react';
+import { SCROLL_BRIDGE_PROPERTIES } from '@/constants/ScrollBridgeProperties';
import { FrontComponentInputFocusContext } from '@/host/caret/contexts/FrontComponentInputFocusContext';
import { FrontComponentPointerCaptureControllerContext } from '@/host/events/contexts/FrontComponentPointerCaptureControllerContext';
import { FrontComponentGeometryTrackerContext } from '@/host/geometry/contexts/FrontComponentGeometryTrackerContext';
@@ -17,6 +18,7 @@ import { getRemoteElementIdFromProps } from '@/host/elements/utils/getRemoteElem
import { preventDefaultThenForwardToRemote } from '@/host/events/utils/preventDefaultThenForwardToRemote';
import { sanitizeIframeSandbox } from '@/host/elements/utils/sanitizeIframeSandbox';
import { useRetryPendingHostFocus } from '@/host/focus/hooks/useRetryPendingHostFocus';
+import { useHostScrollCommands } from '@/host/scroll/hooks/useHostScrollCommands';
type HtmlHostElementProps = {
setEditableFocused: SetEditableFocused | null;
@@ -38,12 +40,18 @@ export const useHtmlHostElementProps = ({
FrontComponentPointerCaptureControllerContext,
);
- const remoteElementId = getRemoteElementIdFromProps(props);
+ const {
+ [SCROLL_BRIDGE_PROPERTIES.request]: scrollCommands,
+ [SCROLL_BRIDGE_PROPERTIES.update]: onScrollUpdate,
+ ...remoteProps
+ } = props;
+
+ const remoteElementId = getRemoteElementIdFromProps(remoteProps);
const { reactUnsupportedEventHandlers, reactBindableProps } =
extractReactUnsupportedEventHandlers(
buildHostReactPropsFromRemoteProps({
- remoteProps: props,
+ remoteProps,
htmlTag,
findRemoteElementIdContainingNode:
geometryTracker?.findRemoteElementIdContainingNode,
@@ -60,6 +68,8 @@ export const useHtmlHostElementProps = ({
useRetryPendingHostFocus();
+ useHostScrollCommands({ remoteElementId, scrollCommands, onScrollUpdate });
+
const composedElementRef = useComposedElementRef([
reactUnsupportedEventListenerRef,
geometryNodeRef,
diff --git a/packages/twenty-front-component-renderer/src/host/elements/utils/__tests__/createHtmlHostWrapper.test.ts b/packages/twenty-front-component-renderer/src/host/elements/utils/__tests__/createHtmlHostWrapper.test.ts
index d0d141e39c3..556661cc29d 100644
--- a/packages/twenty-front-component-renderer/src/host/elements/utils/__tests__/createHtmlHostWrapper.test.ts
+++ b/packages/twenty-front-component-renderer/src/host/elements/utils/__tests__/createHtmlHostWrapper.test.ts
@@ -1,12 +1,14 @@
import '@/testing/setupServerRenderingGlobals';
import { REMOTE_ELEMENT_PROP } from '@remote-dom/react/host';
+import { isString } from '@sniptt/guards';
import userEvent from '@testing-library/user-event';
import { act, createElement, type ComponentType } from 'react';
import { createRoot, type Root } from 'react-dom/client';
import { renderToStaticMarkup } from 'react-dom/server';
import { jsx } from 'react/jsx-runtime';
+import { SCROLL_BRIDGE_PROPERTIES } from '@/constants/ScrollBridgeProperties';
import { createHtmlHostWrapper } from '../createHtmlHostWrapper';
(
@@ -540,3 +542,71 @@ describe('createHtmlHostWrapper client events', () => {
);
});
});
+
+describe('createHtmlHostWrapper scroll bridge props', () => {
+ let container: HTMLDivElement;
+ let root: Root;
+
+ beforeEach(() => {
+ container = document.createElement('div');
+ document.body.appendChild(container);
+ root = createRoot(container);
+ });
+
+ afterEach(() => {
+ act(() => {
+ root.unmount();
+ });
+ container.remove();
+ jest.restoreAllMocks();
+ });
+
+ it.each(['div', 'input', 'textarea'])(
+ 'should not render the scroll bridge props as attributes on the %s element',
+ (htmlTag) => {
+ const consoleErrorSpy = jest
+ .spyOn(console, 'error')
+ .mockImplementation(() => {});
+ const Wrapper = createHtmlHostWrapper(htmlTag);
+
+ act(() => {
+ root.render(
+ createWrapperElement(Wrapper, {
+ [REMOTE_ELEMENT_PROP]: { id: '7' },
+ [SCROLL_BRIDGE_PROPERTIES.request]: [
+ { sequence: 1, request: { method: 'scrollTo', top: 10 } },
+ ],
+ [SCROLL_BRIDGE_PROPERTIES.update]: jest.fn(),
+ }),
+ );
+ });
+
+ const node = container.firstElementChild;
+
+ expect(node).toBeInstanceOf(HTMLElement);
+
+ if (!(node instanceof HTMLElement)) {
+ return;
+ }
+
+ const scrollBridgePropertyNames = Object.values(SCROLL_BRIDGE_PROPERTIES);
+ const renderedScrollBridgePropertyNames =
+ scrollBridgePropertyNames.filter((scrollBridgePropertyName) =>
+ node.hasAttribute(scrollBridgePropertyName),
+ );
+ const scrollBridgeWarningArguments = consoleErrorSpy.mock.calls
+ .flat()
+ .filter(
+ (warningArgument) =>
+ isString(warningArgument) &&
+ scrollBridgePropertyNames.some((scrollBridgePropertyName) =>
+ warningArgument.includes(scrollBridgePropertyName),
+ ),
+ );
+
+ expect(node.tagName.toLowerCase()).toBe(htmlTag);
+ expect(renderedScrollBridgePropertyNames).toEqual([]);
+ expect(scrollBridgeWarningArguments).toEqual([]);
+ },
+ );
+});
diff --git a/packages/twenty-front-component-renderer/src/host/events/utils/__tests__/serializeEvent.test.ts b/packages/twenty-front-component-renderer/src/host/events/utils/__tests__/serializeEvent.test.ts
index 5648877d63a..f5f2364a1b4 100644
--- a/packages/twenty-front-component-renderer/src/host/events/utils/__tests__/serializeEvent.test.ts
+++ b/packages/twenty-front-component-renderer/src/host/events/utils/__tests__/serializeEvent.test.ts
@@ -229,6 +229,33 @@ describe('serializeEvent', () => {
});
});
+ it('should include the target scroll extents', () => {
+ expect(
+ serializeEvent({
+ type: 'keydown',
+ target: { scrollLeft: 0, scrollWidth: 480, clientWidth: 160 },
+ }),
+ ).toEqual({
+ type: 'keydown',
+ scrollLeft: 0,
+ scrollWidth: 480,
+ clientWidth: 160,
+ });
+ });
+
+ it('should leave out target scroll state when a non-bubbling event reaches a listener on another element', () => {
+ const listeningElement = { scrollTop: 0 };
+
+ expect(
+ serializeEvent({
+ type: 'mouseenter',
+ bubbles: false,
+ currentTarget: listeningElement,
+ target: { scrollTop: 40, scrollWidth: 480, clientWidth: 160 },
+ }),
+ ).toEqual({ type: 'mouseenter' });
+ });
+
it.each(['keydown', 'keypress', 'beforeinput', 'pointerdown', 'paste'])(
'should leave out form control state on %s, before the browser applies the change',
(type) => {
diff --git a/packages/twenty-front-component-renderer/src/host/events/utils/applyEventTargetProperties.ts b/packages/twenty-front-component-renderer/src/host/events/utils/applyEventTargetProperties.ts
index 0d68a870e2d..6ae28249b68 100644
--- a/packages/twenty-front-component-renderer/src/host/events/utils/applyEventTargetProperties.ts
+++ b/packages/twenty-front-component-renderer/src/host/events/utils/applyEventTargetProperties.ts
@@ -9,10 +9,12 @@ export const applyEventTargetProperties = ({
serializedEvent,
target,
includesFormControlState,
+ includesScrollState,
}: {
serializedEvent: SerializedEventData;
target: unknown;
includesFormControlState: boolean;
+ includesScrollState: boolean;
}): void => {
if (!isPlainObject(target)) {
return;
@@ -22,6 +24,9 @@ export const applyEventTargetProperties = ({
applyFormControlTargetProperties({ serializedEvent, target });
}
- applyScrollTargetProperties({ serializedEvent, target });
+ if (includesScrollState) {
+ applyScrollTargetProperties({ serializedEvent, target });
+ }
+
applyMediaTargetProperties({ serializedEvent, target });
};
diff --git a/packages/twenty-front-component-renderer/src/host/events/utils/applyScrollTargetProperties.ts b/packages/twenty-front-component-renderer/src/host/events/utils/applyScrollTargetProperties.ts
index bb87cc49712..192df86bbcf 100644
--- a/packages/twenty-front-component-renderer/src/host/events/utils/applyScrollTargetProperties.ts
+++ b/packages/twenty-front-component-renderer/src/host/events/utils/applyScrollTargetProperties.ts
@@ -1,5 +1,6 @@
import { isNumber } from '@sniptt/guards';
+import { EVENT_SCROLL_STATE_KEYS } from '@/constants/EventScrollStateKeys';
import { type SerializedEventData } from '@/types/SerializedEventData';
export const applyScrollTargetProperties = ({
@@ -9,10 +10,11 @@ export const applyScrollTargetProperties = ({
serializedEvent: SerializedEventData;
target: Record<string, unknown>;
}): void => {
- if (isNumber(target.scrollTop)) {
- serializedEvent.scrollTop = target.scrollTop;
- }
- if (isNumber(target.scrollLeft)) {
- serializedEvent.scrollLeft = target.scrollLeft;
+ for (const key of EVENT_SCROLL_STATE_KEYS) {
+ const value = target[key];
+
+ if (isNumber(value)) {
+ serializedEvent[key] = value;
+ }
}
};
diff --git a/packages/twenty-front-component-renderer/src/host/events/utils/isTargetScrollStateForwardable.ts b/packages/twenty-front-component-renderer/src/host/events/utils/isTargetScrollStateForwardable.ts
new file mode 100644
index 00000000000..fd617dead5d
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/events/utils/isTargetScrollStateForwardable.ts
@@ -0,0 +1,11 @@
+import { isDefined } from 'twenty-shared/utils';
+
+import { type HostEventDispatchFields } from '@/host/events/types/HostEventDispatchFields';
+import { isBubblingHostEvent } from '@/host/events/utils/isBubblingHostEvent';
+
+export const isTargetScrollStateForwardable = (
+ domEvent: HostEventDispatchFields & { currentTarget?: unknown },
+): boolean =>
+ isBubblingHostEvent(domEvent) ||
+ !isDefined(domEvent.currentTarget) ||
+ domEvent.currentTarget === domEvent.target;
diff --git a/packages/twenty-front-component-renderer/src/host/events/utils/serializeEvent.ts b/packages/twenty-front-component-renderer/src/host/events/utils/serializeEvent.ts
index 95bf0a615c9..8f5e5bba2d9 100644
--- a/packages/twenty-front-component-renderer/src/host/events/utils/serializeEvent.ts
+++ b/packages/twenty-front-component-renderer/src/host/events/utils/serializeEvent.ts
@@ -8,6 +8,7 @@ import { applyKeyboardEventProperties } from '@/host/events/utils/applyKeyboardE
import { applyMouseEventProperties } from '@/host/events/utils/applyMouseEventProperties';
import { applyPointerEventProperties } from '@/host/events/utils/applyPointerEventProperties';
import { applyWheelEventProperties } from '@/host/events/utils/applyWheelEventProperties';
+import { isTargetScrollStateForwardable } from '@/host/events/utils/isTargetScrollStateForwardable';
import { type SerializedEventData } from '@/types/SerializedEventData';
type SerializeEventOptions = {
@@ -38,6 +39,7 @@ export const serializeEvent = (
serializedEvent,
target: domEvent.target,
includesFormControlState,
+ includesScrollState: isTargetScrollStateForwardable(domEvent),
});
return serializedEvent;
diff --git a/packages/twenty-front-component-renderer/src/host/geometry/types/GeometryWakeSources.ts b/packages/twenty-front-component-renderer/src/host/geometry/types/GeometryWakeSources.ts
index 46a16c2f101..80a2569a756 100644
--- a/packages/twenty-front-component-renderer/src/host/geometry/types/GeometryWakeSources.ts
+++ b/packages/twenty-front-component-renderer/src/host/geometry/types/GeometryWakeSources.ts
@@ -2,7 +2,7 @@ export type GeometryWakeSources = {
attachViewportSources: () => void;
attachElementSources: () => void;
detachElementSources: () => void;
- attachPortalLayerSources: () => void;
+ attachPortalLayerSources: (portalLayer: Element) => void;
detachPortalLayerSources: () => void;
detachAllSources: () => void;
setRoot: (node: Element | null) => void;
diff --git a/packages/twenty-front-component-renderer/src/host/geometry/utils/__tests__/createGeometryWakeSources.test.ts b/packages/twenty-front-component-renderer/src/host/geometry/utils/__tests__/createGeometryWakeSources.test.ts
new file mode 100644
index 00000000000..d4952bf562e
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/geometry/utils/__tests__/createGeometryWakeSources.test.ts
@@ -0,0 +1,103 @@
+import { type GeometryWakeSources } from '@/host/geometry/types/GeometryWakeSources';
+import { createGeometryWakeSources } from '@/host/geometry/utils/createGeometryWakeSources';
+
+const createdWakeSources: GeometryWakeSources[] = [];
+
+const createPortalFixture = () => {
+ const onWake = jest.fn();
+ const wakeSources = createGeometryWakeSources(onWake);
+ const rootContainer = document.createElement('div');
+ const portalLayer = document.createElement('div');
+ const portalScroller = document.createElement('div');
+ const unrelatedScroller = document.createElement('div');
+
+ portalLayer.append(portalScroller);
+ document.body.append(rootContainer, portalLayer, unrelatedScroller);
+ wakeSources.setRoot(rootContainer);
+ createdWakeSources.push(wakeSources);
+
+ return {
+ onWake,
+ wakeSources,
+ portalLayer,
+ portalScroller,
+ unrelatedScroller,
+ };
+};
+
+const dispatchScroll = (target: Element) => {
+ target.dispatchEvent(new Event('scroll'));
+};
+
+describe('createGeometryWakeSources', () => {
+ afterEach(() => {
+ for (const wakeSources of createdWakeSources) {
+ wakeSources.detachPortalLayerSources();
+ wakeSources.detachAllSources();
+ }
+ createdWakeSources.length = 0;
+ document.body.replaceChildren();
+ });
+
+ it('should wake when an element inside the attached portal layer scrolls', () => {
+ const { onWake, wakeSources, portalLayer, portalScroller } =
+ createPortalFixture();
+
+ wakeSources.attachPortalLayerSources(portalLayer);
+ dispatchScroll(portalScroller);
+
+ expect(onWake).toHaveBeenCalledTimes(1);
+ });
+
+ it('should not wake when an element outside the root and the portal layer scrolls', () => {
+ const { onWake, wakeSources, portalLayer, unrelatedScroller } =
+ createPortalFixture();
+
+ wakeSources.attachPortalLayerSources(portalLayer);
+ dispatchScroll(unrelatedScroller);
+
+ expect(onWake).not.toHaveBeenCalled();
+ });
+
+ it('should stop waking on portal scrolls once the portal layer sources are detached', () => {
+ const { onWake, wakeSources, portalLayer, portalScroller } =
+ createPortalFixture();
+
+ wakeSources.attachPortalLayerSources(portalLayer);
+ wakeSources.detachPortalLayerSources();
+ dispatchScroll(portalScroller);
+
+ expect(onWake).not.toHaveBeenCalled();
+ });
+
+ it('should stop waking on scrolls in a previous portal layer once another portal layer is attached', () => {
+ const { onWake, wakeSources, portalLayer, portalScroller } =
+ createPortalFixture();
+ const nextPortalLayer = document.createElement('div');
+ const nextPortalScroller = document.createElement('div');
+
+ nextPortalLayer.append(nextPortalScroller);
+ document.body.append(nextPortalLayer);
+ wakeSources.attachPortalLayerSources(portalLayer);
+ wakeSources.attachPortalLayerSources(nextPortalLayer);
+ dispatchScroll(portalScroller);
+
+ expect(onWake).not.toHaveBeenCalled();
+
+ dispatchScroll(nextPortalScroller);
+
+ expect(onWake).toHaveBeenCalledTimes(1);
+ });
+
+ it('should keep waking on portal scrolls when the element sources are detached', () => {
+ const { onWake, wakeSources, portalLayer, portalScroller } =
+ createPortalFixture();
+
+ wakeSources.attachElementSources();
+ wakeSources.attachPortalLayerSources(portalLayer);
+ wakeSources.detachElementSources();
+ dispatchScroll(portalScroller);
+
+ expect(onWake).toHaveBeenCalledTimes(1);
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/host/geometry/utils/createGeometryTracker.ts b/packages/twenty-front-component-renderer/src/host/geometry/utils/createGeometryTracker.ts
index 342b7ac8f71..f507c669c8b 100644
--- a/packages/twenty-front-component-renderer/src/host/geometry/utils/createGeometryTracker.ts
+++ b/packages/twenty-front-component-renderer/src/host/geometry/utils/createGeometryTracker.ts
@@ -276,7 +276,7 @@ export const createGeometryTracker = (): GeometryTracker => {
rootContainer,
viewport: readViewportGeometry(),
});
- wakeSources.attachPortalLayerSources();
+ wakeSources.attachPortalLayerSources(element);
wake();
};
diff --git a/packages/twenty-front-component-renderer/src/host/geometry/utils/createGeometryWakeSources.ts b/packages/twenty-front-component-renderer/src/host/geometry/utils/createGeometryWakeSources.ts
index 115da9e94bd..8000c571f0a 100644
--- a/packages/twenty-front-component-renderer/src/host/geometry/utils/createGeometryWakeSources.ts
+++ b/packages/twenty-front-component-renderer/src/host/geometry/utils/createGeometryWakeSources.ts
@@ -35,13 +35,13 @@ export const createGeometryWakeSources = (
createInputMediaFeatureChangeObserver(onWake);
let rootContainer: Element | null = null;
+ let portalLayer: Element | null = null;
let resizeObserver: ResizeObserver | null = null;
let mutationObserver: MutationObserver | null = null;
let rootAncestorMutationObserver: MutationObserver | null = null;
let documentStyleObserver: MutationObserver | null = null;
let areViewportSourcesAttached = false;
let areElementSourcesAttached = false;
- let arePortalLayerSourcesAttached = false;
const isEventTargetRelevantToRoot = (target: EventTarget | null): boolean => {
if (!isDefined(rootContainer)) {
@@ -52,7 +52,11 @@ export const createGeometryWakeSources = (
return false;
}
- return rootContainer.contains(target) || target.contains(rootContainer);
+ return (
+ rootContainer.contains(target) ||
+ target.contains(rootContainer) ||
+ (isDefined(portalLayer) && portalLayer.contains(target))
+ );
};
const handleAnimationEvent = (event: Event): void => {
@@ -75,7 +79,7 @@ export const createGeometryWakeSources = (
};
const syncScrollListener = (): void => {
- if (areElementSourcesAttached || arePortalLayerSourcesAttached) {
+ if (areElementSourcesAttached || isDefined(portalLayer)) {
document.addEventListener('scroll', handleScroll, true);
return;
}
@@ -220,12 +224,15 @@ export const createGeometryWakeSources = (
resizeObservedNodes.clear();
};
- const attachPortalLayerSources = (): void => {
- if (arePortalLayerSourcesAttached) {
+ const attachPortalLayerSources = (nextPortalLayer: Element): void => {
+ const wasPortalLayerAttached = isDefined(portalLayer);
+
+ portalLayer = nextPortalLayer;
+
+ if (wasPortalLayerAttached) {
return;
}
- arePortalLayerSourcesAttached = true;
syncScrollListener();
if (isDefined(rootContainer)) {
@@ -234,11 +241,11 @@ export const createGeometryWakeSources = (
};
const detachPortalLayerSources = (): void => {
- if (!arePortalLayerSourcesAttached) {
+ if (!isDefined(portalLayer)) {
return;
}
- arePortalLayerSourcesAttached = false;
+ portalLayer = null;
syncScrollListener();
disconnectRootAncestorMutations();
};
@@ -282,7 +289,7 @@ export const createGeometryWakeSources = (
observeRootMutations(node);
}
- if (arePortalLayerSourcesAttached) {
+ if (isDefined(portalLayer)) {
observeRootAncestorMutations(node);
}
};
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/contexts/FrontComponentHostScrollControllerContext.ts b/packages/twenty-front-component-renderer/src/host/scroll/contexts/FrontComponentHostScrollControllerContext.ts
new file mode 100644
index 00000000000..6047956a734
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/contexts/FrontComponentHostScrollControllerContext.ts
@@ -0,0 +1,6 @@
+import { createContext } from 'react';
+
+import { type HostScrollController } from '@/host/scroll/types/HostScrollController';
+
+export const FrontComponentHostScrollControllerContext =
+ createContext<HostScrollController | null>(null);
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/hooks/useHostScrollCommands.ts b/packages/twenty-front-component-renderer/src/host/scroll/hooks/useHostScrollCommands.ts
new file mode 100644
index 00000000000..7b4cf32e179
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/hooks/useHostScrollCommands.ts
@@ -0,0 +1,35 @@
+import { isArray } from '@sniptt/guards';
+import { useContext, useLayoutEffect } from 'react';
+import { isDefined } from 'twenty-shared/utils';
+
+import { FrontComponentHostScrollControllerContext } from '@/host/scroll/contexts/FrontComponentHostScrollControllerContext';
+
+export const useHostScrollCommands = ({
+ remoteElementId,
+ scrollCommands,
+ onScrollUpdate,
+}: {
+ remoteElementId: string | undefined;
+ scrollCommands: unknown;
+ onScrollUpdate: unknown;
+}): void => {
+ const hostScrollController = useContext(
+ FrontComponentHostScrollControllerContext,
+ );
+
+ useLayoutEffect(() => {
+ if (
+ !isDefined(hostScrollController) ||
+ !isDefined(remoteElementId) ||
+ !isArray(scrollCommands)
+ ) {
+ return;
+ }
+
+ hostScrollController.enqueueScrollCommands({
+ remoteElementId,
+ scrollCommands,
+ onScrollUpdate,
+ });
+ }, [hostScrollController, remoteElementId, scrollCommands, onScrollUpdate]);
+};
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/types/ElementScale.ts b/packages/twenty-front-component-renderer/src/host/scroll/types/ElementScale.ts
new file mode 100644
index 00000000000..836af4f71d6
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/types/ElementScale.ts
@@ -0,0 +1,4 @@
+export type ElementScale = {
+ x: number;
+ y: number;
+};
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/types/HostScrollController.ts b/packages/twenty-front-component-renderer/src/host/scroll/types/HostScrollController.ts
new file mode 100644
index 00000000000..f8f11f5e6a4
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/types/HostScrollController.ts
@@ -0,0 +1,8 @@
+export type HostScrollController = {
+ enqueueScrollCommands: (input: {
+ remoteElementId: string;
+ scrollCommands: unknown[];
+ onScrollUpdate: unknown;
+ }) => void;
+ reset: () => void;
+};
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/types/ScrollBox.ts b/packages/twenty-front-component-renderer/src/host/scroll/types/ScrollBox.ts
new file mode 100644
index 00000000000..2cec09fa0d0
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/types/ScrollBox.ts
@@ -0,0 +1,6 @@
+export type ScrollBox = {
+ top: number;
+ right: number;
+ bottom: number;
+ left: number;
+};
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/applyScrollRequest.test.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/applyScrollRequest.test.ts
new file mode 100644
index 00000000000..6adace47694
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/applyScrollRequest.test.ts
@@ -0,0 +1,93 @@
+import { applyScrollRequest } from '@/host/scroll/utils/applyScrollRequest';
+import { scrollOwnedAncestorsIntoView } from '@/host/scroll/utils/scrollOwnedAncestorsIntoView';
+import { type ScrollRequest } from '@/types/ScrollRequest';
+
+jest.mock('@/host/scroll/utils/scrollOwnedAncestorsIntoView', () => ({
+ scrollOwnedAncestorsIntoView: jest.fn(),
+}));
+
+const scrollOwnedAncestorsIntoViewMock = jest.mocked(
+ scrollOwnedAncestorsIntoView,
+);
+
+const createNodeWithScrollTo = () => {
+ const node = document.createElement('div');
+ const scrollTo = jest.fn();
+
+ Object.defineProperty(node, 'scrollTo', {
+ value: scrollTo,
+ configurable: true,
+ });
+
+ return { node, scrollTo };
+};
+
+describe('applyScrollRequest', () => {
+ beforeEach(() => {
+ scrollOwnedAncestorsIntoViewMock.mockReset();
+ });
+
+ it('should scroll the node instantly to both axes and return it', () => {
+ const { node, scrollTo } = createNodeWithScrollTo();
+
+ const scrolledNodes = applyScrollRequest({
+ node,
+ request: { method: 'scrollTo', top: 40, left: 12 },
+ isOwnedNode: jest.fn(),
+ });
+
+ expect(scrollTo.mock.calls).toStrictEqual([
+ [{ top: 40, left: 12, behavior: 'instant' }],
+ ]);
+ expect(scrolledNodes).toHaveLength(1);
+ expect(scrolledNodes[0]).toBe(node);
+ expect(scrollOwnedAncestorsIntoViewMock).not.toHaveBeenCalled();
+ });
+
+ it.each<{
+ request: ScrollRequest;
+ expectedScrollToOptions: ScrollToOptions;
+ }>([
+ {
+ request: { method: 'scrollTo', top: 40 },
+ expectedScrollToOptions: { top: 40, behavior: 'instant' },
+ },
+ {
+ request: { method: 'scrollTo', left: 0 },
+ expectedScrollToOptions: { left: 0, behavior: 'instant' },
+ },
+ ])(
+ 'should pass only the defined axes of the request $request to scrollTo',
+ ({ request, expectedScrollToOptions }) => {
+ const { node, scrollTo } = createNodeWithScrollTo();
+
+ applyScrollRequest({ node, request, isOwnedNode: jest.fn() });
+
+ expect(scrollTo.mock.calls).toStrictEqual([[expectedScrollToOptions]]);
+ },
+ );
+
+ it('should delegate a scrollIntoView request to the owned ancestors walk and return its scrolled containers', () => {
+ const { node, scrollTo } = createNodeWithScrollTo();
+ const scrolledAncestors = [document.createElement('div')];
+ const isOwnedNode = jest.fn();
+
+ scrollOwnedAncestorsIntoViewMock.mockReturnValue(scrolledAncestors);
+
+ const scrolledNodes = applyScrollRequest({
+ node,
+ request: { method: 'scrollIntoView', block: 'center', inline: 'end' },
+ isOwnedNode,
+ });
+
+ expect(scrolledNodes).toBe(scrolledAncestors);
+ expect(scrollOwnedAncestorsIntoViewMock).toHaveBeenCalledTimes(1);
+ expect(scrollOwnedAncestorsIntoViewMock).toHaveBeenCalledWith({
+ target: node,
+ block: 'center',
+ inline: 'end',
+ isOwnedNode,
+ });
+ expect(scrollTo).not.toHaveBeenCalled();
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/createHostScrollController.test.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/createHostScrollController.test.ts
new file mode 100644
index 00000000000..7f4398d8fff
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/createHostScrollController.test.ts
@@ -0,0 +1,531 @@
+import { isDefined } from 'twenty-shared/utils';
+
+import { latestNativeEditSequenceByHostElement } from '@/host/caret/states/latestNativeEditSequenceByHostElement';
+import { MAX_PENDING_SCROLL_COMMANDS } from '@/constants/MaxPendingScrollCommands';
+import { createHostScrollController } from '@/host/scroll/utils/createHostScrollController';
+import { createGeometryTrackerStub } from '@/testing/createGeometryTrackerStub';
+
+type AppliedScrollTo = {
+ remoteElementId: string;
+ scrollToOptions: ScrollToOptions;
+};
+
+const createScrollToCommand = ({
+ sequence,
+ top,
+ left,
+}: {
+ sequence: number;
+ top?: number;
+ left?: number;
+}) => ({
+ sequence,
+ request: { method: 'scrollTo', top, left },
+});
+
+const flushScrollCommands = () => Promise.resolve();
+
+const createScrollControllerFixture = () => {
+ const geometryTracker = createGeometryTrackerStub();
+ const registeredNodesByRemoteElementId = new Map<string, Element>();
+ const appliedScrollTos: AppliedScrollTo[] = [];
+
+ jest
+ .mocked(geometryTracker.getRegisteredNode)
+ .mockImplementation((remoteElementId) =>
+ registeredNodesByRemoteElementId.get(remoteElementId),
+ );
+ jest
+ .mocked(geometryTracker.findRemoteElementIdContainingNode)
+ .mockImplementation((node) => {
+ for (const [
+ remoteElementId,
+ registeredNode,
+ ] of registeredNodesByRemoteElementId) {
+ if (registeredNode === node) {
+ return remoteElementId;
+ }
+ }
+
+ return undefined;
+ });
+
+ const registerScrollableElement = (remoteElementId: string) => {
+ const element = document.createElement('div');
+ const scrollTo = jest.fn((scrollToOptions: ScrollToOptions) => {
+ appliedScrollTos.push({ remoteElementId, scrollToOptions });
+
+ if (isDefined(scrollToOptions.top)) {
+ element.scrollTop = scrollToOptions.top;
+ }
+
+ if (isDefined(scrollToOptions.left)) {
+ element.scrollLeft = scrollToOptions.left;
+ }
+ });
+
+ Object.defineProperty(element, 'scrollTo', {
+ value: scrollTo,
+ configurable: true,
+ });
+ document.body.append(element);
+ registeredNodesByRemoteElementId.set(remoteElementId, element);
+
+ return { element, scrollTo };
+ };
+
+ return {
+ controller: createHostScrollController({ geometryTracker }),
+ registerScrollableElement,
+ appliedScrollTos,
+ };
+};
+
+describe('createHostScrollController', () => {
+ afterEach(() => {
+ document.body.replaceChildren();
+ });
+
+ it('should apply the commands of every element in global sequence order on the next microtask', async () => {
+ const { controller, registerScrollableElement, appliedScrollTos } =
+ createScrollControllerFixture();
+
+ registerScrollableElement('first');
+ registerScrollableElement('second');
+ controller.enqueueScrollCommands({
+ remoteElementId: 'first',
+ scrollCommands: [
+ createScrollToCommand({ sequence: 3, top: 30 }),
+ createScrollToCommand({ sequence: 1, top: 10 }),
+ ],
+ onScrollUpdate: jest.fn(),
+ });
+ controller.enqueueScrollCommands({
+ remoteElementId: 'second',
+ scrollCommands: [createScrollToCommand({ sequence: 2, top: 20 })],
+ onScrollUpdate: jest.fn(),
+ });
+
+ expect(appliedScrollTos).toHaveLength(0);
+
+ await flushScrollCommands();
+
+ expect(appliedScrollTos).toEqual([
+ {
+ remoteElementId: 'first',
+ scrollToOptions: { top: 10, behavior: 'instant' },
+ },
+ {
+ remoteElementId: 'second',
+ scrollToOptions: { top: 20, behavior: 'instant' },
+ },
+ {
+ remoteElementId: 'first',
+ scrollToOptions: { top: 30, behavior: 'instant' },
+ },
+ ]);
+ });
+
+ it('should not apply a sequence again when the same commands are enqueued repeatedly', async () => {
+ const { controller, registerScrollableElement } =
+ createScrollControllerFixture();
+ const { scrollTo } = registerScrollableElement('list');
+ const scrollCommands = [createScrollToCommand({ sequence: 1, top: 10 })];
+ const onScrollUpdate = jest.fn();
+
+ controller.enqueueScrollCommands({
+ remoteElementId: 'list',
+ scrollCommands,
+ onScrollUpdate,
+ });
+ controller.enqueueScrollCommands({
+ remoteElementId: 'list',
+ scrollCommands,
+ onScrollUpdate,
+ });
+ await flushScrollCommands();
+ controller.enqueueScrollCommands({
+ remoteElementId: 'list',
+ scrollCommands,
+ onScrollUpdate,
+ });
+ await flushScrollCommands();
+
+ expect(scrollTo).toHaveBeenCalledTimes(1);
+ expect(onScrollUpdate).toHaveBeenCalledTimes(1);
+ });
+
+ it('should apply only the commands newer than the last applied sequence of an element', async () => {
+ const { controller, registerScrollableElement } =
+ createScrollControllerFixture();
+ const { scrollTo } = registerScrollableElement('list');
+ const onScrollUpdate = jest.fn();
+
+ controller.enqueueScrollCommands({
+ remoteElementId: 'list',
+ scrollCommands: [createScrollToCommand({ sequence: 1, top: 10 })],
+ onScrollUpdate,
+ });
+ await flushScrollCommands();
+ controller.enqueueScrollCommands({
+ remoteElementId: 'list',
+ scrollCommands: [
+ createScrollToCommand({ sequence: 1, top: 10 }),
+ createScrollToCommand({ sequence: 2, top: 20 }),
+ ],
+ onScrollUpdate,
+ });
+ await flushScrollCommands();
+
+ expect(scrollTo.mock.calls).toEqual([
+ [{ top: 10, behavior: 'instant' }],
+ [{ top: 20, behavior: 'instant' }],
+ ]);
+ expect(onScrollUpdate).toHaveBeenLastCalledWith({
+ scrollCommandSequence: 2,
+ scrollPositions: [
+ { remoteElementId: 'list', scrollTop: 20, scrollLeft: 0 },
+ ],
+ });
+ });
+
+ it('should acknowledge each element once with its highest sequence and its scroll position after the flush', async () => {
+ const { controller, registerScrollableElement } =
+ createScrollControllerFixture();
+ const onFirstScrollUpdate = jest.fn();
+ const onSecondScrollUpdate = jest.fn();
+
+ registerScrollableElement('first');
+ registerScrollableElement('second');
+ controller.enqueueScrollCommands({
+ remoteElementId: 'first',
+ scrollCommands: [
+ createScrollToCommand({ sequence: 1, top: 10 }),
+ createScrollToCommand({ sequence: 3, top: 30, left: 5 }),
+ ],
+ onScrollUpdate: onFirstScrollUpdate,
+ });
+ controller.enqueueScrollCommands({
+ remoteElementId: 'second',
+ scrollCommands: [createScrollToCommand({ sequence: 2, left: 15 })],
+ onScrollUpdate: onSecondScrollUpdate,
+ });
+ await flushScrollCommands();
+
+ expect(onFirstScrollUpdate).toHaveBeenCalledTimes(1);
+ expect(onFirstScrollUpdate).toHaveBeenCalledWith({
+ scrollCommandSequence: 3,
+ scrollPositions: [
+ { remoteElementId: 'first', scrollTop: 30, scrollLeft: 5 },
+ ],
+ });
+ expect(onSecondScrollUpdate).toHaveBeenCalledTimes(1);
+ expect(onSecondScrollUpdate).toHaveBeenCalledWith({
+ scrollCommandSequence: 2,
+ scrollPositions: [
+ { remoteElementId: 'second', scrollTop: 0, scrollLeft: 15 },
+ ],
+ });
+ });
+
+ it('should acknowledge without scrolling a command for an element that is not registered', async () => {
+ const { controller, appliedScrollTos } = createScrollControllerFixture();
+ const onScrollUpdate = jest.fn();
+
+ controller.enqueueScrollCommands({
+ remoteElementId: 'missing',
+ scrollCommands: [createScrollToCommand({ sequence: 4, top: 40 })],
+ onScrollUpdate,
+ });
+ await flushScrollCommands();
+
+ expect(appliedScrollTos).toHaveLength(0);
+ expect(onScrollUpdate).toHaveBeenCalledWith({
+ scrollCommandSequence: 4,
+ scrollPositions: [],
+ });
+ });
+
+ it('should acknowledge without scrolling a command for an element that is disconnected', async () => {
+ const { controller, registerScrollableElement } =
+ createScrollControllerFixture();
+ const { element, scrollTo } = registerScrollableElement('detached');
+ const onScrollUpdate = jest.fn();
+
+ element.remove();
+ controller.enqueueScrollCommands({
+ remoteElementId: 'detached',
+ scrollCommands: [createScrollToCommand({ sequence: 1, top: 40 })],
+ onScrollUpdate,
+ });
+ await flushScrollCommands();
+
+ expect(scrollTo).not.toHaveBeenCalled();
+ expect(onScrollUpdate).toHaveBeenCalledWith({
+ scrollCommandSequence: 1,
+ scrollPositions: [],
+ });
+ });
+
+ it('should acknowledge without scrolling a command whose request is invalid', async () => {
+ const { controller, registerScrollableElement } =
+ createScrollControllerFixture();
+ const { scrollTo } = registerScrollableElement('list');
+ const onScrollUpdate = jest.fn();
+
+ controller.enqueueScrollCommands({
+ remoteElementId: 'list',
+ scrollCommands: [
+ { sequence: 1, request: { method: 'scrollBy', top: 5 } },
+ ],
+ onScrollUpdate,
+ });
+ await flushScrollCommands();
+
+ expect(scrollTo).not.toHaveBeenCalled();
+ expect(onScrollUpdate).toHaveBeenCalledWith({
+ scrollCommandSequence: 1,
+ scrollPositions: [],
+ });
+ });
+
+ it('should apply scroll commands to an element the user edited natively', async () => {
+ const { controller, registerScrollableElement } =
+ createScrollControllerFixture();
+ const { element, scrollTo } = registerScrollableElement('textarea');
+ const onScrollUpdate = jest.fn();
+
+ latestNativeEditSequenceByHostElement.set(element, 5);
+ controller.enqueueScrollCommands({
+ remoteElementId: 'textarea',
+ scrollCommands: [
+ {
+ sequence: 1,
+ acknowledgedNativeEditSequence: 4,
+ request: { method: 'scrollTo', top: 10 },
+ },
+ { sequence: 2, request: { method: 'scrollTo', top: 20 } },
+ ],
+ onScrollUpdate,
+ });
+ await flushScrollCommands();
+
+ expect(scrollTo.mock.calls).toEqual([
+ [{ top: 10, behavior: 'instant' }],
+ [{ top: 20, behavior: 'instant' }],
+ ]);
+ expect(onScrollUpdate).toHaveBeenCalledWith({
+ scrollCommandSequence: 2,
+ scrollPositions: [
+ { remoteElementId: 'textarea', scrollTop: 20, scrollLeft: 0 },
+ ],
+ });
+ });
+
+ it('should apply every command of a large batch across elements in sequence order', async () => {
+ const { controller, registerScrollableElement, appliedScrollTos } =
+ createScrollControllerFixture();
+ const remoteElementIds = ['first', 'second', 'third'];
+ const onScrollUpdates = remoteElementIds.map(() => jest.fn());
+
+ for (const remoteElementId of remoteElementIds) {
+ registerScrollableElement(remoteElementId);
+ }
+
+ for (const [elementIndex, remoteElementId] of remoteElementIds.entries()) {
+ controller.enqueueScrollCommands({
+ remoteElementId,
+ scrollCommands: Array.from(
+ { length: MAX_PENDING_SCROLL_COMMANDS },
+ (_, commandIndex) =>
+ createScrollToCommand({
+ sequence:
+ commandIndex * remoteElementIds.length + elementIndex + 1,
+ top: commandIndex + 1,
+ }),
+ ),
+ onScrollUpdate: onScrollUpdates[elementIndex],
+ });
+ }
+ await flushScrollCommands();
+
+ expect(appliedScrollTos).toHaveLength(
+ MAX_PENDING_SCROLL_COMMANDS * remoteElementIds.length,
+ );
+ expect(
+ appliedScrollTos
+ .slice(0, remoteElementIds.length)
+ .map(({ remoteElementId }) => remoteElementId),
+ ).toEqual(remoteElementIds);
+
+ for (const [elementIndex, remoteElementId] of remoteElementIds.entries()) {
+ expect(onScrollUpdates[elementIndex]).toHaveBeenCalledWith({
+ scrollCommandSequence:
+ (MAX_PENDING_SCROLL_COMMANDS - 1) * remoteElementIds.length +
+ elementIndex +
+ 1,
+ scrollPositions: [
+ {
+ remoteElementId,
+ scrollTop: MAX_PENDING_SCROLL_COMMANDS,
+ scrollLeft: 0,
+ },
+ ],
+ });
+ }
+ });
+
+ it('should only consider the latest pending commands of an element', async () => {
+ const { controller, registerScrollableElement } =
+ createScrollControllerFixture();
+ const { scrollTo } = registerScrollableElement('element');
+ const extraCommandCount = 8;
+
+ controller.enqueueScrollCommands({
+ remoteElementId: 'element',
+ scrollCommands: Array.from(
+ { length: MAX_PENDING_SCROLL_COMMANDS + extraCommandCount },
+ (_, commandIndex) =>
+ createScrollToCommand({
+ sequence: commandIndex + 1,
+ top: commandIndex + 1,
+ }),
+ ),
+ onScrollUpdate: jest.fn(),
+ });
+ await flushScrollCommands();
+
+ expect(scrollTo).toHaveBeenCalledTimes(MAX_PENDING_SCROLL_COMMANDS);
+ expect(scrollTo).toHaveBeenNthCalledWith(1, {
+ top: extraCommandCount + 1,
+ behavior: 'instant',
+ });
+ });
+
+ it('should forget the applied sequence of an element once its pending commands are cleared', async () => {
+ const { controller, registerScrollableElement } =
+ createScrollControllerFixture();
+ const { scrollTo } = registerScrollableElement('element');
+ const scrollCommands = [createScrollToCommand({ sequence: 5, top: 50 })];
+
+ controller.enqueueScrollCommands({
+ remoteElementId: 'element',
+ scrollCommands,
+ onScrollUpdate: jest.fn(),
+ });
+ await flushScrollCommands();
+ controller.enqueueScrollCommands({
+ remoteElementId: 'element',
+ scrollCommands,
+ onScrollUpdate: jest.fn(),
+ });
+ await flushScrollCommands();
+
+ expect(scrollTo).toHaveBeenCalledTimes(1);
+
+ controller.enqueueScrollCommands({
+ remoteElementId: 'element',
+ scrollCommands: [],
+ onScrollUpdate: jest.fn(),
+ });
+ await flushScrollCommands();
+ controller.enqueueScrollCommands({
+ remoteElementId: 'element',
+ scrollCommands,
+ onScrollUpdate: jest.fn(),
+ });
+ await flushScrollCommands();
+
+ expect(scrollTo).toHaveBeenCalledTimes(2);
+ });
+
+ it('should not apply the commands enqueued before a reset', async () => {
+ const { controller, registerScrollableElement } =
+ createScrollControllerFixture();
+ const { scrollTo } = registerScrollableElement('list');
+ const onScrollUpdate = jest.fn();
+
+ controller.enqueueScrollCommands({
+ remoteElementId: 'list',
+ scrollCommands: [createScrollToCommand({ sequence: 1, top: 10 })],
+ onScrollUpdate,
+ });
+ controller.reset();
+ await flushScrollCommands();
+
+ expect(scrollTo).not.toHaveBeenCalled();
+ expect(onScrollUpdate).not.toHaveBeenCalled();
+ });
+
+ it('should flush the commands enqueued right after a reset that cancelled a pending flush', async () => {
+ const { controller, registerScrollableElement } =
+ createScrollControllerFixture();
+ const { scrollTo } = registerScrollableElement('list');
+
+ controller.enqueueScrollCommands({
+ remoteElementId: 'list',
+ scrollCommands: [createScrollToCommand({ sequence: 1, top: 10 })],
+ onScrollUpdate: jest.fn(),
+ });
+ controller.reset();
+ controller.enqueueScrollCommands({
+ remoteElementId: 'list',
+ scrollCommands: [createScrollToCommand({ sequence: 1, top: 20 })],
+ onScrollUpdate: jest.fn(),
+ });
+ await flushScrollCommands();
+
+ expect(scrollTo.mock.calls).toEqual([[{ top: 20, behavior: 'instant' }]]);
+ });
+
+ it('should apply an already applied sequence again after a reset', async () => {
+ const { controller, registerScrollableElement } =
+ createScrollControllerFixture();
+ const { scrollTo } = registerScrollableElement('list');
+ const scrollCommands = [createScrollToCommand({ sequence: 1, top: 10 })];
+
+ controller.enqueueScrollCommands({
+ remoteElementId: 'list',
+ scrollCommands,
+ onScrollUpdate: jest.fn(),
+ });
+ await flushScrollCommands();
+ controller.reset();
+ controller.enqueueScrollCommands({
+ remoteElementId: 'list',
+ scrollCommands,
+ onScrollUpdate: jest.fn(),
+ });
+ await flushScrollCommands();
+
+ expect(scrollTo).toHaveBeenCalledTimes(2);
+ });
+
+ it('should still scroll and acknowledge other elements when an element has no scroll update function', async () => {
+ const { controller, registerScrollableElement } =
+ createScrollControllerFixture();
+ const { scrollTo: firstScrollTo } = registerScrollableElement('first');
+ const onSecondScrollUpdate = jest.fn();
+
+ registerScrollableElement('second');
+ controller.enqueueScrollCommands({
+ remoteElementId: 'first',
+ scrollCommands: [createScrollToCommand({ sequence: 1, top: 10 })],
+ onScrollUpdate: 'not a function',
+ });
+ controller.enqueueScrollCommands({
+ remoteElementId: 'second',
+ scrollCommands: [createScrollToCommand({ sequence: 2, top: 20 })],
+ onScrollUpdate: onSecondScrollUpdate,
+ });
+ await flushScrollCommands();
+
+ expect(firstScrollTo).toHaveBeenCalledTimes(1);
+ expect(onSecondScrollUpdate).toHaveBeenCalledWith({
+ scrollCommandSequence: 2,
+ scrollPositions: [
+ { remoteElementId: 'second', scrollTop: 20, scrollLeft: 0 },
+ ],
+ });
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/expandRectByScrollMargin.test.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/expandRectByScrollMargin.test.ts
new file mode 100644
index 00000000000..9e159439f22
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/expandRectByScrollMargin.test.ts
@@ -0,0 +1,95 @@
+import { type ElementScale } from '@/host/scroll/types/ElementScale';
+import { expandRectByScrollMargin } from '@/host/scroll/utils/expandRectByScrollMargin';
+
+type ScrollMarginStyle = Pick<
+ CSSStyleDeclaration,
+ | 'scrollMarginTop'
+ | 'scrollMarginRight'
+ | 'scrollMarginBottom'
+ | 'scrollMarginLeft'
+>;
+
+const UNSCALED: ElementScale = { x: 1, y: 1 };
+
+const TARGET_RECT = new DOMRect(20, 10, 30, 30);
+
+const createUniformScrollMarginStyle = (
+ scrollMargin: string,
+): ScrollMarginStyle => ({
+ scrollMarginTop: scrollMargin,
+ scrollMarginRight: scrollMargin,
+ scrollMarginBottom: scrollMargin,
+ scrollMarginLeft: scrollMargin,
+});
+
+describe('expandRectByScrollMargin', () => {
+ it('should keep the rect edges when the scroll margin is zero', () => {
+ expect(
+ expandRectByScrollMargin({
+ rect: TARGET_RECT,
+ style: createUniformScrollMarginStyle('0px'),
+ scale: UNSCALED,
+ }),
+ ).toEqual({ top: 10, right: 50, bottom: 40, left: 20 });
+ });
+
+ it('should expand each edge by its pixel scroll margin', () => {
+ expect(
+ expandRectByScrollMargin({
+ rect: TARGET_RECT,
+ style: {
+ scrollMarginTop: '1px',
+ scrollMarginRight: '2px',
+ scrollMarginBottom: '3px',
+ scrollMarginLeft: '4px',
+ },
+ scale: UNSCALED,
+ }),
+ ).toEqual({ top: 9, right: 52, bottom: 43, left: 16 });
+ });
+
+ it('should shrink each edge by a negative scroll margin', () => {
+ expect(
+ expandRectByScrollMargin({
+ rect: TARGET_RECT,
+ style: createUniformScrollMarginStyle('-2px'),
+ scale: UNSCALED,
+ }),
+ ).toEqual({ top: 12, right: 48, bottom: 38, left: 22 });
+ });
+
+ it('should scale the scroll margin on each axis', () => {
+ expect(
+ expandRectByScrollMargin({
+ rect: TARGET_RECT,
+ style: {
+ scrollMarginTop: '1px',
+ scrollMarginRight: '2px',
+ scrollMarginBottom: '3px',
+ scrollMarginLeft: '4px',
+ },
+ scale: { x: 2, y: 3 },
+ }),
+ ).toEqual({ top: 7, right: 54, bottom: 49, left: 12 });
+ });
+
+ it('should ignore percentage scroll margins', () => {
+ expect(
+ expandRectByScrollMargin({
+ rect: TARGET_RECT,
+ style: createUniformScrollMarginStyle('50%'),
+ scale: UNSCALED,
+ }),
+ ).toEqual({ top: 10, right: 50, bottom: 40, left: 20 });
+ });
+
+ it('should treat empty scroll margins as zero', () => {
+ expect(
+ expandRectByScrollMargin({
+ rect: TARGET_RECT,
+ style: createUniformScrollMarginStyle(''),
+ scale: UNSCALED,
+ }),
+ ).toEqual({ top: 10, right: 50, bottom: 40, left: 20 });
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/isScrollContainerOnAxis.test.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/isScrollContainerOnAxis.test.ts
new file mode 100644
index 00000000000..24001bd5f54
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/isScrollContainerOnAxis.test.ts
@@ -0,0 +1,41 @@
+import { isScrollContainerOnAxis } from '@/host/scroll/utils/isScrollContainerOnAxis';
+
+describe('isScrollContainerOnAxis', () => {
+ it.each(['auto', 'scroll', 'hidden', 'overlay'])(
+ 'should be a scroll container when overflow is %s and the content overflows',
+ (overflow) => {
+ expect(
+ isScrollContainerOnAxis({ overflow, scrollSize: 300, clientSize: 100 }),
+ ).toBe(true);
+ },
+ );
+
+ it.each(['visible', 'clip'])(
+ 'should not be a scroll container when overflow is %s even if the content overflows',
+ (overflow) => {
+ expect(
+ isScrollContainerOnAxis({ overflow, scrollSize: 300, clientSize: 100 }),
+ ).toBe(false);
+ },
+ );
+
+ it('should not be a scroll container when the content fits exactly', () => {
+ expect(
+ isScrollContainerOnAxis({
+ overflow: 'auto',
+ scrollSize: 100,
+ clientSize: 100,
+ }),
+ ).toBe(false);
+ });
+
+ it('should not be a scroll container when the content is smaller than the client size', () => {
+ expect(
+ isScrollContainerOnAxis({
+ overflow: 'scroll',
+ scrollSize: 50,
+ clientSize: 100,
+ }),
+ ).toBe(false);
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/parseScrollRequest.test.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/parseScrollRequest.test.ts
new file mode 100644
index 00000000000..66a748dcb80
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/parseScrollRequest.test.ts
@@ -0,0 +1,131 @@
+import { SCROLL_INTO_VIEW_ALIGNMENTS } from '@/constants/ScrollIntoViewAlignments';
+import { parseScrollRequest } from '@/host/scroll/utils/parseScrollRequest';
+
+describe('parseScrollRequest', () => {
+ it.each([
+ { request: undefined },
+ { request: null },
+ { request: 'scrollTo' },
+ { request: 10 },
+ { request: [{ method: 'scrollTo', top: 10 }] },
+ ])(
+ 'should return null when the request $request is not a plain object',
+ ({ request }) => {
+ expect(parseScrollRequest(request)).toBeNull();
+ },
+ );
+
+ it('should keep both finite axes of a scrollTo request', () => {
+ expect(
+ parseScrollRequest({ method: 'scrollTo', top: 40, left: -12.5 }),
+ ).toStrictEqual({ method: 'scrollTo', top: 40, left: -12.5 });
+ });
+
+ it('should keep only the top axis of a scrollTo request that only sets top', () => {
+ expect(parseScrollRequest({ method: 'scrollTo', top: 0 })).toStrictEqual({
+ method: 'scrollTo',
+ top: 0,
+ });
+ });
+
+ it('should keep only the left axis of a scrollTo request that only sets left', () => {
+ expect(parseScrollRequest({ method: 'scrollTo', left: 25 })).toStrictEqual({
+ method: 'scrollTo',
+ left: 25,
+ });
+ });
+
+ it.each([
+ { top: Number.NaN },
+ { top: Number.POSITIVE_INFINITY },
+ { top: Number.NEGATIVE_INFINITY },
+ { top: '40' },
+ { top: null },
+ ])(
+ 'should drop the top axis $top of a scrollTo request and keep the finite left axis',
+ ({ top }) => {
+ expect(
+ parseScrollRequest({ method: 'scrollTo', top, left: 8 }),
+ ).toStrictEqual({ method: 'scrollTo', left: 8 });
+ },
+ );
+
+ it.each([
+ { request: { method: 'scrollTo' } },
+ { request: { method: 'scrollTo', top: Number.NaN, left: '8' } },
+ {
+ request: {
+ method: 'scrollTo',
+ top: Number.POSITIVE_INFINITY,
+ left: undefined,
+ },
+ },
+ ])(
+ 'should return null for the scrollTo request $request without a finite axis',
+ ({ request }) => {
+ expect(parseScrollRequest(request)).toBeNull();
+ },
+ );
+
+ it('should drop the unknown properties of a scrollTo request', () => {
+ expect(
+ parseScrollRequest({ method: 'scrollTo', top: 10, behavior: 'smooth' }),
+ ).toStrictEqual({ method: 'scrollTo', top: 10 });
+ });
+
+ it.each(
+ SCROLL_INTO_VIEW_ALIGNMENTS.flatMap((block) =>
+ SCROLL_INTO_VIEW_ALIGNMENTS.map((inline) => ({ block, inline })),
+ ),
+ )(
+ 'should keep a scrollIntoView request aligned with block $block and inline $inline',
+ ({ block, inline }) => {
+ expect(
+ parseScrollRequest({ method: 'scrollIntoView', block, inline }),
+ ).toStrictEqual({ method: 'scrollIntoView', block, inline });
+ },
+ );
+
+ it('should drop the unknown properties of a scrollIntoView request', () => {
+ expect(
+ parseScrollRequest({
+ method: 'scrollIntoView',
+ block: 'center',
+ inline: 'nearest',
+ behavior: 'smooth',
+ }),
+ ).toStrictEqual({
+ method: 'scrollIntoView',
+ block: 'center',
+ inline: 'nearest',
+ });
+ });
+
+ it.each([
+ { block: 'middle', inline: 'nearest' },
+ { block: 'start', inline: 'left' },
+ { block: 'START', inline: 'nearest' },
+ { block: undefined, inline: 'nearest' },
+ { block: 'start', inline: undefined },
+ { block: 0, inline: 'nearest' },
+ ])(
+ 'should return null for a scrollIntoView request with block $block and inline $inline',
+ ({ block, inline }) => {
+ expect(
+ parseScrollRequest({ method: 'scrollIntoView', block, inline }),
+ ).toBeNull();
+ },
+ );
+
+ it.each([
+ { request: { method: 'scrollBy', top: 10 } },
+ { request: { method: 'scroll', top: 10 } },
+ { request: { top: 10, left: 10 } },
+ { request: { method: 'SCROLLTO', top: 10 } },
+ ])(
+ 'should return null for the request $request with an unknown method',
+ ({ request }) => {
+ expect(parseScrollRequest(request)).toBeNull();
+ },
+ );
+});
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/readNewScrollCommands.test.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/readNewScrollCommands.test.ts
new file mode 100644
index 00000000000..3c3272e6f45
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/readNewScrollCommands.test.ts
@@ -0,0 +1,99 @@
+import { readNewScrollCommands } from '@/host/scroll/utils/readNewScrollCommands';
+
+const SCROLL_TO_TOP_REQUEST = { method: 'scrollTo', top: 10 };
+
+describe('readNewScrollCommands', () => {
+ it('should skip the entries that are not plain objects', () => {
+ expect(
+ readNewScrollCommands({
+ scrollCommands: [
+ null,
+ undefined,
+ 'scrollTo',
+ 4,
+ [5, SCROLL_TO_TOP_REQUEST],
+ { sequence: 6, request: SCROLL_TO_TOP_REQUEST },
+ ],
+ appliedSequence: 0,
+ }),
+ ).toEqual([{ sequence: 6, request: SCROLL_TO_TOP_REQUEST }]);
+ });
+
+ it.each([
+ { sequence: 1.5 },
+ { sequence: Number.NaN },
+ { sequence: Number.POSITIVE_INFINITY },
+ { sequence: Number.MAX_SAFE_INTEGER + 1 },
+ { sequence: '2' },
+ { sequence: undefined },
+ ])(
+ 'should skip a command whose sequence $sequence is not a safe integer',
+ ({ sequence }) => {
+ expect(
+ readNewScrollCommands({
+ scrollCommands: [{ sequence, request: SCROLL_TO_TOP_REQUEST }],
+ appliedSequence: 0,
+ }),
+ ).toEqual([]);
+ },
+ );
+
+ it('should skip the commands whose sequence is not greater than the applied sequence', () => {
+ expect(
+ readNewScrollCommands({
+ scrollCommands: [
+ { sequence: 2, request: SCROLL_TO_TOP_REQUEST },
+ { sequence: 3, request: SCROLL_TO_TOP_REQUEST },
+ { sequence: 4, request: SCROLL_TO_TOP_REQUEST },
+ ],
+ appliedSequence: 3,
+ }),
+ ).toEqual([{ sequence: 4, request: SCROLL_TO_TOP_REQUEST }]);
+ });
+
+ it('should skip the commands with a zero or negative sequence when nothing was applied yet', () => {
+ expect(
+ readNewScrollCommands({
+ scrollCommands: [
+ { sequence: -1, request: SCROLL_TO_TOP_REQUEST },
+ { sequence: 0, request: SCROLL_TO_TOP_REQUEST },
+ ],
+ appliedSequence: 0,
+ }),
+ ).toEqual([]);
+ });
+
+ it('should return the new commands sorted by sequence', () => {
+ const newScrollCommands = readNewScrollCommands({
+ scrollCommands: [
+ { sequence: 5, request: SCROLL_TO_TOP_REQUEST },
+ { sequence: 2, request: SCROLL_TO_TOP_REQUEST },
+ { sequence: 9, request: SCROLL_TO_TOP_REQUEST },
+ ],
+ appliedSequence: 0,
+ });
+
+ expect(newScrollCommands.map(({ sequence }) => sequence)).toEqual([
+ 2, 5, 9,
+ ]);
+ });
+
+ it('should keep only the sequence and the raw request of a command', () => {
+ const request = { method: 'scrollBy', top: 'not validated here' };
+
+ const [newScrollCommand] = readNewScrollCommands({
+ scrollCommands: [
+ {
+ sequence: 1,
+ acknowledgedNativeEditSequence: 7,
+ request,
+ ignoredProperty: true,
+ },
+ ],
+ appliedSequence: 0,
+ });
+
+ expect(newScrollCommand).toStrictEqual({ sequence: 1, request });
+ expect(newScrollCommand.request).toBe(request);
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/resolveBlockScrollIntoViewDelta.test.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/resolveBlockScrollIntoViewDelta.test.ts
new file mode 100644
index 00000000000..d56a2e0d86c
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/resolveBlockScrollIntoViewDelta.test.ts
@@ -0,0 +1,29 @@
+import { SCROLL_INTO_VIEW_ALIGNMENTS } from '@/constants/ScrollIntoViewAlignments';
+import { resolveBlockScrollIntoViewDelta } from '@/host/scroll/utils/resolveBlockScrollIntoViewDelta';
+import { resolveScrollIntoViewDelta } from '@/host/scroll/utils/resolveScrollIntoViewDelta';
+
+const SCROLLPORT = { top: 100, bottom: 200 };
+const TARGET_BOX = { top: 180, bottom: 220 };
+
+describe('resolveBlockScrollIntoViewDelta', () => {
+ it.each(SCROLL_INTO_VIEW_ALIGNMENTS)(
+ 'should map top to start and bottom to end for %s alignment',
+ (alignment) => {
+ expect(
+ resolveBlockScrollIntoViewDelta({
+ targetBox: TARGET_BOX,
+ scrollport: SCROLLPORT,
+ alignment,
+ }),
+ ).toBe(
+ resolveScrollIntoViewDelta({
+ elementStart: TARGET_BOX.top,
+ elementEnd: TARGET_BOX.bottom,
+ scrollportStart: SCROLLPORT.top,
+ scrollportEnd: SCROLLPORT.bottom,
+ alignment,
+ }),
+ );
+ },
+ );
+});
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/resolveCssCalcExpressionInPixels.test.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/resolveCssCalcExpressionInPixels.test.ts
new file mode 100644
index 00000000000..493a3e36d40
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/resolveCssCalcExpressionInPixels.test.ts
@@ -0,0 +1,72 @@
+import { resolveCssCalcExpressionInPixels } from '@/host/scroll/utils/resolveCssCalcExpressionInPixels';
+
+describe('resolveCssCalcExpressionInPixels', () => {
+ it('should add a percentage resolved against the reference size to a pixel length', () => {
+ expect(
+ resolveCssCalcExpressionInPixels({
+ expression: '10% + 20px',
+ referenceSize: 200,
+ }),
+ ).toBe(40);
+ });
+
+ it('should apply multiplication before subtraction', () => {
+ expect(
+ resolveCssCalcExpressionInPixels({
+ expression: '100% - 2 * 8px',
+ referenceSize: 100,
+ }),
+ ).toBe(84);
+ });
+
+ it('should evaluate parenthesised sub-expressions and division', () => {
+ expect(
+ resolveCssCalcExpressionInPixels({
+ expression: '(50% + 10px) / 2',
+ referenceSize: 100,
+ }),
+ ).toBe(30);
+ });
+
+ it('should read negative and fractional pixel terms', () => {
+ expect(
+ resolveCssCalcExpressionInPixels({
+ expression: '-4.5px + 0.5px',
+ referenceSize: 100,
+ }),
+ ).toBe(-4);
+ });
+
+ it('should resolve to zero for a unit computed styles never leave unresolved', () => {
+ expect(
+ resolveCssCalcExpressionInPixels({
+ expression: '10em + 4px',
+ referenceSize: 100,
+ }),
+ ).toBe(0);
+ });
+
+ it('should resolve a malformed expression to zero', () => {
+ expect(
+ resolveCssCalcExpressionInPixels({
+ expression: '10px +',
+ referenceSize: 100,
+ }),
+ ).toBe(0);
+ expect(
+ resolveCssCalcExpressionInPixels({
+ expression: '(10px',
+ referenceSize: 100,
+ }),
+ ).toBe(0);
+ });
+
+ it('should resolve a division by zero to zero', () => {
+ expect(
+ resolveCssCalcExpressionInPixels({
+ expression: '10px / 0',
+ referenceSize: 100,
+ }),
+ ).toBe(0);
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/resolveElementScale.test.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/resolveElementScale.test.ts
new file mode 100644
index 00000000000..ae187a6e366
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/resolveElementScale.test.ts
@@ -0,0 +1,114 @@
+import { resolveElementScale } from '@/host/scroll/utils/resolveElementScale';
+
+const createElementWithSizes = ({
+ renderedWidth,
+ renderedHeight,
+ offsetWidth,
+ offsetHeight,
+}: {
+ renderedWidth: number;
+ renderedHeight: number;
+ offsetWidth: number;
+ offsetHeight: number;
+}) => {
+ const element = document.createElement('div');
+
+ element.getBoundingClientRect = () =>
+ new DOMRect(0, 0, renderedWidth, renderedHeight);
+ Object.defineProperty(element, 'offsetWidth', { value: offsetWidth });
+ Object.defineProperty(element, 'offsetHeight', { value: offsetHeight });
+
+ return element;
+};
+
+describe('resolveElementScale', () => {
+ it('should resolve the ratio of the rendered size to the layout size on each axis', () => {
+ expect(
+ resolveElementScale(
+ createElementWithSizes({
+ renderedWidth: 200,
+ renderedHeight: 50,
+ offsetWidth: 100,
+ offsetHeight: 100,
+ }),
+ ),
+ ).toEqual({ x: 2, y: 0.5 });
+ });
+
+ it('should resolve an unscaled element to one on each axis', () => {
+ expect(
+ resolveElementScale(
+ createElementWithSizes({
+ renderedWidth: 100,
+ renderedHeight: 40,
+ offsetWidth: 100,
+ offsetHeight: 40,
+ }),
+ ),
+ ).toEqual({ x: 1, y: 1 });
+ });
+
+ it.each([
+ {
+ reason: 'the layout size is zero',
+ sizes: {
+ renderedWidth: 200,
+ renderedHeight: 50,
+ offsetWidth: 0,
+ offsetHeight: 0,
+ },
+ },
+ {
+ reason: 'the layout size is negative',
+ sizes: {
+ renderedWidth: 200,
+ renderedHeight: 50,
+ offsetWidth: -100,
+ offsetHeight: -100,
+ },
+ },
+ {
+ reason: 'the rendered size is zero',
+ sizes: {
+ renderedWidth: 0,
+ renderedHeight: 0,
+ offsetWidth: 100,
+ offsetHeight: 100,
+ },
+ },
+ {
+ reason: 'the ratio is not finite',
+ sizes: {
+ renderedWidth: Number.POSITIVE_INFINITY,
+ renderedHeight: Number.NaN,
+ offsetWidth: 100,
+ offsetHeight: 100,
+ },
+ },
+ {
+ reason: 'the layout size is not a number',
+ sizes: {
+ renderedWidth: 200,
+ renderedHeight: 50,
+ offsetWidth: Number.NaN,
+ offsetHeight: Number.NaN,
+ },
+ },
+ ])('should fall back to one when $reason', ({ sizes }) => {
+ expect(resolveElementScale(createElementWithSizes(sizes))).toEqual({
+ x: 1,
+ y: 1,
+ });
+ });
+
+ it('should fall back to one when the element has no layout size', () => {
+ const svgElement = document.createElementNS(
+ 'http://www.w3.org/2000/svg',
+ 'svg',
+ );
+
+ svgElement.getBoundingClientRect = () => new DOMRect(0, 0, 200, 50);
+
+ expect(resolveElementScale(svgElement)).toEqual({ x: 1, y: 1 });
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/resolveInlineScrollIntoViewDelta.test.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/resolveInlineScrollIntoViewDelta.test.ts
new file mode 100644
index 00000000000..76a781b3b8e
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/resolveInlineScrollIntoViewDelta.test.ts
@@ -0,0 +1,189 @@
+import { SCROLL_INTO_VIEW_ALIGNMENTS } from '@/constants/ScrollIntoViewAlignments';
+import { type ScrollBox } from '@/host/scroll/types/ScrollBox';
+import { resolveInlineScrollIntoViewDelta } from '@/host/scroll/utils/resolveInlineScrollIntoViewDelta';
+import { resolveScrollIntoViewDelta } from '@/host/scroll/utils/resolveScrollIntoViewDelta';
+import { type ScrollIntoViewAlignment } from '@/types/ScrollIntoViewAlignment';
+
+const SCROLLPORT: ScrollBox = { top: 0, right: 200, bottom: 100, left: 100 };
+
+const createTargetBox = ({
+ left,
+ right,
+}: {
+ left: number;
+ right: number;
+}): ScrollBox => ({ top: 10, right, bottom: 20, left });
+
+const resolveDeltaInScrollport = ({
+ left,
+ right,
+ alignment,
+ isRightToLeft,
+}: {
+ left: number;
+ right: number;
+ alignment: ScrollIntoViewAlignment;
+ isRightToLeft: boolean;
+}) =>
+ resolveInlineScrollIntoViewDelta({
+ targetBox: createTargetBox({ left, right }),
+ scrollport: SCROLLPORT,
+ alignment,
+ isRightToLeft,
+ });
+
+describe('resolveInlineScrollIntoViewDelta', () => {
+ it.each(SCROLL_INTO_VIEW_ALIGNMENTS)(
+ 'should map left to start and right to end for %s alignment in left to right layouts',
+ (alignment) => {
+ const targetBox = createTargetBox({ left: 180, right: 220 });
+
+ expect(
+ resolveInlineScrollIntoViewDelta({
+ targetBox,
+ scrollport: SCROLLPORT,
+ alignment,
+ isRightToLeft: false,
+ }),
+ ).toBe(
+ resolveScrollIntoViewDelta({
+ elementStart: targetBox.left,
+ elementEnd: targetBox.right,
+ scrollportStart: SCROLLPORT.left,
+ scrollportEnd: SCROLLPORT.right,
+ alignment,
+ }),
+ );
+ },
+ );
+
+ describe('right to left', () => {
+ it('should align the right edges for start alignment', () => {
+ expect(
+ resolveDeltaInScrollport({
+ left: 150,
+ right: 170,
+ alignment: 'start',
+ isRightToLeft: true,
+ }),
+ ).toBe(-30);
+ });
+
+ it('should align the left edges for end alignment', () => {
+ expect(
+ resolveDeltaInScrollport({
+ left: 150,
+ right: 170,
+ alignment: 'end',
+ isRightToLeft: true,
+ }),
+ ).toBe(50);
+ });
+
+ it('should increase the scroll offset for start alignment when the target is past the right edge', () => {
+ expect(
+ resolveDeltaInScrollport({
+ left: 220,
+ right: 240,
+ alignment: 'start',
+ isRightToLeft: true,
+ }),
+ ).toBe(40);
+ });
+
+ it('should decrease the scroll offset for end alignment when the target is past the left edge', () => {
+ expect(
+ resolveDeltaInScrollport({
+ left: 40,
+ right: 60,
+ alignment: 'end',
+ isRightToLeft: true,
+ }),
+ ).toBe(-60);
+ });
+
+ it('should align the centers for center alignment', () => {
+ expect(
+ resolveDeltaInScrollport({
+ left: 150,
+ right: 170,
+ alignment: 'center',
+ isRightToLeft: true,
+ }),
+ ).toBe(10);
+ });
+
+ it('should not scroll for nearest alignment when the target is fully visible', () => {
+ expect(
+ resolveDeltaInScrollport({
+ left: 150,
+ right: 170,
+ alignment: 'nearest',
+ isRightToLeft: true,
+ }),
+ ).toBeCloseTo(0);
+ });
+
+ it('should not scroll for nearest alignment when the target straddles both edges', () => {
+ expect(
+ resolveDeltaInScrollport({
+ left: 50,
+ right: 250,
+ alignment: 'nearest',
+ isRightToLeft: true,
+ }),
+ ).toBeCloseTo(0);
+ });
+
+ it('should scroll left for nearest alignment when the target overflows the left edge', () => {
+ expect(
+ resolveDeltaInScrollport({
+ left: 40,
+ right: 60,
+ alignment: 'nearest',
+ isRightToLeft: true,
+ }),
+ ).toBe(-60);
+ });
+
+ it('should scroll right for nearest alignment when the target overflows the right edge', () => {
+ expect(
+ resolveDeltaInScrollport({
+ left: 180,
+ right: 220,
+ alignment: 'nearest',
+ isRightToLeft: true,
+ }),
+ ).toBe(20);
+ });
+
+ it('should resolve the same physical nearest delta as left to right layouts', () => {
+ const targetHorizontalExtents = [
+ { left: 80, right: 120 },
+ { left: 180, right: 220 },
+ { left: 0, right: 150 },
+ { left: 150, right: 300 },
+ { left: 50, right: 150 },
+ { left: 150, right: 250 },
+ ];
+
+ for (const { left, right } of targetHorizontalExtents) {
+ expect(
+ resolveDeltaInScrollport({
+ left,
+ right,
+ alignment: 'nearest',
+ isRightToLeft: true,
+ }),
+ ).toBe(
+ resolveDeltaInScrollport({
+ left,
+ right,
+ alignment: 'nearest',
+ isRightToLeft: false,
+ }),
+ );
+ }
+ });
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/resolveScrollIntoViewDelta.test.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/resolveScrollIntoViewDelta.test.ts
new file mode 100644
index 00000000000..82804a333cc
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/resolveScrollIntoViewDelta.test.ts
@@ -0,0 +1,202 @@
+import { resolveScrollIntoViewDelta } from '@/host/scroll/utils/resolveScrollIntoViewDelta';
+import { type ScrollIntoViewAlignment } from '@/types/ScrollIntoViewAlignment';
+
+const SCROLLPORT_START = 100;
+const SCROLLPORT_END = 200;
+
+const resolveDeltaInScrollport = ({
+ elementStart,
+ elementEnd,
+ alignment,
+}: {
+ elementStart: number;
+ elementEnd: number;
+ alignment: ScrollIntoViewAlignment;
+}) =>
+ resolveScrollIntoViewDelta({
+ elementStart,
+ elementEnd,
+ scrollportStart: SCROLLPORT_START,
+ scrollportEnd: SCROLLPORT_END,
+ alignment,
+ });
+
+describe('resolveScrollIntoViewDelta', () => {
+ describe('start alignment', () => {
+ it('should align the element start with the scrollport start', () => {
+ expect(
+ resolveDeltaInScrollport({
+ elementStart: 150,
+ elementEnd: 170,
+ alignment: 'start',
+ }),
+ ).toBe(50);
+ });
+
+ it('should return a negative delta when the element starts before the scrollport', () => {
+ expect(
+ resolveDeltaInScrollport({
+ elementStart: 40,
+ elementEnd: 60,
+ alignment: 'start',
+ }),
+ ).toBe(-60);
+ });
+ });
+
+ describe('end alignment', () => {
+ it('should align the element end with the scrollport end', () => {
+ expect(
+ resolveDeltaInScrollport({
+ elementStart: 150,
+ elementEnd: 170,
+ alignment: 'end',
+ }),
+ ).toBe(-30);
+ });
+
+ it('should return a positive delta when the element ends after the scrollport', () => {
+ expect(
+ resolveDeltaInScrollport({
+ elementStart: 230,
+ elementEnd: 260,
+ alignment: 'end',
+ }),
+ ).toBe(60);
+ });
+ });
+
+ describe('center alignment', () => {
+ it('should align the element center with the scrollport center', () => {
+ expect(
+ resolveDeltaInScrollport({
+ elementStart: 150,
+ elementEnd: 170,
+ alignment: 'center',
+ }),
+ ).toBe(10);
+ });
+
+ it('should center an element that is larger than the scrollport', () => {
+ expect(
+ resolveDeltaInScrollport({
+ elementStart: 0,
+ elementEnd: 400,
+ alignment: 'center',
+ }),
+ ).toBe(50);
+ });
+ });
+
+ describe('nearest alignment', () => {
+ it('should not scroll when the element is fully inside the scrollport', () => {
+ expect(
+ resolveDeltaInScrollport({
+ elementStart: 120,
+ elementEnd: 180,
+ alignment: 'nearest',
+ }),
+ ).toBe(0);
+ });
+
+ it('should not scroll when the element edges touch the scrollport edges', () => {
+ expect(
+ resolveDeltaInScrollport({
+ elementStart: SCROLLPORT_START,
+ elementEnd: SCROLLPORT_END,
+ alignment: 'nearest',
+ }),
+ ).toBe(0);
+ });
+
+ it('should not scroll when the element straddles both scrollport edges', () => {
+ expect(
+ resolveDeltaInScrollport({
+ elementStart: 50,
+ elementEnd: 250,
+ alignment: 'nearest',
+ }),
+ ).toBe(0);
+ });
+
+ it('should align the start when a smaller element overflows the scrollport start', () => {
+ expect(
+ resolveDeltaInScrollport({
+ elementStart: 80,
+ elementEnd: 120,
+ alignment: 'nearest',
+ }),
+ ).toBe(-20);
+ });
+
+ it('should align the start when a smaller element is entirely before the scrollport', () => {
+ expect(
+ resolveDeltaInScrollport({
+ elementStart: 10,
+ elementEnd: 30,
+ alignment: 'nearest',
+ }),
+ ).toBe(-90);
+ });
+
+ it('should align the end when a smaller element overflows the scrollport end', () => {
+ expect(
+ resolveDeltaInScrollport({
+ elementStart: 180,
+ elementEnd: 220,
+ alignment: 'nearest',
+ }),
+ ).toBe(20);
+ });
+
+ it('should align the end when a smaller element is entirely after the scrollport', () => {
+ expect(
+ resolveDeltaInScrollport({
+ elementStart: 300,
+ elementEnd: 320,
+ alignment: 'nearest',
+ }),
+ ).toBe(120);
+ });
+
+ it('should align the end when a larger element overflows the scrollport start', () => {
+ expect(
+ resolveDeltaInScrollport({
+ elementStart: 0,
+ elementEnd: 150,
+ alignment: 'nearest',
+ }),
+ ).toBe(-50);
+ });
+
+ it('should align the start when a larger element overflows the scrollport end', () => {
+ expect(
+ resolveDeltaInScrollport({
+ elementStart: 150,
+ elementEnd: 300,
+ alignment: 'nearest',
+ }),
+ ).toBe(50);
+ });
+
+ it('should bring an element of the scrollport size fully into view when it overflows the start', () => {
+ expect(
+ resolveDeltaInScrollport({
+ elementStart: 50,
+ elementEnd: 150,
+ alignment: 'nearest',
+ }),
+ ).toBe(-50);
+ });
+
+ it('should bring an element of the scrollport size fully into view when it overflows the end', () => {
+ expect(
+ resolveDeltaInScrollport({
+ elementStart: 150,
+ elementEnd: 250,
+ alignment: 'nearest',
+ }),
+ ).toBe(50);
+ });
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/resolveScrollLengthInPixels.test.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/resolveScrollLengthInPixels.test.ts
new file mode 100644
index 00000000000..b3e996874b8
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/resolveScrollLengthInPixels.test.ts
@@ -0,0 +1,60 @@
+import { resolveScrollLengthInPixels } from '@/host/scroll/utils/resolveScrollLengthInPixels';
+
+describe('resolveScrollLengthInPixels', () => {
+ it('should read a pixel length', () => {
+ expect(
+ resolveScrollLengthInPixels({ length: '12px', referenceSize: 300 }),
+ ).toBe(12);
+ });
+
+ it('should read a fractional pixel length', () => {
+ expect(
+ resolveScrollLengthInPixels({ length: '12.5px', referenceSize: 300 }),
+ ).toBe(12.5);
+ });
+
+ it('should read a negative pixel length', () => {
+ expect(
+ resolveScrollLengthInPixels({ length: '-4px', referenceSize: 300 }),
+ ).toBe(-4);
+ });
+
+ it('should resolve a percentage against the reference size', () => {
+ expect(
+ resolveScrollLengthInPixels({ length: '25%', referenceSize: 200 }),
+ ).toBe(50);
+ });
+
+ it('should resolve a percentage surrounded by whitespace against the reference size', () => {
+ expect(
+ resolveScrollLengthInPixels({ length: ' 10% ', referenceSize: 200 }),
+ ).toBe(20);
+ });
+
+ it('should resolve a percentage to zero when the reference size is zero', () => {
+ expect(
+ resolveScrollLengthInPixels({ length: '50%', referenceSize: 0 }),
+ ).toBe(0);
+ });
+
+ it('should resolve a calc() length mixing a percentage and pixels', () => {
+ expect(
+ resolveScrollLengthInPixels({
+ length: 'calc(10% + 20px)',
+ referenceSize: 200,
+ }),
+ ).toBe(40);
+ });
+
+ it('should resolve auto to zero', () => {
+ expect(
+ resolveScrollLengthInPixels({ length: 'auto', referenceSize: 200 }),
+ ).toBe(0);
+ });
+
+ it('should resolve an empty length to zero', () => {
+ expect(
+ resolveScrollLengthInPixels({ length: '', referenceSize: 200 }),
+ ).toBe(0);
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/resolveScrollportBox.test.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/resolveScrollportBox.test.ts
new file mode 100644
index 00000000000..d36466d4052
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/resolveScrollportBox.test.ts
@@ -0,0 +1,120 @@
+import { type ElementScale } from '@/host/scroll/types/ElementScale';
+import { resolveScrollportBox } from '@/host/scroll/utils/resolveScrollportBox';
+
+type ScrollContainerGeometry = Pick<
+ Element,
+ | 'getBoundingClientRect'
+ | 'clientLeft'
+ | 'clientTop'
+ | 'clientWidth'
+ | 'clientHeight'
+>;
+
+type ScrollPaddingStyle = Pick<
+ CSSStyleDeclaration,
+ | 'scrollPaddingTop'
+ | 'scrollPaddingRight'
+ | 'scrollPaddingBottom'
+ | 'scrollPaddingLeft'
+>;
+
+const UNSCALED: ElementScale = { x: 1, y: 1 };
+
+const createUniformScrollPaddingStyle = (
+ scrollPadding: string,
+): ScrollPaddingStyle => ({
+ scrollPaddingTop: scrollPadding,
+ scrollPaddingRight: scrollPadding,
+ scrollPaddingBottom: scrollPadding,
+ scrollPaddingLeft: scrollPadding,
+});
+
+const SCROLL_CONTAINER: ScrollContainerGeometry = {
+ getBoundingClientRect: () => new DOMRect(10, 20, 104, 56),
+ clientLeft: 2,
+ clientTop: 3,
+ clientWidth: 100,
+ clientHeight: 50,
+};
+
+describe('resolveScrollportBox', () => {
+ it('should offset the scrollport by the client offsets and size it by the client size', () => {
+ expect(
+ resolveScrollportBox({
+ scrollContainer: SCROLL_CONTAINER,
+ scrollContainerStyle: createUniformScrollPaddingStyle('0px'),
+ scale: UNSCALED,
+ }),
+ ).toEqual({ top: 23, right: 112, bottom: 73, left: 12 });
+ });
+
+ it('should treat auto scroll padding as zero', () => {
+ expect(
+ resolveScrollportBox({
+ scrollContainer: SCROLL_CONTAINER,
+ scrollContainerStyle: createUniformScrollPaddingStyle('auto'),
+ scale: UNSCALED,
+ }),
+ ).toEqual({ top: 23, right: 112, bottom: 73, left: 12 });
+ });
+
+ it('should shrink the scrollport by pixel scroll padding on each side', () => {
+ expect(
+ resolveScrollportBox({
+ scrollContainer: SCROLL_CONTAINER,
+ scrollContainerStyle: {
+ scrollPaddingTop: '5px',
+ scrollPaddingRight: '6px',
+ scrollPaddingBottom: '7px',
+ scrollPaddingLeft: '8px',
+ },
+ scale: UNSCALED,
+ }),
+ ).toEqual({ top: 28, right: 106, bottom: 66, left: 20 });
+ });
+
+ it('should resolve percentage scroll padding against the client size of each axis', () => {
+ expect(
+ resolveScrollportBox({
+ scrollContainer: SCROLL_CONTAINER,
+ scrollContainerStyle: {
+ scrollPaddingTop: '10%',
+ scrollPaddingRight: '20%',
+ scrollPaddingBottom: '20%',
+ scrollPaddingLeft: '10%',
+ },
+ scale: UNSCALED,
+ }),
+ ).toEqual({ top: 28, right: 92, bottom: 63, left: 22 });
+ });
+
+ it('should scale the client offsets and the client size', () => {
+ expect(
+ resolveScrollportBox({
+ scrollContainer: SCROLL_CONTAINER,
+ scrollContainerStyle: createUniformScrollPaddingStyle('0px'),
+ scale: { x: 2, y: 0.5 },
+ }),
+ ).toEqual({ top: 21.5, right: 214, bottom: 46.5, left: 14 });
+ });
+
+ it('should scale pixel scroll padding', () => {
+ expect(
+ resolveScrollportBox({
+ scrollContainer: SCROLL_CONTAINER,
+ scrollContainerStyle: createUniformScrollPaddingStyle('4px'),
+ scale: { x: 2, y: 0.5 },
+ }),
+ ).toEqual({ top: 23.5, right: 206, bottom: 44.5, left: 22 });
+ });
+
+ it('should scale percentage scroll padding resolved against the unscaled client size', () => {
+ expect(
+ resolveScrollportBox({
+ scrollContainer: SCROLL_CONTAINER,
+ scrollContainerStyle: createUniformScrollPaddingStyle('10%'),
+ scale: { x: 2, y: 0.5 },
+ }),
+ ).toEqual({ top: 24, right: 194, bottom: 44, left: 34 });
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/scrollOwnedAncestorsIntoView.test.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/scrollOwnedAncestorsIntoView.test.ts
new file mode 100644
index 00000000000..51395ca4672
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/__tests__/scrollOwnedAncestorsIntoView.test.ts
@@ -0,0 +1,561 @@
+import { scrollOwnedAncestorsIntoView } from '@/host/scroll/utils/scrollOwnedAncestorsIntoView';
+
+type ScrollComputedStyle = Pick<
+ CSSStyleDeclaration,
+ | 'overflowX'
+ | 'overflowY'
+ | 'direction'
+ | 'position'
+ | 'scrollPaddingTop'
+ | 'scrollPaddingRight'
+ | 'scrollPaddingBottom'
+ | 'scrollPaddingLeft'
+ | 'scrollMarginTop'
+ | 'scrollMarginRight'
+ | 'scrollMarginBottom'
+ | 'scrollMarginLeft'
+>;
+
+type ElementLayout = Pick<
+ HTMLElement,
+ | 'clientWidth'
+ | 'clientHeight'
+ | 'scrollWidth'
+ | 'scrollHeight'
+ | 'scrollTop'
+ | 'scrollLeft'
+ | 'offsetWidth'
+ | 'offsetHeight'
+>;
+
+const DEFAULT_COMPUTED_STYLE: ScrollComputedStyle = {
+ overflowX: 'visible',
+ overflowY: 'visible',
+ direction: 'ltr',
+ position: 'static',
+ scrollPaddingTop: 'auto',
+ scrollPaddingRight: 'auto',
+ scrollPaddingBottom: 'auto',
+ scrollPaddingLeft: 'auto',
+ scrollMarginTop: '0px',
+ scrollMarginRight: '0px',
+ scrollMarginBottom: '0px',
+ scrollMarginLeft: '0px',
+};
+
+const VERTICALLY_SCROLLABLE_STYLE: Partial<ScrollComputedStyle> = {
+ overflowY: 'auto',
+};
+
+const VERTICALLY_SCROLLABLE_LAYOUT: Partial<ElementLayout> = {
+ clientWidth: 100,
+ clientHeight: 100,
+ scrollWidth: 100,
+ scrollHeight: 500,
+};
+
+const createRectList = (rects: DOMRect[]): DOMRectList =>
+ Object.assign([...rects], {
+ item: (index: number) => rects[index] ?? null,
+ });
+
+const stubElementGeometry = ({
+ element,
+ rect,
+ layout = {},
+}: {
+ element: HTMLElement;
+ rect: DOMRect;
+ layout?: Partial<ElementLayout>;
+}) => {
+ element.getBoundingClientRect = () => rect;
+ element.getClientRects = () => createRectList([rect]);
+
+ for (const [propertyName, value] of Object.entries(layout)) {
+ Object.defineProperty(element, propertyName, { value });
+ }
+};
+
+const stubScrollTo = (element: HTMLElement) => {
+ const scrollTo = jest.fn();
+
+ element.scrollTo = scrollTo;
+
+ return scrollTo;
+};
+
+const stubComputedStyles = (
+ computedStylesByElement: Map<Element, Partial<ScrollComputedStyle>>,
+) => {
+ const readComputedStyle = window.getComputedStyle.bind(window);
+
+ return jest
+ .spyOn(window, 'getComputedStyle')
+ .mockImplementation((element) => {
+ const computedStyle = readComputedStyle(element);
+ const stubbedStyle = {
+ ...DEFAULT_COMPUTED_STYLE,
+ ...computedStylesByElement.get(element),
+ };
+
+ for (const [propertyName, value] of Object.entries(stubbedStyle)) {
+ Object.defineProperty(computedStyle, propertyName, { value });
+ }
+
+ return computedStyle;
+ });
+};
+
+const createNestedElements = () => {
+ const root = document.createElement('div');
+ const outer = document.createElement('div');
+ const inner = document.createElement('div');
+ const target = document.createElement('div');
+
+ root.append(outer);
+ outer.append(inner);
+ inner.append(target);
+
+ return {
+ root,
+ outer,
+ inner,
+ target,
+ rootScrollTo: stubScrollTo(root),
+ outerScrollTo: stubScrollTo(outer),
+ innerScrollTo: stubScrollTo(inner),
+ };
+};
+
+const isAnyNodeOwned = () => true;
+
+describe('scrollOwnedAncestorsIntoView', () => {
+ afterEach(() => {
+ jest.restoreAllMocks();
+ });
+
+ it('should return no scroll container and scroll nothing when the target has no client rects', () => {
+ const { outer, inner, target, outerScrollTo, innerScrollTo } =
+ createNestedElements();
+
+ stubElementGeometry({
+ element: outer,
+ rect: new DOMRect(0, 0, 100, 100),
+ layout: VERTICALLY_SCROLLABLE_LAYOUT,
+ });
+ stubElementGeometry({
+ element: inner,
+ rect: new DOMRect(0, 0, 100, 100),
+ layout: VERTICALLY_SCROLLABLE_LAYOUT,
+ });
+ target.getBoundingClientRect = () => new DOMRect(0, 300, 100, 20);
+ target.getClientRects = () => createRectList([]);
+ const getComputedStyleSpy = stubComputedStyles(
+ new Map([
+ [outer, VERTICALLY_SCROLLABLE_STYLE],
+ [inner, VERTICALLY_SCROLLABLE_STYLE],
+ ]),
+ );
+
+ expect(
+ scrollOwnedAncestorsIntoView({
+ target,
+ block: 'nearest',
+ inline: 'nearest',
+ isOwnedNode: isAnyNodeOwned,
+ }),
+ ).toEqual([]);
+ expect(innerScrollTo).not.toHaveBeenCalled();
+ expect(outerScrollTo).not.toHaveBeenCalled();
+ expect(getComputedStyleSpy).not.toHaveBeenCalled();
+ });
+
+ it('should scroll the innermost owned scroll container first and return every scroll container walked', () => {
+ const { outer, inner, target, outerScrollTo, innerScrollTo } =
+ createNestedElements();
+
+ stubElementGeometry({
+ element: outer,
+ rect: new DOMRect(0, 0, 100, 100),
+ layout: { ...VERTICALLY_SCROLLABLE_LAYOUT, scrollTop: 40 },
+ });
+ stubElementGeometry({
+ element: inner,
+ rect: new DOMRect(0, 50, 100, 100),
+ layout: { ...VERTICALLY_SCROLLABLE_LAYOUT, scrollTop: 10 },
+ });
+ stubElementGeometry({
+ element: target,
+ rect: new DOMRect(0, 300, 100, 20),
+ });
+ stubComputedStyles(
+ new Map([
+ [outer, VERTICALLY_SCROLLABLE_STYLE],
+ [inner, VERTICALLY_SCROLLABLE_STYLE],
+ ]),
+ );
+
+ const scrollContainers = scrollOwnedAncestorsIntoView({
+ target,
+ block: 'start',
+ inline: 'nearest',
+ isOwnedNode: isAnyNodeOwned,
+ });
+
+ expect(scrollContainers).toEqual([inner, outer]);
+ expect(innerScrollTo).toHaveBeenCalledTimes(1);
+ expect(innerScrollTo).toHaveBeenCalledWith({
+ top: 260,
+ left: 0,
+ behavior: 'instant',
+ });
+ expect(outerScrollTo).toHaveBeenCalledTimes(1);
+ expect(outerScrollTo).toHaveBeenCalledWith({
+ top: 340,
+ left: 0,
+ behavior: 'instant',
+ });
+ expect(innerScrollTo.mock.invocationCallOrder[0]).toBeLessThan(
+ outerScrollTo.mock.invocationCallOrder[0],
+ );
+ });
+
+ it('should not scroll any ancestor of a fixed-position target', () => {
+ const { inner, target, innerScrollTo } = createNestedElements();
+
+ stubElementGeometry({
+ element: inner,
+ rect: new DOMRect(0, 0, 100, 100),
+ layout: VERTICALLY_SCROLLABLE_LAYOUT,
+ });
+ stubElementGeometry({
+ element: target,
+ rect: new DOMRect(0, 300, 100, 20),
+ });
+ stubComputedStyles(
+ new Map<Element, Partial<ScrollComputedStyle>>([
+ [inner, VERTICALLY_SCROLLABLE_STYLE],
+ [target, { position: 'fixed' }],
+ ]),
+ );
+
+ expect(
+ scrollOwnedAncestorsIntoView({
+ target,
+ block: 'start',
+ inline: 'nearest',
+ isOwnedNode: isAnyNodeOwned,
+ }),
+ ).toEqual([]);
+ expect(innerScrollTo).not.toHaveBeenCalled();
+ });
+
+ it('should scroll a fixed-position scroll container and stop walking above it', () => {
+ const { outer, inner, target, outerScrollTo, innerScrollTo } =
+ createNestedElements();
+
+ stubElementGeometry({
+ element: outer,
+ rect: new DOMRect(0, 0, 100, 100),
+ layout: { ...VERTICALLY_SCROLLABLE_LAYOUT, scrollTop: 40 },
+ });
+ stubElementGeometry({
+ element: inner,
+ rect: new DOMRect(0, 50, 100, 100),
+ layout: { ...VERTICALLY_SCROLLABLE_LAYOUT, scrollTop: 10 },
+ });
+ stubElementGeometry({
+ element: target,
+ rect: new DOMRect(0, 300, 100, 20),
+ });
+ stubComputedStyles(
+ new Map<Element, Partial<ScrollComputedStyle>>([
+ [outer, VERTICALLY_SCROLLABLE_STYLE],
+ [inner, { ...VERTICALLY_SCROLLABLE_STYLE, position: 'fixed' }],
+ ]),
+ );
+
+ expect(
+ scrollOwnedAncestorsIntoView({
+ target,
+ block: 'start',
+ inline: 'nearest',
+ isOwnedNode: isAnyNodeOwned,
+ }),
+ ).toEqual([inner]);
+ expect(innerScrollTo).toHaveBeenCalledWith({
+ top: 260,
+ left: 0,
+ behavior: 'instant',
+ });
+ expect(outerScrollTo).not.toHaveBeenCalled();
+ });
+
+ it('should return a scroll container without scrolling it when the target is already visible in it', () => {
+ const { inner, target, innerScrollTo } = createNestedElements();
+
+ stubElementGeometry({
+ element: inner,
+ rect: new DOMRect(0, 0, 100, 100),
+ layout: VERTICALLY_SCROLLABLE_LAYOUT,
+ });
+ stubElementGeometry({
+ element: target,
+ rect: new DOMRect(0, 40, 100, 20),
+ });
+ stubComputedStyles(new Map([[inner, VERTICALLY_SCROLLABLE_STYLE]]));
+
+ expect(
+ scrollOwnedAncestorsIntoView({
+ target,
+ block: 'nearest',
+ inline: 'nearest',
+ isOwnedNode: isAnyNodeOwned,
+ }),
+ ).toEqual([inner]);
+ expect(innerScrollTo).not.toHaveBeenCalled();
+ });
+
+ it('should skip ancestors that are not scroll containers without scrolling them', () => {
+ const { outer, inner, target, outerScrollTo, innerScrollTo } =
+ createNestedElements();
+
+ stubElementGeometry({
+ element: outer,
+ rect: new DOMRect(0, 0, 100, 100),
+ layout: VERTICALLY_SCROLLABLE_LAYOUT,
+ });
+ stubElementGeometry({
+ element: inner,
+ rect: new DOMRect(0, 0, 100, 100),
+ layout: VERTICALLY_SCROLLABLE_LAYOUT,
+ });
+ stubElementGeometry({
+ element: target,
+ rect: new DOMRect(0, 300, 100, 20),
+ });
+ stubComputedStyles(
+ new Map<Element, Partial<ScrollComputedStyle>>([
+ [outer, VERTICALLY_SCROLLABLE_STYLE],
+ [inner, { overflowX: 'visible', overflowY: 'visible' }],
+ ]),
+ );
+
+ const scrollContainers = scrollOwnedAncestorsIntoView({
+ target,
+ block: 'nearest',
+ inline: 'nearest',
+ isOwnedNode: isAnyNodeOwned,
+ });
+
+ expect(scrollContainers).toEqual([outer]);
+ expect(innerScrollTo).not.toHaveBeenCalled();
+ expect(outerScrollTo).toHaveBeenCalledWith({
+ top: 220,
+ left: 0,
+ behavior: 'instant',
+ });
+ });
+
+ it('should skip an ancestor with scrollable overflow whose content fits', () => {
+ const { outer, inner, target, outerScrollTo, innerScrollTo } =
+ createNestedElements();
+
+ stubElementGeometry({
+ element: outer,
+ rect: new DOMRect(0, 0, 100, 100),
+ layout: VERTICALLY_SCROLLABLE_LAYOUT,
+ });
+ stubElementGeometry({
+ element: inner,
+ rect: new DOMRect(0, 0, 100, 100),
+ layout: {
+ clientWidth: 100,
+ clientHeight: 100,
+ scrollWidth: 100,
+ scrollHeight: 100,
+ },
+ });
+ stubElementGeometry({
+ element: target,
+ rect: new DOMRect(0, 300, 100, 20),
+ });
+ stubComputedStyles(
+ new Map([
+ [outer, VERTICALLY_SCROLLABLE_STYLE],
+ [inner, VERTICALLY_SCROLLABLE_STYLE],
+ ]),
+ );
+
+ expect(
+ scrollOwnedAncestorsIntoView({
+ target,
+ block: 'nearest',
+ inline: 'nearest',
+ isOwnedNode: isAnyNodeOwned,
+ }),
+ ).toEqual([outer]);
+ expect(innerScrollTo).not.toHaveBeenCalled();
+ expect(outerScrollTo).toHaveBeenCalledTimes(1);
+ });
+
+ it('should stop at the first ancestor rejected by isOwnedNode without touching it or anything above it', () => {
+ const {
+ root,
+ outer,
+ inner,
+ target,
+ rootScrollTo,
+ outerScrollTo,
+ innerScrollTo,
+ } = createNestedElements();
+
+ for (const scrollContainer of [root, outer, inner]) {
+ stubElementGeometry({
+ element: scrollContainer,
+ rect: new DOMRect(0, 0, 100, 100),
+ layout: VERTICALLY_SCROLLABLE_LAYOUT,
+ });
+ }
+ stubElementGeometry({
+ element: target,
+ rect: new DOMRect(0, 300, 100, 20),
+ });
+ const getComputedStyleSpy = stubComputedStyles(
+ new Map([
+ [root, VERTICALLY_SCROLLABLE_STYLE],
+ [outer, VERTICALLY_SCROLLABLE_STYLE],
+ [inner, VERTICALLY_SCROLLABLE_STYLE],
+ ]),
+ );
+ const isOwnedNode = jest.fn((node: Element) => node !== outer);
+
+ const scrollContainers = scrollOwnedAncestorsIntoView({
+ target,
+ block: 'nearest',
+ inline: 'nearest',
+ isOwnedNode,
+ });
+
+ expect(scrollContainers).toEqual([inner]);
+ expect(innerScrollTo).toHaveBeenCalledTimes(1);
+ expect(outerScrollTo).not.toHaveBeenCalled();
+ expect(rootScrollTo).not.toHaveBeenCalled();
+ expect(isOwnedNode).not.toHaveBeenCalledWith(root);
+ expect(getComputedStyleSpy).not.toHaveBeenCalledWith(outer);
+ expect(getComputedStyleSpy).not.toHaveBeenCalledWith(root);
+ });
+
+ it('should scroll a right to left container to a negative scroll left for nearest inline alignment', () => {
+ const { inner, target, innerScrollTo } = createNestedElements();
+
+ stubElementGeometry({
+ element: inner,
+ rect: new DOMRect(100, 0, 100, 100),
+ layout: {
+ clientWidth: 100,
+ clientHeight: 100,
+ scrollWidth: 300,
+ scrollHeight: 100,
+ scrollLeft: 0,
+ },
+ });
+ stubElementGeometry({
+ element: target,
+ rect: new DOMRect(40, 40, 20, 20),
+ });
+ stubComputedStyles(
+ new Map<Element, Partial<ScrollComputedStyle>>([
+ [inner, { overflowX: 'auto', direction: 'rtl' }],
+ ]),
+ );
+
+ expect(
+ scrollOwnedAncestorsIntoView({
+ target,
+ block: 'nearest',
+ inline: 'nearest',
+ isOwnedNode: isAnyNodeOwned,
+ }),
+ ).toEqual([inner]);
+ expect(innerScrollTo).toHaveBeenCalledWith({
+ top: 0,
+ left: -60,
+ behavior: 'instant',
+ });
+ });
+
+ it('should divide the scroll delta by the scroll container scale', () => {
+ const { inner, target, innerScrollTo } = createNestedElements();
+
+ stubElementGeometry({
+ element: inner,
+ rect: new DOMRect(0, 0, 200, 100),
+ layout: {
+ clientWidth: 100,
+ clientHeight: 50,
+ scrollWidth: 400,
+ scrollHeight: 500,
+ scrollTop: 10,
+ scrollLeft: 5,
+ offsetWidth: 100,
+ offsetHeight: 50,
+ },
+ });
+ stubElementGeometry({
+ element: target,
+ rect: new DOMRect(300, 300, 20, 20),
+ });
+ stubComputedStyles(
+ new Map<Element, Partial<ScrollComputedStyle>>([
+ [inner, { overflowX: 'auto', overflowY: 'auto' }],
+ ]),
+ );
+
+ scrollOwnedAncestorsIntoView({
+ target,
+ block: 'start',
+ inline: 'start',
+ isOwnedNode: isAnyNodeOwned,
+ });
+
+ expect(innerScrollTo).toHaveBeenCalledWith({
+ top: 160,
+ left: 155,
+ behavior: 'instant',
+ });
+ });
+
+ it('should honour the container scroll padding and the target scroll margin', () => {
+ const { inner, target, innerScrollTo } = createNestedElements();
+
+ stubElementGeometry({
+ element: inner,
+ rect: new DOMRect(0, 0, 100, 100),
+ layout: VERTICALLY_SCROLLABLE_LAYOUT,
+ });
+ stubElementGeometry({
+ element: target,
+ rect: new DOMRect(0, 300, 100, 20),
+ });
+ stubComputedStyles(
+ new Map<Element, Partial<ScrollComputedStyle>>([
+ [inner, { overflowY: 'auto', scrollPaddingTop: '10px' }],
+ [target, { scrollMarginTop: '5px' }],
+ ]),
+ );
+
+ scrollOwnedAncestorsIntoView({
+ target,
+ block: 'start',
+ inline: 'nearest',
+ isOwnedNode: isAnyNodeOwned,
+ });
+
+ expect(innerScrollTo).toHaveBeenCalledWith({
+ top: 285,
+ left: 0,
+ behavior: 'instant',
+ });
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/applyScrollRequest.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/applyScrollRequest.ts
new file mode 100644
index 00000000000..f865cec2545
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/applyScrollRequest.ts
@@ -0,0 +1,31 @@
+import { isDefined } from 'twenty-shared/utils';
+
+import { scrollOwnedAncestorsIntoView } from '@/host/scroll/utils/scrollOwnedAncestorsIntoView';
+import { type ScrollRequest } from '@/types/ScrollRequest';
+
+export const applyScrollRequest = ({
+ node,
+ request,
+ isOwnedNode,
+}: {
+ node: Element;
+ request: ScrollRequest;
+ isOwnedNode: (node: Element) => boolean;
+}): Element[] => {
+ if (request.method === 'scrollIntoView') {
+ return scrollOwnedAncestorsIntoView({
+ target: node,
+ block: request.block,
+ inline: request.inline,
+ isOwnedNode,
+ });
+ }
+
+ node.scrollTo({
+ ...(isDefined(request.top) && { top: request.top }),
+ ...(isDefined(request.left) && { left: request.left }),
+ behavior: 'instant',
+ });
+
+ return [node];
+};
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/createHostScrollController.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/createHostScrollController.ts
new file mode 100644
index 00000000000..f2547265a38
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/createHostScrollController.ts
@@ -0,0 +1,196 @@
+import { isFunction } from '@sniptt/guards';
+import { isDefined } from 'twenty-shared/utils';
+
+import { type GeometryTracker } from '@/host/geometry/types/GeometryTracker';
+import { type HostScrollController } from '@/host/scroll/types/HostScrollController';
+import { applyScrollRequest } from '@/host/scroll/utils/applyScrollRequest';
+import { parseScrollRequest } from '@/host/scroll/utils/parseScrollRequest';
+import { readNewScrollCommands } from '@/host/scroll/utils/readNewScrollCommands';
+import { readScrolledElementPosition } from '@/host/scroll/utils/readScrolledElementPosition';
+import { type RemoteElementCommand } from '@/types/RemoteElementCommand';
+import { type ScrollCommandAcknowledgement } from '@/types/ScrollCommandAcknowledgement';
+import { type ScrolledElementPosition } from '@/types/ScrolledElementPosition';
+
+type PendingScrollCommands = {
+ scrollCommands: unknown[];
+ onScrollUpdate: unknown;
+};
+
+type PendingScrollAcknowledgement = {
+ onScrollUpdate: unknown;
+ scrollCommandSequence: number;
+ scrolledNodes: Set<Element>;
+};
+
+type ScrollCommandCandidate = {
+ remoteElementId: string;
+ scrollCommand: RemoteElementCommand<unknown>;
+ scrolledNodes: Set<Element>;
+};
+
+export const createHostScrollController = ({
+ geometryTracker,
+}: {
+ geometryTracker: GeometryTracker;
+}): HostScrollController => {
+ const pendingScrollCommandsByRemoteElementId = new Map<
+ string,
+ PendingScrollCommands
+ >();
+ const appliedSequenceByRemoteElementId = new Map<string, number>();
+ let isFlushScheduled = false;
+
+ const isOwnedNode = (node: Element): boolean => {
+ const remoteElementId =
+ geometryTracker.findRemoteElementIdContainingNode(node);
+
+ return (
+ isDefined(remoteElementId) &&
+ geometryTracker.getRegisteredNode(remoteElementId) === node
+ );
+ };
+
+ const applyScrollCommand = ({
+ remoteElementId,
+ scrollCommand,
+ }: Pick<
+ ScrollCommandCandidate,
+ 'remoteElementId' | 'scrollCommand'
+ >): Element[] => {
+ const node = geometryTracker.getRegisteredNode(remoteElementId);
+
+ if (!isDefined(node) || !node.isConnected) {
+ return [];
+ }
+
+ const request = parseScrollRequest(scrollCommand.request);
+
+ if (!isDefined(request)) {
+ return [];
+ }
+
+ return applyScrollRequest({ node, request, isOwnedNode });
+ };
+
+ const readScrolledElementPositions = (
+ scrolledNodes: Set<Element>,
+ ): ScrolledElementPosition[] => {
+ const scrolledElementPositions: ScrolledElementPosition[] = [];
+
+ for (const scrolledNode of scrolledNodes) {
+ const remoteElementId =
+ geometryTracker.findRemoteElementIdContainingNode(scrolledNode);
+
+ if (isDefined(remoteElementId)) {
+ scrolledElementPositions.push(
+ readScrolledElementPosition({ node: scrolledNode, remoteElementId }),
+ );
+ }
+ }
+
+ return scrolledElementPositions;
+ };
+
+ const notifyScrollUpdate = ({
+ onScrollUpdate,
+ scrollCommandSequence,
+ scrolledNodes,
+ }: PendingScrollAcknowledgement): void => {
+ if (!isFunction(onScrollUpdate)) {
+ return;
+ }
+
+ const acknowledgement: ScrollCommandAcknowledgement = {
+ scrollCommandSequence,
+ scrollPositions: readScrolledElementPositions(scrolledNodes),
+ };
+
+ onScrollUpdate(acknowledgement);
+ };
+
+ const flush = (): void => {
+ isFlushScheduled = false;
+
+ const acknowledgements: PendingScrollAcknowledgement[] = [];
+ const candidates: ScrollCommandCandidate[] = [];
+
+ for (const [
+ remoteElementId,
+ { scrollCommands, onScrollUpdate },
+ ] of pendingScrollCommandsByRemoteElementId) {
+ if (scrollCommands.length === 0) {
+ appliedSequenceByRemoteElementId.delete(remoteElementId);
+ continue;
+ }
+
+ const newScrollCommands = readNewScrollCommands({
+ scrollCommands,
+ appliedSequence:
+ appliedSequenceByRemoteElementId.get(remoteElementId) ?? 0,
+ });
+ const lastScrollCommand = newScrollCommands[newScrollCommands.length - 1];
+
+ if (!isDefined(lastScrollCommand)) {
+ continue;
+ }
+
+ const scrolledNodes = new Set<Element>();
+
+ appliedSequenceByRemoteElementId.set(
+ remoteElementId,
+ lastScrollCommand.sequence,
+ );
+ acknowledgements.push({
+ onScrollUpdate,
+ scrollCommandSequence: lastScrollCommand.sequence,
+ scrolledNodes,
+ });
+
+ for (const scrollCommand of newScrollCommands) {
+ candidates.push({ remoteElementId, scrollCommand, scrolledNodes });
+ }
+ }
+
+ pendingScrollCommandsByRemoteElementId.clear();
+
+ candidates.sort(
+ (firstCandidate, secondCandidate) =>
+ firstCandidate.scrollCommand.sequence -
+ secondCandidate.scrollCommand.sequence,
+ );
+
+ for (const candidate of candidates) {
+ for (const scrolledNode of applyScrollCommand(candidate)) {
+ candidate.scrolledNodes.add(scrolledNode);
+ }
+ }
+
+ for (const acknowledgement of acknowledgements) {
+ notifyScrollUpdate(acknowledgement);
+ }
+ };
+
+ return {
+ enqueueScrollCommands: ({
+ remoteElementId,
+ scrollCommands,
+ onScrollUpdate,
+ }) => {
+ pendingScrollCommandsByRemoteElementId.set(remoteElementId, {
+ scrollCommands,
+ onScrollUpdate,
+ });
+
+ if (isFlushScheduled) {
+ return;
+ }
+
+ isFlushScheduled = true;
+ queueMicrotask(flush);
+ },
+ reset: () => {
+ pendingScrollCommandsByRemoteElementId.clear();
+ appliedSequenceByRemoteElementId.clear();
+ },
+ };
+};
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/expandRectByScrollMargin.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/expandRectByScrollMargin.ts
new file mode 100644
index 00000000000..6298587d197
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/expandRectByScrollMargin.ts
@@ -0,0 +1,27 @@
+import { type ElementScale } from '@/host/scroll/types/ElementScale';
+import { type ScrollBox } from '@/host/scroll/types/ScrollBox';
+import { resolveScrollLengthInPixels } from '@/host/scroll/utils/resolveScrollLengthInPixels';
+
+const readScrollMargin = (length: string): number =>
+ resolveScrollLengthInPixels({ length, referenceSize: 0 });
+
+export const expandRectByScrollMargin = ({
+ rect,
+ style,
+ scale,
+}: {
+ rect: ScrollBox;
+ style: Pick<
+ CSSStyleDeclaration,
+ | 'scrollMarginTop'
+ | 'scrollMarginRight'
+ | 'scrollMarginBottom'
+ | 'scrollMarginLeft'
+ >;
+ scale: ElementScale;
+}): ScrollBox => ({
+ top: rect.top - readScrollMargin(style.scrollMarginTop) * scale.y,
+ right: rect.right + readScrollMargin(style.scrollMarginRight) * scale.x,
+ bottom: rect.bottom + readScrollMargin(style.scrollMarginBottom) * scale.y,
+ left: rect.left - readScrollMargin(style.scrollMarginLeft) * scale.x,
+});
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/isFixedPositionStyle.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/isFixedPositionStyle.ts
new file mode 100644
index 00000000000..f8e069ef9d9
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/isFixedPositionStyle.ts
@@ -0,0 +1,3 @@
+export const isFixedPositionStyle = (
+ style: Pick<CSSStyleDeclaration, 'position'>,
+): boolean => style.position === 'fixed';
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/isScrollContainerOnAxis.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/isScrollContainerOnAxis.ts
new file mode 100644
index 00000000000..29f8a9f664d
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/isScrollContainerOnAxis.ts
@@ -0,0 +1,17 @@
+const SCROLLABLE_OVERFLOW_VALUES = new Set([
+ 'auto',
+ 'scroll',
+ 'hidden',
+ 'overlay',
+]);
+
+export const isScrollContainerOnAxis = ({
+ overflow,
+ scrollSize,
+ clientSize,
+}: {
+ overflow: string;
+ scrollSize: number;
+ clientSize: number;
+}): boolean =>
+ SCROLLABLE_OVERFLOW_VALUES.has(overflow) && scrollSize > clientSize;
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/parseScrollRequest.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/parseScrollRequest.ts
new file mode 100644
index 00000000000..69ee591ac75
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/parseScrollRequest.ts
@@ -0,0 +1,53 @@
+import { isNumber } from '@sniptt/guards';
+import { isDefined, isPlainObject } from 'twenty-shared/utils';
+
+import { type ScrollAxisOffsets } from '@/types/ScrollAxisOffsets';
+import { type ScrollRequest } from '@/types/ScrollRequest';
+import { isScrollIntoViewAlignment } from '@/utils/isScrollIntoViewAlignment';
+
+const readFiniteNumber = (value: unknown): number | undefined =>
+ isNumber(value) && Number.isFinite(value) ? value : undefined;
+
+const parseScrollAxisOffsets = (
+ request: Record<string, unknown>,
+): ScrollAxisOffsets | null => {
+ const top = readFiniteNumber(request.top);
+ const left = readFiniteNumber(request.left);
+
+ if (!isDefined(top) && !isDefined(left)) {
+ return null;
+ }
+
+ return {
+ ...(isDefined(top) && { top }),
+ ...(isDefined(left) && { left }),
+ };
+};
+
+export const parseScrollRequest = (request: unknown): ScrollRequest | null => {
+ if (!isPlainObject(request)) {
+ return null;
+ }
+
+ if (request.method === 'scrollTo') {
+ const scrollAxisOffsets = parseScrollAxisOffsets(request);
+
+ return isDefined(scrollAxisOffsets)
+ ? { method: 'scrollTo', ...scrollAxisOffsets }
+ : null;
+ }
+
+ if (
+ request.method === 'scrollIntoView' &&
+ isScrollIntoViewAlignment(request.block) &&
+ isScrollIntoViewAlignment(request.inline)
+ ) {
+ return {
+ method: 'scrollIntoView',
+ block: request.block,
+ inline: request.inline,
+ };
+ }
+
+ return null;
+};
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/readNewScrollCommands.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/readNewScrollCommands.ts
new file mode 100644
index 00000000000..3d2d133b8cd
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/readNewScrollCommands.ts
@@ -0,0 +1,40 @@
+import { isNumber } from '@sniptt/guards';
+import { isPlainObject } from 'twenty-shared/utils';
+
+import { MAX_PENDING_SCROLL_COMMANDS } from '@/constants/MaxPendingScrollCommands';
+import { type RemoteElementCommand } from '@/types/RemoteElementCommand';
+
+export const readNewScrollCommands = ({
+ scrollCommands,
+ appliedSequence,
+}: {
+ scrollCommands: unknown[];
+ appliedSequence: number;
+}): RemoteElementCommand<unknown>[] => {
+ const newScrollCommands: RemoteElementCommand<unknown>[] = [];
+
+ for (const scrollCommand of scrollCommands.slice(
+ -MAX_PENDING_SCROLL_COMMANDS,
+ )) {
+ if (!isPlainObject(scrollCommand)) {
+ continue;
+ }
+
+ const { sequence, request } = scrollCommand;
+
+ if (
+ !isNumber(sequence) ||
+ !Number.isSafeInteger(sequence) ||
+ sequence <= appliedSequence
+ ) {
+ continue;
+ }
+
+ newScrollCommands.push({ sequence, request });
+ }
+
+ return newScrollCommands.sort(
+ (firstCommand, secondCommand) =>
+ firstCommand.sequence - secondCommand.sequence,
+ );
+};
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/readScrolledElementPosition.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/readScrolledElementPosition.ts
new file mode 100644
index 00000000000..1ed86c27361
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/readScrolledElementPosition.ts
@@ -0,0 +1,13 @@
+import { type ScrolledElementPosition } from '@/types/ScrolledElementPosition';
+
+export const readScrolledElementPosition = ({
+ node,
+ remoteElementId,
+}: {
+ node: Pick<Element, 'scrollTop' | 'scrollLeft'>;
+ remoteElementId: string;
+}): ScrolledElementPosition => ({
+ remoteElementId,
+ scrollTop: node.scrollTop,
+ scrollLeft: node.scrollLeft,
+});
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/resolveBlockScrollIntoViewDelta.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/resolveBlockScrollIntoViewDelta.ts
new file mode 100644
index 00000000000..8295bc765e2
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/resolveBlockScrollIntoViewDelta.ts
@@ -0,0 +1,20 @@
+import { type ScrollBox } from '@/host/scroll/types/ScrollBox';
+import { resolveScrollIntoViewDelta } from '@/host/scroll/utils/resolveScrollIntoViewDelta';
+import { type ScrollIntoViewAlignment } from '@/types/ScrollIntoViewAlignment';
+
+export const resolveBlockScrollIntoViewDelta = ({
+ targetBox,
+ scrollport,
+ alignment,
+}: {
+ targetBox: Pick<ScrollBox, 'top' | 'bottom'>;
+ scrollport: Pick<ScrollBox, 'top' | 'bottom'>;
+ alignment: ScrollIntoViewAlignment;
+}): number =>
+ resolveScrollIntoViewDelta({
+ elementStart: targetBox.top,
+ elementEnd: targetBox.bottom,
+ scrollportStart: scrollport.top,
+ scrollportEnd: scrollport.bottom,
+ alignment,
+ });
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/resolveCssCalcExpressionInPixels.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/resolveCssCalcExpressionInPixels.ts
new file mode 100644
index 00000000000..8de0f22c817
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/resolveCssCalcExpressionInPixels.ts
@@ -0,0 +1,118 @@
+import { isDefined } from 'twenty-shared/utils';
+
+type CalcExpressionCursor = {
+ expression: string;
+ index: number;
+};
+
+const LEADING_WHITESPACE_PATTERN = /^\s*/;
+
+const LEADING_NUMBER_WITH_UNIT_PATTERN =
+ /^(-?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?)(px|%)?/i;
+
+const peekCharacter = (cursor: CalcExpressionCursor): string | undefined => {
+ const whitespaceLength =
+ LEADING_WHITESPACE_PATTERN.exec(cursor.expression.slice(cursor.index))?.[0]
+ .length ?? 0;
+
+ cursor.index += whitespaceLength;
+
+ return cursor.expression[cursor.index];
+};
+
+const parseOperand = ({
+ cursor,
+ referenceSize,
+}: {
+ cursor: CalcExpressionCursor;
+ referenceSize: number;
+}): number => {
+ const nextCharacter = peekCharacter(cursor);
+
+ if (nextCharacter === '(') {
+ cursor.index += 1;
+ const value = parseSum({ cursor, referenceSize });
+
+ if (peekCharacter(cursor) !== ')') {
+ return Number.NaN;
+ }
+
+ cursor.index += 1;
+
+ return value;
+ }
+
+ const match = LEADING_NUMBER_WITH_UNIT_PATTERN.exec(
+ cursor.expression.slice(cursor.index),
+ );
+
+ if (!isDefined(match)) {
+ return Number.NaN;
+ }
+
+ cursor.index += match[0].length;
+ const value = Number.parseFloat(match[1]);
+
+ return match[2] === '%' ? (value * referenceSize) / 100 : value;
+};
+
+const parseProduct = ({
+ cursor,
+ referenceSize,
+}: {
+ cursor: CalcExpressionCursor;
+ referenceSize: number;
+}): number => {
+ let value = parseOperand({ cursor, referenceSize });
+
+ for (
+ let operator = peekCharacter(cursor);
+ operator === '*' || operator === '/';
+ operator = peekCharacter(cursor)
+ ) {
+ cursor.index += 1;
+ const operand = parseOperand({ cursor, referenceSize });
+
+ value = operator === '*' ? value * operand : value / operand;
+ }
+
+ return value;
+};
+
+const parseSum = ({
+ cursor,
+ referenceSize,
+}: {
+ cursor: CalcExpressionCursor;
+ referenceSize: number;
+}): number => {
+ let value = parseProduct({ cursor, referenceSize });
+
+ for (
+ let operator = peekCharacter(cursor);
+ operator === '+' || operator === '-';
+ operator = peekCharacter(cursor)
+ ) {
+ cursor.index += 1;
+ const operand = parseProduct({ cursor, referenceSize });
+
+ value = operator === '+' ? value + operand : value - operand;
+ }
+
+ return value;
+};
+
+export const resolveCssCalcExpressionInPixels = ({
+ expression,
+ referenceSize,
+}: {
+ expression: string;
+ referenceSize: number;
+}): number => {
+ const cursor: CalcExpressionCursor = { expression, index: 0 };
+ const value = parseSum({ cursor, referenceSize });
+ const isFullyConsumed =
+ !isDefined(peekCharacter(cursor)) && cursor.index === expression.length;
+
+ return isFullyConsumed && Number.isFinite(value) ? value : 0;
+};
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/resolveElementScale.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/resolveElementScale.ts
new file mode 100644
index 00000000000..0934238412b
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/resolveElementScale.ts
@@ -0,0 +1,32 @@
+import { isNumber } from '@sniptt/guards';
+
+import { type ElementScale } from '@/host/scroll/types/ElementScale';
+
+const resolveScaleRatio = ({
+ renderedSize,
+ layoutSize,
+}: {
+ renderedSize: number;
+ layoutSize: number | undefined;
+}): number => {
+ if (!isNumber(layoutSize) || layoutSize <= 0) {
+ return 1;
+ }
+
+ const scaleRatio = renderedSize / layoutSize;
+
+ return Number.isFinite(scaleRatio) && scaleRatio > 0 ? scaleRatio : 1;
+};
+
+export const resolveElementScale = (
+ element: Pick<Element, 'getBoundingClientRect'> &
+ Partial<Pick<HTMLElement, 'offsetWidth' | 'offsetHeight'>>,
+): ElementScale => {
+ const { width, height } = element.getBoundingClientRect();
+ const { offsetWidth, offsetHeight } = element;
+
+ return {
+ x: resolveScaleRatio({ renderedSize: width, layoutSize: offsetWidth }),
+ y: resolveScaleRatio({ renderedSize: height, layoutSize: offsetHeight }),
+ };
+};
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/resolveInlineScrollIntoViewDelta.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/resolveInlineScrollIntoViewDelta.ts
new file mode 100644
index 00000000000..d8429fe793d
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/resolveInlineScrollIntoViewDelta.ts
@@ -0,0 +1,33 @@
+import { type ScrollBox } from '@/host/scroll/types/ScrollBox';
+import { resolveScrollIntoViewDelta } from '@/host/scroll/utils/resolveScrollIntoViewDelta';
+import { type ScrollIntoViewAlignment } from '@/types/ScrollIntoViewAlignment';
+
+export const resolveInlineScrollIntoViewDelta = ({
+ targetBox,
+ scrollport,
+ alignment,
+ isRightToLeft,
+}: {
+ targetBox: Pick<ScrollBox, 'left' | 'right'>;
+ scrollport: Pick<ScrollBox, 'left' | 'right'>;
+ alignment: ScrollIntoViewAlignment;
+ isRightToLeft: boolean;
+}): number => {
+ if (!isRightToLeft) {
+ return resolveScrollIntoViewDelta({
+ elementStart: targetBox.left,
+ elementEnd: targetBox.right,
+ scrollportStart: scrollport.left,
+ scrollportEnd: scrollport.right,
+ alignment,
+ });
+ }
+
+ return -resolveScrollIntoViewDelta({
+ elementStart: -targetBox.right,
+ elementEnd: -targetBox.left,
+ scrollportStart: -scrollport.right,
+ scrollportEnd: -scrollport.left,
+ alignment,
+ });
+};
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/resolveScrollIntoViewDelta.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/resolveScrollIntoViewDelta.ts
new file mode 100644
index 00000000000..0e0009081d3
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/resolveScrollIntoViewDelta.ts
@@ -0,0 +1,63 @@
+import { type ScrollIntoViewAlignment } from '@/types/ScrollIntoViewAlignment';
+
+const resolveNearestScrollIntoViewDelta = ({
+ elementStart,
+ elementEnd,
+ scrollportStart,
+ scrollportEnd,
+}: {
+ elementStart: number;
+ elementEnd: number;
+ scrollportStart: number;
+ scrollportEnd: number;
+}): number => {
+ const isStartOutside = elementStart < scrollportStart;
+ const isEndOutside = elementEnd > scrollportEnd;
+
+ if (isStartOutside === isEndOutside) {
+ return 0;
+ }
+
+ const isElementLargerThanScrollport =
+ elementEnd - elementStart > scrollportEnd - scrollportStart;
+ const shouldAlignStart = isStartOutside !== isElementLargerThanScrollport;
+
+ return shouldAlignStart
+ ? elementStart - scrollportStart
+ : elementEnd - scrollportEnd;
+};
+
+export const resolveScrollIntoViewDelta = ({
+ elementStart,
+ elementEnd,
+ scrollportStart,
+ scrollportEnd,
+ alignment,
+}: {
+ elementStart: number;
+ elementEnd: number;
+ scrollportStart: number;
+ scrollportEnd: number;
+ alignment: ScrollIntoViewAlignment;
+}): number => {
+ if (alignment === 'start') {
+ return elementStart - scrollportStart;
+ }
+
+ if (alignment === 'end') {
+ return elementEnd - scrollportEnd;
+ }
+
+ if (alignment === 'center') {
+ return (
+ (elementStart + elementEnd) / 2 - (scrollportStart + scrollportEnd) / 2
+ );
+ }
+
+ return resolveNearestScrollIntoViewDelta({
+ elementStart,
+ elementEnd,
+ scrollportStart,
+ scrollportEnd,
+ });
+};
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/resolveScrollLengthInPixels.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/resolveScrollLengthInPixels.ts
new file mode 100644
index 00000000000..34c20e7b03f
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/resolveScrollLengthInPixels.ts
@@ -0,0 +1,33 @@
+import { isDefined } from 'twenty-shared/utils';
+
+import { resolveCssCalcExpressionInPixels } from '@/host/scroll/utils/resolveCssCalcExpressionInPixels';
+
+const CALC_FUNCTION_PATTERN = /^calc\((.*)\)$/is;
+
+export const resolveScrollLengthInPixels = ({
+ length,
+ referenceSize,
+}: {
+ length: string;
+ referenceSize: number;
+}): number => {
+ const trimmedLength = length.trim();
+ const calcExpression = CALC_FUNCTION_PATTERN.exec(trimmedLength)?.[1];
+
+ if (isDefined(calcExpression)) {
+ return resolveCssCalcExpressionInPixels({
+ expression: calcExpression,
+ referenceSize,
+ });
+ }
+
+ const numericLength = Number.parseFloat(trimmedLength);
+
+ if (!Number.isFinite(numericLength)) {
+ return 0;
+ }
+
+ return trimmedLength.endsWith('%')
+ ? (numericLength * referenceSize) / 100
+ : numericLength;
+};
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/resolveScrollportBox.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/resolveScrollportBox.ts
new file mode 100644
index 00000000000..f42d4c200e4
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/resolveScrollportBox.ts
@@ -0,0 +1,51 @@
+import { type ElementScale } from '@/host/scroll/types/ElementScale';
+import { type ScrollBox } from '@/host/scroll/types/ScrollBox';
+import { resolveScrollLengthInPixels } from '@/host/scroll/utils/resolveScrollLengthInPixels';
+
+export const resolveScrollportBox = ({
+ scrollContainer,
+ scrollContainerStyle,
+ scale,
+}: {
+ scrollContainer: Pick<
+ Element,
+ | 'getBoundingClientRect'
+ | 'clientLeft'
+ | 'clientTop'
+ | 'clientWidth'
+ | 'clientHeight'
+ >;
+ scrollContainerStyle: Pick<
+ CSSStyleDeclaration,
+ | 'scrollPaddingTop'
+ | 'scrollPaddingRight'
+ | 'scrollPaddingBottom'
+ | 'scrollPaddingLeft'
+ >;
+ scale: ElementScale;
+}): ScrollBox => {
+ const borderBoxRectangle = scrollContainer.getBoundingClientRect();
+ const { clientLeft, clientTop, clientWidth, clientHeight } = scrollContainer;
+ const left = borderBoxRectangle.left + clientLeft * scale.x;
+ const top = borderBoxRectangle.top + clientTop * scale.y;
+ const readBlockScrollPadding = (length: string): number =>
+ resolveScrollLengthInPixels({ length, referenceSize: clientHeight }) *
+ scale.y;
+ const readInlineScrollPadding = (length: string): number =>
+ resolveScrollLengthInPixels({ length, referenceSize: clientWidth }) *
+ scale.x;
+
+ return {
+ top: top + readBlockScrollPadding(scrollContainerStyle.scrollPaddingTop),
+ right:
+ left +
+ clientWidth * scale.x -
+ readInlineScrollPadding(scrollContainerStyle.scrollPaddingRight),
+ bottom:
+ top +
+ clientHeight * scale.y -
+ readBlockScrollPadding(scrollContainerStyle.scrollPaddingBottom),
+ left:
+ left + readInlineScrollPadding(scrollContainerStyle.scrollPaddingLeft),
+ };
+};
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/scrollContainerToRevealTarget.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/scrollContainerToRevealTarget.ts
new file mode 100644
index 00000000000..c8d7dda19e1
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/scrollContainerToRevealTarget.ts
@@ -0,0 +1,93 @@
+import { expandRectByScrollMargin } from '@/host/scroll/utils/expandRectByScrollMargin';
+import { isScrollContainerOnAxis } from '@/host/scroll/utils/isScrollContainerOnAxis';
+import { resolveBlockScrollIntoViewDelta } from '@/host/scroll/utils/resolveBlockScrollIntoViewDelta';
+import { resolveElementScale } from '@/host/scroll/utils/resolveElementScale';
+import { resolveInlineScrollIntoViewDelta } from '@/host/scroll/utils/resolveInlineScrollIntoViewDelta';
+import { resolveScrollportBox } from '@/host/scroll/utils/resolveScrollportBox';
+import { type ScrollIntoViewAlignment } from '@/types/ScrollIntoViewAlignment';
+
+export const scrollContainerToRevealTarget = ({
+ target,
+ targetStyle,
+ scrollContainer,
+ scrollContainerStyle,
+ block,
+ inline,
+}: {
+ target: Element;
+ targetStyle: Pick<
+ CSSStyleDeclaration,
+ | 'scrollMarginTop'
+ | 'scrollMarginRight'
+ | 'scrollMarginBottom'
+ | 'scrollMarginLeft'
+ >;
+ scrollContainer: Element;
+ scrollContainerStyle: Pick<
+ CSSStyleDeclaration,
+ | 'overflowX'
+ | 'overflowY'
+ | 'direction'
+ | 'scrollPaddingTop'
+ | 'scrollPaddingRight'
+ | 'scrollPaddingBottom'
+ | 'scrollPaddingLeft'
+ >;
+ block: ScrollIntoViewAlignment;
+ inline: ScrollIntoViewAlignment;
+}): boolean => {
+ const canScrollBlock = isScrollContainerOnAxis({
+ overflow: scrollContainerStyle.overflowY,
+ scrollSize: scrollContainer.scrollHeight,
+ clientSize: scrollContainer.clientHeight,
+ });
+ const canScrollInline = isScrollContainerOnAxis({
+ overflow: scrollContainerStyle.overflowX,
+ scrollSize: scrollContainer.scrollWidth,
+ clientSize: scrollContainer.clientWidth,
+ });
+
+ if (!canScrollBlock && !canScrollInline) {
+ return false;
+ }
+
+ const scale = resolveElementScale(scrollContainer);
+ const scrollport = resolveScrollportBox({
+ scrollContainer,
+ scrollContainerStyle,
+ scale,
+ });
+ const targetBox = expandRectByScrollMargin({
+ rect: target.getBoundingClientRect(),
+ style: targetStyle,
+ scale,
+ });
+ const isRightToLeft = scrollContainerStyle.direction === 'rtl';
+ const blockDelta = canScrollBlock
+ ? resolveBlockScrollIntoViewDelta({
+ targetBox,
+ scrollport,
+ alignment: block,
+ })
+ : 0;
+ const inlineDelta = canScrollInline
+ ? resolveInlineScrollIntoViewDelta({
+ targetBox,
+ scrollport,
+ alignment: inline,
+ isRightToLeft,
+ })
+ : 0;
+
+ if (blockDelta === 0 && inlineDelta === 0) {
+ return true;
+ }
+
+ scrollContainer.scrollTo({
+ top: scrollContainer.scrollTop + blockDelta / scale.y,
+ left: scrollContainer.scrollLeft + inlineDelta / scale.x,
+ behavior: 'instant',
+ });
+
+ return true;
+};
diff --git a/packages/twenty-front-component-renderer/src/host/scroll/utils/scrollOwnedAncestorsIntoView.ts b/packages/twenty-front-component-renderer/src/host/scroll/utils/scrollOwnedAncestorsIntoView.ts
new file mode 100644
index 00000000000..fdf98097e91
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/host/scroll/utils/scrollOwnedAncestorsIntoView.ts
@@ -0,0 +1,55 @@
+import { isDefined } from 'twenty-shared/utils';
+
+import { isFixedPositionStyle } from '@/host/scroll/utils/isFixedPositionStyle';
+import { scrollContainerToRevealTarget } from '@/host/scroll/utils/scrollContainerToRevealTarget';
+import { type ScrollIntoViewAlignment } from '@/types/ScrollIntoViewAlignment';
+
+export const scrollOwnedAncestorsIntoView = ({
+ target,
+ block,
+ inline,
+ isOwnedNode,
+}: {
+ target: Element;
+ block: ScrollIntoViewAlignment;
+ inline: ScrollIntoViewAlignment;
+ isOwnedNode: (node: Element) => boolean;
+}): Element[] => {
+ const scrollContainers: Element[] = [];
+
+ if (target.getClientRects().length === 0) {
+ return scrollContainers;
+ }
+
+ const targetStyle = getComputedStyle(target);
+
+ if (isFixedPositionStyle(targetStyle)) {
+ return scrollContainers;
+ }
+
+ let scrollContainer = target.parentElement;
+
+ while (isDefined(scrollContainer) && isOwnedNode(scrollContainer)) {
+ const scrollContainerStyle = getComputedStyle(scrollContainer);
+ const isScrollContainer = scrollContainerToRevealTarget({
+ target,
+ targetStyle,
+ scrollContainer,
+ scrollContainerStyle,
+ block,
+ inline,
+ });
+
+ if (isScrollContainer) {
+ scrollContainers.push(scrollContainer);
+ }
+
+ if (isFixedPositionStyle(scrollContainerStyle)) {
+ break;
+ }
+
+ scrollContainer = scrollContainer.parentElement;
+ }
+
+ return scrollContainers;
+};
diff --git a/packages/twenty-front-component-renderer/src/polyfills/dom/utils/__tests__/findSelfOrAncestorByRemoteId.test.ts b/packages/twenty-front-component-renderer/src/polyfills/dom/utils/__tests__/findSelfOrAncestorByRemoteId.test.ts
new file mode 100644
index 00000000000..221c8f1882d
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/dom/utils/__tests__/findSelfOrAncestorByRemoteId.test.ts
@@ -0,0 +1,93 @@
+import { remoteId } from '@remote-dom/core/elements';
+import { Window } from '@remote-dom/polyfill';
+
+import { findSelfOrAncestorByRemoteId } from '@/polyfills/dom/utils/findSelfOrAncestorByRemoteId';
+
+const createRemoteTree = () => {
+ const document = new Window().document as unknown as Document;
+ const rootElement = document.createElement('div');
+ const scrollContainer = document.createElement('div');
+ const listItem = document.createElement('div');
+ const label = document.createElement('span');
+
+ scrollContainer.append(listItem);
+ listItem.append(label);
+ rootElement.append(scrollContainer);
+ document.body.append(rootElement);
+
+ return { document, rootElement, scrollContainer, listItem, label };
+};
+
+describe('findSelfOrAncestorByRemoteId', () => {
+ it('should return the element itself when it carries the remote id', () => {
+ const { rootElement, label } = createRemoteTree();
+
+ expect(
+ findSelfOrAncestorByRemoteId({
+ element: label,
+ remoteElementId: remoteId(label),
+ rootElement,
+ }),
+ ).toBe(label);
+ });
+
+ it('should return the closest ancestor carrying the remote id', () => {
+ const { rootElement, scrollContainer, label } = createRemoteTree();
+
+ expect(
+ findSelfOrAncestorByRemoteId({
+ element: label,
+ remoteElementId: remoteId(scrollContainer),
+ rootElement,
+ }),
+ ).toBe(scrollContainer);
+ });
+
+ it('should stop at the root without matching the root itself', () => {
+ const { rootElement, label } = createRemoteTree();
+
+ expect(
+ findSelfOrAncestorByRemoteId({
+ element: label,
+ remoteElementId: remoteId(rootElement),
+ rootElement,
+ }),
+ ).toBeNull();
+ });
+
+ it('should not match an ancestor above the root', () => {
+ const { document, rootElement, label } = createRemoteTree();
+
+ expect(
+ findSelfOrAncestorByRemoteId({
+ element: label,
+ remoteElementId: remoteId(document.body),
+ rootElement,
+ }),
+ ).toBeNull();
+ });
+
+ it('should return null when no element in the chain carries the remote id', () => {
+ const { rootElement, listItem } = createRemoteTree();
+
+ expect(
+ findSelfOrAncestorByRemoteId({
+ element: listItem,
+ remoteElementId: 'missing',
+ rootElement,
+ }),
+ ).toBeNull();
+ });
+
+ it('should walk every ancestor when there is no root', () => {
+ const { document, label } = createRemoteTree();
+
+ expect(
+ findSelfOrAncestorByRemoteId({
+ element: label,
+ remoteElementId: remoteId(document.body),
+ rootElement: null,
+ }),
+ ).toBe(document.body);
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/polyfills/dom/utils/findAncestorByRemoteId.ts b/packages/twenty-front-component-renderer/src/polyfills/dom/utils/findAncestorByRemoteId.ts
index ae8a1df9d26..ab70c9353b4 100644
--- a/packages/twenty-front-component-renderer/src/polyfills/dom/utils/findAncestorByRemoteId.ts
+++ b/packages/twenty-front-component-renderer/src/polyfills/dom/utils/findAncestorByRemoteId.ts
@@ -1,6 +1,5 @@
-import { remoteId } from '@remote-dom/core/elements';
-
import { type NodeLike } from '@/polyfills/dom/types/NodeLike';
+import { findSelfOrAncestorByRemoteId } from '@/polyfills/dom/utils/findSelfOrAncestorByRemoteId';
import { isElementNode } from '@/polyfills/dom/utils/isElementNode';
export const findAncestorByRemoteId = ({
@@ -10,15 +9,15 @@ export const findAncestorByRemoteId = ({
node: NodeLike;
remoteElementId: string;
}): Element | null => {
- let ancestor: unknown = node.parentNode;
-
- while (isElementNode(ancestor)) {
- if (remoteId(ancestor) === remoteElementId) {
- return ancestor;
- }
+ const { parentNode } = node;
- ancestor = ancestor.parentNode;
+ if (!isElementNode(parentNode)) {
+ return null;
}
- return null;
+ return findSelfOrAncestorByRemoteId({
+ element: parentNode,
+ remoteElementId,
+ rootElement: null,
+ });
};
diff --git a/packages/twenty-front-component-renderer/src/polyfills/dom/utils/findSelfOrAncestorByRemoteId.ts b/packages/twenty-front-component-renderer/src/polyfills/dom/utils/findSelfOrAncestorByRemoteId.ts
new file mode 100644
index 00000000000..c42aea60811
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/dom/utils/findSelfOrAncestorByRemoteId.ts
@@ -0,0 +1,25 @@
+import { remoteId } from '@remote-dom/core/elements';
+
+import { isElementNode } from '@/polyfills/dom/utils/isElementNode';
+
+export const findSelfOrAncestorByRemoteId = ({
+ element,
+ remoteElementId,
+ rootElement,
+}: {
+ element: object;
+ remoteElementId: string;
+ rootElement: object | null;
+}): Element | null => {
+ let currentNode: object | null = element;
+
+ while (isElementNode(currentNode) && currentNode !== rootElement) {
+ if (remoteId(currentNode) === remoteElementId) {
+ return currentNode;
+ }
+
+ currentNode = currentNode.parentNode;
+ }
+
+ return null;
+};
diff --git a/packages/twenty-front-component-renderer/src/polyfills/geometry/utils/__tests__/installElementGeometryPolyfill.test.ts b/packages/twenty-front-component-renderer/src/polyfills/geometry/utils/__tests__/installElementGeometryPolyfill.test.ts
index 8b617195833..36ad124d341 100644
--- a/packages/twenty-front-component-renderer/src/polyfills/geometry/utils/__tests__/installElementGeometryPolyfill.test.ts
+++ b/packages/twenty-front-component-renderer/src/polyfills/geometry/utils/__tests__/installElementGeometryPolyfill.test.ts
@@ -25,8 +25,6 @@ type GeometryPolyfilledElement = FakeElement & {
clientLeft: number;
scrollWidth: number;
scrollHeight: number;
- scrollTop: number;
- scrollLeft: number;
offsetParent: FakeElement | null;
};
@@ -131,7 +129,7 @@ describe('installElementGeometryPolyfill', () => {
expect(element.clientHeight).toBe(10);
expect(element.scrollWidth).toBe(13);
expect(element.scrollHeight).toBe(14);
- expect(element.scrollTop).toBe(15);
+ expect(element.clientWidth).toBe(9);
});
it('should measure content when a textarea resets its block size', () => {
@@ -212,22 +210,7 @@ describe('installElementGeometryPolyfill', () => {
expect(element.offsetWidth).toBe(0);
expect(element.clientHeight).toBe(0);
expect(element.scrollHeight).toBe(0);
- expect(element.scrollLeft).toBe(0);
- });
-
- it('should not throw when scrollTop is assigned and should keep reading the mirrored value', () => {
- installOn(
- createWorkerGeometryStoreStub({
- resolveElementSnapshot: () => createElementGeometrySnapshotFixture(),
- }),
- );
-
- const element = asPolyfilled(new FakeElement());
-
- expect(() => {
- element.scrollTop = 999;
- }).not.toThrow();
- expect(element.scrollTop).toBe(15);
+ expect(element.clientLeft).toBe(0);
});
it('should return the document body from offsetParent', () => {
diff --git a/packages/twenty-front-component-renderer/src/polyfills/geometry/utils/installElementGeometryPolyfill.ts b/packages/twenty-front-component-renderer/src/polyfills/geometry/utils/installElementGeometryPolyfill.ts
index 1518f88ad20..6083995c38e 100644
--- a/packages/twenty-front-component-renderer/src/polyfills/geometry/utils/installElementGeometryPolyfill.ts
+++ b/packages/twenty-front-component-renderer/src/polyfills/geometry/utils/installElementGeometryPolyfill.ts
@@ -39,16 +39,13 @@ export const installElementGeometryPolyfill = ({
const defineGeometryGetter = ({
propertyName,
- hasNoOpSetter = false,
}: {
propertyName: keyof ElementGeometrySnapshot;
- hasNoOpSetter?: boolean;
}): void => {
Object.defineProperty(elementPrototype, propertyName, {
get(this: object) {
return resolveSnapshot(this)?.[propertyName] ?? 0;
},
- ...(hasNoOpSetter && { set() {} }),
configurable: true,
});
};
@@ -67,10 +64,6 @@ export const installElementGeometryPolyfill = ({
defineGeometryGetter({ propertyName });
}
- for (const propertyName of ['scrollTop', 'scrollLeft'] as const) {
- defineGeometryGetter({ propertyName, hasNoOpSetter: true });
- }
-
Object.defineProperty(elementPrototype, 'scrollHeight', {
get(this: TextareaIntrinsicSizeElement) {
return readTextareaIntrinsicSize({
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/constants/ScrollOffsetPropertyByAxis.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/constants/ScrollOffsetPropertyByAxis.ts
new file mode 100644
index 00000000000..cd2c54dad57
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/constants/ScrollOffsetPropertyByAxis.ts
@@ -0,0 +1,7 @@
+import { type EventScrollState } from '@/polyfills/scroll/types/EventScrollState';
+import { type ScrollAxis } from '@/types/ScrollAxis';
+
+export const SCROLL_OFFSET_PROPERTY_BY_AXIS = {
+ top: 'scrollTop',
+ left: 'scrollLeft',
+} as const satisfies Record<ScrollAxis, keyof EventScrollState>;
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/states/workerScrollStore.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/states/workerScrollStore.ts
new file mode 100644
index 00000000000..7aed809531c
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/states/workerScrollStore.ts
@@ -0,0 +1,6 @@
+import { workerGeometryStore } from '@/polyfills/geometry/states/workerGeometryStore';
+import { createWorkerScrollStore } from '@/polyfills/scroll/utils/createWorkerScrollStore';
+
+export const workerScrollStore = createWorkerScrollStore({
+ geometryStore: workerGeometryStore,
+});
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/types/AcknowledgedScrollPosition.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/types/AcknowledgedScrollPosition.ts
new file mode 100644
index 00000000000..b3af044f9dc
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/types/AcknowledgedScrollPosition.ts
@@ -0,0 +1,7 @@
+import { type ElementGeometrySnapshot } from '@/types/ElementGeometrySnapshot';
+
+export type AcknowledgedScrollPosition = {
+ top: number;
+ left: number;
+ baseSnapshot: ElementGeometrySnapshot | null;
+};
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/types/EventScrollExtent.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/types/EventScrollExtent.ts
new file mode 100644
index 00000000000..fd720ddefe7
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/types/EventScrollExtent.ts
@@ -0,0 +1 @@
+export type EventScrollExtent = 'scrollWidth' | 'clientWidth';
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/types/EventScrollState.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/types/EventScrollState.ts
new file mode 100644
index 00000000000..39c71bba96e
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/types/EventScrollState.ts
@@ -0,0 +1,7 @@
+import { type EVENT_SCROLL_STATE_KEYS } from '@/constants/EventScrollStateKeys';
+import { type SerializedEventData } from '@/types/SerializedEventData';
+
+export type EventScrollState = Pick<
+ SerializedEventData,
+ (typeof EVENT_SCROLL_STATE_KEYS)[number]
+>;
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/types/HostScrollOffset.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/types/HostScrollOffset.ts
new file mode 100644
index 00000000000..822ffd4b52e
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/types/HostScrollOffset.ts
@@ -0,0 +1,4 @@
+export type HostScrollOffset = {
+ offset: number;
+ isMeasured: boolean;
+};
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/types/WorkerScrollStore.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/types/WorkerScrollStore.ts
new file mode 100644
index 00000000000..7bc018ef350
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/types/WorkerScrollStore.ts
@@ -0,0 +1,19 @@
+import { type EventScrollExtent } from '@/polyfills/scroll/types/EventScrollExtent';
+import { type ScrollAxis } from '@/types/ScrollAxis';
+import { type ScrollRequest } from '@/types/ScrollRequest';
+import { type SerializedEventData } from '@/types/SerializedEventData';
+
+export type WorkerScrollStore = {
+ setRootElement: (rootElement: object) => void;
+ readScrollOffset: (input: { element: object; axis: ScrollAxis }) => number;
+ readEventScrollExtent: (input: {
+ element: object;
+ extent: EventScrollExtent;
+ }) => number | undefined;
+ requestScroll: (input: { element: object; request: ScrollRequest }) => void;
+ observeEventTarget: (input: {
+ element: object;
+ eventData: SerializedEventData;
+ }) => void;
+ scheduleDetachedElementSweep: () => void;
+};
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/__tests__/createWorkerScrollStore.test.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/__tests__/createWorkerScrollStore.test.ts
new file mode 100644
index 00000000000..44272f55874
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/__tests__/createWorkerScrollStore.test.ts
@@ -0,0 +1,895 @@
+import { updateRemoteElementProperty } from '@remote-dom/core/elements';
+import { isFunction } from '@sniptt/guards';
+
+import { MAX_PENDING_SCROLL_COMMANDS } from '@/constants/MaxPendingScrollCommands';
+import { REMOTE_RENDER_CONTAINER_TAG } from '@/constants/RemoteRenderContainerTag';
+import { SCROLL_BRIDGE_PROPERTIES } from '@/constants/ScrollBridgeProperties';
+import { NODE_TYPE_BY_NAME } from '@/polyfills/dom/constants/NodeTypeByName';
+import { createWorkerScrollStore } from '@/polyfills/scroll/utils/createWorkerScrollStore';
+import { createElementGeometrySnapshotFixture } from '@/testing/createElementGeometrySnapshotFixture';
+import { createWorkerGeometryStoreStub } from '@/testing/createWorkerGeometryStoreStub';
+import { type ElementGeometrySnapshot } from '@/types/ElementGeometrySnapshot';
+import { type ScrollCommandAcknowledgement } from '@/types/ScrollCommandAcknowledgement';
+
+type FakeRemoteNode = {
+ parentNode: object | null;
+ localName: string;
+ nodeType: number;
+};
+
+type ScrollUpdateHandler = (
+ acknowledgement: ScrollCommandAcknowledgement,
+) => void;
+
+const remoteElementIdByNode = new WeakMap<object, string>();
+
+jest.mock('@remote-dom/core/elements', () => ({
+ remoteId: (node: object) =>
+ remoteElementIdByNode.get(node) ?? 'unregistered-remote-element',
+ updateRemoteElementProperty: jest.fn(),
+}));
+
+const updateRemoteElementPropertyMock = jest.mocked(
+ updateRemoteElementProperty,
+);
+
+const createFakeRemoteNode = ({
+ parentNode,
+ remoteElementId,
+ localName = 'html-div',
+}: {
+ parentNode: object | null;
+ remoteElementId: string;
+ localName?: string;
+}): FakeRemoteNode => {
+ const fakeRemoteNode = {
+ parentNode,
+ localName,
+ nodeType: NODE_TYPE_BY_NAME.ELEMENT,
+ };
+
+ remoteElementIdByNode.set(fakeRemoteNode, remoteElementId);
+
+ return fakeRemoteNode;
+};
+
+const createScrollStoreEnvironment = () => {
+ const snapshotByElement = new Map<object, ElementGeometrySnapshot>();
+ const resolveElementSnapshot = jest.fn(
+ (element: object) => snapshotByElement.get(element) ?? null,
+ );
+ const scrollStore = createWorkerScrollStore({
+ geometryStore: createWorkerGeometryStoreStub({ resolveElementSnapshot }),
+ });
+ const rootElement = createFakeRemoteNode({
+ parentNode: null,
+ remoteElementId: 'root',
+ localName: 'remote-root',
+ });
+ const scrollContainer = createFakeRemoteNode({
+ parentNode: rootElement,
+ remoteElementId: 'scroll-container',
+ });
+ const scrolledItem = createFakeRemoteNode({
+ parentNode: scrollContainer,
+ remoteElementId: 'scrolled-item',
+ });
+
+ snapshotByElement.set(
+ scrollContainer,
+ createElementGeometrySnapshotFixture(),
+ );
+ snapshotByElement.set(
+ scrolledItem,
+ createElementGeometrySnapshotFixture({ scrollTop: 0, scrollLeft: 0 }),
+ );
+ scrollStore.setRootElement(rootElement);
+
+ return {
+ scrollStore,
+ snapshotByElement,
+ resolveElementSnapshot,
+ rootElement,
+ scrollContainer,
+ scrolledItem,
+ };
+};
+
+const readBridgePropertyValues = ({
+ element,
+ bridgeProperty,
+}: {
+ element: object;
+ bridgeProperty: string;
+}): unknown[] =>
+ updateRemoteElementPropertyMock.mock.calls
+ .filter(
+ ([updatedElement, updatedProperty]) =>
+ updatedElement === element && updatedProperty === bridgeProperty,
+ )
+ .map(([, , value]) => value);
+
+const readSentScrollQueues = (element: object): unknown[] =>
+ readBridgePropertyValues({
+ element,
+ bridgeProperty: SCROLL_BRIDGE_PROPERTIES.request,
+ });
+
+const readLatestScrollUpdateHandler = (
+ element: object,
+): ScrollUpdateHandler => {
+ const scrollUpdateHandlers = readBridgePropertyValues({
+ element,
+ bridgeProperty: SCROLL_BRIDGE_PROPERTIES.update,
+ });
+ const latestScrollUpdateHandler =
+ scrollUpdateHandlers[scrollUpdateHandlers.length - 1];
+
+ if (!isFunction<ScrollUpdateHandler, unknown>(latestScrollUpdateHandler)) {
+ throw new Error('Expected a host scroll subscription for the element');
+ }
+
+ return latestScrollUpdateHandler;
+};
+
+describe('createWorkerScrollStore', () => {
+ beforeEach(() => {
+ updateRemoteElementPropertyMock.mockClear();
+ });
+
+ it('should send nothing for the remote root, a render container or a detached element', () => {
+ const { scrollStore, rootElement } = createScrollStoreEnvironment();
+ const renderContainer = createFakeRemoteNode({
+ parentNode: rootElement,
+ remoteElementId: 'render-container',
+ localName: REMOTE_RENDER_CONTAINER_TAG,
+ });
+ const detachedElement = createFakeRemoteNode({
+ parentNode: null,
+ remoteElementId: 'detached-element',
+ });
+
+ for (const element of [rootElement, renderContainer, detachedElement]) {
+ scrollStore.requestScroll({
+ element,
+ request: { method: 'scrollTo', top: 40 },
+ });
+ scrollStore.requestScroll({
+ element,
+ request: {
+ method: 'scrollIntoView',
+ block: 'start',
+ inline: 'nearest',
+ },
+ });
+ }
+
+ expect(updateRemoteElementPropertyMock).not.toHaveBeenCalled();
+ });
+
+ it('should send nothing before the remote root is known', () => {
+ const scrollStore = createWorkerScrollStore({
+ geometryStore: createWorkerGeometryStoreStub(),
+ });
+ const element = createFakeRemoteNode({
+ parentNode: {},
+ remoteElementId: 'element',
+ });
+
+ scrollStore.requestScroll({
+ element,
+ request: { method: 'scrollTo', top: 40 },
+ });
+
+ expect(updateRemoteElementPropertyMock).not.toHaveBeenCalled();
+ });
+
+ it('should not resolve the geometry snapshot when writing to an element that was never read', () => {
+ const { scrollStore, resolveElementSnapshot, scrollContainer } =
+ createScrollStoreEnvironment();
+
+ scrollStore.requestScroll({
+ element: scrollContainer,
+ request: { method: 'scrollTo', top: 40 },
+ });
+
+ expect(resolveElementSnapshot).not.toHaveBeenCalled();
+ });
+
+ it('should read the geometry offset of an element that is not a scroll command target', () => {
+ const { scrollStore, snapshotByElement, rootElement } =
+ createScrollStoreEnvironment();
+ snapshotByElement.set(
+ rootElement,
+ createElementGeometrySnapshotFixture({ scrollTop: 7 }),
+ );
+
+ expect(
+ scrollStore.readScrollOffset({ element: rootElement, axis: 'top' }),
+ ).toBe(7);
+ });
+
+ it('should enqueue scrollTo commands on the request bridge property and subscribe to host updates once', () => {
+ const { scrollStore, scrollContainer } = createScrollStoreEnvironment();
+
+ scrollStore.requestScroll({
+ element: scrollContainer,
+ request: { method: 'scrollTo', top: 40 },
+ });
+ scrollStore.requestScroll({
+ element: scrollContainer,
+ request: { method: 'scrollTo', left: 10 },
+ });
+
+ expect(updateRemoteElementPropertyMock.mock.calls).toEqual([
+ [scrollContainer, SCROLL_BRIDGE_PROPERTIES.update, expect.any(Function)],
+ [
+ scrollContainer,
+ SCROLL_BRIDGE_PROPERTIES.request,
+ [{ sequence: 1, request: { method: 'scrollTo', top: 40 } }],
+ ],
+ [
+ scrollContainer,
+ SCROLL_BRIDGE_PROPERTIES.request,
+ [
+ { sequence: 1, request: { method: 'scrollTo', top: 40 } },
+ { sequence: 2, request: { method: 'scrollTo', left: 10 } },
+ ],
+ ],
+ ]);
+ });
+
+ it('should drop the oldest pending scroll command once the pending limit is exceeded', () => {
+ const { scrollStore, scrollContainer } = createScrollStoreEnvironment();
+
+ for (
+ let requestedOffset = 1;
+ requestedOffset <= MAX_PENDING_SCROLL_COMMANDS + 1;
+ requestedOffset += 1
+ ) {
+ scrollStore.requestScroll({
+ element: scrollContainer,
+ request: { method: 'scrollTo', top: requestedOffset },
+ });
+ }
+
+ const sentScrollQueues = readSentScrollQueues(scrollContainer);
+
+ expect(sentScrollQueues[sentScrollQueues.length - 1]).toEqual(
+ Array.from(
+ { length: MAX_PENDING_SCROLL_COMMANDS },
+ (_, commandIndex) => ({
+ sequence: commandIndex + 2,
+ request: { method: 'scrollTo', top: commandIndex + 2 },
+ }),
+ ),
+ );
+ });
+
+ it('should return the requested offset immediately after a write', () => {
+ const { scrollStore, scrollContainer } = createScrollStoreEnvironment();
+
+ scrollStore.requestScroll({
+ element: scrollContainer,
+ request: { method: 'scrollTo', top: 120 },
+ });
+
+ expect(
+ scrollStore.readScrollOffset({ element: scrollContainer, axis: 'top' }),
+ ).toBe(120);
+ expect(
+ scrollStore.readScrollOffset({ element: scrollContainer, axis: 'left' }),
+ ).toBe(16);
+ });
+
+ it('should return a negative right-to-left scroll left as written until the host acknowledges it', () => {
+ const { scrollStore, scrollContainer } = createScrollStoreEnvironment();
+
+ scrollStore.requestScroll({
+ element: scrollContainer,
+ request: { method: 'scrollTo', left: -120 },
+ });
+
+ expect(
+ scrollStore.readScrollOffset({ element: scrollContainer, axis: 'left' }),
+ ).toBe(-120);
+ });
+
+ it('should trim acknowledged commands and resend the remaining ones', () => {
+ const { scrollStore, scrollContainer } = createScrollStoreEnvironment();
+
+ scrollStore.requestScroll({
+ element: scrollContainer,
+ request: { method: 'scrollTo', top: 40 },
+ });
+ scrollStore.requestScroll({
+ element: scrollContainer,
+ request: { method: 'scrollTo', top: 80 },
+ });
+ const handleScrollUpdate = readLatestScrollUpdateHandler(scrollContainer);
+ updateRemoteElementPropertyMock.mockClear();
+
+ handleScrollUpdate({
+ scrollCommandSequence: 1,
+ scrollPositions: [
+ { remoteElementId: 'scroll-container', scrollTop: 40, scrollLeft: 16 },
+ ],
+ });
+
+ expect(readSentScrollQueues(scrollContainer)).toEqual([
+ [{ sequence: 2, request: { method: 'scrollTo', top: 80 } }],
+ ]);
+ expect(
+ scrollStore.readScrollOffset({ element: scrollContainer, axis: 'top' }),
+ ).toBe(80);
+ });
+
+ it('should read the acknowledged position once every command is acknowledged', () => {
+ const { scrollStore, scrollContainer } = createScrollStoreEnvironment();
+
+ scrollStore.requestScroll({
+ element: scrollContainer,
+ request: { method: 'scrollTo', top: 400 },
+ });
+ const handleScrollUpdate = readLatestScrollUpdateHandler(scrollContainer);
+ updateRemoteElementPropertyMock.mockClear();
+
+ handleScrollUpdate({
+ scrollCommandSequence: 1,
+ scrollPositions: [
+ { remoteElementId: 'scroll-container', scrollTop: 250, scrollLeft: 0 },
+ ],
+ });
+
+ expect(readSentScrollQueues(scrollContainer)).toEqual([[]]);
+ expect(
+ scrollStore.readScrollOffset({ element: scrollContainer, axis: 'top' }),
+ ).toBe(250);
+ expect(
+ scrollStore.readScrollOffset({ element: scrollContainer, axis: 'left' }),
+ ).toBe(0);
+ });
+
+ it('should read the acknowledged position when the element has no geometry snapshot', () => {
+ const { scrollStore, snapshotByElement, scrollContainer } =
+ createScrollStoreEnvironment();
+ snapshotByElement.delete(scrollContainer);
+
+ scrollStore.requestScroll({
+ element: scrollContainer,
+ request: { method: 'scrollTo', top: 40 },
+ });
+ readLatestScrollUpdateHandler(scrollContainer)({
+ scrollCommandSequence: 1,
+ scrollPositions: [
+ { remoteElementId: 'scroll-container', scrollTop: 35, scrollLeft: 0 },
+ ],
+ });
+
+ expect(
+ scrollStore.readScrollOffset({ element: scrollContainer, axis: 'top' }),
+ ).toBe(35);
+ });
+
+ it('should let a newer geometry snapshot supersede an acknowledged position', () => {
+ const { scrollStore, snapshotByElement, scrollContainer } =
+ createScrollStoreEnvironment();
+
+ scrollStore.requestScroll({
+ element: scrollContainer,
+ request: { method: 'scrollTo', top: 40 },
+ });
+ readLatestScrollUpdateHandler(scrollContainer)({
+ scrollCommandSequence: 1,
+ scrollPositions: [
+ { remoteElementId: 'scroll-container', scrollTop: 40, scrollLeft: 0 },
+ ],
+ });
+
+ expect(
+ scrollStore.readScrollOffset({ element: scrollContainer, axis: 'top' }),
+ ).toBe(40);
+
+ snapshotByElement.set(
+ scrollContainer,
+ createElementGeometrySnapshotFixture({ scrollTop: 90, scrollLeft: 3 }),
+ );
+
+ expect(
+ scrollStore.readScrollOffset({ element: scrollContainer, axis: 'top' }),
+ ).toBe(90);
+ expect(
+ scrollStore.readScrollOffset({ element: scrollContainer, axis: 'left' }),
+ ).toBe(3);
+ });
+
+ it('should record an acknowledged ancestor position on that ancestor and enrol it for geometry', () => {
+ const {
+ scrollStore,
+ resolveElementSnapshot,
+ scrollContainer,
+ scrolledItem,
+ } = createScrollStoreEnvironment();
+
+ scrollStore.requestScroll({
+ element: scrolledItem,
+ request: { method: 'scrollIntoView', block: 'center', inline: 'nearest' },
+ });
+
+ expect(resolveElementSnapshot).not.toHaveBeenCalledWith(scrollContainer);
+
+ readLatestScrollUpdateHandler(scrolledItem)({
+ scrollCommandSequence: 1,
+ scrollPositions: [
+ { remoteElementId: 'scroll-container', scrollTop: 200, scrollLeft: 0 },
+ ],
+ });
+
+ expect(resolveElementSnapshot).toHaveBeenCalledWith(scrollContainer);
+ expect(
+ scrollStore.readScrollOffset({ element: scrollContainer, axis: 'top' }),
+ ).toBe(200);
+ expect(
+ scrollStore.readScrollOffset({ element: scrolledItem, axis: 'top' }),
+ ).toBe(0);
+ });
+
+ it('should ignore acknowledged positions outside the scrolled element ancestor chain', () => {
+ const {
+ scrollStore,
+ snapshotByElement,
+ resolveElementSnapshot,
+ rootElement,
+ scrolledItem,
+ } = createScrollStoreEnvironment();
+ const siblingElement = createFakeRemoteNode({
+ parentNode: rootElement,
+ remoteElementId: 'sibling-element',
+ });
+ snapshotByElement.set(
+ siblingElement,
+ createElementGeometrySnapshotFixture(),
+ );
+
+ scrollStore.requestScroll({
+ element: scrolledItem,
+ request: { method: 'scrollIntoView', block: 'start', inline: 'nearest' },
+ });
+ readLatestScrollUpdateHandler(scrolledItem)({
+ scrollCommandSequence: 1,
+ scrollPositions: [
+ { remoteElementId: 'sibling-element', scrollTop: 300, scrollLeft: 0 },
+ { remoteElementId: 'root', scrollTop: 300, scrollLeft: 0 },
+ ],
+ });
+
+ expect(resolveElementSnapshot).not.toHaveBeenCalledWith(siblingElement);
+ expect(resolveElementSnapshot).not.toHaveBeenCalledWith(rootElement);
+ expect(
+ scrollStore.readScrollOffset({ element: siblingElement, axis: 'top' }),
+ ).toBe(15);
+ });
+
+ it('should elide a write that echoes the last read offset', () => {
+ const { scrollStore, scrollContainer } = createScrollStoreEnvironment();
+
+ const readScrollTop = scrollStore.readScrollOffset({
+ element: scrollContainer,
+ axis: 'top',
+ });
+ scrollStore.requestScroll({
+ element: scrollContainer,
+ request: { method: 'scrollTo', top: readScrollTop },
+ });
+
+ expect(readScrollTop).toBe(15);
+ expect(updateRemoteElementPropertyMock).not.toHaveBeenCalled();
+ });
+
+ it('should send only the axes that differ from the last read offsets', () => {
+ const { scrollStore, scrollContainer } = createScrollStoreEnvironment();
+
+ scrollStore.readScrollOffset({ element: scrollContainer, axis: 'top' });
+ scrollStore.requestScroll({
+ element: scrollContainer,
+ request: { method: 'scrollTo', top: 15, left: 30 },
+ });
+
+ expect(readSentScrollQueues(scrollContainer)).toEqual([
+ [{ sequence: 1, request: { method: 'scrollTo', left: 30 } }],
+ ]);
+ });
+
+ it('should send a zero write to an element that was never read even when its snapshot is already at zero', () => {
+ const { scrollStore, scrolledItem } = createScrollStoreEnvironment();
+
+ scrollStore.requestScroll({
+ element: scrolledItem,
+ request: { method: 'scrollTo', top: 0 },
+ });
+
+ expect(readSentScrollQueues(scrolledItem)).toEqual([
+ [{ sequence: 1, request: { method: 'scrollTo', top: 0 } }],
+ ]);
+ });
+
+ it('should send a write of the last read offset after the host position moved away from it', () => {
+ const { scrollStore, snapshotByElement, scrollContainer } =
+ createScrollStoreEnvironment();
+
+ scrollStore.readScrollOffset({ element: scrollContainer, axis: 'top' });
+ snapshotByElement.set(
+ scrollContainer,
+ createElementGeometrySnapshotFixture({ scrollTop: 50 }),
+ );
+ scrollStore.requestScroll({
+ element: scrollContainer,
+ request: { method: 'scrollTo', top: 15 },
+ });
+
+ expect(readSentScrollQueues(scrollContainer)).toEqual([
+ [{ sequence: 1, request: { method: 'scrollTo', top: 15 } }],
+ ]);
+ });
+
+ it('should send a write of the last read offset after a pending write moved away from it', () => {
+ const { scrollStore, scrollContainer } = createScrollStoreEnvironment();
+
+ scrollStore.readScrollOffset({ element: scrollContainer, axis: 'top' });
+ scrollStore.requestScroll({
+ element: scrollContainer,
+ request: { method: 'scrollTo', top: 40 },
+ });
+ scrollStore.requestScroll({
+ element: scrollContainer,
+ request: { method: 'scrollTo', top: 15 },
+ });
+
+ expect(
+ scrollStore.readScrollOffset({ element: scrollContainer, axis: 'top' }),
+ ).toBe(15);
+ expect(readSentScrollQueues(scrollContainer)).toEqual([
+ [{ sequence: 1, request: { method: 'scrollTo', top: 40 } }],
+ [
+ { sequence: 1, request: { method: 'scrollTo', top: 40 } },
+ { sequence: 2, request: { method: 'scrollTo', top: 15 } },
+ ],
+ ]);
+ });
+
+ it('should send a write echoing an acknowledged position while the element has no geometry snapshot', () => {
+ const { scrollStore, snapshotByElement, scrollContainer } =
+ createScrollStoreEnvironment();
+ snapshotByElement.delete(scrollContainer);
+
+ scrollStore.requestScroll({
+ element: scrollContainer,
+ request: { method: 'scrollTo', top: 120 },
+ });
+ readLatestScrollUpdateHandler(scrollContainer)({
+ scrollCommandSequence: 1,
+ scrollPositions: [
+ { remoteElementId: 'scroll-container', scrollTop: 120, scrollLeft: 0 },
+ ],
+ });
+ const readScrollTop = scrollStore.readScrollOffset({
+ element: scrollContainer,
+ axis: 'top',
+ });
+ scrollStore.requestScroll({
+ element: scrollContainer,
+ request: { method: 'scrollTo', top: readScrollTop },
+ });
+
+ expect(readScrollTop).toBe(120);
+ expect(readSentScrollQueues(scrollContainer)).toEqual([
+ [{ sequence: 1, request: { method: 'scrollTo', top: 120 } }],
+ [],
+ [{ sequence: 2, request: { method: 'scrollTo', top: 120 } }],
+ ]);
+ });
+
+ it('should elide a write echoing a pending write on an element without a geometry snapshot', () => {
+ const { scrollStore, snapshotByElement, scrollContainer } =
+ createScrollStoreEnvironment();
+ snapshotByElement.delete(scrollContainer);
+
+ scrollStore.requestScroll({
+ element: scrollContainer,
+ request: { method: 'scrollTo', top: 40 },
+ });
+ const readScrollTop = scrollStore.readScrollOffset({
+ element: scrollContainer,
+ axis: 'top',
+ });
+ scrollStore.requestScroll({
+ element: scrollContainer,
+ request: { method: 'scrollTo', top: readScrollTop },
+ });
+
+ expect(readScrollTop).toBe(40);
+ expect(readSentScrollQueues(scrollContainer)).toEqual([
+ [{ sequence: 1, request: { method: 'scrollTo', top: 40 } }],
+ ]);
+ });
+
+ it('should send a restore of the last read offset while a descendant reveal is pending', () => {
+ const { scrollStore, scrollContainer, scrolledItem } =
+ createScrollStoreEnvironment();
+
+ const savedScrollTop = scrollStore.readScrollOffset({
+ element: scrollContainer,
+ axis: 'top',
+ });
+ scrollStore.requestScroll({
+ element: scrolledItem,
+ request: {
+ method: 'scrollIntoView',
+ block: 'nearest',
+ inline: 'nearest',
+ },
+ });
+ scrollStore.requestScroll({
+ element: scrollContainer,
+ request: { method: 'scrollTo', top: savedScrollTop },
+ });
+
+ expect(readSentScrollQueues(scrollContainer)).toEqual([
+ [
+ {
+ sequence: 2,
+ request: { method: 'scrollTo', top: savedScrollTop },
+ },
+ ],
+ ]);
+ });
+
+ it('should elide echoed writes again once the descendant reveal is acknowledged', () => {
+ const { scrollStore, scrollContainer, scrolledItem } =
+ createScrollStoreEnvironment();
+
+ scrollStore.requestScroll({
+ element: scrolledItem,
+ request: {
+ method: 'scrollIntoView',
+ block: 'nearest',
+ inline: 'nearest',
+ },
+ });
+ readLatestScrollUpdateHandler(scrolledItem)({
+ scrollCommandSequence: 1,
+ scrollPositions: [],
+ });
+
+ const readScrollTop = scrollStore.readScrollOffset({
+ element: scrollContainer,
+ axis: 'top',
+ });
+ scrollStore.requestScroll({
+ element: scrollContainer,
+ request: { method: 'scrollTo', top: readScrollTop },
+ });
+
+ expect(readSentScrollQueues(scrollContainer)).toEqual([]);
+ });
+
+ it('should never elide scrollIntoView requests', () => {
+ const { scrollStore, scrollContainer } = createScrollStoreEnvironment();
+
+ scrollStore.readScrollOffset({ element: scrollContainer, axis: 'top' });
+ scrollStore.readScrollOffset({ element: scrollContainer, axis: 'left' });
+ scrollStore.requestScroll({
+ element: scrollContainer,
+ request: { method: 'scrollIntoView', block: 'start', inline: 'nearest' },
+ });
+ scrollStore.requestScroll({
+ element: scrollContainer,
+ request: { method: 'scrollIntoView', block: 'start', inline: 'nearest' },
+ });
+
+ expect(readSentScrollQueues(scrollContainer)).toEqual([
+ [
+ {
+ sequence: 1,
+ request: {
+ method: 'scrollIntoView',
+ block: 'start',
+ inline: 'nearest',
+ },
+ },
+ ],
+ [
+ {
+ sequence: 1,
+ request: {
+ method: 'scrollIntoView',
+ block: 'start',
+ inline: 'nearest',
+ },
+ },
+ {
+ sequence: 2,
+ request: {
+ method: 'scrollIntoView',
+ block: 'start',
+ inline: 'nearest',
+ },
+ },
+ ],
+ ]);
+ expect(
+ scrollStore.readScrollOffset({ element: scrollContainer, axis: 'top' }),
+ ).toBe(15);
+ });
+
+ it('should expose event scroll state synchronously and clear it after a microtask', async () => {
+ const { scrollStore, scrollContainer } = createScrollStoreEnvironment();
+
+ scrollStore.observeEventTarget({
+ element: scrollContainer,
+ eventData: {
+ type: 'scroll',
+ scrollTop: 300,
+ scrollLeft: 4,
+ scrollWidth: 900,
+ clientWidth: 200,
+ },
+ });
+
+ expect(
+ scrollStore.readScrollOffset({ element: scrollContainer, axis: 'top' }),
+ ).toBe(300);
+ expect(
+ scrollStore.readScrollOffset({ element: scrollContainer, axis: 'left' }),
+ ).toBe(4);
+ expect(
+ scrollStore.readEventScrollExtent({
+ element: scrollContainer,
+ extent: 'scrollWidth',
+ }),
+ ).toBe(900);
+ expect(
+ scrollStore.readEventScrollExtent({
+ element: scrollContainer,
+ extent: 'clientWidth',
+ }),
+ ).toBe(200);
+
+ await Promise.resolve();
+
+ expect(
+ scrollStore.readScrollOffset({ element: scrollContainer, axis: 'top' }),
+ ).toBe(15);
+ expect(
+ scrollStore.readScrollOffset({ element: scrollContainer, axis: 'left' }),
+ ).toBe(16);
+ expect(
+ scrollStore.readEventScrollExtent({
+ element: scrollContainer,
+ extent: 'scrollWidth',
+ }),
+ ).toBeUndefined();
+ });
+
+ it('should ignore event data without scroll state', () => {
+ const { scrollStore, scrollContainer } = createScrollStoreEnvironment();
+
+ scrollStore.observeEventTarget({
+ element: scrollContainer,
+ eventData: { type: 'click', clientX: 3 },
+ });
+
+ expect(
+ scrollStore.readEventScrollExtent({
+ element: scrollContainer,
+ extent: 'scrollWidth',
+ }),
+ ).toBeUndefined();
+ expect(
+ scrollStore.readScrollOffset({ element: scrollContainer, axis: 'top' }),
+ ).toBe(15);
+ });
+
+ it('should discard the pending commands of a detached element after a microtask sweep', async () => {
+ const { scrollStore, scrollContainer } = createScrollStoreEnvironment();
+
+ scrollStore.requestScroll({
+ element: scrollContainer,
+ request: { method: 'scrollTo', top: 40 },
+ });
+ scrollContainer.parentNode = null;
+ updateRemoteElementPropertyMock.mockClear();
+
+ scrollStore.scheduleDetachedElementSweep();
+
+ expect(updateRemoteElementPropertyMock).not.toHaveBeenCalled();
+
+ await Promise.resolve();
+
+ expect(readSentScrollQueues(scrollContainer)).toEqual([[]]);
+ expect(
+ scrollStore.readScrollOffset({ element: scrollContainer, axis: 'top' }),
+ ).toBe(15);
+ });
+
+ it('should keep the pending commands of elements still attached during a sweep', async () => {
+ const { scrollStore, scrollContainer } = createScrollStoreEnvironment();
+
+ scrollStore.requestScroll({
+ element: scrollContainer,
+ request: { method: 'scrollTo', top: 40 },
+ });
+ updateRemoteElementPropertyMock.mockClear();
+
+ scrollStore.scheduleDetachedElementSweep();
+ await Promise.resolve();
+
+ expect(updateRemoteElementPropertyMock).not.toHaveBeenCalled();
+ expect(
+ scrollStore.readScrollOffset({ element: scrollContainer, axis: 'top' }),
+ ).toBe(40);
+ });
+
+ it('should ignore an acknowledgement for an element detached from the remote root', () => {
+ const { scrollStore, scrollContainer } = createScrollStoreEnvironment();
+
+ scrollStore.requestScroll({
+ element: scrollContainer,
+ request: { method: 'scrollTo', top: 40 },
+ });
+ const handleScrollUpdate = readLatestScrollUpdateHandler(scrollContainer);
+ scrollContainer.parentNode = null;
+ updateRemoteElementPropertyMock.mockClear();
+
+ handleScrollUpdate({
+ scrollCommandSequence: 1,
+ scrollPositions: [
+ { remoteElementId: 'scroll-container', scrollTop: 40, scrollLeft: 0 },
+ ],
+ });
+
+ expect(updateRemoteElementPropertyMock).not.toHaveBeenCalled();
+ });
+
+ it('should ignore an acknowledgement from a subscription replaced by a detached element sweep', async () => {
+ const { scrollStore, rootElement, scrollContainer } =
+ createScrollStoreEnvironment();
+
+ scrollStore.requestScroll({
+ element: scrollContainer,
+ request: { method: 'scrollTo', top: 40 },
+ });
+ const staleScrollUpdateHandler =
+ readLatestScrollUpdateHandler(scrollContainer);
+ scrollContainer.parentNode = null;
+ scrollStore.scheduleDetachedElementSweep();
+ await Promise.resolve();
+ scrollContainer.parentNode = rootElement;
+ scrollStore.requestScroll({
+ element: scrollContainer,
+ request: { method: 'scrollTo', top: 70 },
+ });
+ const currentScrollUpdateHandler =
+ readLatestScrollUpdateHandler(scrollContainer);
+ updateRemoteElementPropertyMock.mockClear();
+
+ staleScrollUpdateHandler({
+ scrollCommandSequence: 2,
+ scrollPositions: [
+ { remoteElementId: 'scroll-container', scrollTop: 70, scrollLeft: 0 },
+ ],
+ });
+
+ expect(currentScrollUpdateHandler).not.toBe(staleScrollUpdateHandler);
+ expect(updateRemoteElementPropertyMock).not.toHaveBeenCalled();
+
+ currentScrollUpdateHandler({
+ scrollCommandSequence: 2,
+ scrollPositions: [
+ { remoteElementId: 'scroll-container', scrollTop: 70, scrollLeft: 0 },
+ ],
+ });
+
+ expect(readSentScrollQueues(scrollContainer)).toEqual([[]]);
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/__tests__/elideEchoedScrollAxes.test.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/__tests__/elideEchoedScrollAxes.test.ts
new file mode 100644
index 00000000000..afed44ac723
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/__tests__/elideEchoedScrollAxes.test.ts
@@ -0,0 +1,108 @@
+import { elideEchoedScrollAxes } from '@/polyfills/scroll/utils/elideEchoedScrollAxes';
+import { type ScrollAxis } from '@/types/ScrollAxis';
+import { type ScrollAxisOffsets } from '@/types/ScrollAxisOffsets';
+
+const readOffsetsFrom =
+ (currentOffsets: ScrollAxisOffsets) => (axis: ScrollAxis) =>
+ currentOffsets[axis];
+
+describe('elideEchoedScrollAxes', () => {
+ it('should drop an axis restoring the offset that was just read and is still current', () => {
+ expect(
+ elideEchoedScrollAxes({
+ requestedOffsets: { top: 120 },
+ lastReadOffsets: { top: 120 },
+ readCurrentOffset: readOffsetsFrom({ top: 120, left: 0 }),
+ }),
+ ).toEqual({});
+ });
+
+ it('should keep a cold reset write when no offset was read before', () => {
+ expect(
+ elideEchoedScrollAxes({
+ requestedOffsets: { top: 0 },
+ lastReadOffsets: undefined,
+ readCurrentOffset: readOffsetsFrom({ top: 0, left: 0 }),
+ }),
+ ).toEqual({ top: 0 });
+ });
+
+ it('should keep an axis when no offset was read on that axis', () => {
+ expect(
+ elideEchoedScrollAxes({
+ requestedOffsets: { left: 0 },
+ lastReadOffsets: { top: 0 },
+ readCurrentOffset: readOffsetsFrom({ top: 0, left: 0 }),
+ }),
+ ).toEqual({ left: 0 });
+ });
+
+ it('should keep an axis equal to the last read offset when the current offset moved', () => {
+ expect(
+ elideEchoedScrollAxes({
+ requestedOffsets: { top: 120 },
+ lastReadOffsets: { top: 120 },
+ readCurrentOffset: readOffsetsFrom({ top: 80, left: 0 }),
+ }),
+ ).toEqual({ top: 120 });
+ });
+
+ it('should keep an axis equal to the current offset when it differs from the last read offset', () => {
+ expect(
+ elideEchoedScrollAxes({
+ requestedOffsets: { top: 120 },
+ lastReadOffsets: { top: 50 },
+ readCurrentOffset: readOffsetsFrom({ top: 120, left: 0 }),
+ }),
+ ).toEqual({ top: 120 });
+ });
+
+ it('should keep an axis whose current offset is unknown', () => {
+ expect(
+ elideEchoedScrollAxes({
+ requestedOffsets: { top: 120 },
+ lastReadOffsets: { top: 120 },
+ readCurrentOffset: readOffsetsFrom({ left: 0 }),
+ }),
+ ).toEqual({ top: 120 });
+ });
+
+ it('should only read the current offset of axes matching their last read offset', () => {
+ const readCurrentOffset = jest.fn(readOffsetsFrom({ top: 120, left: 30 }));
+
+ elideEchoedScrollAxes({
+ requestedOffsets: { top: 120, left: 30 },
+ lastReadOffsets: { top: 120, left: 10 },
+ readCurrentOffset,
+ });
+
+ expect(readCurrentOffset.mock.calls).toEqual([['top']]);
+ });
+
+ it('should decide each axis independently', () => {
+ expect(
+ elideEchoedScrollAxes({
+ requestedOffsets: { top: 120, left: 30 },
+ lastReadOffsets: { top: 120, left: 10 },
+ readCurrentOffset: readOffsetsFrom({ top: 120, left: 30 }),
+ }),
+ ).toEqual({ left: 30 });
+ expect(
+ elideEchoedScrollAxes({
+ requestedOffsets: { top: 200, left: 30 },
+ lastReadOffsets: { top: 120, left: 30 },
+ readCurrentOffset: readOffsetsFrom({ top: 120, left: 30 }),
+ }),
+ ).toEqual({ top: 200 });
+ });
+
+ it('should not add axes that were not requested', () => {
+ expect(
+ elideEchoedScrollAxes({
+ requestedOffsets: {},
+ lastReadOffsets: { top: 120, left: 30 },
+ readCurrentOffset: readOffsetsFrom({ top: 0, left: 0 }),
+ }),
+ ).toEqual({});
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/__tests__/installElementScrollPolyfill.test.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/__tests__/installElementScrollPolyfill.test.ts
new file mode 100644
index 00000000000..dd5b60388f8
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/__tests__/installElementScrollPolyfill.test.ts
@@ -0,0 +1,237 @@
+import { installElementGeometryPolyfill } from '@/polyfills/geometry/utils/installElementGeometryPolyfill';
+import { type WorkerScrollStore } from '@/polyfills/scroll/types/WorkerScrollStore';
+import { installElementScrollPolyfill } from '@/polyfills/scroll/utils/installElementScrollPolyfill';
+import { createElementGeometrySnapshotFixture } from '@/testing/createElementGeometrySnapshotFixture';
+import { createWorkerGeometryStoreStub } from '@/testing/createWorkerGeometryStoreStub';
+
+class ScrollPolyfilledElement {
+ declare scrollTop: number;
+ declare scrollLeft: number;
+ declare scrollWidth: number;
+ declare scrollHeight: number;
+ declare clientWidth: number;
+ declare scrollTo: (...scrollToArguments: unknown[]) => void;
+ declare scroll: (...scrollArguments: unknown[]) => void;
+ declare scrollIntoView: (scrollIntoViewArgument?: unknown) => void;
+}
+
+const createScrollStoreMock = (): jest.Mocked<WorkerScrollStore> => {
+ const scrollStore: jest.Mocked<WorkerScrollStore> = {
+ setRootElement: jest.fn(),
+ readScrollOffset: jest.fn(),
+ readEventScrollExtent: jest.fn(),
+ requestScroll: jest.fn(),
+ observeEventTarget: jest.fn(),
+ scheduleDetachedElementSweep: jest.fn(),
+ };
+
+ scrollStore.readScrollOffset.mockReturnValue(0);
+
+ return scrollStore;
+};
+
+const installScrollPolyfillsOnFakeElement = () => {
+ class FakeElement extends ScrollPolyfilledElement {}
+
+ const scrollStore = createScrollStoreMock();
+
+ installElementGeometryPolyfill({
+ elementPrototype: FakeElement.prototype,
+ documentTarget: {},
+ geometryStore: createWorkerGeometryStoreStub({
+ resolveElementSnapshot: () => createElementGeometrySnapshotFixture(),
+ }),
+ });
+ installElementScrollPolyfill({
+ elementPrototype: FakeElement.prototype,
+ scrollStore,
+ });
+
+ return {
+ element: new FakeElement(),
+ elementPrototype: FakeElement.prototype,
+ scrollStore,
+ };
+};
+
+describe('installElementScrollPolyfill', () => {
+ it('should read offsets from the scroll store', () => {
+ const { element, scrollStore } = installScrollPolyfillsOnFakeElement();
+ scrollStore.readScrollOffset.mockImplementation(({ axis }) =>
+ axis === 'top' ? 120 : 30,
+ );
+
+ expect(element.scrollTop).toBe(120);
+ expect(element.scrollLeft).toBe(30);
+ expect(scrollStore.readScrollOffset.mock.calls).toEqual([
+ [{ element, axis: 'top' }],
+ [{ element, axis: 'left' }],
+ ]);
+ });
+
+ it('should request a scrollTo from the offset setters', () => {
+ const { element, scrollStore } = installScrollPolyfillsOnFakeElement();
+
+ element.scrollTop = 40;
+ element.scrollLeft = 12;
+
+ expect(scrollStore.requestScroll.mock.calls).toEqual([
+ [{ element, request: { method: 'scrollTo', top: 40 } }],
+ [{ element, request: { method: 'scrollTo', left: 12 } }],
+ ]);
+ });
+
+ it('should normalize non-finite and non-numeric offsets written to the setters', () => {
+ const { element, scrollStore } = installScrollPolyfillsOnFakeElement();
+
+ element.scrollTop = Number.NaN;
+ element.scrollLeft = Number.POSITIVE_INFINITY;
+ Reflect.set(element, 'scrollTop', '25');
+
+ expect(scrollStore.requestScroll.mock.calls).toEqual([
+ [{ element, request: { method: 'scrollTo', top: 0 } }],
+ [{ element, request: { method: 'scrollTo', left: 0 } }],
+ [{ element, request: { method: 'scrollTo', top: 25 } }],
+ ]);
+ });
+
+ it('should map scrollTo coordinates and scroll options to scrollTo requests', () => {
+ const { element, scrollStore } = installScrollPolyfillsOnFakeElement();
+
+ element.scrollTo(10, 20);
+ element.scrollTo({ top: 30 });
+ element.scroll({ left: 5 });
+
+ expect(scrollStore.requestScroll.mock.calls).toEqual([
+ [{ element, request: { method: 'scrollTo', left: 10, top: 20 } }],
+ [{ element, request: { method: 'scrollTo', top: 30 } }],
+ [{ element, request: { method: 'scrollTo', left: 5 } }],
+ ]);
+ });
+
+ it('should send nothing when scrollTo is called without offsets', () => {
+ const { element, scrollStore } = installScrollPolyfillsOnFakeElement();
+
+ element.scrollTo();
+ element.scrollTo({});
+ element.scroll(null);
+
+ expect(scrollStore.requestScroll).not.toHaveBeenCalled();
+ });
+
+ it('should throw a TypeError when scrollTo receives a single non-object argument', () => {
+ const { element, scrollStore } = installScrollPolyfillsOnFakeElement();
+
+ expect(() => element.scrollTo(5)).toThrow(TypeError);
+ expect(scrollStore.requestScroll).not.toHaveBeenCalled();
+ });
+
+ it('should map scrollIntoView arguments to block and inline alignments', () => {
+ const { element, scrollStore } = installScrollPolyfillsOnFakeElement();
+
+ element.scrollIntoView();
+ element.scrollIntoView(false);
+ element.scrollIntoView({ block: 'center' });
+
+ expect(scrollStore.requestScroll.mock.calls).toEqual([
+ [
+ {
+ element,
+ request: {
+ method: 'scrollIntoView',
+ block: 'start',
+ inline: 'nearest',
+ },
+ },
+ ],
+ [
+ {
+ element,
+ request: {
+ method: 'scrollIntoView',
+ block: 'end',
+ inline: 'nearest',
+ },
+ },
+ ],
+ [
+ {
+ element,
+ request: {
+ method: 'scrollIntoView',
+ block: 'center',
+ inline: 'nearest',
+ },
+ },
+ ],
+ ]);
+ });
+
+ it('should throw a TypeError when scrollIntoView receives an unknown alignment', () => {
+ const { element, scrollStore } = installScrollPolyfillsOnFakeElement();
+
+ expect(() => element.scrollIntoView({ inline: 'middle' })).toThrow(
+ TypeError,
+ );
+ expect(scrollStore.requestScroll).not.toHaveBeenCalled();
+ });
+
+ it('should prefer an event scroll extent over the geometry extent', () => {
+ const { element, scrollStore } = installScrollPolyfillsOnFakeElement();
+ scrollStore.readEventScrollExtent.mockImplementation(({ extent }) =>
+ extent === 'scrollWidth' ? 900 : undefined,
+ );
+
+ expect(element.scrollWidth).toBe(900);
+ expect(element.clientWidth).toBe(9);
+ expect(scrollStore.readEventScrollExtent).toHaveBeenCalledWith({
+ element,
+ extent: 'clientWidth',
+ });
+ });
+
+ it('should keep an event scroll extent of zero', () => {
+ const { element, scrollStore } = installScrollPolyfillsOnFakeElement();
+ scrollStore.readEventScrollExtent.mockReturnValue(0);
+
+ expect(element.scrollWidth).toBe(0);
+ expect(element.clientWidth).toBe(0);
+ });
+
+ it('should fall back to the geometry extents when no event extent is known', () => {
+ const { element } = installScrollPolyfillsOnFakeElement();
+
+ expect(element.scrollWidth).toBe(13);
+ expect(element.clientWidth).toBe(9);
+ });
+
+ it('should define scrollTo, scroll and scrollIntoView as methods on the element prototype', () => {
+ const { elementPrototype } = installScrollPolyfillsOnFakeElement();
+
+ for (const methodName of ['scrollTo', 'scroll', 'scrollIntoView']) {
+ expect(
+ Object.getOwnPropertyDescriptor(elementPrototype, methodName),
+ ).toEqual(
+ expect.objectContaining({
+ value: expect.any(Function),
+ writable: true,
+ configurable: true,
+ }),
+ );
+ }
+ });
+
+ it('should fall back to zero extents when no geometry getter was installed before it', () => {
+ class BareElement extends ScrollPolyfilledElement {}
+
+ installElementScrollPolyfill({
+ elementPrototype: BareElement.prototype,
+ scrollStore: createScrollStoreMock(),
+ });
+
+ const element = new BareElement();
+
+ expect(element.scrollWidth).toBe(0);
+ expect(element.clientWidth).toBe(0);
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/__tests__/installWindowScrollPolyfill.test.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/__tests__/installWindowScrollPolyfill.test.ts
new file mode 100644
index 00000000000..07a5ecbf818
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/__tests__/installWindowScrollPolyfill.test.ts
@@ -0,0 +1,88 @@
+import { isFunction } from '@sniptt/guards';
+
+import { installWindowScrollPolyfill } from '@/polyfills/scroll/utils/installWindowScrollPolyfill';
+
+const WINDOW_SCROLL_METHOD_NAMES = ['scrollTo', 'scroll', 'scrollBy'];
+
+const callWindowScrollMethod = ({
+ installTarget,
+ methodName,
+ scrollArguments,
+}: {
+ installTarget: Record<string, unknown>;
+ methodName: string;
+ scrollArguments: unknown[];
+}): unknown => {
+ const windowScrollMethod = installTarget[methodName];
+
+ if (!isFunction(windowScrollMethod)) {
+ throw new Error(`Expected ${methodName} to be installed`);
+ }
+
+ return Reflect.apply(windowScrollMethod, installTarget, scrollArguments);
+};
+
+describe('installWindowScrollPolyfill', () => {
+ it('should install no-op scroll methods on the global scope and on a distinct polyfill window', () => {
+ const polyfillWindow: Record<string, unknown> = {};
+ const globalScope: Record<string, unknown> = { window: polyfillWindow };
+
+ installWindowScrollPolyfill({ globalScope });
+
+ for (const installTarget of [globalScope, polyfillWindow]) {
+ for (const methodName of WINDOW_SCROLL_METHOD_NAMES) {
+ expect(
+ callWindowScrollMethod({
+ installTarget,
+ methodName,
+ scrollArguments: [0, 120],
+ }),
+ ).toBeUndefined();
+ expect(
+ callWindowScrollMethod({
+ installTarget,
+ methodName,
+ scrollArguments: [{ top: 120, behavior: 'smooth' }],
+ }),
+ ).toBeUndefined();
+ }
+ }
+ });
+
+ it('should install the scroll methods when the window is the global scope itself', () => {
+ const globalScope: Record<string, unknown> = {};
+ globalScope.window = globalScope;
+
+ installWindowScrollPolyfill({ globalScope });
+
+ for (const methodName of WINDOW_SCROLL_METHOD_NAMES) {
+ expect(
+ callWindowScrollMethod({
+ installTarget: globalScope,
+ methodName,
+ scrollArguments: [],
+ }),
+ ).toBeUndefined();
+ }
+ });
+
+ it('should replace an existing scroll method that throws', () => {
+ const notImplementedScrollTo = jest.fn(() => {
+ throw new Error('Not implemented: window.scrollTo');
+ });
+ const globalScope: Record<string, unknown> = {
+ scrollTo: notImplementedScrollTo,
+ };
+
+ installWindowScrollPolyfill({ globalScope });
+
+ expect(
+ callWindowScrollMethod({
+ installTarget: globalScope,
+ methodName: 'scrollTo',
+ scrollArguments: [0, 120],
+ }),
+ ).toBeUndefined();
+ expect(notImplementedScrollTo).not.toHaveBeenCalled();
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/__tests__/isScrollCommandTarget.test.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/__tests__/isScrollCommandTarget.test.ts
new file mode 100644
index 00000000000..edba36d87d3
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/__tests__/isScrollCommandTarget.test.ts
@@ -0,0 +1,57 @@
+import { REMOTE_RENDER_CONTAINER_TAG } from '@/constants/RemoteRenderContainerTag';
+import { isScrollCommandTarget } from '@/polyfills/scroll/utils/isScrollCommandTarget';
+
+const createNode = ({
+ parentNode = null,
+ localName = 'div',
+}: {
+ parentNode?: object | null;
+ localName?: string;
+} = {}) => ({ parentNode, localName });
+
+describe('isScrollCommandTarget', () => {
+ it('should return true for an element under the root', () => {
+ const rootElement = createNode();
+ const list = createNode({ parentNode: rootElement });
+ const item = createNode({ parentNode: list });
+
+ expect(isScrollCommandTarget({ element: list, rootElement })).toBe(true);
+ expect(isScrollCommandTarget({ element: item, rootElement })).toBe(true);
+ });
+
+ it('should return false for the root itself', () => {
+ const rootElement = createNode();
+
+ expect(isScrollCommandTarget({ element: rootElement, rootElement })).toBe(
+ false,
+ );
+ });
+
+ it('should return false for a remote render container under the root', () => {
+ const rootElement = createNode();
+ const renderContainer = createNode({
+ parentNode: rootElement,
+ localName: REMOTE_RENDER_CONTAINER_TAG,
+ });
+
+ expect(
+ isScrollCommandTarget({ element: renderContainer, rootElement }),
+ ).toBe(false);
+ });
+
+ it('should return false for a detached element', () => {
+ const rootElement = createNode();
+ const detachedParent = createNode();
+ const detachedElement = createNode({ parentNode: detachedParent });
+
+ expect(
+ isScrollCommandTarget({ element: detachedElement, rootElement }),
+ ).toBe(false);
+ });
+
+ it('should return false when there is no root', () => {
+ const element = createNode({ parentNode: createNode() });
+
+ expect(isScrollCommandTarget({ element, rootElement: null })).toBe(false);
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/__tests__/normalizeScrollIntoViewArguments.test.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/__tests__/normalizeScrollIntoViewArguments.test.ts
new file mode 100644
index 00000000000..111e74e98d1
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/__tests__/normalizeScrollIntoViewArguments.test.ts
@@ -0,0 +1,83 @@
+import { normalizeScrollIntoViewArguments } from '@/polyfills/scroll/utils/normalizeScrollIntoViewArguments';
+
+describe('normalizeScrollIntoViewArguments', () => {
+ it('should align to the start for undefined, null and true', () => {
+ const startAlignments = { block: 'start', inline: 'nearest' };
+
+ expect(normalizeScrollIntoViewArguments(undefined)).toEqual(
+ startAlignments,
+ );
+ expect(normalizeScrollIntoViewArguments(null)).toEqual(startAlignments);
+ expect(normalizeScrollIntoViewArguments(true)).toEqual(startAlignments);
+ });
+
+ it('should align to the end for false', () => {
+ expect(normalizeScrollIntoViewArguments(false)).toEqual({
+ block: 'end',
+ inline: 'nearest',
+ });
+ });
+
+ it('should align truthy primitives to the start', () => {
+ const startAlignments = { block: 'start', inline: 'nearest' };
+
+ expect(normalizeScrollIntoViewArguments(1)).toEqual(startAlignments);
+ expect(normalizeScrollIntoViewArguments('center')).toEqual(startAlignments);
+ });
+
+ it('should align falsy primitives to the end', () => {
+ const endAlignments = { block: 'end', inline: 'nearest' };
+
+ expect(normalizeScrollIntoViewArguments(0)).toEqual(endAlignments);
+ expect(normalizeScrollIntoViewArguments('')).toEqual(endAlignments);
+ expect(normalizeScrollIntoViewArguments(Number.NaN)).toEqual(endAlignments);
+ });
+
+ it('should default an empty options object to block start and inline nearest', () => {
+ expect(normalizeScrollIntoViewArguments({})).toEqual({
+ block: 'start',
+ inline: 'nearest',
+ });
+ });
+
+ it('should default only the alignment the options leave undefined', () => {
+ expect(normalizeScrollIntoViewArguments({ block: 'center' })).toEqual({
+ block: 'center',
+ inline: 'nearest',
+ });
+ expect(normalizeScrollIntoViewArguments({ inline: 'end' })).toEqual({
+ block: 'start',
+ inline: 'end',
+ });
+ });
+
+ it('should keep every valid alignment passed explicitly', () => {
+ for (const alignment of ['start', 'center', 'end', 'nearest']) {
+ expect(
+ normalizeScrollIntoViewArguments({
+ block: alignment,
+ inline: alignment,
+ behavior: 'smooth',
+ }),
+ ).toEqual({ block: alignment, inline: alignment });
+ }
+ });
+
+ it('should throw a type error for an invalid block alignment', () => {
+ expect(() => normalizeScrollIntoViewArguments({ block: 'top' })).toThrow(
+ TypeError,
+ );
+ });
+
+ it('should throw a type error for an invalid inline alignment', () => {
+ expect(() =>
+ normalizeScrollIntoViewArguments({ inline: 'middle' }),
+ ).toThrow(TypeError);
+ });
+
+ it('should throw a type error for a null alignment', () => {
+ expect(() => normalizeScrollIntoViewArguments({ block: null })).toThrow(
+ TypeError,
+ );
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/__tests__/normalizeScrollOffset.test.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/__tests__/normalizeScrollOffset.test.ts
new file mode 100644
index 00000000000..ce15db3396b
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/__tests__/normalizeScrollOffset.test.ts
@@ -0,0 +1,27 @@
+import { normalizeScrollOffset } from '@/polyfills/scroll/utils/normalizeScrollOffset';
+
+describe('normalizeScrollOffset', () => {
+ it('should keep finite numbers including negative and fractional offsets', () => {
+ expect(normalizeScrollOffset(120)).toBe(120);
+ expect(normalizeScrollOffset(-48)).toBe(-48);
+ expect(normalizeScrollOffset(12.5)).toBe(12.5);
+ });
+
+ it('should convert numeric strings to numbers', () => {
+ expect(normalizeScrollOffset('42')).toBe(42);
+ expect(normalizeScrollOffset('-7.5')).toBe(-7.5);
+ expect(normalizeScrollOffset(' 16 ')).toBe(16);
+ });
+
+ it('should return zero for non-finite numbers', () => {
+ expect(normalizeScrollOffset(Number.NaN)).toBe(0);
+ expect(normalizeScrollOffset(Number.POSITIVE_INFINITY)).toBe(0);
+ expect(normalizeScrollOffset(Number.NEGATIVE_INFINITY)).toBe(0);
+ });
+
+ it('should return zero for undefined and non-numeric strings', () => {
+ expect(normalizeScrollOffset(undefined)).toBe(0);
+ expect(normalizeScrollOffset('auto')).toBe(0);
+ expect(normalizeScrollOffset('12px')).toBe(0);
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/__tests__/normalizeScrollToArguments.test.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/__tests__/normalizeScrollToArguments.test.ts
new file mode 100644
index 00000000000..c1e3bfb9fb2
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/__tests__/normalizeScrollToArguments.test.ts
@@ -0,0 +1,65 @@
+import { normalizeScrollToArguments } from '@/polyfills/scroll/utils/normalizeScrollToArguments';
+
+describe('normalizeScrollToArguments', () => {
+ it('should map the two coordinate arguments to left and top', () => {
+ expect(normalizeScrollToArguments([30, 120])).toEqual({
+ left: 30,
+ top: 120,
+ });
+ });
+
+ it('should normalize both coordinate arguments', () => {
+ expect(normalizeScrollToArguments(['15', Number.NaN])).toEqual({
+ left: 15,
+ top: 0,
+ });
+ });
+
+ it('should return no offsets when called without arguments', () => {
+ expect(normalizeScrollToArguments([])).toEqual({});
+ });
+
+ it('should return no offsets for an undefined or null options argument', () => {
+ expect(normalizeScrollToArguments([undefined])).toEqual({});
+ expect(normalizeScrollToArguments([null])).toEqual({});
+ });
+
+ it('should keep only the top axis when the options only define top', () => {
+ expect(normalizeScrollToArguments([{ top: 80 }])).toEqual({ top: 80 });
+ });
+
+ it('should keep only the left axis when the options only define left', () => {
+ expect(normalizeScrollToArguments([{ left: 64 }])).toEqual({ left: 64 });
+ });
+
+ it('should keep both axes when the options define top and left', () => {
+ expect(
+ normalizeScrollToArguments([{ top: 10, left: 20, behavior: 'smooth' }]),
+ ).toEqual({ top: 10, left: 20 });
+ });
+
+ it('should normalize the option values', () => {
+ expect(
+ normalizeScrollToArguments([
+ { top: '200', left: Number.POSITIVE_INFINITY },
+ ]),
+ ).toEqual({ top: 200, left: 0 });
+ });
+
+ it('should convert null option values to zero', () => {
+ expect(normalizeScrollToArguments([{ top: null, left: null }])).toEqual({
+ top: 0,
+ left: 0,
+ });
+ });
+
+ it('should treat a function argument as empty options', () => {
+ expect(normalizeScrollToArguments([() => undefined])).toEqual({});
+ });
+
+ it('should throw a type error for a single primitive argument', () => {
+ expect(() => normalizeScrollToArguments([5])).toThrow(TypeError);
+ expect(() => normalizeScrollToArguments(['top'])).toThrow(TypeError);
+ expect(() => normalizeScrollToArguments([true])).toThrow(TypeError);
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/__tests__/readSerializedEventScrollState.test.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/__tests__/readSerializedEventScrollState.test.ts
new file mode 100644
index 00000000000..28752506b75
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/__tests__/readSerializedEventScrollState.test.ts
@@ -0,0 +1,59 @@
+import { readSerializedEventScrollState } from '@/polyfills/scroll/utils/readSerializedEventScrollState';
+
+describe('readSerializedEventScrollState', () => {
+ it('should pick only the scroll state from the serialized event', () => {
+ expect(
+ readSerializedEventScrollState({
+ type: 'scroll',
+ bubbles: false,
+ targetRemoteElementId: '7',
+ scrollTop: 120,
+ scrollLeft: -40,
+ scrollWidth: 900,
+ clientWidth: 300,
+ clientX: 12,
+ deltaY: 3,
+ }),
+ ).toEqual({
+ scrollTop: 120,
+ scrollLeft: -40,
+ scrollWidth: 900,
+ clientWidth: 300,
+ });
+ });
+
+ it('should keep a zero scroll offset', () => {
+ expect(
+ readSerializedEventScrollState({ type: 'scroll', scrollTop: 0 }),
+ ).toEqual({ scrollTop: 0 });
+ });
+
+ it('should skip values that are not finite numbers', () => {
+ expect(
+ readSerializedEventScrollState({
+ type: 'scroll',
+ scrollLeft: Number.NaN,
+ scrollWidth: 640,
+ }),
+ ).toEqual({ scrollWidth: 640 });
+ });
+
+ it('should return null when the event carries no scroll state', () => {
+ expect(
+ readSerializedEventScrollState({
+ type: 'wheel',
+ deltaX: 4,
+ deltaY: 12,
+ }),
+ ).toBeNull();
+ });
+
+ it('should return null when every scroll value is invalid', () => {
+ expect(
+ readSerializedEventScrollState({
+ type: 'scroll',
+ scrollTop: Number.NaN,
+ }),
+ ).toBeNull();
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/__tests__/resolveOptimisticScrollOffset.test.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/__tests__/resolveOptimisticScrollOffset.test.ts
new file mode 100644
index 00000000000..f9b8034f3ef
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/__tests__/resolveOptimisticScrollOffset.test.ts
@@ -0,0 +1,103 @@
+import { resolveOptimisticScrollOffset } from '@/polyfills/scroll/utils/resolveOptimisticScrollOffset';
+import { type ScrollCommand } from '@/types/ScrollCommand';
+import { type ScrollRequest } from '@/types/ScrollRequest';
+
+const createScrollCommands = (requests: ScrollRequest[]): ScrollCommand[] =>
+ requests.map((request, requestIndex) => ({
+ sequence: requestIndex + 1,
+ request,
+ }));
+
+describe('resolveOptimisticScrollOffset', () => {
+ it('should return the host offset when no command is pending', () => {
+ expect(
+ resolveOptimisticScrollOffset({
+ hostOffset: 140,
+ pendingCommands: [],
+ axis: 'top',
+ }),
+ ).toBe(140);
+ });
+
+ it('should return the offset of the latest pending scroll on the axis', () => {
+ expect(
+ resolveOptimisticScrollOffset({
+ hostOffset: 0,
+ pendingCommands: createScrollCommands([
+ { method: 'scrollTo', top: 50 },
+ { method: 'scrollTo', top: 80, left: 10 },
+ ]),
+ axis: 'top',
+ }),
+ ).toBe(80);
+ });
+
+ it('should ignore pending scrolls that only target the other axis', () => {
+ expect(
+ resolveOptimisticScrollOffset({
+ hostOffset: 20,
+ pendingCommands: createScrollCommands([
+ { method: 'scrollTo', top: 300 },
+ ]),
+ axis: 'left',
+ }),
+ ).toBe(20);
+ });
+
+ it('should keep the latest axis offset when a later scroll only targets the other axis', () => {
+ expect(
+ resolveOptimisticScrollOffset({
+ hostOffset: 0,
+ pendingCommands: createScrollCommands([
+ { method: 'scrollTo', top: 90 },
+ { method: 'scrollTo', left: 40 },
+ ]),
+ axis: 'top',
+ }),
+ ).toBe(90);
+ });
+
+ it('should ignore pending scroll into view commands', () => {
+ expect(
+ resolveOptimisticScrollOffset({
+ hostOffset: 60,
+ pendingCommands: createScrollCommands([
+ { method: 'scrollIntoView', block: 'start', inline: 'nearest' },
+ ]),
+ axis: 'top',
+ }),
+ ).toBe(60);
+ expect(
+ resolveOptimisticScrollOffset({
+ hostOffset: 0,
+ pendingCommands: createScrollCommands([
+ { method: 'scrollTo', top: 75 },
+ { method: 'scrollIntoView', block: 'end', inline: 'center' },
+ ]),
+ axis: 'top',
+ }),
+ ).toBe(75);
+ });
+
+ it('should keep a negative right-to-left host offset without clamping', () => {
+ expect(
+ resolveOptimisticScrollOffset({
+ hostOffset: -45,
+ pendingCommands: [],
+ axis: 'left',
+ }),
+ ).toBe(-45);
+ });
+
+ it('should keep a negative right-to-left pending offset without clamping', () => {
+ expect(
+ resolveOptimisticScrollOffset({
+ hostOffset: 0,
+ pendingCommands: createScrollCommands([
+ { method: 'scrollTo', left: -120 },
+ ]),
+ axis: 'left',
+ }),
+ ).toBe(-120);
+ });
+});
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/createScrollPositionRequest.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/createScrollPositionRequest.ts
new file mode 100644
index 00000000000..12ea9da7343
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/createScrollPositionRequest.ts
@@ -0,0 +1,13 @@
+import { type ScrollAxis } from '@/types/ScrollAxis';
+import { type ScrollPositionRequest } from '@/types/ScrollPositionRequest';
+
+export const createScrollPositionRequest = ({
+ axis,
+ offset,
+}: {
+ axis: ScrollAxis;
+ offset: number;
+}): ScrollPositionRequest =>
+ axis === 'top'
+ ? { method: 'scrollTo', top: offset }
+ : { method: 'scrollTo', left: offset };
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/createWorkerScrollStore.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/createWorkerScrollStore.ts
new file mode 100644
index 00000000000..e97de6c3072
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/createWorkerScrollStore.ts
@@ -0,0 +1,278 @@
+import { isNumber } from '@sniptt/guards';
+import { isDefined } from 'twenty-shared/utils';
+
+import { MAX_PENDING_SCROLL_COMMANDS } from '@/constants/MaxPendingScrollCommands';
+import { SCROLL_BRIDGE_PROPERTIES } from '@/constants/ScrollBridgeProperties';
+import { findSelfOrAncestorByRemoteId } from '@/polyfills/dom/utils/findSelfOrAncestorByRemoteId';
+import { isAncestorOrSelfOfNode } from '@/polyfills/dom/utils/isAncestorOrSelfOfNode';
+import { type WorkerGeometryStore } from '@/polyfills/geometry/types/WorkerGeometryStore';
+import { SCROLL_OFFSET_PROPERTY_BY_AXIS } from '@/polyfills/scroll/constants/ScrollOffsetPropertyByAxis';
+import { type AcknowledgedScrollPosition } from '@/polyfills/scroll/types/AcknowledgedScrollPosition';
+import { type EventScrollState } from '@/polyfills/scroll/types/EventScrollState';
+import { type HostScrollOffset } from '@/polyfills/scroll/types/HostScrollOffset';
+import { type WorkerScrollStore } from '@/polyfills/scroll/types/WorkerScrollStore';
+import { elideEchoedScrollAxes } from '@/polyfills/scroll/utils/elideEchoedScrollAxes';
+import { hasPendingScrollWriteOnAxis } from '@/polyfills/scroll/utils/hasPendingScrollWriteOnAxis';
+import { isScrollCommandTarget } from '@/polyfills/scroll/utils/isScrollCommandTarget';
+import { readSerializedEventScrollState } from '@/polyfills/scroll/utils/readSerializedEventScrollState';
+import { resolveOptimisticScrollOffset } from '@/polyfills/scroll/utils/resolveOptimisticScrollOffset';
+import { createRemoteElementCommandQueue } from '@/polyfills/utils/createRemoteElementCommandQueue';
+import { createRemoteElementHostSubscriptions } from '@/polyfills/utils/createRemoteElementHostSubscriptions';
+import { type ScrollAxis } from '@/types/ScrollAxis';
+import { type ScrollAxisOffsets } from '@/types/ScrollAxisOffsets';
+import { type ScrollCommandAcknowledgement } from '@/types/ScrollCommandAcknowledgement';
+import { type ScrolledElementPosition } from '@/types/ScrolledElementPosition';
+import { type ScrollRequest } from '@/types/ScrollRequest';
+
+export const createWorkerScrollStore = ({
+ geometryStore,
+}: {
+ geometryStore: WorkerGeometryStore;
+}): WorkerScrollStore => {
+ const commandQueue = createRemoteElementCommandQueue<ScrollRequest>({
+ bridgeProperty: SCROLL_BRIDGE_PROPERTIES.request,
+ maxPendingCommands: MAX_PENDING_SCROLL_COMMANDS,
+ });
+ const acknowledgedScrollPositions = new WeakMap<
+ object,
+ AcknowledgedScrollPosition
+ >();
+ const lastReadScrollOffsets = new WeakMap<object, ScrollAxisOffsets>();
+ const eventScrollStates = new Map<object, EventScrollState>();
+ const pendingRevealTargets = new Set<object>();
+
+ let rootElement: object | null = null;
+ let hasScheduledEventScrollStateClear = false;
+
+ const readHostScrollOffset = ({
+ element,
+ axis,
+ }: {
+ element: object;
+ axis: ScrollAxis;
+ }): HostScrollOffset => {
+ const scrollOffsetProperty = SCROLL_OFFSET_PROPERTY_BY_AXIS[axis];
+ const eventScrollOffset =
+ eventScrollStates.get(element)?.[scrollOffsetProperty];
+
+ if (isDefined(eventScrollOffset)) {
+ return { offset: eventScrollOffset, isMeasured: true };
+ }
+
+ const snapshot = geometryStore.resolveElementSnapshot(element);
+ const acknowledgedScrollPosition = acknowledgedScrollPositions.get(element);
+ const isMeasured = isDefined(snapshot);
+
+ if (
+ isDefined(acknowledgedScrollPosition) &&
+ acknowledgedScrollPosition.baseSnapshot === snapshot
+ ) {
+ return { offset: acknowledgedScrollPosition[axis], isMeasured };
+ }
+
+ return { offset: snapshot?.[scrollOffsetProperty] ?? 0, isMeasured };
+ };
+
+ const readCurrentScrollOffset = ({
+ element,
+ axis,
+ }: {
+ element: object;
+ axis: ScrollAxis;
+ }): number =>
+ resolveOptimisticScrollOffset({
+ hostOffset: readHostScrollOffset({ element, axis }).offset,
+ pendingCommands: commandQueue.readPendingCommands(element),
+ axis,
+ });
+
+ const readMeasuredScrollOffset = ({
+ element,
+ axis,
+ }: {
+ element: object;
+ axis: ScrollAxis;
+ }): number | undefined => {
+ const hostScrollOffset = readHostScrollOffset({ element, axis });
+ const pendingCommands = commandQueue.readPendingCommands(element);
+
+ if (
+ !hostScrollOffset.isMeasured &&
+ !hasPendingScrollWriteOnAxis({ pendingCommands, axis })
+ ) {
+ return undefined;
+ }
+
+ return resolveOptimisticScrollOffset({
+ hostOffset: hostScrollOffset.offset,
+ pendingCommands,
+ axis,
+ });
+ };
+
+ const recordAcknowledgedScrollPosition = ({
+ element,
+ scrolledElementPosition,
+ }: {
+ element: object;
+ scrolledElementPosition: ScrolledElementPosition;
+ }): void => {
+ const { remoteElementId, scrollTop, scrollLeft } = scrolledElementPosition;
+
+ if (!isNumber(scrollTop) || !isNumber(scrollLeft)) {
+ return;
+ }
+
+ const scrolledElement = findSelfOrAncestorByRemoteId({
+ element,
+ remoteElementId,
+ rootElement,
+ });
+
+ if (!isDefined(scrolledElement)) {
+ return;
+ }
+
+ acknowledgedScrollPositions.set(scrolledElement, {
+ top: scrollTop,
+ left: scrollLeft,
+ baseSnapshot: geometryStore.resolveElementSnapshot(scrolledElement),
+ });
+ hostScrollSubscriptions.trackElement(scrolledElement);
+ };
+
+ const forgetSettledRevealTarget = (element: object): void => {
+ const hasPendingReveal = commandQueue
+ .readPendingCommands(element)
+ .some(({ request }) => request.method === 'scrollIntoView');
+
+ if (!hasPendingReveal) {
+ pendingRevealTargets.delete(element);
+ }
+ };
+
+ const hasPendingRevealInside = (element: object): boolean => {
+ for (const revealTarget of pendingRevealTargets) {
+ if (
+ revealTarget !== element &&
+ isAncestorOrSelfOfNode(element, revealTarget)
+ ) {
+ return true;
+ }
+ }
+
+ return false;
+ };
+
+ const hostScrollSubscriptions =
+ createRemoteElementHostSubscriptions<ScrollCommandAcknowledgement>({
+ updateBridgeProperty: SCROLL_BRIDGE_PROPERTIES.update,
+ readRootElement: () => rootElement,
+ onHostUpdate: ({ element, hostUpdate: acknowledgement }) => {
+ commandQueue.acknowledgeCommands({
+ element,
+ acknowledgedCommandSequence: acknowledgement.scrollCommandSequence,
+ });
+ forgetSettledRevealTarget(element);
+
+ for (const scrolledElementPosition of acknowledgement.scrollPositions) {
+ recordAcknowledgedScrollPosition({
+ element,
+ scrolledElementPosition,
+ });
+ }
+ },
+ onForgetElement: (element) => {
+ pendingRevealTargets.delete(element);
+ acknowledgedScrollPositions.delete(element);
+ lastReadScrollOffsets.delete(element);
+ commandQueue.discardPendingCommands(element);
+ },
+ });
+
+ const clearEventScrollStates = (): void => {
+ hasScheduledEventScrollStateClear = false;
+ eventScrollStates.clear();
+ };
+
+ const resolveRequestToEnqueue = ({
+ element,
+ request,
+ }: {
+ element: object;
+ request: ScrollRequest;
+ }): ScrollRequest | null => {
+ if (
+ request.method === 'scrollIntoView' ||
+ hasPendingRevealInside(element)
+ ) {
+ return request;
+ }
+
+ const remainingOffsets = elideEchoedScrollAxes({
+ requestedOffsets: request,
+ lastReadOffsets: lastReadScrollOffsets.get(element),
+ readCurrentOffset: (axis) => readMeasuredScrollOffset({ element, axis }),
+ });
+
+ if (!isDefined(remainingOffsets.top) && !isDefined(remainingOffsets.left)) {
+ return null;
+ }
+
+ return { method: 'scrollTo', ...remainingOffsets };
+ };
+
+ return {
+ setRootElement: (nextRootElement) => {
+ rootElement = nextRootElement;
+ },
+ readScrollOffset: ({ element, axis }) => {
+ const scrollOffset = readCurrentScrollOffset({ element, axis });
+
+ lastReadScrollOffsets.set(element, {
+ ...lastReadScrollOffsets.get(element),
+ [axis]: scrollOffset,
+ });
+
+ return scrollOffset;
+ },
+ readEventScrollExtent: ({ element, extent }) =>
+ eventScrollStates.get(element)?.[extent],
+ requestScroll: ({ element, request }) => {
+ if (!isScrollCommandTarget({ element, rootElement })) {
+ return;
+ }
+
+ const requestToEnqueue = resolveRequestToEnqueue({ element, request });
+
+ if (!isDefined(requestToEnqueue)) {
+ return;
+ }
+
+ hostScrollSubscriptions.subscribe(element);
+ commandQueue.enqueueCommand({ element, request: requestToEnqueue });
+
+ if (requestToEnqueue.method === 'scrollIntoView') {
+ pendingRevealTargets.add(element);
+ }
+ },
+ observeEventTarget: ({ element, eventData }) => {
+ const eventScrollState = readSerializedEventScrollState(eventData);
+
+ if (!isDefined(eventScrollState)) {
+ return;
+ }
+
+ eventScrollStates.set(element, eventScrollState);
+
+ if (hasScheduledEventScrollStateClear) {
+ return;
+ }
+
+ hasScheduledEventScrollStateClear = true;
+ queueMicrotask(clearEventScrollStates);
+ },
+ scheduleDetachedElementSweep:
+ hostScrollSubscriptions.scheduleDetachedElementSweep,
+ };
+};
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/elideEchoedScrollAxes.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/elideEchoedScrollAxes.ts
new file mode 100644
index 00000000000..12ea4a0082c
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/elideEchoedScrollAxes.ts
@@ -0,0 +1,35 @@
+import { isDefined } from 'twenty-shared/utils';
+
+import { SCROLL_AXES } from '@/constants/ScrollAxes';
+import { type ScrollAxis } from '@/types/ScrollAxis';
+import { type ScrollAxisOffsets } from '@/types/ScrollAxisOffsets';
+
+export const elideEchoedScrollAxes = ({
+ requestedOffsets,
+ lastReadOffsets,
+ readCurrentOffset,
+}: {
+ requestedOffsets: ScrollAxisOffsets;
+ lastReadOffsets: ScrollAxisOffsets | undefined;
+ readCurrentOffset: (axis: ScrollAxis) => number | undefined;
+}): ScrollAxisOffsets => {
+ const remainingOffsets: ScrollAxisOffsets = {};
+
+ for (const axis of SCROLL_AXES) {
+ const requestedOffset = requestedOffsets[axis];
+
+ if (!isDefined(requestedOffset)) {
+ continue;
+ }
+
+ const isEchoOfLastRead =
+ requestedOffset === lastReadOffsets?.[axis] &&
+ requestedOffset === readCurrentOffset(axis);
+
+ if (!isEchoOfLastRead) {
+ remainingOffsets[axis] = requestedOffset;
+ }
+ }
+
+ return remainingOffsets;
+};
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/hasPendingScrollWriteOnAxis.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/hasPendingScrollWriteOnAxis.ts
new file mode 100644
index 00000000000..cf0db96532d
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/hasPendingScrollWriteOnAxis.ts
@@ -0,0 +1,16 @@
+import { isDefined } from 'twenty-shared/utils';
+
+import { readScrollToOffsetOnAxis } from '@/polyfills/scroll/utils/readScrollToOffsetOnAxis';
+import { type ScrollAxis } from '@/types/ScrollAxis';
+import { type ScrollCommand } from '@/types/ScrollCommand';
+
+export const hasPendingScrollWriteOnAxis = ({
+ pendingCommands,
+ axis,
+}: {
+ pendingCommands: ScrollCommand[];
+ axis: ScrollAxis;
+}): boolean =>
+ pendingCommands.some(({ request }) =>
+ isDefined(readScrollToOffsetOnAxis({ request, axis })),
+ );
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/installElementScrollPolyfill.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/installElementScrollPolyfill.ts
new file mode 100644
index 00000000000..d164aa49c35
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/installElementScrollPolyfill.ts
@@ -0,0 +1,103 @@
+import { isDefined, typedObjectEntries } from 'twenty-shared/utils';
+
+import { SCROLL_OFFSET_PROPERTY_BY_AXIS } from '@/polyfills/scroll/constants/ScrollOffsetPropertyByAxis';
+import { type EventScrollExtent } from '@/polyfills/scroll/types/EventScrollExtent';
+import { type WorkerScrollStore } from '@/polyfills/scroll/types/WorkerScrollStore';
+import { createScrollPositionRequest } from '@/polyfills/scroll/utils/createScrollPositionRequest';
+import { normalizeScrollIntoViewArguments } from '@/polyfills/scroll/utils/normalizeScrollIntoViewArguments';
+import { normalizeScrollOffset } from '@/polyfills/scroll/utils/normalizeScrollOffset';
+import { normalizeScrollToArguments } from '@/polyfills/scroll/utils/normalizeScrollToArguments';
+import { readPrototypeNumberGetter } from '@/polyfills/scroll/utils/readPrototypeNumberGetter';
+import { definePolyfillMethod } from '@/polyfills/utils/definePolyfillMethod';
+
+const EVENT_SCROLL_EXTENTS: EventScrollExtent[] = [
+ 'scrollWidth',
+ 'clientWidth',
+];
+
+const SCROLL_TO_METHOD_NAMES = ['scrollTo', 'scroll'];
+
+export const installElementScrollPolyfill = ({
+ elementPrototype,
+ scrollStore,
+}: {
+ elementPrototype: object;
+ scrollStore: WorkerScrollStore;
+}): void => {
+ for (const [axis, propertyName] of typedObjectEntries(
+ SCROLL_OFFSET_PROPERTY_BY_AXIS,
+ )) {
+ Object.defineProperty(elementPrototype, propertyName, {
+ get(this: object) {
+ return scrollStore.readScrollOffset({ element: this, axis });
+ },
+ set(this: object, value: unknown) {
+ scrollStore.requestScroll({
+ element: this,
+ request: createScrollPositionRequest({
+ axis,
+ offset: normalizeScrollOffset(value),
+ }),
+ });
+ },
+ configurable: true,
+ });
+ }
+
+ for (const extent of EVENT_SCROLL_EXTENTS) {
+ const readBaseExtent = readPrototypeNumberGetter({
+ prototype: elementPrototype,
+ propertyName: extent,
+ });
+
+ Object.defineProperty(elementPrototype, extent, {
+ get(this: object) {
+ const eventScrollExtent = scrollStore.readEventScrollExtent({
+ element: this,
+ extent,
+ });
+
+ return isDefined(eventScrollExtent)
+ ? eventScrollExtent
+ : readBaseExtent(this);
+ },
+ configurable: true,
+ });
+ }
+
+ for (const methodName of SCROLL_TO_METHOD_NAMES) {
+ definePolyfillMethod<object>({
+ target: elementPrototype,
+ methodName,
+ method: (element, ...scrollToArguments) => {
+ const scrollAxisOffsets = normalizeScrollToArguments(scrollToArguments);
+
+ if (
+ !isDefined(scrollAxisOffsets.top) &&
+ !isDefined(scrollAxisOffsets.left)
+ ) {
+ return;
+ }
+
+ scrollStore.requestScroll({
+ element,
+ request: { method: 'scrollTo', ...scrollAxisOffsets },
+ });
+ },
+ });
+ }
+
+ definePolyfillMethod<object>({
+ target: elementPrototype,
+ methodName: 'scrollIntoView',
+ method: (element, scrollIntoViewArgument) => {
+ scrollStore.requestScroll({
+ element,
+ request: {
+ method: 'scrollIntoView',
+ ...normalizeScrollIntoViewArguments(scrollIntoViewArgument),
+ },
+ });
+ },
+ });
+};
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/installWindowScrollPolyfill.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/installWindowScrollPolyfill.ts
new file mode 100644
index 00000000000..9e69e76e503
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/installWindowScrollPolyfill.ts
@@ -0,0 +1,20 @@
+import { definePolyfillMethod } from '@/polyfills/utils/definePolyfillMethod';
+import { resolveGlobalScopeInstallTargets } from '@/polyfills/utils/resolveGlobalScopeInstallTargets';
+
+const WINDOW_SCROLL_METHOD_NAMES = ['scrollTo', 'scroll', 'scrollBy'];
+
+export const installWindowScrollPolyfill = ({
+ globalScope,
+}: {
+ globalScope: Record<string, unknown>;
+}): void => {
+ for (const installTarget of resolveGlobalScopeInstallTargets(globalScope)) {
+ for (const methodName of WINDOW_SCROLL_METHOD_NAMES) {
+ definePolyfillMethod({
+ target: installTarget,
+ methodName,
+ method: () => undefined,
+ });
+ }
+ }
+};
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/isScrollCommandTarget.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/isScrollCommandTarget.ts
new file mode 100644
index 00000000000..bd8f01bacb5
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/isScrollCommandTarget.ts
@@ -0,0 +1,13 @@
+import { REMOTE_RENDER_CONTAINER_TAG } from '@/constants/RemoteRenderContainerTag';
+import { isElementUnderRemoteRoot } from '@/polyfills/geometry/utils/isElementUnderRemoteRoot';
+
+export const isScrollCommandTarget = ({
+ element,
+ rootElement,
+}: {
+ element: object;
+ rootElement: object | null;
+}): boolean =>
+ element !== rootElement &&
+ Reflect.get(element, 'localName') !== REMOTE_RENDER_CONTAINER_TAG &&
+ isElementUnderRemoteRoot(element, rootElement);
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/normalizeScrollIntoViewArguments.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/normalizeScrollIntoViewArguments.ts
new file mode 100644
index 00000000000..5b6570cced4
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/normalizeScrollIntoViewArguments.ts
@@ -0,0 +1,60 @@
+import { isNull, isObject, isUndefined } from '@sniptt/guards';
+
+import { type ScrollIntoViewAlignment } from '@/types/ScrollIntoViewAlignment';
+import { type ScrollIntoViewRequest } from '@/types/ScrollIntoViewRequest';
+import { isScrollIntoViewAlignment } from '@/utils/isScrollIntoViewAlignment';
+
+type ScrollIntoViewAlignments = Omit<ScrollIntoViewRequest, 'method'>;
+
+const START_ALIGNMENTS: ScrollIntoViewAlignments = {
+ block: 'start',
+ inline: 'nearest',
+};
+
+const END_ALIGNMENTS: ScrollIntoViewAlignments = {
+ block: 'end',
+ inline: 'nearest',
+};
+
+const normalizeScrollIntoViewAlignment = ({
+ alignment,
+ defaultAlignment,
+}: {
+ alignment: unknown;
+ defaultAlignment: ScrollIntoViewAlignment;
+}): ScrollIntoViewAlignment => {
+ if (isUndefined(alignment)) {
+ return defaultAlignment;
+ }
+
+ if (!isScrollIntoViewAlignment(alignment)) {
+ throw new TypeError(
+ `Failed to execute 'scrollIntoView' on 'Element': The provided value '${String(alignment)}' is not a valid enum value of type ScrollLogicalPosition.`,
+ );
+ }
+
+ return alignment;
+};
+
+export const normalizeScrollIntoViewArguments = (
+ scrollIntoViewArgument: unknown,
+): ScrollIntoViewAlignments => {
+ if (isUndefined(scrollIntoViewArgument) || isNull(scrollIntoViewArgument)) {
+ return START_ALIGNMENTS;
+ }
+
+ if (!isObject(scrollIntoViewArgument)) {
+ return scrollIntoViewArgument ? START_ALIGNMENTS : END_ALIGNMENTS;
+ }
+
+ return {
+ block: normalizeScrollIntoViewAlignment({
+ alignment: Reflect.get(scrollIntoViewArgument, 'block'),
+ defaultAlignment: START_ALIGNMENTS.block,
+ }),
+ inline: normalizeScrollIntoViewAlignment({
+ alignment: Reflect.get(scrollIntoViewArgument, 'inline'),
+ defaultAlignment: START_ALIGNMENTS.inline,
+ }),
+ };
+};
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/normalizeScrollOffset.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/normalizeScrollOffset.ts
new file mode 100644
index 00000000000..c0be2ab9798
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/normalizeScrollOffset.ts
@@ -0,0 +1,5 @@
+export const normalizeScrollOffset = (value: unknown): number => {
+ const scrollOffset = Number(value);
+
+ return Number.isFinite(scrollOffset) ? scrollOffset : 0;
+};
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/normalizeScrollToArguments.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/normalizeScrollToArguments.ts
new file mode 100644
index 00000000000..c3477cfa33a
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/normalizeScrollToArguments.ts
@@ -0,0 +1,35 @@
+import { isFunction, isNull, isObject, isUndefined } from '@sniptt/guards';
+
+import { normalizeScrollOffset } from '@/polyfills/scroll/utils/normalizeScrollOffset';
+import { type ScrollAxisOffsets } from '@/types/ScrollAxisOffsets';
+
+export const normalizeScrollToArguments = (
+ scrollToArguments: unknown[],
+): ScrollAxisOffsets => {
+ if (scrollToArguments.length >= 2) {
+ return {
+ left: normalizeScrollOffset(scrollToArguments[0]),
+ top: normalizeScrollOffset(scrollToArguments[1]),
+ };
+ }
+
+ const [scrollToOptions] = scrollToArguments;
+
+ if (isUndefined(scrollToOptions) || isNull(scrollToOptions)) {
+ return {};
+ }
+
+ if (!isObject(scrollToOptions) && !isFunction(scrollToOptions)) {
+ throw new TypeError(
+ "Failed to execute 'scrollTo' on 'Element': The provided value is not of type 'ScrollToOptions'.",
+ );
+ }
+
+ const top: unknown = Reflect.get(scrollToOptions, 'top');
+ const left: unknown = Reflect.get(scrollToOptions, 'left');
+
+ return {
+ ...(!isUndefined(top) && { top: normalizeScrollOffset(top) }),
+ ...(!isUndefined(left) && { left: normalizeScrollOffset(left) }),
+ };
+};
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/readPrototypeNumberGetter.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/readPrototypeNumberGetter.ts
new file mode 100644
index 00000000000..938c0f08578
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/readPrototypeNumberGetter.ts
@@ -0,0 +1,17 @@
+import { isNumber } from '@sniptt/guards';
+
+export const readPrototypeNumberGetter = ({
+ prototype,
+ propertyName,
+}: {
+ prototype: object;
+ propertyName: string;
+}): ((receiver: object) => number) => {
+ const getter = Object.getOwnPropertyDescriptor(prototype, propertyName)?.get;
+
+ return (receiver) => {
+ const value: unknown = getter?.call(receiver);
+
+ return isNumber(value) ? value : 0;
+ };
+};
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/readScrollToOffsetOnAxis.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/readScrollToOffsetOnAxis.ts
new file mode 100644
index 00000000000..bed62e0ed7c
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/readScrollToOffsetOnAxis.ts
@@ -0,0 +1,11 @@
+import { type ScrollAxis } from '@/types/ScrollAxis';
+import { type ScrollRequest } from '@/types/ScrollRequest';
+
+export const readScrollToOffsetOnAxis = ({
+ request,
+ axis,
+}: {
+ request: ScrollRequest;
+ axis: ScrollAxis;
+}): number | undefined =>
+ request.method === 'scrollTo' ? request[axis] : undefined;
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/readSerializedEventScrollState.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/readSerializedEventScrollState.ts
new file mode 100644
index 00000000000..404bd96d290
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/readSerializedEventScrollState.ts
@@ -0,0 +1,23 @@
+import { isNumber } from '@sniptt/guards';
+
+import { EVENT_SCROLL_STATE_KEYS } from '@/constants/EventScrollStateKeys';
+import { type EventScrollState } from '@/polyfills/scroll/types/EventScrollState';
+import { type SerializedEventData } from '@/types/SerializedEventData';
+
+export const readSerializedEventScrollState = (
+ eventData: SerializedEventData,
+): EventScrollState | null => {
+ const eventScrollState: EventScrollState = {};
+ let hasScrollState = false;
+
+ for (const key of EVENT_SCROLL_STATE_KEYS) {
+ const value = eventData[key];
+
+ if (isNumber(value)) {
+ eventScrollState[key] = value;
+ hasScrollState = true;
+ }
+ }
+
+ return hasScrollState ? eventScrollState : null;
+};
diff --git a/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/resolveOptimisticScrollOffset.ts b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/resolveOptimisticScrollOffset.ts
new file mode 100644
index 00000000000..db98c8c7bb3
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/polyfills/scroll/utils/resolveOptimisticScrollOffset.ts
@@ -0,0 +1,21 @@
+import { readScrollToOffsetOnAxis } from '@/polyfills/scroll/utils/readScrollToOffsetOnAxis';
+import { type ScrollAxis } from '@/types/ScrollAxis';
+import { type ScrollCommand } from '@/types/ScrollCommand';
+
+export const resolveOptimisticScrollOffset = ({
+ hostOffset,
+ pendingCommands,
+ axis,
+}: {
+ hostOffset: number;
+ pendingCommands: ScrollCommand[];
+ axis: ScrollAxis;
+}): number => {
+ let scrollOffset = hostOffset;
+
+ for (const { request } of pendingCommands) {
+ scrollOffset = readScrollToOffsetOnAxis({ request, axis }) ?? scrollOffset;
+ }
+
+ return scrollOffset;
+};
diff --git a/packages/twenty-front-component-renderer/src/remote/elements/constants/SerializedEventTargetPropertyKeys.ts b/packages/twenty-front-component-renderer/src/remote/elements/constants/SerializedEventTargetPropertyKeys.ts
index b5c497f83fb..202e29e230f 100644
--- a/packages/twenty-front-component-renderer/src/remote/elements/constants/SerializedEventTargetPropertyKeys.ts
+++ b/packages/twenty-front-component-renderer/src/remote/elements/constants/SerializedEventTargetPropertyKeys.ts
@@ -4,8 +4,6 @@ export const SERIALIZED_EVENT_TARGET_PROPERTY_KEYS = [
'value',
'checked',
'files',
- 'scrollTop',
- 'scrollLeft',
'currentTime',
'duration',
'paused',
diff --git a/packages/twenty-front-component-renderer/src/remote/elements/utils/applySerializedEventTargetProperties.ts b/packages/twenty-front-component-renderer/src/remote/elements/utils/applySerializedEventTargetProperties.ts
index bbeda280538..a3f7bc6319e 100644
--- a/packages/twenty-front-component-renderer/src/remote/elements/utils/applySerializedEventTargetProperties.ts
+++ b/packages/twenty-front-component-renderer/src/remote/elements/utils/applySerializedEventTargetProperties.ts
@@ -8,6 +8,7 @@ import { installFilesResetOnValueClear } from '@/remote/elements/utils/installFi
import { isNativeEditAcknowledged } from '@/remote/elements/utils/isNativeEditAcknowledged';
import { uncheckOtherRadioButtons } from '@/remote/elements/utils/uncheckOtherRadioButtons';
import { workerInputSelectionStore } from '@/polyfills/input-selection/states/workerInputSelectionStore';
+import { workerScrollStore } from '@/polyfills/scroll/states/workerScrollStore';
import { readInputSelectionState } from '@/utils/readInputSelectionState';
import { type SerializedEventData } from '@/types/SerializedEventData';
@@ -50,6 +51,8 @@ export const applySerializedEventTargetProperties = ({
workerInputSelectionStore.applySnapshot({ element, state: selectionState });
}
+ workerScrollStore.observeEventTarget({ element, eventData });
+
if (eventData.checked) {
uncheckOtherRadioButtons(element);
}
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 2eff4be684e..f3372256e23 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
@@ -47,6 +47,9 @@ import { installElementGeometryPolyfill } from '@/polyfills/geometry/utils/insta
import { installVisualViewportPolyfill } from '@/polyfills/geometry/utils/installVisualViewportPolyfill';
import { installResizeObserverPolyfill } from '@/polyfills/geometry/utils/installResizeObserverPolyfill';
import { installWindowGeometryPolyfill } from '@/polyfills/geometry/utils/installWindowGeometryPolyfill';
+import { workerScrollStore } from '@/polyfills/scroll/states/workerScrollStore';
+import { installElementScrollPolyfill } from '@/polyfills/scroll/utils/installElementScrollPolyfill';
+import { installWindowScrollPolyfill } from '@/polyfills/scroll/utils/installWindowScrollPolyfill';
import { mediaQueryEnvironmentSource } from '@/polyfills/media-query/states/mediaQueryEnvironmentSource';
import { workerMediaBridge } from '@/polyfills/media/states/workerMediaBridge';
import { installMediaCapturePolyfills } from '@/polyfills/media/utils/installMediaCapturePolyfills';
@@ -137,6 +140,7 @@ installActiveElementDetachmentHook({
onRemoveSubtree: (node) => {
workerFocusTransport.blurFocusedElementWithinSubtree(node);
workerInputSelectionStore.scheduleDetachedElementSweep();
+ workerScrollStore.scheduleDetachedElementSweep();
workerPointerCapture.scheduleDetachedCaptureSweep();
},
});
@@ -159,11 +163,20 @@ installElementGeometryPolyfill({
geometryStore: workerGeometryStore,
});
+installElementScrollPolyfill({
+ elementPrototype: Element.prototype,
+ scrollStore: workerScrollStore,
+});
+
installWindowGeometryPolyfill({
globalScope: toGlobalScopeRecord(globalThis),
geometryStore: workerGeometryStore,
});
+installWindowScrollPolyfill({
+ globalScope: toGlobalScopeRecord(globalThis),
+});
+
installVisualViewportPolyfill({
globalScope: toGlobalScopeRecord(globalThis),
geometryStore: workerGeometryStore,
diff --git a/packages/twenty-front-component-renderer/src/remote/worker/rendering/utils/attachRemoteRenderRootToWorkerDocument.ts b/packages/twenty-front-component-renderer/src/remote/worker/rendering/utils/attachRemoteRenderRootToWorkerDocument.ts
index 84387336428..c4503cf3c08 100644
--- a/packages/twenty-front-component-renderer/src/remote/worker/rendering/utils/attachRemoteRenderRootToWorkerDocument.ts
+++ b/packages/twenty-front-component-renderer/src/remote/worker/rendering/utils/attachRemoteRenderRootToWorkerDocument.ts
@@ -10,6 +10,7 @@ import { REMOTE_RENDER_CONTAINER_TAG } from '@/constants/RemoteRenderContainerTa
import { workerGeometryStore } from '@/polyfills/geometry/states/workerGeometryStore';
import { workerInputSelectionStore } from '@/polyfills/input-selection/states/workerInputSelectionStore';
import { workerFocusTransport } from '@/polyfills/dom/states/workerFocusTransport';
+import { workerScrollStore } from '@/polyfills/scroll/states/workerScrollStore';
import { installStyleBridge } from '@/polyfills/style/utils/installStyleBridge';
export const attachRemoteRenderRootToWorkerDocument = (
@@ -38,6 +39,7 @@ export const attachRemoteRenderRootToWorkerDocument = (
workerGeometryStore.setRootElement(remoteRoot);
workerFocusTransport.setRootElement(remoteRoot);
workerInputSelectionStore.setRootElement(remoteRoot);
+ workerScrollStore.setRootElement(remoteRoot);
installStyleBridge(styleContainer);
return renderContainer;
diff --git a/packages/twenty-front-component-renderer/src/types/ScrollAxis.ts b/packages/twenty-front-component-renderer/src/types/ScrollAxis.ts
new file mode 100644
index 00000000000..f0d92bece8a
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/types/ScrollAxis.ts
@@ -0,0 +1,3 @@
+import { type SCROLL_AXES } from '@/constants/ScrollAxes';
+
+export type ScrollAxis = (typeof SCROLL_AXES)[number];
diff --git a/packages/twenty-front-component-renderer/src/types/ScrollAxisOffsets.ts b/packages/twenty-front-component-renderer/src/types/ScrollAxisOffsets.ts
new file mode 100644
index 00000000000..2305ffa0e93
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/types/ScrollAxisOffsets.ts
@@ -0,0 +1,3 @@
+import { type ScrollAxis } from '@/types/ScrollAxis';
+
+export type ScrollAxisOffsets = Partial<Record<ScrollAxis, number>>;
diff --git a/packages/twenty-front-component-renderer/src/types/ScrollCommand.ts b/packages/twenty-front-component-renderer/src/types/ScrollCommand.ts
new file mode 100644
index 00000000000..29feba461f9
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/types/ScrollCommand.ts
@@ -0,0 +1,4 @@
+import { type RemoteElementCommand } from '@/types/RemoteElementCommand';
+import { type ScrollRequest } from '@/types/ScrollRequest';
+
+export type ScrollCommand = RemoteElementCommand<ScrollRequest>;
diff --git a/packages/twenty-front-component-renderer/src/types/ScrollCommandAcknowledgement.ts b/packages/twenty-front-component-renderer/src/types/ScrollCommandAcknowledgement.ts
new file mode 100644
index 00000000000..65ab1d0eda7
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/types/ScrollCommandAcknowledgement.ts
@@ -0,0 +1,6 @@
+import { type ScrolledElementPosition } from '@/types/ScrolledElementPosition';
+
+export type ScrollCommandAcknowledgement = {
+ scrollCommandSequence: number;
+ scrollPositions: ScrolledElementPosition[];
+};
diff --git a/packages/twenty-front-component-renderer/src/types/ScrollIntoViewAlignment.ts b/packages/twenty-front-component-renderer/src/types/ScrollIntoViewAlignment.ts
new file mode 100644
index 00000000000..ad9f31c0d14
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/types/ScrollIntoViewAlignment.ts
@@ -0,0 +1,4 @@
+import { type SCROLL_INTO_VIEW_ALIGNMENTS } from '@/constants/ScrollIntoViewAlignments';
+
+export type ScrollIntoViewAlignment =
+ (typeof SCROLL_INTO_VIEW_ALIGNMENTS)[number];
diff --git a/packages/twenty-front-component-renderer/src/types/ScrollIntoViewRequest.ts b/packages/twenty-front-component-renderer/src/types/ScrollIntoViewRequest.ts
new file mode 100644
index 00000000000..135a40e3bf3
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/types/ScrollIntoViewRequest.ts
@@ -0,0 +1,7 @@
+import { type ScrollIntoViewAlignment } from '@/types/ScrollIntoViewAlignment';
+
+export type ScrollIntoViewRequest = {
+ method: 'scrollIntoView';
+ block: ScrollIntoViewAlignment;
+ inline: ScrollIntoViewAlignment;
+};
diff --git a/packages/twenty-front-component-renderer/src/types/ScrollPositionRequest.ts b/packages/twenty-front-component-renderer/src/types/ScrollPositionRequest.ts
new file mode 100644
index 00000000000..94e6ef56cfc
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/types/ScrollPositionRequest.ts
@@ -0,0 +1,3 @@
+import { type ScrollAxisOffsets } from '@/types/ScrollAxisOffsets';
+
+export type ScrollPositionRequest = { method: 'scrollTo' } & ScrollAxisOffsets;
diff --git a/packages/twenty-front-component-renderer/src/types/ScrollRequest.ts b/packages/twenty-front-component-renderer/src/types/ScrollRequest.ts
new file mode 100644
index 00000000000..09d8a540871
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/types/ScrollRequest.ts
@@ -0,0 +1,4 @@
+import { type ScrollIntoViewRequest } from '@/types/ScrollIntoViewRequest';
+import { type ScrollPositionRequest } from '@/types/ScrollPositionRequest';
+
+export type ScrollRequest = ScrollPositionRequest | ScrollIntoViewRequest;
diff --git a/packages/twenty-front-component-renderer/src/types/ScrolledElementPosition.ts b/packages/twenty-front-component-renderer/src/types/ScrolledElementPosition.ts
new file mode 100644
index 00000000000..05fda58fd34
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/types/ScrolledElementPosition.ts
@@ -0,0 +1,5 @@
+export type ScrolledElementPosition = {
+ remoteElementId: string;
+ scrollTop: number;
+ scrollLeft: number;
+};
diff --git a/packages/twenty-front-component-renderer/src/types/SerializedEventData.ts b/packages/twenty-front-component-renderer/src/types/SerializedEventData.ts
index a4332b444e0..efb4b6965b8 100644
--- a/packages/twenty-front-component-renderer/src/types/SerializedEventData.ts
+++ b/packages/twenty-front-component-renderer/src/types/SerializedEventData.ts
@@ -53,6 +53,8 @@ export type SerializedEventData = {
selectedOptionIndexes?: number[];
scrollTop?: number;
scrollLeft?: number;
+ scrollWidth?: number;
+ clientWidth?: number;
deltaX?: number;
deltaY?: number;
deltaZ?: number;
diff --git a/packages/twenty-front-component-renderer/src/utils/isScrollIntoViewAlignment.ts b/packages/twenty-front-component-renderer/src/utils/isScrollIntoViewAlignment.ts
new file mode 100644
index 00000000000..428204806aa
--- /dev/null
+++ b/packages/twenty-front-component-renderer/src/utils/isScrollIntoViewAlignment.ts
@@ -0,0 +1,7 @@
+import { SCROLL_INTO_VIEW_ALIGNMENTS } from '@/constants/ScrollIntoViewAlignments';
+import { type ScrollIntoViewAlignment } from '@/types/ScrollIntoViewAlignment';
+
+export const isScrollIntoViewAlignment = (
+ value: unknown,
+): value is ScrollIntoViewAlignment =>
+ SCROLL_INTO_VIEW_ALIGNMENTS.some((alignment) => alignment === value);