@ethora/chat-component-rn 26.10.5 → 26.10.7

package/src/helpers/caption.ts

@@ -0,0 +1,283 @@
+import { IMentionSpan } from '../types/types';
+import { safeJsonParse } from './safeJson';
+import { validateMentionSpans } from './mentionSpans';
+import { getAttachmentName, getMessageAttachments, isMediaMessage } from './attachments';
+
+/**
+ * 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[];
+}
+
+const isSpanShape = (value: unknown): value is IMentionSpan => {
+  if (!value || typeof value !== 'object') return false;
+  const span = value as Record<string, unknown>;
+  return (
+    typeof span.jid === 'string' &&
+    typeof span.name === 'string' &&
+    typeof span.offset === 'number' &&
+    Number.isInteger(span.offset) &&
+    typeof span.length === 'number' &&
+    Number.isInteger(span.length)
+  );
+};
+
+/**
+ * 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 const normalizeCaptionMentions = (
+  value: unknown,
+  caption: string
+): IMentionSpan[] | undefined => {
+  const parsed =
+    typeof value === 'string' ? safeJsonParse<unknown>(value, []) : value;
+  if (!Array.isArray(parsed)) return undefined;
+  const spans = validateMentionSpans(caption, parsed.filter(isSpanShape));
+  return spans.length > 0 ? spans : undefined;
+};
+
+/**
+ * Turns what the composer typed into the caption that travels with the
+ * media. Undefined for blank text, which means "no caption".
+ */
+export const normalizeCaptionInput = (
+  input?: CaptionInput | null
+): NormalizedCaption | undefined => {
+  const text = typeof input?.text === 'string' ? input.text : '';
+  if (!/\S/.test(text)) return undefined;
+  const mentions = normalizeCaptionMentions(input?.mentions, text);
+  return mentions ? { caption: text, mentions } : { caption: text };
+};
+
+/** 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[];
+}
+
+/**
+ * Bodies that are not something a person typed: the media placeholder every
+ * SDK sends, and the labels apps generate for a file with nothing to say.
+ */
+const PLACEHOLDER_BODIES = new Set([
+  'media',
+  'attachment',
+  'attachments',
+  'photo',
+  'photos',
+  'image',
+  'images',
+  'picture',
+  'video',
+  'audio',
+  'voice',
+  'voice message',
+  'voice note',
+  'file',
+  'files',
+  'document',
+  'blob',
+  'undefined',
+  'null',
+  '[object object]',
+]);
+
+/** `<data>` attributes older or foreign clients stamp the file's text on. */
+const CAPTION_ALIASES = ['captionText', 'text', 'message', 'description', 'title'] as const;
+
+const norm = (value: unknown): string =>
+  typeof value === 'string' ? value.trim().toLowerCase() : '';
+
+const str = (value: unknown): string =>
+  typeof value === 'string' ? value : typeof value === 'number' ? String(value) : '';
+
+const tail = (url: string): string => {
+  const path = url.split(/[?#]/)[0];
+  return path.slice(path.lastIndexOf('/') + 1);
+};
+
+const safeDecode = (value: string): string => {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+};
+
+/** Every string a media message's `body` is allowed to merely repeat. */
+const echoCandidates = (
+  message: Record<string, any>,
+  options: CaptionOptions
+): Set<string> => {
+  const out = new Set<string>();
+  const add = (value: unknown) => {
+    const v = norm(value);
+    if (v) out.add(v);
+  };
+
+  // The file itself: its names and its URLs, as sent and as stored.
+  const attachments = getMessageAttachments(message as never);
+  for (const attachment of attachments) {
+    add(getAttachmentName(attachment));
+    add(attachment.originalName);
+    add(attachment.fileName);
+    for (const url of [attachment.location, attachment.locationPreview]) {
+      if (!url) continue;
+      add(url);
+      add(safeDecode(url));
+      add(tail(url));
+      add(safeDecode(tail(url)));
+    }
+  }
+  add(message.originalName);
+  add(message.fileName);
+  add(message.location);
+  add(message.locationPreview);
+
+  // The sender: some clients put their own name, e-mail or username in the
+  // body next to the file.
+  const user = (message.user ?? {}) as Record<string, unknown>;
+  const first = str(message.senderFirstName) || str(message.firstName) || str(user.firstName);
+  const last = str(message.senderLastName) || str(message.lastName) || str(user.lastName);
+  add(user.name);
+  add(`${first} ${last}`);
+  add(first && !last ? first : '');
+  add(user.email);
+  add(user.username);
+  add(message.email);
+  add(message.userName);
+  add(message.username);
+  add(message.senderName);
+  const idLocal = str(user.id).split('@')[0];
+  add(idLocal);
+  add(str(user.id).split('_').pop());
+  add(str(message.senderJID).split('/')[0].split('@')[0]);
+  for (const name of options.senderNames ?? []) add(name);
+  return out;
+};
+
+/** "etest etest" is echoed as "etest": every word of the name is the body. */
+const isRepeatedName = (name: string, text: string): boolean =>
+  Boolean(name && text) && name.split(/\s+/).every((part) => part === text);
+
+const isRealCaptionText = (
+  text: string,
+  message: Record<string, any>,
+  options: CaptionOptions
+): boolean => {
+  const t = text.trim();
+  if (!t) return false;
+  const n = t.toLowerCase();
+  if (PLACEHOLDER_BODIES.has(n)) return false;
+  // The key envelope a sealed message carries in its body is never text.
+  if (/^\{\s*"v"\s*:\s*\d+\s*,\s*"keys"/.test(t)) return false;
+  const candidates = echoCandidates(message, options);
+  if (candidates.has(n)) return false;
+  for (const name of candidates) if (isRepeatedName(name, n)) return false;
+  return true;
+};
+
+const asRecord = (message: unknown): Record<string, any> | undefined =>
+  message && typeof message === 'object' ? (message as Record<string, any>) : undefined;
+
+const resolveSpans = (
+  message: Record<string, any>,
+  text: string,
+  keys: string[]
+): IMentionSpan[] | undefined => {
+  for (const key of keys) {
+    const spans = normalizeCaptionMentions(message[key] ?? message.data?.[key], text);
+    if (spans) return spans;
+  }
+  return undefined;
+};
+
+/**
+ * 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 const resolveMessageCaption = (
+  message?: object | null,
+  options: CaptionOptions = {}
+): ResolvedCaption | undefined => {
+  const source = asRecord(message);
+  if (!source || source.isDeleted) return undefined;
+
+  const explicit = source.caption;
+  if (typeof explicit === 'string' && /\S/.test(explicit)) {
+    const mentions = normalizeCaptionMentions(source.captionMentions, explicit);
+    return mentions ? { text: explicit, mentions } : { text: explicit };
+  }
+
+  const sealed =
+    options.sealed === true ||
+    source.clientEncrypted === 'true' ||
+    (Array.isArray(source.e2eeKeys) && source.e2eeKeys.length > 0);
+  if (sealed) return undefined;
+
+  const isMedia = options.isMedia ?? isMediaMessage(source as never);
+  if (!isMedia) return undefined;
+
+  for (const key of CAPTION_ALIASES) {
+    const value = str(source[key] ?? source.data?.[key]);
+    if (value && isRealCaptionText(value, source, options)) {
+      const mentions = resolveSpans(source, value, ['captionMentions']);
+      return mentions ? { text: value, mentions } : { text: value };
+    }
+  }
+
+  const body = str(source.body);
+  if (body && isRealCaptionText(body, source, options)) {
+    const mentions = resolveSpans(source, body, ['mentions']);
+    return mentions ? { text: body, mentions } : { text: body };
+  }
+  return undefined;
+};
+
+/** The caption a message carries, or undefined when it has none. */
+export const getMessageCaption = (
+  message?: object | null,
+  options?: CaptionOptions
+): string | undefined => resolveMessageCaption(message, options)?.text;
+
+/** The mention spans of `getMessageCaption`'s text. */
+export const getMessageCaptionMentions = (
+  message?: object | null,
+  options?: CaptionOptions
+): IMentionSpan[] | undefined => resolveMessageCaption(message, options)?.mentions;

package/src/helpers/createMainMessageForThread.ts

@@ -1,8 +1,13 @@
 import { IMessage } from '../types/types';
+import { getMessageCaption } from './caption';
 
 export const createMainMessageForThread = (message: IMessage): string => {
+  // A media message is quoted by its caption. A sealed one never is: the
+  // reply stanza travels in the clear, the caption does not.
+  const caption =
+    message.clientEncrypted === 'true' ? undefined : getMessageCaption(message);
   const data = {
-    text: message.body,
+    text: caption ?? message.body,
     id: message.id,
     userName: message.user.name,
     createdAt: message.date,

package/src/helpers/createMessageFromXml.ts

@@ -1,7 +1,8 @@
 import { IMessage } from '../types/types';
 import { isE2eeRoom } from '../e2ee';
 import { composeName } from './displayName';
-import { parseSealedMediaBody } from '../e2ee/sealedBody';
+import { parseSealedMediaPayload } from '../e2ee/sealedBody';
+import { normalizeMediaDataAttrs } from './mediaWireData';
 
 interface IMessageWithNewData extends IMessage {
   [x: string]: any;
@@ -66,7 +67,9 @@ export const createMessageFromXml = async (
   }
 
   const merged: any = {
-    ...inner,
+    // Idempotent: the wrapped path already ran it in getDataFromXml, the
+    // positional (MAM catch-up) path hands over the raw attrs.
+    ...normalizeMediaDataAttrs(inner),
     ...outerExtras,
     isDeleted: !!outerExtras?.deleted || !!(arg as any)?.isDeleted,
   };
@@ -140,15 +143,28 @@ export const createMessageFromXml = async (
   const unencrypted =
     merged.omemoEncrypted !== 'true' && isE2eeRoom(String(merged.roomJid || ''));
 
-  const sealedKeys =
+  // A sealed media body is `{v:1,keys,caption?,captionMentions?}`. The keys
+  // and the caption are lifted next to each other; the caption is the only
+  // one a sealed message may show (any open caption attribute was dropped
+  // by normalizeMediaDataAttrs).
+  const sealed =
     merged.clientEncrypted === 'true'
-      ? parseSealedMediaBody(merged.body)
+      ? parseSealedMediaPayload(merged.body)
       : undefined;
 
   const message: IMessage = {
     ...merged,
     ...(unencrypted ? { unencrypted: true } : {}),
-    ...(sealedKeys ? { e2eeKeys: sealedKeys, body: 'media' } : {}),
+    ...(sealed
+      ? {
+          e2eeKeys: sealed.keys,
+          body: 'media',
+          ...(sealed.caption ? { caption: sealed.caption } : {}),
+          ...(sealed.captionMentions
+            ? { captionMentions: sealed.captionMentions }
+            : {}),
+        }
+      : {}),
     user: {
       ...(merged.user || {}),
       id: merged?.user?.id || fromResource || senderLocal,

package/src/helpers/fileKind.ts

@@ -0,0 +1,38 @@
+import { filenameFromUrl, isLikelyAudio } from './mimeToExtension';
+
+export type FileKind = 'image' | 'video' | 'audio' | 'file';
+
+interface FileKindInput {
+  mimetype?: string | null;
+  name?: string | null;
+  url?: string | null;
+  duration?: number | string | null;
+  waveForm?: string | null;
+  originalName?: string | null;
+}
+
+/**
+ * Which card a file gets in a bubble. Mirrors the branches MediaMessage has
+ * always used for a single file (image, video, audio, octet-stream as a voice
+ * note, then the voice-message heuristics) so an album, a card stack and a
+ * lone file all agree on what a given file is.
+ */
+export const getFileKind = (input: FileKindInput): FileKind => {
+  const mime = (input.mimetype || '').toLowerCase();
+  if (mime.startsWith('image/')) {return 'image';}
+  if (mime.startsWith('video/')) {return 'video';}
+  if (mime.startsWith('audio/')) {return 'audio';}
+  if (mime.includes('application/octet-stream')) {return 'audio';}
+  const name = input.name || filenameFromUrl(input.url);
+  return isLikelyAudio(mime, name, input.url, {
+    duration: input.duration,
+    waveForm: input.waveForm,
+    originalName: input.originalName,
+  })
+    ? 'audio'
+    : 'file';
+};
+
+/** True for the kinds that sit in the picture/video album. */
+export const isAlbumKind = (kind: FileKind): boolean =>
+  kind === 'image' || kind === 'video';

package/src/helpers/getDataFromXml.ts

@@ -2,6 +2,7 @@ import { Element } from 'ltx';
 import { Iso639_1Codes, IUser } from '../types/types';
 import { transformArrayToObject } from './transformTranslatations';
 import { normalizeXmppUsername } from './xmppUsername';
+import { normalizeMediaDataAttrs } from './mediaWireData';
 
 const getLocalpartFromJid = (jid?: string): string | undefined => {
   const value = String(jid || '').trim();
@@ -122,7 +123,10 @@ export const getDataFromXml = async (stanza: Element): Promise<DataXml | undefin
     photoURL,
   } as any;
 
-  const dataAttrs = data?.attrs || {};
+  // `attachments` and `caption` ride on <data> as strings; decode them here
+  // so every consumer sees the typed values (sealed captions are lifted from
+  // the encrypted body later, see createMessageFromXml).
+  const dataAttrs = normalizeMediaDataAttrs(data?.attrs || {});
 
   return {
     data: dataAttrs,

package/src/helpers/mapWithConcurrency.ts

@@ -0,0 +1,32 @@
+/**
+ * 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 async function mapWithConcurrency<T, R>(
+  items: readonly T[],
+  limit: number,
+  worker: (item: T, index: number) => Promise<R>
+): Promise<PromiseSettledResult<R>[]> {
+  const results: PromiseSettledResult<R>[] = new Array(items.length);
+  const width = Math.max(1, Math.min(Math.floor(limit) || 1, items.length));
+  let next = 0;
+
+  const lane = async (): Promise<void> => {
+    while (next < items.length) {
+      const index = next;
+      next += 1;
+      try {
+        const value = await worker(items[index]!, index);
+        results[index] = { status: 'fulfilled', value };
+      } catch (reason) {
+        results[index] = { status: 'rejected', reason };
+      }
+    }
+  };
+
+  await Promise.all(Array.from({ length: width }, () => lane()));
+  return results;
+}

package/src/helpers/mediaLimits.ts

@@ -0,0 +1,27 @@
+import type { IConfig } from '../types/types';
+
+/** Hard client-side cap on a single upload. Mirrors the backend's body limit. */
+export const MAX_MEDIA_BYTES = 50 * 1024 * 1024;
+
+/** The most files one message may carry (also the parser-side ceiling). */
+export const MAX_MEDIA_FILES = 10;
+
+/** Files per message the host allows: `attachments.maxFiles`, clamped to 1-10. */
+export const mediaFileCap = (config?: Pick<IConfig, 'attachments'> | null): number => {
+  const configured = Number(config?.attachments?.maxFiles);
+  if (!Number.isFinite(configured)) {return MAX_MEDIA_FILES;}
+  return Math.min(MAX_MEDIA_FILES, Math.max(1, Math.floor(configured)));
+};
+
+/**
+ * Bytes allowed per file: the 50 MB upload cap, lowered by
+ * `attachments.maxSizeMB` when the host sets a smaller one.
+ */
+export const mediaSizeLimit = (
+  config?: Pick<IConfig, 'attachments'> | null,
+  override?: number
+): number => {
+  const base = typeof override === 'number' && override > 0 ? Math.min(override, MAX_MEDIA_BYTES) : MAX_MEDIA_BYTES;
+  const mb = Number(config?.attachments?.maxSizeMB);
+  return Number.isFinite(mb) && mb > 0 ? Math.min(base, mb * 1024 * 1024) : base;
+};

package/src/helpers/mediaSendRetry.ts

@@ -0,0 +1,59 @@
+/**
+ * Retry hooks for media messages whose uploads did not all land.
+ *
+ * The send closure lives inside useSendMessage, but the bubble that shows
+ * "Retry" on a tile 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>;
+
+const runners = new Map<string, MediaRetryRunner>();
+
+export const registerMediaRetry = (messageId: string, runner: MediaRetryRunner): void => {
+  runners.set(messageId, runner);
+};
+
+export const unregisterMediaRetry = (messageId: string): void => {
+  runners.delete(messageId);
+};
+
+export const hasMediaRetry = (messageId: string): boolean => runners.has(messageId);
+
+/**
+ * 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 const retryMediaSend = async (
+  messageId: string,
+  index?: number | number[]
+): Promise<boolean> => {
+  const runner = runners.get(messageId);
+  if (!runner) {return false;}
+  const indices = index === undefined ? undefined : Array.isArray(index) ? index : [index];
+  return runner(indices);
+};
+
+const pendingRetryIndices = new Map<string, Set<number>>();
+
+/**
+ * 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 const requestMediaRetry = (messageId: string, index: number): void => {
+  const batch = pendingRetryIndices.get(messageId);
+  if (batch) {
+    batch.add(index);
+    return;
+  }
+  const next = new Set<number>([index]);
+  pendingRetryIndices.set(messageId, next);
+  queueMicrotask(() => {
+    pendingRetryIndices.delete(messageId);
+    retryMediaSend(messageId, [...next]).catch(() => false);
+  });
+};

package/src/helpers/mediaWireData.ts

@@ -0,0 +1,57 @@
+import { parseAttachments } from './attachments';
+import { getMessageCaption, normalizeCaptionMentions } from './caption';
+
+/**
+ * Normalises the media parts of a message's flat `<data>` attributes:
+ *
+ *  - `attachments` (a JSON string on the wire) becomes the typed array, or is
+ *    dropped when it decodes to nothing so the flat legacy fields win;
+ *  - `caption` is kept only when it holds text, with `captionMentions` (JSON
+ *    on the wire) checked against it;
+ *  - in a sealed message (`clientEncrypted`) the caption attributes are
+ *    always dropped: the only caption such a message may show is the one
+ *    inside its encrypted body, which the caller lifts afterwards.
+ *
+ * Safe to apply twice, so the wrapped and the positional parsers can both
+ * call it.
+ */
+export const normalizeMediaDataAttrs = (
+  attrs: Record<string, any>
+): Record<string, any> => {
+  const out: Record<string, any> = { ...attrs };
+
+  if ('attachments' in out) {
+    const attachments = parseAttachments(out.attachments);
+    if (attachments.length > 0) {
+      out.attachments = attachments;
+    } else {
+      delete out.attachments;
+    }
+  }
+
+  if (out.clientEncrypted === 'true') {
+    delete out.caption;
+    delete out.captionMentions;
+    return out;
+  }
+
+  if ('caption' in out) {
+    const caption = getMessageCaption({ caption: out.caption });
+    if (caption) {
+      out.caption = caption;
+      const spans = normalizeCaptionMentions(out.captionMentions, caption);
+      if (spans) {
+        out.captionMentions = spans;
+      } else {
+        delete out.captionMentions;
+      }
+    } else {
+      delete out.caption;
+      delete out.captionMentions;
+    }
+  } else if ('captionMentions' in out) {
+    delete out.captionMentions;
+  }
+
+  return out;
+};

package/src/helpers/mentionSpans.ts

@@ -0,0 +1,17 @@
+import type { IMentionSpan } from '../types/models/message.model';
+
+/**
+ * Keeps only the spans that still read "@Name" at their offset in `text`.
+ * RN does not render mentions; a caption's spans are stored (and checked) so
+ * they survive a round trip to a client that does.
+ */
+export const validateMentionSpans = (
+  text: string,
+  spans: IMentionSpan[]
+): IMentionSpan[] =>
+  spans.filter((span) => {
+    if (span.offset < 0 || span.offset + span.length > text.length) {
+      return false;
+    }
+    return text.slice(span.offset, span.offset + span.length) === `@${span.name}`;
+  });

package/src/helpers/mimeToExtension.ts

@@ -64,6 +64,57 @@ const MIME_TO_EXT: Record<string, string> = {
 
 const VALID_EXT_RE = /\.[a-z0-9]{1,8}$/i;
 
+// Extensions that stand for a picture, video, audio or PDF a bubble can
+// show, read back from the table above (first entry per extension wins).
+// `.webm` and `.svg` are left out on purpose: a recorded voice note is often
+// a `.webm` and must stay generic (audio), and SVG is not a bubble picture.
+const INFERRABLE_EXT_TO_MIME: Record<string, string> = {};
+for (const [mime, ext] of Object.entries(MIME_TO_EXT)) {
+  const inferrable =
+    mime === 'application/pdf' ||
+    mime.startsWith('image/') ||
+    mime.startsWith('video/') ||
+    mime.startsWith('audio/');
+  const bare = ext.slice(1);
+  if (inferrable && bare !== 'webm' && bare !== 'svg' && !INFERRABLE_EXT_TO_MIME[bare]) {
+    INFERRABLE_EXT_TO_MIME[bare] = mime;
+  }
+}
+// Spellings the table above has no entry for.
+Object.assign(INFERRABLE_EXT_TO_MIME, {
+  jpeg: 'image/jpeg',
+  jpe: 'image/jpeg',
+  tif: 'image/tiff',
+  avif: 'image/avif',
+  avi: 'video/x-msvideo',
+  oga: 'audio/ogg',
+  opus: 'audio/ogg',
+  amr: 'audio/amr',
+});
+
+/** A mimetype that says nothing: empty, or the storage's "could not sniff". */
+export function isGenericMime(mime: string | undefined | null): boolean {
+  const normalized = (mime || '').toLowerCase().split(';')[0]!.trim();
+  return (
+    !normalized ||
+    normalized === 'application/octet-stream' ||
+    normalized === 'binary/octet-stream'
+  );
+}
+
+/**
+ * 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 function inferMimeFromName(
+  name: string | undefined | null
+): string | undefined {
+  const base = String(name || '').split(/[?#]/)[0]!;
+  const dot = base.lastIndexOf('.');
+  if (dot < 1) {return undefined;}
+  return INFERRABLE_EXT_TO_MIME[base.slice(dot + 1).toLowerCase()];
+}
+
 // Audio file extensions we recognise across the SDK. Used for the
 // "looks like audio even when the mimetype is application/octet-stream"
 // heuristic in MediaMessage / FilePreviewModal. Voice-message senders