diff --git a/packages/core/src/Popover/Popover.tsx b/packages/core/src/Popover/Popover.tsx
index 5f02abb63d829..ac81626cd2fe6 100644
--- a/packages/core/src/Popover/Popover.tsx
+++ b/packages/core/src/Popover/Popover.tsx
@@ -430,6 +430,11 @@ const styles = stylex.create({
`calc(${layerViewportInset.maxBlockSize})`,
`calc(${layerViewportInset.maxBlockSizeFallback})`,
),
+ // A scroll container from the commit in which the software keyboard caps
+ // the layer, a frame before the overflow measure sees the shorter box.
+ // Otherwise `visible`. The type names the two values the property takes.
+ // SYNC: LAYER_KEYBOARD_OVERFLOW_PROPERTY (Layer/useLayerKeyboardClearance.ts).
+ overflow: 'var(--_layer-keyboard-overflow, visible)' as 'auto' | 'visible',
},
surfaceScrollable: {
overflow: 'auto',
diff --git a/packages/core/src/Popover/__tests__/PopoverKeyboard.interaction.browser.spec.ts b/packages/core/src/Popover/__tests__/PopoverKeyboard.interaction.browser.spec.ts
new file mode 100644
index 0000000000000..2586e5c984e91
--- /dev/null
+++ b/packages/core/src/Popover/__tests__/PopoverKeyboard.interaction.browser.spec.ts
@@ -0,0 +1,456 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file PopoverKeyboard.interaction.browser.spec.ts
+ * @input The built Keyboard Avoidance and Default Popover stories, a
+ * stand-in visual viewport that reports a software keyboard, real touch
+ * input and the interaction harness
+ * @output Proofs for the layer runtime's keyboard clearance, through
+ * Popover. A tall popover takes its shorter height once the rising
+ * keyboard has arrived. It ends 10 px above the keyboard, with its content
+ * scrollable and its last control reachable. It takes its full height back
+ * as the keyboard starts down. One opened while the keyboard is already up
+ * is clear of it from the first frame that shows it. A popover clear of the
+ * keyboard is left alone. A storyboard shows both states.
+ * @position Browser proofs for Layer/useLayerKeyboardClearance.ts.
+ * Headless browsers have no software keyboard. So the page's
+ * `visualViewport` is replaced by one the test shrinks the way Mobile
+ * Safari does (one `resize`, final height). Mobile Safari itself is proven
+ * on the iOS simulator.
+ */
+
+import {
+ expect,
+ test,
+ type Locator,
+ type Page,
+} from '@astryxdesign/a11y-spec/playwright';
+import {
+ openStory,
+ touchDriver,
+ waitForRest,
+ withStorybook,
+ writeEvidence,
+} from '@astryxdesign/interaction-harness';
+import {LAYER_KEYBOARD_CLEARANCE_PX} from '../../Layer/layerKeyboardClearance';
+import {timing} from '../../motion/uikit/timing';
+
+const storybook = withStorybook(test);
+
+// The cover Mobile Safari reports on an iPhone 17 Pro (keyboard, accessory
+// bar and the floating address bar over a 714 px layout viewport).
+const COVER = 337;
+
+/**
+ * Replaces `window.visualViewport` before the page loads with one the test
+ * drives: `__keyboard(cover)` shrinks it from the bottom and fires one
+ * `resize`, as Mobile Safari does. The keyboard module measures the visual
+ * viewport wherever one exists, Chrome's `navigator.virtualKeyboard`
+ * included (spec:AST-099 FR6, DEC-4). By default the page has no
+ * `navigator.virtualKeyboard`, as in Mobile Safari; `chrome` keeps it.
+ */
+async function installKeyboard(page: Page, {chrome = false} = {}) {
+ await page.addInitScript(keepVirtualKeyboard => {
+ if (!keepVirtualKeyboard) {
+ Reflect.deleteProperty(Navigator.prototype, 'virtualKeyboard');
+ }
+ const viewport = Object.assign(new EventTarget(), {
+ height: window.innerHeight,
+ width: window.innerWidth,
+ offsetTop: 0,
+ offsetLeft: 0,
+ pageTop: 0,
+ pageLeft: 0,
+ scale: 1,
+ });
+ Object.defineProperty(window, 'visualViewport', {
+ configurable: true,
+ get: () => viewport,
+ });
+ (window as unknown as {__keyboard: (cover: number) => void}).__keyboard =
+ cover => {
+ viewport.height = window.innerHeight - cover;
+ viewport.dispatchEvent(new Event('resize'));
+ };
+ }, chrome);
+}
+
+const keyboard = async (page: Page, cover: number) =>
+ page.evaluate(
+ value =>
+ (window as unknown as {__keyboard: (cover: number) => void}).__keyboard(
+ value,
+ ),
+ cover,
+ );
+
+interface Opened {
+ surface: Locator;
+ trigger: Locator;
+}
+
+async function openPopover(
+ page: Page,
+ story: string,
+ name: string,
+ options: {chrome?: boolean} = {},
+): Promise
{
+ await installKeyboard(page, options);
+ await openStory(page, storybook(), story);
+ const driver = await touchDriver(page);
+ const trigger = page.getByRole('button', {name});
+ const box = await trigger.boundingBox();
+ if (box == null) {
+ throw new Error(`no trigger named ${name}`);
+ }
+ await driver.tap({x: box.x + box.width / 2, y: box.y + box.height / 2});
+ await expect(trigger).toHaveAttribute('aria-expanded', 'true');
+ const layer = page.locator('[popover]:has([role="dialog"])').first();
+ await waitForRest(layer);
+ return {surface: layer.locator('[role="dialog"]'), trigger};
+}
+
+/**
+ * A screenshot of the page with the stand-in keyboard drawn over its cover
+ * (headless browsers draw no keyboard): a grey block, for the evidence only.
+ */
+async function shotWithKeyboard(page: Page, cover: number) {
+ await page.evaluate(value => {
+ // A manual popover of its own, so it paints over the popover under test
+ // in the top layer, as the keyboard paints over the page.
+ const block = document.createElement('div');
+ block.id = 'stand-in-keyboard';
+ block.setAttribute('popover', 'manual');
+ Object.assign(block.style, {
+ position: 'fixed',
+ inset: 'auto 0 0 0',
+ margin: '0',
+ border: '0',
+ padding: '0',
+ width: '100%',
+ height: `${value}px`,
+ background: 'rgb(209, 211, 217)',
+ pointerEvents: 'none',
+ });
+ document.body.append(block);
+ block.showPopover();
+ }, cover);
+ const viewport = page.viewportSize() ?? {width: 402, height: 714};
+ const shot = await page.screenshot({
+ clip: {x: 0, y: 0, width: viewport.width, height: viewport.height},
+ });
+ await page.evaluate(() =>
+ document.getElementById('stand-in-keyboard')?.remove(),
+ );
+ return shot;
+}
+
+const boxOf = async (locator: Locator) =>
+ locator.evaluate(element => {
+ const rect = element.getBoundingClientRect();
+ const el = element as HTMLElement;
+ const layer = el.closest('[popover]');
+ // The cap the layer's own style declares while the keyboard caps it, in
+ // px; an uncapped layer declares a limit out of reach instead.
+ const declared =
+ layer == null
+ ? ''
+ : getComputedStyle(layer)
+ .getPropertyValue('--_layer-keyboard-max-block-size')
+ .trim();
+ return {
+ top: rect.top,
+ bottom: rect.bottom,
+ clientHeight: el.clientHeight,
+ scrollHeight: el.scrollHeight,
+ keyboardCap: declared.endsWith('px') ? declared : '',
+ innerHeight: window.innerHeight,
+ };
+ });
+
+test('a tall popover shrinks to stay 10 px above the keyboard once it has arrived, and grows back as it goes down', async ({
+ page,
+}, testInfo) => {
+ const {surface} = await openPopover(
+ page,
+ 'core-popover--keyboard-avoidance',
+ 'Add note',
+ );
+ const field = page.getByRole('textbox', {name: 'Title'});
+ await field.focus();
+ const before = await boxOf(surface);
+ const keyboardTop = before.innerHeight - COVER;
+ // The story's popover runs under the keyboard's resting top.
+ expect(before.bottom).toBeGreaterThan(keyboardTop);
+
+ await keyboard(page, COVER);
+ // On its way up the keyboard covers the difference: nothing changes yet.
+ await page.waitForTimeout(timing.keyboardNotificationMs / 2);
+ expect((await boxOf(surface)).keyboardCap).toBe('');
+ const covered = await shotWithKeyboard(page, COVER);
+ await page.waitForTimeout(timing.keyboardNotificationMs);
+ const avoiding = await boxOf(surface);
+ expect(avoiding.top).toBeCloseTo(before.top, 0);
+ expect(
+ Math.abs(avoiding.bottom - (keyboardTop - LAYER_KEYBOARD_CLEARANCE_PX)),
+ ).toBeLessThanOrEqual(1);
+ // Its content scrolls, and the last control can be reached above the
+ // keyboard.
+ expect(avoiding.scrollHeight).toBeGreaterThan(avoiding.clientHeight);
+ await expect(field).toBeFocused();
+ await surface.evaluate(element => {
+ element.scrollTop = element.scrollHeight;
+ });
+ const save = await page
+ .getByRole('button', {name: 'Save note'})
+ .evaluate(element => element.getBoundingClientRect().bottom);
+ expect(save).toBeLessThanOrEqual(keyboardTop - LAYER_KEYBOARD_CLEARANCE_PX);
+ await surface.evaluate(element => {
+ element.scrollTop = 0;
+ });
+ const clear = await shotWithKeyboard(page, COVER);
+ await writeEvidence(
+ 'keyboard/popover-avoidance',
+ {
+ [`${testInfo.project.name}.json`]: JSON.stringify(
+ {cover: COVER, keyboardTop, before, avoiding, save},
+ null,
+ 1,
+ ),
+ [`${testInfo.project.name}-keyboard-rising.png`]: covered,
+ [`${testInfo.project.name}-keyboard-up.png`]: clear,
+ },
+ testInfo,
+ );
+
+ // Going down: the full height comes back at once, behind the keyboard.
+ await keyboard(page, 0);
+ const restored = await boxOf(surface);
+ expect(restored.keyboardCap).toBe('');
+ expect(restored.bottom).toBeCloseTo(before.bottom, 0);
+});
+
+test("where Chrome's navigator.virtualKeyboard exists, the visual viewport still sets the cap", async ({
+ page,
+ browserName,
+}) => {
+ test.skip(
+ browserName !== 'chromium',
+ "navigator.virtualKeyboard is Chrome's",
+ );
+ const {surface} = await openPopover(
+ page,
+ 'core-popover--keyboard-avoidance',
+ 'Add note',
+ {chrome: true},
+ );
+ expect(await page.evaluate(() => 'virtualKeyboard' in navigator)).toBe(true);
+ await page.getByRole('textbox', {name: 'Title'}).focus();
+ const before = await boxOf(surface);
+ const keyboardTop = before.innerHeight - COVER;
+ expect(before.bottom).toBeGreaterThan(keyboardTop);
+ await keyboard(page, COVER);
+ await page.waitForTimeout(timing.keyboardNotificationMs * 1.5);
+ const avoiding = await boxOf(surface);
+ expect(avoiding.top).toBeCloseTo(before.top, 0);
+ expect(
+ Math.abs(avoiding.bottom - (keyboardTop - LAYER_KEYBOARD_CLEARANCE_PX)),
+ ).toBeLessThanOrEqual(1);
+});
+
+test('with the keyboard up, a tap on the scrolled-in Save note clicks it', async ({
+ page,
+}) => {
+ const {surface} = await openPopover(
+ page,
+ 'core-popover--keyboard-avoidance',
+ 'Add note',
+ );
+ const field = page.getByRole('textbox', {name: 'Title'});
+ await field.focus();
+ await keyboard(page, COVER);
+ await page.waitForTimeout(timing.keyboardNotificationMs * 1.5);
+ expect((await boxOf(surface)).keyboardCap).not.toBe('');
+ await surface.evaluate(element => {
+ element.scrollTop = element.scrollHeight;
+ });
+ const save = page.getByRole('button', {name: 'Save note'});
+ await save.evaluate(element => {
+ const counter = window as unknown as {__saveClicks: number};
+ counter.__saveClicks = 0;
+ element.addEventListener('click', () => {
+ counter.__saveClicks += 1;
+ });
+ });
+ const box = await save.boundingBox();
+ if (box == null) {
+ throw new Error('no Save note');
+ }
+ // The tap moves focus off the field, and the keyboard starts down: the
+ // popover keeps its height until the tap's click has landed on Save.
+ const driver = await touchDriver(page);
+ await driver.tap({x: box.x + box.width / 2, y: box.y + box.height / 2});
+ await expect
+ .poll(async () =>
+ page.evaluate(
+ () => (window as unknown as {__saveClicks: number}).__saveClicks,
+ ),
+ )
+ .toBe(1);
+});
+
+test('opened while the keyboard is already up, it opens clear of the keyboard', async ({
+ page,
+ browserName,
+}) => {
+ await installKeyboard(page);
+ await openStory(page, storybook(), 'core-popover--keyboard-avoidance');
+ const driver = await touchDriver(page);
+ // A field on the page brings the keyboard up first.
+ const search = page.getByRole('textbox', {name: 'Search notes'});
+ await search.focus();
+ await keyboard(page, COVER);
+ await page.waitForTimeout(timing.keyboardNotificationMs + 100);
+ const trigger = page.getByRole('button', {name: 'Add note'});
+ const box = await trigger.boundingBox();
+ if (box == null) {
+ throw new Error('no trigger named Add note');
+ }
+ // The layer's entrance is slowed through Chromium's DevTools protocol. So
+ // the popover is measured mid-flight, under its entrance transform, as on a
+ // phone. WebKit measures it as it comes.
+ const cdp =
+ browserName === 'chromium'
+ ? await page.context().newCDPSession(page)
+ : null;
+ await cdp?.send('Animation.enable');
+ await cdp?.send('Animation.setPlaybackRate', {playbackRate: 0.1});
+ await driver.tap({x: box.x + box.width / 2, y: box.y + box.height / 2});
+ await expect(trigger).toHaveAttribute('aria-expanded', 'true');
+ await page.waitForTimeout(200);
+ await cdp?.send('Animation.setPlaybackRate', {playbackRate: 1});
+ const layer = page.locator('[popover]:has([role="dialog"])').first();
+ await waitForRest(layer);
+ const surface = layer.locator('[role="dialog"]');
+ const opened = await boxOf(surface);
+ const keyboardTop = opened.innerHeight - COVER;
+ expect(opened.keyboardCap).not.toBe('');
+ expect(
+ Math.abs(opened.bottom - (keyboardTop - LAYER_KEYBOARD_CLEARANCE_PX)),
+ ).toBeLessThanOrEqual(1);
+ expect(opened.scrollHeight).toBeGreaterThan(opened.clientHeight);
+});
+
+/** What the page read of the first frame that shows the layer. */
+interface FirstFrame {
+ /** As the frame begins: the layer's layout bottom, without its entrance. */
+ bottom: number;
+ /** As the frame begins: the cap the layer declares. */
+ cap: string;
+ /** After the frame's layout, before it paints: the content overflows. */
+ overflows: boolean;
+ /** After the frame's layout, before it paints: the surface's overflow. */
+ overflowY: string;
+}
+
+/**
+ * Raises the stand-in keyboard from a field on the page, then taps Add note
+ * and reads the first frame that shows the popover.
+ */
+async function firstFrameOpenedWithKeyboardUp(page: Page): Promise {
+ await installKeyboard(page);
+ await openStory(page, storybook(), 'core-popover--keyboard-avoidance');
+ const driver = await touchDriver(page);
+ await page.getByRole('textbox', {name: 'Search notes'}).focus();
+ await keyboard(page, COVER);
+ await page.waitForTimeout(timing.keyboardNotificationMs + 100);
+ // The page's own frame loop, started before the tap. Its callback runs
+ // ahead of any frame callback the open schedules, so it reads each frame
+ // as the frame begins. In the first frame that shows the layer, a
+ // ResizeObserver started then reads the surface after that frame's layout.
+ await page.evaluate(() => {
+ const win = window as unknown as {__firstFrame?: FirstFrame};
+ const read = () => {
+ const layer = document.querySelector(
+ '[popover]:has([role="dialog"])',
+ );
+ const surface = layer?.querySelector('[role="dialog"]');
+ if (layer?.matches(':popover-open') !== true || surface == null) {
+ requestAnimationFrame(read);
+ return;
+ }
+ const bottom = layer.offsetTop + layer.offsetHeight;
+ const cap = getComputedStyle(layer)
+ .getPropertyValue('--_layer-keyboard-max-block-size')
+ .trim();
+ const observer = new ResizeObserver(() => {
+ observer.disconnect();
+ win.__firstFrame = {
+ bottom,
+ cap,
+ overflows: surface.scrollHeight > surface.clientHeight + 1,
+ overflowY: getComputedStyle(surface).overflowY,
+ };
+ });
+ observer.observe(surface);
+ };
+ requestAnimationFrame(read);
+ });
+ const trigger = page.getByRole('button', {name: 'Add note'});
+ const box = await trigger.boundingBox();
+ if (box == null) {
+ throw new Error('no trigger named Add note');
+ }
+ await driver.tap({x: box.x + box.width / 2, y: box.y + box.height / 2});
+ await expect(trigger).toHaveAttribute('aria-expanded', 'true');
+ const firstFrame = async () =>
+ page.evaluate(
+ () =>
+ (window as unknown as {__firstFrame?: FirstFrame}).__firstFrame ?? null,
+ );
+ await expect.poll(firstFrame).not.toBeNull();
+ const first = await firstFrame();
+ if (first == null) {
+ throw new Error('no frame showed the popover');
+ }
+ return first;
+}
+
+test('opened while the keyboard is already up, it is clear of the keyboard in the first frame that shows it', async ({
+ page,
+}) => {
+ const first = await firstFrameOpenedWithKeyboardUp(page);
+ const innerHeight = await page.evaluate(() => window.innerHeight);
+ const keyboardTop = innerHeight - COVER;
+ expect(first.bottom).toBeLessThanOrEqual(
+ keyboardTop - LAYER_KEYBOARD_CLEARANCE_PX + 1,
+ );
+ expect(first.cap).toMatch(/px$/);
+});
+
+test('opened while the keyboard is already up, its content stays inside its box in the first frame that paints it', async ({
+ page,
+}) => {
+ const first = await firstFrameOpenedWithKeyboardUp(page);
+ // The capped box is shorter than its content.
+ expect(first.overflows).toBe(true);
+ // So the surface already clips and scrolls its content in that frame.
+ expect(first.overflowY).not.toBe('visible');
+});
+
+test('a popover clear of the keyboard is left as it is', async ({page}) => {
+ const {surface} = await openPopover(
+ page,
+ 'core-popover--default',
+ 'Settings',
+ );
+ const before = await boxOf(surface);
+ expect(before.bottom).toBeLessThan(
+ before.innerHeight - COVER - LAYER_KEYBOARD_CLEARANCE_PX,
+ );
+ await keyboard(page, COVER);
+ await page.waitForTimeout(timing.keyboardNotificationMs + 200);
+ const after = await boxOf(surface);
+ expect(after.keyboardCap).toBe('');
+ expect(after.bottom).toBeCloseTo(before.bottom, 0);
+});
diff --git a/packages/core/src/Selector/Selector.tsx b/packages/core/src/Selector/Selector.tsx
index 0b1fdf7b14a92..5ff337841c09c 100644
--- a/packages/core/src/Selector/Selector.tsx
+++ b/packages/core/src/Selector/Selector.tsx
@@ -50,6 +50,7 @@ import {Divider} from '../Divider';
import {layerAnimations} from '../Layer/layerAnimations.stylex';
import {reducedMotionFadeConsts} from '../motion/reducedMotion.stylex';
import {useKeepLayerOpenProps, type LayerPlacement} from '../Layer/useLayer';
+import {layerViewportInset} from '../Layer/layerViewportInset.stylex';
import {InternalInputClearButton} from '../Field/InputClearButton';
import {Spinner} from '../Spinner';
import {PanelSearchInput} from '../Field/PanelSearchInput';
@@ -350,10 +351,31 @@ const styles = stylex.create({
borderRadius: radiusVars['--radius-element'],
},
+ // A panel with a search field, capped as a whole.
+ searchPanel: {
+ display: 'flex',
+ flexDirection: 'column',
+ // No taller than its layer's block-size cap, which folds in the software
+ // keyboard's. The search field's row keeps its height, and the list takes
+ // what is left.
+ maxHeight: stylex.firstThatWorks(
+ `calc(${layerViewportInset.maxBlockSize})`,
+ `calc(${layerViewportInset.maxBlockSizeFallback})`,
+ ),
+ },
+
// Dropdown container
dropdown: {
boxSizing: 'border-box',
- maxHeight: '300px',
+ // In a search panel, the list shrinks below its content to fit the cap.
+ minHeight: 0,
+ // 300 px, and no taller than its layer's block-size cap, which folds in
+ // the software keyboard's: the list ends above the keyboard with the
+ // layer.
+ maxHeight: stylex.firstThatWorks(
+ `min(300px, ${layerViewportInset.maxBlockSize})`,
+ `min(300px, ${layerViewportInset.maxBlockSizeFallback})`,
+ ),
overflowY: 'auto',
outline: 'none',
paddingBlock: spacingVars['--spacing-1'],
@@ -1976,7 +1998,7 @@ export function Selector(
);
const panelContent = hasSearch ? (
-
+
{renderSearch()}
{
+ fs.rmSync(scratch, {recursive: true, force: true});
+});
+
+/**
+ * The bytes each source module puts in what an import of `name` from
+ * `entry` loads at once. That is the entry chunk and every chunk it imports
+ * statically. It also counts the bytes in the chunks the import loads only
+ * through import(). It builds as the size report builds a component import.
+ */
+function importOf(entry, name) {
+ const entryFile = path.join(scratch, `${name}.mjs`);
+ fs.writeFileSync(
+ entryFile,
+ `export {${name}} from ${JSON.stringify(path.join(REPO, entry))};`,
+ );
+ const result = esbuild.buildSync({
+ absWorkingDir: REPO,
+ entryPoints: [entryFile],
+ outdir: path.join(scratch, `out-${name}`),
+ bundle: true,
+ splitting: true,
+ minify: true,
+ format: 'esm',
+ platform: 'browser',
+ define: {'process.env.NODE_ENV': '"production"'},
+ loader: {'.css': 'empty'},
+ external: [
+ 'react',
+ 'react/*',
+ 'react-dom',
+ 'react-dom/*',
+ '@stylexjs/stylex',
+ ],
+ metafile: true,
+ write: false,
+ logLevel: 'silent',
+ });
+ const outputs = result.metafile.outputs;
+ const entryOutput = Object.keys(outputs).find(
+ key => outputs[key].entryPoint != null,
+ );
+ const eager = new Set();
+ const pending = [entryOutput];
+ while (pending.length > 0) {
+ const key = pending.pop();
+ if (eager.has(key)) {
+ continue;
+ }
+ eager.add(key);
+ for (const {path: imported, kind} of outputs[key].imports) {
+ if (kind === 'import-statement' && outputs[imported] != null) {
+ pending.push(imported);
+ }
+ }
+ }
+ const bytesIn = keys => {
+ const bytes = {};
+ for (const key of keys) {
+ for (const [input, {bytesInOutput}] of Object.entries(
+ outputs[key].inputs,
+ )) {
+ bytes[input] = (bytes[input] ?? 0) + bytesInOutput;
+ }
+ }
+ return bytes;
+ };
+ const onDemand = Object.keys(outputs).filter(
+ key => !eager.has(key) && !key.endsWith('.map'),
+ );
+ return {eager: bytesIn(eager), onDemand: bytesIn(onDemand)};
+}
+
+/** The inputs matching `pattern` that put bytes in `bytes`. */
+function rideIn(bytes) {
+ return Object.entries(bytes)
+ .filter(([input, size]) => SHEET_RIDE_INPUT.test(input) && size > 0)
+ .map(([input]) => input)
+ .sort();
+}
+
+describe('a menu with an on-demand bottom sheet', () => {
+ it.each([
+ ['DropdownMenu', 'packages/core/src/DropdownMenu/index.ts'],
+ ['ContextMenu', 'packages/core/src/ContextMenu/index.ts'],
+ ['Selector', 'packages/core/src/Selector/index.ts'],
+ ['MultiSelector', 'packages/core/src/MultiSelector/index.ts'],
+ ])(
+ "%s loads the sheet's keyboard ride only with the sheet",
+ (name, entry) => {
+ const {eager, onDemand} = importOf(entry, name);
+ // The sheet still rides the keyboard, on demand.
+ expect(rideIn(onDemand)).toEqual([
+ 'packages/core/src/keyboard/rideKeyboard.ts',
+ 'packages/core/src/motion/animator.ts',
+ ]);
+ expect(rideIn(eager)).toEqual([]);
+ },
+ );
+});