The best way to control Claude Code, Codex and more from any computer or phone
| 1 | import type { |
| 2 | DesktopPreviewColorScheme, |
| 3 | PreviewViewportSetting, |
| 4 | ScopedThreadRef, |
| 5 | } from "@t3tools/contracts"; |
| 6 | import { useShallow } from "zustand/react/shallow"; |
| 7 | import { useEffect, useEffectEvent, useRef, useState } from "react"; |
| 8 | |
| 9 | import { previewBridge } from "~/components/preview/previewBridge"; |
| 10 | import { |
| 11 | preventThumbButtonFocus, |
| 12 | takeThumbButtonNavigation, |
| 13 | } from "~/components/preview/thumbButtons"; |
| 14 | import { usePreviewBridge } from "~/components/preview/usePreviewBridge"; |
| 15 | import { useClientSettingsHydrated } from "~/hooks/useSettings"; |
| 16 | import { cn, isMacPlatform } from "~/lib/utils"; |
| 17 | |
| 18 | import { resolveBrowserSurfacePanelRect, useBrowserSurfaceStore } from "./browserSurfaceStore"; |
| 19 | import { useActiveBrowserRecordingTabIds } from "./browserRecording"; |
| 20 | import { |
| 21 | browserViewportSettingKey, |
| 22 | resolveBrowserViewportLayout, |
| 23 | resolveBrowserViewportTransform, |
| 24 | resolveFittedBrowserViewport, |
| 25 | } from "./browserViewportLayout"; |
| 26 | import { BrowserDeviceToolbar } from "./BrowserDeviceToolbar"; |
| 27 | import { BrowserViewportResizeHandles } from "./BrowserViewportResizeHandles"; |
| 28 | import { acquireDesktopTab, type AcquiredDesktopTab, withDesktopTab } from "./desktopTabLifetime"; |
| 29 | import { resolveHostedBrowserWebviewWrapperStyle } from "./hostedBrowserWebviewStyle"; |
| 30 | import { usePreviewWebviewConfig } from "./previewWebviewConfigState"; |
| 31 | import { useBrowserLayoutZoomFactor } from "./useBrowserLayoutZoomFactor"; |
| 32 | import { useBrowserViewportResize } from "./useBrowserViewportResize"; |
| 33 | import { |
| 34 | INITIAL_WEBVIEW_CRASH_RECOVERY_STATE, |
| 35 | planWebviewCrashRecovery, |
| 36 | type WebviewCrashRecoveryState, |
| 37 | } from "./webviewCrashRecovery"; |
| 38 | |
| 39 | interface ElectronWebview extends HTMLElement { |
| 40 | src: string; |
| 41 | partition: string; |
| 42 | preload?: string; |
| 43 | webpreferences?: string; |
| 44 | getWebContentsId: () => number; |
| 45 | executeJavaScript: (code: string, userGesture?: boolean) => Promise<unknown>; |
| 46 | } |
| 47 | |
| 48 | declare global { |
| 49 | interface HTMLElementTagNameMap { |
| 50 | webview: ElectronWebview; |
| 51 | } |
| 52 | } |
| 53 | |
| 54 | export function HostedBrowserWebview(props: { |
| 55 | readonly threadRef: ScopedThreadRef; |
| 56 | readonly tabId: string; |
| 57 | readonly runtimeTabId: string; |
| 58 | readonly initialUrl: string | null; |
| 59 | readonly viewport: PreviewViewportSetting; |
| 60 | readonly pictureInPicture: boolean; |
| 61 | /** Fixed for the tab lifetime; Electron reads partition before guest attachment. */ |
| 62 | readonly profileId: string | undefined; |
| 63 | readonly zoomFactor: number; |
| 64 | readonly serverDriven?: boolean; |
| 65 | readonly serverRendering?: { |
| 66 | readonly colorScheme: DesktopPreviewColorScheme; |
| 67 | readonly zoomFactor: number; |
| 68 | }; |
| 69 | }) { |
| 70 | const { |
| 71 | threadRef, |
| 72 | tabId, |
| 73 | runtimeTabId, |
| 74 | initialUrl, |
| 75 | viewport, |
| 76 | pictureInPicture, |
| 77 | zoomFactor, |
| 78 | profileId, |
| 79 | serverDriven = false, |
| 80 | serverRendering, |
| 81 | } = props; |
| 82 | const clientSettingsHydrated = useClientSettingsHydrated(); |
| 83 | const config = usePreviewWebviewConfig(threadRef.environmentId, profileId); |
| 84 | const [initialSrc] = useState(() => initialUrl ?? "about:blank"); |
| 85 | const tabLeaseRef = useRef<AcquiredDesktopTab | null>(null); |
| 86 | const wrapperRef = useRef<HTMLDivElement | null>(null); |
| 87 | const webviewRef = useRef<ElectronWebview | null>(null); |
| 88 | const crashRecoveryRef = useRef<WebviewCrashRecoveryState>(INITIAL_WEBVIEW_CRASH_RECOVERY_STATE); |
| 89 | const [aspectRatioLocked, setAspectRatioLocked] = useState(false); |
| 90 | const presentation = useBrowserSurfaceStore( |
| 91 | useShallow((state) => { |
| 92 | const current = state.byTabId[runtimeTabId]; |
| 93 | return { |
| 94 | content: current?.content ?? null, |
| 95 | cornerRadius: current?.cornerRadius ?? 0, |
| 96 | fitSourceContent: current?.fitSourceContent ?? false, |
| 97 | fittedSourceContent: current?.fittedSourceContent ?? null, |
| 98 | rect: resolveBrowserSurfacePanelRect(state.byTabId, runtimeTabId), |
| 99 | visible: current?.visible ?? false, |
| 100 | zIndex: current?.zIndex ?? 30, |
| 101 | }; |
| 102 | }), |
| 103 | ); |
| 104 | const backgroundActivity = useBrowserSurfaceStore( |
| 105 | (state) => (state.activityByTabId[runtimeTabId] ?? 0) > 0, |
| 106 | ); |
| 107 | const recordingActive = useActiveBrowserRecordingTabIds().has(runtimeTabId); |
| 108 | usePreviewBridge({ threadRef, tabId, runtimeTabId, serverDriven }); |
| 109 | |
| 110 | const serverColorScheme = serverRendering?.colorScheme; |
| 111 | const serverZoomFactor = serverRendering?.zoomFactor; |
| 112 | |
| 113 | // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- leases the desktop preview tab for this webview and releases it on cleanup |
| 114 | useEffect(() => { |
| 115 | if (!clientSettingsHydrated) return; |
| 116 | crashRecoveryRef.current = INITIAL_WEBVIEW_CRASH_RECOVERY_STATE; |
| 117 | const lease = acquireDesktopTab( |
| 118 | runtimeTabId, |
| 119 | serverDriven ? { threadId: threadRef.threadId, tabId } : undefined, |
| 120 | ); |
| 121 | tabLeaseRef.current = lease; |
| 122 | return () => { |
| 123 | if (tabLeaseRef.current === lease) tabLeaseRef.current = null; |
| 124 | lease.release(); |
| 125 | }; |
| 126 | }, [clientSettingsHydrated, runtimeTabId, serverDriven, tabId, threadRef.threadId]); |
| 127 | |
| 128 | // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- applies the server color scheme to the desktop preview tab through the desktop bridge |
| 129 | useEffect(() => { |
| 130 | const bridge = window.desktopBridge?.preview; |
| 131 | if (!bridge || serverColorScheme === undefined) return; |
| 132 | withDesktopTab(runtimeTabId, () => bridge.setColorScheme(runtimeTabId, serverColorScheme)); |
| 133 | }, [runtimeTabId, serverColorScheme]); |
| 134 | // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- applies the server zoom factor to the desktop preview tab through the desktop bridge |
| 135 | useEffect(() => { |
| 136 | const bridge = window.desktopBridge?.preview; |
| 137 | if (!bridge || serverZoomFactor === undefined) return; |
| 138 | withDesktopTab(runtimeTabId, () => bridge.setZoomFactor(runtimeTabId, serverZoomFactor)); |
| 139 | }, [runtimeTabId, serverZoomFactor]); |
| 140 | |
| 141 | const [webviewGeneration, setWebviewGeneration] = useState(0); |
| 142 | const [recoverySrc, setRecoverySrc] = useState(initialSrc); |
| 143 | const active = presentation.visible && presentation.rect !== null; |
| 144 | const shown = active || pictureInPicture; |
| 145 | const reportedShown = useEffectEvent(() => serverDriven && shown); |
| 146 | const remountCrashedWebview = useEffectEvent(() => { |
| 147 | setRecoverySrc(initialUrl ?? initialSrc); |
| 148 | setWebviewGeneration((generation) => generation + 1); |
| 149 | }); |
| 150 | |
| 151 | const setWebviewRef = (node: HTMLElement | null) => { |
| 152 | webviewRef.current = node as ElectronWebview | null; |
| 153 | }; |
| 154 | |
| 155 | // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- registers the webview's webContents with the desktop bridge and listens for crashes and focus |
| 156 | useEffect(() => { |
| 157 | const webview = webviewRef.current; |
| 158 | const bridge = previewBridge; |
| 159 | if (!clientSettingsHydrated || !webview || !config || !bridge) return; |
| 160 | let disposed = false; |
| 161 | let recoveryTimeout: ReturnType<typeof setTimeout> | null = null; |
| 162 | const register = () => { |
| 163 | const lease = tabLeaseRef.current; |
| 164 | if (!lease) return; |
| 165 | void (async () => { |
| 166 | try { |
| 167 | // Tab creation and webview attachment use separate effects; wait to avoid PreviewTabNotFoundError. |
| 168 | await lease.ready; |
| 169 | if (disposed || webviewRef.current !== webview) return; |
| 170 | const webContentsId = webview.getWebContentsId(); |
| 171 | if (Number.isInteger(webContentsId) && webContentsId > 0) { |
| 172 | await bridge.registerWebview(runtimeTabId, webContentsId); |
| 173 | withDesktopTab(runtimeTabId, () => bridge.setShown(runtimeTabId, reportedShown())); |
| 174 | } |
| 175 | } catch {} |
| 176 | })(); |
| 177 | }; |
| 178 | const recoverGuest = () => { |
| 179 | if (disposed || recoveryTimeout !== null) return; |
| 180 | const recovery = planWebviewCrashRecovery(crashRecoveryRef.current, Date.now()); |
| 181 | if (!recovery) return; |
| 182 | crashRecoveryRef.current = recovery.state; |
| 183 | recoveryTimeout = setTimeout(() => { |
| 184 | recoveryTimeout = null; |
| 185 | if (!disposed) remountCrashedWebview(); |
| 186 | }, recovery.delayMs); |
| 187 | }; |
| 188 | // Guest clicks never reach this document, so replay a pointerdown to dismiss host popups. |
| 189 | // The guest preload reports each press, since the guest does not always take focus. |
| 190 | const dismissHostPopups = () => { |
| 191 | webview.dispatchEvent( |
| 192 | new PointerEvent("pointerdown", { bubbles: true, pointerType: "mouse" }), |
| 193 | ); |
| 194 | }; |
| 195 | const guestPointerDown = (event: Event) => { |
| 196 | // Mirrors POINTER_DOWN_HOST_CHANNEL in apps/desktop/src/preview/GuestProtocol.ts. |
| 197 | if ((event as Event & { channel?: string }).channel === "preview:pointer-down") { |
| 198 | dismissHostPopups(); |
| 199 | } |
| 200 | }; |
| 201 | webview.addEventListener("did-attach", register); |
| 202 | webview.addEventListener("dom-ready", register); |
| 203 | webview.addEventListener("render-process-gone", recoverGuest); |
| 204 | webview.addEventListener("focus", dismissHostPopups); |
| 205 | webview.addEventListener("ipc-message", guestPointerDown); |
| 206 | register(); |
| 207 | return () => { |
| 208 | disposed = true; |
| 209 | if (recoveryTimeout !== null) clearTimeout(recoveryTimeout); |
| 210 | webview.removeEventListener("did-attach", register); |
| 211 | webview.removeEventListener("dom-ready", register); |
| 212 | webview.removeEventListener("render-process-gone", recoverGuest); |
| 213 | webview.removeEventListener("focus", dismissHostPopups); |
| 214 | webview.removeEventListener("ipc-message", guestPointerDown); |
| 215 | }; |
| 216 | }, [ |
| 217 | clientSettingsHydrated, |
| 218 | config, |
| 219 | runtimeTabId, |
| 220 | // oxlint-disable-next-line react/exhaustive-effect-dependencies -- A crash recovery remounts the webview under a new key, so the listeners attach to the new element. |
| 221 | webviewGeneration, |
| 222 | ]); |
| 223 | |
| 224 | const lastRect = presentation.rect; |
| 225 | const layoutZoomFactor = useBrowserLayoutZoomFactor(zoomFactor); |
| 226 | const viewportWidth = viewport._tag === "fill" ? null : viewport.width; |
| 227 | const viewportHeight = viewport._tag === "fill" ? null : viewport.height; |
| 228 | const viewportAspectRatio = |
| 229 | viewportWidth === null || viewportHeight === null ? null : viewportWidth / viewportHeight; |
| 230 | const lockedAspectRatio = |
| 231 | aspectRatioLocked && viewportAspectRatio !== null ? viewportAspectRatio : null; |
| 232 | const handleAspectRatioChange = (aspectRatio: number | null) => { |
| 233 | setAspectRatioLocked(aspectRatio !== null); |
| 234 | }; |
| 235 | const content = presentation.content; |
| 236 | const hiddenWidth = |
| 237 | viewport._tag !== "fill" |
| 238 | ? viewport.width * layoutZoomFactor |
| 239 | : content |
| 240 | ? content.width / content.scale |
| 241 | : (lastRect?.width ?? 1280); |
| 242 | const hiddenHeight = |
| 243 | viewport._tag !== "fill" |
| 244 | ? viewport.height * layoutZoomFactor |
| 245 | : content |
| 246 | ? content.height / content.scale |
| 247 | : (lastRect?.height ?? 800); |
| 248 | // Build from primitives on each side of the resize hook to keep both objects cached. |
| 249 | const containerSize = |
| 250 | active && lastRect ? lastRect : { width: hiddenWidth, height: hiddenHeight }; |
| 251 | const deviceToolbarVisible = active && viewport._tag !== "fill" && !presentation.fitSourceContent; |
| 252 | const { |
| 253 | activeDrag, |
| 254 | commitViewportChange, |
| 255 | effectiveViewport, |
| 256 | handleResizeKeyDown, |
| 257 | handleResizePointerDown, |
| 258 | layout: viewportLayout, |
| 259 | } = useBrowserViewportResize({ |
| 260 | target: { threadRef, tabId, runtimeTabId }, |
| 261 | viewport, |
| 262 | zoomFactor: layoutZoomFactor, |
| 263 | containerSize, |
| 264 | deviceToolbarVisible, |
| 265 | aspectRatio: lockedAspectRatio, |
| 266 | }); |
| 267 | const fittedSourceViewport = |
| 268 | presentation.fitSourceContent && lastRect |
| 269 | ? resolveFittedBrowserViewport(viewport, presentation.fittedSourceContent, layoutZoomFactor) |
| 270 | : null; |
| 271 | const layout = |
| 272 | fittedSourceViewport && lastRect |
| 273 | ? resolveBrowserViewportLayout(lastRect, fittedSourceViewport, layoutZoomFactor) |
| 274 | : viewportLayout; |
| 275 | |
| 276 | const syncContentPresentation = () => { |
| 277 | const wrapper = wrapperRef.current; |
| 278 | if (!wrapper) return; |
| 279 | useBrowserSurfaceStore.getState().presentContent(runtimeTabId, { |
| 280 | x: layout.viewportX, |
| 281 | y: layout.viewportY, |
| 282 | width: layout.viewportWidth, |
| 283 | height: layout.viewportHeight, |
| 284 | scale: layout.viewportScale, |
| 285 | scrollLeft: wrapper.scrollLeft, |
| 286 | scrollTop: wrapper.scrollTop, |
| 287 | }); |
| 288 | }; |
| 289 | |
| 290 | // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- schedules a frame that publishes the webview layout and scroll to the browser surface store |
| 291 | useEffect(() => { |
| 292 | const frameId = window.requestAnimationFrame(syncContentPresentation); |
| 293 | return () => window.cancelAnimationFrame(frameId); |
| 294 | }, [syncContentPresentation]); |
| 295 | |
| 296 | // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- scrolls the webview wrapper element to its origin for a new tab or viewport size |
| 297 | useEffect(() => { |
| 298 | const wrapper = wrapperRef.current; |
| 299 | if (!wrapper) return; |
| 300 | wrapper.scrollTo({ left: 0, top: 0 }); |
| 301 | }, [ |
| 302 | // oxlint-disable-next-line react/exhaustive-effect-dependencies -- A new tab or viewport size starts the canvas scrolled to its origin. |
| 303 | runtimeTabId, |
| 304 | viewport._tag, |
| 305 | viewportHeight, |
| 306 | viewportWidth, |
| 307 | ]); |
| 308 | |
| 309 | // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- Report the mounted webview's visibility to the desktop host. |
| 310 | useEffect(() => { |
| 311 | const bridge = window.desktopBridge?.preview; |
| 312 | if (!clientSettingsHydrated || !bridge || !serverDriven) return; |
| 313 | withDesktopTab(runtimeTabId, () => bridge.setShown(runtimeTabId, shown)); |
| 314 | return () => withDesktopTab(runtimeTabId, () => bridge.setShown(runtimeTabId, false)); |
| 315 | }, [clientSettingsHydrated, runtimeTabId, serverDriven, shown]); |
| 316 | |
| 317 | // Captures copy the guest's raster, which a scaled guest only keeps at full detail on request. |
| 318 | const fullDetail = backgroundActivity || pictureInPicture || recordingActive; |
| 319 | // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- tells the desktop host once the guest is drawn at full detail, so its screenshot waits for that frame |
| 320 | useEffect(() => { |
| 321 | const bridge = window.desktopBridge?.preview; |
| 322 | if (!clientSettingsHydrated || !bridge || !serverDriven || !fullDetail) return; |
| 323 | let frame = requestAnimationFrame(() => { |
| 324 | frame = requestAnimationFrame(() => |
| 325 | withDesktopTab(runtimeTabId, () => bridge.setCaptureDrawn(runtimeTabId, true)), |
| 326 | ); |
| 327 | }); |
| 328 | return () => { |
| 329 | cancelAnimationFrame(frame); |
| 330 | withDesktopTab(runtimeTabId, () => bridge.setCaptureDrawn(runtimeTabId, false)); |
| 331 | }; |
| 332 | }, [clientSettingsHydrated, fullDetail, runtimeTabId, serverDriven]); |
| 333 | |
| 334 | if (!clientSettingsHydrated || !config) return null; |
| 335 | |
| 336 | // This fixed wrapper sits outside the right panel shell, so it takes thumb presses itself. |
| 337 | const navigateThumb = (direction: "back" | "forward") => { |
| 338 | if (direction === "back") void previewBridge?.goBack(runtimeTabId); |
| 339 | else void previewBridge?.goForward(runtimeTabId); |
| 340 | }; |
| 341 | |
| 342 | const renderingActive = active || backgroundActivity || pictureInPicture || recordingActive; |
| 343 | const viewportTransform = resolveBrowserViewportTransform(layout.viewportScale, fullDetail); |
| 344 | const wrapperStyle = resolveHostedBrowserWebviewWrapperStyle({ |
| 345 | active, |
| 346 | renderingActive, |
| 347 | // Electron 43 can permanently blank a macOS webview after `visibility: hidden`. |
| 348 | keepPaintableWhenInactive: isMacPlatform(navigator.platform), |
| 349 | cornerRadius: presentation.cornerRadius, |
| 350 | zIndex: presentation.zIndex, |
| 351 | rect: lastRect, |
| 352 | hiddenSize: { width: hiddenWidth, height: hiddenHeight }, |
| 353 | }); |
| 354 | |
| 355 | return ( |
| 356 | <div |
| 357 | ref={wrapperRef} |
| 358 | className="fixed overflow-hidden bg-muted/35" |
| 359 | style={{ ...wrapperStyle, overscrollBehavior: "contain" }} |
| 360 | onScroll={syncContentPresentation} |
| 361 | onMouseDown={preventThumbButtonFocus} |
| 362 | onMouseUp={(event) => takeThumbButtonNavigation(event, navigateThumb)} |
| 363 | data-preview-rendering={renderingActive ? "active" : "suspended"} |
| 364 | data-preview-viewport={runtimeTabId} |
| 365 | > |
| 366 | <div className="relative" style={{ width: layout.canvasWidth, height: layout.canvasHeight }}> |
| 367 | {deviceToolbarVisible && effectiveViewport._tag !== "fill" ? ( |
| 368 | <BrowserDeviceToolbar |
| 369 | setting={effectiveViewport} |
| 370 | width={Math.max(1, Math.round(active && lastRect ? lastRect.width : hiddenWidth))} |
| 371 | aspectRatio={lockedAspectRatio} |
| 372 | onAspectRatioChange={handleAspectRatioChange} |
| 373 | onChange={commitViewportChange} |
| 374 | /> |
| 375 | ) : null} |
| 376 | <div |
| 377 | className="absolute" |
| 378 | style={{ |
| 379 | left: layout.viewportX, |
| 380 | top: layout.viewportY, |
| 381 | width: layout.viewportWidth, |
| 382 | height: layout.viewportHeight, |
| 383 | transformStyle: viewportTransform && fullDetail ? "preserve-3d" : undefined, |
| 384 | }} |
| 385 | > |
| 386 | <webview |
| 387 | key={webviewGeneration} |
| 388 | ref={setWebviewRef} |
| 389 | // Electron needs allowpopups at attachment. React drops boolean values for unknown attributes. |
| 390 | {...({ allowpopups: "true" } as unknown as { readonly allowpopups?: boolean })} |
| 391 | src={webviewGeneration === 0 ? initialSrc : recoverySrc} |
| 392 | partition={config.partition} |
| 393 | webpreferences={config.webPreferences} |
| 394 | {...(config.preloadUrl ? { preload: config.preloadUrl } : {})} |
| 395 | data-preview-tab={runtimeTabId} |
| 396 | data-preview-server-tab={tabId} |
| 397 | data-preview-viewport-mode={effectiveViewport._tag} |
| 398 | data-preview-viewport-key={browserViewportSettingKey(effectiveViewport)} |
| 399 | data-preview-css-width={ |
| 400 | fittedSourceViewport |
| 401 | ? fittedSourceViewport.width |
| 402 | : effectiveViewport._tag === "fill" |
| 403 | ? Math.max(1, Math.round(layout.viewportWidth / layoutZoomFactor)) |
| 404 | : effectiveViewport.width |
| 405 | } |
| 406 | data-preview-css-height={ |
| 407 | fittedSourceViewport |
| 408 | ? fittedSourceViewport.height |
| 409 | : effectiveViewport._tag === "fill" |
| 410 | ? Math.max(1, Math.round(layout.viewportHeight / layoutZoomFactor)) |
| 411 | : effectiveViewport.height |
| 412 | } |
| 413 | aria-hidden={active ? undefined : true} |
| 414 | className={cn( |
| 415 | "absolute top-0 left-0 flex overflow-hidden bg-white", |
| 416 | active && !layout.fillsPanel && "ring-1 ring-border/70 shadow-sm", |
| 417 | )} |
| 418 | style={{ |
| 419 | width: layout.viewportWidth / layout.viewportScale, |
| 420 | height: layout.viewportHeight / layout.viewportScale, |
| 421 | transform: viewportTransform, |
| 422 | transformOrigin: "top left", |
| 423 | }} |
| 424 | /> |
| 425 | </div> |
| 426 | {active && effectiveViewport._tag !== "fill" && !fittedSourceViewport ? ( |
| 427 | <> |
| 428 | <BrowserViewportResizeHandles |
| 429 | layout={layout} |
| 430 | activeDirection={activeDrag?.direction ?? null} |
| 431 | onPointerDown={handleResizePointerDown} |
| 432 | onKeyDown={handleResizeKeyDown} |
| 433 | /> |
| 434 | {activeDrag ? ( |
| 435 | <div |
| 436 | className="pointer-events-none absolute z-40 -translate-x-1/2 rounded-md border border-border/80 bg-background/95 px-2 py-1 text-2xs font-medium tabular-nums text-foreground shadow-md backdrop-blur-sm" |
| 437 | style={{ |
| 438 | left: layout.viewportX + layout.viewportWidth / 2, |
| 439 | top: layout.viewportY + 10, |
| 440 | }} |
| 441 | aria-hidden="true" |
| 442 | > |
| 443 | {activeDrag.width} × {activeDrag.height} |
| 444 | </div> |
| 445 | ) : null} |
| 446 | </> |
| 447 | ) : null} |
| 448 | </div> |
| 449 | </div> |
| 450 | ); |
| 451 | } |