@ethora/chat-component-rn 26.10.9 → 26.10.11

package/src/booking/pendingScheduledCall.ts

@@ -0,0 +1,272 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { store } from '../roomStore';
+import { openRoomFromPush } from '../helpers/pushPayload';
+import { normalizeRoomJid } from '../helpers/normalizeRoomJid';
+import {
+  getScheduledCall,
+  isScheduledCallApiError,
+} from '../networking/api-requests/scheduledCalls.api';
+import { parseScheduledCallLink } from './scheduledCallLink';
+import { chatNameOfRoom } from './scheduledCall';
+import { scheduledCallUi } from './scheduledCallStore';
+
+/**
+ * Opening a scheduled call from a link or a reminder push.
+ *
+ * A link can arrive while the app is still starting: before the user is
+ * signed in, or before `<Chat>` has configured the store and connected. The
+ * slug is then held (in memory, and in AsyncStorage so a cold start that
+ * is interrupted by the sign-in screen keeps it) and opened once both are
+ * true. Opening = resolve the slug through the API, open its room, show the
+ * pre-join sheet. No media starts before the user taps Join.
+ */
+
+export const PENDING_SCHEDULED_CALL_KEY = 'ethora_pending_scheduled_call';
+/** A link older than this is dropped instead of ambushing the user later. */
+export const PENDING_SCHEDULED_CALL_TTL_MS = 30 * 60 * 1000;
+
+export interface PendingStorage {
+  read(): Promise<{ slug: string; at: number } | null>;
+  write(value: { slug: string; at: number }): Promise<void>;
+  clear(): Promise<void>;
+}
+
+export const asyncPendingStorage: PendingStorage = {
+  async read() {
+    try {
+      const raw = await AsyncStorage.getItem(PENDING_SCHEDULED_CALL_KEY);
+      if (!raw) {return null;}
+      const parsed = JSON.parse(raw);
+      return typeof parsed?.slug === 'string' && Number.isFinite(parsed?.at)
+        ? { slug: parsed.slug, at: parsed.at }
+        : null;
+    } catch {
+      return null;
+    }
+  },
+  async write(value) {
+    try {
+      await AsyncStorage.setItem(PENDING_SCHEDULED_CALL_KEY, JSON.stringify(value));
+    } catch {
+      // Memory still holds it.
+    }
+  },
+  async clear() {
+    try {
+      await AsyncStorage.removeItem(PENDING_SCHEDULED_CALL_KEY);
+    } catch {
+      // Nothing to do.
+    }
+  },
+};
+
+export interface PendingQueueDeps {
+  /** Signed in AND the chat is configured and connected. */
+  isReady: () => boolean;
+  /** Opens the call; called once per held link, when ready. */
+  open: (slug: string) => void;
+  storage: PendingStorage;
+  now?: () => number;
+  ttlMs?: number;
+}
+
+/**
+ * The hold-until-ready logic, free of the store so it can be tested. One
+ * slot: a newer link replaces an older one (the user tapped it last).
+ */
+export const createPendingScheduledCallQueue = (deps: PendingQueueDeps) => {
+  const now = deps.now || Date.now;
+  const ttl = deps.ttlMs ?? PENDING_SCHEDULED_CALL_TTL_MS;
+  let held: { slug: string; at: number } | null = null;
+  let restored = false;
+
+  const fresh = (entry: { slug: string; at: number } | null) =>
+    !!entry && now() - entry.at <= ttl;
+
+  const flush = (): boolean => {
+    if (!held) {return false;}
+    if (!fresh(held)) {
+      held = null;
+      void deps.storage.clear();
+      return false;
+    }
+    if (!deps.isReady()) {return false;}
+    const { slug } = held;
+    held = null;
+    void deps.storage.clear();
+    deps.open(slug);
+    return true;
+  };
+
+  return {
+    /** A link arrived: open it now, or hold it. Returns what happened. */
+    submit(slug: string): 'opened' | 'held' {
+      held = { slug, at: now() };
+      if (flush()) {return 'opened';}
+      void deps.storage.write(held);
+      return 'held';
+    },
+    /** Something that can make us ready changed. */
+    poke(): boolean {
+      return flush();
+    },
+    /** Pick up a link persisted by an earlier run of the app. */
+    async restore(): Promise<void> {
+      if (restored) {return;}
+      restored = true;
+      const saved = await deps.storage.read();
+      // A link that arrived while we were reading is newer: keep it.
+      if (!held && saved && fresh(saved)) {
+        held = saved;
+      } else if (!fresh(saved)) {
+        void deps.storage.clear();
+      }
+      flush();
+    },
+    peek: () => held,
+    reset() {
+      held = null;
+      restored = false;
+    },
+  };
+};
+
+export const isScheduledCallReady = (): boolean => {
+  const settings = store.getState().chatSettingStore;
+  return (
+    !!settings.user?.token &&
+    settings.config !== undefined &&
+    (settings.connection === 'online' || settings.connection === 'syncing')
+  );
+};
+
+const reportOpenError = (
+  slug: string,
+  reason: 'not-found' | 'not-a-member' | 'cancelled' | 'network'
+): void => {
+  try {
+    store
+      .getState()
+      .chatSettingStore.config?.scheduledCalls?.onOpenError?.({ slug, reason });
+  } catch {
+    // A host callback must not break the flow.
+  }
+};
+
+/** Resolve the slug, open its room, show the pre-join sheet. */
+export const resolveAndOpenScheduledCall = async (
+  slug: string
+): Promise<void> => {
+  scheduledCallUi.showPreJoin({ phase: 'loading', slug });
+  let detail;
+  try {
+    detail = await getScheduledCall(slug);
+  } catch (error) {
+    const code = isScheduledCallApiError(error) ? error.code : 'unknown';
+    const reason =
+      code === 'not-a-member'
+        ? 'not-a-member'
+        : code === 'not-found'
+          ? 'not-found'
+          : 'network';
+    scheduledCallUi.showPreJoin({ phase: 'error', slug, reason });
+    reportOpenError(slug, reason);
+    return;
+  }
+  if (detail.scheduledCall.status === 'cancelled') {
+    scheduledCallUi.showPreJoin({
+      phase: 'error',
+      slug,
+      reason: 'cancelled',
+      title: detail.scheduledCall.title,
+    });
+    reportOpenError(slug, 'cancelled');
+    return;
+  }
+  const conference = store.getState().chatSettingStore.config?.xmppSettings?.conference;
+  const jid =
+    detail.chat?.jid ||
+    normalizeRoomJid(
+      detail.chat?.name || chatNameOfRoom(detail.scheduledCall.chatName),
+      conference
+    );
+  if (jid) {openRoomFromPush(jid);}
+  scheduledCallUi.showPreJoin({ phase: 'ready', slug, detail });
+};
+
+const queue = createPendingScheduledCallQueue({
+  isReady: isScheduledCallReady,
+  open: (slug) => {
+    void resolveAndOpenScheduledCall(slug);
+  },
+  storage: asyncPendingStorage,
+});
+
+let unsubscribe: (() => void) | null = null;
+
+/**
+ * Watches the store so a held link opens the moment sign-in and the chat
+ * are both there. Idempotent; `<Chat>` arms it on import and
+ * `openScheduledCall` arms it too, so a link that beats `<Chat>` is not lost.
+ */
+export const installScheduledCallHook = (): void => {
+  if (unsubscribe) {return;}
+  unsubscribe = store.subscribe(() => {
+    if (queue.peek()) {queue.poke();}
+  });
+  void queue.restore();
+};
+
+/**
+ * Open a scheduled call by slug: now when the user is signed in and the
+ * chat is up, otherwise as soon as both are true. Returns `'opening'` when
+ * it started right away and `'pending'` when it is held.
+ */
+export const openScheduledCall = (slug: string): 'opening' | 'pending' => {
+  installScheduledCallHook();
+  return queue.submit(slug) === 'opened' ? 'opening' : 'pending';
+};
+
+/**
+ * Hand any URL to the SDK: a scheduled-call link is opened (or held) and
+ * `true` is returned; anything else returns `false` untouched.
+ */
+export const handleScheduledCallUrl = (url: string | null | undefined): boolean => {
+  const slug = parseScheduledCallLink(url);
+  if (!slug) {return false;}
+  openScheduledCall(slug);
+  return true;
+};
+
+/** The reminder push the backend sends 10 minutes before a call. */
+export const SCHEDULED_CALL_REMINDER_PUSH_TYPE = 'scheduledCallReminder';
+
+export const isScheduledCallReminderPush = (
+  data: Record<string, unknown> | null | undefined
+): boolean => String(data?.type || '') === SCHEDULED_CALL_REMINDER_PUSH_TYPE;
+
+/** Slug of a reminder push: `slug`, else parsed out of `joinUrl`. */
+export const scheduledCallSlugFromPush = (
+  data: Record<string, unknown> | null | undefined
+): string | null => {
+  if (!isScheduledCallReminderPush(data)) {return null;}
+  const slug = String(data?.slug || '').trim();
+  if (/^[A-Za-z0-9_-]{16,128}$/.test(slug)) {return slug;}
+  return parseScheduledCallLink(String(data?.joinUrl || ''));
+};
+
+/** A tap on the reminder push opens the same flow as the join link. */
+export const handleScheduledCallPush = (
+  data: Record<string, unknown> | null | undefined
+): boolean => {
+  const slug = scheduledCallSlugFromPush(data);
+  if (!slug) {return false;}
+  openScheduledCall(slug);
+  return true;
+};
+
+export const __resetPendingScheduledCallForTests = (): void => {
+  queue.reset();
+  unsubscribe?.();
+  unsubscribe = null;
+};

package/src/booking/scheduleForm.ts

@@ -0,0 +1,84 @@
+/**
+ * Pure helpers behind the schedule / edit sheet: the default start, the
+ * stepper arithmetic and the validation the server repeats.
+ */
+
+export const MIN_DURATION_MINUTES = 5;
+export const MAX_DURATION_MINUTES = 480;
+export const DEFAULT_DURATION_MINUTES = 30;
+export const DURATION_CHOICES = [15, 30, 45, 60, 90, 120];
+export const TIME_STEP_MINUTES = 15;
+export const TITLE_MAX = 200;
+export const NOTES_MAX = 2000;
+/** The server accepts a start this far in the past (clock skew). */
+export const CLOCK_SKEW_MS = 2 * 60 * 1000;
+
+const MINUTE = 60 * 1000;
+
+/** The next quarter hour that is at least 15 minutes away. */
+export const defaultStartMs = (now: number): number => {
+  const step = TIME_STEP_MINUTES * MINUTE;
+  const earliest = now + 15 * MINUTE;
+  return Math.ceil(earliest / step) * step;
+};
+
+/** Move by whole local days (DST safe: done on the calendar, not by 24 h). */
+export const shiftDays = (ms: number, days: number): number => {
+  const d = new Date(ms);
+  d.setDate(d.getDate() + days);
+  return d.getTime();
+};
+
+export const shiftMinutes = (ms: number, minutes: number): number =>
+  ms + minutes * MINUTE;
+
+export const clampDuration = (minutes: number): number => {
+  const n = Math.round(Number(minutes));
+  if (!Number.isFinite(n)) {return DEFAULT_DURATION_MINUTES;}
+  return Math.min(MAX_DURATION_MINUTES, Math.max(MIN_DURATION_MINUTES, n));
+};
+
+export type ScheduleFormError = 'pastTime' | null;
+
+/** Only the rules the client can check; the server stays the authority. */
+export const validateStart = (
+  startMs: number,
+  now: number,
+  options?: { allowPast?: boolean }
+): ScheduleFormError => {
+  if (!Number.isFinite(startMs)) {return 'pastTime';}
+  if (options?.allowPast) {return null;}
+  return startMs < now - CLOCK_SKEW_MS ? 'pastTime' : null;
+};
+
+export const deviceTimezone = (): string | undefined => {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || undefined;
+  } catch {
+    return undefined;
+  }
+};
+
+export const formatDay = (ms: number, locale?: string): string => {
+  try {
+    return new Date(ms).toLocaleDateString(locale, {
+      weekday: 'short',
+      day: 'numeric',
+      month: 'short',
+      year: 'numeric',
+    });
+  } catch {
+    return new Date(ms).toDateString();
+  }
+};
+
+export const formatClock = (ms: number, locale?: string): string => {
+  try {
+    return new Date(ms).toLocaleTimeString(locale, {
+      hour: '2-digit',
+      minute: '2-digit',
+    });
+  } catch {
+    return new Date(ms).toTimeString().slice(0, 5);
+  }
+};

package/src/booking/scheduledCall.ts

@@ -0,0 +1,163 @@
+import { msgSortableMs } from '../helpers/msgSortableMs';
+import type { IMessage } from '../types/types';
+
+/**
+ * Scheduled-call invite cards: what a `<data type="scheduledCall">` message
+ * says, and the pure rules for which message owns a card and what state the
+ * card is in. No React, no store: everything here is unit-testable.
+ */
+
+export const SCHEDULED_CALL_MESSAGE_TYPE = 'scheduledCall';
+
+/** Join opens this long before the start (contract: 15 minutes). */
+export const JOIN_WINDOW_BEFORE_MS = 15 * 60 * 1000;
+
+export type ScheduledCallMessageStatus = 'scheduled' | 'updated' | 'cancelled';
+
+/** upcoming -> joinable (15 min before start until the end) -> ended; or cancelled. */
+export type ScheduledCallCardState =
+  | 'upcoming'
+  | 'joinable'
+  | 'ended'
+  | 'cancelled';
+
+export interface ScheduledCallCardData {
+  slug: string;
+  title: string;
+  /** ISO UTC. */
+  startAt: string;
+  startMs: number;
+  durationMinutes: number;
+  kind: 'video' | 'audio';
+  status: ScheduledCallMessageStatus;
+  joinUrl: string;
+  icsUrl: string;
+  googleUrl: string;
+  outlookUrl: string;
+  /** Creator's user id (`scheduledCallCreatedBy`); '' on an invite that predates it. */
+  createdBy: string;
+}
+
+const text = (value: unknown): string =>
+  typeof value === 'string' ? value.trim() : '';
+
+export const isScheduledCallMessage = (message: unknown): boolean =>
+  text((message as any)?.type) === SCHEDULED_CALL_MESSAGE_TYPE &&
+  !!text((message as any)?.scheduledCallSlug);
+
+/**
+ * The card data a message carries, or null when it is not a usable invite
+ * (no slug, or a start time that is not a date). Defaults follow the
+ * contract: 30 minutes, video, status `scheduled`.
+ */
+export const parseScheduledCallMessage = (
+  message: unknown
+): ScheduledCallCardData | null => {
+  if (!isScheduledCallMessage(message)) {return null;}
+  const raw = message as Record<string, any>;
+  const startAt = text(raw.scheduledCallStartAt);
+  const startMs = Date.parse(startAt);
+  if (!Number.isFinite(startMs)) {return null;}
+
+  const duration = Math.round(Number(raw.scheduledCallDurationMinutes));
+  const status = text(raw.scheduledCallStatus).toLowerCase();
+  return {
+    slug: text(raw.scheduledCallSlug),
+    title: text(raw.scheduledCallTitle),
+    startAt,
+    startMs,
+    durationMinutes: Number.isFinite(duration) && duration > 0 ? duration : 30,
+    kind: text(raw.scheduledCallKind).toLowerCase() === 'audio' ? 'audio' : 'video',
+    status:
+      status === 'cancelled' || status === 'canceled'
+        ? 'cancelled'
+        : status === 'updated'
+          ? 'updated'
+          : 'scheduled',
+    joinUrl: text(raw.scheduledCallJoinUrl),
+    icsUrl: text(raw.scheduledCallIcsUrl),
+    googleUrl: text(raw.scheduledCallGoogleUrl),
+    outlookUrl: text(raw.scheduledCallOutlookUrl),
+    createdBy: text(raw.scheduledCallCreatedBy),
+  };
+};
+
+/**
+ * One card per slug, latest message wins. "Latest" is the server order
+ * (message id, then date); on a tie the one further down the list.
+ * Returns slug -> the winning message.
+ */
+const latestCache = new WeakMap<object, Map<string, IMessage>>();
+
+export const latestScheduledCallMessages = (
+  messages: ReadonlyArray<IMessage> | undefined | null
+): Map<string, IMessage> => {
+  const source = messages || [];
+  const cached = latestCache.get(source);
+  if (cached) {return cached;}
+  const winners = new Map<string, { message: IMessage; at: number }>();
+  source.forEach((message) => {
+    if (!isScheduledCallMessage(message)) {return;}
+    const slug = text((message as any).scheduledCallSlug);
+    const at = msgSortableMs(message);
+    const current = winners.get(slug);
+    if (!current || at >= current.at) {
+      winners.set(slug, { message, at });
+    }
+  });
+  const out = new Map<string, IMessage>();
+  winners.forEach((value, slug) => out.set(slug, value.message));
+  // The store hands out a new array whenever messages change, so the array
+  // itself is the cache key (every card in a room shares one pass).
+  if (messages) {latestCache.set(messages, out);}
+  return out;
+};
+
+/** The message that owns this slug's card, or undefined for no invite at all. */
+export const latestScheduledCallMessage = (
+  messages: ReadonlyArray<IMessage> | undefined | null,
+  slug: string
+): IMessage | undefined => latestScheduledCallMessages(messages).get(slug);
+
+export const scheduledCallEndMs = (
+  card: Pick<ScheduledCallCardData, 'startMs' | 'durationMinutes'>
+): number => card.startMs + card.durationMinutes * 60 * 1000;
+
+/** Where a card stands at `now` (epoch ms). */
+export const getScheduledCallCardState = (
+  card: Pick<
+    ScheduledCallCardData,
+    'startMs' | 'durationMinutes' | 'status'
+  >,
+  now: number
+): ScheduledCallCardState => {
+  if (card.status === 'cancelled') {return 'cancelled';}
+  if (now >= scheduledCallEndMs(card)) {return 'ended';}
+  if (now >= card.startMs - JOIN_WINDOW_BEFORE_MS) {return 'joinable';}
+  return 'upcoming';
+};
+
+/**
+ * The next instant the card's state changes (join window opens, call ends),
+ * or null when it will not change on its own (cancelled / ended). Lets the
+ * card sleep until then instead of polling.
+ */
+export const nextScheduledCallTransition = (
+  card: Pick<
+    ScheduledCallCardData,
+    'startMs' | 'durationMinutes' | 'status'
+  >,
+  now: number
+): number | null => {
+  const state = getScheduledCallCardState(card, now);
+  if (state === 'upcoming') {return card.startMs - JOIN_WINDOW_BEFORE_MS;}
+  if (state === 'joinable') {return scheduledCallEndMs(card);}
+  return null;
+};
+
+/** Longest a single setTimeout may sleep (the platform clamps at 2^31-1 ms). */
+export const MAX_TIMER_MS = 2_000_000_000;
+
+/** The room's bare name, as the call and booking endpoints take it. */
+export const chatNameOfRoom = (roomJidOrName: string): string =>
+  String(roomJidOrName || '').split('@')[0];

package/src/booking/scheduledCallActions.ts

@@ -0,0 +1,141 @@
+import { Alert, Linking } from 'react-native';
+import { store } from '../roomStore';
+import { toastEmitter } from '../utils/toastEmitter';
+import {
+  cancelScheduledCall,
+  getScheduledCall,
+  type ScheduledCallDetail,
+} from '../networking/api-requests/scheduledCalls.api';
+import { translateCallString } from '../components/VideoCalls/callActions';
+import { startRoomCall, type StartRoomCallOutcome } from './startRoomCall';
+
+/**
+ * What the buttons of the invite card and the pre-join sheet do. Kept out of
+ * the components so both share one behaviour (and so it reads in one place).
+ */
+
+const t = translateCallString;
+
+const toast = (type: 'success' | 'error', message: string) =>
+  toastEmitter.emit({
+    id: `scheduled-call-${Date.now()}`,
+    title: t(type === 'success' ? 'toast.successTitle' : 'toast.error'),
+    message,
+    type,
+  });
+
+export const notifyScheduledCall = toast;
+
+/** A link the backend gave us, opened as is. Only web links are opened. */
+export const openBackendLink = async (url: string | undefined): Promise<void> => {
+  if (!url || !/^https?:\/\//i.test(url)) {
+    toast('error', t('booking.error.openLink'));
+    return;
+  }
+  try {
+    await Linking.openURL(url);
+  } catch {
+    toast('error', t('booking.error.openLink'));
+  }
+};
+
+const JOIN_ERRORS: Partial<Record<StartRoomCallOutcome, string>> = {
+  busy: 'booking.error.busy',
+  disabled: 'booking.error.callsOff',
+  'no-room': 'booking.error.joinFailed',
+  failed: 'booking.error.joinFailed',
+};
+
+/** The user tapped Join: the room's ordinary call start / join. */
+export const joinScheduledCall = async (
+  roomJidOrName: string,
+  kind: 'audio' | 'video'
+): Promise<boolean> => {
+  const outcome = await startRoomCall(roomJidOrName, kind);
+  const errorKey = JOIN_ERRORS[outcome];
+  if (errorKey) {
+    toast('error', t(errorKey));
+    return false;
+  }
+  return true;
+};
+
+const confirmCancel = (): Promise<boolean> =>
+  new Promise((resolve) => {
+    Alert.alert(
+      t('booking.confirm.cancelTitle'),
+      t('booking.confirm.cancelMessage'),
+      [
+        {
+          text: t('booking.action.keepCall'),
+          style: 'cancel',
+          onPress: () => resolve(false),
+        },
+        {
+          text: t('booking.action.cancelCall'),
+          style: 'destructive',
+          onPress: () => resolve(true),
+        },
+      ],
+      { cancelable: true, onDismiss: () => resolve(false) }
+    );
+  });
+
+/** Ask, then cancel. Resolves true when the call was cancelled. */
+export const confirmAndCancelScheduledCall = async (
+  slug: string
+): Promise<boolean> => {
+  if (!(await confirmCancel())) {return false;}
+  try {
+    await cancelScheduledCall(slug);
+    invalidateScheduledCallDetail(slug);
+    toast('success', t('booking.toast.cancelled'));
+    return true;
+  } catch {
+    toast('error', t('booking.error.cancel'));
+    return false;
+  }
+};
+
+// ---- detail cache: the cards ask for a call's detail (creator, notes) once.
+
+const details = new Map<string, Promise<ScheduledCallDetail>>();
+
+export const getScheduledCallDetailCached = (
+  slug: string,
+  version: string
+): Promise<ScheduledCallDetail> => {
+  const key = `${slug}|${version}`;
+  let hit = details.get(key);
+  if (!hit) {
+    hit = getScheduledCall(slug);
+    details.set(key, hit);
+    hit.catch(() => details.delete(key));
+  }
+  return hit;
+};
+
+export const invalidateScheduledCallDetail = (slug: string): void => {
+  [...details.keys()]
+    .filter((key) => key.startsWith(`${slug}|`))
+    .forEach((key) => details.delete(key));
+};
+
+export const __resetScheduledCallDetailCacheForTests = (): void => details.clear();
+
+/**
+ * May this user edit or cancel the call? The server decides for real
+ * (creator or room owner); this only decides whether to show the buttons.
+ */
+export const canManageScheduledCall = (params: {
+  createdBy?: string;
+  userId?: string;
+  roomRole?: string;
+}): boolean => {
+  const { createdBy, userId, roomRole } = params;
+  if (createdBy && userId && createdBy === userId) {return true;}
+  return roomRole === 'owner' || roomRole === 'moderator';
+};
+
+export const currentUserId = (): string =>
+  store.getState().chatSettingStore.user?._id || '';