@q9labsai/chalk-react-native 5.0.1 → 5.2.0

package/src/sheets/people-chat/people-chat-model.test.ts

@@ -1,98 +0,0 @@
-import type { ChatMessage, Participant, PendingChatSend } from "@q9labsai/chalk-client";
-import { describe, expect, it } from "vitest";
-import { groupMessages, messageSummary, mimeTypeOf, stagingError } from "./chat-model";
-import { nextHandOrder, peopleRows } from "./people-model";
-
-function person(participantId: string, displayName: string, handRaised = false): Participant {
-  return {
-    participantId,
-    displayName,
-    role: "participant",
-    eligibleRoles: [],
-    capabilities: [],
-    handRaised,
-    media: { microphone: "active", camera: "inactive", screenShare: "inactive" },
-    presence: { state: "connected", speaking: false, activeSpeaker: false },
-  } as const satisfies Participant;
-}
-
-function message(messageId: string, participantId: string, text: string): ChatMessage {
-  return { messageId, clientMessageId: `c-${messageId}`, sequence: messageId, participantId, displayName: participantId, text, createdAt: "2026-10-18T10:00:00Z", attachments: [] };
-}
-
-const photo = { attachmentId: "a", fileName: "IMG_0412.jpg", mimeType: "image/jpeg", byteLength: 10 } as const;
-const pdf = { attachmentId: "b", fileName: "Q4 plan.pdf", mimeType: "application/pdf", byteLength: 10 } as const;
-
-describe("peopleRows", () => {
-  const roster = [person("me", "Hasan"), person("n", "Nora", true), person("s", "Sam", true), person("k", "Kai")];
-
-  it("puts the raised-hands queue in the order hands went up, above everyone, once two hands are up", () => {
-    const rows = peopleRows({ roster, waiting: [], handOrder: ["s", "n"], query: "" });
-    expect(rows.map((row) => row.key)).toEqual(["section.hands", "hand.s", "hand.n", "section.call", "person.me", "person.n", "person.s", "person.k"]);
-    expect(rows.find((row) => row.key === "person.n")).toMatchObject({ handNumber: 2 });
-  });
-
-  it("numbers nothing and shows no queue for a single raised hand", () => {
-    const rows = peopleRows({ roster: [person("me", "Hasan"), person("n", "Nora", true)], waiting: [], handOrder: ["n"], query: "" });
-    expect(rows.map((row) => row.kind)).toEqual(["person", "person"]);
-    expect(rows[1]).toMatchObject({ handNumber: null });
-  });
-
-  it("filters by name and says when no one matches", () => {
-    expect(peopleRows({ roster, waiting: [], handOrder: ["s", "n"], query: "no" }).map((row) => row.key)).toEqual(["person.n"]);
-    expect(peopleRows({ roster, waiting: [], handOrder: [], query: "zed" })).toEqual([{ kind: "none", key: "none", query: "zed" }]);
-  });
-
-  it("keeps the first-raised hand at the front as others raise and lower", () => {
-    const first = nextHandOrder([], [person("n", "Nora", true)]);
-    const second = nextHandOrder(first, [person("n", "Nora", true), person("s", "Sam", true)]);
-    expect(second).toEqual(["n", "s"]);
-    expect(nextHandOrder(second, [person("n", "Nora"), person("s", "Sam", true)])).toEqual(["s"]);
-    expect(nextHandOrder(second, [person("n", "Nora", true), person("s", "Sam", true)])).toBe(second);
-  });
-});
-
-describe("groupMessages", () => {
-  const self = { participantId: "me", displayName: "Hasan" };
-
-  it("groups consecutive messages from one person and marks yours", () => {
-    const groups = groupMessages([message("1", "n", "Hi"), message("2", "n", "Ready?"), message("3", "me", "Yes")], [], self, new Set());
-    expect(groups.map((group) => [group.participantId, group.mine, group.entries.length])).toEqual([
-      ["n", false, 2],
-      ["me", true, 1],
-    ]);
-  });
-
-  it("adds your waiting sends after the confirmed messages and hides ones you retried", () => {
-    const failed: PendingChatSend = { clientMessageId: "p1", text: "Lost", attachments: [], status: "failed", error: null };
-    const sending: PendingChatSend = { clientMessageId: "p2", text: "Again", attachments: [], status: "sending", error: null };
-    const groups = groupMessages([message("1", "me", "First")], [failed, sending], self, new Set(["p1"]));
-    expect(groups).toHaveLength(1);
-    expect(groups[0]?.entries.map((entry) => [entry.text, entry.state])).toEqual([
-      ["First", "sent"],
-      ["Again", "sending"],
-    ]);
-  });
-});
-
-describe("chat files", () => {
-  it("says what a message with only attachments sent", () => {
-    expect(messageSummary("", [photo])).toBe("Sent a photo");
-    expect(messageSummary("", [photo, photo])).toBe("Sent 2 photos");
-    expect(messageSummary("", [photo, pdf])).toBe("Sent 2 files");
-    expect(messageSummary("Look", [photo])).toBe("Look");
-  });
-
-  it("refuses unknown types, files over 25 MB and a sixth file", () => {
-    expect(stagingError({ name: "Demo.mov", mimeType: "video/quicktime", size: 10 }, 0)).toBe("Can’t send .mov files");
-    expect(stagingError({ name: "Site photos.pdf", mimeType: "application/pdf", size: 31 * 1024 * 1024 }, 0)).toBe("Over the 25 MB limit");
-    expect(stagingError({ name: "Agenda.pdf", mimeType: "application/pdf", size: 10 }, 5)).toBe("Only 5 files per message");
-    expect(stagingError({ name: "Agenda.pdf", mimeType: "application/pdf", size: 10 }, 4)).toBeNull();
-  });
-
-  it("falls back to the extension when the picker reports no type", () => {
-    expect(mimeTypeOf("Budget 2027.XLSX", undefined)).toBe("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
-    expect(mimeTypeOf("notes", undefined)).toBe("application/octet-stream");
-    expect(mimeTypeOf("a.png", "image/png")).toBe("image/png");
-  });
-});

package/src/space-client/whiteboard-watchdog.test.ts

@@ -1,23 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import type { SpaceClientPlatform } from "@q9labsai/chalk-client/effect";
-const mocks = vi.hoisted(() => ({ platform: vi.fn(), whiteboard: vi.fn() }));
-vi.mock("react-native", () => ({ AppState: { currentState: "active", addEventListener: vi.fn(() => ({ remove: vi.fn() })) } }));
-vi.mock("@cloudflare/react-native-webrtc", () => ({ RTCPeerConnection: vi.fn(), mediaDevices: {} }));
-vi.mock("@q9labsai/chalk-client/effect", () => ({ createSpaceClientForPlatform: mocks.platform }));
-vi.mock("@q9labsai/chalk-client", async (original) => ({ ...(await original<typeof import("@q9labsai/chalk-client")>()), createChalkWhiteboardV1Client: mocks.whiteboard }));
-import { createNativeSpaceClient } from "./create-native-space-client";
-describe("native whiteboard watchdog adapter", () => {
-  it("passes the shared core's replacement recorder without a journey option", () => {
-    createNativeSpaceClient({
-      space: "test",
-      getAccess: async () => {
-        throw new Error("unused");
-      },
-    });
-    const platform: SpaceClientPlatform | undefined = mocks.platform.mock.calls[0]?.[1];
-    const onWatchdogReplacement = vi.fn();
-    platform?.dependencies?.createWhiteboardClient?.({ token: async () => "unused", onSummary: vi.fn(), onWatchdogReplacement });
-    expect(mocks.whiteboard).toHaveBeenCalledOnce();
-    expect(mocks.whiteboard.mock.calls[0]?.[0].onWatchdogReplacement).toBe(onWatchdogReplacement);
-  });
-});

package/src/stage/layout.test.ts

@@ -1,77 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { nextStageOrder, stageLayout, type StageInput, type StageItem } from "./layout";
-
-// The D1 portrait stage from `frameRegions`. Expected frames come from the mockup's own `layout()`.
-const stage = { x: 8, y: 111, width: 377, height: 625 };
-const ids = (count: number) => Array.from({ length: count }, (_, index) => String(index));
-const input = (overrides: Partial<StageInput>): StageInput => ({ stage, portrait: true, layout: "spotlight", order: ids(6), spot: "1", pinned: null, content: null, ...overrides });
-const rounded = (item: StageItem) => [item.frame.x, item.frame.y, item.frame.width, item.frame.height].map((value) => Math.round(value * 10) / 10);
-
-describe("stageLayout", () => {
-  it("floats you over the other person when two are in the call (P2)", () => {
-    const [main, you] = stageLayout(input({ order: ids(2) }));
-    expect(main).toMatchObject({ kind: "person", id: "1", frame: stage });
-    expect(you).toMatchObject({ kind: "person", id: "0", float: true });
-    if (you) expect(rounded(you)).toEqual([277, 123, 96, 128]);
-  });
-
-  it("puts the speaker big and everyone else in justified rows below (P3, G1)", () => {
-    const items = stageLayout(input({}));
-    expect(items.map((item) => (item.kind === "person" ? item.id : item.kind))).toEqual(["1", "0", "2", "3", "4", "5"]);
-    expect(items[0]).toMatchObject({ big: true });
-    expect(items.map(rounded)).toEqual([
-      [8, 111, 377, 429],
-      [8, 548, 120.3, 90],
-      [136.3, 548, 120.3, 90],
-      [264.7, 548, 120.3, 90],
-      [8, 646, 184.5, 90],
-      [200.5, 646, 184.5, 90],
-    ]);
-  });
-
-  it("keeps a pinned person big over the speaker", () => {
-    expect(stageLayout(input({ pinned: "4" }))[0]).toMatchObject({ kind: "person", id: "4", big: true });
-  });
-
-  it("fills the stage with 24 tiles in Grid (P4, G2)", () => {
-    const items = stageLayout(input({ layout: "grid", order: ids(24) }));
-    expect(items).toHaveLength(24);
-    expect(items.every((item) => item.kind === "person" && Math.round(item.frame.width * 10) / 10 === 88.3)).toBe(true);
-  });
-
-  it("stands a phone share at full height with people beside it (C2, S4)", () => {
-    const [share, ...rest] = stageLayout(input({ content: { kind: "screen", aspect: 9 / 16 } }));
-    expect(share).toMatchObject({ kind: "content", mini: false });
-    if (share) expect(rounded(share)).toEqual([8, 111, 249, 625]);
-    expect(rest.every((item) => item.frame.x === 265 && item.frame.width === 120)).toBe(true);
-  });
-
-  it("gives a shared board the stage with one row of people and a +N tile (C3)", () => {
-    const items = stageLayout(input({ content: { kind: "board", aspect: null } }));
-    expect(items[0] && rounded(items[0])).toEqual([8, 111, 377, 511]);
-    expect(items.at(-1)).toMatchObject({ kind: "more", count: 3 });
-  });
-
-  it("shows the share as a double tile in Grid", () => {
-    const [share] = stageLayout(input({ layout: "grid", content: { kind: "screen", aspect: 16 / 9 } }));
-    expect(share).toMatchObject({ kind: "content", mini: true });
-  });
-});
-
-describe("nextStageOrder", () => {
-  it("swaps a new speaker with the person in the spotlight, so only those two tiles move", () => {
-    const start = nextStageOrder({ order: [], spot: null }, ["you", "a", "b", "c"], "you", null);
-    expect(start).toEqual({ order: ["you", "a", "b", "c"], spot: "a" });
-    expect(nextStageOrder(start, ["you", "a", "b", "c"], "you", "c")).toEqual({ order: ["you", "c", "b", "a"], spot: "c" });
-  });
-
-  it("ignores your own speech and keeps the same object when nothing changes", () => {
-    const start = nextStageOrder({ order: [], spot: null }, ["you", "a", "b"], "you", null);
-    expect(nextStageOrder(start, ["you", "a", "b"], "you", "you")).toBe(start);
-  });
-
-  it("drops leavers, appends newcomers and moves the spotlight off someone who left", () => {
-    const start = { order: ["you", "a", "b"], spot: "a" };
-    expect(nextStageOrder(start, ["you", "b", "d"], "you", null)).toEqual({ order: ["you", "b", "d"], spot: "b" });
-  });
-});

package/src/status/call-screen.test.ts

@@ -1,42 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { callScreen } from "./call-screen";
-
-type ConnectionOptions = { readonly code?: "episode.ended" | "access.invalid"; readonly episodeEnded?: boolean; readonly removedByHost?: boolean };
-
-const connection = (status: Parameters<typeof callScreen>[0]["status"], { code, episodeEnded = false, removedByHost = false }: ConnectionOptions = {}) => ({
-  status,
-  episode: null,
-  lastError: code ? { code, recoverable: false, message: "" } : null,
-  episodeEnded,
-  removedByHost,
-});
-
-describe("callScreen", () => {
-  it("covers the call while it joins or reconnects", () => {
-    expect(callScreen(connection("joining"), false)).toEqual({ kind: "joining" });
-    expect(callScreen(connection("reconnecting"), false)).toEqual({ kind: "reconnecting" });
-    expect(callScreen(connection("live"), false)).toEqual({ kind: "call" });
-  });
-
-  it("shows the person's own leave as left, even when the leave call failed", () => {
-    expect(callScreen(connection("left"), true)).toEqual({ kind: "status", outcome: "left" });
-    expect(callScreen(connection("left", { removedByHost: true }), true)).toEqual({ kind: "status", outcome: "left" });
-  });
-
-  it("shows removed only when the server reported a host removal", () => {
-    expect(callScreen(connection("left", { removedByHost: true }), false)).toEqual({ kind: "status", outcome: "removed" });
-  });
-
-  it("shows a neutral exit for any other exit nobody asked for", () => {
-    expect(callScreen(connection("left"), false)).toEqual({ kind: "status", outcome: "exited" });
-  });
-
-  it("shows the call ended when the Episode ends while the person is in it", () => {
-    expect(callScreen(connection("left", { episodeEnded: true }), false)).toEqual({ kind: "status", outcome: "ended" });
-    expect(callScreen(connection("left", { code: "episode.ended" }), false)).toEqual({ kind: "status", outcome: "ended" });
-  });
-
-  it("shows a failure as failed", () => {
-    expect(callScreen(connection("failed", { code: "access.invalid" }), false)).toEqual({ kind: "status", outcome: "failed" });
-  });
-});

package/src/toasts/notices.test.ts

@@ -1,92 +0,0 @@
-import type { Capability, Participant, SpaceSnapshot } from "@q9labsai/chalk-client";
-import { describe, expect, it } from "vitest";
-import { callNotices } from "./notices";
-
-const HOST: readonly Capability[] = ["endEpisode", "muteOthers"];
-
-function person(participantId: string, displayName: string, capabilities: readonly Capability[] = [], screenShare: "active" | "inactive" = "inactive"): Participant {
-  return {
-    participantId,
-    displayName,
-    role: capabilities.length ? "host" : "guest",
-    eligibleRoles: [],
-    capabilities,
-    handRaised: false,
-    media: { microphone: "inactive", camera: "inactive", screenShare },
-    presence: { state: "connected", speaking: false, activeSpeaker: false },
-  };
-}
-
-type Shape = {
-  readonly status?: SpaceSnapshot["connection"]["status"];
-  readonly roster?: readonly Participant[];
-  readonly selfCapabilities?: readonly Capability[];
-  readonly microphone?: "enabled" | "disabled";
-  readonly requests?: SpaceSnapshot["media"]["incomingRequests"];
-  readonly recording?: "recording" | "stopped";
-};
-
-function snapshot({ status = "live", roster = [], selfCapabilities = [], microphone = "disabled", requests = [], recording }: Shape): SpaceSnapshot {
-  const local = (state: "enabled" | "disabled") => ({ source: "microphone" as const, state, track: null });
-  return {
-    connection: { status, episode: null, lastError: null },
-    self: { participantId: "me", displayName: "Hasan", role: null, capabilities: selfCapabilities, handRaised: false, can: (capability) => selfCapabilities.includes(capability) },
-    participants: { roster: [person("me", "Hasan", selfCapabilities), ...roster], admissionQueue: [] },
-    media: {
-      devices: { microphones: [], cameras: [], speakers: [] },
-      selection: { microphone: null, camera: null, speaker: null },
-      local: { microphone: local(microphone), camera: { ...local("disabled"), source: "camera" }, screen: { ...local("disabled"), source: "screen" } },
-      remote: [],
-      screenShare: { ...local("disabled"), source: "screen" },
-      incomingRequests: requests,
-    },
-    chat: { status: "ready", messages: [], pendingSends: [], readReceipts: [], unreadCount: 0, pagination: { cursor: null, hasOlder: false, historyTruncated: false }, lastError: null },
-    reactions: { active: [] },
-    recording: { current: recording ? { recordingId: "r1", status: recording, failureCode: null } : null },
-    whiteboard: { open: false, engine: { status: "unsubscribed", sceneId: null, revision: null, presenting: false, error: null } },
-    offline: { pending: [], decisionNeeded: false, policy: "ask" },
-  };
-}
-
-const nora = person("nora", "Nora Lindqvist", HOST);
-const sam = person("sam", "Sam Okafor");
-
-describe("callNotices", () => {
-  it("says nothing while the roster arrives on join or empties on leave", () => {
-    expect(callNotices(snapshot({ status: "joining" }), snapshot({ roster: [nora, sam] }), false)).toEqual([]);
-    expect(callNotices(snapshot({ roster: [nora, sam] }), snapshot({ status: "left" }), false)).toEqual([]);
-  });
-
-  it("names people who join and leave, but never you", () => {
-    expect(callNotices(snapshot({ roster: [nora] }), snapshot({ roster: [nora, sam] }), false)).toEqual([{ kind: "joined", name: "Sam Okafor" }]);
-    expect(callNotices(snapshot({ roster: [nora, sam] }), snapshot({ roster: [nora] }), false)).toEqual([{ kind: "left", name: "Sam Okafor" }]);
-  });
-
-  it("tells you the host left and you're the host now, instead of a plain leave", () => {
-    const notices = callNotices(snapshot({ roster: [nora, sam] }), snapshot({ roster: [sam], selfCapabilities: HOST }), false);
-    expect(notices).toEqual([{ kind: "newHost", previousHost: "Nora" }]);
-  });
-
-  it("reports a host mute only when you didn't mute yourself", () => {
-    const before = snapshot({ roster: [nora, sam], microphone: "enabled" });
-    const after = snapshot({ roster: [nora, sam], microphone: "disabled" });
-    expect(callNotices(before, after, false)).toEqual([{ kind: "mutedByHost", by: "Nora" }]);
-    expect(callNotices(before, after, true)).toEqual([]);
-  });
-
-  it("reports each new request to unmute once", () => {
-    const request = { requestId: "q1", kind: "unmute" as const, actorParticipantId: "nora", actorDisplayName: "Nora Lindqvist", expiresAt: "2026-10-18T12:00:00Z" };
-    expect(callNotices(snapshot({ roster: [nora] }), snapshot({ roster: [nora], requests: [request] }), false)).toEqual([{ kind: "mediaRequest", request }]);
-    expect(callNotices(snapshot({ roster: [nora], requests: [request] }), snapshot({ roster: [nora], requests: [request] }), false)).toEqual([]);
-  });
-
-  it("reports when someone else stops sharing", () => {
-    const sharing = person("sam", "Sam Okafor", [], "active");
-    expect(callNotices(snapshot({ roster: [sharing] }), snapshot({ roster: [sam] }), false)).toEqual([{ kind: "shareStopped", name: "Sam" }]);
-  });
-
-  it("reports recording starting and stopping", () => {
-    expect(callNotices(snapshot({}), snapshot({ recording: "recording" }), false)).toEqual([{ kind: "recordingStarted" }]);
-    expect(callNotices(snapshot({ recording: "recording" }), snapshot({ recording: "stopped" }), false)).toEqual([{ kind: "recordingStopped" }]);
-  });
-});

package/src/whiteboard/embedded-whiteboard-viewport.test.ts

@@ -1,13 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { createEmbeddedWhiteboardViewport } from "./embedded-whiteboard-viewport";
-
-describe("native embedded whiteboard viewport", () => {
-  it("uses the measured Board rectangle rather than the device window", () => {
-    expect(createEmbeddedWhiteboardViewport(640, 420, 2)).toEqual({ width: 640, height: 420, scale: 2 });
-  });
-
-  it("waits for a usable layout", () => {
-    expect(createEmbeddedWhiteboardViewport(0, 420, 2)).toBeNull();
-  });
-});