@repzo/widget-react-native 1.0.0 → 1.0.4

package/src/attachments/pickers.ts

@@ -0,0 +1,515 @@
+/**
+ * Visitor attachments: picking photos/files and turning them into the base64
+ * data URLs `POST /api/widget/messages` accepts.
+ *
+ * The SDK ships no native code, so every picker is borrowed from the host —
+ * the same approach as `storage.ts` and `native-gradient.ts`:
+ * - `expo-image-picker` → photo library and camera
+ * - `expo-document-picker` → any file
+ * - `expo-file-system` → reads a picked file as base64 (optional; without it
+ *   the file is read through `fetch` + `FileReader`)
+ * - `expo-image-manipulator` → shrinks photos to fit the 1.5 MB cap (optional;
+ *   without it a full-resolution camera photo is usually refused as too large)
+ *
+ * A host without those (or with `react-native-image-picker` etc.) plugs its own
+ * picker in through `boot({ attachments: { pick } })`. With neither, the attach
+ * button simply isn't shown.
+ *
+ * No `react-native` import on purpose: the limit and encoding helpers stay
+ * testable in plain Node.
+ */
+
+import type { AttachmentSource, RepzoPickedFile, RepzoWidgetAttachmentOptions } from '../types';
+
+/** The server keeps the first five and silently drops the rest. */
+export const MAX_ATTACHMENTS = 5;
+/** Per file, decoded. The server silently drops anything larger. */
+export const MAX_ATTACHMENT_BYTES = 1_500_000;
+/**
+ * All files in one message, decoded. Base64 inside JSON inflates bytes by
+ * ~1.37x and the server caps a request body at 10 MB, so five files at the
+ * per-file maximum would come back as a 413.
+ */
+export const MAX_TOTAL_ATTACHMENT_BYTES = 6_000_000;
+
+/** Photos are re-encoded at this JPEG quality — small enough to fit the cap more often. */
+const IMAGE_QUALITY = 0.7;
+
+/** A picked file, encoded and ready to send; what the composer shows as a chip. */
+export interface DraftAttachment {
+  id: string;
+  name: string;
+  contentType: string;
+  /** Decoded bytes — what the server measures against its cap. */
+  size: number;
+  /** `data:<mime>;base64,<…>` — the wire format. */
+  dataUrl: string;
+  /** What `<Image>` renders locally: the picked file's URI, else the data URL. */
+  previewUri: string;
+}
+
+/** Why some (or all) of a pick didn't make it into the composer. */
+export type AttachmentProblem =
+  | 'tooMany'
+  | 'tooLarge'
+  | 'tooLargeTogether'
+  | 'cameraDenied'
+  | 'failed';
+
+export interface PickResult {
+  added: DraftAttachment[];
+  /** The first thing that went wrong; files that fit are still added. */
+  problem: AttachmentProblem | null;
+}
+
+// ─── Host integrations ─────────────────────────────────────────────────────
+// Resolved once at module load. Each `require` is static so Metro can see it,
+// and `withRepzoWidget` (metro.js) maps an uninstalled one to an empty module.
+
+let imagePicker: any = null;
+try {
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const mod = require('expo-image-picker');
+  if (typeof mod?.launchImageLibraryAsync === 'function') imagePicker = mod;
+} catch {
+  imagePicker = null;
+}
+
+let documentPicker: any = null;
+try {
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const mod = require('expo-document-picker');
+  if (typeof mod?.getDocumentAsync === 'function') documentPicker = mod;
+} catch {
+  documentPicker = null;
+}
+
+let fileSystem: any = null;
+try {
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  fileSystem = require('expo-file-system') ?? null;
+} catch {
+  fileSystem = null;
+}
+
+let imageManipulator: any = null;
+try {
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const mod = require('expo-image-manipulator');
+  if (
+    typeof mod?.manipulateAsync === 'function' ||
+    typeof mod?.ImageManipulator?.manipulate === 'function'
+  ) {
+    imageManipulator = mod;
+  }
+} catch {
+  imageManipulator = null;
+}
+
+/** Longest edge of a shrunk photo — plenty for chat, typically 200–500 KB as JPEG. */
+const MAX_IMAGE_EDGE = 1600;
+
+let hostOptions: RepzoWidgetAttachmentOptions | null = null;
+
+/** Set from `boot({ attachments })`; `null` restores auto-detection. */
+export function setAttachmentOptions(options: RepzoWidgetAttachmentOptions | null): void {
+  hostOptions = options;
+}
+
+const ALL_SOURCES: AttachmentSource[] = ['photo', 'camera', 'file'];
+
+/**
+ * The options the attach menu offers, in menu order. Empty means no button:
+ * attachments were switched off by the host, or nothing can pick a file.
+ */
+export function getAttachmentSources(): AttachmentSource[] {
+  if (hostOptions?.enabled === false) return [];
+  if (hostOptions?.pick) {
+    const wanted = hostOptions.sources ?? ALL_SOURCES;
+    return ALL_SOURCES.filter((source) => wanted.includes(source));
+  }
+  const sources: AttachmentSource[] = [];
+  if (imagePicker) sources.push('photo');
+  if (typeof imagePicker?.launchCameraAsync === 'function') sources.push('camera');
+  if (documentPicker) sources.push('file');
+  return sources;
+}
+
+// ─── Picking ───────────────────────────────────────────────────────────────
+
+/** Returned (not thrown) so no `instanceof` on an Error subclass is needed. */
+const CAMERA_DENIED = 'cameraDenied' as const;
+
+/**
+ * Opens the picker for `source` and returns what fits alongside `current`.
+ * Never throws: a cancelled pick is `{ added: [], problem: null }`.
+ */
+export async function pickAttachments(
+  source: AttachmentSource,
+  current: DraftAttachment[]
+): Promise<PickResult> {
+  const slots = MAX_ATTACHMENTS - current.length;
+  if (slots <= 0) return { added: [], problem: 'tooMany' };
+
+  let picked: RepzoPickedFile[] | null | typeof CAMERA_DENIED;
+  try {
+    picked = hostOptions?.pick
+      ? await hostOptions.pick(source)
+      : await launchBuiltInPicker(source, slots);
+  } catch (error) {
+    console.warn('[repzo-widget] attachment picker failed', error);
+    return { added: [], problem: 'failed' };
+  }
+  if (picked === CAMERA_DENIED) return { added: [], problem: 'cameraDenied' };
+  if (!Array.isArray(picked) || picked.length === 0) return { added: [], problem: null };
+
+  const added: DraftAttachment[] = [];
+  let problem: AttachmentProblem | null = null;
+  for (const file of picked) {
+    const accepted = [...current, ...added];
+    if (accepted.length >= MAX_ATTACHMENTS) {
+      problem = problem ?? 'tooMany';
+      break;
+    }
+    // A size the picker already knows rules a file out before it's read, so
+    // a 40 MB video never lands in memory as a base64 string.
+    const declared = file.base64 ? null : validSize(file.size);
+    const early = declared === null ? null : checkAttachmentFits(accepted, declared);
+    if (early) {
+      problem = problem ?? early;
+      continue;
+    }
+
+    let draft: DraftAttachment;
+    try {
+      draft = await toDraft(file);
+    } catch (error) {
+      if (error === TOO_LARGE) {
+        problem = problem ?? 'tooLarge';
+        continue;
+      }
+      console.warn('[repzo-widget] could not read attachment', error);
+      problem = problem ?? 'failed';
+      continue;
+    }
+    const fits = draft.size > 0 ? checkAttachmentFits(accepted, draft.size) : 'failed';
+    if (fits) {
+      problem = problem ?? fits;
+      continue;
+    }
+    added.push(draft);
+  }
+  return { added, problem };
+}
+
+async function launchBuiltInPicker(
+  source: AttachmentSource,
+  slots: number
+): Promise<RepzoPickedFile[] | null | typeof CAMERA_DENIED> {
+  if (source === 'file') {
+    if (!documentPicker) return null;
+    const result = await documentPicker.getDocumentAsync({
+      type: '*/*',
+      multiple: slots > 1,
+      copyToCacheDirectory: true,
+    });
+    // SDK 48+ returns `{ canceled, assets }`; older ones a single `{ type, uri, … }`.
+    if (result?.canceled || result?.type === 'cancel') return null;
+    const assets: any[] = Array.isArray(result?.assets) ? result.assets : result?.uri ? [result] : [];
+    return assets.map((asset) => ({
+      name: asset.name || fileNameFromUri(asset.uri) || 'file',
+      type: asset.mimeType || '',
+      size: asset.size,
+      uri: asset.uri,
+    }));
+  }
+
+  if (!imagePicker) return null;
+  const options = {
+    quality: IMAGE_QUALITY,
+    // With the manipulator the photo is re-encoded below, so the picker's own
+    // (full-resolution) base64 would only waste memory.
+    base64: !imageManipulator,
+    exif: false,
+  };
+
+  let result: any;
+  if (source === 'camera') {
+    const permission = await imagePicker.requestCameraPermissionsAsync?.();
+    if (permission && permission.granted === false) return CAMERA_DENIED;
+    result = await launchImagePicker(imagePicker.launchCameraAsync, options);
+  } else {
+    result = await launchImagePicker(imagePicker.launchImageLibraryAsync, {
+      ...options,
+      allowsMultipleSelection: slots > 1,
+      selectionLimit: slots,
+    });
+  }
+  if (result?.canceled || result?.cancelled) return null;
+  const assets: any[] = Array.isArray(result?.assets) ? result.assets : [];
+  const files: RepzoPickedFile[] = [];
+  for (const [index, asset] of assets.slice(0, slots).entries()) {
+    const shrunk = await shrinkPhoto(asset);
+    const type = shrunk
+      ? 'image/jpeg'
+      : asset.mimeType || guessContentType(asset.fileName || asset.uri) || 'image/jpeg';
+    const baseName = (asset.fileName || `photo-${Date.now()}-${index + 1}`).replace(/\.[^.]+$/, '');
+    files.push({
+      name: `${baseName}.${extensionFor(type)}`,
+      type,
+      // No `size`: `fileSize` is the original's, not the re-encoded base64's.
+      uri: shrunk?.uri ?? asset.uri,
+      base64: shrunk?.base64 ?? asset.base64 ?? undefined,
+    });
+  }
+  return files;
+}
+
+/**
+ * `mediaTypes: ['images']` is the expo-image-picker 16 (SDK 52)+ form; older
+ * versions reject the array before any UI shows, so retry with the legacy
+ * `MediaTypeOptions.Images` enum they expect.
+ */
+async function launchImagePicker(launch: (options: object) => Promise<any>, options: object) {
+  try {
+    return await launch({ ...options, mediaTypes: ['images'] });
+  } catch (error) {
+    const legacy = imagePicker?.MediaTypeOptions?.Images;
+    if (!legacy) throw error;
+    return launch({ ...options, mediaTypes: legacy });
+  }
+}
+
+/**
+ * Re-encodes a photo as JPEG, scaled so its longest edge is at most
+ * MAX_IMAGE_EDGE. Null when the manipulator isn't installed or fails — the
+ * caller then falls back to the picker's own output (and the size check).
+ */
+async function shrinkPhoto(asset: any): Promise<{ uri: string; base64: string } | null> {
+  if (!imageManipulator || !asset?.uri) return null;
+  const width = Number(asset.width) || 0;
+  const height = Number(asset.height) || 0;
+  const longest = Math.max(width, height);
+  const resize =
+    longest > MAX_IMAGE_EDGE
+      ? width >= height
+        ? { width: MAX_IMAGE_EDGE }
+        : { height: MAX_IMAGE_EDGE }
+      : null;
+  const saveOptions = {
+    compress: IMAGE_QUALITY,
+    format: imageManipulator.SaveFormat?.JPEG ?? 'jpeg',
+    base64: true,
+  };
+  try {
+    let output: any;
+    if (typeof imageManipulator.manipulateAsync === 'function') {
+      output = await imageManipulator.manipulateAsync(asset.uri, resize ? [{ resize }] : [], saveOptions);
+    } else {
+      const context = imageManipulator.ImageManipulator.manipulate(asset.uri);
+      if (resize) context.resize(resize);
+      const image = await context.renderAsync();
+      output = await image.saveAsync(saveOptions);
+    }
+    return typeof output?.base64 === 'string' && output.base64
+      ? { uri: output.uri ?? asset.uri, base64: output.base64 }
+      : null;
+  } catch (error) {
+    console.warn('[repzo-widget] could not shrink photo — sending it as picked', error);
+    return null;
+  }
+}
+
+async function toDraft(file: RepzoPickedFile): Promise<DraftAttachment> {
+  let base64 = file.base64 ? stripDataUrlPrefix(file.base64) : '';
+  if (!base64) {
+    if (!file.uri) throw new Error('Picked file has neither base64 nor uri');
+    base64 = await readBase64(file.uri);
+  }
+  base64 = base64.replace(/\s/g, '');
+
+  const name = (file.name || fileNameFromUri(file.uri) || 'file').slice(0, 255);
+  const contentType =
+    normalizeContentType(file.type) ?? guessContentType(name) ?? 'application/octet-stream';
+  const dataUrl = buildDataUrl(contentType, base64);
+  return {
+    id: `draft-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    name,
+    contentType,
+    size: base64ByteLength(base64),
+    dataUrl,
+    // Only the chip ever renders a data URL; the store keeps it out of messages.
+    previewUri: file.uri || dataUrl,
+  };
+}
+
+/** Thrown (by identity) when a file is over the per-file cap before it's read. */
+const TOO_LARGE = new Error('File exceeds the attachment cap');
+
+/**
+ * `expo-file-system`'s `File` class (SDK 54+) first, then its legacy
+ * `readAsStringAsync` (SDK 53 and older — a throwing stub on 54), then plain
+ * `fetch` + `FileReader`, which RN supports for `file://` URIs.
+ *
+ * Every path checks the size before encoding: the file-system readers only
+ * run once the file is known to fit, so a 300 MB video never becomes a
+ * 400 MB base64 string. When the size can't be read, `fetch` measures the blob.
+ */
+async function readBase64(uri: string): Promise<string> {
+  if (typeof fileSystem?.File === 'function') {
+    let file: any = null;
+    try {
+      file = new fileSystem.File(uri);
+    } catch {
+      file = null;
+    }
+    const size = validSize(file?.size);
+    if (size !== null && size > MAX_ATTACHMENT_BYTES) throw TOO_LARGE;
+    if (size !== null && typeof file.base64 === 'function') {
+      try {
+        const value = await file.base64();
+        if (typeof value === 'string' && value) return value;
+      } catch {
+        // Fall through to the next reader.
+      }
+    }
+  }
+  if (
+    typeof fileSystem?.readAsStringAsync === 'function' &&
+    typeof fileSystem?.getInfoAsync === 'function'
+  ) {
+    try {
+      const info = await fileSystem.getInfoAsync(uri, { size: true });
+      const size = validSize(info?.size);
+      if (size !== null && size > MAX_ATTACHMENT_BYTES) throw TOO_LARGE;
+      if (size !== null) {
+        const value = await fileSystem.readAsStringAsync(uri, { encoding: 'base64' });
+        if (typeof value === 'string' && value) return value;
+      }
+    } catch (error) {
+      if (error === TOO_LARGE) throw error;
+      // Fall through to fetch.
+    }
+  }
+  return readBase64WithFetch(uri);
+}
+
+async function readBase64WithFetch(uri: string): Promise<string> {
+  const response = await fetch(uri);
+  const blob = await response.blob();
+  // Checked before encoding: the per-file cap is the most any file may be.
+  if (blob.size > MAX_ATTACHMENT_BYTES) throw TOO_LARGE;
+  const dataUrl = await new Promise<string>((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(typeof reader.result === 'string' ? reader.result : '');
+    reader.onerror = () => reject(reader.error ?? new Error('FileReader failed'));
+    reader.readAsDataURL(blob);
+  });
+  return stripDataUrlPrefix(dataUrl);
+}
+
+// ─── Pure helpers ──────────────────────────────────────────────────────────
+
+/** Null when a file of `size` bytes still fits beside `current`; otherwise the limit it breaks. */
+export function checkAttachmentFits(
+  current: ReadonlyArray<{ size: number }>,
+  size: number
+): AttachmentProblem | null {
+  if (current.length >= MAX_ATTACHMENTS) return 'tooMany';
+  if (size > MAX_ATTACHMENT_BYTES) return 'tooLarge';
+  const total = current.reduce((sum, item) => sum + item.size, 0);
+  if (total + size > MAX_TOTAL_ATTACHMENT_BYTES) return 'tooLargeTogether';
+  return null;
+}
+
+export function buildDataUrl(contentType: string, base64: string): string {
+  return `data:${normalizeContentType(contentType) ?? 'application/octet-stream'};base64,${base64}`;
+}
+
+/** RFC 6838 `type/subtype` characters; no parameters, no `,` or `;`. */
+const MIME_TYPE = /^[a-z0-9][a-z0-9!#$&^_.+-]{0,63}\/[a-z0-9][a-z0-9!#$&^_.+-]{0,63}$/;
+
+/**
+ * A picker's MIME type as a bare lowercase `type/subtype`, or null when it
+ * isn't one. Parameters (`;charset=…`) are dropped: anything else could split
+ * the data URL at the wrong `,` and hand the server a forged content type.
+ */
+export function normalizeContentType(value: string | null | undefined): string | null {
+  if (typeof value !== 'string') return null;
+  const bare = value.split(';')[0]!.trim().toLowerCase();
+  return MIME_TYPE.test(bare) ? bare : null;
+}
+
+/** Accepts raw base64 or a whole data URL; returns the base64 part. */
+export function stripDataUrlPrefix(value: string): string {
+  const comma = value.startsWith('data:') ? value.indexOf(',') : -1;
+  return comma >= 0 ? value.slice(comma + 1) : value;
+}
+
+/** Decoded length of a base64 string (whitespace ignored). */
+export function base64ByteLength(base64: string): number {
+  const clean = base64.replace(/\s/g, '');
+  if (!clean) return 0;
+  const padding = clean.endsWith('==') ? 2 : clean.endsWith('=') ? 1 : 0;
+  return Math.floor((clean.length * 3) / 4) - padding;
+}
+
+/** `1.2 MB`, `340 KB` — for chips; the limits themselves use decimal units too. */
+export function formatBytes(bytes: number): string {
+  if (bytes >= 1_000_000) return `${(bytes / 1_000_000).toFixed(1).replace(/\.0$/, '')} MB`;
+  if (bytes >= 1_000) return `${Math.round(bytes / 1_000)} KB`;
+  return `${Math.max(0, Math.round(bytes))} B`;
+}
+
+export function isImageAttachment(contentType: string | null | undefined): boolean {
+  return !!contentType && contentType.toLowerCase().startsWith('image/');
+}
+
+function validSize(size: unknown): number | null {
+  return typeof size === 'number' && Number.isFinite(size) && size > 0 ? size : null;
+}
+
+function fileNameFromUri(uri: string | undefined): string | null {
+  if (!uri) return null;
+  const last = uri.split(/[?#]/)[0]?.split('/').pop();
+  if (!last) return null;
+  try {
+    return decodeURIComponent(last);
+  } catch {
+    return last;
+  }
+}
+
+const CONTENT_TYPES: Record<string, string> = {
+  jpg: 'image/jpeg',
+  jpeg: 'image/jpeg',
+  png: 'image/png',
+  gif: 'image/gif',
+  webp: 'image/webp',
+  heic: 'image/heic',
+  heif: 'image/heif',
+  pdf: 'application/pdf',
+  txt: 'text/plain',
+  csv: 'text/csv',
+  doc: 'application/msword',
+  docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  xls: 'application/vnd.ms-excel',
+  xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  ppt: 'application/vnd.ms-powerpoint',
+  pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+  zip: 'application/zip',
+  mp3: 'audio/mpeg',
+  m4a: 'audio/mp4',
+  mp4: 'video/mp4',
+  mov: 'video/quicktime',
+};
+
+function guessContentType(nameOrUri: string | null | undefined): string | null {
+  const extension = /\.([a-z0-9]+)$/i.exec(nameOrUri?.split(/[?#]/)[0] ?? '')?.[1];
+  return extension ? (CONTENT_TYPES[extension.toLowerCase()] ?? null) : null;
+}
+
+function extensionFor(contentType: string): string {
+  const subtype = contentType.split('/')[1]?.toLowerCase();
+  return subtype === 'jpeg' || !subtype ? 'jpg' : subtype;
+}

package/src/i18n.ts

@@ -29,6 +29,29 @@ export function createTranslator(config: WidgetConfig | null, locale: string): T
     fallback;
 }
 
+/**
+ * Dashboard copy that's written per language: the default language's text is
+ * the plain config field and every other enabled language's lives under the
+ * same key in `translations`.
+ */
+const WELCOME_TEXT_KEYS = [
+  'welcomeHeading',
+  'welcomeSubheading',
+  'startConversationLabel',
+  'replyTimeLabel',
+] as const;
+
+/** The config with its welcome text in the active locale. */
+export function localizeWelcomeText(config: WidgetConfig | null, locale: string): WidgetConfig | null {
+  if (!config) return config;
+  const translate = createTranslator(config, locale);
+  const localized = { ...config };
+  WELCOME_TEXT_KEYS.forEach((key) => {
+    localized[key] = translate(key, config[key]);
+  });
+  return localized;
+}
+
 export const DEFAULT_LABELS = {
   back: 'Back',
   loading: 'Loading...',
@@ -36,6 +59,21 @@ export const DEFAULT_LABELS = {
   emptyConversation: 'Send a message to start the conversation',
   messagePlaceholder: 'Type a message...',
   attachFile: 'Attach file',
+  // Attach menu, composer chips and the notices under them.
+  attachPhotoLibrary: 'Photo library',
+  attachTakePhoto: 'Take photo',
+  attachChooseFile: 'File',
+  removeAttachment: 'Remove {name}',
+  attachmentTooLarge: 'File is too large (max {max})',
+  attachmentTooMany: 'You can attach up to {count} files',
+  attachmentsTooLargeTogether:
+    'Attachments are too large to send together — send some in another message',
+  attachmentFailed: "Couldn't attach that file",
+  // Full-screen image viewer.
+  imageLoadFailed: "Couldn't load this image",
+  openImageExternally: 'Open image',
+  cameraPermissionDenied: 'Allow camera access in Settings to take a photo',
+  cancel: 'Cancel',
   failedToSend: 'Failed to send',
   thinking: 'Typing',
   messages: 'Messages',
@@ -75,6 +113,11 @@ export const DEFAULT_LABELS = {
   today: 'Today',
   yesterday: 'Yesterday',
   conversationUpdated: 'Conversation updated',
+  messageDeleted: 'This message was deleted',
+  messageSent: 'Sent',
+  messageSeen: 'Seen',
+  waitingForTeammate: 'Waiting for a teammate',
+  joinedConversation: 'joined the conversation',
   // Forms.
   procedureSend: 'Send details',
   procedureSent: 'Sent',
@@ -85,6 +128,11 @@ export const DEFAULT_LABELS = {
   outboundTitle: 'New update',
   outboundCta: 'Learn more',
   dismiss: 'Dismiss',
+  // In-app card for a new reply while the messenger is closed.
+  notificationReplyFrom: 'Reply from {name}',
+  notificationNewReply: 'New reply',
+  notificationAttachment: 'Sent an attachment',
+  notificationOpenHint: 'Opens the conversation',
   // Rich blocks an agent can send.
   blockService: 'Service',
   blockProduct: 'Product',

package/src/index.tsx

@@ -27,11 +27,15 @@ export { useWidgetState } from './state/use-widget-state';
 export type {
   AgentUiAction,
   AgentUiBlock,
+  AttachmentSource,
   BootOptions,
   Conversation,
+  InAppNotification,
   Message,
   OutboundMessage,
   PreChatField,
+  RepzoPickedFile,
+  RepzoWidgetAttachmentOptions,
   RepzoWidgetErrorCode,
   RepzoWidgetStorageAdapter,
   WidgetAttachment,

package/src/locales.ts

@@ -21,6 +21,18 @@ const ar: LabelMap = {
   emptyConversation: 'أرسل رسالة لبدء المحادثة',
   messagePlaceholder: 'اكتب رسالة...',
   attachFile: 'إرفاق ملف',
+  attachPhotoLibrary: 'مكتبة الصور',
+  attachTakePhoto: 'التقاط صورة',
+  attachChooseFile: 'ملف',
+  removeAttachment: 'إزالة {name}',
+  attachmentTooLarge: 'الملف كبير جدًا (الحد الأقصى {max})',
+  attachmentTooMany: 'يمكنك إرفاق {count} ملفات كحد أقصى',
+  attachmentsTooLargeTogether: 'المرفقات كبيرة جدًا لإرسالها معًا — أرسل بعضها في رسالة أخرى',
+  attachmentFailed: 'تعذر إرفاق هذا الملف',
+  imageLoadFailed: 'تعذر تحميل هذه الصورة',
+  openImageExternally: 'فتح الصورة',
+  cameraPermissionDenied: 'اسمح بالوصول إلى الكاميرا من الإعدادات لالتقاط صورة',
+  cancel: 'إلغاء',
   failedToSend: 'تعذر الإرسال',
   thinking: 'يكتب',
   messages: 'الرسائل',
@@ -57,6 +69,11 @@ const ar: LabelMap = {
   today: 'اليوم',
   yesterday: 'أمس',
   conversationUpdated: 'تم تحديث المحادثة',
+  messageDeleted: 'تم حذف هذه الرسالة',
+  messageSent: 'تم الإرسال',
+  messageSeen: 'تمت المشاهدة',
+  waitingForTeammate: 'بانتظار أحد أعضاء الفريق',
+  joinedConversation: 'انضم إلى المحادثة',
   procedureSend: 'إرسال التفاصيل',
   procedureSent: 'تم الإرسال',
   fieldRequired: '{field} مطلوب',
@@ -65,6 +82,10 @@ const ar: LabelMap = {
   outboundTitle: 'تحديث جديد',
   outboundCta: 'اعرف المزيد',
   dismiss: 'تجاهل',
+  notificationReplyFrom: 'رد من {name}',
+  notificationNewReply: 'رد جديد',
+  notificationAttachment: 'أرسل مرفقًا',
+  notificationOpenHint: 'يفتح المحادثة',
   blockService: 'خدمة',
   blockProduct: 'منتج',
   blockChooseTime: 'اختر وقتًا',