@ethora/chat-component 26.9.8 → 26.10.3

package/dist/helpers/caption.d.ts

@@ -0,0 +1,63 @@
+import { IMentionSpan } from '../types/types';
+/**
+ * The text typed with a set of attachments, sent as part of the media
+ * message itself (never as a separate text stanza).
+ *
+ * `mentions` index into `text`, the same way a text message's mention spans
+ * index into its body.
+ */
+export interface CaptionInput {
+    text: string;
+    mentions?: IMentionSpan[];
+}
+export interface NormalizedCaption {
+    caption: string;
+    mentions?: IMentionSpan[];
+}
+/**
+ * Mention spans for a caption, checked against the caption text: a span that
+ * no longer reads "@Name" at its offset is dropped. Undefined when nothing is
+ * left, so a caption without mentions carries no empty attribute.
+ */
+export declare const normalizeCaptionMentions: (value: unknown, caption: string) => IMentionSpan[] | undefined;
+/**
+ * Turns what the composer typed into the caption that travels with the
+ * media. Undefined for blank text, which means "no caption".
+ */
+export declare const normalizeCaptionInput: (input?: CaptionInput | null) => NormalizedCaption | undefined;
+/** What a media message's text is, and the @-mention spans that index into it. */
+export interface ResolvedCaption {
+    text: string;
+    mentions?: IMentionSpan[];
+}
+export interface CaptionOptions {
+    /**
+     * The caller already knows this is a media message (a thin `lastMessage`
+     * that only says so by its id). Otherwise it is read off the message.
+     */
+    isMedia?: boolean;
+    /** The message is sealed: only a caption that came out of the envelope counts. */
+    sealed?: boolean;
+    /** Extra names of the sender, which a body may merely echo. */
+    senderNames?: string[];
+}
+/**
+ * The text of a media message, from whichever format carried it. The one
+ * place that knows the formats, so every surface (bubble, room list preview,
+ * notification, reply quote, copy) agrees:
+ *
+ *  1. `caption` (+ `captionMentions`): what this SDK sends. The only source
+ *     for a sealed message, whose caption comes out of the envelope.
+ *  2. The caption under another name on `<data>` (`captionText`, `text`,
+ *     `message`, `description`, `title`) from other clients.
+ *  3. A real `body`: older clients and other SDKs put the text in the
+ *     `<body>` of the media message itself. "media", the file's name or URL,
+ *     the sender's own name or e-mail and generated labels are not text.
+ *
+ * Never derived for a sealed message, and never for a message with no file.
+ */
+export declare const resolveMessageCaption: (message?: object | null, options?: CaptionOptions) => ResolvedCaption | undefined;
+/** The caption a message carries, or undefined when it has none. */
+export declare const getMessageCaption: (message?: object | null, options?: CaptionOptions) => string | undefined;
+/** The mention spans of `getMessageCaption`'s text. */
+export declare const getMessageCaptionMentions: (message?: object | null, options?: CaptionOptions) => IMentionSpan[] | undefined;

package/dist/helpers/composerFocus.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Hands "focus the message input" from the room list to the composer.
+ *
+ * The room list and the composer live in different subtrees, and the
+ * composer may only mount after the switch (or re-render later), so a plain
+ * callback would race it. Instead the request is parked here until the
+ * mounted composer for that room claims it. A claim is one-shot, so a single
+ * click focuses exactly once.
+ */
+type Listener = () => void;
+/** Ask the composer for `roomJid` to take focus. Wakes mounted composers. */
+export declare const requestComposerFocus: (roomJid: string | null | undefined) => void;
+/** Mounted composers subscribe here to learn that a request arrived. */
+export declare const subscribeComposerFocus: (listener: Listener) => (() => void);
+/**
+ * Claims a pending request for `roomJid`. Returns true exactly once per
+ * request, and only for the room the request was made for.
+ */
+export declare const takeComposerFocusRequest: (roomJid: string | null | undefined) => boolean;
+/** Test helper: drops any parked request and all listeners. */
+export declare const resetComposerFocusForTests: () => void;
+export {};

package/dist/helpers/createMainMessageForThread.d.ts

@@ -1,2 +1,2 @@
 import { IMessage } from '../types/types';
-export declare const createMainMessageForThread: (message: IMessage) => string;
+export declare const createMainMessageForThread: (message: IMessage, t?: (key: string, vars?: Record<string, string | number>) => string) => string;

package/dist/helpers/downloadFile.d.ts

@@ -0,0 +1,19 @@
+export type DownloadResult = 'blob' | 'direct' | 'http-error';
+export interface DownloadDeps {
+    fetchImpl?: typeof fetch;
+    /** Hands a blob to the browser as a download. */
+    saveBlob?: (blob: Blob, fileName: string) => void;
+    /** Hands a plain URL to the browser as a download / new tab. */
+    saveUrl?: (url: string, fileName: string) => void;
+}
+/**
+ * Saves a media file. The blob route is preferred (it keeps the user's file
+ * name), but it needs CORS: <img>/<video>/<a> to a host such as
+ * secure-files.* never did, so a host without Access-Control-Allow-Origin
+ * makes fetch() reject with a bare TypeError. That says nothing about the
+ * file, so fall back to handing the URL to the browser directly.
+ *
+ * A reachable server that answers with an error status is different: its
+ * body is an error page, not the file, so nothing is saved.
+ */
+export declare function downloadFile(url: string, fileName: string, deps?: DownloadDeps): Promise<DownloadResult>;

package/dist/helpers/fileKind.d.ts

@@ -11,7 +11,24 @@ export type FileKind = 'image' | 'video' | 'audio' | 'pdf' | 'file';
 /** Lowercase extension without the dot; '' when the name carries none. */
 export declare const getFileExtension: (name?: string) => string;
 export declare const isPdfFile: (mimetype?: string, name?: string) => boolean;
+/**
+ * SVG is deliberately not an image here. It does not render reliably as a
+ * message picture, can be blocked by the host's CSP, and is a script
+ * injection vector when opened directly. It is treated as a plain file.
+ */
+export declare const isSvgFile: (mimetype?: string, name?: string) => boolean;
+/** True when the file renders as a picture (never for SVG). */
+export declare const isRasterImage: (mimetype?: string, name?: string) => boolean;
+/**
+ * The mimetype a file name's extension stands for, for the pictures, videos,
+ * audio and PDFs a bubble can show. Undefined for anything else.
+ */
+export declare const inferMimeFromName: (name?: string) => string | undefined;
+/** A mimetype that says nothing: empty, or the storage's "could not sniff". */
+export declare const isGenericMime: (mimetype?: string) => boolean;
 export declare const getFileKind: (mimetype?: string, name?: string) => FileKind;
 export declare const formatFileSize: (sizeInBytes?: string | number) => string;
 /** Middle-truncates the base name, always keeping the extension visible. */
 export declare const formatFileName: (name: string, maxLength: number) => string;
+/** An animated-picture candidate: image/gif, or a name or URL ending in .gif. */
+export declare const isGifFile: (mimetype?: string, nameOrUrl?: string) => boolean;

package/dist/helpers/lastMessagePreview.d.ts

@@ -0,0 +1,55 @@
+import { LastMessage } from '../types/types';
+/**
+ * What the room list draws for a media last message.
+ *
+ * One derivation for every source of a last message: the live stanza that
+ * updates roomsSlice, the history loaded from MAM, and the flattened
+ * `lastMessage` the backend embeds in `GET /chats/my`. All three reach the row
+ * as the same loose message object, and since multi-attachment messages the
+ * file fields may sit in `attachments` only, with no top level `location` or
+ * `mimetype`, so the row reads through getMessageAttachments like the bubble.
+ */
+export type MediaPreviewKind = 'image' | 'video' | 'voice' | 'audio' | 'file'
+/** Media of unknown type: a thin backend payload that only says "media". */
+ | 'attachment' | 'sealed';
+export interface MediaPreview {
+    kind: MediaPreviewKind;
+    /** How many attachments the message carries (at least 1). */
+    count: number;
+    /** Thumbnail source, before the viewer's file token is appended. */
+    thumbUrl?: string;
+    /** The single file's name, for the file kind. */
+    fileName?: string;
+    /** "0:12" for a voice message or audio file, when the duration is known. */
+    durationText?: string;
+    /** The text the sender typed next to the media, if any. */
+    caption?: string;
+}
+type PreviewSource = Partial<LastMessage> & {
+    attachments?: unknown;
+    fileName?: string;
+    location?: string;
+    /** The caption the sender typed with the files, carried on the message. */
+    caption?: unknown;
+    duration?: unknown;
+    mediaDuration?: unknown;
+};
+/** True when the last message should render as media rather than text. */
+export declare const hasMediaPreview: (message?: PreviewSource | null) => boolean;
+/**
+ * `sealed` is true for an e2ee room or a message flagged `clientEncrypted`.
+ * Sealed content never gets a thumbnail: the server holds ciphertext, so the
+ * row shows the icon and the label only.
+ */
+export declare const deriveMediaPreview: (message?: PreviewSource | null, options?: {
+    sealed?: boolean;
+    senderNames?: string[];
+}) => MediaPreview | undefined;
+/**
+ * Which message the room row previews: the newest real message already in the
+ * room's `messages[]` (a live stanza or history), else the backend's
+ * `lastMessage` seed. Entries with neither text nor media (markers, receipts,
+ * state-only stanzas) are skipped.
+ */
+export declare const pickPreviewSource: <T extends PreviewSource>(messages: T[] | undefined, lastMessage?: T | null) => T | undefined;
+export {};

package/dist/helpers/mapWithConcurrency.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Runs `worker` over `items` with at most `limit` calls in flight, and
+ * resolves with the results in INPUT order, whatever order the calls finish
+ * in. Workers that throw are reported as rejected entries instead of
+ * aborting the rest of the batch, so one failed upload never stops its
+ * siblings.
+ */
+export declare function mapWithConcurrency<T, R>(items: readonly T[], limit: number, worker: (item: T, index: number) => Promise<R>): Promise<PromiseSettledResult<R>[]>;

package/dist/helpers/mediaBox.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Pure sizing helpers for in-bubble media. Kept free of React and the DOM so
+ * the rules (clamping, never upscaling, duration formatting) are testable.
+ */
+/**
+ * Reference box a solo picture is fitted into. It is the largest the
+ * responsive media width ever gets (see MEDIA_WIDTH_CSS), so a picture is
+ * never upscaled past what the widest pane could show; the real, smaller cap
+ * for the current pane is applied in CSS from the shared width variable.
+ */
+export declare const SOLO_IMAGE_MAX_WIDTH_PX = 560;
+export declare const SOLO_IMAGE_MAX_HEIGHT_PX = 784;
+/** Box used while a solo image's dimensions are still unknown: 4:3. */
+export declare const SOLO_DEFAULT_BOX: {
+    readonly width: 560;
+    readonly height: 420;
+};
+/** Box used while a solo video's dimensions are unknown: 16:9. */
+export declare const SOLO_VIDEO_DEFAULT_BOX: {
+    readonly width: 560;
+    readonly height: 315;
+};
+/**
+ * The ONE width of the media block of a message: the album grid, a solo
+ * picture or video and the file cards under them all share it.
+ *
+ * `--ethora-pane-w` is the width of the message list pane (not the
+ * viewport), written by the message list's ResizeObserver, so a chat embedded
+ * in a narrow host sizes itself to that host. A container query would do the
+ * same, but `container-type` contains layout, which turns the list into the
+ * containing block of the context menu's `position: fixed` overlay.
+ *
+ *   pane 390   -> 300 (the bubble then clips it to its own width)
+ *   pane 700   -> 340
+ *   pane 1000  -> 430
+ *   pane 1400  -> 550
+ *   pane 1600+ -> 560
+ */
+export declare const MEDIA_WIDTH_VAR = "--ethora-media-w";
+export declare const PANE_WIDTH_VAR = "--ethora-pane-w";
+export declare const MEDIA_WIDTH_RULE = "clamp(300px, calc(var(--ethora-pane-w, 800px) * 0.3 + 130px), 560px)";
+/** Use inside a stylesheet or inline style; falls back when the list did not set it. */
+export declare const MEDIA_WIDTH_CSS = "var(--ethora-media-w, 340px)";
+/** A lone file card is capped so it does not become a giant bar. */
+export declare const FILE_ONLY_MAX_WIDTH_PX = 360;
+/** Tallest a solo picture gets, relative to the media width. */
+export declare const SOLO_MAX_HEIGHT_FACTOR = 1.4;
+/** CSS length of the tallest a solo picture may be: 60vh, or 1.4 x the media width. */
+export declare const SOLO_MAX_HEIGHT_CSS = "min(60vh, calc(1.4 * var(--ethora-media-w, 340px)))";
+export interface MediaBox {
+    width: number;
+    height: number;
+}
+/**
+ * Fit a natural size inside a max box, keeping its aspect ratio. Never
+ * upscales: a picture smaller than the box keeps its natural size. Returns
+ * null when either dimension is unknown or not positive.
+ */
+export declare const fitMediaBox: (naturalWidth: number | undefined, naturalHeight: number | undefined, maxWidth?: number, maxHeight?: number) => MediaBox | null;
+/** A picture whose longest side is below this is shown at its natural size. */
+export declare const SOLO_TINY_MAX_SIDE_PX = 120;
+/** Smallest frame drawn around a tiny picture. */
+export declare const SOLO_MIN_FRAME_PX = 64;
+/** Beyond this long:short ratio a picture is cropped rather than letterboxed. */
+export declare const SOLO_EXTREME_RATIO = 3;
+/** Shorter side of the box of an extreme-ratio picture. */
+export declare const SOLO_MIN_SHORT_SIDE_PX = 96;
+/**
+ * How the picture sits in its box.
+ *   fit     - same aspect ratio as the box, fills it.
+ *   cover   - extreme ratio: fills the box and is gently cropped from the centre.
+ *   natural - smaller than its frame: drawn at its own size, centred on a tile.
+ */
+export type SoloMode = 'fit' | 'cover' | 'natural';
+export interface SoloBox {
+    /** The frame (stage) size in CSS px. */
+    width: number;
+    height: number;
+    /** The drawn picture size; equals the frame unless `mode` is natural. */
+    imageWidth: number;
+    imageHeight: number;
+    mode: SoloMode;
+}
+/**
+ * The size policy of a single picture in a bubble.
+ *
+ *  - Inside the max box (560 x 784 by default) at its own aspect ratio,
+ *    never upscaled. CSS narrows it to the pane's media width and height.
+ *  - Tiny (longest side < 120): natural size on a tile of at least 64px.
+ *  - Extreme ratio (beyond 3:1 or 1:3): the shorter side is lifted to 96px
+ *    and the picture is cover-cropped (the viewer shows all of it).
+ *
+ * `ratioOnly` is for a size read from a downscaled preview: only its aspect
+ * ratio is trusted, so the box is scaled up to the real maximum instead of
+ * staying thumbnail-sized (which would jump when the full file arrives).
+ * Returns null while a dimension is unknown.
+ */
+export declare const computeSoloBox: (naturalWidth: number | undefined, naturalHeight: number | undefined, options?: {
+    ratioOnly?: boolean;
+    maxWidth?: number;
+    maxHeight?: number;
+}) => SoloBox | null;
+/** Parses a dimension that may arrive as a number or a numeric string. */
+export declare const parseDimension: (value: unknown) => number | undefined;
+/**
+ * Formats a duration in seconds as m:ss, or h:mm:ss past one hour. Returns
+ * an empty string when the value is missing or not a positive number, so
+ * callers can skip the chip entirely.
+ */
+export declare const formatDuration: (seconds: string | number | undefined) => string;

package/dist/helpers/mediaBubble.d.ts

@@ -0,0 +1,67 @@
+import { IAttachment } from '../types/types';
+/**
+ * How a message's files share one column:
+ *  - album: two or more pictures or videos, one grid; cards stretch to it.
+ *  - solo: one picture or video; the block shrink-wraps it (at most the media
+ *    width) and any cards stretch to that.
+ *  - files: documents only; the media width, capped so a lone card is no bar.
+ *  - plain: voice notes only, which keep their own width.
+ */
+export type MediaBlockMode = 'album' | 'solo' | 'files' | 'plain';
+export interface AttachmentItem {
+    attachment: IAttachment;
+    /** Position in the message's attachments, used for retry. */
+    index: number;
+}
+export interface AttachmentPartition {
+    /** Pictures and videos rendered as one album grid (empty for a lone one). */
+    tiles: AttachmentItem[];
+    /** Everything else, rendered one after another below the grid. */
+    rows: AttachmentItem[];
+}
+export declare const attachmentKind: (attachment: IAttachment) => import('./fileKind').FileKind;
+/**
+ * Splits a message's files into the album and the rows below it. Pictures and
+ * videos always come first, in the order they were picked; the remaining files
+ * (documents, svg, pdf, audio) follow, also in their picked order. A lone
+ * picture is not an album: it stays a row, but it still leads the message.
+ */
+export declare const partitionAttachments: (attachments: IAttachment[]) => AttachmentPartition;
+/** The block mode for a message's files, from the partition it renders. */
+export declare const getMediaBlockMode: (attachments: IAttachment[]) => MediaBlockMode;
+/**
+ * Whether the time can sit as a glass pill over the media (Telegram style):
+ * only when the bubble is pictures and videos and nothing else. A caption or
+ * any card or audio row puts the time on its own line at the bottom right.
+ */
+export declare const usesMediaOverlayTime: (attachments: IAttachment[], options?: {
+    hasCaption?: boolean;
+}) => boolean;
+export type TimeMode = 'overlay' | 'row';
+export interface MediaTimeFacts {
+    attachments: IAttachment[];
+    /** The caption the bubble really shows (see getMessageCaption), if any. */
+    hasCaption: boolean;
+    /** The sender's own bubble is in the failed state. */
+    failed?: boolean;
+    /** Quick reply buttons are shown under the bubble content. */
+    hasQuickReplies?: boolean;
+    /** A URL preview card is shown (only ever from a caption, never the body). */
+    hasUrlPreview?: boolean;
+    /** The manual translate row is shown. */
+    hasTranslateRow?: boolean;
+}
+/**
+ * The one rule for where a media bubble's time goes, read by both the time
+ * element and the bubble itself (data-time-mode), so they cannot disagree.
+ *
+ * `mediaOnly`: pictures and videos and nothing else (no caption, no card, no
+ * voice note). Such a bubble always shows the time as the glass pill over the
+ * media, unless something else needs the bottom of the bubble (a failed
+ * notice, quick replies, a preview card or the translate row), in which case
+ * the time takes the normal bottom right row.
+ */
+export declare const getMediaTimeLayout: (facts: MediaTimeFacts) => {
+    mediaOnly: boolean;
+    mode: TimeMode;
+};

package/dist/helpers/mediaLabel.d.ts

@@ -0,0 +1,10 @@
+import { getMessageAttachments } from './attachments';
+type Translate = (key: string, vars?: Record<string, string | number>) => string;
+/**
+ * What to call a media message's files when there is no text to show:
+ * "Photo", "Video", "Voice message", "File", "3 photos", "2 attachments".
+ * Empty when the message carries no file. The kind comes from the normalised
+ * attachment, so a file sent with no mimetype is still a photo by its name.
+ */
+export declare const getMediaLabel: (message: Parameters<typeof getMessageAttachments>[0], t: Translate) => string;
+export {};

package/dist/helpers/mediaSendRetry.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Retry hooks for media messages whose uploads did not all land.
+ *
+ * The send closure lives inside useSendMessage, but the bubble that shows
+ * "Retry" is somewhere else in the tree and has no access to it. The send
+ * registers its retry runner under the message id while the message is
+ * unsent, and the bubble looks it up here. The runner is removed as soon as
+ * the message is delivered.
+ */
+export type MediaRetryRunner = (indices?: number[]) => Promise<boolean>;
+export declare const registerMediaRetry: (messageId: string, runner: MediaRetryRunner) => void;
+export declare const unregisterMediaRetry: (messageId: string) => void;
+export declare const hasMediaRetry: (messageId: string) => boolean;
+/**
+ * Re-runs the uploads still missing for `messageId` (only `index` / `indices`
+ * when given), then sends the message once every file is in. Resolves to
+ * false when nothing is registered or the attempt did not deliver.
+ */
+export declare const retryMediaSend: (messageId: string, index?: number | number[]) => Promise<boolean>;
+/**
+ * Asks for one file of `messageId` to be retried. Requests made in the same
+ * tick are merged into one run: the runner takes a single run at a time, so
+ * a separate call per tile would drop every retry after the first.
+ */
+export declare const requestMediaRetry: (messageId: string, index: number) => void;

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

@@ -0,0 +1,48 @@
+import { IMessage } from '../types/types';
+/**
+ * Per-room lookup tables for the delivery/read ticks, built once per
+ * `room.messages` array (WeakMap keyed by the array reference) and shared by
+ * every own bubble in that room. A bubble then costs O(viewers), not O(n).
+ */
+export interface ReceiptIndex {
+    /** message id -> position in the loaded list. */
+    indexById: Map<string, number>;
+    /** message position -> timestamp in ms (0 when unknown). */
+    tsByIndex: number[];
+    /** author local part -> position of their newest loaded message. */
+    lastAuthoredIndexByUser: Map<string, number>;
+}
+/** The lookup tables for `messages`, built on first use per array. */
+export declare const getReceiptIndex: (messages: readonly IMessage[]) => ReceiptIndex;
+/** Number of index builds so far (tests check one build per messages change). */
+export declare const getReceiptIndexBuildCount: () => number;
+export interface ReceiptState {
+    /** Other members who have read this message. */
+    seenBy: string[];
+    /** Other members who have received it (readers included). */
+    deliveredBy: string[];
+}
+export declare const NO_RECEIPTS: ReceiptState;
+export declare const receiptStateEqual: (a: ReceiptState, b: ReceiptState) => boolean;
+export interface ComputeReceiptsInput {
+    index: ReceiptIndex;
+    messageId: string;
+    /** The bubble's own timestamp in ms (0 when unknown). */
+    messageTs: number;
+    /** Per-message receipts: xmppUsername -> ms (from message.receivedBy). */
+    receivedBy?: Record<string, number>;
+    /** Room delivery watermarks: xmppUsername -> stanza-id. */
+    lastReceivedByUser?: Record<string, string>;
+    /** Room read watermarks: xmppUsername -> stanza-id. */
+    lastDisplayedByUser?: Record<string, string>;
+    /** The current user's xmppUsername (never listed as a viewer). */
+    selfId?: string;
+}
+/**
+ * Who has read and who has received one of our messages. A viewer has read
+ * it when their read watermark covers it, or when they have authored a
+ * message at or after it (posting in the room implies they saw what came
+ * before). A viewer has received it when a per-message receipt exists or
+ * their delivery watermark covers it; reading implies receiving.
+ */
+export declare const computeReceiptState: ({ index, messageId, messageTs, receivedBy, lastReceivedByUser, lastDisplayedByUser, selfId, }: ComputeReceiptsInput) => ReceiptState;

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

@@ -0,0 +1,31 @@
+/**
+ * Auto-sizing for the composer textarea.
+ *
+ * The field is sized from its real content (soft wraps included), not from
+ * the newline count. One line keeps the original 40px field (34px textarea
+ * plus the 6px wrapper border and padding). Two lines or more use a tighter
+ * vertical padding so the text hugs the field, and the textarea scrolls
+ * internally once it reaches the cap.
+ */
+export declare const COMPOSER_LINE_HEIGHT = 20;
+/** Vertical padding per side for a single line (keeps the 40px field). */
+export declare const COMPOSER_PAD_SINGLE = 7;
+/** Vertical padding per side once the text wraps to two lines or more. */
+export declare const COMPOSER_PAD_MULTI = 5;
+/** Textarea box cap (about five lines), after which it scrolls. */
+export declare const COMPOSER_MAX_HEIGHT = 140;
+export interface TextareaFit {
+    /** Textarea border-box height in px. */
+    height: number;
+    /** True when the text occupies two lines or more. */
+    multiline: boolean;
+    /** True when the content is taller than the cap and must scroll. */
+    scrollable: boolean;
+}
+/**
+ * @param scrollHeight the textarea's scrollHeight, measured with height:auto
+ *   and the single-line padding applied (so it is content + 14px).
+ */
+export declare function computeTextareaFit(scrollHeight: number): TextareaFit;
+/** Re-measures a textarea from its content and applies the result to the DOM. */
+export declare function fitTextareaToContent(el: HTMLTextAreaElement): TextareaFit;

package/dist/helpers/timestamp.d.ts

@@ -1,2 +1,9 @@
 export declare const normalizeTimestampValue: (value: number) => number;
 export declare const getTimestampFromUnknown: (value: unknown) => number;
+/**
+ * Time encoded in a message or stanza id, 0 when the id carries none. Only an
+ * all-digit id (server stanza-id, microseconds) encodes a time: ids such as
+ * `send-text-message:<uuid>` must not be read as one, because a uuid can hold
+ * a run of ten or more digits that would parse as a far-future time.
+ */
+export declare const getTimestampFromId: (id: unknown) => number;

package/dist/helpers/userEntry.d.ts

@@ -0,0 +1,14 @@
+import { RoomMember } from '../types/types';
+/**
+ * Narrow lookup into `rooms.usersSet` for one user key.
+ *
+ * Returns the entry only for an own property of the map. Prototype keys
+ * (`__proto__`, `constructor`, `prototype`) are refused outright: a plain
+ * dictionary lookup would hand back `Object.prototype` members for them,
+ * which look like a user entry to every caller that checks truthiness.
+ *
+ * Components use this with a `useSelector` on `state.rooms.usersSet` so they
+ * subscribe to one entry (reference-stable under Immer) instead of the whole
+ * map.
+ */
+export declare const lookupUserEntry: (usersSet: Record<string, RoomMember> | null | undefined, key: string | null | undefined) => RoomMember | undefined;