Skip to content
Source
Sign inSign up
pingdotgg/t3code
Open History to see the last commit

ThreadPreviewMiniPlayer.tsx

643 lines24.6 KB

1import { FILL_PREVIEW_VIEWPORT, type ScopedThreadRef } from "@t3tools/contracts";
2import { previewPdfAssetUrl } from "@t3tools/shared/preview";
3import { useEnvironmentHttpBaseUrl } from "~/state/environments";
4import { PanelRightIcon, PictureInPicture2, XIcon } from "lucide-react";
5import {
6 type PointerEvent as ReactPointerEvent,
7 type ReactNode,
8 useEffect,
9 useRef,
10 useState,
11} from "react";
12import { create } from "zustand";
13import { useAtomValue } from "@effect/atom-react";
14import { scopedThreadKey } from "@t3tools/client-runtime/environment";
15​
16import { useChatCanvas } from "../chat/ChatCanvasContext";
17import type { ChatCanvasPreview } from "../chat/chatCanvasLayout";
18import { BrowserSurfaceSlot } from "~/browser/BrowserSurfaceSlot";
19import {
20 findActiveBrowserRecordingRuntimeTabId,
21 useActiveBrowserRecordingTabIds,
22} from "~/browser/browserRecording";
23import { useBrowserSurfaceStore } from "~/browser/browserSurfaceStore";
24import type { BrowserViewportResizeDirection } from "~/browser/browserViewportLayout";
25import { previewRuntimeTabId } from "~/browser/previewRuntimeTabId";
26import { rendersServerTabNatively } from "~/browser/previewRuntime";
27import { primaryEnvironmentIdAtom } from "~/state/primaryEnvironment";
28import { type ServerBrowserHandle, ServerBrowserSurface } from "~/browser/ServerBrowserSurface";
29import {
30 closeServerPictureInPicture,
31 openServerPictureInPicture,
32 serverPictureInPictureKey,
33 supportsServerPictureInPicture,
34 useServerPictureInPictureKey,
35} from "~/browser/serverPictureInPicture";
36import { useBrowserLayoutZoomFactor } from "~/browser/useBrowserLayoutZoomFactor";
37import { Button } from "~/components/ui/button";
38import { toastManager } from "~/components/ui/toast";
39import { Tooltip, TooltipPopup, TooltipTrigger } from "~/components/ui/tooltip";
40import { cn } from "~/lib/utils";
41import { useThreadPreviewState } from "~/previewStateStore";
42import {
43 type PreviewMiniPlayerSize,
44 type PreviewMiniPlayerSource,
45 type PreviewMiniPlayerState,
46 browserMiniPlayerSource,
47 previewMiniPlayerSourceKey,
48 usePreviewMiniPlayerStore,
49} from "~/previewMiniPlayerStore";
50import { useRightPanelStore } from "~/rightPanelStore";
51import { useDeviceState } from "~/state/device";
52​
53import { DeviceStreamView } from "../device/DeviceStreamView";
54import type { DeviceScreenSize } from "@t3tools/client-runtime/device/stream";
55import { Atom } from "effect/reactivity";
56import { deviceScreenKey, deviceStreamScreenAtom } from "../device/deviceStreamSession";
57import type { PreviewStreamViewport } from "@t3tools/client-runtime/preview/server-browser-stream";
58import { previewBridge } from "./previewBridge";
59import { PreviewUnreachable } from "./PreviewUnreachable";
60import { showPreviewPopup } from "./showPreviewPopup";
61import {
62 clampPreviewMiniPlayerPosition,
63 PREVIEW_MINI_PLAYER_CORNER_RADIUS,
64 PREVIEW_MINI_PLAYER_WEBVIEW_Z_INDEX,
65 type PreviewMiniPlayerFrame,
66 resizePreviewMiniPlayer,
67 resolveDeviceMiniPlayerCornerRadius,
68 resolveDeviceMiniPlayerSourceSize,
69 resolvePreviewMiniPlayerSourceSize,
70} from "./previewMiniPlayerLayout";
71​
72interface PointerGesture {
73 readonly pointerId: number;
74 readonly pointerType: string;
75 readonly pointerX: number;
76 readonly pointerY: number;
77 readonly frame: PreviewMiniPlayerFrame;
78 readonly direction: BrowserViewportResizeDirection | null;
79 moved: boolean;
81​
82const HANDLE_TAP_SLOP_PX = 6;
83​
84interface Props {
85 readonly threadRef: ScopedThreadRef;
86 readonly miniPlayer: PreviewMiniPlayerState;
88​
89const frameCornerRadius = () => PREVIEW_MINI_PLAYER_CORNER_RADIUS;
90​
91const RESIZE_HANDLES: ReadonlyArray<{
92 readonly direction: BrowserViewportResizeDirection;
93 readonly className: string;
94}> = [
95 { direction: "north", className: "inset-x-0 -top-1 h-2 cursor-ns-resize" },
96 { direction: "south", className: "inset-x-0 -bottom-1 h-2 cursor-ns-resize" },
97 { direction: "west", className: "inset-y-0 -left-1 w-2 cursor-ew-resize" },
98 { direction: "east", className: "inset-y-0 -right-1 w-2 cursor-ew-resize" },
99 { direction: "northwest", className: "-left-2 -top-2 size-4 cursor-nwse-resize" },
100 { direction: "northeast", className: "-right-2 -top-2 size-4 cursor-nesw-resize" },
101 { direction: "southwest", className: "-bottom-2 -left-2 size-4 cursor-nesw-resize" },
102 { direction: "southeast", className: "-bottom-2 -right-2 size-4 cursor-nwse-resize" },
103];
104​
105// What the stream reports about its source. It lives outside the player so the
106// chat canvas lays out the frame from the same source size the player uses. One
107// slot is enough, since only the shown thread renders a player, and it keeps the
108// store from collecting an entry for every tab a session ever streamed.
109const useStreamedSourceSize = create<{
110 readonly key: string;
111 readonly viewport: PreviewStreamViewport;
112} | null>(() => null);
113​
114const NO_DEVICE_SCREEN_ATOM = Atom.make<DeviceScreenSize | null>(null).pipe(
115 Atom.withLabel("device-stream-screen:none"),
116);
117​
118const streamedSourceKey = (threadRef: ScopedThreadRef, sourceKey: string) =>
119 `${scopedThreadKey(threadRef)}\u0000${sourceKey}`;
120​
121// The mini player's device stream view, named so the canvas can read the
122// screen size that view reports.
123const miniPlayerDeviceViewId = (
124 threadRef: ScopedThreadRef,
125 source: Extract<PreviewMiniPlayerSource, { kind: "device" }>,
126) =>
127 `preview-mini-player\u0000${scopedThreadKey(threadRef)}\u0000${deviceScreenKey(threadRef.environmentId, source.hostId, source.deviceId)}`;
128​
129function useBrowserMiniPlayerSource(threadRef: ScopedThreadRef | null, tabId: string | null) {
130 const previewState = useThreadPreviewState(threadRef);
131 const snapshot = tabId === null ? null : (previewState.sessions[tabId] ?? null);
132 const runtimeTabId =
133 threadRef && tabId !== null
134 ? previewRuntimeTabId(threadRef, previewState.serverEpoch, tabId)
135 : null;
136 const desktopOverlay = tabId === null ? null : (previewState.desktopByTabId[tabId] ?? null);
137 const layoutZoomFactor = useBrowserLayoutZoomFactor(desktopOverlay?.zoomFactor ?? 1);
138 const fittedSourceContent = useBrowserSurfaceStore((state) =>
139 runtimeTabId === null ? null : (state.byTabId[runtimeTabId]?.fittedSourceContent ?? null),
140 );
141 const primaryEnvironmentId = useAtomValue(primaryEnvironmentIdAtom);
142 const serverTab =
143 threadRef !== null &&
144 snapshot?.runtime === "server" &&
145 !rendersServerTabNatively(threadRef.environmentId, primaryEnvironmentId, snapshot);
146 const streamViewport = useStreamedSourceSize((state) =>
147 threadRef &&
148 tabId !== null &&
149 state?.key ===
150 streamedSourceKey(threadRef, previewMiniPlayerSourceKey(browserMiniPlayerSource(tabId)))
151 ? state.viewport
152 : null,
153 );
154 const sourceSize: PreviewMiniPlayerSize =
155 serverTab && streamViewport
156 ? streamViewport
157 : resolvePreviewMiniPlayerSourceSize(
158 snapshot?.viewport ?? FILL_PREVIEW_VIEWPORT,
159 fittedSourceContent,
160 layoutZoomFactor,
161 );
162 return { serverEpoch: previewState.serverEpoch, snapshot, desktopOverlay, serverTab, sourceSize };
164​
165/** The mini player as the chat canvas lays it out; null when no player renders. */
166export function useThreadPreviewCanvasSource(
167 threadRef: ScopedThreadRef | null,
168 miniPlayer: PreviewMiniPlayerState | null,
169): ChatCanvasPreview | null {
170 const source = miniPlayer?.source ?? null;
171 const browser = useBrowserMiniPlayerSource(
172 threadRef,
173 source?.kind === "browser" ? source.tabId : null,
174 );
175 const sourceKey = source ? previewMiniPlayerSourceKey(source) : null;
176 const screen = useAtomValue(
177 threadRef && source?.kind === "device"
178 ? deviceStreamScreenAtom(miniPlayerDeviceViewId(threadRef, source))
179 : NO_DEVICE_SCREEN_ATOM,
180 );
181 if (!miniPlayer || !source || sourceKey === null) return null;
182 if (source.kind === "browser" && !browser.snapshot) return null;
183 return {
184 key: sourceKey,
185 width: miniPlayer.width,
186 position: miniPlayer.position,
187 lastInteraction: miniPlayer.lastInteraction,
188 source:
189 source.kind === "browser"
190 ? browser.sourceSize
191 : resolveDeviceMiniPlayerSourceSize(source.platform, screen),
192 };
194​
195export function ThreadPreviewMiniPlayer({ threadRef, miniPlayer }: Props) {
196 const { source } = miniPlayer;
197 return source.kind === "browser" ? (
198 <BrowserMiniPlayer
199 key={source.tabId}
200 threadRef={threadRef}
201 tabId={source.tabId}
202 miniPlayer={miniPlayer}
203 />
204 ) : (
205 <DeviceMiniPlayer
206 key={previewMiniPlayerSourceKey(source)}
207 threadRef={threadRef}
208 source={source}
209 miniPlayer={miniPlayer}
210 />
211 );
213​
214function BrowserMiniPlayer({ threadRef, tabId, miniPlayer }: Props & { readonly tabId: string }) {
215 const httpBaseUrl = useEnvironmentHttpBaseUrl(threadRef.environmentId);
216 const { serverEpoch, snapshot, desktopOverlay, serverTab, sourceSize } =
217 useBrowserMiniPlayerSource(threadRef, tabId);
218 const runtimeTabId = previewRuntimeTabId(threadRef, serverEpoch, tabId);
219 const recordingTabIds = useActiveBrowserRecordingTabIds();
220 const recording =
221 recordingTabIds.has(runtimeTabId) ||
222 findActiveBrowserRecordingRuntimeTabId(threadRef, tabId) !== null;
223 const serverSurfaceRef = useRef<ServerBrowserHandle | null>(null);
224 const serverPictureInPicture =
225 useServerPictureInPictureKey() === serverPictureInPictureKey(threadRef.threadId, tabId);
226 const viewportKey = streamedSourceKey(
227 threadRef,
228 previewMiniPlayerSourceKey(browserMiniPlayerSource(tabId)),
229 );
230​
231 const openInPanel = () => {
232 usePreviewMiniPlayerStore.getState().close(threadRef);
233 useRightPanelStore.getState().openBrowser(threadRef, tabId);
234 };
235​
236 const toggleNativePictureInPicture = async () => {
237 try {
238 if (serverTab) {
239 if (serverPictureInPicture) closeServerPictureInPicture();
240 else
241 await openServerPictureInPicture({
242 ...threadRef,
243 tabId,
244 seed: serverSurfaceRef.current?.canvas() ?? null,
245 });
246 } else if (previewBridge) {
247 const operation = desktopOverlay?.pictureInPicture
248 ? previewBridge.pictureInPicture.close
249 : previewBridge.pictureInPicture.open;
250 await operation(runtimeTabId);
251 }
252 } catch (error) {
253 toastManager.add({
254 type: "error",
255 title: serverTab ? "Unable to pop out preview" : "Unable to update popped-out preview",
256 description: error instanceof Error ? error.message : "An error occurred.",
257 });
258 }
259 };
260​
261 if (!snapshot) return null;
262 const pdfUrl =
263 snapshot.navStatus._tag === "Success"
264 ? previewPdfAssetUrl(snapshot.navStatus.url, httpBaseUrl)
265 : null;
266 const loadFailed = snapshot.navStatus._tag === "LoadFailed" ? snapshot.navStatus : null;
267 const poppedOut = serverTab ? serverPictureInPicture : Boolean(desktopOverlay?.pictureInPicture);
268 const canPopOut = serverTab
269 ? poppedOut || (pdfUrl === null && supportsServerPictureInPicture())
270 : true;
271​
272 return (
273 <MiniPlayerShell
274 threadRef={threadRef}
275 miniPlayer={miniPlayer}
276 sourceSize={sourceSize}
277 label="Floating browser preview"
278 recording={recording}
279 onOpenInPanel={openInPanel}
280 pillActions={
281 canPopOut ? (
282 <Tooltip>
283 <TooltipTrigger
284 render={
285 <Button
286 variant={poppedOut ? "secondary" : "ghost"}
287 size="icon-xs"
288 aria-label={
289 poppedOut ? "Close popped-out preview" : "Pop preview into separate window"
290 }
291 disabled={!serverTab && !desktopOverlay?.hasWebContents}
292 onPointerDown={(event) => event.stopPropagation()}
293 onClick={toggleNativePictureInPicture}
294 />
295 }
296 >
297 <PictureInPicture2 />
298 </TooltipTrigger>
299 <TooltipPopup side="top">
300 {poppedOut ? "Close separate window" : "Pop into separate window"}
301 </TooltipPopup>
302 </Tooltip>
303 ) : null
304 }
305 >
306 {(frame) =>
307 serverTab ? (
308 <div
309 className="pointer-events-auto absolute inset-0 overflow-hidden rounded-[inherit]"
310 style={{ zIndex: PREVIEW_MINI_PLAYER_WEBVIEW_Z_INDEX }}
311 >
312 <ServerBrowserSurface
313 ref={serverSurfaceRef}
314 environmentId={threadRef.environmentId}
315 threadId={threadRef.threadId}
316 tabId={tabId}
317 pdfUrl={pdfUrl}
318 visible
319 followSize={false}
320 controlPosition="bottom"
321 onViewport={(viewport) =>
322 useStreamedSourceSize.setState(
323 (state) =>
324 state?.key === viewportKey &&
325 state.viewport.width === viewport.width &&
326 state.viewport.height === viewport.height
327 ? state
328 : { key: viewportKey, viewport },
329 true,
330 )
331 }
332 onPopup={(popupTabId) => showPreviewPopup(threadRef, popupTabId, "floating")}
333 className="size-full"
334 />
335 </div>
336 ) : (
337 <>
338 <BrowserSurfaceSlot
339 tabId={runtimeTabId}
340 visible={Boolean(desktopOverlay?.hasWebContents) && !loadFailed}
341 cornerRadius={PREVIEW_MINI_PLAYER_CORNER_RADIUS}
342 zIndex={PREVIEW_MINI_PLAYER_WEBVIEW_Z_INDEX}
343 fitSourceContent
344 layoutVersion={`${frame.x}:${frame.y}`}
345 className="absolute inset-0"
346 />
347 {loadFailed ? (
348 <div className="pointer-events-auto absolute inset-0 z-[48] overflow-hidden rounded-[inherit]">
349 <PreviewUnreachable
350 url={loadFailed.url}
351 code={loadFailed.code}
352 description={loadFailed.description}
353 onReload={() => void previewBridge?.refresh(runtimeTabId)}
354 />
355 </div>
356 ) : !desktopOverlay?.hasWebContents ? (
357 <div className="pointer-events-none absolute inset-0 z-[49] flex items-center justify-center rounded-[inherit] bg-muted text-xs text-muted-foreground">
358 Reconnecting preview…
359 </div>
360 ) : null}
361 </>
362 )
363 }
364 </MiniPlayerShell>
365 );
367​
368function DeviceMiniPlayer({
369 threadRef,
370 source,
371 miniPlayer,
372}: Props & { readonly source: Extract<PreviewMiniPlayerSource, { kind: "device" }> }) {
373 const { state: deviceState } = useDeviceState(threadRef.environmentId);
374 const viewId = miniPlayerDeviceViewId(threadRef, source);
375 const screen = useAtomValue(deviceStreamScreenAtom(viewId));
376 const sourceSize = resolveDeviceMiniPlayerSourceSize(source.platform, screen);
377 const device = deviceState.devices.find(
378 (entry) => entry.hostId === source.hostId && entry.id === source.deviceId,
379 );
380 const host = deviceState.hosts.find((entry) => entry.id === source.hostId);
381 const hostLabel = host?.label ?? "Device host";
382 const cornerRadius = (player: PreviewMiniPlayerSize) =>
383 resolveDeviceMiniPlayerCornerRadius(source.platform, player);
384​
385 const openInPanel = () => {
386 usePreviewMiniPlayerStore.getState().close(threadRef);
387 useRightPanelStore.getState().openDevice(threadRef, {
388 hostId: source.hostId,
389 deviceId: source.deviceId,
390 platform: source.platform,
391 name: source.name,
392 });
393 };
394​
395 return (
396 <MiniPlayerShell
397 threadRef={threadRef}
398 miniPlayer={miniPlayer}
399 sourceSize={sourceSize}
400 label="Floating device preview"
401 onOpenInPanel={openInPanel}
402 cornerRadius={cornerRadius}
403 >
404 {() => (
405 <div
406 className="pointer-events-auto absolute inset-0 overflow-hidden rounded-[inherit]"
407 style={{ zIndex: PREVIEW_MINI_PLAYER_WEBVIEW_Z_INDEX }}
408 >
409 <DeviceStreamView
410 environmentId={threadRef.environmentId}
411 platform={source.platform}
412 deviceId={source.deviceId}
413 hostId={source.hostId}
414 deviceName={device?.name ?? source.name}
415 deviceDescription={`${hostLabel} · ${device?.version ?? source.platform}`}
416 visible
417 viewId={viewId}
418 serveSimOnly={host?.kind === "simlock"}
419 />
420 </div>
421 )}
422 </MiniPlayerShell>
423 );
425​
426/** Match native clipping and DOM radii to align their separately composited edges. */
427function MiniPlayerShell({
428 threadRef,
429 miniPlayer,
430 sourceSize,
431 label,
432 onOpenInPanel,
433 pillActions,
434 recording = false,
435 cornerRadius = frameCornerRadius,
436 children,
437}: {
438 readonly threadRef: ScopedThreadRef;
439 readonly miniPlayer: PreviewMiniPlayerState;
440 readonly sourceSize: PreviewMiniPlayerSize;
441 readonly label: string;
442 readonly onOpenInPanel: () => void;
443 readonly pillActions?: ReactNode;
444 readonly recording?: boolean;
445 readonly cornerRadius?: (frame: PreviewMiniPlayerSize) => number;
446 readonly children: (frame: PreviewMiniPlayerFrame) => ReactNode;
447}) {
448 const canvas = useChatCanvas();
449 const gestureRef = useRef<PointerGesture | null>(null);
450 // Touch toggles the pill after the tap's click so that click cannot land on the newly opened pill.
451 const [pillOpen, setPillOpen] = useState(false);
452 const handleTappedRef = useRef(false);
453 const handleRef = useRef<HTMLDivElement | null>(null);
454 // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- document pointerdown listener closes the open pill on an outside press
455 useEffect(() => {
456 if (!pillOpen) return;
457 const dismiss = (event: PointerEvent) => {
458 if (event.target instanceof Node && handleRef.current?.contains(event.target)) return;
459 setPillOpen(false);
460 };
461 document.addEventListener("pointerdown", dismiss, true);
462 return () => document.removeEventListener("pointerdown", dismiss, true);
463 }, [pillOpen]);
464 const container = canvas?.container ?? null;
465 const sourceKey = previewMiniPlayerSourceKey(miniPlayer.source);
466 const frame = canvas?.previewKey === sourceKey ? canvas.layout.frame : null;
467​
468 const radius = frame ? cornerRadius(frame) : PREVIEW_MINI_PLAYER_CORNER_RADIUS;
469 const pillInset = Math.max(8, Math.round(radius * 0.55));
470​
471 const close = () => {
472 usePreviewMiniPlayerStore.getState().close(threadRef);
473 };
474​
475 const beginGesture = (
476 event: ReactPointerEvent<HTMLElement>,
477 direction: BrowserViewportResizeDirection | null,
478 ) => {
479 if (event.button !== 0 || !frame) return;
480 gestureRef.current = {
481 pointerId: event.pointerId,
482 pointerType: event.pointerType,
483 pointerX: event.clientX,
484 pointerY: event.clientY,
485 frame,
486 direction,
487 moved: false,
488 };
489 event.currentTarget.setPointerCapture(event.pointerId);
490 event.preventDefault();
491 event.stopPropagation();
492 };
493​
494 const handlePointerMove = (event: ReactPointerEvent<HTMLElement>) => {
495 const gesture = gestureRef.current;
496 if (!gesture || gesture.pointerId !== event.pointerId || !container) return;
497 const delta = { x: event.clientX - gesture.pointerX, y: event.clientY - gesture.pointerY };
498 if (!gesture.moved && Math.hypot(delta.x, delta.y) < HANDLE_TAP_SLOP_PX) return;
499 gesture.moved = true;
500 const store = usePreviewMiniPlayerStore.getState();
501 if (gesture.direction === null) {
502 store.move(
503 threadRef,
504 sourceKey,
505 clampPreviewMiniPlayerPosition(
506 { x: gesture.frame.x + delta.x, y: gesture.frame.y + delta.y },
507 container,
508 gesture.frame,
509 ),
510 );
511 return;
512 }
513 const next = resizePreviewMiniPlayer({
514 start: gesture.frame,
515 direction: gesture.direction,
516 delta,
517 source: sourceSize,
518 container,
519 });
520 store.resize(threadRef, sourceKey, next.width, { x: next.x, y: next.y });
521 };
522​
523 const endGesture = (event: ReactPointerEvent<HTMLElement>) => {
524 const gesture = gestureRef.current;
525 if (gesture?.pointerId !== event.pointerId) return;
526 gestureRef.current = null;
527 handleTappedRef.current =
528 event.type === "pointerup" &&
529 gesture.direction === null &&
530 gesture.pointerType === "touch" &&
531 !gesture.moved;
532 if (event.currentTarget.hasPointerCapture(event.pointerId)) {
533 event.currentTarget.releasePointerCapture(event.pointerId);
534 }
535 };
536​
537 return (
538 <div className="pointer-events-none absolute inset-0">
539 {frame ? (
540 <section
541 aria-label={label}
542 data-preview-mini-player={sourceKey}
543 className="pointer-events-none absolute select-none"
544 style={{
545 left: frame.x,
546 top: frame.y,
547 width: frame.width,
548 height: frame.height,
549 borderRadius: radius,
550 }}
551 >
552 <div
553 ref={handleRef}
554 data-pill-open={pillOpen ? "" : undefined}
555 className="group pointer-events-auto absolute z-[49] size-3 touch-none cursor-grab active:cursor-grabbing pointer-coarse:-m-2.5 pointer-coarse:size-8"
556 style={{ right: pillInset, top: pillInset }}
557 onPointerDown={(event) => beginGesture(event, null)}
558 onPointerMove={handlePointerMove}
559 onPointerUp={endGesture}
560 onPointerCancel={endGesture}
561 onClick={() => {
562 if (!handleTappedRef.current) return;
563 handleTappedRef.current = false;
564 setPillOpen((open) => !open);
565 }}
566 >
567 <div
568 role={recording ? "status" : undefined}
569 aria-label={recording ? "Recording preview" : undefined}
570 aria-hidden={!recording}
571 className="absolute right-0 top-0 size-2 transition-opacity group-hover:opacity-0 group-focus-within:opacity-0 group-data-pill-open:opacity-0 pointer-coarse:right-2.5 pointer-coarse:top-2.5"
572 >
573 <span
574 className={cn(
575 "block size-2 rounded-full shadow-sm ring-1 ring-background/70",
576 recording
577 ? "bg-destructive motion-safe:animate-status-pulse"
578 : "bg-foreground/25",
579 )}
580 />
581 </div>
582 <div className="pointer-events-none absolute right-0 top-0 flex h-8 cursor-grab items-center gap-0.5 rounded-lg border border-border/80 bg-popover/92 p-0.5 opacity-0 shadow-lg/20 backdrop-blur-xl transition-opacity group-hover:pointer-events-auto group-hover:opacity-100 group-focus-within:pointer-events-auto group-focus-within:opacity-100 group-data-pill-open:pointer-events-auto group-data-pill-open:opacity-100 active:cursor-grabbing pointer-coarse:right-2.5 pointer-coarse:top-2.5">
583 {recording ? (
584 <span aria-hidden className="flex size-6 shrink-0 items-center justify-center">
585 <span className="size-2 rounded-full bg-destructive motion-safe:animate-status-pulse" />
586 </span>
587 ) : null}
588 <Tooltip>
589 <TooltipTrigger
590 render={
591 <Button
592 variant="ghost"
593 size="icon-xs"
594 aria-label="Open preview in right panel"
595 onPointerDown={(event) => event.stopPropagation()}
596 onClick={onOpenInPanel}
597 />
598 }
599 >
600 <PanelRightIcon />
601 </TooltipTrigger>
602 <TooltipPopup side="top">Open in right panel</TooltipPopup>
603 </Tooltip>
604 {pillActions}
605 <Tooltip>
606 <TooltipTrigger
607 render={
608 <Button
609 variant="ghost"
610 size="icon-xs"
611 aria-label="Close floating preview"
612 onPointerDown={(event) => event.stopPropagation()}
613 onClick={close}
614 />
615 }
616 >
617 <XIcon />
618 </TooltipTrigger>
619 <TooltipPopup side="top">Close floating preview</TooltipPopup>
620 </Tooltip>
621 </div>
622 </div>
623​
624 <div className="absolute inset-0 z-[47] rounded-[inherit] bg-muted shadow-2xl/35" />
625 {children(frame)}
626 <div className="pointer-events-none absolute inset-0 z-[49] rounded-[inherit] ring-1 ring-inset ring-border/80" />
627 {RESIZE_HANDLES.map(({ direction, className }) => (
628 <div
629 key={direction}
630 role="presentation"
631 data-preview-mini-player-resize={direction}
632 className={cn("pointer-events-auto absolute z-[49] touch-none", className)}
633 onPointerDown={(event) => beginGesture(event, direction)}
634 onPointerMove={handlePointerMove}
635 onPointerUp={endGesture}
636 onPointerCancel={endGesture}
637 />
638 ))}
639 </section>
640 ) : null}
641 </div>
642 );