The best way to control Claude Code, Codex and more from any computer or phone
| 1 | import { |
| 2 | FILE_PREVIEW_SCROLL_SCRIPT, |
| 3 | injectHtmlRenderBootstrap, |
| 4 | readFilePreviewScroll, |
| 5 | } from "@t3tools/shared/htmlRender"; |
| 6 | import { describe, expect, it, vi } from "vite-plus/test"; |
| 7 | import { page } from "vite-plus/test/browser"; |
| 8 | |
| 9 | import "~/index.css"; |
| 10 | import { render } from "../../../test/render"; |
| 11 | |
| 12 | import { BrowserDocumentFrame, HtmlRenderDocument } from "./BrowserDocumentFrame"; |
| 13 | |
| 14 | const sizeChanged = (height: number) => ({ |
| 15 | jsonrpc: "2.0", |
| 16 | method: "ui/notifications/size-changed", |
| 17 | params: { height }, |
| 18 | }); |
| 19 | |
| 20 | describe("HtmlRenderDocument", () => { |
| 21 | it("reports the page's first height and ignores messages from other windows", async () => { |
| 22 | using pageUrl = (() => { |
| 23 | const page = `<script>parent.postMessage(${JSON.stringify(sizeChanged(321))}, "*");</script>`; |
| 24 | const url = URL.createObjectURL(new Blob([page], { type: "text/html" })); |
| 25 | return { url, [Symbol.dispose]: () => URL.revokeObjectURL(url) }; |
| 26 | })(); |
| 27 | const onContentHeight = vi.fn(); |
| 28 | await using _screen = await render( |
| 29 | <HtmlRenderDocument src={pageUrl.url} title="Report" onContentHeight={onContentHeight} />, |
| 30 | ); |
| 31 | |
| 32 | await vi.waitFor(() => expect(onContentHeight).toHaveBeenCalledWith(321)); |
| 33 | |
| 34 | // Listeners run in registration order, so once this one sees the message the frame's has too. |
| 35 | const delivered = new Promise<void>((resolve) => |
| 36 | window.addEventListener("message", () => resolve(), { once: true }), |
| 37 | ); |
| 38 | window.postMessage(sizeChanged(999), "*"); |
| 39 | await delivered; |
| 40 | expect(onContentHeight).toHaveBeenCalledTimes(1); |
| 41 | }); |
| 42 | |
| 43 | it("opens a clicked image with the other images of its block in the viewer", async () => { |
| 44 | const swatch = (color: string) => |
| 45 | `data:image/svg+xml,${encodeURIComponent( |
| 46 | `<svg xmlns="http://www.w3.org/2000/svg" width="80" height="50"><rect width="80" height="50" fill="${color}"/></svg>`, |
| 47 | )}`; |
| 48 | const html = injectHtmlRenderBootstrap( |
| 49 | `<!doctype html><html><body><div>${["Red", "Green", "Blue"] |
| 50 | .map((name) => `<img alt="${name}" src="${swatch(name.toLowerCase())}">`) |
| 51 | .join("")}</div></body></html>`, |
| 52 | ); |
| 53 | const src = URL.createObjectURL(new Blob([html], { type: "text/html" })); |
| 54 | using _url = { [Symbol.dispose]: () => URL.revokeObjectURL(src) }; |
| 55 | await using screen = await render(<HtmlRenderDocument src={src} title="Swatches" />); |
| 56 | |
| 57 | await page.frameLocator(screen.getByTitle("Swatches")).getByAltText("Green").click(); |
| 58 | |
| 59 | const viewer = page.getByRole("dialog", { name: "Expanded image preview" }); |
| 60 | await expect.element(viewer.getByAltText("Green")).toBeVisible(); |
| 61 | await expect.element(viewer.getByRole("button", { name: "Next media" })).toBeVisible(); |
| 62 | await expect.element(viewer.getByRole("button", { name: "Previous media" })).toBeVisible(); |
| 63 | }); |
| 64 | }); |
| 65 | |
| 66 | it("keeps the chat in place when a label far from its hidden radio is clicked", async () => { |
| 67 | const html = injectHtmlRenderBootstrap(`<!doctype html><html><head><style> |
| 68 | .r > input { position: absolute; opacity: 0; pointer-events: none; } |
| 69 | .fill { height: 1400px; } |
| 70 | </style></head><body><div class="r"> |
| 71 | <input type="radio" name="opt" id="opt-a" checked> |
| 72 | <input type="radio" name="opt" id="opt-b"> |
| 73 | <label for="opt-a">Top A</label><label for="opt-b">Top B</label> |
| 74 | <div class="fill"></div> |
| 75 | <label for="opt-a">A</label><label for="opt-b">B</label> |
| 76 | </div><script> |
| 77 | document.getElementById("opt-b").addEventListener("change", function() { |
| 78 | parent.postMessage({ type: "radio-changed", id: "opt-b" }, "*"); |
| 79 | }); |
| 80 | </script></body></html>`); |
| 81 | const src = URL.createObjectURL(new Blob([html], { type: "text/html" })); |
| 82 | using _url = { [Symbol.dispose]: () => URL.revokeObjectURL(src) }; |
| 83 | const scroller = document.createElement("div"); |
| 84 | scroller.style.cssText = "height: 400px; overflow: auto; width: 728px;"; |
| 85 | const changed = vi.fn(); |
| 86 | const messages = new AbortController(); |
| 87 | using _messages = { [Symbol.dispose]: () => messages.abort() }; |
| 88 | window.addEventListener( |
| 89 | "message", |
| 90 | (event) => { |
| 91 | if (event.data?.type === "radio-changed") changed(event.data.id); |
| 92 | }, |
| 93 | { signal: messages.signal }, |
| 94 | ); |
| 95 | const contentHeight = vi.fn((height: number) => { |
| 96 | scroller.style.setProperty("--content-height", `${height}px`); |
| 97 | }); |
| 98 | await using screen = await render( |
| 99 | <> |
| 100 | <style>{`iframe[title="Toggle"] { |
| 101 | display: block; width: 100%; height: var(--content-height, 120px); border: 0; |
| 102 | }`}</style> |
| 103 | <div style={{ height: 600 }} /> |
| 104 | <HtmlRenderDocument src={src} title="Toggle" onContentHeight={contentHeight} /> |
| 105 | <div style={{ height: 100 }} /> |
| 106 | </>, |
| 107 | { container: scroller }, |
| 108 | ); |
| 109 | |
| 110 | const frame = screen.getByTitle("Toggle").element() as HTMLIFrameElement; |
| 111 | await vi.waitFor(() => expect(frame.getBoundingClientRect().height).toBeGreaterThan(1400)); |
| 112 | scroller.scrollTop = scroller.scrollHeight; |
| 113 | const scrollTop = scroller.scrollTop; |
| 114 | |
| 115 | await page.frameLocator(screen.getByTitle("Toggle")).getByText("B", { exact: true }).click(); |
| 116 | |
| 117 | await vi.waitFor(() => expect(changed).toHaveBeenCalledWith("opt-b")); |
| 118 | expect(scroller.scrollTop).toBe(scrollTop); |
| 119 | }); |
| 120 | |
| 121 | const scrollIntoViewPage = injectHtmlRenderBootstrap(`<!doctype html><html><head><style> |
| 122 | .fill { height: 1400px; } |
| 123 | .panel { height: 200px; overflow: auto; } |
| 124 | .card { height: 100px; overflow: hidden; } |
| 125 | .gap { height: 600px; } |
| 126 | .card .gap { height: 300px; } |
| 127 | </style></head><body> |
| 128 | <nav id="top">Index</nav> |
| 129 | <div class="fill"></div> |
| 130 | <div class="panel" id="panel"><div class="gap"></div> |
| 131 | <div class="card" id="card"><div class="gap"></div><p id="deep">Deep</p></div> |
| 132 | </div> |
| 133 | <script> |
| 134 | addEventListener("message", function(event) { |
| 135 | if (event.data?.type !== "scroll-into-view") return; |
| 136 | document.getElementById(event.data.id).scrollIntoView({ block: "nearest" }); |
| 137 | parent.postMessage({ |
| 138 | type: "scrolled", |
| 139 | id: event.data.id, |
| 140 | card: document.getElementById("card").scrollTop, |
| 141 | panel: document.getElementById("panel").scrollTop, |
| 142 | page: document.scrollingElement.scrollTop, |
| 143 | }, "*"); |
| 144 | }); |
| 145 | </script></body></html>`); |
| 146 | |
| 147 | // Inline chat frames are fitted and contained; the expanded view keeps native scrolling, since |
| 148 | // its dialog scroller is how the page's own navigation reaches a section. |
| 149 | it.each([ |
| 150 | { name: "a fitted inline frame", containScroll: true, fitted: true }, |
| 151 | { name: "a fitted expanded frame", containScroll: false, fitted: true }, |
| 152 | { name: "a capped inline frame", containScroll: true, fitted: false }, |
| 153 | ])( |
| 154 | "scrolls only what it should when a page script scrolls into view in $name", |
| 155 | async (frameCase) => { |
| 156 | const src = URL.createObjectURL(new Blob([scrollIntoViewPage], { type: "text/html" })); |
| 157 | using _url = { [Symbol.dispose]: () => URL.revokeObjectURL(src) }; |
| 158 | const scroller = document.createElement("div"); |
| 159 | scroller.style.cssText = "height: 400px; overflow: auto; width: 728px;"; |
| 160 | const scrolled = vi.fn(); |
| 161 | const messages = new AbortController(); |
| 162 | using _messages = { [Symbol.dispose]: () => messages.abort() }; |
| 163 | window.addEventListener( |
| 164 | "message", |
| 165 | (event) => { |
| 166 | if (event.data?.type === "scrolled") scrolled(event.data); |
| 167 | }, |
| 168 | { signal: messages.signal }, |
| 169 | ); |
| 170 | const contentHeight = vi.fn((height: number) => { |
| 171 | if (frameCase.fitted) scroller.style.setProperty("--content-height", `${height}px`); |
| 172 | }); |
| 173 | await using screen = await render( |
| 174 | <> |
| 175 | <style>{`iframe[title="Index"] { |
| 176 | display: block; width: 100%; height: var(--content-height, 300px); border: 0; |
| 177 | }`}</style> |
| 178 | <div style={{ height: 600 }} /> |
| 179 | <HtmlRenderDocument |
| 180 | src={src} |
| 181 | title="Index" |
| 182 | containScroll={frameCase.containScroll} |
| 183 | onContentHeight={contentHeight} |
| 184 | /> |
| 185 | <div style={{ height: 100 }} /> |
| 186 | </>, |
| 187 | { container: scroller }, |
| 188 | ); |
| 189 | |
| 190 | const frame = screen.getByTitle("Index").element() as HTMLIFrameElement; |
| 191 | await vi.waitFor(() => expect(contentHeight).toHaveBeenCalled()); |
| 192 | if (frameCase.fitted) { |
| 193 | await vi.waitFor(() => expect(frame.getBoundingClientRect().height).toBeGreaterThan(1400)); |
| 194 | } |
| 195 | scroller.scrollTop = scroller.scrollHeight; |
| 196 | const scrollTop = scroller.scrollTop; |
| 197 | |
| 198 | frame.contentWindow?.postMessage({ type: "scroll-into-view", id: "deep" }, "*"); |
| 199 | await vi.waitFor(() => |
| 200 | expect(scrolled).toHaveBeenCalledWith(expect.objectContaining({ id: "deep" })), |
| 201 | ); |
| 202 | const deep = scrolled.mock.lastCall?.[0]; |
| 203 | // Every scroller inside the page moves, as the browser would: the clipped card, its panel, |
| 204 | // and in a capped frame the page itself. |
| 205 | expect(deep.card).toBeGreaterThan(0); |
| 206 | expect(deep.panel).toBeGreaterThan(0); |
| 207 | if (!frameCase.fitted) expect(deep.page).toBeGreaterThan(0); |
| 208 | expect(scroller.scrollTop).toBe(scrollTop); |
| 209 | |
| 210 | frame.contentWindow?.postMessage({ type: "scroll-into-view", id: "top" }, "*"); |
| 211 | await vi.waitFor(() => |
| 212 | expect(scrolled).toHaveBeenCalledWith(expect.objectContaining({ id: "top" })), |
| 213 | ); |
| 214 | if (frameCase.containScroll) expect(scroller.scrollTop).toBe(scrollTop); |
| 215 | else expect(scroller.scrollTop).toBeLessThan(scrollTop); |
| 216 | }, |
| 217 | ); |
| 218 | |
| 219 | it("keeps the first and last selected card rings inside the fitted renderer frame", async () => { |
| 220 | const html = injectHtmlRenderBootstrap(`<!doctype html><html><head><style> |
| 221 | main { display: grid; gap: 12px; } |
| 222 | button { box-sizing: border-box; width: 100%; height: 72px; border: 0; } |
| 223 | button[aria-pressed="true"] { outline: 3px solid blue; outline-offset: 2px; } |
| 224 | </style></head><body><main> |
| 225 | <button id="first" aria-pressed="false">Meadow</button> |
| 226 | <button id="middle" aria-pressed="false">Harbor</button> |
| 227 | <button id="last" aria-pressed="false">Orchid</button> |
| 228 | </main><script> |
| 229 | document.querySelectorAll("button").forEach(function(button) { |
| 230 | button.addEventListener("click", function() { |
| 231 | document.querySelectorAll("button").forEach(function(card) { |
| 232 | card.setAttribute("aria-pressed", String(card === button)); |
| 233 | }); |
| 234 | }); |
| 235 | }); |
| 236 | window.addEventListener("message", function(event) { |
| 237 | if (event.source !== window.parent || event.data.type !== "select-card") return; |
| 238 | var button = document.getElementById(event.data.id); |
| 239 | button.click(); |
| 240 | var rect = button.getBoundingClientRect(); |
| 241 | var style = getComputedStyle(button); |
| 242 | var ring = parseFloat(style.outlineWidth) + parseFloat(style.outlineOffset); |
| 243 | window.parent.postMessage({ |
| 244 | type: "selected-card-bounds", |
| 245 | id: button.id, |
| 246 | selected: button.getAttribute("aria-pressed") === "true", |
| 247 | ring: ring, |
| 248 | left: rect.left - ring, |
| 249 | right: rect.right + ring, |
| 250 | top: rect.top - ring, |
| 251 | bottom: rect.bottom + ring, |
| 252 | pageHeight: document.documentElement.getBoundingClientRect().height, |
| 253 | viewportHeight: window.innerHeight, |
| 254 | viewportWidth: window.innerWidth, |
| 255 | scrollWidth: document.documentElement.scrollWidth |
| 256 | }, "*"); |
| 257 | }); |
| 258 | </script></body></html>`); |
| 259 | const src = URL.createObjectURL(new Blob([html], { type: "text/html" })); |
| 260 | using _url = { [Symbol.dispose]: () => URL.revokeObjectURL(src) }; |
| 261 | const container = document.createElement("div"); |
| 262 | container.style.width = "728px"; |
| 263 | const reports = new Map< |
| 264 | string, |
| 265 | { |
| 266 | selected: boolean; |
| 267 | ring: number; |
| 268 | left: number; |
| 269 | right: number; |
| 270 | top: number; |
| 271 | bottom: number; |
| 272 | pageHeight: number; |
| 273 | viewportHeight: number; |
| 274 | viewportWidth: number; |
| 275 | scrollWidth: number; |
| 276 | } |
| 277 | >(); |
| 278 | const messages = new AbortController(); |
| 279 | using _messages = { [Symbol.dispose]: () => messages.abort() }; |
| 280 | window.addEventListener( |
| 281 | "message", |
| 282 | (event) => { |
| 283 | const frame = container.querySelector("iframe"); |
| 284 | if (event.source === frame?.contentWindow && event.data?.type === "selected-card-bounds") { |
| 285 | reports.set(event.data.id, event.data); |
| 286 | } |
| 287 | }, |
| 288 | { signal: messages.signal }, |
| 289 | ); |
| 290 | const contentHeight = vi.fn((height: number) => { |
| 291 | container.style.setProperty("--content-height", `${height}px`); |
| 292 | }); |
| 293 | await using screen = await render( |
| 294 | <> |
| 295 | <style>{`iframe[title="Edge cards"] { |
| 296 | display: block; width: 100%; height: var(--content-height, 120px); border: 0; |
| 297 | }`}</style> |
| 298 | <HtmlRenderDocument src={src} title="Edge cards" onContentHeight={contentHeight} /> |
| 299 | </>, |
| 300 | { container }, |
| 301 | ); |
| 302 | |
| 303 | await vi.waitFor(() => expect(contentHeight).toHaveBeenCalled()); |
| 304 | const frame = screen.getByTitle("Edge cards").element() as HTMLIFrameElement; |
| 305 | await vi.waitFor(() => { |
| 306 | expect(frame.getBoundingClientRect().height).toBe(contentHeight.mock.lastCall?.[0]); |
| 307 | }); |
| 308 | |
| 309 | for (const id of ["first", "last"]) { |
| 310 | frame.contentWindow?.postMessage({ type: "select-card", id }, "*"); |
| 311 | await vi.waitFor(() => expect(reports.get(id)?.selected).toBe(true)); |
| 312 | const bounds = reports.get(id)!; |
| 313 | expect(bounds.ring).toBe(5); |
| 314 | expect(bounds.viewportWidth).toBe(728); |
| 315 | expect(bounds.pageHeight).toBe(contentHeight.mock.lastCall?.[0]); |
| 316 | expect(bounds.viewportHeight).toBe(bounds.pageHeight); |
| 317 | expect(bounds.left).toBeGreaterThanOrEqual(0); |
| 318 | expect(bounds.top).toBeGreaterThanOrEqual(0); |
| 319 | expect(bounds.right).toBeLessThanOrEqual(bounds.viewportWidth); |
| 320 | expect(bounds.bottom).toBeLessThanOrEqual(bounds.viewportHeight); |
| 321 | expect(bounds.scrollWidth).toBeLessThanOrEqual(bounds.viewportWidth); |
| 322 | } |
| 323 | }); |
| 324 | |
| 325 | describe("BrowserDocumentFrame", () => { |
| 326 | it("keeps a page on screen until its next revision has loaded", async () => { |
| 327 | using pages = (() => { |
| 328 | const urls = ["first", "second", "third"].map((name) => |
| 329 | URL.createObjectURL(new Blob([`<p>${name}</p>`], { type: "text/html" })), |
| 330 | ); |
| 331 | return { urls, [Symbol.dispose]: () => urls.forEach((url) => URL.revokeObjectURL(url)) }; |
| 332 | })(); |
| 333 | const [first, second, third] = pages.urls as [string, string, string]; |
| 334 | const frame = (revision: string, src: string) => ( |
| 335 | <div className="flex h-75 w-100 flex-col"> |
| 336 | <BrowserDocumentFrame |
| 337 | src={src} |
| 338 | title="Report" |
| 339 | pdf={false} |
| 340 | documentKey={`report:${revision}`} |
| 341 | documentId="report" |
| 342 | /> |
| 343 | </div> |
| 344 | ); |
| 345 | await using screen = await render(frame("1", first)); |
| 346 | const srcs = () => Array.from(screen.container.querySelectorAll("iframe"), (f) => f.src); |
| 347 | const onScreen = () => { |
| 348 | const box = screen.container.getBoundingClientRect(); |
| 349 | const hit = document.elementFromPoint(box.left + box.width / 2, box.top + 10); |
| 350 | return hit instanceof HTMLIFrameElement ? hit.src : null; |
| 351 | }; |
| 352 | await vi.waitFor(() => expect(onScreen()).toBe(first)); |
| 353 | |
| 354 | // The incoming frame cannot have loaded when it is inserted, so the current page must cover it. |
| 355 | const atInsertion = new Promise<string | null>((resolve) => { |
| 356 | const observer = new MutationObserver(() => { |
| 357 | if (!srcs().includes(second)) return; |
| 358 | observer.disconnect(); |
| 359 | resolve(onScreen()); |
| 360 | }); |
| 361 | observer.observe(screen.container, { childList: true, subtree: true }); |
| 362 | }); |
| 363 | await screen.rerender(frame("2", second)); |
| 364 | expect(await atInsertion).toBe(first); |
| 365 | await vi.waitFor(() => expect(srcs()).toEqual([second])); |
| 366 | expect(onScreen()).toBe(second); |
| 367 | |
| 368 | await screen.rerender(frame("3", third)); |
| 369 | await screen.rerender(frame("2", second)); |
| 370 | expect(srcs(), "returning to the shown revision kept the pending frame").toEqual([second]); |
| 371 | await screen.rerender(frame("3", third)); |
| 372 | await vi.waitFor(() => expect(onScreen()).toBe(third)); |
| 373 | }); |
| 374 | |
| 375 | it("opens the next revision where the reader left the page", async () => { |
| 376 | // The first page scrolls itself, as a reader would; the second is served without scrolling. |
| 377 | const tall = '<div style="height:5000px">report</div>'; |
| 378 | using pages = (() => { |
| 379 | const urls = [ |
| 380 | `${tall}<script>addEventListener("load",()=>scrollTo(0,1200))</script>`, |
| 381 | tall, |
| 382 | ].map((body) => |
| 383 | URL.createObjectURL(new Blob([body + FILE_PREVIEW_SCROLL_SCRIPT], { type: "text/html" })), |
| 384 | ); |
| 385 | return { urls, [Symbol.dispose]: () => urls.forEach((url) => URL.revokeObjectURL(url)) }; |
| 386 | })(); |
| 387 | const [first, second] = pages.urls as [string, string]; |
| 388 | const reports: Array<{ source: MessageEventSource | null; y: number }> = []; |
| 389 | const onMessage = (event: MessageEvent) => { |
| 390 | const scroll = readFilePreviewScroll(event.data); |
| 391 | if (scroll !== undefined) reports.push({ source: event.source, y: scroll.y }); |
| 392 | }; |
| 393 | window.addEventListener("message", onMessage); |
| 394 | using _listener = { [Symbol.dispose]: () => window.removeEventListener("message", onMessage) }; |
| 395 | const frame = (revision: string, src: string) => ( |
| 396 | <div className="flex h-75 w-100 flex-col"> |
| 397 | <BrowserDocumentFrame |
| 398 | src={src} |
| 399 | title="Report" |
| 400 | pdf={false} |
| 401 | documentKey={`report:${revision}`} |
| 402 | documentId="report" |
| 403 | /> |
| 404 | </div> |
| 405 | ); |
| 406 | await using screen = await render(frame("1", first)); |
| 407 | const iframes = () => Array.from(screen.container.querySelectorAll("iframe")); |
| 408 | await vi.waitFor(() => expect(reports.map((report) => report.y)).toContain(1200)); |
| 409 | |
| 410 | await screen.rerender(frame("2", second)); |
| 411 | await vi.waitFor(() => expect(iframes().map((element) => element.src)).toEqual([second])); |
| 412 | const shown = iframes()[0]!.contentWindow; |
| 413 | expect( |
| 414 | reports.filter((report) => report.source === shown).map((report) => report.y), |
| 415 | "the next revision was uncovered before it took the reader's position", |
| 416 | ).toContain(1200); |
| 417 | }); |
| 418 | }); |