@ethora/chat-component 26.9.5 → 26.9.8

package/dist/components/Modals/styledModalComponents.d.ts

@@ -9,8 +9,6 @@ export declare const ModalContainer: import('styled-components/dist/types').ISty
 export declare const ModalTitle: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, never>> & string;
 /** Small uppercase-weight label above a field/list inside a modal - e.g. "Select Users (max 20)". */
 export declare const ModalSectionLabel: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
-/** 48px-min-height row used for members/blocked-users/etc. lists inside modals. */
-export declare const ModalListRow: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
 export declare const ModalDescription: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, never>> & string;
 export declare const GroupContainer: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
 export declare const ModalContainerFullScreen: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
@@ -24,15 +22,9 @@ export declare const HeaderRight: import('styled-components/dist/types').IStyled
 export declare const CenterContainer: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<Omit<import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>, "ref"> & {
     ref?: import('react').Ref<HTMLDivElement>;
 }, never>> & string;
-export declare const ProfileImage: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
-export declare const UserInfo: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
 export declare const UserName: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
-export declare const UserStatus: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
-export declare const BorderedContainer: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
-export declare const LabelData: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
 export declare const Label: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>> & string;
 export declare const ActionButton: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<Omit<ButtonProps & import('react').RefAttributes<HTMLButtonElement>, "ref"> & {
     ref?: import('react').Ref<HTMLButtonElement>;
 }, never>> & string & Omit<import('react').ForwardRefExoticComponent<ButtonProps & import('react').RefAttributes<HTMLButtonElement>>, keyof import('react').Component<any, {}, any>>;
-export declare const EmptySection: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
 export declare const Divider: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;

package/dist/components/styled/RoomListComponents/index.d.ts

@@ -37,3 +37,6 @@ export declare const SkeletonLines: import('styled-components/dist/types').IStyl
 export declare const SkeletonLine: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
     $width?: string;
 }>> & string;
+export declare const MessageMatches: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const MessageMatchesTitle: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const MessageMatchesNote: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;

package/dist/context/ToastContext.d.ts

@@ -7,4 +7,11 @@ export declare const ToastProvider: React.FC<{
     children: ReactNode;
 }>;
 export declare const useToast: () => ToastContextType;
+/**
+ * `useToast` for code that can run outside a ToastProvider (a MessageList
+ * rendered on its own, a host that mounts pieces of the chat directly): it
+ * gets `undefined` instead of a thrown error, and simply has nowhere to show
+ * a toast.
+ */
+export declare const useOptionalToast: () => ToastContextType | undefined;
 export {};

package/dist/firebase-messaging-sw.js

@@ -172,8 +172,26 @@ function pickUrl(raw = {}, data = {}, notification = {}) {
   );
 }
 
-function pickIcon() {
-  return CUSTOM_ICON || DEFAULT_ICON;
+// An icon the push itself carries (data.icon, notification.icon or icon on
+// the payload) wins over the one configured for the whole app: a push about a
+// specific chat or sender knows better than the app-wide default. Only http(s)
+// and same-origin paths are accepted; anything else (data:, javascript:, a
+// bare word) is ignored and the configured/default icon is used instead.
+function sanitizeIconUrl(value) {
+  const url = typeof value === 'string' ? value.trim() : '';
+  if (!url) return '';
+  if (url.charAt(0) === '/' && url.charAt(1) !== '/') return url;
+  return /^https?:\/\/[^\s]+$/i.test(url) ? url : '';
+}
+
+function pickIcon(raw = {}, data = {}, notification = {}) {
+  return (
+    sanitizeIconUrl(data.icon) ||
+    sanitizeIconUrl(notification.icon) ||
+    sanitizeIconUrl(raw.icon) ||
+    CUSTOM_ICON ||
+    DEFAULT_ICON
+  );
 }
 
 function pickBadge() {
@@ -332,7 +350,7 @@ async function handlePush(raw = {}, source = 'push') {
   const title = pickTitle(raw, data, notification);
   const body = pickBody(raw, data, notification);
   const url = pickUrl(raw, data, notification);
-  const icon = pickIcon();
+  const icon = pickIcon(raw, data, notification);
   const badge = pickBadge();
   const image = pickImage(raw, data, notification);
 

package/dist/{handleCopyClick-DPjxMoJn.js → handleCopyClick-BtXos0AJ.js}

@@ -1,4 +1,4 @@
-import { x as e, z as t } from "./main-BRIZ98KV.js";
+import { x as e, z as t } from "./main-BnLtessp.js";
 const i = e.div`
   display: flex;
   flex-direction: column;

package/dist/helpers/checkUniqueUsers.d.ts

@@ -1,3 +1,3 @@
 import { IMessage, RoomMember } from '../types/types';
-export declare const checkUniqueUsers: (messages: IMessage[]) => Promise<RoomMember[]>;
-export declare const checkSingleUser: (usersSet: Record<string, RoomMember>, xmppUsername: string) => Promise<RoomMember>;
+export declare const checkUniqueUsers: (messages: IMessage[]) => any;
+export declare const checkSingleUser: (usersSet: Record<string, RoomMember>, xmppUsername: string) => Promise<any>;

package/dist/helpers/constants/MODAL_TYPES.d.ts

@@ -4,6 +4,8 @@ export declare const MODAL_TYPES: {
     CHAT_PROFILE: string;
     MANAGE_DATA: string;
     VISIBILITY: string;
+    MESSAGE_SEARCH: string;
+    PUBLIC_CHATS: string;
     FILE_PREVIEW: string;
 };
 /**

package/dist/helpers/dedupeMembers.d.ts

@@ -0,0 +1,10 @@
+import { RoomMember } from '../types/types';
+/** Stable identity of a member: normalised xmppUsername local part, else _id. */
+export declare const memberKey: (m: Partial<RoomMember> | null | undefined) => string;
+/**
+ * Drops repeated members (keeps the first occurrence, order preserved).
+ * The room directory endpoint can return the same user on several pages;
+ * duplicates would produce duplicate React keys and inflated counts.
+ * Members without any identity are dropped.
+ */
+export declare const dedupeMembers: <T extends Partial<RoomMember>>(list: ReadonlyArray<T> | null | undefined) => T[];

package/dist/helpers/historyPreloadConfig.d.ts

@@ -0,0 +1,25 @@
+import { IConfig } from '../types/types';
+export type HistoryPreloadMode = 'staged' | 'all' | 'off';
+export interface ResolvedHistoryPreload {
+    /**
+     * 'legacy' only when a host explicitly pinned
+     * `historyQoS.stagedPreloadEnabled: false`: the old cache catch-up path
+     * (updateMessagesTillLast). Everything else resolves to a public mode.
+     */
+    mode: HistoryPreloadMode | 'legacy';
+    /** Rooms (by recent activity) the background sweep covers. 0 = no cap. */
+    topRooms: number;
+    concurrency: number;
+    firstPassSize: number;
+    secondPassSize: number;
+}
+export declare const DEFAULT_PRELOAD_TOP_ROOMS = 8;
+export declare const DEFAULT_PRELOAD_CONCURRENCY = 3;
+export declare const TEASER_ROOM_FACTOR = 4;
+/**
+ * One place that turns `config.historyPreload` (and the older
+ * `historyQoS.stagedPreload*` / `preloadTopKRooms` names, still honoured)
+ * into the numbers the preload sweeps use. Staged preload is the default:
+ * the sweep covers the top N rooms, every other room loads when it is opened.
+ */
+export declare const resolveHistoryPreloadConfig: (config?: Pick<IConfig, "historyPreload" | "historyQoS"> | null) => ResolvedHistoryPreload;

package/dist/helpers/historyPreloadScheduler.d.ts

@@ -1,4 +1,5 @@
 import { default as XmppClient } from '../networking/xmppClient';
+import { IRoom } from '../types/types';
 interface HistoryPreloadSchedulerOptions {
     client: XmppClient;
     signal?: AbortSignal;
@@ -10,6 +11,8 @@ interface HistoryPreloadSchedulerOptions {
     defaultRoomJids?: string[];
     forceReload?: boolean;
     completionState?: 'done' | 'partial';
+    skipApiPreview?: boolean;
 }
+export declare const hasApiPreview: (room?: IRoom) => boolean;
 export declare const runHistoryPreloadScheduler: (options: HistoryPreloadSchedulerOptions) => Promise<void>;
 export default runHistoryPreloadScheduler;

package/dist/helpers/insertMessageWithDelimiter.d.ts

@@ -1,4 +1,5 @@
 import { IMessage } from '../types/types';
+export declare function deepMerge(target: any, source: any): any;
 export declare function insertMessageWithDelimiter(roomMessages: Partial<IMessage>[], message: IMessage, lastViewedTimestamp: {
     toString: () => string;
 }): void;

package/dist/helpers/isMessageSearchEnabled.d.ts

@@ -0,0 +1,9 @@
+import { IConfig } from '../types/types';
+/**
+ * The single rule for message search. It is opt-in: the host must set
+ * `enableMessageSearch` AND provide an `appId` (the archive endpoint is scoped
+ * by app). A leftover `disableMessageSearch: true` still wins as a hard off.
+ * Every entry point (header button, profile entry, chat-list matches, the
+ * Ctrl/Cmd+F shortcut, the modal itself) goes through this helper.
+ */
+export declare const isMessageSearchEnabled: (config?: Pick<IConfig, "enableMessageSearch" | "disableMessageSearch" | "appId"> | null) => boolean;

package/dist/helpers/jumpThread.d.ts

@@ -0,0 +1,56 @@
+import { IMessage } from '../types/types';
+/** How long a jump request may stay pending before it is dropped. */
+export declare const JUMP_TTL_MS = 60000;
+/**
+ * Index of the message a jump names.
+ *
+ * By id first (message.id is the MAM stanza id for history, xmppId the client
+ * message id). When the request has no id at all, which is common for archive
+ * rows, by content: same text, sent within a few seconds of the same time.
+ */
+export declare const findMessageIndex: (messages: IMessage[], ids: string[], content?: {
+    createdAt?: string;
+    body?: string;
+}) => number;
+/**
+ * Where a jump to a thread REPLY lands, and the thread panel's parent message
+ * when that message is not in the room's live list.
+ *
+ * Replies never appear in the main list (it hides them unless they are also
+ * shown in the channel), so a jump to one has to open its parent's thread and
+ * highlight the reply there. Two things have to be remembered for that:
+ *  - which list owns the jump: `at` is the pending request this entry serves,
+ *    `parentId` the thread that owns it. The main list stays inert for a jump
+ *    that has an owner thread, and a thread list stays inert for any jump that
+ *    is not its own (see useJumpToMessage);
+ *  - the parent and the replies when they exist only in a jump window or came
+ *    from a separate fetch: the thread panel reads them from here, so it does
+ *    not depend on the window that found them still being on screen.
+ *
+ * Kept outside redux on purpose: the room slice's thread flag lives on
+ * messages of the live list, which is exactly what these messages are not in.
+ */
+export interface JumpThreadState {
+    roomJID: string;
+    parentId: string;
+    /** The pending request this entry serves; null for a thread opened by hand. */
+    at: number | null;
+    /** Set only when the parent is not in the room's live messages. */
+    parent: IMessage | null;
+    /** Replies known to belong to the thread beyond the live list. */
+    replies: IMessage[];
+}
+export declare const getJumpThread: () => JumpThreadState | null;
+export declare const setJumpThread: (next: JumpThreadState | null) => void;
+export declare const clearJumpThread: () => void;
+export declare const subscribeJumpThread: (listener: () => void) => (() => void);
+export declare const useJumpThread: () => JumpThreadState | null;
+/** The thread that owns the jump `at`, or null when the main list does. */
+export declare const ownerThreadFor: (thread: JumpThreadState | null, at: number | undefined) => string | null;
+/**
+ * The parent id of a message that is a thread reply and nothing else, or null:
+ * a reply also shown in the channel is in the main list, so it needs no thread.
+ */
+export declare const replyParentId: (message: IMessage) => string | null;
+/** `a` then `b`, one entry per message id, oldest first. */
+export declare const mergeById: (a: IMessage[], b: IMessage[]) => IMessage[];

package/dist/helpers/jumpWindow.d.ts

@@ -0,0 +1,73 @@
+import { HistoryWindowPage } from '../networking/xmppClient';
+import { JumpWindow } from '../roomStore/roomsSlice';
+import { IMessage } from '../types/types';
+/** Messages shown above / below the target when a window opens (tunable). */
+export declare const JUMP_WINDOW_BEFORE = 10;
+export declare const JUMP_WINDOW_AFTER = 10;
+/** Page size for loading more once the reader scrolls toward either edge. */
+export declare const JUMP_WINDOW_PAGE = 20;
+/** The slice of the XMPP client the window helpers need. */
+export interface HistoryWindowClient {
+    getHistoryWindow: (chatJID: string, max: number, cursor: {
+        before?: number;
+        after?: number;
+        start?: string;
+        end?: string;
+    }) => Promise<HistoryWindowPage>;
+}
+export type JumpWindowResult = 
+/** The window around the target is ready to be shown. */
+{
+    status: 'found';
+    window: JumpWindow;
+}
+/** The server answered, and the target is not in the archive. */
+ | {
+    status: 'missing';
+}
+/** No usable id, or a request failed: use the paging path instead. */
+ | {
+    status: 'unavailable';
+};
+/**
+ * How far apart the archive's timestamp and the transcript's may be for the
+ * same message. They are recorded by different components, so they are not
+ * identical, but never more than a moment apart.
+ */
+export declare const CONTENT_MATCH_WINDOW_MS = 5000;
+/** What a hit with no archive id can be located by. */
+export interface JumpContent {
+    createdAt?: string;
+    body?: string;
+}
+export declare const mamIdCandidates: (ids: string[]) => string[];
+/**
+ * Fetches about JUMP_WINDOW_BEFORE messages before the target, the target and
+ * about JUMP_WINDOW_AFTER after it: two MAM queries in parallel (the target
+ * itself comes with the "after" page, asked from one microsecond before it).
+ * Nothing is written to the store here.
+ */
+export declare function loadJumpWindow(client: HistoryWindowClient, roomJID: string, ids: string[], content?: JumpContent): Promise<JumpWindowResult>;
+/**
+ * For a hit with no usable archive id (older archive documents carry neither a
+ * stanza id nor a message id): ask the server for the rows within a few
+ * seconds of its timestamp (MAM start/end filter), find the one with the same
+ * text, and continue exactly as the id-based window does with that row's id.
+ * The server's answer is final: 'missing' only when it said the range holds no
+ * such row.
+ */
+export declare function loadJumpWindowByTime(client: HistoryWindowClient, roomJID: string, content: JumpContent): Promise<JumpWindowResult>;
+export interface OlderWindowPage {
+    messages: IMessage[];
+    olderCursor: number | null;
+    hasOlder: boolean;
+}
+export interface NewerWindowPage {
+    messages: IMessage[];
+    newerCursor: number | null;
+    hasNewer: boolean;
+}
+/** The page above the window; null when the request failed. */
+export declare function loadOlderWindowPage(client: HistoryWindowClient, window: JumpWindow): Promise<OlderWindowPage | null>;
+/** The page below the window; null when the request failed. */
+export declare function loadNewerWindowPage(client: HistoryWindowClient, window: JumpWindow): Promise<NewerWindowPage | null>;

package/dist/helpers/nanoToMs.d.ts

@@ -1 +1 @@
-export declare const nanoToMs: (number: string) => number;
+export declare const nanoToMs: (number?: string | number | null) => number;

package/dist/helpers/openRoomAtMessage.d.ts

@@ -0,0 +1,17 @@
+import { AppDispatch } from '../roomStore';
+type MaybeId = string | number | null | undefined;
+/**
+ * Every id a caller may know the target message by, without blanks and
+ * duplicates. A notification, a push payload or a link can carry the client
+ * (xmpp) message id, the archive stanza id or the stored message id, and the
+ * jump matcher checks message.id and message.xmppId, so all of them go in.
+ */
+export declare const collectMessageIds: (...candidates: MaybeId[]) => string[];
+/**
+ * Open a room and, when the caller knows which message it is about, ask the
+ * mounted room to land on it (scroll if mounted, widen the window, or page
+ * older history; see useJumpToMessage). With no message id this is just
+ * "open the room".
+ */
+export declare const openRoomAtMessage: (dispatch: AppDispatch, roomJID: string, ...messageIds: MaybeId[]) => void;
+export {};

package/dist/helpers/openThreadForJump.d.ts

@@ -0,0 +1,26 @@
+import { AppDispatch } from '../roomStore';
+import { IMessage } from '../types/types';
+import { HistoryWindowClient } from './jumpWindow';
+export interface OpenThreadForJumpParams {
+    client?: HistoryWindowClient | null;
+    dispatch: AppDispatch;
+    roomJID: string;
+    /** The pending request this opens a thread for. */
+    at: number;
+    /** The reply the jump named. */
+    reply: IMessage;
+    /** The room's live messages, unfiltered. */
+    live: IMessage[];
+    /** Messages found alongside the reply (a window), unfiltered. */
+    nearby?: IMessage[];
+}
+/**
+ * Opens the thread a reply belongs to, so a jump to the reply can highlight it
+ * there. Resolves true when the thread is open (or about to be), false when
+ * the parent could not be obtained.
+ *
+ * The parent comes from the live list (the usual thread flag), from the
+ * messages found next to the reply, or, when it is in neither, from a window
+ * around the parent fetched for the purpose.
+ */
+export declare function openThreadForJump({ client, dispatch, roomJID, at, reply, live, nearby, }: OpenThreadForJumpParams): Promise<boolean>;

package/dist/helpers/pdf/loadPdfjs.d.ts

@@ -61,4 +61,11 @@ export interface PdfjsLib {
 }
 /** Test seam - the module-level cache would otherwise leak between cases. */
 export declare const resetPdfjsCache: () => void;
-export declare const loadPdfjs: (workerSrc?: string) => Promise<PdfjsLib | null>;
+/**
+ * `libUrl`: load pdf.js from this URL (an ES module build such as
+ * `pdfjs-dist/legacy/build/pdf.min.mjs` served by the host) instead of the
+ * copy bundled with the component. For hosts that ship the component as one
+ * self-contained script (the embeddable widget), where a bundled pdf.js is
+ * 1.7 MB that every visitor downloads whether or not a PDF ever appears.
+ */
+export declare const loadPdfjs: (workerSrc?: string, libUrl?: string) => Promise<PdfjsLib | null>;

package/dist/helpers/roomUserCount.d.ts

@@ -0,0 +1,19 @@
+import { IRoom } from '../types/types';
+type CountSource = Pick<IRoom, 'members' | 'usersCnt'> | {
+    members?: unknown;
+    usersCnt?: unknown;
+} | null | undefined;
+/**
+ * User count to DISPLAY for a room. /chats/my returns `usersCnt` (the true
+ * total) but at most 30 members for big public rooms, so the truncated
+ * members array must never win over usersCnt.
+ */
+export declare const getRoomUserCount: (room: CountSource) => number;
+/** True when the room is known to have more users than members loaded. */
+export declare const isRoomMembersTruncated: (room: CountSource) => boolean;
+/**
+ * Next usersCnt after a live join (+1) or leave (-1). Adjusts the CURRENT
+ * count instead of recomputing from the (possibly truncated) members array.
+ */
+export declare const adjustUsersCnt: (room: CountSource, delta: 1 | -1, nextMembersLength: number) => number;
+export {};

package/dist/helpers/userResolver.d.ts

@@ -0,0 +1,57 @@
+import { RoomMember } from '../types/types';
+export type RoomDirectoryState = 'idle' | 'loading' | 'done' | 'error';
+/** Re-render hook: called when a directory state or a negative cache entry changes. */
+export declare const subscribeUserResolver: (listener: () => void) => (() => void);
+/**
+ * True for an id the backend answered 404 for: the user really is gone.
+ * (An id merely not resolved yet is NOT "not found".)
+ */
+export declare const isUserNotFound: (rawId: string) => boolean;
+/**
+ * Where a sender's lookup stands, for the display chain:
+ * - resolved: in usersSet
+ * - pending: queued, in flight, or not requested yet (a bubble just mounted)
+ * - notfound / forbidden: the backend answered, nothing to show from it
+ * - failed: the last attempt errored (backoff), or the lookup is exhausted
+ * - unavailable: this id can never be looked up (plain handle) or there is
+ *   no session token, so nothing is coming
+ */
+export type UserLookupStatus = 'resolved' | 'pending' | 'notfound' | 'forbidden' | 'failed' | 'unavailable';
+export declare const getUserLookupStatus: (rawId: string) => UserLookupStatus;
+/**
+ * Ask for the profiles of these senders. Cheap to call from anywhere (a
+ * bubble mounting, a history batch parse): known, in-flight and recently
+ * failed ids are dropped, the rest are debounced into one pass.
+ */
+export declare function requestUsers(ids: string[]): void;
+/**
+ * Re-fetch one user's profile even though it is already in usersSet, because
+ * the server said it changed (ethora-event user-profile-updated). Bypasses
+ * the cache and forgets a negative-cache entry, but shares everything else
+ * with requestUsers: the same route chain (lookupUser), the same worker
+ * queue and concurrency cap, one request at a time per user. Calls for the
+ * same user within REFRESH_DEBOUNCE_MS coalesce into one fetch. The answer
+ * goes through insertUsers (display fields only), so existing bubbles are
+ * re-named. Never throws.
+ */
+export declare function refreshUser(rawId: string): void;
+/**
+ * Members loaded so far by ensureRoomDirectory for this room (a new array
+ * identity after every page, a stable empty array before any).
+ */
+export declare const getRoomDirectoryMembers: (roomJID: string) => RoomMember[];
+/** requestUsers for the senders of a batch of messages (history page, jump window). */
+export declare function requestSendersOf(messages: ReadonlyArray<{
+    user?: {
+        id?: string;
+    };
+} | null | undefined> | undefined): void;
+export declare const getRoomDirectoryState: (roomJID: string) => RoomDirectoryState;
+/**
+ * Loads every member of one room into usersSet, once. Pages are not
+ * guaranteed to be full, so it stops on an empty page or offset >= total,
+ * never on `items.length < limit`.
+ */
+export declare function ensureRoomDirectory(roomJID: string): Promise<void>;
+/** For tests and logout: drops every cache, timer and in-flight result. */
+export declare function resetUserResolver(): void;

package/dist/helpers/xmppIdShape.d.ts

@@ -2,7 +2,7 @@ export declare const toLocalPart: (value?: string) => string;
 /**
  * True when `value` (a full JID or already-bare local part) is a
  * machine-generated Ethora id rather than anything a human would recognize
- * as their own name - `<24 hex>_<24 hex>` (appId_userId) or a bare 24-hex
+ * as their own name - `<24 hex>_<24 hex>`, `<appId>_<uuid>` or a bare 24-hex
  * id. Kept narrow on purpose: a handle a person actually picked is never
  * this shape, so it is never mistaken for one.
  */

package/dist/hooks/useChatWrapperInit.d.ts

@@ -22,5 +22,11 @@ export declare const hasHostRefreshedSession: (user: {
     xmppUsername?: string;
     xmppPassword?: string;
 }) => boolean;
+export declare const startBackgroundJoinSweep: (client: {
+    sendAllPresencesAndMarkReady: () => Promise<unknown>;
+}) => void;
+export declare const loadRoomsThenJoinInBackground: <T>(client: {
+    sendAllPresencesAndMarkReady: () => Promise<unknown>;
+}, fetchRooms: () => Promise<T>, onListReady: () => void) => Promise<T>;
 declare const useChatWrapperInit: ({ roomJID, wasAutoSelected, config, }: useChatWrapperInitProps) => useChatWrapperInitResult;
 export default useChatWrapperInit;

package/dist/hooks/useMessageSearchShortcut.d.ts

@@ -0,0 +1,14 @@
+interface Options {
+    enabled: boolean;
+    /** Whether the search panel is already open (then the shortcut re-focuses it). */
+    isOpen: boolean;
+    open: () => void;
+}
+/**
+ * Ctrl/Cmd+F opens message search, but only while the reader is working in the
+ * chat (focus or pointer inside it). A host page that embeds the chat keeps its
+ * browser find everywhere else: hijacking it page-wide would be a hostile thing
+ * for an SDK to do.
+ */
+export declare function useMessageSearchShortcut({ enabled, isOpen, open }: Options): void;
+export {};

package/dist/hooks/usePdfThumbnail.d.ts

@@ -9,6 +9,7 @@ interface UsePdfThumbnailParams {
     maxBytes?: number;
     sizeInBytes?: number;
     workerSrc?: string;
+    libUrl?: string;
 }
 interface UsePdfThumbnailResult {
     status: PdfThumbnailStatus;
@@ -18,5 +19,5 @@ interface UsePdfThumbnailResult {
     /** Re-runs a render that failed or was skipped for being too big. */
     retry: () => void;
 }
-export declare const usePdfThumbnail: ({ url, enabled, width, maxBytes, sizeInBytes, workerSrc, }: UsePdfThumbnailParams) => UsePdfThumbnailResult;
+export declare const usePdfThumbnail: ({ url, enabled, width, maxBytes, sizeInBytes, workerSrc, libUrl, }: UsePdfThumbnailParams) => UsePdfThumbnailResult;
 export {};

package/dist/hooks/useRoomDirectory.d.ts

@@ -0,0 +1,11 @@
+import { RoomDirectoryState } from '../helpers/userResolver';
+import { RoomMember } from '../types/types';
+/**
+ * Directory of a big room (usersCnt > the members the API returned).
+ * `enabled` starts the (once per room, deduplicated) load; the result grows
+ * page by page. Rooms that are not truncated never trigger a request.
+ */
+export declare const useRoomDirectory: (roomJid: string | undefined, enabled: boolean) => {
+    members: RoomMember[];
+    state: RoomDirectoryState;
+};

package/dist/hooks/useRoomState.d.ts

@@ -9,5 +9,6 @@ export declare const useRoomState: (roomJID?: string) => {
     roomMessages: any;
     roomsLoadedOnce: any;
     roomsLoadError: any;
+    joiningRoomJID: string;
 };
 export declare const useUsersSet: () => any;