🎥 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.tsindex 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', aexpect(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.tsindex 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.tsnew file mode 100644index 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.tsindex 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.tsxindex 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<{<spanref={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.tsxindex 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.tsindex 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';