@marktiderman/genesis-chat 0.1.1 → 0.2.1

package/src/native/__tests__/video-upload.test.ts

@@ -0,0 +1,227 @@
+// @feat:chat
+import { describe, expect, it, vi } from "vitest";
+import { chunkedPut, createVideoUploads, nextOffset, type ByteSource } from "../video-upload";
+
+const KIB = 1024;
+const bytes = (n: number): ByteSource => {
+  const buf = new Uint8Array(n).map((_, i) => i % 251).buffer;
+  return { size: n, read: async (a, b) => buf.slice(a, b), close: vi.fn() };
+};
+const res = (status: number, headers: Record<string, string> = {}) => new Response(status === 204 ? null : "", { status, headers });
+const noSleep = async () => undefined;
+const flush = () => new Promise((r) => setTimeout(r, 0));
+
+/** A resumable upload server (the protocol Mux direct uploads speak): keeps what it receives. */
+function server(total: number, opts: { dropAt?: number[]; refuse?: number } = {}) {
+  let have = 0;
+  const calls: { range: string; size: number }[] = [];
+  let n = 0;
+  const fetch = vi.fn(async (_url: string, init: RequestInit) => {
+    const range = String((init.headers as Record<string, string>)["content-range"]);
+    const size = init.body ? (init.body as ArrayBuffer).byteLength : 0;
+    calls.push({ range, size });
+    const call = n++;
+    if (opts.refuse !== undefined) return res(opts.refuse);
+    if (range.startsWith("bytes */")) return have >= total ? res(200) : res(308, have ? { range: `bytes=0-${have - 1}` } : {});
+    if (opts.dropAt?.includes(call)) throw new TypeError("Network request failed");
+    const [, from, to] = /bytes (\d+)-(\d+)\//.exec(range)!.map(Number);
+    if (from !== have) return res(308, have ? { range: `bytes=0-${have - 1}` } : {});
+    have = to! + 1;
+    return have >= total ? res(201) : res(308, { range: `bytes=0-${have - 1}` });
+  });
+  return { fetch: fetch as unknown as typeof globalThis.fetch, calls, have: () => have };
+}
+
+describe("chunkedPut (resumable PUT to a direct upload URL)", () => {
+  it("sends 256 KiB-multiple chunks with Content-Range and reports progress", async () => {
+    const s = server(600 * KIB);
+    const progress: number[] = [];
+    await chunkedPut({ url: "https://up", contentType: "video/quicktime", source: bytes(600 * KIB), fetch: s.fetch, chunkBytes: 256 * KIB, onProgress: (sent) => progress.push(sent), sleep: noSleep });
+    expect(s.calls.map((c) => c.range)).toEqual([`bytes 0-262143/614400`, `bytes 262144-524287/614400`, `bytes 524288-614399/614400`]);
+    expect(progress).toEqual([0, 262144, 524288, 614400]);
+    expect(s.have()).toBe(614400);
+  });
+
+  it("after a dropped connection asks where the server is and carries on from there", async () => {
+    const s = server(600 * KIB, { dropAt: [1] });
+    await chunkedPut({ url: "https://up", contentType: "video/mp4", source: bytes(600 * KIB), fetch: s.fetch, chunkBytes: 256 * KIB, sleep: noSleep });
+    expect(s.calls.map((c) => c.range)).toEqual([`bytes 0-262143/614400`, `bytes 262144-524287/614400`, `bytes */614400`, `bytes 262144-524287/614400`, `bytes 524288-614399/614400`]);
+    expect(s.have()).toBe(614400);
+  });
+
+  it("resumes an upload that got partway (a Retry) without sending the start again", async () => {
+    const first = server(512 * KIB);
+    await chunkedPut({ url: "u", contentType: "video/mp4", source: bytes(512 * KIB), fetch: first.fetch, chunkBytes: 256 * KIB, sleep: noSleep, isCancelled: () => first.have() >= 256 * KIB }).catch(() => undefined);
+    expect(first.have()).toBe(256 * KIB);
+    first.calls.length = 0;
+    await chunkedPut({ url: "u", contentType: "video/mp4", source: bytes(512 * KIB), fetch: first.fetch, chunkBytes: 256 * KIB, sleep: noSleep, resume: true });
+    expect(first.calls.map((c) => c.range)).toEqual([`bytes */524288`, `bytes 262144-524287/524288`]);
+  });
+
+  it("gives up on a refusal at once, and marks an expired upload URL so Retry mints another", async () => {
+    const refused = server(10, { refuse: 403 });
+    await expect(chunkedPut({ url: "u", contentType: "video/mp4", source: bytes(10), fetch: refused.fetch, sleep: noSleep })).rejects.toMatchObject({ code: "42501" });
+    expect(refused.calls).toHaveLength(1);
+    const gone = server(10, { refuse: 410 });
+    await expect(chunkedPut({ url: "u", contentType: "video/mp4", source: bytes(10), fetch: gone.fetch, sleep: noSleep })).rejects.toMatchObject({ code: "P0002" });
+  });
+
+  it("fails after its retries when the network stays down", async () => {
+    const down = vi.fn(async () => {
+      throw new TypeError("Network request failed");
+    }) as unknown as typeof fetch;
+    await expect(chunkedPut({ url: "u", contentType: "video/mp4", source: bytes(10), fetch: down, retries: 2, sleep: noSleep })).rejects.toThrow(/connection/);
+  });
+
+  it("ends in an error, not a loop, when the server answers 308 without moving forward", async () => {
+    const stuck = vi.fn(async () => res(308)) as unknown as typeof fetch;
+    await expect(chunkedPut({ url: "u", contentType: "video/mp4", source: bytes(10), fetch: stuck, retries: 3, sleep: noSleep })).rejects.toThrow(/out of step/);
+    expect((stuck as unknown as { mock: { calls: unknown[] } }).mock.calls.length).toBe(4);
+  });
+
+  it("refuses a server that calls a middle chunk the whole upload (it kept only part)", async () => {
+    const plain = vi.fn(async () => res(200)) as unknown as typeof fetch;
+    await expect(chunkedPut({ url: "u", contentType: "video/mp4", source: bytes(512 * KIB), fetch: plain, chunkBytes: 256 * KIB, sleep: noSleep })).rejects.toThrow(/only part/);
+  });
+
+  it("reads Range headers", () => {
+    expect(nextOffset("bytes=0-262143")).toBe(262144);
+    expect(nextOffset(null)).toBe(0);
+  });
+});
+
+describe("video uploads in flight", () => {
+  const video = { uri: "file:///take.mov", name: "video-1.mov", contentType: "video/quicktime", durationMs: 4200 };
+  const read = async () => new Response(new Uint8Array(100));
+
+  it("with videoUpload: uploads to the minted URL, then sends the pending Mux attachment through the outbox", async () => {
+    const s = server(100);
+    const fetch = vi.fn(async (url: string, init?: RequestInit) => (url.startsWith("file:") ? read() : s.fetch(url, init!))) as unknown as typeof globalThis.fetch;
+    const send = vi.fn(async () => "client-1");
+    const create = vi.fn(async () => ({ url: "https://storage.googleapis.com/up", providerId: "upl_1", provider: "mux" as const }));
+    const uploads = createVideoUploads(() => "t1");
+    const seen: number[] = [];
+    uploads.subscribe(() => seen.push(uploads.list("c")[0]?.progress ?? -1));
+    uploads.start({ conversationId: "c", video, extra: { replyToId: "m9", threadRootId: null }, send, videoUpload: { create }, fetch, sleep: noSleep });
+    await vi.waitFor(() => expect(send).toHaveBeenCalled());
+    expect(create).toHaveBeenCalledWith("c");
+    expect(send).toHaveBeenCalledWith({
+      conversationId: "c",
+      replyToId: "m9",
+      threadRootId: null,
+      body: "",
+      attachments: [{ kind: "video", provider: "mux", providerId: "upl_1", status: "pending", name: "video-1.mov", mime: "video/quicktime", bytes: 100, durationMs: 4200 }],
+    });
+    expect(uploads.list("c")).toEqual([]);
+    expect(seen).toContain(1);
+  });
+
+  it("uses the upload minted when recording started", async () => {
+    const s = server(100);
+    const fetch = vi.fn(async (url: string, init?: RequestInit) => (url.startsWith("file:") ? read() : s.fetch(url, init!))) as unknown as typeof globalThis.fetch;
+    const create = vi.fn();
+    const send = vi.fn(async () => "x");
+    createVideoUploads().start({ conversationId: "c", video, send, videoUpload: { create }, prepared: Promise.resolve({ url: "https://up", providerId: "upl_p", provider: "mux" }), fetch, sleep: noSleep });
+    await vi.waitFor(() => expect(send).toHaveBeenCalled());
+    expect(create).not.toHaveBeenCalled();
+    expect((send.mock.calls[0] as unknown[])[0]).toMatchObject({ attachments: [{ providerId: "upl_p" }] });
+  });
+
+  it("a failed upload shows as failed, and Retry resumes it on the same upload", async () => {
+    let up = true;
+    const s = server(100);
+    const fetch = vi.fn(async (url: string, init?: RequestInit) => {
+      if (url.startsWith("file:")) return read();
+      if (!up) throw new TypeError("Network request failed");
+      return s.fetch(url, init!);
+    }) as unknown as typeof globalThis.fetch;
+    up = false;
+    const send = vi.fn(async () => "x");
+    const create = vi.fn(async () => ({ url: "https://up", providerId: "upl_1", provider: "mux" as const }));
+    const uploads = createVideoUploads(() => "t1");
+    uploads.start({ conversationId: "c", video, send, videoUpload: { create }, fetch, sleep: noSleep });
+    await vi.waitFor(() => expect(uploads.list("c")[0]?.status).toBe("failed"));
+    expect(uploads.list("c")[0]?.error).toBe("offline");
+    up = true;
+    uploads.retry("t1");
+    await vi.waitFor(() => expect(send).toHaveBeenCalledTimes(1));
+    expect(create).toHaveBeenCalledTimes(1);
+    expect(s.calls[0]?.range).toBe("bytes */100");
+  });
+
+  it("an outbox that won't take the message leaves it failed, and Retry sends it without uploading again", async () => {
+    const s = server(100);
+    const fetch = vi.fn(async (url: string, init?: RequestInit) => (url.startsWith("file:") ? read() : s.fetch(url, init!))) as unknown as typeof globalThis.fetch;
+    const send = vi.fn().mockRejectedValueOnce(new Error("storage full")).mockResolvedValue("x");
+    const uploads = createVideoUploads(() => "t1");
+    uploads.start({ conversationId: "c", video, send, videoUpload: { create: async () => ({ url: "https://up", providerId: "p", provider: "mux" }) }, fetch, sleep: noSleep });
+    await vi.waitFor(() => expect(uploads.list("c")[0]?.status).toBe("failed"));
+    const puts = s.calls.length;
+    uploads.retry("t1");
+    await vi.waitFor(() => expect(send).toHaveBeenCalledTimes(2));
+    expect(s.calls.length).toBe(puts);
+    expect(uploads.list("c")).toEqual([]);
+  });
+
+  it("mints a fresh upload, once and by itself, when the one minted at the start has expired", async () => {
+    const live = server(100);
+    const fetch = vi.fn(async (url: string, init?: RequestInit) => {
+      if (url.startsWith("file:")) return read();
+      if (url === "https://expired") return res(410);
+      return live.fetch(url, init!);
+    }) as unknown as typeof globalThis.fetch;
+    const create = vi.fn(async () => ({ url: "https://fresh", providerId: "upl_2", provider: "mux" as const }));
+    const send = vi.fn(async () => "x");
+    createVideoUploads().start({ conversationId: "c", video, send, videoUpload: { create }, prepared: Promise.resolve({ url: "https://expired", providerId: "upl_1", provider: "mux" }), fetch, sleep: noSleep });
+    await vi.waitFor(() => expect(send).toHaveBeenCalled());
+    expect(create).toHaveBeenCalledTimes(1);
+    expect((send.mock.calls[0] as unknown[])[0]).toMatchObject({ attachments: [{ providerId: "upl_2" }] });
+  });
+
+  it("cancelAll (sign-out) stops every upload, and none is sent", async () => {
+    let release!: () => void;
+    const gate = new Promise<void>((r) => (release = r));
+    const fetch = vi.fn(async (url: string) => (url.startsWith("file:") ? read() : (await gate, res(201)))) as unknown as typeof globalThis.fetch;
+    const send = vi.fn();
+    const uploads = createVideoUploads();
+    const upload = { create: async () => ({ url: "https://up", providerId: "p", provider: "mux" as const }) };
+    uploads.start({ conversationId: "c", userId: "u1", video, send, videoUpload: upload, fetch, sleep: noSleep });
+    uploads.start({ conversationId: "d", userId: "u1", video, send, videoUpload: upload, fetch, sleep: noSleep });
+    await flush();
+    uploads.cancelAll();
+    release();
+    await flush();
+    await flush();
+    expect(uploads.list()).toEqual([]);
+    expect(send).not.toHaveBeenCalled();
+  });
+
+  it("Cancel stops it and nothing is sent", async () => {
+    let release!: () => void;
+    const gate = new Promise<void>((r) => (release = r));
+    const fetch = vi.fn(async (url: string) => {
+      if (url.startsWith("file:")) return read();
+      await gate;
+      return res(201);
+    }) as unknown as typeof globalThis.fetch;
+    const send = vi.fn();
+    const uploads = createVideoUploads(() => "t1");
+    uploads.start({ conversationId: "c", video, send, videoUpload: { create: async () => ({ url: "https://up", providerId: "p", provider: "mux" }) }, fetch, sleep: noSleep });
+    await flush();
+    uploads.cancel("t1");
+    release();
+    await flush();
+    await flush();
+    expect(uploads.list("c")).toEqual([]);
+    expect(send).not.toHaveBeenCalled();
+  });
+
+  it("without videoUpload: goes through the outbox as a file to storage", async () => {
+    const send = vi.fn(async () => "x");
+    createVideoUploads().start({ conversationId: "c", video, extra: { threadRootId: "root" }, send });
+    await vi.waitFor(() => expect(send).toHaveBeenCalled());
+    expect(send).toHaveBeenCalledWith({ conversationId: "c", threadRootId: "root", body: "" }, [
+      { data: "file:///take.mov", name: "video-1.mov", contentType: "video/quicktime", previewUrl: "file:///take.mov", meta: { kind: "video", durationMs: 4200 } },
+    ]);
+  });
+});

package/src/native/access-error.tsx

@@ -0,0 +1,31 @@
+/**
+ * @feat:chat
+ * In the composer's place when your role in a conversation couldn't be read
+ * (offline, a server hiccup): what happened and Retry
+ * (`useConversation().refetchAccess`), instead of waiting quietly forever or
+ * saying you can't post.
+ */
+import { View } from "react-native";
+import { NativeButton, NativeInlineAlert } from "@marktiderman/genesis-ui-native/components";
+import { useThemeRoles } from "@marktiderman/genesis-ui-native/hooks";
+import { useChatNative } from "./context";
+
+export interface ChatAccessErrorProps {
+  onRetry: () => void;
+  /** A retry is under way. */
+  retrying?: boolean;
+  testID?: string;
+}
+
+export function ChatAccessError({ onRetry, retrying = false, testID = "chat-access-error" }: ChatAccessErrorProps) {
+  const { copy } = useChatNative();
+  const colors = useThemeRoles();
+  return (
+    <View testID={testID} style={{ padding: 12, gap: 10, backgroundColor: colors.groupedBackground }}>
+      <NativeInlineAlert variant="warning" description={copy.accessError} testID={`${testID}-alert`} />
+      <NativeButton variant="outline" size="lg" onPress={onRetry} loading={retrying} testID={`${testID}-retry`}>
+        {copy.retry}
+      </NativeButton>
+    </View>
+  );
+}

package/src/native/actions.ts

@@ -0,0 +1,42 @@
+/**
+ * @feat:chat
+ * Which actions a message offers this person, from the same rules migration
+ * 0001 enforces (react and reply need can_post; pin follows
+ * useConversation().canPin: an owner or admin, or a member of a two-person
+ * kind; delete needs the sender, an owner or
+ * admin, or an observer who may post). The server stays the judge: an action
+ * it refuses shows a toast.
+ */
+import type { ChatMessage, ChatRole } from "../core/types";
+
+export type MessageActionId = "reply" | "copy" | "pin" | "unpin" | "delete";
+
+/** The quick reactions on the long-press sheet. */
+export const QUICK_REACTIONS = ["👍", "❤️", "😂", "😮", "😢", "🙏"] as const;
+
+export interface MessageActionContext {
+  me: string;
+  role: ChatRole | null;
+  canPost: boolean;
+  pinned: boolean;
+  /** May pin here (`useConversation().canPin`: an owner or admin, or a member of a two-person kind). */
+  canPin: boolean;
+  /** Copy needs expo-clipboard. */
+  canCopy: boolean;
+}
+
+export function canReactTo(message: ChatMessage, ctx: Pick<MessageActionContext, "canPost">): boolean {
+  return ctx.canPost && !message.deletedAt && message.kind === "text";
+}
+
+export function messageActionsFor(message: ChatMessage, ctx: MessageActionContext): MessageActionId[] {
+  if (message.deletedAt || message.kind === "system") return [];
+  const out: MessageActionId[] = [];
+  if (ctx.canPost) out.push("reply");
+  if (ctx.canCopy && message.body.trim()) out.push("copy");
+  const admin = ctx.role === "owner" || ctx.role === "admin";
+  if (message.visibility === "everyone" && ctx.canPin) out.push(ctx.pinned ? "unpin" : "pin");
+  const own = message.senderId === ctx.me && ctx.role !== null;
+  if (own || admin || (ctx.role === "observer" && ctx.canPost)) out.push("delete");
+  return out;
+}

package/src/native/attachment-cards.tsx

@@ -0,0 +1,132 @@
+/**
+ * @feat:chat
+ * Cards for the app's own attachment kinds (`ChatProvider attachmentKinds`: a form to fill, a
+ * check-in to answer): an icon, the title and subtitle the kind gives, and one button. The
+ * button runs the kind's `onPress`; else the app's `onOpenAttachment` (open the form in the
+ * app's own screen); else its `href`, when it is https. The bubble offers the same button as
+ * a VoiceOver action (`cardAction`), since an accessible bubble hides what is inside it.
+ *
+ * The kind's `title`, `subtitle` and `action` get a second argument, `{ mine }` (`ChatCardContext`):
+ * true on the sender's own card, so a kind can drop its button there (you don't answer your own
+ * check-in). Previews (the inbox, the long-press sheet) name a card by its kind's `label`, else
+ * its title, not "Attachment".
+ */
+import { Linking, View } from "react-native";
+import { NativeButton, NativeIcon, NativeText } from "@marktiderman/genesis-ui-native/components";
+import { useThemeRoles } from "@marktiderman/genesis-ui-native/hooks";
+import type { ChatAttachment, ChatMessage } from "../core/types";
+import type { ChatAttachmentKind, ChatCardContext } from "../react/index";
+import { attachmentPreview, callAttachmentKind as call, cardTitle, messagePreview } from "../react/previews";
+
+export type { ChatCardContext };
+export { attachmentPreview, cardTitle, messagePreview };
+import { fill } from "./copy";
+import { useChatNative } from "./context";
+import { ON_TINT_FILL, ON_TINT_FILL_STRONG } from "./media-colors";
+
+export type OpenAttachment = (attachment: ChatAttachment, message: ChatMessage) => void;
+
+/** A message's attachments split into the app's cards and the rest (photos, voice, video, files). */
+export function splitCardAttachments<T extends { kind: string }>(attachments: readonly T[], kinds: Record<string, ChatAttachmentKind> | undefined): { cards: T[]; rest: T[] } {
+  if (!kinds) return { cards: [], rest: [...attachments] };
+  const cards: T[] = [];
+  const rest: T[] = [];
+  for (const a of attachments) (Object.prototype.hasOwnProperty.call(kinds, a.kind) ? cards : rest).push(a);
+  return { cards, rest };
+}
+
+/**
+ * A link a card may open by itself: https only. A kind's href is often built from what another
+ * person sent, so any other scheme (tel:, sms:, another app's links) goes through the app's own
+ * `onOpenAttachment` or the kind's `onPress` instead.
+ */
+export function isOpenableHref(href: string | null | undefined): href is string {
+  if (!href) return false;
+  try {
+    const u = new URL(href);
+    return u.protocol === "https:" && Boolean(u.hostname);
+  } catch {
+    return false;
+  }
+}
+
+/** What a card does: the kind's own handler, else the app's, else an https href; null without a button. */
+export function cardAction(
+  kind: ChatAttachmentKind | undefined,
+  attachment: ChatAttachment,
+  message: ChatMessage,
+  onOpenAttachment?: OpenAttachment,
+  ctx: ChatCardContext = { mine: false },
+): { label: string; run: () => void } | null {
+  let action: ReturnType<NonNullable<ChatAttachmentKind["action"]>> = null;
+  try {
+    action = call(kind, "action", attachment, ctx);
+  } catch {
+    return null;
+  }
+  if (!action?.label) return null;
+  const href = isOpenableHref(action.href) ? action.href : null;
+  const onPress = action.onPress;
+  const run = onPress ? onPress : onOpenAttachment ? () => onOpenAttachment(attachment, message) : href ? () => void Linking.openURL(href).catch(() => undefined) : null;
+  return run ? { label: action.label, run } : null;
+}
+
+export interface ChatAttachmentCardProps {
+  attachment: ChatAttachment;
+  message: ChatMessage;
+  kind: ChatAttachmentKind;
+  mine?: boolean;
+  onOpenAttachment?: OpenAttachment;
+  testID?: string;
+}
+
+export function ChatAttachmentCard({ attachment, message, kind, mine = false, onOpenAttachment, testID = "chat-attachment-card" }: ChatAttachmentCardProps) {
+  const { copy } = useChatNative();
+  const colors = useThemeRoles();
+  let title = "";
+  let subtitle: string | null | undefined = null;
+  const ctx: ChatCardContext = { mine };
+  try {
+    title = call(kind, "title", attachment, ctx) ?? "";
+    subtitle = call(kind, "subtitle", attachment, ctx);
+  } catch (e) {
+    // An app's kind that throws shows as a plain card, and says so in development.
+    if (typeof __DEV__ !== "undefined" && __DEV__) console.warn(`[genesis-chat] attachment kind "${attachment.kind}" threw:`, e);
+  }
+  title = title || attachment.name || attachment.kind;
+  const action = cardAction(kind, attachment, message, onOpenAttachment, ctx);
+  const fg = mine ? "text-primary-foreground" : undefined;
+  return (
+    <View
+      testID={testID}
+      style={{ flexDirection: "row", alignItems: "center", gap: 10, padding: 10, borderRadius: 12, minWidth: 220, backgroundColor: mine ? ON_TINT_FILL : colors.groupedBackground }}
+    >
+      <View
+        accessible
+        accessibilityLabel={subtitle ? fill(copy.attachmentCard, { title, subtitle }) : title}
+        style={{ flexDirection: "row", alignItems: "center", gap: 10, flex: 1 }}
+      >
+        <View style={{ width: 40, height: 40, borderRadius: 10, alignItems: "center", justifyContent: "center", backgroundColor: mine ? ON_TINT_FILL_STRONG : colors.fill }}>
+          <NativeIcon name="file" size={20} color={mine ? colors.surface : colors.tint} />
+        </View>
+        <View style={{ flex: 1, minWidth: 0 }}>
+          <NativeText numberOfLines={1} className={fg} style={mine ? { fontWeight: "600", fontSize: 15 } : { fontWeight: "600", fontSize: 15, color: colors.label }}>
+            {title}
+          </NativeText>
+          {subtitle ? (
+            <NativeText preset="caption" numberOfLines={1} className={fg} style={mine ? { opacity: 0.85 } : { color: colors.secondaryLabel }}>
+              {subtitle}
+            </NativeText>
+          ) : null}
+        </View>
+      </View>
+      {action ? (
+        <NativeButton testID={`${testID}-action`} variant={mine ? "secondary" : "default"} onPress={action.run}>
+          {action.label}
+        </NativeButton>
+      ) : null}
+    </View>
+  );
+}
+
+declare const __DEV__: boolean | undefined;

package/src/native/auto-retry.ts

@@ -0,0 +1,69 @@
+/**
+ * @feat:chat
+ * Retries unsent messages when there's a chance they'll go now: the app
+ * coming back to the front (AppState "active") and, with NetInfo
+ * (`modules.netInfo`), the connection coming back, through
+ * `useChat().retryAll()`, which resends what failed for a reason that may
+ * pass and leaves alone what the server refused (`permanent`: not allowed,
+ * bad data) and messages whose files are gone. Mount it once under
+ * ChatProvider and ChatNativeProvider: `<ChatAutoRetry />`.
+ */
+import { useEffect, useRef } from "react";
+import { AppState } from "react-native";
+import { useChat } from "../react/index";
+import { useChatNative } from "./context";
+import type { NetInfoLike } from "./modules";
+
+/** React Native's `AppState`, as the hook uses it. */
+export interface AppStateLike {
+  currentState: string | null;
+  addEventListener(type: "change", listener: (state: string) => void): { remove(): void };
+}
+
+export interface ChatAutoRetryOptions {
+  /** Default `modules.netInfo`. */
+  netInfo?: NetInfoLike;
+  /** Default React Native's AppState. */
+  appState?: AppStateLike;
+}
+
+/** Whether a NetInfo state is online: unknown counts as online, so only a real "offline" waits. */
+export function isOnline(state: { isConnected: boolean | null; isInternetReachable?: boolean | null }): boolean {
+  return state.isConnected !== false && state.isInternetReachable !== false;
+}
+
+export function useChatAutoRetry({ netInfo, appState }: ChatAutoRetryOptions = {}): void {
+  const { retryAll } = useChat();
+  const { modules } = useChatNative();
+  const net = netInfo ?? modules.netInfo;
+  const app = appState ?? (AppState as unknown as AppStateLike | undefined);
+  // The latest retryAll, so a changing queue doesn't resubscribe.
+  const retry = useRef(retryAll);
+  retry.current = retryAll;
+
+  useEffect(() => {
+    const go = () => void retry.current().catch(() => undefined);
+    let last = app?.currentState ?? null;
+    const sub = app?.addEventListener?.("change", (next) => {
+      if (next === "active" && last !== "active") go();
+      last = next;
+    });
+    // Only a change from offline to online: NetInfo also reports the current state on subscribing.
+    let wasOnline: boolean | null = null;
+    const unsubscribe = net?.addEventListener((state) => {
+      const online = isOnline(state);
+      if (online && wasOnline === false) go();
+      wasOnline = online;
+    });
+    return () => {
+      sub?.remove();
+      unsubscribe?.();
+    };
+  }, [net, app]);
+}
+
+/** `useChatAutoRetry` as a component, for a provider tree. */
+export function ChatAutoRetry(props: ChatAutoRetryOptions) {
+  useChatAutoRetry(props);
+  return null;
+}