Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。
import { expect, it, vi } from "vitest";
import { RemoteInputSession } from "../src/client/remote-control/input-session";
import { picturePoint, rotatePicturePoint, rotatePictureDelta, type VideoRotation } from "../src/client/media/video-geometry";
import { InputRoute, type InputIdentity } from "../src/client/remote-control/input-route";
import { matchesRemoteShortcut, remoteInputStateSchema } from "../src/client/remote-control/protocol";
import { RemoteGamepad } from "../src/client/remote-control/gamepad";
it("recognizes only the selected local release chord outside IME composition", () => {
const chord = { code: "F9", ctrlKey: true, altKey: true, metaKey: false, shiftKey: false, isComposing: false };
expect(matchesRemoteShortcut(chord, 9)).toBe(true);
expect(matchesRemoteShortcut(chord, 10)).toBe(false);
for (const changed of [{ ctrlKey: false }, { altKey: false }, { shiftKey: true }, { metaKey: true }, { isComposing: true }]) {
expect(matchesRemoteShortcut({ ...chord, ...changed }, 9)).toBe(false);
}
});
class Channel extends EventTarget {
readyState = "open";
bufferedAmount = 0;
sent: Record<string, unknown>[] = [];
send(value: string) { this.sent.push(JSON.parse(value)); }
close() { this.readyState = "closed"; this.dispatchEvent(new Event("close")); }
receive(value: object) { this.dispatchEvent(new MessageEvent("message", { data: JSON.stringify(value) })); }
}
it("opts into input feedback only when advertised and retains the same grant after a rejected input", () => {
const channel = new Channel();
const session = new RemoteInputSession(channel as unknown as RTCDataChannel, () => {});
const ready = { platform: "windows", mode: "room", state: "ready" };
channel.receive(ready);
expect(channel.sent).toEqual([{ type: "sync" }, { type: "capabilities" }]);
channel.receive({ ...ready, capabilities: ["coPlay", "text"] });
expect(channel.sent).toHaveLength(2);
channel.receive({ ...ready, capabilities: ["coPlay", "text", "inputFeedback"] });
expect(channel.sent.at(-1)).toEqual({ type: "capabilities", inputFeedback: true });
channel.receive({ ...ready, capabilities: ["coPlay", "text", "inputFeedback"] });
expect(channel.sent).toHaveLength(3);
session.request();
const intent = channel.sent.at(-1)?.intent, grant = "f".repeat(64);
const active = { ...ready, state: "active", intent, grant, capabilities: ["inputFeedback"] };
channel.receive(active);
session.input({ type: "key", code: "KeyW", down: true });
const beforeFeedback = channel.sent.length;
channel.receive({ ...active, inputFailed: true });
expect(session.state).toMatchObject({ state: "active", grant, intent, inputFailed: true });
expect(channel.sent).toHaveLength(beforeFeedback);
session.input({ type: "key", code: "KeyD", down: true });
expect(channel.sent.at(-1)).toEqual({ type: "key", code: "KeyD", down: true, grant });
channel.receive(active);
expect(session.state?.inputFailed).toBeUndefined();
expect(session.state?.grant).toBe(grant);
expect(channel.readyState).toBe("open");
session.release();
expect(channel.sent.at(-1)).toEqual({ type: "release", intent });
session.dispose();
});
it("updates text availability without replacing an active keyboard grant", () => {
const channel = new Channel();
const session = new RemoteInputSession(channel as unknown as RTCDataChannel, () => {});
channel.receive({ platform: "windows", mode: "room", state: "ready", coPlay: true, capabilities: ["coPlay"] });
session.request();
const intent = channel.sent.at(-1)?.intent, grant = "d".repeat(64);
const active = { platform: "windows", mode: "room", state: "active", coPlay: true, intent, grant };
for (const enabled of [true, false, true]) {
channel.receive({ ...active, capabilities: enabled ? ["coPlay", "text"] : ["coPlay"] });
const before = channel.sent.length;
session.input({ type: "text", text: "hello" });
expect(channel.sent.length - before).toBe(enabled ? 1 : 0);
expect(session.state?.grant).toBe(grant);
}
session.dispose();
});
it("keeps keyboard control when optional gamepad support fails for the grant", () => {
const channel = new Channel(), changed = vi.fn();
const session = new RemoteInputSession(channel as unknown as RTCDataChannel, changed);
channel.receive({ platform: "windows", mode: "room", state: "ready", coPlay: true, capabilities: ["coPlay", "gamepad"] });
session.request();
const intent = channel.sent.at(-1)?.intent, grant = "e".repeat(64);
const active = { platform: "windows", mode: "room", state: "active", coPlay: true, intent, grant };
const gamepad = { buttons: 0, leftTrigger: 0, rightTrigger: 0, leftX: 0, leftY: 0, rightX: 0, rightY: 0 };
channel.receive({ ...active, capabilities: ["coPlay", "gamepad", "text"] });
session.input({ type: "gamepad", gamepad });
expect(channel.sent.at(-1)).toEqual({ type: "gamepad", gamepad, grant });
channel.receive({ ...active, capabilities: ["coPlay", "text"], reason: "gamepad" });
const before = channel.sent.length;
session.input({ type: "gamepad", gamepad }); session.input({ type: "gamepad-reset" }); session.input({ type: "gamepad-stop" });
expect(channel.sent).toHaveLength(before);
session.input({ type: "key", code: "KeyW", down: false });
session.input({ type: "text", text: "hello" });
session.input({ type: "reset" });
expect(channel.sent.slice(before)).toEqual([
{ type: "key", code: "KeyW", down: false, grant }, { type: "text", text: "hello", grant }, { type: "reset", grant },
]);
expect(session.state?.state).toBe("active"); expect(session.state?.grant).toBe(grant);
session.dispose();
});
it("maps standard gamepads into one negotiated grant and resets on focus loss, unplug and retirement", () => {
const channel = new Channel();
const session = new RemoteInputSession(channel as unknown as RTCDataChannel, () => {});
channel.receive({ platform: "windows", mode: "ask", state: "ready" });
expect(channel.sent.at(-1)).toEqual({ type: "capabilities" });
channel.receive({ platform: "windows", mode: "ask", state: "ready", coPlay: true, capabilities: ["coPlay", "gamepad"] });
session.request();
const intent = channel.sent.at(-1)?.intent;
expect(channel.sent.at(-1)).toEqual({ type: "request", intent });
const grant = "d".repeat(64);
channel.receive({ platform: "windows", mode: "ask", state: "active", intent, grant, coPlay: true, capabilities: ["coPlay", "gamepad"] });
const beforeInput = channel.sent.length;
session.input({ type: "key", code: "KeyW", down: true });
session.input({ type: "button", button: 0, down: true });
expect(channel.sent.slice(beforeInput)).toEqual([
{ type: "key", code: "KeyW", down: true, grant }, { type: "button", button: 0, down: true, grant },
]);
const pad = { index: 1, connected: true, mapping: "standard", axes: [-1, -1, 1, 1],
buttons: Array.from({ length: 17 }, (_, index) => ({ pressed: [0, 1, 4, 8, 9, 10, 12].includes(index), value: index === 6 ? .5 : index === 7 ? 1 : 0 })),
} as unknown as Gamepad;
let pads: (Gamepad | null)[] = [{ ...pad, index: 0, mapping: "" } as Gamepad, pad];
let focused = true;
const page = Object.assign(new EventTarget(), { hidden: false, hasFocus: () => focused });
const frames = new Map<number, FrameRequestCallback>();
let sequence = 0;
const owner = Object.assign(new EventTarget(), { navigator: { getGamepads: () => pads },
requestAnimationFrame: (frame: FrameRequestCallback) => { frames.set(++sequence, frame); return sequence; },
cancelAnimationFrame: (id: number) => frames.delete(id),
});
const tick = (time: number) => {
const entry = frames.entries().next().value!;
frames.delete(entry[0]); entry[1](time);
};
const controller = new RemoteGamepad(event => session.input(event), () => {}, owner as unknown as Window, page as unknown as Document);
try {
tick(0); tick(17);
const report = { type: "gamepad", grant, gamepad: { buttons: 0x1713,
leftTrigger: 128, rightTrigger: 255, leftX: -32768, leftY: -32768, rightX: 32767, rightY: 32767 } };
expect(channel.sent.slice(-2)).toEqual([report, report]);
const beforeSuspend = channel.sent.length;
channel.receive({ platform: "windows", mode: "ask", state: "suspended", intent, grant, coPlay: true, capabilities: ["coPlay", "gamepad"] });
tick(34);
expect(channel.sent).toHaveLength(beforeSuspend);
channel.receive({ platform: "windows", mode: "ask", state: "active", intent, grant, coPlay: true, capabilities: ["coPlay", "gamepad"] });
tick(51);
expect(channel.sent.at(-1)).toEqual(report);
focused = false; owner.dispatchEvent(new Event("blur"));
expect(channel.sent.at(-1)).toEqual({ type: "gamepad-reset", grant });
expect(frames.size).toBe(0);
focused = true; owner.dispatchEvent(new Event("focus")); tick(68);
expect(channel.sent.at(-1)).toEqual(report);
pads = [];
owner.dispatchEvent(Object.assign(new Event("gamepaddisconnected"), { gamepad: pad }));
expect(channel.sent.at(-1)).toEqual({ type: "gamepad-stop", grant });
tick(85);
expect(channel.sent.at(-1)).toEqual({ type: "gamepad-stop", grant });
pads = [pad]; tick(102);
expect(channel.sent.at(-1)).toEqual(report);
// Polling also notices a device removed without a Browser event.
pads = []; tick(119);
expect(channel.sent.at(-1)).toEqual({ type: "gamepad-stop", grant });
page.hidden = true; page.dispatchEvent(new Event("visibilitychange"));
expect(frames.size).toBe(0);
channel.receive({ platform: "windows", mode: "ask", state: "suspended", intent, grant, coPlay: true, capabilities: ["coPlay", "gamepad"] });
} finally {
controller.dispose();
expect(channel.sent.at(-1)).toEqual({ type: "gamepad-stop", grant });
session.dispose();
}
expect(frames.size).toBe(0);
expect(channel.sent.at(-1)).toEqual({ type: "release", intent });
owner.dispatchEvent(new Event("focus"));
expect(frames.size).toBe(0);
});
it.each(["windows", "darwin", "linux"] as const)("keeps the Host platform in local request state (%s)", platform => {
const channel = new Channel();
const session = new RemoteInputSession(channel as unknown as RTCDataChannel, () => {});
session.request();
expect(channel.sent).toEqual([{ type: "sync" }]);
expect(remoteInputStateSchema.safeParse({ mode: "ask", state: "ready" }).success).toBe(false);
expect(remoteInputStateSchema.safeParse({ mode: "ask", state: "ready", platform: "unknown" }).success).toBe(false);
channel.receive({ mode: "ask", state: "ready", platform });
session.request();
expect(session.state).toMatchObject({ state: "pending", platform });
session.release();
expect(session.state).toMatchObject({ state: "ready", platform });
session.dispose();
});
it("reuses the authenticated identity across media routes and syncs after delayed key installation", async () => {
const registered: InputIdentity[] = [];
const route = new InputRoute(() => {});
route.enable(identity => { registered.push(identity); return true; });
const first = new Channel();
route.setUpstream(first as unknown as RTCDataChannel);
first.receive({ ready: true });
const oldEndpoint = route.current!;
const session = new RemoteInputSession(oldEndpoint, () => {});
await vi.waitFor(() => expect(first.sent.filter(p => p.data)).toHaveLength(1));
const oldPacket = first.sent.find(p => p.data)!;
expect(oldPacket.data).not.toContain("sync");
first.receive({ id: registered[0].endpointId, ready: true });
await vi.waitFor(() => expect(first.sent.filter(p => p.data)).toHaveLength(2));
session.dispose();
const next = new Channel();
route.setUpstream(next as unknown as RTCDataChannel);
expect(oldEndpoint.readyState).toBe("closed");
next.receive({ ready: true });
const nextSession = new RemoteInputSession(route.current!, () => {});
await vi.waitFor(() => expect(next.sent.filter(p => p.data)).toHaveLength(1));
const newPacket = next.sent.find(p => p.data)!;
expect(registered).toHaveLength(1);
expect(newPacket.id).toBe(oldPacket.id);
expect(newPacket.epoch).not.toBe(oldPacket.epoch);
const sequence = (p: Record<string, unknown>) => new DataView(Uint8Array.from(atob(p.data as string), c => c.charCodeAt(0)).buffer).getBigUint64(0);
expect(sequence(newPacket)).toBeGreaterThan(sequence(oldPacket));
nextSession.dispose();
route.dispose();
});
it.each([false, true])("retires the current input epoch after late old-branch packets (closed=%s)", async closed => {
const controller = new InputRoute(() => {}), relay = new InputRoute(() => {});
controller.enable(() => true);
const oldUpstream = new Channel(), nextUpstream = new Channel(), upstream = new Channel(), sharedChild = new Channel();
const connection = Object.assign(new EventTarget(), { connectionState: "connected" });
relay.setUpstream(upstream as unknown as RTCDataChannel);
upstream.receive({ ready: true });
relay.attachChild(sharedChild as unknown as RTCDataChannel, connection as unknown as RTCPeerConnection);
try {
controller.setUpstream(oldUpstream as unknown as RTCDataChannel);
oldUpstream.receive({ ready: true });
controller.current!.send(JSON.stringify({ type: "request" }));
controller.current!.send(JSON.stringify({ type: "key", code: "KeyA", down: true }));
await vi.waitFor(() => expect(oldUpstream.sent.filter(packet => packet.data)).toHaveLength(2));
const [oldRequest, lateOldInput] = oldUpstream.sent.filter(packet => packet.data);
controller.setUpstream(nextUpstream as unknown as RTCDataChannel);
nextUpstream.receive({ ready: true });
controller.current!.send(JSON.stringify({ type: "request" }));
controller.current!.send(JSON.stringify({ type: "key", code: "KeyW", down: true }));
await vi.waitFor(() => expect(nextUpstream.sent.filter(packet => packet.data)).toHaveLength(2));
const currentPackets = nextUpstream.sent.filter(packet => packet.data);
expect(currentPackets[0].id).toBe(oldRequest.id);
expect(currentPackets[0].epoch).not.toBe(oldRequest.epoch);
sharedChild.receive(oldRequest);
currentPackets.forEach(packet => sharedChild.receive(packet));
// A longer retired route can reach this shared leg after the current route.
sharedChild.receive(lateOldInput);
if (closed) sharedChild.receive({ id: oldRequest.id, epoch: oldRequest.epoch, closed: true });
connection.connectionState = "disconnected";
connection.dispatchEvent(new Event("connectionstatechange"));
expect(upstream.sent.filter(packet => packet.closed)).toContainEqual({
id: currentPackets[0].id, epoch: currentPackets[0].epoch, closed: true,
});
} finally {
controller.dispose(); relay.dispose();
}
});
it("bounds unclosed child epochs and retires them before input-channel overflow closes", () => {
const route = new InputRoute(() => {}), upstream = new Channel(), child = new Channel();
const connection = Object.assign(new EventTarget(), { connectionState: "connected" });
const envelope = (index: number) => ({ id: (index % 20).toString(16).padStart(32, "0"),
epoch: index.toString(16).padStart(32, "0"), data: "opaque" });
route.setUpstream(upstream as unknown as RTCDataChannel);
upstream.receive({ ready: true });
route.attachChild(child as unknown as RTCDataChannel, connection as unknown as RTCPeerConnection);
// Real close is asynchronous; retirement cannot wait for its close event.
vi.spyOn(child, "close").mockImplementation(() => { child.readyState = "closing"; });
try {
for (let index = 0; index < 128; index++) child.receive(envelope(index));
child.receive(envelope(0)); // Existing tuples still forward at capacity.
child.receive({ ...envelope(0), id: "f".repeat(32) }); // Keep the existing 20-identity bound.
expect(upstream.sent.filter(packet => packet.data)).toHaveLength(129);
expect(child.close).not.toHaveBeenCalled();
child.receive(envelope(128));
expect(child.close).toHaveBeenCalledOnce();
expect(upstream.sent.filter(packet => packet.data)).toHaveLength(129);
expect(upstream.sent.filter(packet => packet.closed)).toHaveLength(128);
for (let index = 0; index < 128; index++) expect(upstream.sent).toContainEqual({
id: envelope(index).id, epoch: envelope(index).epoch, closed: true,
});
const retiredCount = upstream.sent.length;
child.receive(envelope(129));
child.dispatchEvent(new Event("close"));
expect(upstream.sent).toHaveLength(retiredCount);
expect(connection.connectionState).toBe("connected");
} finally {
route.dispose();
}
});
it("binds input to the current request and retires cancelled or replaced grants", () => {
const channel = new Channel();
const session = new RemoteInputSession(channel as unknown as RTCDataChannel, () => {});
const grant = "a".repeat(64);
channel.receive({ platform: "windows", mode: "ask", state: "ready" });
session.request();
const first = channel.sent.at(-1)?.intent;
session.release();
channel.receive({ platform: "windows", mode: "ask", state: "active", intent: first, grant });
expect(session.state?.state).toBe("ready");
expect(channel.sent.at(-1)).toEqual({ type: "release", intent: first });
session.request();
const second = channel.sent.at(-1)?.intent;
channel.receive({ platform: "windows", mode: "ask", state: "ready", intent: first });
expect(session.state?.state).toBe("pending");
channel.receive({ platform: "windows", mode: "ask", state: "active", intent: second, grant });
session.input({ type: "key", code: "KeyW", down: true });
expect(channel.sent.at(-1)).toEqual({ type: "key", code: "KeyW", down: true, grant });
channel.receive({ platform: "windows", mode: "ask", state: "suspended", intent: second, grant });
const count = channel.sent.length;
session.input({ type: "key", code: "KeyD", down: true });
expect(channel.sent).toHaveLength(count);
session.input({ type: "reset" });
expect(channel.sent.at(-1)).toEqual({ type: "reset", grant });
channel.receive({ platform: "windows", mode: "ask", state: "active", intent: second, grant });
session.dispose();
expect(channel.sent.at(-1)).toEqual({ type: "release", intent: second });
channel.receive({ platform: "windows", mode: "ask", state: "active", intent: second, grant });
session.input({ type: "key", code: "KeyW", down: true });
expect(channel.sent.at(-1)).toEqual({ type: "release", intent: second });
expect(channel.readyState).toBe("open"); // Media owns the channel lifetime.
});
it("maps only visible picture pixels when playback has letterboxing", () => {
const video = { videoWidth: 1920, videoHeight: 1080,
style: { objectFit: "contain" }, dataset: {},
getBoundingClientRect: () => ({ left: 100, top: 50, width: 800, height: 600 }),
} as HTMLVideoElement;
expect(picturePoint(video, 500, 350)).toEqual({ x: 0.5, y: 0.5 });
expect(picturePoint(video, 500, 60)).toBeNull();
expect(picturePoint(video, 901, 350)).toBeNull();
video.style.objectFit = "cover";
expect(picturePoint(video, 500, 350)).toEqual({ x: 0.5, y: 0.5 });
// Filling this 4:3 player crops the 16:9 picture, it does not stretch input.
expect(picturePoint(video, 100, 50)?.x).toBeCloseTo(0.125);
expect(picturePoint(video, 900, 650)?.x).toBeCloseTo(0.875);
video.style.objectFit = "fill";
expect(picturePoint(video, 100, 50)).toEqual({ x: 0, y: 0 });
expect(picturePoint(video, 900, 650)).toEqual({ x: 1, y: 1 });
expect(picturePoint(video, 300, 500)).toEqual({ x: 0.25, y: 0.75 });
});
it("ends a pending request when its source becomes unavailable, even before the request reaches the Host", () => {
const channel = new Channel();
const session = new RemoteInputSession(channel as unknown as RTCDataChannel, () => {});
channel.receive({ platform: "windows", mode: "ask", state: "ready" });
session.request();
// Source pause/off can be announced before the Host has seen this intent.
// It still invalidates the whole endpoint, not just an older request.
channel.receive({ platform: "windows", mode: "ask", state: "unavailable" });
expect(session.state?.state).toBe("unavailable");
channel.receive({ platform: "windows", mode: "ask", state: "ready" });
session.request();
channel.receive({ platform: "windows", mode: "off", state: "unavailable", intent: "a".repeat(32) });
expect(session.state?.mode).toBe("off");
session.dispose();
});
it.each([
[0, { x: .25, y: .75 }], [90, { x: .25, y: .25 }],
[180, { x: .75, y: .25 }], [270, { x: .75, y: .75 }],
] as const)("maps rotated picture pixels and relative motion back to source axes (%s°)", (rotation, shown) => {
const video = { videoWidth: 1920, videoHeight: 1080,
style: { objectFit: "fill" }, dataset: { pictureRotation: String(rotation) },
getBoundingClientRect: () => ({ left: 100, top: 50, width: 800, height: 600 }),
} as unknown as HTMLVideoElement;
expect(rotatePicturePoint({ x: .25, y: .75 }, rotation)).toEqual(shown);
expect(picturePoint(video, 100 + shown.x * 800, 50 + shown.y * 600)).toEqual({ x: .25, y: .75 });
expect(picturePoint(video, 99, 50)).toBeNull();
const motion = rotatePictureDelta({ x: .1, y: -.2 }, rotation as VideoRotation);
expect(rotatePictureDelta(motion, rotation, true)).toEqual({ x: .1, y: -.2 });
video.style.objectFit = "contain";
const sideways = rotation === 90 || rotation === 270;
expect(picturePoint(video, sideways ? 101 : 500, sideways ? 350 : 51)).toBeNull();
expect(picturePoint(video, 500, 350)).toEqual({ x: .5, y: .5 });
});
it("sends a control password only in the request and follows the App policy after cancellation", () => {
const channel = new Channel();
const session = new RemoteInputSession(channel as unknown as RTCDataChannel, () => {});
channel.receive({ platform: "windows", state: "ready", mode: "password" });
session.request("temporary-secret");
const intent = channel.sent.at(-1)?.intent;
expect(channel.sent.at(-1)).toMatchObject({ type: "request", password: "temporary-secret" });
channel.receive({ platform: "windows", state: "ready", mode: "password", reason: "password", intent });
expect(session.state?.reason).toBe("password");
session.release();
expect(session.state?.reason).toBeUndefined();
expect(session.state?.mode).toBe("password");
session.request("temporary-secret");
const nextIntent = channel.sent.at(-1)?.intent;
channel.receive({ platform: "windows", state: "active", mode: "password", intent: nextIntent, grant: "a".repeat(64) });
session.release();
expect(session.state?.mode).toBe("password");
expect(channel.sent.at(-1)).toEqual({ type: "release", intent: nextIntent });
channel.receive({ platform: "windows", state: "ready", mode: "ask", intent: nextIntent });
expect(session.state?.mode).toBe("ask");
session.dispose();
});
it("preserves wheel magnitude and fractions across browser units, only within the current grant", () => {
const channel = new Channel();
const session = new RemoteInputSession(channel as unknown as RTCDataChannel, () => {});
channel.receive({ platform: "windows", mode: "ask", state: "ready" });
session.request();
const intent = channel.sent.at(-1)?.intent;
channel.receive({ platform: "windows", mode: "ask", state: "active", intent, grant: "c".repeat(64) });
session.scroll(100, 0);
session.scroll(3, 1);
session.scroll(1, 2);
expect(channel.sent.slice(-3).map(event => event.delta)).toEqual([-120, -120, -120]);
const count = channel.sent.length;
for (let i = 0; i < 4; i++) session.scroll(0.25, 0);
expect(channel.sent).toHaveLength(count + 1);
expect(channel.sent.at(-1)?.delta).toBe(-1);
session.scroll(-10_000, 0);
expect(channel.sent.at(-1)?.delta).toBe(1200);
channel.receive({ platform: "windows", mode: "ask", state: "suspended", intent, grant: "c".repeat(64) });
const suspendedCount = channel.sent.length;
session.scroll(100, 0);
expect(channel.sent).toHaveLength(suspendedCount);
channel.receive({ platform: "windows", mode: "ask", state: "active", intent, grant: "c".repeat(64) });
session.scroll(0.75, 0);
expect(channel.sent).toHaveLength(suspendedCount);
session.dispose();
});
it("flushes coalesced motion before buttons and discards it when control ends", () => {
vi.useFakeTimers();
const channel = new Channel();
const session = new RemoteInputSession(channel as unknown as RTCDataChannel, () => {});
const grant = "b".repeat(64);
try {
channel.receive({ platform: "windows", mode: "ask", state: "ready" });
session.request();
const intent = channel.sent.at(-1)?.intent;
channel.receive({ platform: "windows", mode: "ask", state: "active", intent, grant });
session.input({ type: "move", x: 0.2, y: 0.3 });
session.input({ type: "move", x: 0.7, y: 0.8 });
session.input({ type: "button", button: 0, down: false });
expect(channel.sent.slice(-2)).toEqual([
{ type: "move", x: 0.7, y: 0.8, grant },
{ type: "button", button: 0, down: false, grant },
]);
expect(vi.getTimerCount()).toBe(0);
session.input({ type: "relative", dx: 3, dy: -2 });
session.input({ type: "relative", dx: 4, dy: 5 });
vi.advanceTimersByTime(4); // Input does not depend on a rendered frame.
expect(channel.sent.at(-1)).toEqual({ type: "relative", dx: 7, dy: 3, grant });
session.input({ type: "move", x: 0.9, y: 0.1 });
const count = channel.sent.length;
channel.receive({ platform: "windows", mode: "ask", state: "ready", intent });
expect(vi.getTimerCount()).toBe(0);
expect(channel.sent).toHaveLength(count);
} finally {
session.dispose();
vi.useRealTimers();
}
});
it("sends idle motion immediately and only batches samples inside the send interval", () => {
vi.useFakeTimers();
const channel = new Channel();
const session = new RemoteInputSession(channel as unknown as RTCDataChannel, () => {});
const grant = "b".repeat(64);
try {
channel.receive({ platform: "windows", mode: "ask", state: "ready" });
session.request();
const intent = channel.sent.at(-1)?.intent;
channel.receive({ platform: "windows", mode: "ask", state: "active", intent, grant });
const before = channel.sent.length;
session.input({ type: "move", x: .1, y: .2 });
expect(channel.sent.slice(before)).toEqual([{ type: "move", x: .1, y: .2, grant }]);
expect(vi.getTimerCount()).toBe(0);
vi.advanceTimersByTime(1);
session.input({ type: "move", x: .3, y: .4 });
vi.advanceTimersByTime(1);
session.input({ type: "move", x: .5, y: .6 });
expect(channel.sent).toHaveLength(before + 1);
vi.advanceTimersByTime(2);
expect(channel.sent.slice(before)).toEqual([
{ type: "move", x: .1, y: .2, grant }, { type: "move", x: .5, y: .6, grant },
]);
expect(vi.getTimerCount()).toBe(0);
vi.advanceTimersByTime(12);
session.input({ type: "relative", dx: 2, dy: -3 });
expect(channel.sent.at(-1)).toEqual({ type: "relative", dx: 2, dy: -3, grant });
expect(vi.getTimerCount()).toBe(0);
} finally {
session.dispose();
vi.useRealTimers();
}
});
it("keeps queued motion and wheel precision across updates to the same active grant", () => {
vi.useFakeTimers();
const channel = new Channel();
const session = new RemoteInputSession(channel as unknown as RTCDataChannel, () => {});
const grant = "b".repeat(64);
try {
channel.receive({ platform: "windows", mode: "room", state: "ready", coPlay: true, capabilities: ["coPlay", "text"] });
session.request();
const intent = channel.sent.at(-1)?.intent;
const active = { platform: "windows", mode: "room", state: "active", intent, grant, coPlay: true };
channel.receive({ ...active, capabilities: ["coPlay", "text"] });
session.input({ type: "move", x: .1, y: .2 });
session.input({ type: "move", x: .3, y: .4 });
session.scroll(.5, 0);
// Another controller joining disables committed text, not this player's motion.
channel.receive({ ...active, capabilities: ["coPlay"] });
vi.advanceTimersByTime(4);
expect(channel.sent.at(-1)).toEqual({ type: "move", x: .3, y: .4, grant });
session.scroll(.5, 0);
expect(channel.sent.at(-1)).toEqual({ type: "wheel", delta: -1, grant });
// Suspension still discards motion and precision belonging to the old activity.
session.input({ type: "move", x: .9, y: .9 });
const beforeSuspend = channel.sent.length;
channel.receive({ ...active, state: "suspended", capabilities: ["coPlay"] });
vi.advanceTimersByTime(4);
expect(channel.sent).toHaveLength(beforeSuspend);
channel.receive({ ...active, capabilities: ["coPlay"] });
session.scroll(.75, 0);
expect(channel.sent).toHaveLength(beforeSuspend);
} finally {
session.dispose();
vi.useRealTimers();
}
});