@ethora/chat-component 26.10.6 → 26.10.8

package/dist/types/models/scheduledCall.model.d.ts

@@ -0,0 +1,116 @@
+export type ScheduledCallKind = 'video' | 'audio';
+/** Lifecycle stored on the server row. */
+export type ScheduledCallStatus = 'scheduled' | 'cancelled';
+/**
+ * Status carried by the room message. `updated` means the call was edited
+ * after the first invite; the card treats it like `scheduled`.
+ */
+export type ScheduledCallMessageStatus = 'scheduled' | 'updated' | 'cancelled';
+export interface ScheduledCall {
+    id?: string;
+    appId?: string;
+    chatName: string;
+    chatType?: 'private' | 'group' | 'public';
+    createdBy?: string;
+    title: string;
+    description?: string;
+    /** ISO 8601, UTC. */
+    startAt: string;
+    durationMinutes: number;
+    timezone?: string;
+    kind: ScheduledCallKind;
+    slug: string;
+    status: ScheduledCallStatus;
+    sequence?: number;
+    reminderSentAt?: string | null;
+    createdAt?: string;
+    updatedAt?: string;
+}
+/** Links are built by the backend only; clients never compose calendar URLs. */
+export interface ScheduledCallLinks {
+    join: string;
+    ics: string;
+    google: string;
+    outlook: string;
+    office365?: string;
+}
+export interface ScheduledCallWithLinks {
+    scheduledCall: ScheduledCall;
+    links: ScheduledCallLinks;
+}
+export interface ScheduledCallDetails extends ScheduledCallWithLinks {
+    chat: {
+        name: string;
+        title?: string;
+        type?: string;
+        jid: string;
+    };
+}
+export interface CreateScheduledCallInput {
+    chatName: string;
+    title?: string;
+    description?: string;
+    startAt: string;
+    durationMinutes?: number;
+    timezone?: string;
+    kind?: ScheduledCallKind;
+}
+export interface UpdateScheduledCallInput {
+    title?: string;
+    description?: string;
+    startAt?: string;
+    durationMinutes?: number;
+    kind?: ScheduledCallKind;
+}
+/**
+ * What a `<data type="scheduledCall">` message boils down to. Persisted on the
+ * message (like `callLog`) so a reloaded transcript repaints the card before
+ * the archive re-delivers the stanza.
+ */
+export interface ScheduledCallMeta {
+    slug: string;
+    title: string;
+    /** ISO 8601, UTC. */
+    startAt: string;
+    durationMinutes: number;
+    kind: ScheduledCallKind;
+    status: ScheduledCallMessageStatus;
+    /** Creator's user id (`scheduledCallCreatedBy`), decides who sees Edit and Cancel. */
+    createdBy?: string;
+    joinUrl?: string;
+    icsUrl?: string;
+    googleUrl?: string;
+    outlookUrl?: string;
+}
+/** Why a scheduled call could not be opened. */
+export type ScheduledCallOpenError = 'not-found' | 'not-a-member' | 'cancelled' | 'network';
+export interface ScheduledCallsConfig {
+    /**
+     * Scheduling and invite cards. Defaults to on whenever video calls are on
+     * (`config.videoCalls.enabled`). `false` hides the "Schedule call" action;
+     * invite cards still render so a room that already holds one stays readable,
+     * but without the Join button.
+     */
+    enabled?: boolean;
+    /**
+     * Called when `scheduledCallSlug` (or `openScheduledCall(slug)`) could not be
+     * opened. A host that wants its own error screen resolves the slug itself
+     * first; this is for the in-chat fallback.
+     */
+    onOpenError?: (error: {
+        slug: string;
+        reason: ScheduledCallOpenError;
+    }) => void;
+    /**
+     * Hosts whose `https://<host>/call/<slug>` links `parseScheduledCallLink`
+     * accepts on top of `app.chat.ethora.com` and the page's own host. Same option
+     * name and defaults as the React Native SDK.
+     */
+    hosts?: string[];
+    /**
+     * Custom URL schemes (without `://`) that `parseScheduledCallLink` accepts
+     * for `<scheme>://call/<slug>`. Unset accepts any scheme. Same option name
+     * as the React Native SDK.
+     */
+    schemes?: string[];
+}

package/dist/types/models/xmpp.model.d.ts

@@ -1,4 +1,5 @@
 import { Client } from '@xmpp/client';
+import { ReactionStanzaData } from '../../networking/xmpp/sendMessageReaction.xmpp';
 import { Iso639_1Codes } from './language.model';
 import { default as XmppClient, HistoryWindowPage } from '../../networking/xmppClient';
 import { IMessage } from './message.model';
@@ -112,7 +113,7 @@ export interface XmppClientInterface {
     actionSetTimestampToPrivateStoreStanza(chatId: string, timestamp: number, chats?: string[]): Promise<void>;
     sendMediaMessageStanza(roomJID: string, data: MediaUploadData, id: string): Promise<boolean>;
     createPrivateRoomStanza(title: string, description: string, to: string): Promise<string>;
-    sendMessageReactionStanza(messageId: string, roomJid: string, reactionsList: string[], reactionSymbol?: string): void;
+    sendMessageReactionStanza(messageId: string, roomJid: string, reactionsList: string[], data?: ReactionStanzaData): void;
     sendTextMessageWithTranslateTagStanza(roomJID: string, firstName: string, lastName: string, photo: string, walletAddress: string, userMessage: string, notDisplayedValue?: string, isReply?: boolean, showInChannel?: boolean, mainMessage?: string, langSource?: Iso639_1Codes): void;
     disconnect?(options?: {
         suppressReconnect?: boolean;

package/dist/utils/callAuthMirror.d.ts

@@ -0,0 +1 @@
+export declare function mirrorCallAuthToWorker(token: string | null | undefined): Promise<void>;

package/dist/utils/callBroadcast.d.ts

@@ -0,0 +1,12 @@
+export type CallOutcome = 'accepted' | 'declined' | 'ended';
+export interface CallOutcomeMessage {
+    /** callNotificationKey of the call: its callId, or room:<room>. */
+    key: string;
+    outcome: CallOutcome;
+}
+export declare const CALL_OUTCOME_STORAGE_KEY = "@ethora/chat-component:callOutcome";
+export declare const broadcastCallOutcome: (key: string | null | undefined, outcome: CallOutcome) => void;
+/** Calls `callback` for an outcome another tab announced. Returns the unsubscribe. */
+export declare const subscribeCallOutcomes: (callback: (message: CallOutcomeMessage) => void) => (() => void);
+/** Test hook: forget the cached channel so a stubbed BroadcastChannel is picked up. */
+export declare const resetCallBroadcastForTests: () => void;

package/dist/utils/callNotifications.d.ts

@@ -0,0 +1,67 @@
+export declare const CALL_NOTIFICATION_ACTIONS: {
+    action: string;
+    title: string;
+}[];
+export declare const callNotificationTag: (key: string) => string;
+/**
+ * The key one call goes by in the page and in the service worker: its callId,
+ * or `room:<room bare name>` when the push or token carries none. Both sides
+ * must derive it the same way (the worker has its own copy, callKeyOf in
+ * firebase-messaging-sw.js), otherwise a call without a callId gets two
+ * notifications and the worker later swaps its own for a false "Missed call".
+ */
+export declare const callNotificationKey: (callId: string | null | undefined, roomRef: string | null | undefined) => string;
+/**
+ * Shows the "incoming call" notification. With a service worker registration
+ * (`useServiceWorker`) it goes through registration.showNotification, which is
+ * the only way to get Answer / Decline actions and to have the tap handled by
+ * the worker. Without one it falls back to `new Notification`, which cannot
+ * carry actions (the constructor throws on them), so they are dropped there.
+ *
+ * A ring shown through the registration is persistent (requireInteraction), so
+ * the worker is told (CALL_RING_SHOWN) and ends it at `expiresAt` (swapping it
+ * for "Missed call") even when this tab is closed before the ring is over.
+ */
+export declare function showCallNotification(title: string, options: NotificationOptions & {
+    data?: any;
+    tag: string;
+}, opts?: {
+    scope?: string;
+    useServiceWorker?: boolean;
+    onClick?: () => void;
+    /** When the call stops ringing (the token's exp), ms since epoch, if known. */
+    expiresAt?: number | null;
+}): Promise<void>;
+/**
+ * Closes the OS notification of a call, wherever it was shown: the page's own
+ * Notification, and anything with the call's tag in the worker registration
+ * (including the one the worker showed while no page was listening).
+ */
+export declare function closeCallNotifications(key: string, scope?: string): Promise<void>;
+/**
+ * Closes every call notification of this origin, rings and "Missed call" alike.
+ * For logout: whoever logs in next must not find the previous user's call
+ * notifications (their Answer / Decline would act on a call that is not theirs).
+ */
+export declare function closeAllCallNotifications(scope?: string): Promise<void>;
+/**
+ * The "Missed call" notification, the same one the service worker shows when
+ * it is the one that sees a ring end (same tag, same data), so whichever gets
+ * there first wins and the other leaves it alone. A hidden tab can reach the
+ * ring's end before the worker does, and the worker then finds nothing to swap;
+ * showing it from here as well makes the outcome independent of that order.
+ * `missedCallId` tells a repeat of the same call (skipped) from the next missed
+ * call in the room (replaces, and renotifies).
+ */
+export declare function showMissedCallNotification(call: {
+    key: string;
+    kind: 'audio' | 'video';
+    callerName?: string | null;
+    roomBareName?: string | null;
+}, opts?: {
+    icon?: string;
+    badge?: string;
+    scope?: string;
+    useServiceWorker?: boolean;
+    onClick?: () => void;
+}): Promise<void>;

package/dist/utils/firebasePushNotifications.d.ts

@@ -12,6 +12,8 @@ interface FcmRegistrationOptions {
     firebaseConfig?: any;
     iconPath?: string;
     badgePath?: string;
+    /** Same-origin path a cold-start push tap opens (default: the origin root). */
+    clickPath?: string;
     debug?: boolean;
 }
 /**
@@ -33,6 +35,18 @@ export declare function initPushNotifications(options?: FcmRegistrationOptions):
  * Returns an unsubscribe function.
  */
 export declare function listenForForegroundMessages(handler: (payload: MessagePayload) => void, firebaseConfig?: any): () => void;
+/**
+ * requestPendingPushClick()
+ * A push tapped while no window was open is kept by the service worker, because
+ * the new page is not listening yet when the tap happens. Once the page's
+ * `message` listener is attached it calls this: the worker answers with a
+ * `PUSH_NOTIFICATION_CLICK` message (same shape as a warm tap) and forgets it,
+ * or stays silent when nothing is pending. With `discard`, the worker only
+ * drops the pending click (the page already took it from the `fromPush` url).
+ */
+export declare function requestPendingPushClick(readyTimeoutMs?: number, { discard }?: {
+    discard?: boolean;
+}): Promise<boolean>;
 /**
  * disablePushNotifications()
  */

package/dist/utils/handledCalls.d.ts

@@ -0,0 +1,5 @@
+export declare const HANDLED_CALLS_TTL_MS: number;
+export declare const HANDLED_CALLS_STORAGE_KEY = "@ethora/chat-component:handledCalls";
+export declare const markCallHandled: (key: string | null | undefined, now?: number) => void;
+export declare const isCallHandled: (key: string | null | undefined, now?: number) => boolean;
+export declare const resetHandledCalls: () => void;

package/dist/utils/pushServiceWorkerBridge.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Posts a message to the push service worker. Uses the controlling worker when
+ * the page has one, otherwise waits (briefly) for the registration to become
+ * active, the same way requestPendingPushClick does for a freshly loaded page.
+ */
+export declare function postToPushServiceWorker(message: Record<string, unknown>, readyTimeoutMs?: number): Promise<boolean>;
+export declare const CALL_AUTH_CACHE = "ethora-push-auth-v1";
+export declare const callAuthKey: () => string;
+export declare function deleteMirroredCallAuth(): Promise<void>;
+export declare const PENDING_CLICK_CACHE = "ethora-push-pending-v1";
+export declare const pendingClickKey: () => string;
+/** Drops a tap the worker was holding for the next page load (logout). */
+export declare function deletePendingPushClick(): Promise<void>;
+/**
+ * Tells the worker whether this page can take an incoming call over (the call
+ * push listener is mounted with videoCalls enabled). The worker uses it to pick
+ * where an Answer or a tap on the call notification goes.
+ */
+export declare function announceCallClient(ready: boolean): void;

package/dist/utils/webLock.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Runs `task` while holding the lock `name`, so two contexts doing the same
+ * check-then-act (page and service worker showing one "Missed call") cannot
+ * interleave.
+ */
+export declare function withWebLock<T>(name: string, task: () => Promise<T> | T): Promise<T>;
+/**
+ * First caller wins. Resolves true for the context that gets the lock `name`
+ * (and keeps it for `holdMs`, long enough for the other tabs that received the
+ * same message to try and lose), false for everyone else. Without Web Locks it
+ * is `true` right away (a plain boolean, so the caller does not even yield).
+ */
+export declare function claimOnce(name: string, holdMs?: number): boolean | Promise<boolean>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethora/chat-component",
-  "version": "26.10.6",
+  "version": "26.10.8",
   "type": "module",
   "main": "dist/main.js",
   "types": "dist/main.d.ts",