@ethora/chat-component 26.10.6 → 26.10.8

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

@@ -1,4 +1,4 @@
-import { E as e, G as t } from "./main-36gqdbJ8.js";
+import { a4 as e, a6 as t } from "./main-B25iFKAC.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

@@ -11,6 +11,8 @@ export interface ParsedCallPush {
     callerName: string | null;
     /** Caller's xmpp localpart, when provided. */
     callerXmppUsername: string | null;
+    /** The call is for a group room (always LiveKit). */
+    isGroup: boolean;
 }
 /**
  * True when a push `data` payload represents an incoming call. Matches on an
@@ -20,3 +22,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/canLeaveRoom.d.ts

@@ -0,0 +1,3 @@
+import { ConfigRoom } from '../types/models/room.model';
+/** Ordinary rooms are leaveable; configured app rooms require an explicit opt-in. */
+export declare const canLeaveRoom: (jid: string | undefined, defaultRooms: ConfigRoom[] | undefined) => boolean;

package/dist/helpers/chatComponentConfigEvents.d.ts

@@ -0,0 +1,16 @@
+/**
+ * In-process bus for the `chat-component-config-updated` server event, so the
+ * XMPP stanza handler (networking/ethoraEvents.ts) and whoever acts on it
+ * (`config.remoteAppearance`, see hooks/useRemoteAppearance.ts) do not import
+ * each other.
+ */
+export interface ChatComponentConfigUpdatedEvent {
+    appId: string;
+    /** Opaque state id from the server, pass it to the config endpoint as `v`. */
+    version: string;
+}
+type Listener = (event: ChatComponentConfigUpdatedEvent) => void;
+export declare const subscribeChatComponentConfigUpdated: (listener: Listener) => (() => void);
+export declare const publishChatComponentConfigUpdated: (event: ChatComponentConfigUpdatedEvent) => void;
+export declare const resetChatComponentConfigListeners: () => void;
+export {};

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/liveConfig.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Which `config` keys the chat applies LIVE, and how an operator-saved record
+ * is laid over the host's config.
+ *
+ * Live means: changing the key on a mounted chat re-renders the affected
+ * pieces from the store and the CSS variables, with the XMPP connection, the
+ * rooms, the messages and every draft left alone. The list is exactly the
+ * visual and layout switches; everything else (identity, endpoints, login,
+ * history, e2ee, receipts, ...) is read when the chat starts and a new value
+ * is picked up by the next mount.
+ *
+ * The keys below also form the allowlist for `config.remoteAppearance`: a
+ * record fetched from the server can set these keys and no others, each with
+ * a strict validator, because the record comes over the network and ends up
+ * in CSS variables and a stylesheet.
+ */
+type Parse = (value: unknown) => string | boolean | number | null;
+/** Live keys and their validators. Mirrors ethora-backend modules/apps/chatComponentConfig.js. */
+export declare const LIVE_CONFIG_KEYS: Readonly<Record<string, Parse>>;
+export declare const isLiveConfigPath: (path: string) => boolean;
+/** Flattens to dotted leaf paths. Functions, nodes and class instances are leaves compared by identity. */
+export declare const flattenConfig: (input: unknown, out?: Map<string, unknown>, prefix?: string, depth?: number) => Map<string, unknown>;
+export interface ConfigChange {
+    /** Changed paths the chat applies live. */
+    live: string[];
+    /** Changed paths read when the chat starts: applied by the next mount. */
+    restart: string[];
+}
+/**
+ * Splits what differs between two host configs into live and start-time
+ * paths. A function that is a new closure on every render counts as changed
+ * (it is compared by identity) and lands in `restart`; that only affects the
+ * log line, the chat applies the whole new config either way.
+ */
+export declare function classifyConfigChange(prev: unknown, next: unknown): ConfigChange;
+export type RemoteConfigRecord = Record<string, string | boolean | number>;
+/**
+ * Keeps only allowlisted keys with a valid value. Anything else (an unknown
+ * key, a wrong type, markup, a URL, an out of range number) is dropped, so a
+ * wrong or hostile answer cannot do more than restyle the chat within the
+ * validators' limits.
+ */
+export declare function parseRemoteConfigRecord(raw: unknown): RemoteConfigRecord;
+/** The config with the record laid over it, copying only the objects on the way. Siblings stay. */
+export declare function applyRemoteConfigRecord<T extends object | undefined>(base: T, record: RemoteConfigRecord | null | undefined): T;
+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/helpers/reportRoom.d.ts

@@ -0,0 +1,18 @@
+import { PostReportRoom } from '../types/models/room.model';
+export interface ReportCategory {
+    id: string;
+    labelKey: string;
+    apiCategory: string;
+    /** English name, used in `text` (the report e-mail is not localized). */
+    name: string;
+}
+export declare const REPORT_CATEGORIES: ReportCategory[];
+export declare const OTHER_REPORT_CATEGORY: ReportCategory;
+export declare const findReportCategory: (id: string) => ReportCategory | undefined;
+/**
+ * The request body for a room report. `roomJid` may be the full room JID or
+ * the bare room name: the route takes the bare name (JID localpart), like
+ * every other /v1/chats/... route. Returns null for an unknown category or
+ * an empty room.
+ */
+export declare const buildReportRoomPayload: (roomJid: string, categoryId: string, details?: string) => PostReportRoom | null;

package/dist/helpers/scheduledCallMessage.d.ts

@@ -0,0 +1,23 @@
+import { IMessage } from '../types/types';
+import { ScheduledCallMeta } from '../types/models/scheduledCall.model';
+export declare const SCHEDULED_CALL_MESSAGE_TYPE = "scheduledCall";
+/**
+ * Reads the scheduled-call fields off a message. Null when the message is not
+ * one, or when it lacks what a card cannot do without (a valid slug and a
+ * parseable start); such a message falls back to its plain body.
+ *
+ * `apiBaseUrl` is the API the chat talks to, used to vet the .ics link.
+ */
+export declare const parseScheduledCallMeta: (message: unknown, apiBaseUrl?: string | null) => ScheduledCallMeta | null;
+/**
+ * createMessageFromXml hook: attaches `scheduledCall` meta to a message that
+ * is one. Everything else comes back untouched (same object).
+ */
+export declare const attachScheduledCallMeta: (message: IMessage, apiBaseUrl?: string | null) => IMessage;
+/**
+ * One card per slug: of all messages that announce the same scheduled call
+ * only the newest stays, so an `updated` or `cancelled` message replaces the
+ * card instead of stacking under it. Order of everything else is kept, and the
+ * input is returned as is when no call is announced twice.
+ */
+export declare const collapseScheduledCallMessages: (messages: IMessage[]) => IMessage[];

package/dist/helpers/storeConsole.d.ts

@@ -3,4 +3,5 @@ export declare const useStoreConsole: () => {
     rooms: Record<string, any> & import('redux-persist/es/persistReducer').PersistPartial;
     roomHeapSlice: import('../roomStore/roomHeapSlice').roomHeapSliceState;
     call: import('immer').WritableDraft<import('../roomStore/callSlice').CallState>;
+    scheduledCall: import('immer').WritableDraft<import('../roomStore/scheduledCallSlice').ScheduledCallState>;
 };

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/useNow.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `Date.now()` that re-renders its component every `intervalMs` while
+ * `enabled`. For things that change with the clock (a Join button that opens
+ * 15 minutes before the start) without each caller owning a timer.
+ */
+export declare const useNow: (intervalMs: number, enabled?: boolean) => number;

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.

package/dist/hooks/useRemoteAppearance.d.ts

@@ -0,0 +1,21 @@
+import { IConfig } from '../types/types';
+import { RemoteConfigRecord } from '../helpers/liveConfig';
+export declare const DEFAULT_REMOTE_APPEARANCE_WAIT_MS = 2500;
+export interface RemoteAppearanceState {
+    /** The record to lay over the host config; null until the first read settles. */
+    record: RemoteConfigRecord | null;
+    /** True while the chat should hold its first paint for the first read. */
+    waiting: boolean;
+}
+/**
+ * `config.remoteAppearance`: reads the App's chat component config from the
+ * server and keeps it current. Reads once on mount (the chat waits for it, at
+ * most `initialWaitMs`, so it starts once with its final look), then again
+ * every time the server announces a new version with a
+ * `chat-component-config-updated` event. The newest read wins, a failed read
+ * keeps what is shown, and a version that is already shown is not fetched
+ * again.
+ *
+ * Does nothing (and never waits) when the host did not opt in.
+ */
+export declare function useRemoteAppearance(config?: IConfig): RemoteAppearanceState;

package/dist/hooks/useTypography.d.ts

@@ -4,5 +4,9 @@ import { TypographyConfig } from '../types/models/config.model';
  * Wired into the chat root (ReduxWrapper) so the font is in place before the
  * UI paints. No-op when `typography` is undefined - the default system font
  * stack is kept, so existing integrations are unaffected.
+ *
+ * When `typography` goes away on a mounted chat (the operator cleared the
+ * font in the admin tab), what this hook applied is removed again and the
+ * default stack is back, with no reload.
  */
 export declare function useTypography(typography?: TypographyConfig): void;