Open History to see the last commit
1import { describe, expect, it } from "vite-plus/test";
2import { resolveChatCanvasLayout, type ChatCanvasPreview } from "./chatCanvasLayout";
3import { resizePreviewMiniPlayer } from "../preview/previewMiniPlayerLayout";
4import {
5 resolveThreadDetailsCardDensity,
6 resolveThreadDetailsCardLayout,
7} from "./threadDetailsCardLayout";
8
9const preview: ChatCanvasPreview = {
10 key: "browser:one",
11 width: 320,
12 position: null,
13 source: { width: 1600, height: 1000 },
14};
15const resolve = (width: number, player: ChatCanvasPreview | null = preview, height = 900) =>
16 resolveChatCanvasLayout({ container: { width, height }, preview: player, composerHeight: 180 });
17const expectClear = (result: ReturnType<typeof resolve>) => {
18 const frame = result.frame!;
19 const chat = result.chat;
20 expect(frame.x + frame.width <= chat.left - 12 || frame.x >= chat.left + chat.width + 12).toBe(
21 true,
22 );
23};
24
25describe("chat canvas layout", () => {
26 it("does not enlarge the preview when its right edge is dragged inward", () => {
27 for (const height of [300, 400, 600, 900]) {
28 for (const x of [12, 200, 500, 700]) {
29 const start = resolve(1000, { ...preview, position: { x, y: 500 } }, height).frame!;
30 const resized = resizePreviewMiniPlayer({
31 start,
32 direction: "east",
33 delta: { x: -30, y: 0 },
34 source: preview.source,
35 container: { width: 1000, height },
36 });
37 expect(resized.width, JSON.stringify({ height, x, start, resized })).toBeLessThanOrEqual(
38 start.width,
39 );
40 const rendered = resolve(
41 1000,
42 {
43 ...preview,
44 width: resized.width,
45 position: resized,
46 lastInteraction: "resize",
47 },
48 height,
49 ).frame!;
50 expect(
51 rendered.width,
52 JSON.stringify({ height, x, start, resized, rendered }),
53 ).toBeLessThanOrEqual(start.width);
54 expect(rendered.x).toBe(start.x);
55 expect(rendered.y, JSON.stringify({ height, x, start, resized, rendered })).toBe(start.y);
56 expect(
57 resolve(1000, {
58 ...preview,
59 width: resized.width,
60 position: resized,
61 lastInteraction: "resize",
62 }).frame!.width,
63 ).toBe(resized.width);
64 }
65 }
66 });
67 it("lifts a growing preview above the composer without snapping at the chat boundary", () => {
68 let previous: ReturnType<typeof resolve> | undefined;
69 for (let width = 480; width <= 1100; width++) {
70 const result = resolve(1344, {
71 ...preview,
72 width,
73 lastInteraction: "resize",
74 position: { x: 1332 - width, y: 888 - Math.round(width / 1.6) },
75 });
76 const frame = result.frame!;
77 if (frame.x < result.chat.left + result.chat.width + 12) {
78 expect(frame.y + frame.height).toBeLessThanOrEqual(708);
79 }
80 expect(result.chat.left).toBeLessThanOrEqual(288);
81 expect(result.chat.width).toBeGreaterThanOrEqual(640);
82 if (previous) {
83 expect(Math.abs(frame.y - previous.frame!.y)).toBeLessThanOrEqual(3);
84 expect(Math.abs(frame.width - previous.frame!.width)).toBeLessThanOrEqual(2);
85 expect(Math.abs(result.chat.width - previous.chat.width)).toBeLessThanOrEqual(1);
86 }
87 previous = result;
88 }
89 expect(previous!.overlapsChat).toBe(true);
90 expect(previous!.frame!.width).toBe(1100);
91 });
92 it.each([900, 1000, 1004])("allows dragging across a %spx chat canvas", (width) => {
93 const start = resolve(width, { ...preview, position: { x: width - 332, y: 200 } }).frame!;
94 const moved = resolve(width, {
95 ...preview,
96 position: { x: start.x - 300, y: start.y },
97 lastInteraction: "drag",
98 });
99 expect(moved.frame).toEqual({ ...start, x: start.x - 300 });
100 const returned = resolve(width, {
101 ...preview,
102 position: { x: start.x, y: start.y },
103 lastInteraction: "drag",
104 });
105 expect(returned.frame).toEqual(start);
106 });
107 it("stops leftward dragging before the player can push chat to the right", () => {
108 const centered = resolve(1344, null).chat;
109 for (const x of [1100, 800, 700, 600, 400, 12, -100]) {
110 const result = resolve(1344, { ...preview, position: { x, y: 500 } });
111 expect(result.frame!.x).toBeGreaterThanOrEqual(700);
112 expect(result.chat.left).toBeLessThanOrEqual(centered.left);
113 expect(result.chat.insetStart).toBe(0);
114 expect(result.chat.width).toBeGreaterThanOrEqual(640);
115 expectClear(result);
116 }
117 expect(resolve(1344, { ...preview, position: { x: 12, y: 500 } }).frame!.x).toBe(700);
118 });
119 it("keeps a dragged player above the composer when no readable lane fits beside it", () => {
120 const result = resolve(1000, { ...preview, position: { x: 12, y: 700 } });
121 expect(result.chat).toEqual(resolve(1000, null).chat);
122 expect(result.frame!.x).toBe(12);
123 expect(result.frame!.y + result.frame!.height).toBeLessThanOrEqual(708);
124 });
125 it("restores the preferred width when the container grows again", () => {
126 const player = { ...preview, width: 480 };
127 expect(resolve(1200, player).chat.width).toBeLessThan(768);
128 expect(resolve(1800, player).chat.width).toBe(768);
129 expect(player.width).toBe(480);
130 });
131 it("constrains a dragged preview below the full top-right card instead of folding it", () => {
132 const result = resolveChatCanvasLayout({
133 container: { width: 1584, height: 988 },
134 maxChatWidth: 736,
135 composerHeight: 180,
136 detailsCard: { left: 1260, right: 1572, bottom: 339 },
137 preview: {
138 ...preview,
139 width: 240,
140 source: { width: 240, height: 365 },
141 position: { x: 1260, y: 240 },
142 },
143 });
144 expect(result.frame).toEqual({ x: 1260, y: 351, width: 240, height: 365 });
145 expect(result.overlapsDetailsCard).toBe(false);
146 expect(result.chat).toEqual({ left: 424, width: 736, insetStart: 0, insetEnd: 0 });
147 });
148 it("moves the chat left only as far as a details card it would crowd requires", () => {
149 const { chat } = resolveChatCanvasLayout({
150 container: { width: 1344, height: 988 },
151 maxChatWidth: 736,
152 detailsCard: { left: 1052, right: 1332, bottom: 339 },
153 preview: null,
154 });
155 expect(chat).toMatchObject({ left: 1052 - 32 - 736, width: 736 });
156 });
157 it("keeps the chat canvas-centered when it clears the details card", () => {
158 const result = resolveChatCanvasLayout({
159 container: { width: 2200, height: 988 },
160 maxChatWidth: 736,
161 detailsCard: { left: 1876, right: 2188, bottom: 339 },
162 preview: null,
163 });
164 expect(result.chat.left).toBe((2200 - 736) / 2);
165 });
166 it("moves the chat smoothly as a window with a details card grows", () => {
167 const leftAt = (width: number) =>
168 resolveChatCanvasLayout({
169 container: { width, height: 988 },
170 maxChatWidth: 736,
171 detailsCard: { left: width - 292, right: width - 12, bottom: 339 },
172 preview: null,
173 }).chat.left;
174 for (let width = 1300; width < 1800; width += 1) {
175 expect(Math.abs(leftAt(width + 1) - leftAt(width))).toBeLessThanOrEqual(1);
176 }
177 });
178 it("keeps a dragged or resized preview below the open find bar", () => {
179 const findBar = { left: 1292, right: 1572, bottom: 48 };
180 const layout = (lastInteraction: "drag" | "resize") =>
181 resolveChatCanvasLayout({
182 container: { width: 1584, height: 988 },
183 maxChatWidth: 736,
184 composerHeight: 180,
185 findBar,
186 preview: {
187 ...preview,
188 width: 240,
189 source: { width: 240, height: 365 },
190 position: { x: 1332, y: 12 },
191 lastInteraction,
192 },
193 });
194 for (const lastInteraction of ["drag", "resize"] as const) {
195 const result = layout(lastInteraction);
196 expect(result.frame).toEqual({ x: 1332, y: 60, width: 240, height: 365 });
197 expect(result.overlapsDetailsCard).toBe(false);
198 expect(result.chat).toEqual({ left: 424, width: 736, insetStart: 0, insetEnd: 0 });
199 }
200 });
201 it("uses space beside the full card if a tall preview cannot fit below it", () => {
202 const result = resolveChatCanvasLayout({
203 container: { width: 1584, height: 988 },
204 maxChatWidth: 736,
205 composerHeight: 180,
206 detailsCard: { left: 1260, right: 1572, bottom: 339 },
207 preview: {
208 ...preview,
209 width: 240,
210 source: { width: 240, height: 700 },
211 position: { x: 1260, y: 100 },
212 },
213 });
214 expect(result.frame).toEqual({ x: 1008, y: 100, width: 240, height: 700 });
215 expect(result.overlapsDetailsCard).toBe(false);
216 expectClear(result);
217 });
218 it("keeps a large player when clearing the full card would leave no readable chat", () => {
219 const container = { width: 1584, height: 988 };
220 const source = { width: 1000, height: 1523 };
221 const layout = (width: number) => {
222 const resized = resizePreviewMiniPlayer({
223 start: { x: 1332, y: 610, width: 240, height: 366 },
224 direction: "northwest",
225 delta: { x: 240 - width, y: ((240 - width) * source.height) / source.width },
226 container,
227 source,
228 });
229 return resolveChatCanvasLayout({
230 container,
231 maxChatWidth: 736,
232 composerHeight: 206,
233 detailsCard: { left: 1260, right: 1572, bottom: 339 },
234 preview: { ...preview, width: resized.width, position: resized, source },
235 });
236 };
237 const shifted = layout(460);
238 expect(shifted.frame!.width).toBe(460);
239 expect(shifted.chat.left).toBeLessThan(424);
240 expect(shifted.overlapsDetailsCard).toBe(false);
241 expectClear(shifted);
242
243 const narrowed = layout(532);
244 expect(narrowed.frame!.width).toBe(532);
245 expect(narrowed.chat.width).toBe(656);
246 expect(narrowed.overlapsDetailsCard).toBe(false);
247 expectClear(narrowed);
248
249 const grown = layout(600);
250 expect(grown.frame!.width).toBe(600);
251 expect(grown.overlapsDetailsCard).toBe(true);
252 expect(grown.overlapsChat).toBe(false);
253 expectClear(grown);
254 expect(layout(532)).toEqual(narrowed);
255 });
256 it.each(["west", "north"] as const)(
257 "folds the card before moving a %s resize beside it",
258 (direction) => {
259 const container = { width: 1584, height: 988 };
260 const source = { width: 1000, height: 1523 };
261 const layout = (width: number) => {
262 const resized = resizePreviewMiniPlayer({
263 start: { x: 1332, y: 611, width: 240, height: 365 },
264 direction,
265 delta: { x: 240 - width, y: ((240 - width) * source.height) / source.width },
266 container,
267 source,
268 });
269 return resolveChatCanvasLayout({
270 container,
271 maxChatWidth: 736,
272 composerHeight: 206,
273 detailsCard: { left: 1260, right: 1572, bottom: 339 },
274 preview: {
275 ...preview,
276 width: resized.width,
277 position: resized,
278 source,
279 lastInteraction: "resize",
280 },
281 });
282 };
283 const density = (result: ReturnType<typeof layout>) => {
284 const card = resolveThreadDetailsCardLayout({
285 container,
286 lane: { padding: 48, minChatWidth: 640 },
287 frame: result.frame,
288 overlapsDetailsCard: result.overlapsDetailsCard,
289 });
290 return card
291 ? resolveThreadDetailsCardDensity(card.height, { full: 327, compact: 182 })
292 : "hidden";
293 };
294 expect(density(layout(400))).toBe("full");
295 const compact = layout(460);
296 expect(compact.frame!.x + compact.frame!.width).toBe(1572);
297 expect(compact.frame!.width).toBe(460);
298 expect(compact.chat.left).toBe(364);
299 expect(compact.overlapsDetailsCard).toBe(true);
300 expect(density(compact)).toBe("compact");
301 expectClear(compact);
302 expect(density(layout(500))).toBe("compact");
303 expect(density(layout(520))).toBe("essential");
304 expect(density(layout(540))).toBe("hidden");
305 expect(layout(600).frame!.width).toBe(600);
306 expect(layout(460)).toEqual(compact);
307 expect(density(layout(400))).toBe("full");
308 },
309 );
310 it("requests card folding only when no full-card slot fits and keeps the composer clear", () => {
311 const result = resolveChatCanvasLayout({
312 container: { width: 1584, height: 988 },
313 maxChatWidth: 736,
314 composerHeight: 180,
315 detailsCard: { left: 1260, right: 1572, bottom: 600 },
316 preview: {
317 ...preview,
318 width: 1300,
319 source: { width: 1300, height: 400 },
320 position: { x: 12, y: 12 },
321 },
322 });
323 expect(result.overlapsDetailsCard).toBe(true);
324 expect(result.overlapsChat).toBe(true);
325 expect(result.frame).toEqual({ x: 12, y: 396, width: 1300, height: 400 });
326 });
327});
328
329describe("workspace card beside chat", () => {
330 const withCard = (width: number, player: ChatCanvasPreview | null = null, maxChatWidth = 736) =>
331 resolveChatCanvasLayout({
332 container: { width, height: 900 },
333 maxChatWidth,
334 composerHeight: 180,
335 detailsCard: { left: width - 292, right: width - 12, bottom: 400 },
336 preview: player,
337 });
338 it("keeps chat centered while the card fits beside it", () => {
339 expect(withCard(1500).chat).toEqual({ left: 382, width: 736, insetStart: 0, insetEnd: 0 });
340 });
341 it("narrows chat only after it reaches the left padding", () => {
342 expect(withCard(1108).chat).toMatchObject({ left: 48, width: 736 });
343 expect(withCard(1028).chat).toEqual({ left: 48, width: 656, insetStart: 0, insetEnd: 276 });
344 expect(withCard(1012).chat).toMatchObject({ left: 48, width: 640 });
345 });
346 it("reserves the marker gutter across widths where the details card fits", () => {
347 for (let width = 1012; width <= 1440; width++) {
348 const container = { width, height: 900 };
349 const card = resolveThreadDetailsCardLayout({
350 container,
351 lane: { padding: 48, minChatWidth: 640 },
352 frame: null,
353 })!;
354 const chat = withCard(width).chat;
355 expect(chat.left).toBeGreaterThanOrEqual(48);
356 expect(chat.width).toBeGreaterThanOrEqual(640);
357 expect(card.x - chat.left - chat.width).toBeGreaterThanOrEqual(32);
358 }
359 });
360});