The best way to control Claude Code, Codex and more from any computer or phone

main
tsx 265 lines 9.43 KB
Raw
1 import { useGT } from "gt-react";
2 import { useImperativeHandle, useRef, useState, useSyncExternalStore, type Ref } from "react";
3 import { flushSync } from "react-dom";
4
5 import {
6 onWindowControlsOverlayGeometryChange,
7 windowControlsOverlayHeight,
8 } from "../../lib/windowControlsOverlay";
9
10 import { AttachmentImage } from "../media/AttachmentImage";
11
12 const MAX_ZOOM = 8;
13
14 // Subtract the caption strip, matching dialog CSS's --native-titlebar-height.
15 function readViewerSize() {
16 return { width: window.innerWidth, height: window.innerHeight - windowControlsOverlayHeight() };
17 }
18
19 let viewerSize: ReturnType<typeof readViewerSize> | null = null;
20
21 // Cached so an unchanged size keeps its identity: a new one resets the zoom.
22 function getViewerSize() {
23 const next = readViewerSize();
24 if (next.width !== viewerSize?.width || next.height !== viewerSize.height) viewerSize = next;
25 return viewerSize;
26 }
27
28 function subscribeViewerSize(onChange: () => void) {
29 window.addEventListener("resize", onChange);
30 // Fullscreen caption-strip changes may not emit resize.
31 const stopOverlayListener = onWindowControlsOverlayGeometryChange(onChange);
32 return () => {
33 window.removeEventListener("resize", onChange);
34 stopOverlayListener();
35 };
36 }
37
38 export interface ZoomableImageHandle {
39 pan: (key: string) => boolean;
40 }
41
42 export function ZoomableImage({
43 src,
44 name,
45 mimeType,
46 onError,
47 ref,
48 }: {
49 src: string;
50 name: string;
51 mimeType?: string | undefined;
52 onError: () => void;
53 ref?: Ref<ZoomableImageHandle>;
54 }) {
55 const gt = useGT();
56 const viewportRef = useRef<HTMLDivElement>(null);
57 const [naturalSize, setNaturalSize] = useState({ width: 0, height: 0 });
58 const viewerSize = useSyncExternalStore(subscribeViewerSize, getViewerSize);
59 const [zoom, setZoom] = useState(1);
60 // A resized viewer refits the image.
61 const [zoomViewerSize, setZoomViewerSize] = useState(viewerSize);
62 if (zoomViewerSize !== viewerSize) {
63 setZoomViewerSize(viewerSize);
64 setZoom(1);
65 }
66 const dragRef = useRef<{
67 pointerId: number;
68 x: number;
69 y: number;
70 left: number;
71 top: number;
72 } | null>(null);
73 const suppressClickRef = useRef(false);
74 const [dragging, setDragging] = useState(false);
75 const maxHeight = Math.max(1, Math.min(viewerSize.height * 0.86, viewerSize.height - 160));
76 // A vector scales without loss, and an SVG without width and height reports a tiny default size.
77 const fit = Math.min(
78 mimeType === "image/svg+xml" ? Infinity : 1,
79 (viewerSize.width * 0.92 - (viewerSize.width >= 640 ? 96 : 0)) / (naturalSize.width || 1),
80 maxHeight / (naturalSize.height || 1),
81 );
82 const width = naturalSize.width * fit * zoom;
83 const height = naturalSize.height * fit * zoom;
84
85 useImperativeHandle(
86 ref,
87 () => ({
88 pan(key) {
89 const viewport = viewportRef.current;
90 if (!viewport || zoom <= 1) return false;
91 // A vertical scrollbar alone must not swallow gallery navigation.
92 if (
93 (key === "ArrowLeft" || key === "ArrowRight") &&
94 viewport.scrollWidth <= viewport.offsetWidth
95 )
96 return false;
97 switch (key) {
98 case "ArrowLeft":
99 viewport.scrollLeft -= 40;
100 break;
101 case "ArrowRight":
102 viewport.scrollLeft += 40;
103 break;
104 case "ArrowUp":
105 viewport.scrollTop -= 40;
106 break;
107 case "ArrowDown":
108 viewport.scrollTop += 40;
109 break;
110 default:
111 return false;
112 }
113 return true;
114 },
115 }),
116 [zoom],
117 );
118
119 const changeZoom = (next: number, point?: { x: number; y: number }) => {
120 const viewport = viewportRef.current;
121 const clamped = Math.min(MAX_ZOOM, Math.max(1, next));
122 if (!viewport || zoom === clamped) return;
123 const bounds = viewport.getBoundingClientRect();
124 const x = point ? point.x - bounds.left : viewport.clientWidth / 2;
125 const y = point ? point.y - bounds.top : viewport.clientHeight / 2;
126 const anchorX = (viewport.scrollLeft + x) / zoom;
127 const anchorY = (viewport.scrollTop + y) / zoom;
128 const clientX = bounds.left + x;
129 const clientY = bounds.top + y;
130 // The new size must be laid out before the scroll position can keep the anchor in place.
131 flushSync(() => setZoom(clamped));
132 const resized = viewport.getBoundingClientRect();
133 viewport.scrollLeft = anchorX * clamped - (clientX - resized.left);
134 viewport.scrollTop = anchorY * clamped - (clientY - resized.top);
135 };
136
137 const attachViewport = (viewport: HTMLDivElement) => {
138 viewportRef.current = viewport;
139 // Trackpad pinch arrives as a ctrlKey wheel; plain wheels pan through native overflow scrolling.
140 // React's onWheel is passive and cannot stop the browser's own page zoom.
141 const wheel = (event: WheelEvent) => {
142 if (!event.ctrlKey || event.deltaY === 0) return;
143 event.preventDefault();
144 const delta =
145 event.deltaY *
146 (event.deltaMode === 1 ? 16 : event.deltaMode === 2 ? viewport.clientHeight : 1);
147 changeZoom(zoom * Math.exp(-delta * 0.01), {
148 x: event.clientX,
149 y: event.clientY,
150 });
151 };
152 viewport.addEventListener("wheel", wheel, { passive: false });
153 return () => {
154 viewport.removeEventListener("wheel", wheel);
155 viewportRef.current = null;
156 };
157 };
158
159 return (
160 <div className="min-w-0">
161 <div
162 ref={attachViewport}
163 role="region"
164 aria-label={gt("{name}, zoomable image", { name })}
165 aria-description={gt(
166 "Click to zoom in or return to fit. Pinch or Ctrl+scroll to zoom, scroll or drag to pan. Use Enter to toggle zoom, plus or minus to zoom, and 0 to fit.",
167 )}
168 tabIndex={0}
169 className="max-w-[var(--media-width)] overflow-auto overscroll-contain rounded-lg bg-background shadow-2xl ring-1 ring-border/70 outline-none focus-visible:outline-2 focus-visible:outline-solid focus-visible:-outline-offset-2 focus-visible:outline-ring"
170 style={{
171 width: width || undefined,
172 height: height || undefined,
173 maxHeight,
174 cursor: zoom > 1 ? (dragging ? "grabbing" : "grab") : "zoom-in",
175 }}
176 onClick={(event) => {
177 // Pointer capture emits a click after dragging; preserve zoom.
178 if (suppressClickRef.current || event.detail > 1) return;
179 changeZoom(zoom > 1 ? 1 : 2, { x: event.clientX, y: event.clientY });
180 }}
181 onKeyDown={(event) => {
182 if (event.ctrlKey || event.metaKey || event.altKey) return;
183 if (event.key === "Enter" || event.key === " ") {
184 event.preventDefault();
185 if (!event.repeat) changeZoom(zoom > 1 ? 1 : 2);
186 } else if (event.key === "+" || event.key === "=") {
187 event.preventDefault();
188 changeZoom(zoom * 1.5);
189 } else if (event.key === "-") {
190 event.preventDefault();
191 changeZoom(zoom / 1.5);
192 } else if (event.key === "0") {
193 event.preventDefault();
194 changeZoom(1);
195 }
196 }}
197 onPointerDown={(event) => {
198 if (dragRef.current) return;
199 suppressClickRef.current = false;
200 if (event.pointerType !== "mouse" || event.button !== 0 || zoom <= 1) return;
201 const viewport = event.currentTarget;
202 const bounds = viewport.getBoundingClientRect();
203 if (
204 event.clientX - bounds.left >= viewport.clientWidth ||
205 event.clientY - bounds.top >= viewport.clientHeight
206 )
207 return;
208 dragRef.current = {
209 pointerId: event.pointerId,
210 x: event.clientX,
211 y: event.clientY,
212 left: viewport.scrollLeft,
213 top: viewport.scrollTop,
214 };
215 viewport.setPointerCapture(event.pointerId);
216 setDragging(true);
217 }}
218 onPointerMove={(event) => {
219 const drag = dragRef.current;
220 if (!drag || drag.pointerId !== event.pointerId) return;
221 if (Math.hypot(event.clientX - drag.x, event.clientY - drag.y) > 4) {
222 suppressClickRef.current = true;
223 }
224 event.currentTarget.scrollLeft = drag.left - (event.clientX - drag.x);
225 event.currentTarget.scrollTop = drag.top - (event.clientY - drag.y);
226 }}
227 onPointerUp={(event) => {
228 if (dragRef.current?.pointerId !== event.pointerId) return;
229 if (event.currentTarget.hasPointerCapture(event.pointerId)) {
230 event.currentTarget.releasePointerCapture(event.pointerId);
231 }
232 dragRef.current = null;
233 setDragging(false);
234 }}
235 onLostPointerCapture={(event) => {
236 if (dragRef.current?.pointerId !== event.pointerId) return;
237 dragRef.current = null;
238 setDragging(false);
239 }}
240 >
241 <AttachmentImage
242 name={name}
243 mimeType={mimeType}
244 src={src}
245 alt={name}
246 draggable={false}
247 className="block max-w-none select-none"
248 style={
249 naturalSize.width ? { width, height } : { maxWidth: "var(--media-width)", maxHeight }
250 }
251 onLoad={(event) => {
252 setNaturalSize({
253 width: event.currentTarget.naturalWidth,
254 height: event.currentTarget.naturalHeight,
255 });
256 }}
257 onError={onError}
258 />
259 </div>
260 <span className="sr-only" aria-live="polite">
261 {gt("{percent}% zoom", { percent: Math.round(zoom * 100) })}
262 </span>
263 </div>
264 );
265 }