@ethora/chat-component 26.10.6 → 26.10.7

package/dist/{handleCopyClick-Crn2jEEu.js → handleCopyClick-BUbVvd2G.js}

@@ -1,4 +1,4 @@
-import { E as e, G as t } from "./main-36gqdbJ8.js";
+import { U as e, X as t } from "./main-CpHMnydn.js";
 const i = e.div`
   display: flex;
   flex-direction: column;

package/dist/helpers/callClaim.d.ts

@@ -0,0 +1,17 @@
+/** Records that this tab took the decision for the call (see wonCallDecision). */
+export declare const rememberCallDecision: (key: string | null | undefined) => void;
+/** True when this tab took the accept or decline for `key` itself. */
+export declare const wonCallDecision: (key: string | null | undefined) => boolean;
+export declare const resetCallClaims: () => void;
+/**
+ * Takes the per-call claim for accepting or declining `key`. A plain boolean
+ * without Web Locks (nothing to yield for), otherwise a promise. Both actions
+ * share the one lock, so an Accept here and a Decline in another tab cannot
+ * both go through either.
+ */
+export declare const claimCallDecision: (key: string) => boolean | Promise<boolean>;
+/**
+ * Runs `run` when this tab gets the claim, and not at all when another tab
+ * has it. Synchronous when the claim is (no Web Locks).
+ */
+export declare const runIfCallClaimed: (key: string | null | undefined, run: () => void) => void;

package/dist/helpers/callOutcomeSync.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Marks the end of the ring `key` as local-only: the next time this tab's ring
+ * for it ends, nothing is broadcast. For a timeout, and for an end that came
+ * from another tab (no echo).
+ */
+export declare const silenceCallOutcome: (key: string | null | undefined) => void;
+type CallLike = {
+    direction: string | null;
+    phase: string;
+    callId: string | null;
+    roomJid: string | null;
+    roomBareName: string | null;
+};
+export declare const incomingCallKey: (call: CallLike) => string | null;
+interface StoreLike {
+    getState: () => {
+        call: CallLike;
+    };
+    subscribe: (listener: () => void) => () => void;
+    dispatch: (action: any) => unknown;
+}
+export declare function startCallOutcomeSync(store: StoreLike): () => void;
+export {};

package/dist/helpers/callPush.d.ts

@@ -20,3 +20,26 @@ export interface ParsedCallPush {
  */
 export declare const isCallPush: (data: Record<string, any> | null | undefined) => boolean;
 export declare const parseCallPush: (data: Record<string, any> | null | undefined) => ParsedCallPush;
+/**
+ * Decode the claims of a JWT without verifying it. Only non-sensitive claims
+ * are ever read from the result; the server (and LiveKit on connect) is the
+ * authority on validity. Returns null for anything that is not a JWT.
+ */
+export declare const decodeJwtPayload: (token: string | null | undefined) => Record<string, any> | null;
+/** Expiry of a JWT (`exp`, seconds) as epoch milliseconds, or null. */
+export declare const jwtExpiresAtMs: (token: string | null | undefined) => number | null;
+/** A call token with less than this left is treated as already expired. */
+export declare const CALL_TOKEN_MIN_REMAINING_MS = 3000;
+/**
+ * Whether a call push is still worth ringing for. The backend sets no push TTL,
+ * so a device that was offline can receive a call push long after the call.
+ * The LiveKit token lives 60 s, so its `exp` is the freshness clock.
+ *
+ * When no `exp` can be read (no token, malformed token) the push is treated
+ * as fresh: it cannot be proven stale, and the ring's own 45 s timeout bounds
+ * how long it can stay on screen.
+ */
+export declare const getCallPushFreshness: (data: Record<string, any> | null | undefined, now?: number) => {
+    fresh: boolean;
+    expiresAt: number | null;
+};

package/dist/helpers/incomingCallPush.d.ts

@@ -0,0 +1,89 @@
+export interface CallPushContext {
+    dispatch: (action: any) => unknown;
+    getState: () => any;
+    normalizeRoomJid: (jid?: string) => string;
+}
+export type CallPushOutcome = 
+/** The ring is on (or already was) for this call. */
+'ringing'
+/** Ringing and accepted in the same step (Answer action). */
+ | 'accepted'
+/** This call is already answered / in progress; nothing to do. */
+ | 'active'
+/** Another call is in progress; this one was ignored. */
+ | 'busy'
+/** The push is stale; nothing rings. */
+ | 'expired'
+/** Another tab already accepted, declined or ended this call; nothing to do. */
+ | 'handled'
+/** Held until the chat config and the user are ready. */
+ | 'held'
+/** The push carries no LiveKit token, so it cannot ring. */
+ | 'no-token';
+export declare const markCallRaisedFromPush: (key: string | null | undefined) => void;
+export declare const unmarkCallRaisedFromPush: (key: string | null | undefined) => void;
+export declare const wasCallRaisedFromPush: (key: string | null | undefined) => boolean;
+interface PendingCallPush {
+    data: Record<string, any>;
+    answer: boolean;
+    heldAt: number;
+    /** The worker is showing this call's notification (see raisedFromPush). */
+    swShows: boolean;
+}
+export declare const holdCallPush: (data: Record<string, any>, answer: boolean, swShows?: boolean) => void;
+export declare const takePendingCallPush: (now?: number) => PendingCallPush | null;
+export declare const dropPendingCallPush: (callId: string | null | undefined) => void;
+export declare const resetCallPushState: () => void;
+/**
+ * Everything the call push flow holds that belongs to the session: a call push
+ * held for the config, the pushed-ring marks, the decline dedupe, the click the
+ * worker keeps for the next page load, and the call notifications on screen.
+ * Logout (and an account switch) clears it, so the next user never replays or
+ * answers the previous one's call.
+ */
+export declare const clearCallPushSession: (scope?: string) => Promise<void>;
+/**
+ * Several tabs get the same tap or Answer from the worker. Only one may act on
+ * it: the first to take the lock for this call does, the rest leave it. This
+ * only routes the click. Whether THIS tab may then accept or decline the call
+ * is the per-call claim in callClaim (shared with the ring screen's buttons).
+ */
+export declare const claimCallAction: (action: "click", key: string) => boolean | Promise<boolean>;
+/**
+ * Puts the ring up from a call push (through the guarded reducer) and, for the
+ * Answer action, accepts it right away so LiveKit connects with the push's own
+ * token and no second click.
+ */
+export declare const raiseIncomingCallFromPush: (ctx: CallPushContext, data: Record<string, any>, options?: {
+    answer?: boolean;
+    swShows?: boolean;
+}) => CallPushOutcome;
+export declare const flushPendingCallPush: (ctx: CallPushContext) => CallPushOutcome | null;
+/**
+ * CALL_PUSH from the worker: ring (or hold) and tell the worker what this page
+ * did, so it knows whether to add an OS notification:
+ *  - ring shown and this page visible: ack, the worker shows nothing;
+ *  - this call is already connecting or in progress here: ack whether the page
+ *    is visible or not (a duplicate push must not ring again, nor end as a
+ *    "Missed call" for a call that was answered);
+ *  - a DIFFERENT call is in progress: ack with `busy`, the worker shows a plain
+ *    "Missed call" instead of a ring that Answer could not take;
+ *  - anything else (hidden page, held, expired, no token): no ack, the worker
+ *    notifies. The hidden or held ring is then the worker's to announce, so it
+ *    is marked and the page does not notify a second time.
+ */
+export declare const handleCallPushFromWorker: (ctx: CallPushContext, data: Record<string, any>) => CallPushOutcome;
+/**
+ * Declines a call from a notification action. Both mounted hook instances get
+ * the worker's message, so a repeat for the same call is dropped. A call this
+ * page has already answered is left alone: a stale Decline must never hang up
+ * a live call.
+ *
+ * Tells the worker (CALL_PUSH_DECLINE_ACK) once the decline was actually
+ * handled, and only then: the worker waits for it and otherwise declines over
+ * REST itself. A page that cannot do the XMPP part (the chat config is not in
+ * Redux yet) still has the user token, so it does the REST decline and acks
+ * when the server took it.
+ */
+export declare const declineIncomingCallFromPush: (ctx: CallPushContext, data: Record<string, any>) => Promise<void>;
+export {};

package/dist/helpers/pushRoomHandoff.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A push tap names the room the user wants. The address bar and the parked
+ * QR / deep-link id may still name another one: a host that redirects `/` to
+ * its saved last path lands the window on `/chat?chatId=<last room>`, and
+ * `useQRCodeChat` re-asserts that room for as long as it is parked, which
+ * used to undo the push a moment after it was applied.
+ *
+ * Call this right before opening the pushed room so every source of truth
+ * agrees: a `chatId` already in the url is rewritten to the pushed room (the
+ * way `useRoomUrl` writes it, without adding a history entry), and a parked
+ * id is dropped. A url with no `chatId` is left alone.
+ */
+export declare const claimRoomForPush: (roomJid: string) => void;

package/dist/hooks/useChatSettingState.d.ts

@@ -8,4 +8,5 @@ export declare const useChatSettingState: () => {
     langSource: any;
     translateSendEnabled: any;
     translateMode: any;
+    blockedUserIds: any;
 };

package/dist/hooks/usePushNotifications.d.ts

@@ -28,6 +28,8 @@ interface UsePushNotificationsOptions {
     iconPath?: string;
     /** Custom badge URL/path for browser OS notifications. */
     badgePath?: string;
+    /** Same-origin path a cold-start push tap opens (default: the origin root). */
+    clickPath?: string;
     /**
      * Custom Firebase configuration object.
      * If provided, it overrides the environment variables.