@ethora/chat-component 26.7.4 → 26.7.6

package/dist/hooks/useMentionComposer.d.ts

@@ -0,0 +1,45 @@
+import { IMentionSpan, RoomMember } from '../types/types';
+import { MentionCandidate } from '../helpers/mentions';
+export declare const MENTION_INLINE_LIMIT = 5;
+interface UseMentionComposerParams {
+    roomMembers: RoomMember[];
+    selfId?: string;
+}
+interface DropdownState {
+    start: number;
+    query: string;
+}
+/**
+ * Tracks @-mention spans and the inline autocomplete dropdown for a plain
+ * <input>/<textarea> based message composer (see SendInput.tsx). Text
+ * editing and caret placement stay owned by the caller (a controlled React
+ * input) - this hook only computes the *derived* state: which mention spans
+ * still hold after an edit, and what the dropdown should show.
+ */
+export declare const useMentionComposer: ({ roomMembers, selfId, }: UseMentionComposerParams) => {
+    mentionSpans: IMentionSpan[];
+    setMentionSpans: import('react').Dispatch<import('react').SetStateAction<IMentionSpan[]>>;
+    dropdown: DropdownState;
+    isDropdownOpen: boolean;
+    candidates: MentionCandidate[];
+    visibleCandidates: MentionCandidate[];
+    hasOverflow: boolean;
+    highlightedIndex: number;
+    setHighlightedIndex: import('react').Dispatch<import('react').SetStateAction<number>>;
+    moveHighlight: (delta: number) => void;
+    overflowOpen: boolean;
+    setOverflowOpen: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    resetMentions: () => void;
+    closeDropdown: () => void;
+    handleTextChange: (oldText: string, newText: string, caret: number) => void;
+    selectCandidate: (candidate: MentionCandidate, text: string, caretAtSelection: number) => {
+        text: string;
+        caret: number;
+    } | null;
+    handleBackspace: (text: string, selectionStart: number, selectionEnd: number) => {
+        text: string;
+        caret: number;
+    } | null;
+};
+export type UseMentionComposerReturn = ReturnType<typeof useMentionComposer>;
+export {};

package/dist/hooks/useMessageHeapState.d.ts

@@ -1,4 +1,4 @@
 export declare const useMessageHeapState: () => {
-    queue: import('../types/types').IMessage[];
+    queue: import('../main').IMessage[];
     idSet: Set<string>;
 };

package/dist/hooks/useMessageTranslation.d.ts

@@ -16,9 +16,10 @@ export interface MessageTranslationState {
  * `<translate source="xx"/>` (see sendTextMessageWithTranslateTag) and
  * whatever process attaches actual translations does so server-side,
  * landing on `message.translations` when the stanza is parsed (see
- * getDataFromXml). This function only ever reads that - it never calls a
- * translation service itself, so there's nothing to fail when one isn't
- * reachable, and nothing to await.
+ * getDataFromXml). This hook is a thin wrapper around
+ * `resolveMessageTranslation` (the shared lookup manual mode also uses) - it
+ * never calls a translation service itself, so there's nothing to fail when
+ * one isn't reachable, and nothing to await.
  *
  * A message sent before the sender had translate-sending turned on simply
  * never got tagged, so it has no translation to show - not an error, just

package/dist/hooks/useModalDismiss.d.ts

@@ -0,0 +1,27 @@
+type DismissLayerKind = 'modal' | 'menu';
+export declare const FOCUSABLE_SELECTOR = "a[href], button:not([disabled]), input:not([disabled]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex=\"-1\"])";
+export interface UseModalDismissOptions {
+    onClose?: () => void;
+    enabled?: boolean;
+    /** Ref to the dialog/menu container; used for initial focus. */
+    containerRef?: React.RefObject<HTMLElement | null>;
+    /**
+     * 'modal' (default) stacks; 'menu' is exclusive, see the note above.
+     */
+    kind?: DismissLayerKind;
+    /**
+     * Close when a press lands outside the layer. Off by default: modals own
+     * a full-screen overlay that already handles this.
+     */
+    closeOnOutsidePress?: boolean;
+    /**
+     * Extra elements counted as "inside" for outside-press dismissal, on top
+     * of `containerRef`. A menu passes its trigger here: the trigger's own
+     * click is the toggle's business, and letting the document listener close
+     * the menu first would make the trigger look like it never closes (the
+     * toggle would immediately re-open what the listener just shut).
+     */
+    insideRefs?: React.RefObject<HTMLElement | null>[];
+}
+export declare const useModalDismiss: ({ onClose, enabled, containerRef, kind, closeOnOutsidePress, insideRefs, }: UseModalDismissOptions) => void;
+export default useModalDismiss;

package/dist/hooks/useMyFiles.d.ts

@@ -0,0 +1,16 @@
+import { ApiFile } from '../types/types';
+export interface UseMyFilesOptions {
+    roomName?: string;
+}
+export interface UseMyFilesResult {
+    items: ApiFile[];
+    total: number;
+    loading: boolean;
+    loadingMore: boolean;
+    error: string | null;
+    hasMore: boolean;
+    loadMore: () => void;
+    refresh: () => void;
+    remove: (id: string) => Promise<void>;
+}
+export declare function useMyFiles(options?: UseMyFilesOptions): UseMyFilesResult;

package/dist/hooks/usePdfThumbnail.d.ts

@@ -0,0 +1,22 @@
+export type PdfThumbnailStatus = 'idle' | 'loading' | 'ready' | 'error' | 'skipped';
+interface UsePdfThumbnailParams {
+    url?: string;
+    /** Gate: keep false until the bubble is on screen. */
+    enabled: boolean;
+    /** CSS pixels of the rendered bitmap's long edge. */
+    width?: number;
+    /** Files above this never auto-render; the card stays static. */
+    maxBytes?: number;
+    sizeInBytes?: number;
+    workerSrc?: string;
+}
+interface UsePdfThumbnailResult {
+    status: PdfThumbnailStatus;
+    /** Object URL - owned by this hook, revoked on unmount/url change. */
+    thumbnailUrl?: string;
+    pageCount?: number;
+    /** Re-runs a render that failed or was skipped for being too big. */
+    retry: () => void;
+}
+export declare const usePdfThumbnail: ({ url, enabled, width, maxBytes, sizeInBytes, workerSrc, }: UsePdfThumbnailParams) => UsePdfThumbnailResult;
+export {};

package/dist/hooks/useRoomMute.d.ts

@@ -0,0 +1,19 @@
+export interface UseRoomMuteResult {
+    /** Current muted state for this room. `false` whenever the backend hasn't reported the field - see `isSupported`. */
+    muted: boolean;
+    /**
+     * True only once this room has an actual `muted` boolean - either fetched
+     * from a backend that supports per-chat mute (`/v1/chats/my` or
+     * `/v1/chats/my/{chatName}`), or because this client already toggled it
+     * successfully. Prod doesn't send `muted` yet, so UI should hide the mute
+     * control unless this is true - otherwise it offers a toggle that 404s.
+     */
+    isSupported: boolean;
+    /** True while a toggle request is in flight. Disable the control to avoid a double submit. */
+    isPending: boolean;
+    /** Flips the current muted state - optimistic, with rollback + an error toast on failure. */
+    toggleMute: () => Promise<void>;
+    /** Sets the muted state directly - for controls with an explicit on/off state (e.g. a switch). */
+    setMuted: (nextMuted: boolean) => Promise<void>;
+}
+export declare const useRoomMute: (roomJid: string | undefined) => UseRoomMuteResult;

package/dist/hooks/useRoomState.d.ts

@@ -7,5 +7,5 @@ export declare const useRoomState: (roomJID?: string) => {
     loadingText: any;
     loading: any;
     roomMessages: any;
-    usersSet: any;
 };
+export declare const useUsersSet: () => any;

package/dist/hooks/useSendMessage.d.ts

@@ -1,7 +1,8 @@
-export declare const shouldTagOutgoingTranslateSource: (translatesEnabled: boolean | undefined, translateSendEnabled: boolean | undefined) => boolean;
+import { IMentionSpan } from '../types/types';
+export { shouldTagOutgoingTranslateSource } from '../utils/translateModePolicy';
 export declare const useSendMessage: () => {
-    sendMessage: (message: string, activeRoomJID: string, isReply?: boolean, isChecked?: boolean, mainMessage?: string) => Promise<void>;
-    sendMedia: (data: File, type: string, activeRoomJID: string, isReply?: boolean, isChecked?: boolean, mainMessage?: string) => Promise<void>;
+    sendMessage: (message: string, activeRoomJID: string, isReply?: boolean, isChecked?: boolean, mainMessage?: string, mentions?: IMentionSpan[]) => Promise<void>;
+    sendMedia: (data: File | File[] | Blob, type: string, activeRoomJID: string, isReply?: boolean, isChecked?: boolean, mainMessage?: string) => Promise<void>;
     sendEditMessage: (message: string) => Promise<void>;
     isLastMessageFromUserAndProcessing: (roomJID: string) => boolean;
 };

package/dist/hooks/useTypography.d.ts

@@ -2,7 +2,7 @@ import { TypographyConfig } from '../types/models/config.model';
 /**
  * Loads and applies the host-provided font configuration whenever it changes.
  * 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
+ * UI paints. No-op when `typography` is undefined - the default system font
  * stack is kept, so existing integrations are unaffected.
  */
 export declare function useTypography(typography?: TypographyConfig): void;

package/dist/hooks/useUnreadMessagesCounter.d.ts

@@ -5,8 +5,17 @@ interface UnreadMessagesDisplayMap {
     [roomJid: string]: string;
 }
 interface UnreadMessagesStats {
+    /** True when `totalCount > 0` - already excludes muted rooms, see `totalCount`. */
     hasUnread: boolean;
+    /**
+     * Sum of unread counts across visible rooms, EXCLUDING any room the caller
+     * has muted (a muted room still counts its own unread - see
+     * `unreadByRoom` - it just doesn't inflate this aggregate, so a global
+     * unread badge/favicon built from this number doesn't light up for a
+     * muted chat).
+     */
     totalCount: number;
+    /** Per-room unread counts, including muted rooms - the room-list badge always shows its own count regardless of mute. */
     unreadByRoom: UnreadMessagesMap;
     displayTotal: string;
     displayByRoom: UnreadMessagesDisplayMap;
@@ -16,10 +25,10 @@ interface UnreadMessagesStats {
      * hook keeps `loading` true until the per-room counts have stopped changing
      * for a short window, then latches it to false. After that first settle,
      * live message increments update the counts immediately and never flip
-     * `loading` back on — it's a first-load indicator, not a per-update one.
+     * `loading` back on, it's a first-load indicator, not a per-update one.
      */
     loading: boolean;
-    /** Alias of `loading` — matches the React Native SDK field name. */
+    /** Alias of `loading`, matches the React Native SDK field name. */
     isLoading: boolean;
 }
 export declare const useUnreadMessagesCounter: () => UnreadMessagesStats;

package/dist/index.esm-B-3fyDHY.js

@@ -0,0 +1,28 @@
+import { B as p, D as o, r as e } from "./index.esm2017-CL0mvq6y.js";
+import { F as n, S as _, G as v, H as m, I as A, J as g, K as d, M as S, a as b, N as l, e as E, _ as F, O as c, P as C, Q as L, b as N, R as O, T as f, U as D } from "./index.esm2017-CL0mvq6y.js";
+var s = "firebase", a = "11.9.1";
+e(s, a, "app");
+export {
+  n as FirebaseError,
+  _ as SDK_VERSION,
+  v as _DEFAULT_ENTRY_NAME,
+  m as _addComponent,
+  A as _addOrOverwriteComponent,
+  g as _apps,
+  d as _clearComponents,
+  S as _components,
+  b as _getProvider,
+  l as _isFirebaseApp,
+  E as _isFirebaseServerApp,
+  F as _registerComponent,
+  c as _removeServiceInstance,
+  C as _serverApps,
+  L as deleteApp,
+  N as getApp,
+  o as getApps,
+  p as initializeApp,
+  O as initializeServerApp,
+  f as onLog,
+  e as registerVersion,
+  D as setLogLevel
+};