Skip to content

🎥 Make videos programmatically with React

`@remotion/studio`: Fix tooltips staying visible after leaving an iframe

Jonny Burgerace2a33b9a7d
diff --git a/packages/browser-studio/e2e/browser-studio.test.ts b/packages/browser-studio/e2e/browser-studio.test.ts
index fbe9ed9e80..fae72f6d03 100644
--- a/packages/browser-studio/e2e/browser-studio.test.ts
+++ b/packages/browser-studio/e2e/browser-studio.test.ts
@@ -1498,7 +1498,7 @@ test('reports inline SVG imports as unsupported without changing the project', a
expect(compositionAfter).toBe(compositionBefore);
});
-test('clears hover backgrounds even if pointer leave events are lost', async ({
+test('clears hover backgrounds and tooltips even if pointer leave events are lost', async ({
page,
}) => {
await page.goto('/');
@@ -1675,4 +1675,76 @@ test('clears hover backgrounds even if pointer leave events are lost', async ({
await expect
.poll(() => getBackgroundColor(fileMenu))
.toBe('rgba(0, 0, 0, 0)');
+
+ // Leave a host-page gutter so the pointer can actually cross the iframe
+ // boundary while all leave events inside the frame remain suppressed.
+ await page.locator('iframe').evaluate((iframe) => {
+ iframe.style.width = 'calc(100% - 24px)';
+ });
+ const iframeBox = await page.locator('iframe').boundingBox();
+ if (iframeBox === null) {
+ throw new Error('Expected the Studio iframe to be visible');
+ }
+
+ const loop = studio.getByRole('button', {name: 'Loop', exact: true});
+ const loopTooltip = studio.getByRole('tooltip').filter({hasText: 'Loop'});
+ await loop.hover();
+ await expect(loopTooltip).toBeVisible();
+ await neutralArea.hover();
+ await expect(loopTooltip).toHaveCount(0);
+
+ // Re-entering the same control must still work after recovering a lost leave.
+ await loop.hover();
+ await expect(loopTooltip).toBeVisible();
+ await page.mouse.move(
+ iframeBox.x + iframeBox.width + 12,
+ iframeBox.y + iframeBox.height / 2,
+ );
+ await expect(loopTooltip).toHaveCount(0);
+ await loop.hover();
+ await expect(loopTooltip).toBeVisible();
+ await page.locator('iframe').dispatchEvent('pointerout');
+ await expect(loopTooltip).toHaveCount(0);
+
+ await page.mouse.move(
+ iframeBox.x + iframeBox.width + 12,
+ iframeBox.y + iframeBox.height / 2,
+ );
+ // Let the adjacent-control grace period expire so this hover starts a timer.
+ await page.waitForTimeout(350);
+ await expect(studio.getByRole('tooltip')).toHaveCount(0);
+ await loop.hover();
+ await expect(loopTooltip).toHaveCount(0);
+ await page.locator('iframe').dispatchEvent('pointerout');
+ // Leaving the frame must cancel the pending tooltip, even if CSS still
+ // considers the trigger hovered and its element-level leave was suppressed.
+ await page.waitForTimeout(900);
+ await expect(loopTooltip).toHaveCount(0);
+ await neutralArea.hover();
+ await loop.hover();
+ await expect(loopTooltip).toBeVisible();
+
+ const nextFrame = studio.getByRole('button', {name: 'Go forward 1 frame'});
+ const nextFrameTooltip = studio
+ .getByRole('tooltip')
+ .filter({hasText: 'Next frame'});
+ await nextFrame.hover();
+ await expect(nextFrameTooltip).toBeVisible();
+ await expect(loopTooltip).toHaveCount(0);
+ await nextFrame.click();
+ await expect(nextFrameTooltip).toHaveCount(0);
+ await neutralArea.hover();
+
+ // Enter through keyboard navigation so focus owns the tooltip, independently
+ // of the pointer and the missing leave events above.
+ await nextFrame.focus();
+ await page.keyboard.press('Shift+Tab');
+ await page.keyboard.press('Tab');
+ await expect(nextFrame).toBeFocused();
+ await expect(nextFrameTooltip).toBeVisible();
+ await nextFrame.hover();
+ await neutralArea.hover();
+ await expect(nextFrameTooltip).toBeVisible();
+ await page.keyboard.press('Escape');
+ await expect(nextFrameTooltip).toHaveCount(0);
});
diff --git a/packages/player/src/index.ts b/packages/player/src/index.ts
index 88c9d59f30..bc99388fe9 100644
--- a/packages/player/src/index.ts
+++ b/packages/player/src/index.ts
@@ -9,6 +9,7 @@ import {PlayerEventEmitterContext} from './emitter-context.js';
import {PlayerEmitterProvider} from './EmitterProvider.js';
import type {CallbackListener, PlayerEventTypes} from './event-emitter.js';
import {PlayerEmitter} from './event-emitter.js';
+import {observeHover} from './observe-hover.js';
import {TimelineSequenceObserverContext} from './timeline-sequence-observer-context.js';
import {useHoverState} from './use-hover-state.js';
import {usePlayback} from './use-playback.js';
@@ -47,6 +48,7 @@ export const PlayerInternals = {
useElementSize,
calculateCanvasTransformation,
useHoverState,
+ observeHover,
updateAllElementsSizes,
PlayerEmitterProvider,
BufferingIndicator,
diff --git a/packages/player/src/observe-hover.ts b/packages/player/src/observe-hover.ts
new file mode 100644
index 0000000000..449ea4bb14
--- /dev/null
+++ b/packages/player/src/observe-hover.ts
@@ -0,0 +1,137 @@
+// Browser Studio forwards exits from its iframe because browsers do not always
+// dispatch a leave event on the element inside the frame.
+const browserStudioPointerLeaveEvent = 'remotion-browser-studio-pointerleave';
+
+export const observeHover = ({
+ element,
+ onHoverChange,
+ onPointerMove,
+}: {
+ element: HTMLElement;
+ onHoverChange: (hovered: boolean) => void;
+ onPointerMove: (() => void) | null;
+}): (() => void) => {
+ const {ownerDocument} = element;
+ const ownerWindow = ownerDocument.defaultView;
+ let hovered = false;
+ let disposed = false;
+ let animationFrame: number | null = null;
+ let removeGlobalListeners: (() => void) | null = null;
+
+ const onLeave = () => {
+ if (!hovered) {
+ return;
+ }
+
+ hovered = false;
+ if (animationFrame !== null) {
+ ownerWindow?.cancelAnimationFrame(animationFrame);
+ animationFrame = null;
+ }
+
+ removeGlobalListeners?.();
+ removeGlobalListeners = null;
+ if (!disposed) {
+ onHoverChange(false);
+ }
+ };
+
+ const onVisibilityChange = () => {
+ if (ownerDocument.hidden) {
+ onLeave();
+ }
+ };
+
+ const onPointerCancel = (event: PointerEvent) => {
+ if (event.pointerType !== 'touch') {
+ onLeave();
+ }
+ };
+
+ const onDocumentPointerOut = (event: PointerEvent) => {
+ if (event.pointerType !== 'touch' && event.relatedTarget === null) {
+ onLeave();
+ }
+ };
+
+ const reconcileHover = () => {
+ animationFrame = null;
+ // CSS hover is maintained by the browser even when an element's leave
+ // event is lost, or the layout changes underneath a stationary pointer.
+ if (!element.isConnected || !element.matches(':hover')) {
+ onLeave();
+ return;
+ }
+
+ animationFrame = ownerWindow?.requestAnimationFrame(reconcileHover) ?? null;
+ };
+
+ const onPointerEnter = (event: PointerEvent) => {
+ if (event.pointerType === 'touch' || hovered || disposed) {
+ return;
+ }
+
+ hovered = true;
+ ownerWindow?.addEventListener('blur', onLeave);
+ ownerWindow?.addEventListener(browserStudioPointerLeaveEvent, onLeave);
+ ownerDocument.addEventListener('visibilitychange', onVisibilityChange);
+ ownerDocument.addEventListener('pointercancel', onPointerCancel, true);
+ ownerDocument.addEventListener('pointerout', onDocumentPointerOut, true);
+ removeGlobalListeners = () => {
+ ownerWindow?.removeEventListener('blur', onLeave);
+ ownerWindow?.removeEventListener(browserStudioPointerLeaveEvent, onLeave);
+ ownerDocument.removeEventListener('visibilitychange', onVisibilityChange);
+ ownerDocument.removeEventListener('pointercancel', onPointerCancel, true);
+ ownerDocument.removeEventListener(
+ 'pointerout',
+ onDocumentPointerOut,
+ true,
+ );
+ };
+
+ animationFrame = ownerWindow?.requestAnimationFrame(reconcileHover) ?? null;
+ onHoverChange(true);
+ };
+
+ const onPointerLeave = (event: PointerEvent) => {
+ if (event.pointerType !== 'touch') {
+ onLeave();
+ }
+ };
+
+ const onMove = (event: PointerEvent) => {
+ if (event.pointerType === 'touch' || disposed) {
+ return;
+ }
+
+ // Pointer capture redirects events and keeps :hover on the capture
+ // target. Use the actual hit target before accepting captured movement.
+ const target = event.target as Element;
+ if (
+ target.hasPointerCapture(event.pointerId) &&
+ !element.contains(
+ ownerDocument.elementFromPoint(event.clientX, event.clientY),
+ )
+ ) {
+ onLeave();
+ return;
+ }
+
+ // A move also repairs a missing enter, for example after switching tabs.
+ onPointerEnter(event);
+ if (!disposed) {
+ onPointerMove?.();
+ }
+ };
+
+ element.addEventListener('pointerenter', onPointerEnter);
+ element.addEventListener('pointerleave', onPointerLeave);
+ element.addEventListener('pointermove', onMove);
+ return () => {
+ disposed = true;
+ onLeave();
+ element.removeEventListener('pointerenter', onPointerEnter);
+ element.removeEventListener('pointerleave', onPointerLeave);
+ element.removeEventListener('pointermove', onMove);
+ };
+};
diff --git a/packages/player/src/use-hover-state.ts b/packages/player/src/use-hover-state.ts
index b2e420d6df..56e79793b5 100644
--- a/packages/player/src/use-hover-state.ts
+++ b/packages/player/src/use-hover-state.ts
@@ -1,25 +1,35 @@
import {useEffect, useState} from 'react';
+import {observeHover} from './observe-hover.js';
export const useHoverState = (
- ref: React.RefObject<HTMLDivElement | null>,
+ ref: React.RefObject<HTMLElement | null>,
hideControlsWhenPointerDoesntMove: boolean | number,
) => {
const [hovered, setHovered] = useState(false);
useEffect(() => {
+ setHovered(false);
const {current} = ref;
if (!current) {
return;
}
+ const {ownerDocument} = current;
+ const ownerWindow = ownerDocument.defaultView;
+ let stopTouchReveal: (() => void) | null = null;
let hoverTimeout: Timer;
+ const onLeave = () => {
+ setHovered(false);
+ clearTimeout(hoverTimeout);
+ stopTouchReveal?.();
+ stopTouchReveal = null;
+ };
+
const addHoverTimeout = () => {
if (hideControlsWhenPointerDoesntMove) {
clearTimeout(hoverTimeout);
hoverTimeout = setTimeout(
- () => {
- setHovered(false);
- },
+ onLeave,
hideControlsWhenPointerDoesntMove === true
? 3000
: hideControlsWhenPointerDoesntMove,
@@ -28,28 +38,74 @@ export const useHoverState = (
};
const onHover = () => {
+ stopTouchReveal?.();
+ stopTouchReveal = null;
setHovered(true);
addHoverTimeout();
};
- const onLeave = () => {
- setHovered(false);
- clearTimeout(hoverTimeout);
+ const onVisibilityChange = () => {
+ if (ownerDocument.hidden) {
+ onLeave();
+ }
};
- const onMove = () => {
- setHovered(true);
- addHoverTimeout();
+ // Touch does not hover, but a tap must still reveal the Player controls.
+ // Keep them accessible until inactivity or another interaction dismisses them.
+ const onPointerDown = (event: PointerEvent) => {
+ if (!event.composedPath().includes(current)) {
+ onLeave();
+ return;
+ }
+
+ if (event.pointerType !== 'touch') {
+ return;
+ }
+
+ onHover();
+ ownerDocument.addEventListener('pointerdown', onPointerDown, true);
+ ownerDocument.addEventListener('pointercancel', onLeave, true);
+ ownerDocument.addEventListener('visibilitychange', onVisibilityChange);
+ ownerWindow?.addEventListener('blur', onLeave);
+ ownerWindow?.addEventListener(
+ 'remotion-browser-studio-pointerleave',
+ onLeave,
+ );
+ stopTouchReveal = () => {
+ ownerDocument.removeEventListener('pointerdown', onPointerDown, true);
+ ownerDocument.removeEventListener('pointercancel', onLeave, true);
+ ownerDocument.removeEventListener(
+ 'visibilitychange',
+ onVisibilityChange,
+ );
+ ownerWindow?.removeEventListener('blur', onLeave);
+ ownerWindow?.removeEventListener(
+ 'remotion-browser-studio-pointerleave',
+ onLeave,
+ );
+ };
};
- current.addEventListener('mouseenter', onHover);
- current.addEventListener('mouseleave', onLeave);
- current.addEventListener('mousemove', onMove);
+ current.addEventListener('pointerdown', onPointerDown);
+ const stopObserving = observeHover({
+ element: current,
+ onHoverChange: (isHovered) => {
+ if (isHovered) {
+ onHover();
+ return;
+ }
+
+ if (stopTouchReveal === null) {
+ onLeave();
+ }
+ },
+ onPointerMove: onHover,
+ });
return () => {
- current.removeEventListener('mouseenter', onHover);
- current.removeEventListener('mouseleave', onLeave);
- current.removeEventListener('mousemove', onMove);
+ stopObserving();
+ stopTouchReveal?.();
+ current.removeEventListener('pointerdown', onPointerDown);
clearTimeout(hoverTimeout);
};
}, [hideControlsWhenPointerDoesntMove, ref]);
diff --git a/packages/studio/src/components/ActionTooltip.tsx b/packages/studio/src/components/ActionTooltip.tsx
index db9e57f4ab..bc94521bec 100644
--- a/packages/studio/src/components/ActionTooltip.tsx
+++ b/packages/studio/src/components/ActionTooltip.tsx
@@ -1,3 +1,4 @@
+import {PlayerInternals} from '@remotion/player';
import React, {
useCallback,
useEffect,
@@ -71,6 +72,8 @@ export const ActionTooltip: React.FC<{
const triggerRef = useRef<HTMLSpanElement>(null);
const tooltipRef = useRef<HTMLDivElement>(null);
const timer = useRef<ReturnType<typeof setTimeout> | null>(null);
+ const activation = useRef<'hover' | 'focus' | null>(null);
+ const delayRef = useRef(delay);
// Dismissal must also cancel a tooltip that is waiting for its hover delay.
const [active, setActive] = useState(false);
const [visible, setVisible] = useState(false);
@@ -79,6 +82,10 @@ export const ActionTooltip: React.FC<{
);
const {currentZIndex} = useZIndex();
+ useLayoutEffect(() => {
+ delayRef.current = delay;
+ }, [delay]);
+
useLayoutEffect(() => {
if (!visible) {
return;
@@ -92,6 +99,7 @@ export const ActionTooltip: React.FC<{
}, [visible]);
const hide = useCallback(() => {
+ activation.current = null;
if (timer.current !== null) {
clearTimeout(timer.current);
timer.current = null;
@@ -112,32 +120,59 @@ export const ActionTooltip: React.FC<{
setVisible(true);
}, []);
- const onPointerEnter = useCallback(
- (event: React.PointerEvent<HTMLSpanElement>) => {
- if (
- event.pointerType === 'touch' ||
- timer.current !== null ||
- !event.currentTarget.contains(event.target as Node)
- ) {
- return;
- }
+ useLayoutEffect(() => {
+ const trigger = triggerRef.current;
+ if (!trigger) {
+ return;
+ }
- // Keep adjacent controls instant, including crossing the gap between them.
- if (
- !delay ||
- visibleTooltipCount > 0 ||
- (lastTooltipHiddenAt !== null &&
- Date.now() - lastTooltipHiddenAt < TOOLTIP_SKIP_DELAY_WINDOW)
- ) {
- show();
- return;
- }
+ const unobserve = PlayerInternals.observeHover({
+ element: trigger,
+ onPointerMove: null,
+ onHoverChange: (hovered) => {
+ // Keyboard focus is independent of the pointer's location.
+ if (activation.current === 'focus') {
+ return;
+ }
- setActive(true);
- timer.current = setTimeout(show, delay);
- },
- [delay, show],
- );
+ if (!hovered) {
+ hide();
+ return;
+ }
+
+ activation.current = 'hover';
+ const hoverDelay = delayRef.current;
+ // Keep adjacent controls instant, including crossing the gap between them.
+ if (
+ !hoverDelay ||
+ visibleTooltipCount > 0 ||
+ (lastTooltipHiddenAt !== null &&
+ Date.now() - lastTooltipHiddenAt < TOOLTIP_SKIP_DELAY_WINDOW)
+ ) {
+ show();
+ return;
+ }
+
+ setActive(true);
+ timer.current = setTimeout(() => {
+ // Recheck before opening, even if the browser missed a leave event.
+ if (trigger.isConnected && trigger.matches(':hover')) {
+ show();
+ } else {
+ hide();
+ }
+ }, hoverDelay);
+ },
+ });
+ return () => {
+ unobserve();
+ activation.current = null;
+ if (timer.current !== null) {
+ clearTimeout(timer.current);
+ timer.current = null;
+ }
+ };
+ }, [hide, show]);
useEffect(() => {
if (!active) {
@@ -150,19 +185,35 @@ export const ActionTooltip: React.FC<{
}
};
- window.addEventListener('keydown', onKeyDown);
- window.addEventListener('blur', hide);
- window.addEventListener('resize', hide);
- window.addEventListener('scroll', hide, true);
+ const doc = triggerRef.current?.ownerDocument;
+ const win = doc?.defaultView;
+
+ if (!doc || !win) {
+ return;
+ }
+
+ const onVisibilityChange = () => {
+ if (doc.hidden) {
+ hide();
+ }
+ };
+
+ win.addEventListener('keydown', onKeyDown);
+ win.addEventListener('blur', hide);
+ win.addEventListener('resize', hide);
+ win.addEventListener('scroll', hide, true);
+ doc.addEventListener('visibilitychange', onVisibilityChange);
return () => {
if (timer.current !== null) {
clearTimeout(timer.current);
+ timer.current = null;
}
- window.removeEventListener('keydown', onKeyDown);
- window.removeEventListener('blur', hide);
- window.removeEventListener('resize', hide);
- window.removeEventListener('scroll', hide, true);
+ win.removeEventListener('keydown', onKeyDown);
+ win.removeEventListener('blur', hide);
+ win.removeEventListener('resize', hide);
+ win.removeEventListener('scroll', hide, true);
+ doc.removeEventListener('visibilitychange', onVisibilityChange);
};
}, [active, hide]);
@@ -215,16 +266,22 @@ export const ActionTooltip: React.FC<{
<span
ref={triggerRef}
style={{...defaultTriggerStyle, ...triggerStyle}}
- onPointerEnter={onPointerEnter}
- onPointerLeave={hide}
onPointerDownCapture={dismissOnClick ? hide : undefined}
onClickCapture={dismissOnClick ? hide : undefined}
onFocus={(event) => {
- if (event.currentTarget.contains(event.target)) {
+ if (
+ event.currentTarget.contains(event.target) &&
+ event.target.matches(':focus-visible')
+ ) {
+ activation.current = 'focus';
show();
}
}}
- onBlur={hide}
+ onBlur={(event) => {
+ if (!event.currentTarget.contains(event.relatedTarget)) {
+ hide();
+ }
+ }}
>
{children}
</span>
diff --git a/packages/studio/src/components/Preview.tsx b/packages/studio/src/components/Preview.tsx
index d9d3d7112c..2b64512def 100644
--- a/packages/studio/src/components/Preview.tsx
+++ b/packages/studio/src/components/Preview.tsx
@@ -196,16 +196,12 @@ const CompWhenItHasDimensions: React.FC<{
return;
}
- const onPointerEnter = () => setCanvasHovered(true);
- const onPointerLeave = () => setCanvasHovered(false);
- setCanvasHovered(compositionContainer.matches(':hover'));
- compositionContainer.addEventListener('pointerenter', onPointerEnter);
- compositionContainer.addEventListener('pointerleave', onPointerLeave);
-
- return () => {
- compositionContainer.removeEventListener('pointerenter', onPointerEnter);
- compositionContainer.removeEventListener('pointerleave', onPointerLeave);
- };
+ setCanvasHovered(false);
+ return PlayerInternals.observeHover({
+ element: compositionContainer,
+ onHoverChange: setCanvasHovered,
+ onPointerMove: null,
+ });
}, [canvasContent.type]);
const {centerX, centerY, yCorrection, xCorrection, scale} = useMemo(() => {
diff --git a/packages/studio/src/helpers/hoverable.ts b/packages/studio/src/helpers/hoverable.ts
index 1e21b545a3..c9d88d110f 100644
--- a/packages/studio/src/helpers/hoverable.ts
+++ b/packages/studio/src/helpers/hoverable.ts
@@ -7,6 +7,8 @@ import {TRANSPARENT} from './colors';
// frame, which would leave a state-driven hover background stuck forever.
// CSS `:hover` is maintained by the browser and self-corrects.
// https://github.com/remotion-dev/remotion/issues/9886
+// For behavior that needs JavaScript (tooltips, delayed controls, canvas UI),
+// use PlayerInternals.observeHover so missed leave events are reconciled too.
export const HOVERABLE_CLASS_NAME = '__remotion-hoverable';
export const HOVER_GROUP_CLASS_NAME = '__remotion-hover-group';