@marktiderman/genesis-chat 0.1.0 → 0.2.0

package/src/native/__tests__/inbox-screen.test.tsx

@@ -0,0 +1,48 @@
+// @vitest-environment happy-dom
+// @feat:chat
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { cleanup, render, waitFor } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { GenesisModulesProvider, NativeToastProvider } from "@marktiderman/genesis-ui-native/components";
+import type { ChatClient } from "../../core/client";
+import { ChatProvider } from "../../react/index";
+import { ChatNativeProvider } from "../context";
+import { ChatInboxScreen } from "../inbox-screen";
+
+vi.mock("react-native", async (original) => ({ ...(await original<object>()), useWindowDimensions: () => ({ width: 390, height: 844, scale: 3, fontScale: 1 }) }));
+
+afterEach(cleanup);
+
+const ME = "11111111-1111-4111-8111-111111111111";
+
+function fakeClient() {
+  const inbox = vi.fn(async (_opts: Record<string, unknown>) => []);
+  const client = {
+    inbox,
+    subscribeInbox: vi.fn(() => ({ unsubscribe: vi.fn() })),
+    unreadTotal: vi.fn(async () => 0),
+  } as unknown as ChatClient;
+  return { client, inbox };
+}
+
+describe("ChatInboxScreen", () => {
+  it("passes kinds and excludeKinds to the inbox, so an app can keep support tickets out of Messages", async () => {
+    const { client, inbox } = fakeClient();
+    const qc = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+    render(
+      <QueryClientProvider client={qc}>
+        <GenesisModulesProvider modules={{}}>
+          <ChatProvider client={client} userId={ME}>
+            <NativeToastProvider>
+              <ChatNativeProvider>
+                <ChatInboxScreen onOpen={() => {}} excludeKinds={["support"]} kinds={["direct", "group"]} />
+              </ChatNativeProvider>
+            </NativeToastProvider>
+          </ChatProvider>
+        </GenesisModulesProvider>
+      </QueryClientProvider>,
+    );
+    await waitFor(() => expect(inbox).toHaveBeenCalled());
+    expect(inbox.mock.calls[0]![0]).toMatchObject({ kinds: ["direct", "group"], excludeKinds: ["support"] });
+  });
+});

package/src/native/__tests__/message-bubble.test.tsx

@@ -0,0 +1,127 @@
+// @vitest-environment happy-dom
+// @feat:chat
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { ChatAttachment, ChatMessage, PendingMessage } from "../../core/types";
+import { ChatNativeProvider } from "../context";
+import { MessageBubble } from "../message-bubble";
+import type { ChatNativeModules } from "../modules";
+import { act } from "@testing-library/react";
+import { invertedRows, type ThreadRow } from "../rows";
+
+// The shared React Native shim has no useWindowDimensions; attachments size pictures by it.
+vi.mock("react-native", async (original) => ({ ...(await original<object>()), useWindowDimensions: () => ({ width: 390, height: 844, scale: 3, fontScale: 1 }) }));
+
+afterEach(cleanup);
+
+const ME = "11111111-1111-4111-8111-111111111111";
+
+function failedRow(files: PendingMessage["files"]): Extract<ThreadRow, { type: "message" }> {
+  const pending: PendingMessage = {
+    clientId: "c1",
+    input: { conversationId: "conv", clientId: "c1", body: "" },
+    senderId: ME,
+    createdAt: "2026-10-25T10:00:00Z",
+    status: "failed",
+    error: "Attach the file again to send",
+    files,
+  };
+  return invertedRows([{ type: "pending", pending }], { me: ME, group: false }).find((r) => r.type === "message") as Extract<ThreadRow, { type: "message" }>;
+}
+
+function show(row: Extract<ThreadRow, { type: "message" }>, handlers: Partial<Parameters<typeof MessageBubble>[0]> = {}) {
+  render(<MessageBubble row={row} me={ME} urls={{}} group={false} reducedMotion testID="b" {...handlers} />);
+}
+
+describe("a failed message", () => {
+  it("whose file was lost offers Attach again, not Retry, with the files it lost", () => {
+    const onReattach = vi.fn();
+    const files = [{ name: "photo.png", contentType: "image/png", kind: "image", lost: true }];
+    show(failedRow(files), { onReattach, onRetry: vi.fn(), onDiscard: vi.fn() });
+    expect(screen.getByTestId("b-failed").textContent).toBe("Attach the file again to send");
+    expect(screen.queryByTestId("b-retry")).toBeNull();
+    fireEvent.click(screen.getByTestId("b-reattach"));
+    expect(onReattach).toHaveBeenCalledWith("c1", files);
+    expect(screen.getByTestId("b-discard")).toBeTruthy();
+  });
+
+  it("whose files are all still there offers Retry", () => {
+    const onRetry = vi.fn();
+    show(failedRow([{ name: "photo.jpg", contentType: "image/jpeg", kind: "image" }]), { onRetry, onReattach: vi.fn() });
+    expect(screen.queryByTestId("b-reattach")).toBeNull();
+    fireEvent.click(screen.getByTestId("b-retry"));
+    expect(onRetry).toHaveBeenCalledWith("c1");
+  });
+
+  it("draws a pending voice note from PendingMessage.files, with its duration", () => {
+    show(failedRow([{ name: "voice.m4a", contentType: "audio/mp4", kind: "voice", meta: { durationMs: 9000, waveform: [10, 50] } }]));
+    expect(screen.getByTestId("b-voice-0")).toBeTruthy();
+  });
+});
+
+function attachment(id: string, kind: "image" | "voice", path: string): ChatAttachment {
+  return {
+    id, messageId: "m1", position: 0, kind, ref: {}, provider: "storage", path, providerId: null, playbackId: null, url: null, status: "ready",
+    name: kind === "image" ? `${id}.jpg` : "voice.m4a", mime: null, bytes: null, width: 10, height: 10, durationMs: 4000, waveform: [10, 60],
+    posterPath: null, thumbhash: null, transcript: null, transcriptStatus: null,
+  } as ChatAttachment;
+}
+
+function messageRow(attachments: ChatAttachment[]): Extract<ThreadRow, { type: "message" }> {
+  const message = {
+    id: "m1", conversationId: "conv", seq: 1, clientId: "cm1", senderId: "22222222-2222-4222-8222-222222222222", senderRole: "member", kind: "text",
+    body: "look", mentions: [], replyToId: null, threadRootId: null, threadCount: 0, threadLastAt: null, topic: null, visibility: "everyone",
+    silent: false, meta: {}, createdAt: "2026-10-25T10:00:00Z", editedAt: null, deletedAt: null, attachments, reactions: [],
+  } as unknown as ChatMessage;
+  return invertedRows([{ type: "message", message }], { me: ME, group: false }).find((r) => r.type === "message") as Extract<ThreadRow, { type: "message" }>;
+}
+
+function fakeAudio() {
+  const player = { play: vi.fn(), pause: vi.fn(), seekTo: vi.fn(async () => undefined), setPlaybackRate: vi.fn() };
+  const audio = {
+    useAudioRecorder: vi.fn(),
+    useAudioPlayer: vi.fn(() => player),
+    useAudioPlayerStatus: vi.fn(() => ({ currentTime: 0, duration: 4, playing: false, didJustFinish: false, isLoaded: true, playbackRate: 1 })),
+    RecordingPresets: { HIGH_QUALITY: {} },
+    requestRecordingPermissionsAsync: vi.fn(),
+    setAudioModeAsync: vi.fn(),
+  };
+  return { audio: audio as unknown as ChatNativeModules["audio"], player };
+}
+
+const fireA11y = (el: HTMLElement, name: string) => act(() => void el.dispatchEvent(new CustomEvent("accessibilityaction", { detail: name })));
+
+describe("a bubble with media, for VoiceOver", () => {
+  it("carries the hidden controls as its own actions: play and speed for a voice note, open for each photo", () => {
+    const { audio, player } = fakeAudio();
+    const onOpenImage = vi.fn();
+    const urls = { "p/voice.m4a": "https://x/voice.m4a", "p/a.jpg": "https://x/a.jpg", "p/b.jpg": "https://x/b.jpg" };
+    render(
+      <ChatNativeProvider modules={{ audio }}>
+        <MessageBubble
+          row={messageRow([attachment("v", "voice", "p/voice.m4a"), attachment("a", "image", "p/a.jpg"), attachment("b", "image", "p/b.jpg")])}
+          me={ME}
+          urls={urls}
+          group={false}
+          reducedMotion
+          onOpenImage={onOpenImage}
+          onReply={vi.fn()}
+          testID="b"
+        />
+      </ChatNativeProvider>,
+    );
+    const bubble = screen.getByTestId("b-bubble");
+    expect(bubble.getAttribute("data-a11y-actions")).toBe("voice-0,voice-rate-0,photo-0,photo-1,reply");
+    fireA11y(bubble, "photo-1");
+    expect(onOpenImage).toHaveBeenCalledWith("https://x/b.jpg", "Photo, b.jpg");
+    fireA11y(bubble, "voice-0");
+    expect(player.play).toHaveBeenCalledTimes(1);
+    fireA11y(bubble, "voice-rate-0");
+    expect(player.setPlaybackRate).toHaveBeenCalledWith(1.5);
+  });
+
+  it("offers no play action without expo-audio, where the note can't play", () => {
+    render(<MessageBubble row={messageRow([attachment("v", "voice", "p/voice.m4a")])} me={ME} urls={{ "p/voice.m4a": "https://x/v" }} group={false} reducedMotion testID="b" />);
+    expect(screen.getByTestId("b-bubble").getAttribute("data-a11y-actions") ?? "").not.toContain("voice");
+  });
+});

package/src/native/__tests__/organise-logic.test.ts

@@ -0,0 +1,164 @@
+// @feat:chat
+import { describe, expect, it } from "vitest";
+import type { ChatInboxItem, ChatMessage, ChatTopic } from "../../core/types";
+import { availabilityInput, awayLineFor, clockToDate, dateToClock, defaultWeek, formFrom, hoursFromWeek, sameTimeDays, weekFromHours } from "../availability";
+import { broadcastOutcome, broadcastRows } from "../broadcast-sheet";
+import { emptyComposer, type ComposerState } from "../composer-state";
+import { chatNativeCopy } from "../copy";
+import { moderationNote } from "../moderation";
+import { defaultScheduleAt, scheduleInputFrom, withDay, withTime } from "../schedule-sheet";
+import { snippetText } from "../search-screen";
+import { canManageTopics, checkTopicName, topicClosedFor, topicMenuFor } from "../topics";
+import { rowIndexOf } from "../use-jump";
+import type { ThreadRow } from "../rows";
+
+const topic = (key: string, closed = false): ChatTopic => ({
+  conversationId: "c", topic: key, title: key, position: 0, closedAt: closed ? "2026-10-01T00:00:00Z" : null, createdBy: null, createdAt: "2026-10-01T00:00:00Z",
+});
+
+describe("topics", () => {
+  it("are managed by owners and admins only", () => {
+    expect(canManageTopics("owner")).toBe(true);
+    expect(canManageTopics("admin")).toBe(true);
+    expect(canManageTopics("member")).toBe(false);
+    expect(canManageTopics("observer")).toBe(false);
+    expect(canManageTopics(null)).toBe(false);
+  });
+
+  it("closed, take posts only from owners, admins and observers", () => {
+    expect(topicClosedFor(topic("a", true), "member")).toBe(true);
+    expect(topicClosedFor(topic("a", true), "owner")).toBe(false);
+    expect(topicClosedFor(topic("a", true), "admin")).toBe(false);
+    expect(topicClosedFor(topic("a", true), "observer")).toBe(false);
+    expect(topicClosedFor(topic("a"), "member")).toBe(false);
+    expect(topicClosedFor(null, "member")).toBe(false);
+  });
+
+  it("offer New always, and Rename with Close or Reopen for the topic shown", () => {
+    expect(topicMenuFor(null)).toEqual(["new"]);
+    expect(topicMenuFor(topic("a"))).toEqual(["new", "rename", "close"]);
+    expect(topicMenuFor(topic("a", true))).toEqual(["new", "rename", "reopen"]);
+  });
+
+  it("key a new topic from its name, refuse a clash or an empty name, and keep the key on a rename", () => {
+    expect(checkTopicName("Week 1: Habits", [])).toEqual({ key: "week-1-habits" });
+    expect(checkTopicName("  ", [])).toEqual({ error: "empty" });
+    expect(checkTopicName("Week 1: habits!", [topic("week-1-habits")])).toEqual({ error: "exists" });
+    expect(checkTopicName("New name", [topic("week-1-habits")], "week-1-habits")).toEqual({ key: "week-1-habits" });
+  });
+});
+
+describe("scheduled send", () => {
+  const composer = (text: string, files = 0): ComposerState => ({
+    ...emptyComposer,
+    text,
+    attachments: Array.from({ length: files }, (_, i) => ({ key: `k${i}`, file: { data: "file:///a.jpg", name: "a.jpg", contentType: "image/jpeg" } })),
+  }) as ComposerState;
+  const at = new Date("2026-10-26T09:00:00");
+
+  it("schedules what's written, in the topic shown, with its reply and mentions", () => {
+    const state = { ...composer("hi @[Sam](user:22222222-2222-4222-8222-222222222222)"), replyTo: { messageId: "m1", name: "Sam", preview: "x" } } as ComposerState;
+    const made = scheduleInputFrom(state, { conversationId: "c", topic: "week-1", at });
+    expect(made).toEqual({
+      input: { conversationId: "c", body: "hi @[Sam](user:22222222-2222-4222-8222-222222222222)", mentions: ["22222222-2222-4222-8222-222222222222"], replyToId: "m1", topic: "week-1", sendAt: at },
+    });
+  });
+
+  it("won't schedule nothing, or files (native files are URIs; scheduling uploads bytes only)", () => {
+    expect(scheduleInputFrom(composer("   "), { conversationId: "c", at })).toEqual({ error: "empty" });
+    expect(scheduleInputFrom(composer("with a photo", 1), { conversationId: "c", at })).toEqual({ error: "files" });
+  });
+
+  it("starts the custom time an hour ahead on the next five minutes, and sets day and time apart", () => {
+    const d = defaultScheduleAt(new Date("2026-10-25T10:02:30"));
+    expect([d.getHours(), d.getMinutes(), d.getSeconds()]).toEqual([11, 5, 0]);
+    const base = new Date("2026-10-25T14:30:00");
+    const day = withDay(base, new Date("2026-12-01T03:00:00"));
+    expect([day.getMonth(), day.getDate(), day.getHours(), day.getMinutes()]).toEqual([11, 1, 14, 30]);
+    const time = withTime(base, new Date("2020-01-01T08:15:00"));
+    expect([time.getDate(), time.getHours(), time.getMinutes()]).toEqual([25, 8, 15]);
+  });
+});
+
+describe("availability", () => {
+  it("reads saved hours as a week and writes the week back, keeping extra ranges", () => {
+    const saved = { mon: [["09:00", "12:00"], ["13:00", "17:00"]] as [string, string][], wed: [["10:00", "14:00"]] as [string, string][] };
+    const week = weekFromHours(saved);
+    expect(week.mon).toEqual({ on: true, from: "09:00", to: "12:00" });
+    expect(week.tue.on).toBe(false);
+    expect(hoursFromWeek({ ...week, mon: { ...week.mon, from: "08:00" } }, saved)).toEqual({ mon: [["08:00", "12:00"], ["13:00", "17:00"]], wed: [["10:00", "14:00"]] });
+    expect(Object.keys(hoursFromWeek(defaultWeek(), null))).toEqual(["mon", "tue", "wed", "thu", "fri"]);
+  });
+
+  it("refuses a day that starts and ends at the same time", () => {
+    const week = defaultWeek();
+    expect(sameTimeDays(week)).toEqual([]);
+    expect(sameTimeDays({ ...week, tue: { on: true, from: "09:00", to: "09:00" }, sat: { on: false, from: "09:00", to: "09:00" } })).toEqual(["tue"]);
+  });
+
+  it("saves the form as setAvailability expects (blank message and no hours as null)", () => {
+    const until = new Date("2026-11-02T09:00:00Z");
+    const form = { ...formFrom(null, "Europe/London"), message: "  Back Monday ", until, useHours: false };
+    expect(availabilityInput(form, null)).toEqual({ awayMessage: "Back Monday", awayUntil: until.toISOString(), timeZone: "Europe/London", hours: null });
+    expect(availabilityInput({ ...form, message: " ", until: null, useHours: true }, null)).toMatchObject({ awayMessage: null, awayUntil: null, hours: { mon: [["09:00", "17:00"]] } });
+  });
+
+  it("round-trips a clock time through a picker's Date", () => {
+    expect(dateToClock(clockToDate("07:45"))).toBe("07:45");
+    expect(dateToClock(clockToDate("bad"))).toBe("09:00");
+  });
+
+  it("names the other person when away, everyone away in a group, and skips you and observers", () => {
+    const now = new Date("2026-10-25T12:00:00Z");
+    const away = { userId: "sam", awayMessage: "On a retreat", awayUntil: null, timeZone: "UTC", hours: null };
+    const names: Record<string, string> = { me: "Me", sam: "Sam", lee: "Lee", obs: "Obs" };
+    const forUser = (id: string) => (id === "sam" || id === "lee" || id === "obs" || id === "me" ? { ...away, userId: id } : null);
+    expect(awayLineFor([{ userId: "me", role: "member" }, { userId: "sam", role: "member" }], "me", forUser, (id) => names[id]!, now)).toBe("Sam is away: On a retreat");
+    expect(awayLineFor([{ userId: "me", role: "member" }, { userId: "sam", role: "member" }, { userId: "lee", role: "member" }, { userId: "obs", role: "observer" }], "me", forUser, (id) => names[id]!, now)).toBe("Sam and Lee are away");
+    expect(awayLineFor([{ userId: "me", role: "member" }, { userId: "x", role: "member" }], "me", forUser, (id) => id, now)).toBeNull();
+  });
+});
+
+describe("broadcast", () => {
+  const item = (id: string, title: string | null, other: string | null, archived = false) => ({ conversationId: id, title, otherUserId: other, archived }) as ChatInboxItem;
+  it("lists the inbox by name, without archived ones, filtered by the query", () => {
+    const items = [item("1", null, "zoe"), item("2", "Coaching group", null), item("3", null, "amy"), item("4", null, "old", true)];
+    const person = (id: string | null) => (id ? { name: id === "zoe" ? "Zoe" : id === "amy" ? "Amy" : "Old" } : undefined);
+    expect(broadcastRows(items, { person, untitled: "Conversation" }).map((r) => r.title)).toEqual(["Amy", "Coaching group", "Zoe"]);
+    expect(broadcastRows(items, { person, untitled: "Conversation", query: "zo" }).map((r) => r.title)).toEqual(["Zoe"]);
+    expect(broadcastRows(items, { person, untitled: "Conversation", filter: (i) => i.otherUserId !== null }).map((r) => r.title)).toEqual(["Amy", "Zoe"]);
+  });
+
+  it("says how many it reached", () => {
+    expect(broadcastOutcome(3, 3, chatNativeCopy)).toEqual({ title: "Sent to 3 conversations", partial: false });
+    expect(broadcastOutcome(1, 1, chatNativeCopy)).toEqual({ title: "Sent to 1 conversation", partial: false });
+    expect(broadcastOutcome(2, 3, chatNativeCopy)).toEqual({ title: "Sent to 2 of 3. You can't post in the others.", partial: true });
+  });
+});
+
+describe("moderation", () => {
+  const m = (moderation: ChatMessage["moderation"], deletedAt: string | null = null) => ({ moderation, deletedAt });
+  it("tells a hidden message's sender only they see it, and marks hidden and flagged ones for observers", () => {
+    expect(moderationNote(m("hidden"), { mine: true, observer: false })).toBe("hidden-mine");
+    expect(moderationNote(m("hidden"), { mine: false, observer: true })).toBe("hidden");
+    expect(moderationNote(m("flagged"), { mine: false, observer: true })).toBe("flagged");
+    expect(moderationNote(m("flagged"), { mine: true, observer: false })).toBeNull();
+    expect(moderationNote(m(null), { mine: false, observer: true })).toBeNull();
+    expect(moderationNote(m("hidden", "2026-10-01T00:00:00Z"), { mine: true, observer: false })).toBeNull();
+  });
+});
+
+describe("search and jumping", () => {
+  it("reads a snippet without its marks", () => {
+    expect(snippetText("…a «word» here")).toBe("…a word here");
+  });
+  it("finds a message's row past day and unread rows", () => {
+    const rows = [
+      { type: "day", key: "d", label: "Today" },
+      { type: "unread", key: "u" },
+      { type: "message", key: "c1", item: { type: "message", message: { id: "m1" } } },
+    ] as unknown as ThreadRow[];
+    expect(rowIndexOf(rows, "m1")).toBe(2);
+    expect(rowIndexOf(rows, "m9")).toBe(-1);
+  });
+});