@marktiderman/genesis-chat 0.1.1 → 0.2.1

package/dist/react.d.ts

@@ -1,8 +1,9 @@
 import * as _tanstack_query_core from '@tanstack/query-core';
-import { C as ChatClient, a as ChatConversation, b as ChatMember, c as ChatRole, d as ChatKindRules, e as ChatMessage, f as ChatActivity, S as SendInput, g as ChatSignal, h as ChatInboxItem } from './client-BtdALFCx.js';
+import { h as ChatAttachment, i as ChatClient, k as ChatConversation, p as ChatMember, t as ChatRole, n as ChatKindRules, q as ChatMessage, g as ChatActivity, F as SendInput, M as MessagePage, C as ChatAvailability, d as AvailabilityInput, v as ChatSignal, m as ChatInboxItem, o as ChatLinkPreview, D as ScheduledMessage, S as ScheduleInput, u as ChatSearchHit, x as ChatTopic, T as TopicInput } from './client-DUIG1hum.js';
 import * as react from 'react';
 import { ReactNode } from 'react';
-import { OutboxStore, LocalFile, ThreadItem, Outbox, QueuedMessage } from './index.js';
+import { e as OutboxStore, S as StorageUpload, H as HostedUpload, L as LocalFile, O as Outbox, Q as QueuedMessage } from './outbox-B9NAWQ58.js';
+import { T as ThreadItem } from './thread-oPra7pkW.js';
 import '@supabase/supabase-js';
 
 declare const chatKeys: {
@@ -14,15 +15,77 @@ declare const chatKeys: {
     role: (id: string) => readonly ["genesis-chat", "role", string];
     pins: (id: string) => readonly ["genesis-chat", "pins", string];
     files: (paths: string[]) => readonly ["genesis-chat", "files", string[]];
+    /** Under the conversation's key, so its `conversation` hint (set_topic broadcasts one) refreshes them. */
+    topics: (id: string) => readonly ["genesis-chat", "conversation", string, "topics"];
+    scheduled: (conversationId?: string | null) => readonly ["genesis-chat", "scheduled", string | null];
+    availability: (conversationId: string) => readonly ["genesis-chat", "conversation", string, "availability"];
+    myAvailability: () => readonly ["genesis-chat", "my-availability"];
+    search: (query: string, conversationId?: string | null) => readonly ["genesis-chat", "search", string | null, string];
+    previews: (messageIds: string[]) => readonly ["genesis-chat", "previews", string[]];
+    /** One message's link previews (useLinkPreviews keeps one query per message). */
+    preview: (messageId: string) => readonly ["genesis-chat", "preview", string];
 };
+/** How many messages a catch-up asks for at a time, and how many pages before it gives up and jumps to the newest. */
+declare const CATCH_UP_PAGE = 200;
+declare const CATCH_UP_MAX_PAGES = 10;
+/** What a messages list holds in the query cache: the page, and whether older messages exist. */
+type MessagesData = MessagePage;
 /** Does a messages list (`[genesis-chat, conversation, id, messages, threadRootId, topic]`) hold this message? */
 declare function belongsTo(key: readonly unknown[], m: ChatMessage): boolean;
+/**
+ * Hosted video uploads (Mux direct uploads): your server makes an upload and returns its URL
+ * (`createVideoUploadHandler` in /server). A video the composer marks `hosted` is sent through
+ * the outbox at once, in order, with `{ kind: "video", provider, providerId, status: "pending" }`,
+ * while its bytes are PUT to that URL (see `hostedUploadFrom`). Without it, videos go to storage
+ * as files.
+ */
+interface ChatVideoUpload {
+    create(conversationId: string): Promise<{
+        url: string;
+        providerId: string;
+        provider: "mux";
+    }>;
+}
+/**
+ * The outbox's `hostedUpload` from a `ChatVideoUpload`: mints the upload (or, resuming, reuses
+ * the one minted before), resolves at once with its id, and PUTs the whole file to its URL in
+ * the background (XMLHttpRequest where there is one, for progress). A native file URI is read
+ * with `readFile`. Native apps with chunked, resumable uploads pass their own `hostedUpload`.
+ */
+declare function hostedUploadFrom(videoUpload: ChatVideoUpload, options?: {
+    readFile?: (uri: string) => Promise<Blob | ArrayBuffer>;
+    fetch?: typeof fetch;
+}): HostedUpload;
+/** What a kind's `title`, `subtitle` and `action` are told besides the attachment. */
+interface ChatCardContext {
+    /** The card is on a message you sent (your own check-in reads "Sent", not "Answer"). */
+    mine: boolean;
+}
+/** What an app attachment kind's card shows (a form, a check-in): plain data, drawn by each renderer. */
+interface ChatAttachmentKind {
+    title(attachment: ChatAttachment, ctx?: ChatCardContext): string;
+    subtitle?(attachment: ChatAttachment, ctx?: ChatCardContext): string | null | undefined;
+    /** The card's button: a link (`href`) or a handler (`onPress`). */
+    action?(attachment: ChatAttachment, ctx?: ChatCardContext): {
+        label: string;
+        href?: string;
+        onPress?: () => void;
+    } | null | undefined;
+    /** What previews call it (the inbox's last message, "Check-in"); the title by default. */
+    label?: string;
+}
 interface ChatContextValue {
     client: ChatClient;
     userId: string;
     outbox: Outbox;
     queue: QueuedMessage[];
     loadPeople?: (userIds: string[]) => Promise<Record<string, ChatPerson>>;
+    videoUpload?: ChatVideoUpload;
+    attachmentKinds?: Record<string, ChatAttachmentKind>;
+    /** Retries every failed message (call it when the connection comes back: AppState, NetInfo). */
+    retryAll(): Promise<void>;
+    /** Forgets every unsent message, here and in the outbox store (call it on sign-out). */
+    clearOutbox(): Promise<void>;
     /** Subscribe to inbox hints (one channel for the app, fanned out here). */
     onInbox(listener: (s: ChatSignal) => void): () => void;
 }
@@ -34,14 +97,29 @@ interface ChatProviderProps {
     outboxStore?: OutboxStore;
     /** Reads a native file URI for upload. */
     readFile?: (uri: string) => Promise<Blob | ArrayBuffer>;
-    /** Replaces the plain upload (resumable uploads on native). */
-    upload?: (conversationId: string, file: LocalFile) => Promise<string>;
+    /**
+     * Replaces the plain upload (resumable uploads on native). `signal` aborts when the message is
+     * discarded or the outbox cleared; `onProgress(sent, total)` fills the pending bubble's bar.
+     */
+    upload?: StorageUpload;
+    /**
+     * Starts a hosted upload for files marked `hosted` (see HostedUpload): resolve with
+     * `{ provider, providerId, status: "pending", url?, done }` once the upload id exists. Default:
+     * `hostedUploadFrom(videoUpload)` when `videoUpload` is given.
+     */
+    hostedUpload?: HostedUpload;
     /** Makes client ids (default: a random UUID that works without crypto.randomUUID). */
     newId?: () => string;
     /** Keeps a byte file (a pasted image, a recording) across launches: write it, return a URI. */
     persistFile?: (file: LocalFile) => Promise<string>;
+    /** Lets go of a sent file's preview (default: revokes `blob:` object URLs only). */
+    releasePreview?: (url: string) => void;
     /** Names and avatars for user ids, fetched in batches (usePeople, usePerson). */
     loadPeople?: (userIds: string[]) => Promise<Record<string, ChatPerson>>;
+    /** Hosted video uploads (Mux); videos go to storage without it. */
+    videoUpload?: ChatVideoUpload;
+    /** Cards for your own attachment kinds (`{ form: { title, subtitle, action } }`). */
+    attachmentKinds?: Record<string, ChatAttachmentKind>;
     children: ReactNode;
 }
 /** How the app shows a person. */
@@ -50,11 +128,13 @@ interface ChatPerson {
     avatarUrl?: string | null;
 }
 /** Puts chat in reach of every hook below it. Needs a TanStack QueryClientProvider above it. */
-declare function ChatProvider({ client, userId, outboxStore, readFile, upload, newId, persistFile, loadPeople, children }: ChatProviderProps): react.JSX.Element;
+declare function ChatProvider({ client, userId, outboxStore, readFile, upload, hostedUpload, newId, persistFile, releasePreview, loadPeople, videoUpload, attachmentKinds, children, }: ChatProviderProps): react.JSX.Element;
 declare function useChat(): ChatContextValue;
 /** Your conversations, live. `kind` narrows to one kind; `archived` shows the archived ones. */
 declare function useInbox(opts?: {
     kind?: string;
+    kinds?: string[];
+    excludeKinds?: string[];
     archived?: boolean;
     limit?: number;
 }): {
@@ -64,7 +144,9 @@ declare function useInbox(opts?: {
     refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<NoInfer<ChatInboxItem[]>, Error>>;
 };
 /** How many messages wait for you everywhere (for a badge), live. */
-declare function useUnreadTotal(): number;
+declare function useUnreadTotal(opts?: {
+    excludeKinds?: string[];
+}): number;
 interface UseConversationOptions {
     /** Mark messages read as they arrive while this is true (the thread is on screen). Default true. */
     markRead?: boolean;
@@ -82,6 +164,14 @@ declare function useConversation(conversationId: string | null | undefined, opts
     canPost: boolean;
     /** Your role and posting rights are still loading: show the composer as waiting, not refused. */
     accessLoading: boolean;
+    /** The conversation itself is still loading (it settles to `null` when you can't see it). */
+    conversationLoading: boolean;
+    /** Your role couldn't be loaded (offline): offer `refetchAccess`, don't say "can't post". */
+    accessError: Error | null;
+    /** Retries everything this conversation loads (role, members, the conversation, topics, availability, pins), not only access. */
+    refetchAccess: () => Promise<undefined>;
+    /** Same as refetchAccess: every per-conversation lookup again, for a Retry after being offline. */
+    refetchConversation: () => Promise<undefined>;
     /** The kind's rules (max members, threads, who posts). */
     kind: NonNullable<NoInfer<ChatKindRules | null>> | null;
     /** May you pin here: owners and admins, or anyone in a two-person conversation. */
@@ -95,11 +185,14 @@ declare function useConversation(conversationId: string | null | undefined, opts
     hasEarlier: boolean;
     loadingEarlier: boolean;
     loadEarlier: () => Promise<void>;
+    loadUntil: (seq: number) => Promise<boolean>;
     /** Where to draw the "New" line, from what you had read when it opened. */
     firstUnreadId: string | null;
     activity: ChatActivity[];
     signalTyping: () => void;
     signalRecording: () => void;
+    /** Tells the others you are recording a video (throttled). */
+    signalRecordingVideo: () => void;
     markRead: () => Promise<void>;
     send: (input: Omit<SendInput, "conversationId" | "clientId">, files?: LocalFile[]) => Promise<string>;
     retry: (clientId: string) => Promise<void>;
@@ -133,5 +226,81 @@ declare function useStartConversation(): (kind: string, memberIds: string[], opt
     subjectType?: string;
     subjectId?: string;
 }) => Promise<string>;
+/**
+ * A conversation's topics, live (set_topic's hint refreshes them), and `setTopic` for owners
+ * and admins: add one (`setTopic("week-1", { title: "Week 1" })`), close or reopen it.
+ */
+declare function useTopics(conversationId: string | null | undefined): {
+    topics: ChatTopic[];
+    isLoading: boolean;
+    error: Error | null;
+    setTopic: (topic: string, input?: TopicInput) => Promise<void>;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<NoInfer<ChatTopic[]>, Error>>;
+};
+/**
+ * Your scheduled messages (in one conversation, or all), soonest first, with `schedule` and
+ * `cancel` (which also removes one that failed). `schedule` uploads its files to storage first,
+ * the way `send` does (the provider's `upload` hook, or a native URI read through `readFile`),
+ * then schedules them with the message. A file marked `hosted` goes to storage too.
+ */
+declare function useScheduled(conversationId?: string | null, opts?: {
+    enabled?: boolean;
+}): {
+    items: ScheduledMessage[];
+    isLoading: boolean;
+    error: Error | null;
+    schedule: (input: Omit<ScheduleInput, "clientId"> & {
+        clientId?: string;
+    }, files?: LocalFile[]) => Promise<string>;
+    cancel: (id: string) => Promise<void>;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<NoInfer<ScheduledMessage[]>, Error>>;
+};
+/**
+ * Availability: yours (`mine`, `setMine`) and, given a conversation, its members' (`members`,
+ * `forUser`). Pair with `awayLine` and `isWithinWorkingHours` from the core.
+ */
+declare function useAvailability(conversationId?: string | null): {
+    mine: NonNullable<NoInfer<ChatAvailability | null>> | null;
+    mineLoading: boolean;
+    setMine: (input: AvailabilityInput) => Promise<void>;
+    members: ChatAvailability[];
+    /** Everyone else's, without yours. */
+    others: ChatAvailability[];
+    forUser: (id: string) => ChatAvailability | null;
+    isLoading: boolean;
+};
+/** Sends one message into many conversations (replies come back privately in each). */
+declare function useBroadcast(): {
+    send: (conversationIds: string[], body: string, opts?: {
+        silent?: boolean;
+        clientId?: string;
+    }) => Promise<string[]>;
+    sending: boolean;
+};
+/** The value, once it has stopped changing for `ms`. */
+declare function useDebouncedValue<T>(value: T, ms: number): T;
+/** Search, debounced (250 ms by default), in one conversation or all of yours. Queries under two characters return nothing. */
+declare function useSearch(query: string, opts?: {
+    conversationId?: string | null;
+    debounceMs?: number;
+    limit?: number;
+}): {
+    hits: ChatSearchHit[];
+    /** The query the hits are for. */
+    query: string;
+    /** Typing, or fetching: results are on their way. */
+    isSearching: boolean;
+    error: Error | null;
+};
+/** At most this many link-preview reads at once, per client. */
+declare const LINK_PREVIEW_CONCURRENCY = 4;
+/**
+ * Link previews for these messages, by message id, in link order (only those the server has
+ * fetched). Pass the messages whose text has links (`extractLinks(body).length > 0`). One query
+ * per message, so a new message asks only for its own, and at most LINK_PREVIEW_CONCURRENCY
+ * run at once. One with none yet is asked again a few times, since the runner fills them
+ * moments after it lands.
+ */
+declare function useLinkPreviews(messageIds: (string | null | undefined)[]): Record<string, ChatLinkPreview[]>;
 
-export { type ChatPerson, ChatProvider, type ChatProviderProps, type ConversationState, LocalFile, QueuedMessage, ThreadItem, type UseConversationOptions, belongsTo, chatKeys, useChat, useConversation, useFileUrls, useInbox, useMessageActions, usePeople, usePerson, usePins, useStartConversation, useUnreadTotal };
+export { CATCH_UP_MAX_PAGES, CATCH_UP_PAGE, type ChatAttachmentKind, type ChatCardContext, type ChatPerson, ChatProvider, type ChatProviderProps, type ChatVideoUpload, type ConversationState, LINK_PREVIEW_CONCURRENCY, LocalFile, type MessagesData, QueuedMessage, ThreadItem, type UseConversationOptions, belongsTo, chatKeys, hostedUploadFrom, useAvailability, useBroadcast, useChat, useConversation, useDebouncedValue, useFileUrls, useInbox, useLinkPreviews, useMessageActions, usePeople, usePerson, usePins, useScheduled, useSearch, useStartConversation, useTopics, useUnreadTotal };

package/dist/react.js

@@ -1,5 +1,5 @@
-export { ChatProvider, belongsTo, chatKeys, useChat, useConversation, useFileUrls, useInbox, useMessageActions, usePeople, usePerson, usePins, useStartConversation, useUnreadTotal } from './chunk-27UTR5FW.js';
-import './chunk-SAY24E6V.js';
-import './chunk-JQXZUEEL.js';
+export { CATCH_UP_MAX_PAGES, CATCH_UP_PAGE, ChatProvider, LINK_PREVIEW_CONCURRENCY, belongsTo, chatKeys, hostedUploadFrom, useAvailability, useBroadcast, useChat, useConversation, useDebouncedValue, useFileUrls, useInbox, useLinkPreviews, useMessageActions, usePeople, usePerson, usePins, useScheduled, useSearch, useStartConversation, useTopics, useUnreadTotal } from './chunk-JU2FAPBI.js';
+import './chunk-A4YJX7KT.js';
+import './chunk-GBJ3YI4E.js';
 //# sourceMappingURL=react.js.map
 //# sourceMappingURL=react.js.map