nexus-shared 1.1.21 → 3.0.0

package/dist/Helpers/ChatBackend.js

@@ -0,0 +1,332 @@
+import { NexusModule } from "../Interfaces/ApiInterfaces.js";
+import { apiEndpoint } from "./ApiRoutes.js";
+import { chatPreviewText } from "./ChatHelpers.js";
+/*
+ * How a chat talks to a backend: which endpoint serves each action, what each request sends, and how each answer is
+ * read. `ChatBackend` is what an app implements for its own backend; `NexusChatBackend` is the Nexus one, and runs
+ * when nothing is registered. Nothing here calls anything — `apiChatSource` does that — so this file is pure and can
+ * be checked without a server.
+ *
+ * **The Nexus endpoints below are the shape the Chat module is expected to take, not an API that answers today.** The
+ * backend module (`NexusModule.Chat`, bit 6) exists as a number and a proxy key; its controller does not. Until it
+ * does, an app either registers its own backend with `defineChatBackend` or hands the components a `ChatSource` of
+ * its own (`localChatSource` keeps a conversation in memory). When the controller lands, whatever differs is one
+ * override here, not a change in every component.
+ */
+/** The actions a chat needs from a backend. A backend that does not serve one takes that feature off the panel. */
+export const CHAT_ACTIONS = {
+    /** The conversations a record holds, for this reader. */
+    conversations: "ConversationListing",
+    /** Starts one. */
+    createConversation: "CreateConversation",
+    /** One page of messages. */
+    history: "History",
+    /** Writes one message. */
+    send: "Create",
+    /** The counts of many records at once, for the trigger icons in a list. */
+    summaries: "Summaries",
+    /** The people in a conversation, and the ones who could join, searched. */
+    participants: "ParticipantPagination",
+    /** How far this user has read. */
+    read: "Read",
+    /** Removes one message. */
+    remove: "Delete",
+    /** Adds people to a conversation. */
+    addParticipants: "AddParticipants",
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const text = (value) => (typeof value === "string" && value.trim() !== "" ? value : null);
+const count = (value) => {
+    const number = Number(value);
+    return Number.isFinite(number) ? number : 0;
+};
+const id = (value) => (typeof value === "string" || typeof value === "number" ? value : null);
+/** Rows of an answer: an array, or the `results` of a page. */
+function rowsOf(result) {
+    const list = Array.isArray(result) ? result : isRecord(result) && Array.isArray(result.results) ? result.results : [];
+    return list.filter(isRecord);
+}
+/**
+ * What a chat needs from a backend. Extend it for an app whose chat API differs from the Nexus one, and register it
+ * once beside the app's API modules:
+ *
+ * @example
+ * class HrChatBackend extends NexusChatBackend {
+ *   override endpoint(action: ChatAction) {
+ *     return action === "history" ? apiEndpoint.post(HrModule.Staff, "LeaveChat/Page") : super.endpoint(action);
+ *   }
+ * }
+ * defineChatBackend(new HrChatBackend());
+ */
+export class ChatBackend {
+    /** Whether the backend serves an action. Default true; `false` takes the feature off the panel. */
+    supports(action) {
+        void action;
+        return true;
+    }
+    /** What removing a message sends, as the call's `params`: the id in the path. */
+    removeParams(scope, messageId) {
+        return { id: typeof messageId === "number" ? messageId : String(messageId), parentId: typeof scope.parentId === "number" ? scope.parentId : String(scope.parentId) };
+    }
+}
+/**
+ * The Nexus Chat module: one controller, `Chat`, whose actions take the domain, the parent id and the reader, and
+ * answer as the other Nexus endpoints do (`{ results, totalCount, filterCount }` for pages). See the note at the top
+ * of this file: these are the shape the module is expected to take.
+ */
+export class NexusChatBackend extends ChatBackend {
+    /** The module the chat endpoints live in. `NexusModule.Chat` (bit 6). */
+    module = NexusModule.Chat;
+    /** The controller the actions hang off. */
+    controller = "Chat";
+    endpoint(action) {
+        const path = `${this.controller}/${CHAT_ACTIONS[action]}`;
+        // This class builds the Nexus module's endpoints, so its module is a value of the Nexus enum rather than of the
+        // app's. An app whose modules are its own registers its own backend; the API layer looks a module up by value or
+        // by key either way, so the one cast here is the whole of the assumption.
+        const module = this.module;
+        // `subject` words the failure toasts; the panel shows its own messages, so the calls send `toast: false` for the rest.
+        switch (action) {
+            case "history":
+            case "summaries":
+            case "participants":
+            case "conversations":
+                return apiEndpoint.post(module, path, { action: "load", subject: "chat" });
+            case "createConversation":
+                return apiEndpoint.post(module, path, { action: "create", subject: "conversation" });
+            case "read":
+                return apiEndpoint.put(module, path, { action: "update", subject: "chat" });
+            case "remove":
+                return apiEndpoint.delete(module, `${path}/{id}`, { action: "delete", subject: "message" });
+            case "addParticipants":
+                return apiEndpoint.post(module, path, { action: "create", subject: "participants" });
+            default:
+                return apiEndpoint.post(module, path, { action: "create", subject: "message" });
+        }
+    }
+    conversationsRequest(scope) {
+        return { domainType: scope.domain, parentId: scope.parentId, userId: scope.userId };
+    }
+    readConversations(result) {
+        return rowsOf(result).map(row => this.toConversation(row));
+    }
+    createConversationRequest(scope, request) {
+        return {
+            domainType: scope.domain,
+            parentId: scope.parentId,
+            // The backend's `EChatTypes`: a one-to-one is 0 and a group is 1 until it says otherwise.
+            chatType: request.type === "one-to-one" ? 0 : 1,
+            title: request.title?.trim() || null,
+            userIds: request.userIds,
+        };
+    }
+    readConversation(result) {
+        const row = isRecord(result) ? result : {};
+        // A backend that answers with the whole list (the new one among the old) hands back the newest.
+        const rows = rowsOf(result);
+        return this.toConversation(rows.length === 1 ? rows[0] : rows.length > 1 ? (rows.find(one => one.isNew === true) ?? rows[0]) : row);
+    }
+    historyRequest(scope, request, conversationId) {
+        return {
+            domainType: scope.domain,
+            parentId: scope.parentId,
+            userId: scope.userId,
+            chatId: conversationId ?? null,
+            beforeId: request.before ?? null,
+            afterId: request.after ?? null,
+            maxCount: request.take,
+        };
+    }
+    readHistory(result) {
+        const page = isRecord(result) ? result : {};
+        const messages = rowsOf(result).map(row => this.toMessage(row));
+        const summary = isRecord(page.summary) ? this.toSummary(page.summary) : undefined;
+        const participants = Array.isArray(page.participants) ? page.participants.filter(isRecord).map(row => this.toParticipant(row)) : undefined;
+        return {
+            messages,
+            ...(typeof page.hasMore === "boolean" && { hasMore: page.hasMore }),
+            ...(summary && { summary }),
+            ...(participants && { participants }),
+            ...(typeof page.canSend === "boolean" && { canSend: page.canSend }),
+        };
+    }
+    sendRequest(scope, draft, conversationId) {
+        return {
+            domainType: scope.domain,
+            parentId: scope.parentId,
+            chatId: conversationId ?? null,
+            body: draft.body,
+            replyToId: draft.replyToId ?? null,
+            mentions: draft.mentions ?? [],
+            clientId: draft.clientId,
+        };
+    }
+    readMessage(result, scope, draft) {
+        // The answer is the saved message. A backend that answers with an id alone still gives the chat what it needs:
+        // the body it was sent, and this user as its author.
+        const row = isRecord(result) ? result : {};
+        const saved = this.toMessage(row);
+        return {
+            ...saved,
+            id: saved.id === "" ? (id(row) ?? draft.clientId) : saved.id,
+            authorId: saved.authorId === "" ? scope.userId : saved.authorId,
+            body: saved.body || draft.body,
+            clientId: draft.clientId,
+            status: "sent",
+        };
+    }
+    summariesRequest(domain, parentIds, userId) {
+        return { domainType: domain, parentIds, userId };
+    }
+    readSummaries(result) {
+        const summaries = new Map();
+        for (const row of rowsOf(result)) {
+            const parentId = id(row.parentId);
+            if (parentId === null)
+                continue;
+            summaries.set(String(parentId), this.toSummary(row));
+        }
+        return summaries;
+    }
+    participantsRequest(scope, query, conversationId) {
+        return {
+            domainType: scope.domain,
+            parentId: scope.parentId,
+            chatId: conversationId ?? null,
+            searchKeyword: query.search || undefined,
+            skipCount: query.skip,
+            maxCount: query.pageSize,
+        };
+    }
+    readParticipants(result) {
+        const page = result;
+        const items = rowsOf(result).map(row => this.toParticipant(row));
+        if (Array.isArray(page))
+            return { items, hasMore: false, total: items.length };
+        const total = isRecord(page) ? count(page.filterCount ?? page.totalCount) : items.length;
+        return { items, total, hasMore: items.length > 0 && total > 0 && items.length < total };
+    }
+    readMarkRequest(scope, upTo, conversationId) {
+        return { domainType: scope.domain, parentId: scope.parentId, chatId: conversationId ?? null, messageId: upTo };
+    }
+    addParticipantsRequest(scope, userIds, conversationId) {
+        return { domainType: scope.domain, parentId: scope.parentId, chatId: conversationId ?? null, userIds };
+    }
+    /**
+     * One conversation row. The type comes back as the backend's `EChatTypes` number (0 one-to-one, 1 group) or as a
+     * name; both are read, because which it will be is not settled.
+     */
+    toConversation(row) {
+        const written = String(row.chatType ?? row.type ?? "").toLowerCase().replace(/[\s_-]/g, "");
+        const group = written === "1" || written === "group";
+        const participants = Array.isArray(row.participants) ? row.participants.filter(isRecord).map(person => this.toParticipant(person)) : undefined;
+        return {
+            id: id(row.id ?? row.chatId) ?? "",
+            type: group ? "group" : "one-to-one",
+            title: text(row.title ?? row.name),
+            ...(participants && { participants }),
+            summary: this.toSummary(row),
+            createdAt: text(row.creationTime ?? row.createdAt),
+            createdBy: id(row.creatorUserId ?? row.createdBy),
+            ...(typeof row.canSend === "boolean" && { canSend: row.canSend }),
+            ...(row.isClosed === true && { closed: true }),
+        };
+    }
+    /** One message row. The names are the ones a Nexus contract uses; override this alone for a backend that differs. */
+    toMessage(row) {
+        return {
+            id: id(row.id) ?? "",
+            authorId: id(row.userId ?? row.authorId ?? row.creatorUserId) ?? "",
+            authorName: text(row.userName ?? row.authorName ?? row.creatorUserName),
+            authorAvatar: text(row.userImage ?? row.authorAvatar ?? row.photo),
+            body: typeof row.body === "string" ? row.body : typeof row.message === "string" ? row.message : "",
+            createdAt: text(row.creationTime ?? row.createdAt) ?? "",
+            editedAt: text(row.lastModificationTime ?? row.editedAt),
+            status: "sent",
+            replyToId: id(row.replyToId),
+            ...(Array.isArray(row.attachments) && {
+                attachments: row.attachments.filter(isRecord).map(file => ({
+                    id: id(file.id) ?? undefined,
+                    name: text(file.name ?? file.fileName) ?? "File",
+                    size: file.size === undefined ? undefined : count(file.size),
+                    url: text(file.url ?? file.path),
+                    contentType: text(file.contentType),
+                })),
+            }),
+            ...(row.isSystem === true && { isSystem: true }),
+            ...(Array.isArray(row.deliveredTo) && { deliveredTo: row.deliveredTo.map(id).filter((value) => value !== null) }),
+            ...(Array.isArray(row.readBy) && { readBy: row.readBy.map(id).filter((value) => value !== null) }),
+        };
+    }
+    /** One set of counts. */
+    toSummary(row) {
+        const lastText = text(row.lastMessageText ?? row.lastMessage ?? row.lastBody);
+        return {
+            messageCount: count(row.messageCount ?? row.totalCount),
+            unreadCount: count(row.unreadCount),
+            lastMessageAt: text(row.lastMessageAt ?? row.lastMessageTime),
+            lastMessageText: lastText === null ? null : chatPreviewText(lastText),
+            lastMessageBy: text(row.lastMessageBy ?? row.lastMessageUserName),
+            ...(row.participantCount !== undefined && { participantCount: count(row.participantCount) }),
+        };
+    }
+    /** One participant row. */
+    toParticipant(row) {
+        return {
+            id: id(row.id ?? row.userId) ?? "",
+            name: text(row.name ?? row.userName ?? row.fullName) ?? "Unknown",
+            avatar: text(row.avatar ?? row.userImage ?? row.photo),
+            role: text(row.role ?? row.designation),
+            ...(row.readOnly === true && { readOnly: true }),
+            lastReadAt: text(row.lastReadAt),
+            ...((row.isActive === false || row.inactive === true) && { inactive: true }),
+        };
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let registered;
+/** Makes an app's chat backend the one every chat uses, and returns it. Call it once, beside `defineApiModules`. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function defineChatBackend(backend) {
+    registered = backend;
+    return backend;
+}
+/** The app's chat backend: the one given to `defineChatBackend`, else the Nexus one. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function getChatBackend() {
+    return (registered ??= new NexusChatBackend());
+}
+// Domain names
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let domains = [];
+/**
+ * Names the app's domains, for the panel's heading and its messages. The values are the app's own enum, so this
+ * package never holds a number of its own: the owner's list is Leave, Procurement, Applicants, Students, Companies,
+ * Tenders and the account kinds, and which number each one is belongs to the backend's `EDomainTypes`.
+ *
+ * @example
+ * defineChatDomains([
+ *   { domain: EDomainTypes.Leave, key: "leave", label: "Leave request" },
+ *   { domain: EDomainTypes.Procurement, key: "procurement", label: "Purchase order" },
+ * ]);
+ */
+export function defineChatDomains(list) {
+    const seen = new Set();
+    for (const info of list) {
+        const key = String(info.domain);
+        if (seen.has(key))
+            throw new Error(`Two chat domains have the value ${key}.`);
+        seen.add(key);
+    }
+    domains = list;
+    return list;
+}
+/** The registered domains. Empty until an app calls `defineChatDomains`. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function getChatDomains() {
+    return domains;
+}
+/** A domain's name on screen, or `undefined` when the app has not named it. */
+export function chatDomainLabel(domain) {
+    return domains.find(info => String(info.domain) === String(domain))?.label;
+}

package/dist/Helpers/ChatHelpers.d.ts

@@ -0,0 +1,189 @@
+import type { AnyChatScope, ChatConversation, ChatConversationType, ChatHighlight, ChatId, ChatMessage, ChatParticipant, ChatPlaceSource, ChatScopeKey, ChatSource, ChatSummary } from "../Interfaces/ChatInterfaces.ts";
+import { type DateTimeFormatOptions } from "./DateTimeHelpers.ts";
+/** A conversation with no messages yet. */
+export declare const EMPTY_CHAT_SUMMARY: ChatSummary;
+/** Messages by the same author this close together are drawn as one run, with one avatar and one time. */
+export declare 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 declare function chatScopeKey(scope: Pick<AnyChatScope, "domain" | "parentId">): ChatScopeKey;
+/** Whether two scopes name the same conversation for the same reader. */
+export declare function sameChatScope(a: AnyChatScope | null | undefined, b: AnyChatScope | null | undefined): boolean;
+/**
+ * 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 declare function chatHighlight(summary: ChatSummary | null | undefined): ChatHighlight;
+/** Counts over 99 show as "99+", so a badge never grows wider than its icon. */
+export declare function chatBadgeText(count: number, max?: number): string;
+/** Compares ids the way the chat does: id 7 from an API and "7" from a URL are the same person or message. */
+export declare const sameChatId: (a: ChatId | null | undefined, b: ChatId | null | undefined) => boolean;
+/** A message's key for React, and for the maps that hold the conversation. */
+export declare const chatMessageKey: (message: ChatMessage) => string;
+/** Messages oldest first, as the thread reads. */
+export declare function sortChatMessages(messages: readonly ChatMessage[]): ChatMessage[];
+/**
+ * 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 declare function mergeChatMessages(held: readonly ChatMessage[], incoming: readonly ChatMessage[]): ChatMessage[];
+/** Messages this user has not read: the ones written by somebody else after `lastReadAt`. */
+export declare function countChatUnread(messages: readonly ChatMessage[], userId: ChatId, lastReadAt?: string | null): number;
+/**
+ * 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 declare function firstUnreadChatId(messages: readonly ChatMessage[], userId: ChatId, unreadCount: number): ChatId | null;
+/** The counts of a conversation held in full, for a source that keeps its own messages. */
+export declare function summarizeChatMessages(messages: readonly ChatMessage[], userId: ChatId, lastReadAt?: string | null): ChatSummary;
+/**
+ * How far a message of your own has got. The chat draws one mark for it, in one place, and this is the only thing that
+ * decides which: on its way, not sent, sent, it reached someone, someone read it, everyone read it.
+ */
+export type ChatDelivery = "sending" | "failed" | "sent" | "delivered" | "read" | "read-all";
+/** What each state is called, for the mark's tooltip and for a screen reader. */
+export declare const CHAT_DELIVERY_LABELS: Record<ChatDelivery, string>;
+/**
+ * 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 declare function chatDeliveryState(message: ChatMessage, userId: ChatId, participants?: readonly ChatParticipant[]): ChatDelivery;
+/** A file's size beside its name: "812 B", "248 KB", "3.4 MB". */
+export declare function chatFileSize(bytes: number | null | undefined): string;
+/** A message's first line as plain words, cut for a tooltip or a list: a message is Markdown, a preview is not. */
+export declare function chatPreviewText(body: string, max?: number): string;
+/** How a chat writes dates and times: the user's date settings, and the zone moments are shown in. */
+export type ChatTimeOptions = DateTimeFormatOptions;
+/** What the day divider says: "Today", "Yesterday", or the date in the user's calendar and format. */
+export declare function chatDayLabel(isoDate: string, options?: ChatTimeOptions, today?: string): string;
+/** A message's time of day, in the user's time format and script: "02:30 PM", "१४:३०". */
+export declare function chatTimeLabel(utc: string, options?: ChatTimeOptions): string;
+/** The ISO date a moment falls on in the reader's zone, which is the day its message is grouped under. */
+export declare function chatLocalDate(utc: string, timeZone?: string): string;
+/**
+ * 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 declare function chatTimeAgo(utc: string | null | undefined, options?: ChatTimeOptions, now?: number): string;
+/** Messages by one author, close together, drawn with one avatar and one time. */
+export interface ChatRun {
+    /** The author of every message in the run. */
+    authorId: ChatId;
+    authorName: string;
+    authorAvatar?: string | null;
+    /** Written by this user: the run sits on the right. */
+    mine: boolean;
+    /** Written by the system: a centered note, with no avatar and no side. */
+    system: boolean;
+    /** The "New messages" line goes before this run. */
+    startsUnread: boolean;
+    messages: readonly ChatMessage[];
+}
+/** One day of a conversation. */
+export interface ChatDay {
+    /** The ISO date in the reader's zone. */
+    date: string;
+    /** What the divider says: "Today", "Yesterday", or the date. */
+    label: string;
+    runs: readonly ChatRun[];
+}
+export interface ChatGroupOptions extends ChatTimeOptions {
+    /** Whose messages sit on the right. */
+    userId: ChatId;
+    /** The message the "New messages" line goes before. */
+    unreadFrom?: ChatId | null;
+    /** Minutes within which messages by one author join a run. Default 5. */
+    runMinutes?: number;
+    /** The day "Today" means. Default: the browser's today. */
+    today?: string;
+}
+/** What a message with no author name is called. */
+export declare 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 declare function groupChatMessages(messages: readonly ChatMessage[], options: ChatGroupOptions): ChatDay[];
+/** What a conversation is called: a group by its name or its people, a one-to-one by the other person. */
+export declare function chatConversationName(conversation: ChatConversation, userId: ChatId, fallback?: string): string;
+/** The counts of a whole place: every conversation in it added up, which is what one trigger icon stands for. */
+export declare function chatPlaceSummary(conversations: readonly ChatConversation[]): ChatSummary;
+/** Which conversation to open: the one with unread messages, else the one with the newest message, else the first. */
+export declare function pickChatConversation(conversations: readonly ChatConversation[]): ChatConversation | undefined;
+/** A conversation of two is a one-to-one; more, or a name, make a group. */
+export declare function chatTypeFor(userIds: readonly ChatId[], title?: string | null): ChatConversationType;
+/** What is being typed after an `@`: where it starts, and the letters so far. */
+export interface ChatMention {
+    /** Where the `@` is. */
+    at: number;
+    /** The caret, which is where the name being typed ends. */
+    end: number;
+    /** What has been typed after the `@`, which may be empty. */
+    query: string;
+}
+/**
+ * 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 declare function findChatMention(value: string, caret: number): ChatMention | null;
+/** The people an `@…` offers: those in the conversation whose name or role starts with, or contains, what was typed. */
+export declare function matchChatMentions(participants: readonly ChatParticipant[], query: string, max?: number): ChatParticipant[];
+/**
+ * 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 declare function applyChatMention(value: string, mention: ChatMention, person: ChatParticipant, href?: string | null): {
+    value: string;
+    caret: number;
+};
+/** The people named with @ in a body, by matching what is written against who is in the conversation. */
+export declare function readChatMentions(body: string, participants: readonly ChatParticipant[]): ChatId[];
+export interface LocalChatSourceOptions {
+    /** Who is reading: their messages are their own, and the unread count is theirs. */
+    userId: ChatId;
+    /** The messages it starts with, in any order. */
+    messages?: readonly ChatMessage[];
+    /** Everyone in the conversation, searched by `participants`. */
+    participants?: readonly ChatParticipant[];
+    /** How far this user had read, as a UTC moment. Without it, every message by somebody else is unread. */
+    lastReadAt?: string | null;
+    /** Milliseconds each call waits, so a demo shows its loading states. Default 0. */
+    delay?: number;
+    /** Fails every `send`, to show the failed state and Retry. */
+    failSend?: boolean;
+    /** The author a sent message is written by. Default the reader, named "You". */
+    author?: Pick<ChatParticipant, "name" | "avatar">;
+}
+/**
+ * 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 declare function localChatSource(options: LocalChatSourceOptions): ChatSource & {
+    messages: () => readonly ChatMessage[];
+};
+export interface LocalChatPlaceOptions {
+    userId: ChatId;
+    /** The conversations it starts with. */
+    conversations?: readonly ChatConversation[];
+    /** Everyone who could be put in a conversation here. */
+    participants?: readonly ChatParticipant[];
+    /** Milliseconds each call waits, so a demo shows its loading states. Default 0. */
+    delay?: number;
+    /** Starting a conversation is refused, to show what the panel does then. */
+    failCreate?: boolean;
+}
+/**
+ * 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 declare function localChatPlace(options: LocalChatPlaceOptions): ChatPlaceSource & {
+    list: () => readonly ChatConversation[];
+};