The best way to control Claude Code, Codex and more from any computer or phone
Mirrored from https://github.com/Camo67/t3code.git
Synced Nov 21, 04:45 UTC
| 1 | import { afterEach, expect, it, vi } from "vite-plus/test"; |
| 2 | import { |
| 3 | createDuoControl, |
| 4 | createDuoPinch, |
| 5 | duoFoldState, |
| 6 | duoHoldOrientation, |
| 7 | type DuoCommand, |
| 8 | } from "./duoControl.ts"; |
| 9 | afterEach(() => vi.useRealTimers()); |
| 10 | |
| 11 | it("keeps a failed send visible, including a disconnect while draining queued motion", () => { |
| 12 | const send = vi.fn((_request: { requestId: number; command: DuoCommand }) => false); |
| 13 | const onChange = vi.fn(); |
| 14 | const queue = createDuoControl({ send, onChange }); |
| 15 | queue.enqueue({ control: "angle", value: 40 }); |
| 16 | expect(onChange).toHaveBeenLastCalledWith({ |
| 17 | pending: false, |
| 18 | requested: null, |
| 19 | error: "Device is disconnected.", |
| 20 | }); |
| 21 | send.mockReturnValueOnce(true); |
| 22 | queue.enqueue({ control: "pose", value: "book" }); |
| 23 | queue.enqueue({ control: "angle", value: 60 }); |
| 24 | queue.receive({ requestId: 2, ok: true }); |
| 25 | expect(onChange).toHaveBeenLastCalledWith({ |
| 26 | pending: false, |
| 27 | requested: null, |
| 28 | error: "Device is disconnected.", |
| 29 | }); |
| 30 | }); |
| 31 | |
| 32 | it("coalesces hinge edits behind acknowledgements and lets a preset replace queued edits", () => { |
| 33 | const send = vi.fn((_request: { requestId: number; command: DuoCommand }) => true); |
| 34 | const onChange = vi.fn(); |
| 35 | const queue = createDuoControl({ send, onChange }); |
| 36 | queue.enqueue({ control: "angle", value: 40 }); |
| 37 | queue.enqueue({ control: "angle", value: 50 }); |
| 38 | queue.enqueue({ control: "angle", value: 60 }); |
| 39 | expect(send).toHaveBeenCalledTimes(1); |
| 40 | queue.receive({ requestId: 1, ok: true }); |
| 41 | expect(send.mock.calls[1]?.[0]).toEqual({ |
| 42 | requestId: 2, |
| 43 | command: { control: "angle", value: 60 }, |
| 44 | }); |
| 45 | queue.enqueue({ control: "angle", value: 100 }); |
| 46 | queue.enqueue({ control: "pose", value: "tent" }); |
| 47 | queue.receive({ requestId: 2, ok: true }); |
| 48 | expect(send.mock.calls[2]?.[0]).toEqual({ |
| 49 | requestId: 3, |
| 50 | command: { control: "pose", value: "tent" }, |
| 51 | }); |
| 52 | queue.receive({ requestId: 3, ok: true }); |
| 53 | expect(onChange).toHaveBeenLastCalledWith({ pending: false, requested: null, error: null }); |
| 54 | queue.clear(); |
| 55 | }); |
| 56 | |
| 57 | it("pinches only a hit device, accumulates independently of native readback, clamps and cancels", () => { |
| 58 | let confirmed = 90; |
| 59 | const change = vi.fn(); |
| 60 | const pinch = createDuoPinch({ |
| 61 | angle: () => confirmed, |
| 62 | contains: (x, y) => x > 0.2 && y > 0.2, |
| 63 | change, |
| 64 | }); |
| 65 | expect(pinch.begin(0.1, 0.5)).toBe(false); |
| 66 | pinch.move(1); |
| 67 | expect(change).not.toHaveBeenCalled(); |
| 68 | expect(pinch.begin(0.5, 0.5)).toBe(true); |
| 69 | pinch.move(0.25); |
| 70 | expect(change).toHaveBeenLastCalledWith(120); |
| 71 | confirmed = 100; |
| 72 | pinch.move(0.25); |
| 73 | expect(change).toHaveBeenLastCalledWith(150); |
| 74 | pinch.move(2); |
| 75 | expect(change).toHaveBeenLastCalledWith(180); |
| 76 | pinch.move(-3); |
| 77 | expect(change).toHaveBeenLastCalledWith(0); |
| 78 | pinch.move(NaN); |
| 79 | pinch.end(); |
| 80 | expect(change).toHaveBeenLastCalledWith(null); |
| 81 | const count = change.mock.calls.length; |
| 82 | pinch.move(1); |
| 83 | pinch.end(); |
| 84 | expect(change).toHaveBeenCalledTimes(count); |
| 85 | expect(pinch.active).toBe(false); |
| 86 | }); |
| 87 | |
| 88 | // regression: #16630 fold controls follow the phone's orientation on each screen |
| 89 | it.each([ |
| 90 | [ |
| 91 | "vertical phone, closed", |
| 92 | { screenId: 1, orientation: "portrait", hingeAngle: 0 }, |
| 93 | "closed", |
| 94 | true, |
| 95 | ], |
| 96 | [ |
| 97 | "horizontal phone, closed", |
| 98 | { screenId: 1, orientation: "landscape_right", hingeAngle: 0 }, |
| 99 | "closed", |
| 100 | false, |
| 101 | ], |
| 102 | [ |
| 103 | "vertical phone opened as a book", |
| 104 | { screenId: 3, orientation: "landscape_left", hingeAngle: 180 }, |
| 105 | "open", |
| 106 | true, |
| 107 | ], |
| 108 | [ |
| 109 | "horizontal phone opened as a laptop", |
| 110 | { screenId: 3, orientation: "portrait_upside_down", hingeAngle: 180 }, |
| 111 | "open", |
| 112 | false, |
| 113 | ], |
| 114 | ["half-open book", { screenId: 3, orientation: "landscape_left", hingeAngle: 90 }, "half", true], |
| 115 | ] as const)("reads a %s", (_name, screen, fold, phoneVertical) => { |
| 116 | expect(duoFoldState(screen)).toEqual({ fold, stand: false, phoneVertical, settled: true }); |
| 117 | }); |
| 118 | |
| 119 | it("marks a display handoff unsettled while the cover reports the inner display's orientation", () => { |
| 120 | const handoff = [ |
| 121 | { screenId: 1, orientation: "portrait", hingeAngle: 90 }, |
| 122 | { screenId: 1, orientation: "landscape_left", hingeAngle: 90 }, |
| 123 | { screenId: 3, orientation: "landscape_left", hingeAngle: 90 }, |
| 124 | ] as const; |
| 125 | expect(handoff.map((screen) => duoFoldState(screen).settled)).toEqual([false, false, true]); |
| 126 | expect(duoFoldState({ screenId: 3, orientation: "landscape_left", hingeAngle: 0 }).settled).toBe( |
| 127 | false, |
| 128 | ); |
| 129 | }); |
| 130 | |
| 131 | it("marks native stands so the fold group does not also claim them", () => { |
| 132 | expect( |
| 133 | duoFoldState({ screenId: 3, orientation: "portrait", hingeAngle: 90, hingePose: "laptop" }), |
| 134 | ).toEqual({ fold: "half", stand: true, phoneVertical: false, settled: true }); |
| 135 | }); |
| 136 | |
| 137 | it("falls back like the 3D view when hinge fields are missing", () => { |
| 138 | expect(duoFoldState({ screenId: 1, orientation: "portrait" })).toMatchObject({ |
| 139 | fold: "closed", |
| 140 | phoneVertical: true, |
| 141 | }); |
| 142 | expect(duoFoldState({ orientation: "landscape_left" })).toMatchObject({ |
| 143 | fold: "open", |
| 144 | phoneVertical: true, |
| 145 | }); |
| 146 | }); |
| 147 | |
| 148 | it("rotates a stand back to how the phone was held, in the frame of the display receiving it", () => { |
| 149 | // Recorded from the iPhone Duo simulator: Tent can rest on either display. |
| 150 | // Rotating the inner display to landscape_left, or the cover to portrait, |
| 151 | // leaves a phone that opens and closes vertical. |
| 152 | expect(duoHoldOrientation(true, 3)).toBe("landscape_left"); |
| 153 | expect(duoHoldOrientation(true, 1)).toBe("portrait"); |
| 154 | expect(duoHoldOrientation(false, 1)).toBe("landscape_left"); |
| 155 | expect(duoHoldOrientation(false, 3)).toBe("portrait_upside_down"); |
| 156 | for (const screenId of [1, 3]) |
| 157 | for (const vertical of [true, false]) |
| 158 | expect( |
| 159 | duoFoldState({ screenId, orientation: duoHoldOrientation(vertical, screenId) }) |
| 160 | .phoneVertical, |
| 161 | ).toBe(vertical); |
| 162 | }); |