Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

fix(community): allow free image preview zoom and pan (#986)

Gener4cb31f5d00ce
diff --git a/src/web/src/components/community/messages/image-lightbox-layout.test.ts b/src/web/src/components/community/messages/image-lightbox-layout.test.ts
index e4567f45e..28d37b413 100644
--- a/src/web/src/components/community/messages/image-lightbox-layout.test.ts
+++ b/src/web/src/components/community/messages/image-lightbox-layout.test.ts
@@ -1,46 +1,7 @@
import { describe, expect, it } from "vitest"
-import {
- fallbackPreviewSize,
- fitImageToViewport,
- previewFrameStyle,
- validImageDimensions,
-} from "./image-lightbox-layout"
+import { validImageDimensions } from "./image-lightbox-layout"
describe("image lightbox layout", () => {
- it.each([
- { name: "landscape within bounds", image: { width: 800, height: 450 }, expected: { width: 800, height: 450 } },
- { name: "portrait within bounds", image: { width: 396, height: 702 }, expected: { width: 396, height: 702 } },
- { name: "small image is not enlarged", image: { width: 80, height: 40 }, expected: { width: 80, height: 40 } },
- { name: "width cap", image: { width: 2000, height: 1000 }, expected: { width: 900, height: 450 } },
- { name: "height cap", image: { width: 1000, height: 2000 }, expected: { width: 378, height: 756 } },
- ])("fits $name", ({ image, expected }) => {
- expect(fitImageToViewport(image, { width: 1000, height: 900 })).toEqual(expected)
- })
-
- it("uses a capped square fallback while legacy dimensions are unknown", () => {
- expect(fallbackPreviewSize({ width: 390, height: 844 })).toEqual({ width: 200, height: 200 })
- expect(fallbackPreviewSize({ width: 120, height: 100 })).toEqual({ width: 1, height: 1 })
- })
-
- it("uses live viewport CSS without upscaling or a JavaScript viewport snapshot", () => {
- expect(previewFrameStyle({ width: 1200, height: 630 })).toEqual({
- width: "min(1200px, 90vw, 161.904762vh, calc(max(1px, calc(100vh - 144px)) * 1.904762))",
- aspectRatio: "1200 / 630",
- })
- expect(previewFrameStyle({ width: 80, height: 40 })).toEqual({
- width: "min(80px, 90vw, 170vh, calc(max(1px, calc(100vh - 144px)) * 2))",
- aspectRatio: "80 / 40",
- })
- expect(previewFrameStyle()).toEqual({
- width: "min(200px, 90vw, 85vh, max(1px, calc(100vh - 144px)))",
- aspectRatio: "1 / 1",
- })
- })
-
- it("reserves space for the controls above a tall image in landscape orientation", () => {
- expect(fitImageToViewport({ width: 450, height: 800 }, { width: 844, height: 390 })).toEqual({ width: 138.375, height: 246 })
- })
-
it("rejects incomplete or invalid dimensions", () => {
expect(validImageDimensions(640, 480)).toEqual({ width: 640, height: 480 })
expect(validImageDimensions(undefined, 480)).toBeUndefined()
diff --git a/src/web/src/components/community/messages/image-lightbox-layout.ts b/src/web/src/components/community/messages/image-lightbox-layout.ts
index 5f38d3e4f..4f89508e0 100644
--- a/src/web/src/components/community/messages/image-lightbox-layout.ts
+++ b/src/web/src/components/community/messages/image-lightbox-layout.ts
@@ -1,21 +1,5 @@
export type ImageDimensions = { width: number; height: number }
-export type ViewportDimensions = { width: number; height: number }
-
-export type PreviewFrameStyle = {
- width: string
- aspectRatio: string
-}
-
-const DEFAULT_PREVIEW_EDGE = 200
-const PREVIEW_MAX_WIDTH_RATIO = 0.9
-const PREVIEW_MAX_HEIGHT_RATIO = 0.85
-const PREVIEW_VERTICAL_MARGIN_PX = 144
-
-function formatCssNumber(value: number): string {
- return Number(value.toFixed(6)).toString()
-}
-
export function validImageDimensions(width?: number, height?: number): ImageDimensions | undefined {
if (
width === undefined
@@ -28,46 +12,3 @@ export function validImageDimensions(width?: number, height?: number): ImageDime
return { width, height }
}
-
-export function fitImageToViewport(
- image: ImageDimensions,
- viewport: ViewportDimensions,
-): ImageDimensions {
- const maxWidth = Math.max(1, viewport.width * PREVIEW_MAX_WIDTH_RATIO)
- const maxHeight = Math.max(1, Math.min(viewport.height * PREVIEW_MAX_HEIGHT_RATIO, viewport.height - PREVIEW_VERTICAL_MARGIN_PX))
- const scale = Math.min(1, maxWidth / image.width, maxHeight / image.height)
-
- return {
- width: image.width * scale,
- height: image.height * scale,
- }
-}
-
-export function fallbackPreviewSize(viewport: ViewportDimensions): ImageDimensions {
- const edge = Math.min(
- DEFAULT_PREVIEW_EDGE,
- Math.max(1, viewport.width * PREVIEW_MAX_WIDTH_RATIO),
- Math.max(1, Math.min(viewport.height * PREVIEW_MAX_HEIGHT_RATIO, viewport.height - PREVIEW_VERTICAL_MARGIN_PX)),
- )
- return { width: edge, height: edge }
-}
-
-/**
- * CSS owns live viewport fitting so resize and orientation changes do not need
- * client-side viewport snapshots or event listeners. The height-limited width
- * is expressed in vh after applying the image aspect ratio.
- */
-export function previewFrameStyle(dimensions?: ImageDimensions): PreviewFrameStyle {
- if (!dimensions) {
- return {
- width: `min(${DEFAULT_PREVIEW_EDGE}px, ${PREVIEW_MAX_WIDTH_RATIO * 100}vw, ${PREVIEW_MAX_HEIGHT_RATIO * 100}vh, max(1px, calc(100vh - ${PREVIEW_VERTICAL_MARGIN_PX}px)))`,
- aspectRatio: "1 / 1",
- }
- }
-
- const heightLimitedWidth = PREVIEW_MAX_HEIGHT_RATIO * 100 * (dimensions.width / dimensions.height)
- return {
- width: `min(${formatCssNumber(dimensions.width)}px, ${PREVIEW_MAX_WIDTH_RATIO * 100}vw, ${formatCssNumber(heightLimitedWidth)}vh, calc(max(1px, calc(100vh - ${PREVIEW_VERTICAL_MARGIN_PX}px)) * ${formatCssNumber(dimensions.width / dimensions.height)}))`,
- aspectRatio: `${formatCssNumber(dimensions.width)} / ${formatCssNumber(dimensions.height)}`,
- }
-}
diff --git a/src/web/src/components/community/messages/image-lightbox-zoom.ts b/src/web/src/components/community/messages/image-lightbox-zoom.ts
index bb459a7be..758b1bfbb 100644
--- a/src/web/src/components/community/messages/image-lightbox-zoom.ts
+++ b/src/web/src/components/community/messages/image-lightbox-zoom.ts
@@ -5,29 +5,16 @@ import { useCallback, useEffect, useRef, type KeyboardEvent, type MouseEvent, ty
export type ImageView = { scale: number; x: number; y: number }
type Point = { x: number; y: number }
-type Bounds = { width: number; height: number }
const FIT_VIEW: ImageView = { scale: 1, x: 0, y: 0 }
-const MAX_ZOOM = 8
-function constrain(view: ImageView, bounds: Bounds): ImageView {
- const scale = Math.max(1, Math.min(MAX_ZOOM, view.scale))
- const maxX = bounds.width * (scale - 1) / 2
- const maxY = bounds.height * (scale - 1) / 2
+function zoomAt(view: ImageView, scale: number, point: Point): ImageView {
+ if (!Number.isFinite(scale) || scale <= 0) return view
+ const ratio = scale / view.scale
return {
scale,
- x: Math.max(-maxX, Math.min(maxX, view.x)),
- y: Math.max(-maxY, Math.min(maxY, view.y)),
- }
-}
-
-function zoomAt(view: ImageView, scale: number, point: Point, bounds: Bounds): ImageView {
- const nextScale = Math.max(1, Math.min(MAX_ZOOM, scale))
- const ratio = nextScale / view.scale
- return constrain({
- scale: nextScale,
x: point.x - (point.x - view.x) * ratio,
y: point.y - (point.y - view.y) * ratio,
- }, bounds)
+ }
}
function midpoint(points: Point[]): Point {
@@ -48,10 +35,9 @@ export function useImageLightboxZoom(enabled: boolean) {
const currentView = useRef(FIT_VIEW)
const apply = useCallback((next: ImageView) => {
- const bounds = frameRef.current?.getBoundingClientRect()
- const constrained = bounds ? constrain(next, bounds) : FIT_VIEW
- currentView.current = constrained
- setView(constrained)
+ if (!Number.isFinite(next.scale) || next.scale <= 0 || !Number.isFinite(next.x) || !Number.isFinite(next.y)) return
+ currentView.current = next
+ setView(next)
}, [setView])
const reset = useCallback(() => {
@@ -66,7 +52,7 @@ export function useImageLightboxZoom(enabled: boolean) {
x: point.x - bounds.left - bounds.width / 2,
y: point.y - bounds.top - bounds.height / 2,
} : { x: 0, y: 0 }
- apply(zoomAt(currentView.current, scale, anchor, bounds))
+ apply(zoomAt(currentView.current, scale, anchor))
}, [apply])
useEffect(() => {
@@ -88,7 +74,6 @@ export function useImageLightboxZoom(enabled: boolean) {
frame.addEventListener("wheel", wheel, { passive: false })
const observer = typeof ResizeObserver === "function" ? new ResizeObserver(() => {
pointers.current.clear()
- apply(currentView.current)
}) : undefined
observer?.observe(frame)
return () => {
@@ -96,7 +81,7 @@ export function useImageLightboxZoom(enabled: boolean) {
observer?.disconnect()
activePointers.clear()
}
- }, [apply, enabled, reset, zoomTo])
+ }, [enabled, reset, zoomTo])
const onPointerDown = (event: PointerEvent<HTMLDivElement>) => {
if (!enabled || event.button !== 0 || pointers.current.size >= 2) return
@@ -117,7 +102,7 @@ export function useImageLightboxZoom(enabled: boolean) {
y: oldMidpoint.y - bounds.top - bounds.height / 2,
}
const ratio = before.length === 2 ? distance(after) / Math.max(1, distance(before)) : 1
- const next = zoomAt(currentView.current, currentView.current.scale * ratio, anchor, bounds)
+ const next = zoomAt(currentView.current, currentView.current.scale * ratio, anchor)
apply({ ...next, x: next.x + newMidpoint.x - oldMidpoint.x, y: next.y + newMidpoint.y - oldMidpoint.y })
}
@@ -158,7 +143,9 @@ export function useImageLightboxZoom(enabled: boolean) {
onLostPointerCapture: onPointerEnd,
onKeyDown,
onDoubleClick: (event: MouseEvent<HTMLDivElement>) => {
- if (enabled) zoomTo(currentView.current.scale > 1 ? 1 : 2, { x: event.clientX, y: event.clientY })
+ if (!enabled) return
+ if (currentView.current.scale !== 1) reset()
+ else zoomTo(2, { x: event.clientX, y: event.clientY })
},
},
}
diff --git a/src/web/src/components/community/messages/image-lightbox.dom.test.ts b/src/web/src/components/community/messages/image-lightbox.dom.test.ts
index 7ed5db6a0..323945b88 100644
--- a/src/web/src/components/community/messages/image-lightbox.dom.test.ts
+++ b/src/web/src/components/community/messages/image-lightbox.dom.test.ts
@@ -22,7 +22,6 @@ vi.mock("@/components/ui/dialog", () => ({
}))
import { ImageLightbox } from "./image-lightbox"
-import { previewFrameStyle } from "./image-lightbox-layout"
function renderLightbox(image: React.ComponentProps<typeof ImageLightbox>["image"], onClose = vi.fn()) {
return { renderer: render(React.createElement(ImageLightbox, { image, onClose })), onClose }
@@ -93,7 +92,7 @@ describe("ImageLightbox", () => {
expect(image(renderer, tid.imageLightboxOriginal)).not.toHaveClass("transition-opacity")
expect(image(renderer, tid.imageLightboxThumbnail)).toHaveClass("opacity-0")
expect(renderer.queryByTestId(tid.imageLightboxLoading)).not.toBeInTheDocument()
- expect(renderer.getByTestId(tid.imageLightbox).style.aspectRatio).toBe("1000 / 500")
+ expect(image(renderer, tid.imageLightboxOriginal)).toHaveStyle({ maxWidth: "1000px", maxHeight: "500px" })
expect(renderer.getByRole("button", { name: "Zoom in" })).toBeEnabled()
renderer.unmount()
}
@@ -134,7 +133,7 @@ describe("ImageLightbox", () => {
expect(image(renderer, tid.imageLightboxOriginal)).toBe(retried)
})
- it("reserves the known frame and reveals the original only after decode", async () => {
+ it("keeps one image region and the same fit for both layers through decode", async () => {
let resolveDecode!: () => void
const decodePromise = new Promise<void>((resolve) => { resolveDecode = resolve })
const { renderer } = renderLightbox({
@@ -148,11 +147,10 @@ describe("ImageLightbox", () => {
const thumbnail = image(renderer, tid.imageLightboxThumbnail)
const original = image(renderer, tid.imageLightboxOriginal)
- expect(previewFrameStyle({ width: 800, height: 450 })).toEqual({
- width: "min(800px, 90vw, 151.111111vh, calc(max(1px, calc(100vh - 144px)) * 1.777778))",
- aspectRatio: "800 / 450",
- })
- expect(frame.style.aspectRatio).toBe("800 / 450")
+ expect(frame.style.width).toBe("")
+ expect(frame.style.aspectRatio).toBe("")
+ expect(thumbnail).toHaveStyle({ maxWidth: "800px", maxHeight: "450px" })
+ expect(original).toHaveStyle({ maxWidth: "800px", maxHeight: "450px" })
expect(frame).toHaveAttribute("data-native-context-menu", "true")
expect(thumbnail).toHaveClass("absolute", "inset-0", "size-full")
expect(thumbnail).toHaveClass("pointer-events-none")
@@ -167,7 +165,7 @@ describe("ImageLightbox", () => {
expect(renderer.getByTestId(tid.imageLightboxLoading))
.toHaveTextContent("Loading original image")
- await loadThumbnail(renderer, 800, 450)
+ await loadThumbnail(renderer, 200, 112)
expect(renderer.getByTestId(tid.imageLightbox).parentElement).not.toHaveClass("invisible")
expect(image(renderer, tid.imageLightboxThumbnail)).toHaveClass("pointer-events-auto")
@@ -187,10 +185,11 @@ describe("ImageLightbox", () => {
"pointer-events-none",
"opacity-0",
)
- expect(previewFrameStyle({ width: 800, height: 450 })).toEqual({
- width: "min(800px, 90vw, 151.111111vh, calc(max(1px, calc(100vh - 144px)) * 1.777778))",
- aspectRatio: "800 / 450",
- })
+ expect(renderer.getByTestId(tid.imageLightbox)).toBe(frame)
+ expect(frame.style.width).toBe("")
+ expect(frame.style.aspectRatio).toBe("")
+ expect(thumbnail).toHaveStyle({ maxWidth: "800px", maxHeight: "450px" })
+ expect(original).toHaveStyle({ maxWidth: "800px", maxHeight: "450px" })
})
it("keeps the thumbnail and retries only the failed original", async () => {
@@ -220,7 +219,7 @@ describe("ImageLightbox", () => {
expect(image(renderer, tid.imageLightboxOriginal)).toHaveClass("opacity-100")
})
- it("keeps the safe legacy frame until the decoded original commits once", async () => {
+ it("learns legacy image dimensions after decode without resizing or replacing the region", async () => {
let resolveDecode!: () => void
const decodePromise = new Promise<void>((resolve) => { resolveDecode = resolve })
const { renderer } = renderLightbox({
@@ -228,28 +227,27 @@ describe("ImageLightbox", () => {
thumbnailUrl: "/legacy-thumbnail",
name: "legacy",
})
- const frame = () => renderer.getByTestId(tid.imageLightbox)
+ const frame = renderer.getByTestId(tid.imageLightbox)
- expect(previewFrameStyle(undefined)).toEqual({ width: "min(200px, 90vw, 85vh, max(1px, calc(100vh - 144px)))", aspectRatio: "1 / 1" })
- expect(frame().style.aspectRatio).toBe("1 / 1")
+ expect(frame.style.aspectRatio).toBe("")
await loadThumbnail(renderer, 200, 100)
- expect(frame().style.aspectRatio).toBe("1 / 1")
+ expect(renderer.getByTestId(tid.imageLightbox)).toBe(frame)
const original = image(renderer, tid.imageLightboxOriginal)
prepareImage(original, 1000, 500, () => decodePromise)
fireEvent.load(original)
- expect(frame().style.aspectRatio).toBe("1 / 1")
+ expect(original.style.maxWidth).toBe("")
expect(image(renderer, tid.imageLightboxOriginal)).toHaveClass("opacity-0")
await act(async () => {
resolveDecode()
await decodePromise
})
- expect(previewFrameStyle({ width: 1000, height: 500 })).toEqual({
- width: "min(1000px, 90vw, 170vh, calc(max(1px, calc(100vh - 144px)) * 2))",
- aspectRatio: "1000 / 500",
- })
- expect(frame().style.aspectRatio).toBe("1000 / 500")
+ expect(renderer.getByTestId(tid.imageLightbox)).toBe(frame)
+ expect(frame.style.width).toBe("")
+ expect(frame.style.aspectRatio).toBe("")
+ expect(original).toHaveStyle({ maxWidth: "1000px", maxHeight: "500px" })
+ expect(image(renderer, tid.imageLightboxThumbnail)).toHaveStyle({ maxWidth: "1000px", maxHeight: "500px" })
expect(image(renderer, tid.imageLightboxOriginal)).toHaveClass("opacity-100")
})
@@ -307,11 +305,7 @@ describe("ImageLightbox", () => {
const { renderer } = renderLightbox({ originalUrl: "/original", name: "legacy" })
expect(renderer.getByTestId(tid.imageLightboxLoading))
.toHaveTextContent("Loading original image")
- expect(previewFrameStyle(undefined)).toEqual({
- width: "min(200px, 90vw, 85vh, max(1px, calc(100vh - 144px)))",
- aspectRatio: "1 / 1",
- })
- expect(renderer.getByTestId(tid.imageLightbox).style.aspectRatio).toBe("1 / 1")
+ expect(renderer.getByTestId(tid.imageLightbox).style.aspectRatio).toBe("")
})
it("keeps a slow original pending and displays its success beyond five seconds", async () => {
@@ -376,7 +370,7 @@ describe("ImageLightbox", () => {
it.each([
{ name: "extreme landscape", width: 4000, height: 100 },
{ name: "extreme portrait", width: 100, height: 4000 },
- ])("keeps the error controls outside the clipped image frame for $name", ({ width, height }) => {
+ ])("keeps controls above the transparent, overflowing image layer for $name", ({ width, height }) => {
const { renderer } = renderLightbox({ originalUrl: "/original", name: "extreme", width, height })
fireEvent.error(image(renderer, tid.imageLightboxOriginal))
const frame = renderer.getByTestId(tid.imageLightbox)
@@ -385,6 +379,12 @@ describe("ImageLightbox", () => {
expect(frame.querySelectorAll(`[data-testid="${tid.imageLightboxError}"]`)).toHaveLength(0)
expect(error.parentElement).toBe(frame.parentElement)
+ const toolbar = renderer.getByRole("toolbar", { name: "Image controls" })
+ expect(toolbar.parentElement).toBe(frame.parentElement)
+ expect(toolbar.nextElementSibling).toBe(frame)
+ expect(toolbar).toHaveClass("relative", "z-20")
+ expect(frame).toHaveClass("z-0", "overflow-visible")
+ expect(frame).not.toHaveClass("overflow-hidden", "bg-background")
expect(error).toHaveClass("w-max")
expect(retry).toHaveClass("h-12", "min-w-12")
})
@@ -397,11 +397,11 @@ describe("ImageLightbox", () => {
expect(onClose).toHaveBeenCalledOnce()
})
- async function readyPreview() {
- const result = renderLightbox({ originalUrl: "/zoom-original", thumbnailUrl: "/zoom-thumbnail", name: "detail", width: 800, height: 600 })
+ async function readyPreview(width = 800, height = 600, legacy = false) {
+ const result = renderLightbox({ originalUrl: "/zoom-original", thumbnailUrl: "/zoom-thumbnail", name: "detail", ...(legacy ? {} : { width, height }) })
const frame = result.renderer.getByTestId(tid.imageLightbox)
mockElementGeometry(frame, { left: 100, top: 100, width: 400, height: 300, clientWidth: 400, clientHeight: 300 })
- await loadImage(image(result.renderer, tid.imageLightboxOriginal), 800, 600, () => Promise.resolve())
+ await loadImage(image(result.renderer, tid.imageLightboxOriginal), width, height, () => Promise.resolve())
return { ...result, frame, original: image(result.renderer, tid.imageLightboxOriginal) }
}
@@ -425,7 +425,7 @@ describe("ImageLightbox", () => {
expect(frame.style.touchAction).toBe("none")
})
- it("clamps mouse dragging to the enlarged image and ignores a right-button drag", async () => {
+ it("allows dragging beyond the image region and ignores a right-button drag", async () => {
const { frame, original, renderer } = await readyPreview()
const captures = new Set<number>()
const release = vi.fn((id: number) => captures.delete(id))
@@ -437,18 +437,33 @@ describe("ImageLightbox", () => {
fireEvent.doubleClick(frame, { clientX: 300, clientY: 250 })
pointer(frame, "pointerdown", 1, 300, 250)
pointer(frame, "pointermove", 1, 2000, 1800)
- expect(original.style.transform).toBe("translate(200px, 150px) scale(2)")
+ expect(original.style.transform).toBe("translate(1700px, 1550px) scale(2)")
pointer(frame, "pointerup", 1, 2000, 1800)
expect(release).toHaveBeenCalledWith(1)
expect(captures.size).toBe(0)
pointer(frame, "pointermove", 1, 100, 100)
- expect(original.style.transform).toBe("translate(200px, 150px) scale(2)")
+ expect(original.style.transform).toBe("translate(1700px, 1550px) scale(2)")
fireEvent.click(renderer.getByRole("button", { name: "Fit image" }))
pointer(frame, "pointerdown", 2, 300, 250, 2)
pointer(frame, "pointermove", 2, 500, 400, 2)
expect(original.style.transform).toBe("translate(0px, 0px) scale(1)")
})
+ it.each([
+ { name: "portrait", width: 100, height: 400 },
+ { name: "landscape", width: 400, height: 100 },
+ { name: "small image", width: 80, height: 40 },
+ { name: "legacy portrait", width: 100, height: 400, legacy: true },
+ ])("freely pans a $name without fitted-bitmap bounds", async ({ width, height, legacy }) => {
+ const { frame, original } = await readyPreview(width, height, legacy)
+ fireEvent.doubleClick(frame, { clientX: 300, clientY: 250 })
+ pointer(frame, "pointerdown", 1, 300, 250)
+ pointer(frame, "pointermove", 1, 2000, 1800)
+ expect(original.style.transform).toBe("translate(1700px, 1550px) scale(2)")
+ pointer(frame, "pointermove", 1, -2000, -1800)
+ expect(original.style.transform).toBe("translate(-2300px, -2050px) scale(2)")
+ })
+
it("pinches with two pointers, continues panning with one, and stops on cancellation", async () => {
const { frame, original } = await readyPreview()
pointer(frame, "pointerdown", 1, 250, 250)
@@ -465,23 +480,47 @@ describe("ImageLightbox", () => {
expect(original.style.transform).toBe("translate(50px, 30px) scale(2)")
})
- it("bounds wheel and trackpad zoom and keeps fit and close accessible", async () => {
+ it("shrinks below fit and zooms beyond eight while keeping fit and close accessible", async () => {
const { frame, renderer, onClose } = await readyPreview()
- fireEvent.wheel(frame, { cancelable: true, deltaY: -100000, ctrlKey: true })
- expect(frame.dataset.zoomScale).toBe("8")
- expect(renderer.getByRole("button", { name: "Zoom in" })).toBeDisabled()
+ fireEvent.wheel(frame, { cancelable: true, clientX: 300, clientY: 250, deltaY: -Math.log(16) / 0.005, ctrlKey: true })
+ expect(Number(frame.dataset.zoomScale)).toBeCloseTo(16)
+ expect(renderer.getByRole("button", { name: "Zoom in" })).toBeEnabled()
+ fireEvent.wheel(frame, { cancelable: true, clientX: 300, clientY: 250, deltaY: Math.log(64) / 0.005, ctrlKey: true })
+ expect(Number(frame.dataset.zoomScale)).toBeCloseTo(0.25)
expect(renderer.getByRole("button", { name: "Zoom out" })).toBeEnabled()
fireEvent.click(renderer.getByRole("button", { name: "Fit image" }))
expect(frame.dataset.zoomScale).toBe("1")
- expect(renderer.getByRole("button", { name: "Zoom out" })).toBeDisabled()
- fireEvent.click(renderer.getByRole("button", { name: "Zoom in" }))
- expect(frame.dataset.zoomScale).toBe("1.5")
+ expect(renderer.getByRole("button", { name: "Zoom out" })).toBeEnabled()
fireEvent.click(renderer.getByRole("button", { name: "Zoom out" }))
+ expect(Number(frame.dataset.zoomScale)).toBeCloseTo(2 / 3)
+ fireEvent.click(renderer.getByRole("button", { name: "Zoom in" }))
expect(frame.dataset.zoomScale).toBe("1")
+ for (let step = 0; step < 6; step++) fireEvent.click(renderer.getByRole("button", { name: "Zoom in" }))
+ expect(Number(frame.dataset.zoomScale)).toBeGreaterThan(8)
fireEvent.click(renderer.getByRole("button", { name: "Close image preview" }))
expect(onClose).toHaveBeenCalledOnce()
})
+ it("recovers a freely translated fit and ignores nonrepresentable zoom transforms", async () => {
+ const { frame, original, renderer } = await readyPreview()
+ pointer(frame, "pointerdown", 1, 300, 250)
+ pointer(frame, "pointermove", 1, 800, 750)
+ pointer(frame, "pointerup", 1, 800, 750)
+ expect(original.style.transform).toBe("translate(500px, 500px) scale(1)")
+ expect(renderer.getByRole("button", { name: "Fit image" })).toBeEnabled()
+ fireEvent.click(renderer.getByRole("button", { name: "Fit image" }))
+ expect(original.style.transform).toBe("translate(0px, 0px) scale(1)")
+ expect(renderer.getByRole("button", { name: "Fit image" })).toBeDisabled()
+ for (const deltaY of [-1e10, 1e10]) {
+ fireEvent.wheel(frame, { cancelable: true, deltaY, ctrlKey: true })
+ expect(original.style.transform).toBe("translate(0px, 0px) scale(1)")
+ }
+ fireEvent.keyDown(frame, { key: "-" })
+ expect(Number(frame.dataset.zoomScale)).toBeCloseTo(2 / 3)
+ fireEvent.doubleClick(frame)
+ expect(original.style.transform).toBe("translate(0px, 0px) scale(1)")
+ })
+
it("supports keyboard zoom and pan, double-click reset, and a fresh view for a new image", async () => {
const { frame, original, renderer } = await readyPreview()
fireEvent.keyDown(frame, { key: "+" })
@@ -515,7 +554,7 @@ describe("ImageLightbox", () => {
})
- it("reclamps a panned image on resize, cancels its drag, and disconnects on close", async () => {
+ it("preserves free pan on resize, cancels its drag, and disconnects on close", async () => {
let resize!: ResizeObserverCallback
const disconnect = vi.fn()
vi.stubGlobal("ResizeObserver", class {
@@ -529,9 +568,9 @@ describe("ImageLightbox", () => {
pointer(frame, "pointermove", 1, 1000, 1000)
mockElementGeometry(frame, { left: 100, top: 100, width: 200, height: 150 })
act(() => resize([], {} as ResizeObserver))
- expect(original.style.transform).toBe("translate(100px, 75px) scale(2)")
+ expect(original.style.transform).toBe("translate(700px, 750px) scale(2)")
pointer(frame, "pointermove", 1, 1200, 1200)
- expect(original.style.transform).toBe("translate(100px, 75px) scale(2)")
+ expect(original.style.transform).toBe("translate(700px, 750px) scale(2)")
renderer.unmount()
expect(disconnect).toHaveBeenCalledOnce()
const wheel = new WheelEvent("wheel", { bubbles: true, cancelable: true, deltaY: -100 })
@@ -539,4 +578,28 @@ describe("ImageLightbox", () => {
expect(wheel.defaultPrevented).toBe(false)
})
+ it("preserves portrait pan after an orientation change without reloading the image", async () => {
+ let resize!: ResizeObserverCallback
+ vi.stubGlobal("ResizeObserver", class {
+ constructor(callback: ResizeObserverCallback) { resize = callback }
+ observe = vi.fn()
+ disconnect = vi.fn()
+ })
+ const { frame, original, renderer } = await readyPreview(100, 400)
+ fireEvent.doubleClick(frame, { clientX: 300, clientY: 250 })
+ pointer(frame, "pointerdown", 1, 300, 250)
+ pointer(frame, "pointermove", 1, 1000, 1000)
+ expect(original.style.transform).toBe("translate(700px, 750px) scale(2)")
+ mockElementGeometry(frame, { left: 100, top: 100, width: 600, height: 200 })
+ act(() => resize([], {} as ResizeObserver))
+ expect(original.style.transform).toBe("translate(700px, 750px) scale(2)")
+ expect(image(renderer, tid.imageLightboxOriginal)).toBe(original)
+ expect(original).toHaveAttribute("data-remote-image-state", "ready")
+ expect(original).toHaveAttribute("src", "/zoom-original")
+ pointer(frame, "pointermove", 1, -2000, -1800)
+ expect(original.style.transform).toBe("translate(700px, 750px) scale(2)")
+ fireEvent.click(renderer.getByRole("button", { name: "Fit image" }))
+ expect(original.style.transform).toBe("translate(0px, 0px) scale(1)")
+ })
+
})
diff --git a/src/web/src/components/community/messages/image-lightbox.tsx b/src/web/src/components/community/messages/image-lightbox.tsx
index 81fd2d4a6..4720f2936 100644
--- a/src/web/src/components/community/messages/image-lightbox.tsx
+++ b/src/web/src/components/community/messages/image-lightbox.tsx
@@ -9,7 +9,6 @@ import { MinusIcon, PlusIcon, RotateCcwIcon, XIcon } from "lucide-react"
import type { ImagePreview } from "@/lib/community/models/message"
import { tid } from "@/lib/community/testids"
import {
- previewFrameStyle,
type ImageDimensions,
validImageDimensions,
} from "./image-lightbox-layout"
@@ -40,11 +39,14 @@ function PreviewFrame({ image, onClose }: { image: ImagePreview; onClose: () =>
retryOriginal,
] = useRemoteImageAttempt({ source: image.originalUrl })
- const frameStyle = previewFrameStyle(dimensions)
const thumbnailReady = !!image.thumbnailUrl && thumbnailStatus === "ready"
const originalReady = originalStatus === "ready"
const { frameRef, view, reset, zoomIn, zoomOut, handlers } = useImageLightboxZoom(originalReady)
- const imageTransform = { transform: `translate(${view.x}px, ${view.y}px) scale(${view.scale})` }
+ const imageStyle = {
+ maxWidth: dimensions?.width,
+ maxHeight: dimensions?.height,
+ transform: `translate(${view.x}px, ${view.y}px) scale(${view.scale})`,
+ }
useLayoutEffect(() => {
if (originalStatus !== "ready" || !originalImage) return
@@ -53,7 +55,17 @@ function PreviewFrame({ image, onClose }: { image: ImagePreview; onClose: () =>
}, [knownDimensions, originalImage, originalStatus, setDimensions])
return (
- <div className="relative w-fit">
+ <div className="relative flex size-full min-h-0 flex-col gap-2">
+ <div
+ role="toolbar"
+ aria-label="Image controls"
+ className="relative z-20 flex shrink-0 items-center gap-1 self-center rounded-lg border border-border bg-background p-1"
+ >
+ <Button variant="ghost" size="icon" className="size-11 sm:size-9" aria-label="Zoom out" title="Zoom out" disabled={!originalReady} onClick={zoomOut}><MinusIcon /></Button>
+ <Button variant="ghost" size="icon" className="size-11 sm:size-9" aria-label="Fit image" title="Fit image" disabled={!originalReady || (view.scale === 1 && view.x === 0 && view.y === 0)} onClick={reset}><RotateCcwIcon /></Button>
+ <Button variant="ghost" size="icon" className="size-11 sm:size-9" aria-label="Zoom in" title="Zoom in" disabled={!originalReady} onClick={zoomIn}><PlusIcon /></Button>
+ <Button variant="ghost" size="icon" className="size-11 sm:size-9" aria-label="Close image preview" title="Close" onClick={onClose}><XIcon /></Button>
+ </div>
<div
ref={frameRef}
data-testid={tid.imageLightbox}
@@ -62,8 +74,8 @@ function PreviewFrame({ image, onClose }: { image: ImagePreview; onClose: () =>
role="region"
aria-label="Image preview. Use plus and minus to zoom, arrow keys to pan, and zero to fit."
tabIndex={originalReady ? 0 : -1}
- className={`relative select-none overflow-hidden rounded-lg bg-background ${view.scale > 1 ? "cursor-grab active:cursor-grabbing" : "cursor-default"}`}
- style={{ ...frameStyle, touchAction: originalReady ? "none" : undefined }}
+ className={`relative z-0 min-h-0 w-full flex-1 select-none overflow-visible ${originalReady ? "cursor-grab active:cursor-grabbing" : "cursor-default"}`}
+ style={{ touchAction: originalReady ? "none" : undefined }}
{...handlers}
>
{image.thumbnailUrl && (
@@ -76,17 +88,17 @@ function PreviewFrame({ image, onClose }: { image: ImagePreview; onClose: () =>
src={image.thumbnailUrl}
alt={image.name}
draggable={false}
- style={imageTransform}
+ style={imageStyle}
onLoad={onThumbnailLoad}
onError={onThumbnailError}
- className={`absolute inset-0 size-full rounded-lg object-contain ${thumbnailReady && !originalReady ? "pointer-events-auto opacity-100" : "pointer-events-none opacity-0"}`}
+ className={`absolute inset-0 m-auto size-full rounded-lg object-contain ${thumbnailReady && !originalReady ? "pointer-events-auto opacity-100" : "pointer-events-none opacity-0"}`}
/>
)}
{!thumbnailReady && !originalReady && originalStatus === "pending" && (
<div
data-testid={tid.imageLightboxLoading}
role="status"
- className="absolute inset-0 flex animate-pulse items-center justify-center bg-muted/70 px-4 text-sm text-muted-foreground motion-reduce:animate-none"
+ className="absolute top-1/2 left-1/2 -translate-x-1/2 -translate-y-1/2 animate-pulse rounded-md bg-background px-3 py-2 text-sm text-muted-foreground motion-reduce:animate-none"
>
Loading original image
</div>
@@ -101,29 +113,18 @@ function PreviewFrame({ image, onClose }: { image: ImagePreview; onClose: () =>
src={image.originalUrl}
alt={image.name}
draggable={false}
- style={imageTransform}
+ style={imageStyle}
onLoad={onOriginalLoad}
onError={onOriginalError}
- className={`absolute inset-0 size-full rounded-lg object-contain ${originalReady ? "pointer-events-auto opacity-100" : "pointer-events-none opacity-0"}`}
+ className={`absolute inset-0 m-auto size-full rounded-lg object-contain ${originalReady ? "pointer-events-auto opacity-100" : "pointer-events-none opacity-0"}`}
/>
)}
</div>
- <div
- role="toolbar"
- aria-label="Image controls"
- className="absolute left-1/2 z-20 flex -translate-x-1/2 items-center gap-1 rounded-lg border border-border bg-background p-1"
- style={{ top: "calc(50% - 50vh + 12px)" }}
- >
- <Button variant="ghost" size="icon" className="size-11 sm:size-9" aria-label="Zoom out" title="Zoom out" disabled={!originalReady || view.scale <= 1} onClick={zoomOut}><MinusIcon /></Button>
- <Button variant="ghost" size="icon" className="size-11 sm:size-9" aria-label="Fit image" title="Fit image" disabled={!originalReady || view.scale === 1} onClick={reset}><RotateCcwIcon /></Button>
- <Button variant="ghost" size="icon" className="size-11 sm:size-9" aria-label="Zoom in" title="Zoom in" disabled={!originalReady || view.scale >= 8} onClick={zoomIn}><PlusIcon /></Button>
- <Button variant="ghost" size="icon" className="size-11 sm:size-9" aria-label="Close image preview" title="Close" onClick={onClose}><XIcon /></Button>
- </div>
{originalStatus === "error" && (
<div
data-testid={tid.imageLightboxError}
role="status"
- className="absolute bottom-3 left-1/2 z-10 flex min-h-11 w-max max-w-[min(90vw,24rem)] -translate-x-1/2 items-center justify-between gap-2 rounded-md border border-border bg-background px-3 py-2 text-sm shadow-sm"
+ className="absolute bottom-3 left-1/2 z-10 flex min-h-11 w-max max-w-full -translate-x-1/2 items-center justify-between gap-2 rounded-md border border-border bg-background px-3 py-2 text-sm shadow-sm"
>
<span>Failed to load original image</span>
<button
@@ -145,7 +146,7 @@ export function ImageLightbox({ image, onClose }: { image: ImagePreview; onClose
<Dialog open onOpenChange={(open) => { if (!open) onClose() }}>
<DialogContent
aria-label={image.name}
- className="flex max-h-[90vh] w-auto items-center justify-center border-none bg-transparent p-0 shadow-none sm:max-w-none"
+ className="top-[max(1rem,env(safe-area-inset-top))] right-[max(1rem,env(safe-area-inset-right))] left-[max(1rem,env(safe-area-inset-left))] flex h-[calc(100dvh_-_max(1rem,env(safe-area-inset-top))_-_max(1rem,env(safe-area-inset-bottom)))] w-auto max-w-none translate-x-0 translate-y-0 overflow-visible border-none bg-transparent p-0 shadow-none ring-0 sm:max-w-none"
showCloseButton={false}
>
<PreviewFrame
diff --git a/src/web/src/test/e2e-ui/20-community-attachment-thumbnails.spec.ts b/src/web/src/test/e2e-ui/20-community-attachment-thumbnails.spec.ts
index 51886083a..e3f6550fc 100644
--- a/src/web/src/test/e2e-ui/20-community-attachment-thumbnails.spec.ts
+++ b/src/web/src/test/e2e-ui/20-community-attachment-thumbnails.spec.ts
@@ -73,18 +73,177 @@ function expectSameRect(actual: Rect, expected: Rect) {
expect(actual.height).toBeCloseTo(expected.height, 1)
}
-function expectWithinPreviewViewport(rect: Rect, viewport: { width: number; height: number }) {
- expect(rect.width).toBeLessThanOrEqual(viewport.width * 0.9 + 0.5)
- expect(rect.height).toBeLessThanOrEqual(viewport.height * 0.85 + 0.5)
+function expectWithinRect(rect: Rect, outer: Rect) {
+ expect(rect.width).toBeGreaterThan(0)
+ expect(rect.height).toBeGreaterThan(0)
+ expect(rect.x).toBeGreaterThanOrEqual(outer.x - 0.5)
+ expect(rect.y).toBeGreaterThanOrEqual(outer.y - 0.5)
+ expect(rect.x + rect.width).toBeLessThanOrEqual(outer.x + outer.width + 0.5)
+ expect(rect.y + rect.height).toBeLessThanOrEqual(outer.y + outer.height + 0.5)
}
-async function previewRects(page: Page) {
+async function previewLayout(page: Page) {
+ await waitForDialogEntrance(page)
const container = await boundingRect(page.getByTestId(tid.imageLightbox))
- const thumbnail = await boundingRect(page.getByTestId(tid.imageLightboxThumbnail))
- const original = await boundingRect(page.getByTestId(tid.imageLightboxOriginal))
- expectSameRect(thumbnail, container)
- expectSameRect(original, container)
- return { container, thumbnail, original }
+ const controls = await boundingRect(page.getByRole("toolbar", { name: "Image controls" }))
+ const dialog = await boundingRect(page.locator("[data-slot='dialog-content']").filter({ has: page.getByTestId(tid.imageLightbox) }))
+ const { viewport, inset } = await page.evaluate(() => {
+ const probe = document.createElement("div")
+ probe.style.cssText = "position:fixed;visibility:hidden;pointer-events:none;padding:env(safe-area-inset-top) env(safe-area-inset-right) env(safe-area-inset-bottom) env(safe-area-inset-left)"
+ document.body.appendChild(probe)
+ const style = getComputedStyle(probe)
+ const gutter = Number.parseFloat(getComputedStyle(document.documentElement).fontSize)
+ const inset = {
+ top: Math.max(gutter, Number.parseFloat(style.paddingTop)),
+ right: Math.max(gutter, Number.parseFloat(style.paddingRight)),
+ bottom: Math.max(gutter, Number.parseFloat(style.paddingBottom)),
+ left: Math.max(gutter, Number.parseFloat(style.paddingLeft)),
+ }
+ probe.remove()
+ const visible = window.visualViewport
+ return {
+ viewport: { x: visible?.offsetLeft ?? 0, y: visible?.offsetTop ?? 0, width: visible?.width ?? innerWidth, height: visible?.height ?? innerHeight },
+ inset,
+ }
+ })
+ expectSameRect(dialog, {
+ x: viewport.x + inset.left,
+ y: viewport.y + inset.top,
+ width: viewport.width - inset.left - inset.right,
+ height: viewport.height - inset.top - inset.bottom,
+ })
+ for (const rect of [dialog, controls, container]) expectWithinRect(rect, viewport)
+ expect(controls.y).toBeCloseTo(dialog.y, 1)
+ expect(controls.y + controls.height).toBeLessThan(container.y)
+ expect(container.x).toBeCloseTo(dialog.x, 1)
+ expect(container.width).toBeCloseTo(dialog.width, 1)
+ expect(container.y + container.height).toBeCloseTo(dialog.y + dialog.height, 1)
+ const surfaces = await page.getByTestId(tid.imageLightbox).evaluate((element) => {
+ const result = []
+ for (let node: Element | null = element; node; node = node.parentElement) {
+ const style = getComputedStyle(node)
+ result.push({ background: style.backgroundColor, overflowX: style.overflowX, overflowY: style.overflowY })
+ if (node.getAttribute("data-slot") === "dialog-content") break
+ }
+ return result
+ })
+ for (const surface of surfaces) {
+ expect(surface.background).toBe("rgba(0, 0, 0, 0)")
+ expect(surface.overflowX).toBe("visible")
+ expect(surface.overflowY).toBe("visible")
+ }
+ return { container, controls, dialog, viewport }
+}
+
+async function previewImageGeometry(locator: Locator) {
+ const geometry = await locator.evaluate((element: HTMLImageElement) => {
+ const rect = element.getBoundingClientRect()
+ const box = { x: rect.x, y: rect.y, width: rect.width, height: rect.height }
+ const style = getComputedStyle(element)
+ const transform = new DOMMatrixReadOnly(style.transform)
+ const ratio = Math.min(rect.width / element.naturalWidth, rect.height / element.naturalHeight)
+ const width = element.naturalWidth * ratio
+ const height = element.naturalHeight * ratio
+ return {
+ box,
+ painted: element.naturalWidth > 0 && element.naturalHeight > 0 ? {
+ x: rect.x + (rect.width - width) / 2,
+ y: rect.y + (rect.height - height) / 2,
+ width,
+ height,
+ } : null,
+ naturalWidth: element.naturalWidth,
+ naturalHeight: element.naturalHeight,
+ translation: { x: transform.m41, y: transform.m42 },
+ scale: transform.a,
+ objectFit: style.objectFit,
+ objectPosition: style.objectPosition,
+ state: element.getAttribute("data-remote-image-state"),
+ }
+ })
+ expect(geometry.objectFit).toBe("contain")
+ expect(geometry.objectPosition).toBe("50% 50%")
+ if (geometry.state === "ready") expect(geometry.painted).not.toBeNull()
+ return geometry
+}
+
+function expectFittedImage(painted: Rect | null, container: Rect, dimensions: { width: number; height: number }) {
+ if (!painted) return
+ const ratio = Math.min(1, container.width / dimensions.width, container.height / dimensions.height)
+ const width = dimensions.width * ratio
+ const height = dimensions.height * ratio
+ expectSameRect(painted, {
+ x: container.x + (container.width - width) / 2,
+ y: container.y + (container.height - height) / 2,
+ width,
+ height,
+ })
+ expectWithinRect(painted, container)
+ expect(painted.width / painted.height).toBeCloseTo(dimensions.width / dimensions.height, 2)
+}
+
+async function previewRects(page: Page, dimensions: { width: number; height: number }) {
+ const layout = await previewLayout(page)
+ const thumbnail = await previewImageGeometry(page.getByTestId(tid.imageLightboxThumbnail))
+ const original = await previewImageGeometry(page.getByTestId(tid.imageLightboxOriginal))
+ expectSameRect(thumbnail.box, original.box)
+ for (const layer of [thumbnail, original]) {
+ expectWithinRect(layer.box, layout.container)
+ expectFittedImage(layer.painted, layout.container, dimensions)
+ }
+ if (original.painted) {
+ expect(original.naturalWidth).toBe(dimensions.width)
+ expect(original.naturalHeight).toBe(dimensions.height)
+ }
+ return { ...layout, thumbnail: thumbnail.box, original: original.box, thumbnailPainted: thumbnail.painted, originalPainted: original.painted }
+}
+
+async function expectZoomedImage(page: Page, dimensions: { width: number; height: number }) {
+ const layout = await previewLayout(page)
+ const scale = Number(await page.getByTestId(tid.imageLightbox).getAttribute("data-zoom-scale"))
+ const { painted, translation, scale: renderedScale } = await previewImageGeometry(page.getByTestId(tid.imageLightboxOriginal))
+ expect(painted).not.toBeNull()
+ expect(renderedScale).toBeCloseTo(scale, 4)
+ const fit = Math.min(1, layout.container.width / dimensions.width, layout.container.height / dimensions.height)
+ const width = dimensions.width * fit * scale
+ const height = dimensions.height * fit * scale
+ expectSameRect(painted!, {
+ x: layout.container.x + layout.container.width / 2 + translation.x - width / 2,
+ y: layout.container.y + layout.container.height / 2 + translation.y - height / 2,
+ width,
+ height,
+ })
+ return { ...layout, painted: painted!, scale, translation }
+}
+
+async function expectToolbarAboveImage(page: Page, painted: Rect) {
+ for (const name of ["Zoom out", "Fit image", "Zoom in", "Close image preview"]) {
+ const button = page.getByRole("button", { name, exact: true })
+ const rect = await boundingRect(button)
+ const point = { x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 }
+ expect(point.x).toBeGreaterThan(painted.x)
+ expect(point.x).toBeLessThan(painted.x + painted.width)
+ expect(point.y).toBeGreaterThan(painted.y)
+ expect(point.y).toBeLessThan(painted.y + painted.height)
+ expect(await button.evaluate((element, target) => element.contains(document.elementFromPoint(target.x, target.y)), point)).toBe(true)
+ }
+}
+
+async function previewNodes(page: Page) {
+ return Promise.all([tid.imageLightbox, tid.imageLightboxThumbnail, tid.imageLightboxOriginal].map(async (id) => {
+ const locator = page.getByTestId(id)
+ const node = await locator.elementHandle()
+ expect(node).not.toBeNull()
+ return { id, node, src: await locator.getAttribute("src") }
+ }))
+}
+
+async function expectSamePreviewNodes(page: Page, nodes: Awaited<ReturnType<typeof previewNodes>>) {
+ for (const { id, node, src } of nodes) {
+ const locator = page.getByTestId(id)
+ expect(await locator.evaluate((element, captured) => element === captured, node)).toBe(true)
+ expect(await locator.getAttribute("src")).toBe(src)
+ }
}
async function waitForDialogEntrance(page: Page) {
@@ -280,7 +439,7 @@ test("image previews keep one frame through loading, decode, failure, retry, and
await expect(page.getByTestId(tid.imageLightboxLoading)).toBeVisible()
await expect(page.getByTestId(tid.imageLightboxThumbnail)).toHaveAttribute("src", landscape.thumbnailPath)
await waitForDialogEntrance(page)
- const coldPendingRect = await previewRects(page)
+ const coldPendingRect = await previewRects(page, { width: 800, height: 450 })
expect(await page.getByTestId(tid.imageLightboxThumbnail).evaluate((element: HTMLImageElement) => ({
complete: element.complete,
naturalWidth: element.naturalWidth,
@@ -291,7 +450,7 @@ test("image previews keep one frame through loading, decode, failure, retry, and
await expect(landscapeListFrame).toHaveAttribute("data-remote-image-state", "ready")
expectSameRect(await boundingRect(landscapeListFrame), pendingListRect)
await expect(page.getByTestId(tid.imageLightbox)).toBeVisible()
- expectSameRect(await previewRects(page).then((rects) => rects.container), coldPendingRect.container)
+ expectSameRect(await previewRects(page, { width: 800, height: 450 }).then((rects) => rects.container), coldPendingRect.container)
await expect(page.getByTestId(tid.imageLightboxThumbnail)).toHaveClass(/opacity-100/)
const coldThumbnailReady = await page.getByTestId(tid.imageLightboxThumbnail).evaluate((element: HTMLImageElement) => ({
complete: element.complete,
@@ -302,17 +461,18 @@ test("image previews keep one frame through loading, decode, failure, retry, and
await attachScreenshot(testInfo, "desktop-landscape-first-visible", page)
await page.unroute(thumbnailPattern)
- const desktopLandscapeLoading = await previewRects(page)
- expectWithinPreviewViewport(desktopLandscapeLoading.container, { width: 1280, height: 900 })
+ const desktopLandscapeLoading = await previewRects(page, { width: 800, height: 450 })
+ const desktopNodes = await previewNodes(page)
+ caseResources.own(desktopNodes, async (captured) => { await Promise.all(captured.map(({ node }) => node?.dispose())) })
+ const desktopImageGets = observedGetPaths.filter((path) => path === landscape.originalPath || path === landscape.thumbnailPath)
await attachScreenshot(testInfo, "desktop-landscape-loading", page)
await page.setViewportSize({ width: 700, height: 600 })
- const desktopLandscapeResized = await previewRects(page)
- expectWithinPreviewViewport(desktopLandscapeResized.container, { width: 700, height: 600 })
+ const desktopLandscapeResized = await previewRects(page, { width: 800, height: 450 })
expect(desktopLandscapeResized.container.width).toBeLessThan(desktopLandscapeLoading.container.width)
await attachScreenshot(testInfo, "desktop-landscape-resized-loading", page)
await page.setViewportSize({ width: 1280, height: 900 })
- const desktopLandscapeRestored = await previewRects(page)
+ const desktopLandscapeRestored = await previewRects(page, { width: 800, height: 450 })
expectSameRect(desktopLandscapeRestored.container, desktopLandscapeLoading.container)
releaseLandscape()
@@ -322,8 +482,10 @@ test("image previews keep one frame through loading, decode, failure, retry, and
src: landscape.originalPath,
testId: tid.imageLightboxOriginal,
})
- const desktopLandscapeLoaded = await previewRects(page)
+ const desktopLandscapeLoaded = await previewRects(page, { width: 800, height: 450 })
expectSameRect(desktopLandscapeLoaded.container, desktopLandscapeRestored.container)
+ await expectSamePreviewNodes(page, desktopNodes)
+ expect(observedGetPaths.filter((path) => path === landscape.originalPath || path === landscape.thumbnailPath)).toEqual(desktopImageGets)
await attachScreenshot(testInfo, "desktop-landscape-loaded", page)
const desktopZoomFrame = page.getByTestId(tid.imageLightbox)
await desktopZoomFrame.hover()
@@ -342,13 +504,52 @@ test("image previews keep one frame through loading, decode, failure, retry, and
await page.mouse.move(desktopCenter.x + 70, desktopCenter.y + 40, { steps: 5 })
await page.mouse.up()
await expect.poll(() => landscapeOriginal.evaluate((element) => element.style.transform)).not.toBe(beforeDrag)
+ await expectZoomedImage(page, { width: 800, height: 450 })
await attachScreenshot(testInfo, "desktop-original-zoomed", page)
await page.getByRole("button", { name: "Fit image", exact: true }).click()
await expect(desktopZoomFrame).toHaveAttribute("data-zoom-scale", "1")
+ await page.getByRole("button", { name: "Zoom out", exact: true }).click()
+ const shrunken = await expectZoomedImage(page, { width: 800, height: 450 })
+ expect(shrunken.scale).toBeCloseTo(2 / 3, 4)
+ await page.mouse.move(desktopCenter.x, desktopCenter.y)
+ await page.mouse.down()
+ const outsidePoint = { x: desktopLandscapeLoaded.container.x / 2, y: desktopCenter.y }
+ await page.mouse.move(outsidePoint.x, outsidePoint.y, { steps: 5 })
+ await page.mouse.up()
+ const freelyPanned = await expectZoomedImage(page, { width: 800, height: 450 })
+ expect(freelyPanned.translation.x).toBeCloseTo(outsidePoint.x - desktopCenter.x, 1)
+ expect(outsidePoint.x).toBeLessThan(freelyPanned.container.x)
+ expect(outsidePoint.x).toBeGreaterThan(freelyPanned.painted.x)
+ expect(outsidePoint.x).toBeLessThan(freelyPanned.painted.x + freelyPanned.painted.width)
+ expect(await landscapeOriginal.evaluate((element, point) => document.elementFromPoint(point.x, point.y) === element, outsidePoint)).toBe(true)
+ await attachScreenshot(testInfo, "desktop-whole-image-outside-region", page)
+ await page.getByRole("button", { name: "Fit image", exact: true }).click()
+ for (let step = 0; step < 6; step++) await page.getByRole("button", { name: "Zoom in", exact: true }).click()
+ const beyondEight = await expectZoomedImage(page, { width: 800, height: 450 })
+ expect(beyondEight.scale).toBeGreaterThan(8)
+ await expectToolbarAboveImage(page, beyondEight.painted)
+ await attachScreenshot(testInfo, "desktop-toolbar-above-enlarged-image", page)
+ await page.getByRole("button", { name: "Zoom out", exact: true }).click()
+ expect(Number(await desktopZoomFrame.getAttribute("data-zoom-scale"))).toBeCloseTo(beyondEight.scale / 1.5, 4)
+ await page.getByRole("button", { name: "Fit image", exact: true }).click()
+ await previewRects(page, { width: 800, height: 450 })
await desktopZoomFrame.dblclick()
await expect(desktopZoomFrame).toHaveAttribute("data-zoom-scale", "2")
await desktopZoomFrame.dblclick()
await expect(desktopZoomFrame).toHaveAttribute("data-zoom-scale", "1")
+ await desktopZoomFrame.focus()
+ await desktopZoomFrame.press("Equal")
+ await expect(desktopZoomFrame).toHaveAttribute("data-zoom-scale", "1.5")
+ await desktopZoomFrame.press("Equal")
+ await expect(desktopZoomFrame).toHaveAttribute("data-zoom-scale", "2.25")
+ const beforeKeyboardPan = await landscapeOriginal.evaluate((element) => element.style.transform)
+ await desktopZoomFrame.press("ArrowRight")
+ await expect.poll(() => landscapeOriginal.evaluate((element) => element.style.transform)).not.toBe(beforeKeyboardPan)
+ await expectZoomedImage(page, { width: 800, height: 450 })
+ await desktopZoomFrame.press("0")
+ await expect(desktopZoomFrame).toHaveAttribute("data-zoom-scale", "1")
+ for (let step = 0; step < 6; step++) await desktopZoomFrame.press("Equal")
+ await expectToolbarAboveImage(page, (await expectZoomedImage(page, { width: 800, height: 450 })).painted)
await page.getByRole("button", { name: "Close image preview", exact: true }).click()
await expect(desktopZoomFrame).toHaveCount(0)
await landscapeButton.click()
@@ -356,6 +557,11 @@ test("image previews keep one frame through loading, decode, failure, retry, and
await expect(landscapeOriginal).toHaveClass(/opacity-100/)
await page.keyboard.press("Escape")
await expect(page.getByTestId(tid.imageLightbox)).toHaveCount(0)
+ await landscapeButton.click()
+ await expect(landscapeOriginal).toHaveClass(/opacity-100/)
+ await waitForDialogEntrance(page)
+ await page.mouse.click(1, 1)
+ await expect(desktopZoomFrame).toHaveCount(0)
await page.unroute(`**${landscape.originalPath}`)
const portrait = await uploadImage({
@@ -395,7 +601,7 @@ test("image previews keep one frame through loading, decode, failure, retry, and
await expect.poll(() => portraitOriginalRequests.length).toBe(1)
await expect(page.getByTestId(tid.imageLightboxOriginal)).toHaveClass(/opacity-0/)
await waitForDialogEntrance(page)
- const desktopPortraitLoading = await previewRects(page)
+ const desktopPortraitLoading = await previewRects(page, { width: 450, height: 800 })
await attachScreenshot(testInfo, "desktop-portrait-loading", page)
releasePortraitFailure()
await expect(page.getByTestId(tid.imageLightboxError)).toContainText("Failed to load original image")
@@ -411,14 +617,16 @@ test("image previews keep one frame through loading, decode, failure, retry, and
container: await boundingRect(page.getByTestId(tid.imageLightbox)),
thumbnail: await boundingRect(page.getByTestId(tid.imageLightboxThumbnail)),
}
- expectSameRect(desktopPortraitFailed.thumbnail, desktopPortraitFailed.container)
+ expectSameRect(desktopPortraitFailed.thumbnail, desktopPortraitLoading.thumbnail)
+ const failedThumbnailGeometry = await previewImageGeometry(portraitThumbnail)
+ expectFittedImage(failedThumbnailGeometry.painted, desktopPortraitFailed.container, { width: 450, height: 800 })
expectSameRect(desktopPortraitFailed.container, desktopPortraitLoading.container)
await attachScreenshot(testInfo, "desktop-portrait-failed", page)
await page.getByTestId(tid.imageLightboxRetry).click()
await expect.poll(() => portraitOriginalRequests.length).toBe(2)
await expect(page.getByTestId(tid.imageLightboxOriginal)).toHaveClass(/opacity-100/)
- const desktopPortraitRetried = await previewRects(page)
+ const desktopPortraitRetried = await previewRects(page, { width: 450, height: 800 })
expectSameRect(desktopPortraitRetried.container, desktopPortraitFailed.container)
await attachScreenshot(testInfo, "desktop-portrait-retried", page)
expect(messagePostCount).toBe(2)
@@ -444,6 +652,13 @@ test("image previews keep one frame through loading, decode, failure, retry, and
expect(messagePostCount).toBe(4)
const { page: mobilePage } = await asUser("alice", { hasTouch: true })
+ const mobilePortraitGetPaths: string[] = []
+ mobilePage.on("request", (request) => {
+ const pathname = new URL(request.url()).pathname
+ if (request.method() === "GET" && (pathname === portrait.originalPath || pathname === portrait.thumbnailPath)) {
+ mobilePortraitGetPaths.push(pathname)
+ }
+ })
await mobilePage.setViewportSize({ width: 390, height: 844 })
await mobilePage.goto(channelUrl)
await mobilePage.waitForURL(new RegExp(`/c/channels/[^/]+/${channelId}$`), { waitUntil: "commit" })
@@ -470,12 +685,11 @@ test("image previews keep one frame through loading, decode, failure, retry, and
await expect.poll(() => mobileLandscapeRequests).toBe(1)
await expect(mobilePage.getByTestId(tid.imageLightboxOriginal)).toHaveClass(/opacity-0/)
await waitForDialogEntrance(mobilePage)
- const mobileLandscapeLoading = await previewRects(mobilePage)
- expectWithinPreviewViewport(mobileLandscapeLoading.container, { width: 390, height: 844 })
+ const mobileLandscapeLoading = await previewRects(mobilePage, { width: 800, height: 450 })
await attachScreenshot(testInfo, "mobile-landscape-loading", mobilePage)
releaseMobileLandscape()
await expect(mobilePage.getByTestId(tid.imageLightboxOriginal)).toHaveClass(/opacity-100/)
- const mobileLandscapeLoaded = await previewRects(mobilePage)
+ const mobileLandscapeLoaded = await previewRects(mobilePage, { width: 800, height: 450 })
expectSameRect(mobileLandscapeLoaded.container, mobileLandscapeLoading.container)
await attachScreenshot(testInfo, "mobile-landscape-loaded", mobilePage)
await mobilePage.keyboard.press("Escape")
@@ -496,25 +710,37 @@ test("image previews keep one frame through loading, decode, failure, retry, and
await expect.poll(() => mobilePortraitRequests).toBe(1)
await expect(mobilePage.getByTestId(tid.imageLightboxOriginal)).toHaveClass(/opacity-0/)
await waitForDialogEntrance(mobilePage)
- const mobilePortraitLoading = await previewRects(mobilePage)
- expectWithinPreviewViewport(mobilePortraitLoading.container, { width: 390, height: 844 })
+ const mobilePortraitLoading = await previewRects(mobilePage, { width: 450, height: 800 })
+ await expect(mobilePage.getByTestId(tid.imageLightboxThumbnail)).toHaveClass(/opacity-100/)
+ const mobileNodes = await previewNodes(mobilePage)
+ caseResources.own(mobileNodes, async (captured) => { await Promise.all(captured.map(({ node }) => node?.dispose())) })
+ const pendingMobileGets = [...mobilePortraitGetPaths]
await attachScreenshot(testInfo, "mobile-portrait-loading", mobilePage)
await mobilePage.setViewportSize({ width: 844, height: 390 })
- const mobilePortraitLandscapeOrientation = await previewRects(mobilePage)
- expectWithinPreviewViewport(mobilePortraitLandscapeOrientation.container, { width: 844, height: 390 })
+ const mobilePortraitLandscapeOrientation = await previewRects(mobilePage, { width: 450, height: 800 })
expect(mobilePortraitLandscapeOrientation.container.height).toBeLessThan(mobilePortraitLoading.container.height)
const rotatedControls = await boundingRect(mobilePage.getByRole("toolbar", { name: "Image controls" }))
expect(rotatedControls.y + rotatedControls.height).toBeLessThan(mobilePortraitLandscapeOrientation.container.y)
await attachScreenshot(testInfo, "mobile-portrait-landscape-orientation-loading", mobilePage)
await mobilePage.setViewportSize({ width: 390, height: 844 })
- const mobilePortraitRestored = await previewRects(mobilePage)
+ const mobilePortraitRestored = await previewRects(mobilePage, { width: 450, height: 800 })
expectSameRect(mobilePortraitRestored.container, mobilePortraitLoading.container)
+ await expectSamePreviewNodes(mobilePage, mobileNodes)
+ expect(mobilePortraitGetPaths).toEqual(pendingMobileGets)
releaseMobilePortrait()
await expect(mobilePage.getByTestId(tid.imageLightboxOriginal)).toHaveClass(/opacity-100/)
- const mobilePortraitLoaded = await previewRects(mobilePage)
+ const mobilePortraitLoaded = await previewRects(mobilePage, { width: 450, height: 800 })
expectSameRect(mobilePortraitLoaded.container, mobilePortraitRestored.container)
+ const loadedMobileGets = [...mobilePortraitGetPaths]
+ await mobilePage.setViewportSize({ width: 390, height: 700 })
+ const mobilePortraitLoadedHeight = await previewRects(mobilePage, { width: 450, height: 800 })
+ expect(mobilePortraitLoadedHeight.container.height).toBeLessThan(mobilePortraitLoaded.container.height)
+ await expectSamePreviewNodes(mobilePage, mobileNodes)
+ expect(mobilePortraitGetPaths).toEqual(loadedMobileGets)
+ await mobilePage.setViewportSize({ width: 390, height: 844 })
+ expectSameRect((await previewRects(mobilePage, { width: 450, height: 800 })).container, mobilePortraitLoaded.container)
await attachScreenshot(testInfo, "mobile-portrait-loaded", mobilePage)
const mobileZoomFrame = mobilePage.getByTestId(tid.imageLightbox)
const mobileOriginal = mobilePage.getByTestId(tid.imageLightboxOriginal)
@@ -540,6 +766,25 @@ test("image previews keep one frame through loading, decode, failure, retry, and
await touchSession.detach()
}
expectSameRect(await boundingRect(mobileZoomFrame), mobilePortraitLoaded.container)
+ const mobilePortraitZoomed = await expectZoomedImage(mobilePage, { width: 450, height: 800 })
+ await expectToolbarAboveImage(mobilePage, mobilePortraitZoomed.painted)
+ await mobilePage.setViewportSize({ width: 390, height: 644 })
+ const mobilePortraitZoomedHeight = await expectZoomedImage(mobilePage, { width: 450, height: 800 })
+ expect(mobilePortraitZoomedHeight.scale).toBeCloseTo(2, 1)
+ expect(mobilePortraitZoomedHeight.translation).toEqual(mobilePortraitZoomed.translation)
+ await mobilePage.setViewportSize({ width: 844, height: 390 })
+ const mobilePortraitZoomedRotated = await expectZoomedImage(mobilePage, { width: 450, height: 800 })
+ expect(mobilePortraitZoomedRotated.scale).toBeCloseTo(2, 1)
+ expect(mobilePortraitZoomedRotated.translation).toEqual(mobilePortraitZoomed.translation)
+ await mobilePage.setViewportSize({ width: 390, height: 844 })
+ const mobilePortraitZoomedRestored = await expectZoomedImage(mobilePage, { width: 450, height: 800 })
+ expect(mobilePortraitZoomedRestored.scale).toBeCloseTo(2, 1)
+ expect(mobilePortraitZoomedRestored.translation).toEqual(mobilePortraitZoomed.translation)
+ await expectToolbarAboveImage(mobilePage, mobilePortraitZoomedRestored.painted)
+ expectSameRect(mobilePortraitZoomedRestored.container, mobilePortraitLoaded.container)
+ await expectSamePreviewNodes(mobilePage, mobileNodes)
+ await expect(mobileOriginal).toHaveClass(/opacity-100/)
+ expect(mobilePortraitGetPaths).toEqual(loadedMobileGets)
await attachScreenshot(testInfo, "mobile-original-pinched", mobilePage)
for (const name of ["Zoom out", "Fit image", "Zoom in", "Close image preview"]) {
const control = await boundingRect(mobilePage.getByRole("button", { name, exact: true }))
@@ -615,6 +860,10 @@ test("image previews keep one frame through loading, decode, failure, retry, and
mobilePortraitLandscapeOrientation,
mobilePortraitRestored,
mobilePortraitLoaded,
+ mobilePortraitLoadedHeight,
+ mobilePortraitZoomedHeight,
+ mobilePortraitZoomedRotated,
+ mobilePortraitZoomedRestored,
mobileExtremeLandscapeFailed,
mobileExtremePortraitFailed,
}, null, 2)),