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

main
tsx 418 lines 17.3 KB
Raw
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 });