@ethora/chat-component 26.9.6 → 26.10.1

package/dist/helpers/messageRuns.d.ts

@@ -0,0 +1,10 @@
+import { IMessage } from '../types/types';
+/**
+ * Ids of the messages that end a run of one sender: the next row is another
+ * sender, a system row, or a message on the next day. A run is a block of
+ * consecutive messages from one person, which the bubbles group visually.
+ *
+ * Pass the full list, not a window of it, so the last row of a window still
+ * knows what follows it.
+ */
+export declare const messageRunEnds: (list: IMessage[]) => Set<string>;

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/repairFilenameEncoding.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Repairs file names the backend returns as UTF-8 bytes read as Latin-1
+ * (the classic multer/busboy `originalname` problem): "Список.pdf" arrives
+ * as "СпиÑок.pdf".
+ *
+ * Pure and conservative: a name is only replaced when every character fits
+ * in one byte, the bytes decode as strict UTF-8, the result differs, holds
+ * no replacement or control characters and contains at least one letter
+ * outside basic Latin. A correct name is returned untouched.
+ */
+export declare const repairFilenameEncoding: (name: string) => string;

package/dist/helpers/roomImageGallery.d.ts

@@ -7,9 +7,27 @@ import { IMessage, ModalFile } from '../types/types';
  * download action, the secure `?ft=` token treatment, the alt text - keeps
  * reading exactly the fields it read when a single file was opened by hand.
  */
+export interface GallerySender {
+    id?: string;
+    username?: string;
+    /** The message's own display name, when it has one. */
+    name?: string;
+    firstName?: string;
+    lastName?: string;
+    /** Profile photo URL, when the sender has one. */
+    photo?: string;
+}
 export interface GalleryImage extends ModalFile {
+    /** What the entry renders as. Images zoom; videos play. */
+    kind: 'image' | 'video';
     /** Stable per message+slot, so two identical URLs are still two entries. */
     key: string;
+    /** Low-resolution copy shown blurred while the full image loads. */
+    previewURL?: string;
+    /** Message timestamp (ISO), shown in the viewer's header. */
+    date?: string;
+    /** Who posted it; the viewer header shows their name and avatar. */
+    sender?: GallerySender;
 }
 /**
  * The gallery the lightbox pages through.
@@ -34,7 +52,17 @@ export interface GalleryImage extends ModalFile {
  * Non-images (video, PDF, audio, arbitrary files) are excluded, so opening a
  * PDF simply produces an empty gallery and no navigation chrome.
  */
+/** The sender fields the viewer header needs, or undefined for no sender. */
+export declare const senderFromMessage: (message?: Partial<IMessage> | null) => GallerySender | undefined;
+/** ISO date string for a message, as the viewer header wants it. */
+export declare const isoDateFromMessage: (message?: Partial<IMessage> | null) => string | undefined;
 export declare const collectRoomImages: (messages?: Partial<IMessage>[] | null) => GalleryImage[];
+/**
+ * Same walk as `collectRoomImages`, but the viewer's gallery also pages
+ * through videos, so an album of photos and clips opens as one sequence.
+ * PDFs, audio and other files are still excluded.
+ */
+export declare const collectRoomMedia: (messages?: Partial<IMessage>[] | null, kinds?: Array<"image" | "video">) => GalleryImage[];
 /**
  * Position of the open file inside the gallery, or -1 when it is not part of
  * it (a PDF, a video, a file opened from the Files panel of another room).
@@ -51,3 +79,9 @@ export declare const collectRoomImages: (messages?: Partial<IMessage>[] | null)
  * were stuck.
  */
 export declare const findGalleryIndex: (images: GalleryImage[], activeFile?: ModalFile | null) => number;
+/**
+ * Builds gallery entries from the file list a caller handed over with the
+ * open request (an album grid passes all of its tiles). Items without a
+ * location, or that are neither image nor video, are dropped.
+ */
+export declare const galleryFromFiles: (files?: ModalFile[] | null) => GalleryImage[];

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/safeUrl.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Image URLs that reach the DOM (`<img src>`, CSS `url()`) can come from
+ * user-controlled data: profile photos, message stanzas, link previews,
+ * attachment locations. Anything that is not a plain web or blob image URL is
+ * dropped here so the sink never receives an active or document-bearing URL.
+ */
+/**
+ * Returns the trimmed input when it is a safe image URL, otherwise ''.
+ *
+ * Allowed: absolute or relative (resolved against the page origin) http:,
+ * https: and blob: URLs, and base64 data URLs of png, jpeg, gif, webp or
+ * avif images. Blocked: javascript:, vbscript:, data:text/html, data:image/svg+xml
+ * and anything that does not parse. Non-string input yields ''.
+ */
+export declare const safeImageUrl: (value: unknown) => string;

package/dist/helpers/secureFileUrl.d.ts

@@ -9,4 +9,7 @@ export declare const appendFileToken: (url: string | null | undefined, fileToken
  */
 export declare const withoutFileToken: (url?: string | null) => string;
 export declare const withFileToken: (url?: string | null) => string;
-export declare const requestFileTokenRecovery: () => Promise<boolean>;
+export declare const resetFileTokenRecovery: () => void;
+export declare const requestFileTokenRecovery: (options?: {
+    force?: boolean;
+}) => Promise<boolean>;

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/viewerSender.d.ts

@@ -0,0 +1,47 @@
+/** What the media viewer knows about a sender, however thin. */
+export interface ViewerSenderInput {
+    id?: string;
+    username?: string;
+    /** `message.user.name`, which carries the display name for many senders. */
+    name?: string;
+    firstName?: string;
+    lastName?: string;
+    photo?: string;
+}
+interface DirectoryEntry {
+    firstName?: string;
+    lastName?: string;
+    profileImage?: string;
+}
+interface OwnProfile extends DirectoryEntry {
+    xmppUsername?: string;
+    name?: string;
+}
+export interface ResolveViewerSenderOptions {
+    sender?: ViewerSenderInput | null;
+    /** `rooms.usersSet`, keyed by the xmpp username. */
+    usersSet?: Record<string, DirectoryEntry | undefined>;
+    /** The signed-in user, for their own messages. */
+    me?: OwnProfile | null;
+    /** Only used for a 1:1 room, where the room is named after the peer. */
+    peerRoomName?: string;
+}
+export interface ResolvedViewerSender {
+    /** Empty when nobody could be named. The header then omits the name line. */
+    name: string;
+    photo?: string;
+}
+/**
+ * Resolves the sender shown in the viewer header. The order is the one the
+ * message bubble uses, with the signed-in user's own profile as the answer for
+ * their own messages (an own optimistic message often has no name on it):
+ *
+ *   first + last on the message, the message's own `name`, the profile in
+ *   `usersSet`, the signed-in user's profile (own messages), the username
+ *   before the `@`, and for a 1:1 room the room's name.
+ *
+ * Never returns a placeholder: when nothing is known `name` is '' and the
+ * caller draws a neutral glyph rather than initials.
+ */
+export declare const resolveViewerSender: ({ sender, usersSet, me, peerRoomName, }: ResolveViewerSenderOptions) => ResolvedViewerSender;
+export {};

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/useAvatarImage.d.ts

@@ -0,0 +1,21 @@
+export type AvatarImageStatus = 'none' | 'loading' | 'loaded' | 'failed';
+/**
+ * Resolves an avatar URL for rendering. Never waits on the network: the
+ * caller shows initials immediately and fades the <img> in once `status` is
+ * `loaded`.
+ *
+ *  - appends the viewer's `?ft=` token for secure-files URLs synchronously
+ *    from the store (no token round trip before the request starts);
+ *  - reuses a URL that already loaded for the same file (see
+ *    avatarImageCache) so a token rotation or a second component showing the
+ *    same person does not trigger another download;
+ *  - skips URLs that just failed (no repeated failing requests);
+ *  - on a secure-file failure kicks the throttled fileToken recovery, whose
+ *    refreshed token yields a new URL and therefore a new attempt.
+ */
+export declare const useAvatarImage: (rawSrc: string | null | undefined) => {
+    src: string;
+    status: AvatarImageStatus;
+    onLoad: () => void;
+    onError: () => void;
+};

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/useIsMobileViewport.d.ts

@@ -1 +1,6 @@
 export declare const useIsMobileViewport: (breakpoint?: number) => boolean;
+/**
+ * Non-hook form of the same check, for event handlers that need the answer
+ * at the moment of the event rather than as render state.
+ */
+export declare const isMobileViewportNow: (breakpoint?: number) => boolean;

package/dist/hooks/useMediaProbe.d.ts

@@ -0,0 +1,40 @@
+export type MediaProbeStatus = 'idle' | 'loading' | 'recovering' | 'loaded' | 'error';
+export interface MediaProbe {
+    status: MediaProbeStatus;
+    /**
+     * Natural size. Known once `status` is 'loaded', and usually sooner: it is
+     * read from the first decoded header while the bytes are still arriving.
+     */
+    width: number;
+    height: number;
+    /**
+     * The URL whose bytes are on screen. While a picture is shown, a rotated
+     * `?ft=` token does not swap it for a fresh request: the URL that loaded
+     * stays, so a token refresh never blanks or re-downloads what is visible.
+     */
+    url: string;
+}
+/**
+ * No byte of the file (not even its header) arrived in this long: stop
+ * waiting and show the unavailable state with a manual retry. Once the size
+ * is known the file is on its way and is never cut off by this timer.
+ */
+export declare const MEDIA_STALL_MS = 8000;
+export declare const resetMediaProbeCaches: () => void;
+/**
+ * Preloads one image off-DOM so the visible <img> only mounts once its bytes
+ * are cached.
+ *
+ * A failure never says anything about the file being deleted: a 404 from the
+ * storage host, an expired token, a CORS or DNS hiccup and a dead CDN edge all
+ * fail an <img> the same way, and the server's answer cannot be read across
+ * origins anyway. So the only outcome is the 'error' state, which the surface
+ * offers to `retry`. Deleting a message is driven by the server (a delete
+ * stanza) or by the sender's own Files panel action, never inferred here.
+ *
+ * A secure URL that fails gets at most one shared token refresh per token
+ * (see `requestFileTokenRecovery`); the refreshed URL re-runs this effect.
+ */
+export declare const useMediaProbe: (url: string | undefined) => MediaProbe & {
+    retry: () => void;
+};

package/dist/hooks/usePaneWidthVar.d.ts

@@ -0,0 +1,11 @@
+import { RefObject } from 'react';
+/**
+ * Publishes the width of an element as the `--ethora-pane-w` custom property
+ * on that element, so message media can size itself to the chat pane (which
+ * may be a narrow host) instead of the viewport. Updated on every resize.
+ *
+ * The element may mount after the first render (the list shows a loader
+ * first), so every commit checks whether the ref points at a new element
+ * and re-attaches the observer if so.
+ */
+export declare const usePaneWidthVar: (ref: RefObject<HTMLElement | null>) => void;

package/dist/hooks/usePdfThumbnail.d.ts

@@ -9,14 +9,14 @@ interface UsePdfThumbnailParams {
     maxBytes?: number;
     sizeInBytes?: number;
     workerSrc?: string;
+    libUrl?: string;
 }
 interface UsePdfThumbnailResult {
     status: PdfThumbnailStatus;
     /** Object URL - owned by this hook, revoked on unmount/url change. */
     thumbnailUrl?: string;
-    pageCount?: number;
     /** 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/usePrefersReducedMotion.d.ts

@@ -0,0 +1,2 @@
+/** True while the user asks the OS for reduced motion; follows live changes. */
+export declare const usePrefersReducedMotion: () => boolean;

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/useSendMessage.d.ts

@@ -1,8 +1,11 @@
 import { IMentionSpan } from '../types/types';
+import { CaptionInput } from '../helpers/caption';
+/** Files of one message uploaded at the same time. */
+export declare const MEDIA_UPLOAD_CONCURRENCY = 4;
 export { shouldTagOutgoingTranslateSource } from '../utils/translateModePolicy';
 export declare const useSendMessage: () => {
     sendMessage: (message: string, activeRoomJID: string, isReply?: boolean, isChecked?: boolean, mainMessage?: string, mentions?: IMentionSpan[]) => Promise<void>;
-    sendMedia: (data: File | File[] | Blob, type: string, activeRoomJID: string, isReply?: boolean, isChecked?: boolean, mainMessage?: string) => Promise<void>;
+    sendMedia: (data: File | File[] | Blob, type: string, activeRoomJID: string, isReply?: boolean, isChecked?: boolean, mainMessage?: string, caption?: CaptionInput) => Promise<boolean>;
     sendEditMessage: (message: string) => Promise<void>;
     isLastMessageFromUserAndProcessing: (roomJID: string) => boolean;
 };