The best way to control Claude Code, Codex and more from any computer or phone
Mirrored from https://github.com/Camo67/t3code.git
Synced Nov 21, 04:45 UTC
| 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 | } |