nexus-shared 1.1.21 → 3.0.0

package/dist/Helpers/ChatHelpers.js

@@ -0,0 +1,486 @@
+import { formatDate } from "./DateHelpers.js";
+import { markdownToPlainText } from "./MarkdownHelpers.js";
+import { formatNumber } from "./NumberHelpers.js";
+import { nowUtcDateTime, todayIsoDateIn, toLocalDateTime } from "./DateTimeHelpers.js";
+import { formatTime } from "./TimeHelpers.js";
+/*
+ * Pure helpers behind the chat: which conversation a scope names, which of the three looks the trigger icon takes,
+ * how messages fall into days and runs by the same author, how a page of messages joins the ones already held, and an
+ * in-memory `ChatSource` for demos and tests. No DOM, no React, no network.
+ */
+/** A conversation with no messages yet. */
+export const EMPTY_CHAT_SUMMARY = { messageCount: 0, unreadCount: 0 };
+/** Messages by the same author this close together are drawn as one run, with one avatar and one time. */
+export const CHAT_RUN_MINUTES = 5;
+/** A conversation's key: its domain and its parent id, `"1:482"`. Two scopes of the same record share it, whoever reads. */
+export function chatScopeKey(scope) {
+    return `${String(scope.domain)}:${String(scope.parentId)}`;
+}
+/** Whether two scopes name the same conversation for the same reader. */
+export function sameChatScope(a, b) {
+    if (!a || !b)
+        return a === b;
+    return chatScopeKey(a) === chatScopeKey(b) && String(a.userId) === String(b.userId);
+}
+/**
+ * Which of the three looks the trigger takes: `quiet` with no messages, `active` once the conversation has some, and
+ * `unread` once some are this user's to read. The icon never changes size between them.
+ */
+export function chatHighlight(summary) {
+    if (!summary)
+        return "quiet";
+    if (summary.unreadCount > 0)
+        return "unread";
+    return summary.messageCount > 0 ? "active" : "quiet";
+}
+/** Counts over 99 show as "99+", so a badge never grows wider than its icon. */
+export function chatBadgeText(count, max = 99) {
+    return count > max ? `${max}+` : String(count);
+}
+/** Compares ids the way the chat does: id 7 from an API and "7" from a URL are the same person or message. */
+export const sameChatId = (a, b) => a !== null && a !== undefined && b !== null && b !== undefined && String(a) === String(b);
+/** A message's key for React, and for the maps that hold the conversation. */
+export const chatMessageKey = (message) => String(message.clientId ?? message.id);
+/** The time a message is sorted by: its moment, and its id to break a tie. */
+function order(message) {
+    return `${message.createdAt}|${String(message.id)}`;
+}
+/** Messages oldest first, as the thread reads. */
+export function sortChatMessages(messages) {
+    return [...messages].sort((a, b) => (order(a) < order(b) ? -1 : order(a) > order(b) ? 1 : 0));
+}
+/**
+ * Joins a page of messages with the ones already held: oldest first, one entry per message, and a message that came
+ * back from the server replacing the one this browser sent (matched by `clientId`, then by id). The newer copy wins,
+ * so an edited body and a `sent` status both land.
+ */
+export function mergeChatMessages(held, incoming) {
+    if (incoming.length === 0)
+        return [...held];
+    // A message is known both by its id and by the client id it was sent with, so the copy this browser drew while the
+    // message was on its way is replaced in place, not left beside the one the server answered with.
+    const keysOf = (message) => (message.clientId ? [`id:${String(message.id)}`, `client:${message.clientId}`] : [`id:${String(message.id)}`]);
+    const list = [];
+    const places = new Map();
+    const place = (message) => {
+        const keys = keysOf(message);
+        const at = keys.map(key => places.get(key)).find(found => found !== undefined);
+        if (at === undefined) {
+            list.push(message);
+            for (const key of keys)
+                places.set(key, list.length - 1);
+            return;
+        }
+        const merged = { ...list[at], ...message };
+        list[at] = merged;
+        for (const key of keysOf(merged))
+            places.set(key, at);
+    };
+    for (const message of held)
+        place(message);
+    for (const message of incoming)
+        place(message);
+    return sortChatMessages(list);
+}
+/** Messages this user has not read: the ones written by somebody else after `lastReadAt`. */
+export function countChatUnread(messages, userId, lastReadAt) {
+    return messages.filter(message => !sameChatId(message.authorId, userId) && !message.isSystem && (!lastReadAt || message.createdAt > lastReadAt)).length;
+}
+/**
+ * Where the "New messages" line goes: the id of the first of the last `unreadCount` messages not written by this user.
+ * `null` when there is nothing unread. Worked out once, when a conversation opens, so the line does not move while it
+ * is being read.
+ */
+export function firstUnreadChatId(messages, userId, unreadCount) {
+    if (unreadCount <= 0)
+        return null;
+    const theirs = messages.filter(message => !sameChatId(message.authorId, userId) && !message.isSystem);
+    const first = theirs[Math.max(0, theirs.length - unreadCount)];
+    return first ? first.id : null;
+}
+/** The counts of a conversation held in full, for a source that keeps its own messages. */
+export function summarizeChatMessages(messages, userId, lastReadAt) {
+    const last = messages[messages.length - 1];
+    return {
+        messageCount: messages.length,
+        unreadCount: countChatUnread(messages, userId, lastReadAt),
+        lastMessageAt: last?.createdAt ?? null,
+        lastMessageText: last ? chatPreviewText(last.body) : null,
+        lastMessageBy: last?.authorName ?? null,
+    };
+}
+/** What each state is called, for the mark's tooltip and for a screen reader. */
+export const CHAT_DELIVERY_LABELS = {
+    sending: "Sending…",
+    failed: "Not sent",
+    sent: "Sent",
+    delivered: "Delivered",
+    read: "Read",
+    "read-all": "Read by everyone",
+};
+/**
+ * How far a message has got. Only the sender's own messages carry a mark, so the reader is left out of both lists: a
+ * message is not "read" because the person who wrote it has seen it. Somebody who has left the conversation is left
+ * out of "everyone", or a message could never be read by all of it.
+ */
+export function chatDeliveryState(message, userId, participants = []) {
+    if (message.status === "sending")
+        return "sending";
+    if (message.status === "failed")
+        return "failed";
+    const others = participants.filter(person => !sameChatId(person.id, userId) && !person.inactive);
+    const read = (message.readBy ?? []).filter(id => !sameChatId(id, userId));
+    if (read.length > 0)
+        return others.length > 0 && read.length >= others.length ? "read-all" : "read";
+    const delivered = (message.deliveredTo ?? []).filter(id => !sameChatId(id, userId));
+    return delivered.length > 0 ? "delivered" : "sent";
+}
+/** A file's size beside its name: "812 B", "248 KB", "3.4 MB". */
+export function chatFileSize(bytes) {
+    if (bytes === null || bytes === undefined || !Number.isFinite(bytes) || bytes < 0)
+        return "";
+    if (bytes < 1024)
+        return `${Math.round(bytes)} B`;
+    const units = ["KB", "MB", "GB", "TB"];
+    let size = bytes / 1024;
+    let unit = 0;
+    while (size >= 1024 && unit < units.length - 1) {
+        size /= 1024;
+        unit++;
+    }
+    return `${formatNumber(size, { decimals: size < 10 ? 1 : 0 })} ${units[unit]}`;
+}
+/** A message's first line as plain words, cut for a tooltip or a list: a message is Markdown, a preview is not. */
+export function chatPreviewText(body, max = 120) {
+    const line = markdownToPlainText(body).replace(/\s+/g, " ").trim();
+    return line.length > max ? `${line.slice(0, max - 1)}…` : line;
+}
+/** What the day divider says: "Today", "Yesterday", or the date in the user's calendar and format. */
+export function chatDayLabel(isoDate, options = {}, today = todayIsoDateIn(options.timeZone)) {
+    if (isoDate === today)
+        return "Today";
+    if (isoDate === addIsoDays(today, -1))
+        return "Yesterday";
+    return formatDate(isoDate, options);
+}
+/** A message's time of day, in the user's time format and script: "02:30 PM", "१४:३०". */
+export function chatTimeLabel(utc, options = {}) {
+    const local = toLocalDateTime(utc, options.timeZone);
+    if (!local)
+        return "";
+    return formatTime(local.time, { format: options.timeFormat, script: options.script === "devanagari" ? "devanagari" : "latin", seconds: false });
+}
+/** The ISO date a moment falls on in the reader's zone, which is the day its message is grouped under. */
+export function chatLocalDate(utc, timeZone) {
+    return toLocalDateTime(utc, timeZone)?.date ?? "";
+}
+/** A day before or after an ISO date, for "Yesterday". */
+function addIsoDays(isoDate, days) {
+    const ms = Date.parse(`${isoDate}T00:00:00.000Z`);
+    if (!Number.isFinite(ms))
+        return isoDate;
+    return new Date(ms + days * 86_400_000).toISOString().slice(0, 10);
+}
+/**
+ * How long ago, in few words, for the trigger's tooltip: "just now", "14 min ago", "3 h ago", "yesterday", then the
+ * date itself. Never a live-updating clock: the tooltip is read once.
+ */
+export function chatTimeAgo(utc, options = {}, now = Date.now()) {
+    if (!utc)
+        return "";
+    const then = Date.parse(utc);
+    if (!Number.isFinite(then))
+        return "";
+    const minutes = Math.floor((now - then) / 60_000);
+    if (minutes < 1)
+        return "just now";
+    if (minutes < 60)
+        return `${minutes} min ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours} h ago`;
+    if (hours < 48)
+        return "yesterday";
+    return formatDate(chatLocalDate(utc, options.timeZone), options);
+}
+/** What a message with no author name is called. */
+export const CHAT_UNKNOWN_AUTHOR = "Unknown";
+/**
+ * Lays a conversation out the way it is drawn: a day at a time, and inside a day, runs of messages by one author sent
+ * within `runMinutes` of each other. A system note is always its own run, and the first unread message always starts
+ * one, so the "New messages" line never has to split a bubble group.
+ */
+export function groupChatMessages(messages, options) {
+    const { userId, unreadFrom = null, runMinutes = CHAT_RUN_MINUTES, today = todayIsoDateIn(options.timeZone) } = options;
+    const gap = runMinutes * 60_000;
+    const days = [];
+    let day = null;
+    let run = null;
+    for (const message of messages) {
+        const date = chatLocalDate(message.createdAt, options.timeZone) || today;
+        if (!day || day.date !== date) {
+            day = { date, label: chatDayLabel(date, options, today), runs: [] };
+            days.push(day);
+            run = null;
+        }
+        const at = Date.parse(message.createdAt);
+        const system = message.isSystem === true;
+        const unread = unreadFrom !== null && sameChatId(message.id, unreadFrom);
+        const joins = run !== null &&
+            !unread &&
+            run.system === system &&
+            sameChatId(run.authorId, message.authorId) &&
+            Number.isFinite(at) &&
+            Number.isFinite(run.last) &&
+            at - run.last <= gap;
+        if (joins && run) {
+            run.messages.push(message);
+            run.last = at;
+            continue;
+        }
+        run = {
+            authorId: message.authorId,
+            authorName: message.authorName?.trim() || (system ? "" : CHAT_UNKNOWN_AUTHOR),
+            authorAvatar: message.authorAvatar ?? null,
+            mine: !system && sameChatId(message.authorId, userId),
+            system,
+            startsUnread: unread,
+            messages: [message],
+            last: Number.isFinite(at) ? at : 0,
+        };
+        day.runs.push(run);
+    }
+    return days;
+}
+// Conversations at a place
+/** What a conversation is called: a group by its name or its people, a one-to-one by the other person. */
+export function chatConversationName(conversation, userId, fallback = "Conversation") {
+    const title = conversation.title?.trim();
+    if (title)
+        return title;
+    const others = (conversation.participants ?? []).filter(person => !sameChatId(person.id, userId));
+    if (others.length === 0)
+        return conversation.type === "one-to-one" ? fallback : "Just you";
+    if (others.length === 1)
+        return others[0].name;
+    if (others.length === 2)
+        return `${others[0].name} and ${others[1].name}`;
+    return `${others[0].name}, ${others[1].name} and ${others.length - 2} other${others.length - 2 === 1 ? "" : "s"}`;
+}
+/** The counts of a whole place: every conversation in it added up, which is what one trigger icon stands for. */
+export function chatPlaceSummary(conversations) {
+    let messageCount = 0;
+    let unreadCount = 0;
+    let lastMessageAt = null;
+    let lastMessageText = null;
+    let lastMessageBy = null;
+    for (const conversation of conversations) {
+        const summary = conversation.summary;
+        if (!summary)
+            continue;
+        messageCount += summary.messageCount;
+        unreadCount += summary.unreadCount;
+        if (summary.lastMessageAt && (!lastMessageAt || summary.lastMessageAt > lastMessageAt)) {
+            lastMessageAt = summary.lastMessageAt;
+            lastMessageText = summary.lastMessageText ?? null;
+            lastMessageBy = summary.lastMessageBy ?? null;
+        }
+    }
+    return { messageCount, unreadCount, lastMessageAt, lastMessageText, lastMessageBy, conversationCount: conversations.length };
+}
+/** Which conversation to open: the one with unread messages, else the one with the newest message, else the first. */
+export function pickChatConversation(conversations) {
+    if (conversations.length === 0)
+        return undefined;
+    const unread = conversations.filter(conversation => (conversation.summary?.unreadCount ?? 0) > 0);
+    const from = unread.length > 0 ? unread : conversations;
+    return [...from].sort((a, b) => (b.summary?.lastMessageAt ?? "").localeCompare(a.summary?.lastMessageAt ?? ""))[0];
+}
+/** A conversation of two is a one-to-one; more, or a name, make a group. */
+export function chatTypeFor(userIds, title) {
+    return userIds.length === 1 && !title?.trim() ? "one-to-one" : "group";
+}
+/**
+ * The `@…` the caret sits in, or `null`. An `@` only counts at the start of a word, so an email address does not open
+ * the list, and a space ends it — a name of two words is picked from the list rather than typed through.
+ */
+export function findChatMention(value, caret) {
+    const before = value.slice(0, caret);
+    const at = before.lastIndexOf("@");
+    if (at === -1)
+        return null;
+    // Only at the start of a word: the character before it must be nothing, a space, or a line break.
+    const prior = at === 0 ? "" : before[at - 1];
+    if (prior && !/[\s(\[{]/.test(prior))
+        return null;
+    const query = before.slice(at + 1);
+    if (/[\s@]/.test(query))
+        return null;
+    return { at, end: caret, query };
+}
+/** The people an `@…` offers: those in the conversation whose name or role starts with, or contains, what was typed. */
+export function matchChatMentions(participants, query, max = 8) {
+    const text = query.trim().toLowerCase();
+    const live = participants.filter(person => !person.inactive);
+    if (!text)
+        return live.slice(0, max);
+    // Three tiers, best first: the whole name begins with it, a word of the name does, or it is in there somewhere.
+    const begins = [];
+    const words = [];
+    const holds = [];
+    for (const person of live) {
+        const name = person.name.toLowerCase();
+        if (name.startsWith(text))
+            begins.push(person);
+        else if (name.split(/\s+/).some(word => word.startsWith(text)))
+            words.push(person);
+        else if (name.includes(text) || (person.role ?? "").toLowerCase().includes(text))
+            holds.push(person);
+    }
+    return [...begins, ...words, ...holds].slice(0, max);
+}
+/**
+ * Puts a name into the text being written, in place of the `@…` that was typed. A message is Markdown, so with
+ * `href` the name becomes a link; without one it is plain `@Name`, and the id travels in the draft's `mentions`.
+ */
+export function applyChatMention(value, mention, person, href) {
+    const name = person.name.trim();
+    const written = href ? `[@${name}](${href}) ` : `@${name} `;
+    const next = value.slice(0, mention.at) + written + value.slice(mention.end);
+    return { value: next, caret: mention.at + written.length };
+}
+/** The people named with @ in a body, by matching what is written against who is in the conversation. */
+export function readChatMentions(body, participants) {
+    const found = [];
+    for (const person of participants) {
+        const name = person.name.trim();
+        if (!name)
+            continue;
+        // The name as it was put in, plain or as a link; a longer name wins, so "@Sita Rai" is not read as "@Sita".
+        if (body.includes(`@${name}`) || body.includes(`[@${name}]`))
+            found.push(person.id);
+    }
+    return found;
+}
+/**
+ * A `ChatSource` that keeps everything in memory: the whole chat without a backend, for a demo page, a test, or a
+ * page that already has its messages. It answers pages, sends, searches its participants, and keeps the read mark.
+ *
+ * @example
+ * const source = localChatSource({ userId: 7, messages: DEMO_MESSAGES });
+ * <ChatPanel scope={scope} source={source} title="Leave request #482" />
+ */
+export function localChatSource(options) {
+    let held = sortChatMessages(options.messages ?? []);
+    let lastReadAt = options.lastReadAt ?? null;
+    let sequence = 0;
+    const wait = () => (options.delay ? new Promise(resolve => setTimeout(resolve, options.delay)) : Promise.resolve());
+    return {
+        messages: () => held,
+        async history(request) {
+            await wait();
+            if (request.after) {
+                const from = held.findIndex(message => sameChatId(message.id, request.after));
+                return { messages: from === -1 ? [] : held.slice(from + 1), hasMore: false, summary: summarizeChatMessages(held, options.userId, lastReadAt) };
+            }
+            const end = request.before ? held.findIndex(message => sameChatId(message.id, request.before)) : held.length;
+            const stop = end === -1 ? held.length : end;
+            const start = Math.max(0, stop - request.take);
+            return {
+                messages: held.slice(start, stop),
+                hasMore: start > 0,
+                summary: summarizeChatMessages(held, options.userId, lastReadAt),
+                participants: options.participants,
+            };
+        },
+        async send(draft) {
+            await wait();
+            if (options.failSend)
+                throw new Error("The message could not be sent.");
+            const message = {
+                id: `local-${++sequence}`,
+                authorId: options.userId,
+                authorName: options.author?.name ?? "You",
+                authorAvatar: options.author?.avatar ?? null,
+                body: draft.body,
+                createdAt: nowUtcDateTime(),
+                status: "sent",
+                replyToId: draft.replyToId ?? null,
+                ...(draft.files?.length && { attachments: draft.files.map(file => ({ name: file.name, size: file.size, contentType: file.type })) }),
+            };
+            held = [...held, message];
+            return message;
+        },
+        async participants(query) {
+            await wait();
+            const search = query.search.trim().toLowerCase();
+            const all = options.participants ?? [];
+            const found = search ? all.filter(person => `${person.name} ${person.role ?? ""}`.toLowerCase().includes(search)) : all;
+            return { items: found.slice(query.skip, query.skip + query.pageSize), total: found.length, hasMore: query.skip + query.pageSize < found.length };
+        },
+        async markRead(upTo) {
+            await wait();
+            const message = held.find(item => sameChatId(item.id, upTo));
+            if (message && (!lastReadAt || message.createdAt > lastReadAt))
+                lastReadAt = message.createdAt;
+        },
+        async remove(id) {
+            await wait();
+            held = held.filter(message => !sameChatId(message.id, id));
+        },
+    };
+}
+/**
+ * A `ChatPlaceSource` that keeps its conversations in memory: a record with several conversations, and starting
+ * another, without a backend. A one-to-one with somebody who already has one comes back rather than being made twice,
+ * which is the rule the real backend is expected to follow.
+ */
+export function localChatPlace(options) {
+    let held = [...(options.conversations ?? [])];
+    let sequence = held.length;
+    const wait = () => (options.delay ? new Promise(resolve => setTimeout(resolve, options.delay)) : Promise.resolve());
+    const everyone = options.participants ?? [];
+    return {
+        list: () => held,
+        async conversations() {
+            await wait();
+            return [...held].sort((a, b) => (b.summary?.lastMessageAt ?? "").localeCompare(a.summary?.lastMessageAt ?? ""));
+        },
+        async create(request) {
+            await wait();
+            if (options.failCreate)
+                throw new Error("The conversation could not be started.");
+            const type = chatTypeFor(request.userIds, request.title);
+            if (type === "one-to-one") {
+                const other = request.userIds[0];
+                const existing = held.find(conversation => conversation.type === "one-to-one" &&
+                    (conversation.participants ?? []).some(person => sameChatId(person.id, other)) &&
+                    (conversation.participants ?? []).some(person => sameChatId(person.id, options.userId)));
+                if (existing)
+                    return existing;
+            }
+            const people = [
+                ...everyone.filter(person => request.userIds.some(id => sameChatId(id, person.id))),
+                ...(everyone.some(person => sameChatId(person.id, options.userId)) ? everyone.filter(person => sameChatId(person.id, options.userId)) : [{ id: options.userId, name: "You" }]),
+            ];
+            const made = {
+                id: `local-chat-${++sequence}`,
+                type,
+                title: request.title?.trim() || null,
+                participants: people,
+                summary: { ...EMPTY_CHAT_SUMMARY, lastMessageAt: nowUtcDateTime() },
+                createdAt: nowUtcDateTime(),
+                createdBy: options.userId,
+                canSend: true,
+            };
+            held = [made, ...held];
+            return made;
+        },
+        async participants(query) {
+            await wait();
+            const search = query.search.trim().toLowerCase();
+            const found = (search ? everyone.filter(person => `${person.name} ${person.role ?? ""}`.toLowerCase().includes(search)) : everyone).filter(person => !sameChatId(person.id, options.userId));
+            return { items: found.slice(query.skip, query.skip + query.pageSize), total: found.length, hasMore: query.skip + query.pageSize < found.length };
+        },
+    };
+}

package/dist/Helpers/ChatHooks.d.ts

@@ -0,0 +1,81 @@
+import type { AnyChatScope, ChatConversation, ChatDomainValue, ChatId, ChatParticipant, ChatPlaceSource, ChatScope, ChatSource, ChatSummary, NewChatRequest } from "../Interfaces/ChatInterfaces.ts";
+import type { ChatSummaryState } from "./ChatSummaries.ts";
+import { ChatStore, type ChatSnapshot } from "./ChatStore.ts";
+export interface UseChatOptions<TDomain extends ChatDomainValue = ChatDomainValue> {
+    /** Which conversation: the domain, the record, and the reader. */
+    scope: ChatScope<TDomain>;
+    /** Which conversation at the place, when the record holds more than one. */
+    conversationId?: ChatId;
+    /** Where the messages come from. Default: the app's API, through its `ChatBackend`. */
+    source?: ChatSource;
+    /** Messages per page. Default 30. */
+    pageSize?: number;
+    /** Milliseconds between checks for new messages. 0 turns it off. Default 15,000. */
+    pollInterval?: number;
+    /** The counts the page already had, so the header opens filled. */
+    summary?: ChatSummary;
+    /** The participants the page already had, so the panel makes no call for them. */
+    participants?: readonly ChatParticipant[];
+    /** Loads and watches only while this is true: a closed panel costs nothing. Default true. */
+    enabled?: boolean;
+}
+/** The store and what it holds. The store's methods (`send`, `loadOlder`, `markRead`) are stable; the state is not. */
+export interface ChatHandle {
+    store: ChatStore;
+    state: ChatSnapshot;
+}
+/**
+ * One conversation, kept for as long as the scope stays the same.
+ *
+ * @example
+ * const { store, state } = useChat({ scope, enabled: open });
+ * state.messages.map(…);
+ * store.send(text);
+ */
+export declare function useChat<TDomain extends ChatDomainValue = ChatDomainValue>(options: UseChatOptions<TDomain>): ChatHandle;
+export interface UseChatPlaceOptions<TDomain extends ChatDomainValue = ChatDomainValue> {
+    /** Which record: the domain, the record, and the reader. */
+    scope: ChatScope<TDomain>;
+    /** Where the conversations come from. Default: the app's API, through its `ChatBackend`. */
+    place?: ChatPlaceSource;
+    /** The conversations the page already had, so the panel makes no call for them. */
+    conversations?: readonly ChatConversation[];
+    /** Loads only while this is true: a closed panel costs nothing. Default true. */
+    enabled?: boolean;
+}
+/** The conversations a record holds, and what can be done with them. */
+export interface ChatPlaceHandle {
+    conversations: readonly ChatConversation[];
+    loading: boolean;
+    /** Why the list could not be read. */
+    error: string | null;
+    /** A conversation can be started here. */
+    canCreate: boolean;
+    /** One is being started. */
+    creating: boolean;
+    /** Reads the list again. */
+    reload: () => Promise<void>;
+    /** Starts one, and answers with it — the one that already existed, if the backend found one. */
+    create: (request: NewChatRequest) => Promise<ChatConversation | null>;
+    /** Who can be put in a conversation here. */
+    searchParticipants: ChatPlaceSource["participants"];
+    /** Writes a conversation's new counts into the list, so the switch and the trigger icon follow a panel. */
+    apply: (conversationId: ChatId, summary: ChatSummary) => void;
+}
+/**
+ * The conversations one record holds. A leave request can carry several — the manager and the applicant in one, the
+ * managers between themselves in another — and this is the list behind the switch, the New chat form, and the one
+ * count the trigger icon shows for the record as a whole.
+ */
+export declare function useChatPlace<TDomain extends ChatDomainValue = ChatDomainValue>(options: UseChatPlaceOptions<TDomain>): ChatPlaceHandle;
+/** What a trigger icon knows about a record: its counts, and whether they have arrived. */
+export interface ChatSummaryHandle {
+    summary: ChatSummary | undefined;
+    state: ChatSummaryState;
+}
+/**
+ * The counts one trigger icon draws itself from. Without `given`, it asks the page's cache, which collects every icon
+ * that mounted in the same moment and fills them in one call per domain. With `given` — a list whose rows already
+ * carry the counts — nothing is asked at all.
+ */
+export declare function useChatSummary(scope: AnyChatScope, given?: ChatSummary): ChatSummaryHandle;