xonecas.io
70160
Ce

cel-tui / files

cel-tui / packages / core / src / composite.test.ts

7.9 KB
1import { afterEach, describe, expect, test } from "bun:test";
2import { HStack, VStack } from "./primitives/stacks.js";
3import { Text } from "./primitives/text.js";
4import { TextInput } from "./primitives/text-input.js";
5import { MockTerminal } from "./terminal.js";
6import { testCel as cel } from "./test-helpers.js";
7
8describe("layer compositing", () => {
9  let term: MockTerminal;
10
11  afterEach(() => {
12    cel.stop();
13  });
14
15  function setup(columns = 20, rows = 5): MockTerminal {
16    term = new MockTerminal(columns, rows);
17    cel.init(term);
18    return term;
19  }
20
21  async function waitForRender(): Promise<void> {
22    await cel._flush();
23  }
24
25  function currentBuffer() {
26    const buf = cel._getBuffer();
27    expect(buf).not.toBeNull();
28    if (buf === null) {
29      throw new Error("Expected a rendered buffer");
30    }
31    return buf;
32  }
33
34  test("single layer renders normally", async () => {
35    const term = setup(20, 3);
36    cel.viewport(() => VStack({}, [Text("Hello")]));
37    await waitForRender();
38    expect(term.output).toContain("Hello");
39  });
40
41  test("second layer paints over first", async () => {
42    setup(20, 3);
43    cel.viewport(() => [
44      VStack({}, [Text("AAAAAAAAAA")]),
45      VStack({}, [Text("BB")]),
46    ]);
47    await waitForRender();
48
49    // "BB" should overwrite the first two A's, rest of A's visible
50    const buf = currentBuffer();
51    expect(buf.get(0, 0).char).toBe("B");
52    expect(buf.get(1, 0).char).toBe("B");
53    expect(buf.get(2, 0).char).toBe("A");
54  });
55
56  test("transparent cells in upper layer show lower layer", async () => {
57    setup(10, 3);
58    cel.viewport(() => [
59      // Base layer: fill row 0 with A's
60      VStack({}, [Text("AAAAAAAAAA")]),
61      // Overlay layer: only paint at position (5,0)
62      VStack({}, [
63        HStack({}, [
64          VStack({ width: 5 }, []),
65          VStack({ width: 5 }, [Text("BB")]),
66        ]),
67      ]),
68    ]);
69    await waitForRender();
70
71    const buf = currentBuffer();
72    // First 5 chars: A from base layer (overlay is empty/transparent)
73    expect(buf.get(0, 0).char).toBe("A");
74    expect(buf.get(4, 0).char).toBe("A");
75    // Chars 5-6: B from overlay
76    expect(buf.get(5, 0).char).toBe("B");
77    expect(buf.get(6, 0).char).toBe("B");
78  });
79
80  test("narrow overlay text replaces a wide lower-layer glyph atomically", async () => {
81    setup(3, 1);
82    cel.viewport(() => [Text("😀A"), Text("B")]);
83    await waitForRender();
84
85    const buf = currentBuffer();
86    expect(buf.get(0, 0).char).toBe("B");
87    expect(buf.get(1, 0).char).toBe(" ");
88    expect(buf.get(2, 0).char).toBe("A");
89  });
90
91  test("overlay text on a continuation cell clears the wide lower glyph", async () => {
92    setup(3, 1);
93    cel.viewport(() => [
94      Text("😀A"),
95      HStack({}, [VStack({ width: 1 }, []), Text("B")]),
96    ]);
97    await waitForRender();
98
99    const buf = currentBuffer();
100    expect(buf.get(0, 0).char).toBe(" ");
101    expect(buf.get(1, 0).char).toBe("B");
102    expect(buf.get(2, 0).char).toBe("A");
103  });
104
105  test("an identical wide overlay preserves its lead and continuation", async () => {
106    setup(3, 1);
107    cel.viewport(() => [Text("界A"), Text("界")]);
108    await waitForRender();
109
110    const buf = currentBuffer();
111    expect(buf.get(0, 0).char).toBe("界");
112    expect(buf.get(1, 0).char).toBe("");
113    expect(buf.get(2, 0).char).toBe("A");
114  });
115
116  test("click targets topmost layer", async () => {
117    const term = setup(20, 3);
118    let baseClicked = false;
119    let overlayClicked = false;
120
121    cel.viewport(() => [
122      VStack(
123        {
124          onClick: () => {
125            baseClicked = true;
126          },
127        },
128        [Text("base")],
129      ),
130      VStack(
131        {
132          onClick: () => {
133            overlayClicked = true;
134          },
135        },
136        [Text("overlay")],
137      ),
138    ]);
139    await waitForRender();
140
141    // Click at (3, 0) — should hit overlay, not base
142    term.sendInput("\x1b[<0;4;1m");
143    await waitForRender();
144
145    expect(overlayClicked).toBe(true);
146    expect(baseClicked).toBe(false);
147  });
148
149  test("conditional layer (modal show/hide)", async () => {
150    const term = setup(20, 3);
151    let showModal = false;
152
153    cel.viewport(() => {
154      const layers = [VStack({}, [Text("main")])];
155      if (showModal) {
156        layers.push(VStack({}, [Text("modal")]));
157      }
158      return layers;
159    });
160    await waitForRender();
161
162    expect(term.output).toContain("main");
163    expect(term.output).not.toContain("modal");
164
165    showModal = true;
166    cel.render();
167    await waitForRender();
168
169    // Check buffer contents — diff rendering may not emit "modal" as a
170    // contiguous string since unchanged chars (like 'm') are skipped
171    const buf = currentBuffer();
172    const row = Array.from({ length: 5 }, (_, i) => buf.get(i, 0).char).join(
173      "",
174    );
175    expect(row).toBe("modal");
176  });
177
178  test("layer focus is suspended by a modal and restored afterward", async () => {
179    const term = setup(20, 3);
180    const clicks: string[] = [];
181    let showModal = false;
182
183    cel.viewport(() => {
184      const base = VStack({ stateKey: "base-layer", width: 20, height: 3 }, [
185        HStack({ stateKey: "base", onClick: () => clicks.push("base") }, [
186          Text("base"),
187        ]),
188      ]);
189      if (!showModal) return base;
190      return [
191        base,
192        VStack({ stateKey: "modal-layer", width: 20, height: 3 }, [
193          HStack({ stateKey: "modal", onClick: () => clicks.push("modal") }, [
194            Text("modal"),
195          ]),
196        ]),
197      ];
198    });
199    await waitForRender();
200
201    term.sendInput("\t");
202    await waitForRender();
203    showModal = true;
204    cel.render();
205    await waitForRender();
206    term.sendInput("\r");
207    await waitForRender();
208    expect(clicks).toEqual([]);
209
210    term.sendInput("\t");
211    await waitForRender();
212    term.sendInput("\r");
213    await waitForRender();
214    expect(clicks).toEqual(["modal"]);
215
216    showModal = false;
217    cel.render();
218    await waitForRender();
219    term.sendInput("\r");
220    await waitForRender();
221    expect(clicks).toEqual(["modal", "base"]);
222  });
223
224  test("a controlled TextInput in a covered layer receives no keys", async () => {
225    const term = setup(20, 3);
226    let value = "";
227
228    cel.viewport(() => [
229      TextInput({
230        stateKey: "covered-input",
231        value,
232        focused: true,
233        onChange: (next) => {
234          value = next;
235        },
236      }),
237      VStack({ stateKey: "overlay", width: 20, height: 3 }, [Text("modal")]),
238    ]);
239    await waitForRender();
240
241    term.sendInput("x");
242    await waitForRender();
243
244    expect(value).toBe("");
245  });
246
247  test("autoFocus prefers the modal and restores underlying focus", async () => {
248    const term = setup(20, 3);
249    const events: string[] = [];
250    let showModal = false;
251
252    cel.viewport(() => {
253      const base = VStack({ stateKey: "base-layer", width: 20, height: 3 }, [
254        HStack(
255          {
256            stateKey: "base-auto",
257            autoFocus: true,
258            onFocus: ({ reason }) => events.push(`base:${reason}`),
259            onClick: () => events.push("base:click"),
260          },
261          [Text("base")],
262        ),
263      ]);
264      if (!showModal) return base;
265      return [
266        base,
267        VStack({ stateKey: "modal-layer", width: 20, height: 3 }, [
268          HStack(
269            {
270              stateKey: "modal-auto",
271              autoFocus: true,
272              onFocus: ({ reason }) => events.push(`modal:${reason}`),
273              onClick: () => events.push("modal:click"),
274            },
275            [Text("modal")],
276          ),
277        ]),
278      ];
279    });
280    await waitForRender();
281    expect(events).toEqual(["base:auto"]);
282
283    showModal = true;
284    cel.render();
285    await waitForRender();
286    term.sendInput("\r");
287    await waitForRender();
288    expect(events).toEqual(["base:auto", "modal:auto", "modal:click"]);
289
290    showModal = false;
291    cel.render();
292    await waitForRender();
293    term.sendInput("\r");
294    await waitForRender();
295    expect(events).toEqual([
296      "base:auto",
297      "modal:auto",
298      "modal:click",
299      "base:click",
300    ]);
301  });
302});