@ethora/chat-component 26.5.12 → 26.6.1

package/dist/assets/icons.d.ts

@@ -1,3 +1,7 @@
+export declare const GlobeIcon: ({ color, ...props }: {
+    [x: string]: any;
+    color?: string;
+}) => import("react/jsx-runtime").JSX.Element;
 export declare const AddNewIcon: ({ color, ...props }: {
     [x: string]: any;
     color?: string;

package/dist/components/MainComponents/LanguageSelectorModal.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+/**
+ * Globe-icon button for the chat header that opens a language picker modal.
+ * Picking a language dispatches `setLangSource`, which drives both:
+ *  - the reader's translation target (Message.tsx falls back to it when
+ *    `config.translates.readerLocale` / `config.i18n.locale` aren't set),
+ *  - the source language declared on the reader's own outgoing messages.
+ *
+ * `langSource` lives in `chatSettingStore`, which redux-persist already
+ * persists (see roomStore/index.ts) - no separate storage needed here.
+ */
+export declare const LanguageSelectorButton: React.FC;
+export default LanguageSelectorButton;

package/dist/components/MessageBubble/MessageTranslate.d.ts

@@ -0,0 +1,21 @@
+import { FC } from 'react';
+import { IConfig, IMessage } from '../../types/types';
+interface MessageTranslateProps {
+    message: IMessage;
+    isUser: boolean;
+    config?: IConfig;
+}
+/**
+ * On-demand message translation (LinkedIn-style). Renders a "Translate" link
+ * under an incoming message; on click it calls `config.translates.onTranslate`
+ * (host endpoint) - or falls back to a server-provided translation already on
+ * the message - and shows the result inline with a "Show original" toggle.
+ *
+ * Visibility: `config.translates.showTranslateForMessage(message)` if the host
+ * supplies it (they keep the locale logic and just tell us yes/no); otherwise
+ * we compare the message's source base-language with the reader's base-language
+ * (region ignored, so en-US vs en-CA shows nothing). The reader's FULL locale
+ * (fr-CA vs fr-FR) is still forwarded to `onTranslate` as `targetLocale`.
+ */
+declare const MessageTranslate: FC<MessageTranslateProps>;
+export default MessageTranslate;

package/dist/components/MessageBubble/TranslatedMessageBody.d.ts

@@ -0,0 +1,14 @@
+import { default as React, ReactNode } from 'react';
+interface TranslatedMessageBodyProps {
+    /** Text as sent, in the sender's language. */
+    originalText: string;
+    accentColor?: string;
+    /** Renders the translated text (markdown pipeline, mentions, etc). */
+    children: ReactNode;
+}
+/**
+ * A message body that is showing a translation: the translated text reads
+ * as the primary content, with the original quoted above it for reference.
+ */
+export declare const TranslatedMessageBody: React.FC<TranslatedMessageBodyProps>;
+export default TranslatedMessageBody;

package/dist/components/RoomComponents/ChatRoomItem.d.ts

@@ -7,5 +7,5 @@ interface ChatRoomItemProps {
     performClick: (chat: IRoom) => void;
     config: IConfig;
 }
-declare const ChatRoomItem: React.FC<ChatRoomItemProps>;
-export default ChatRoomItem;
+declare const _default: React.NamedExoticComponent<ChatRoomItemProps>;
+export default _default;

package/dist/components/RoomComponents/OnlineUsersPopover.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+import { RoomMember } from '../../types/types';
+interface OnlineUsersPopoverProps {
+    /** xmppUsernames currently online in this room (from useRoomPresence). */
+    onlineUsernames: string[];
+    members?: RoomMember[];
+    myXmppUsername: string;
+    isChatActive?: boolean;
+}
+declare const OnlineUsersPopover: React.FC<OnlineUsersPopoverProps>;
+export default OnlineUsersPopover;

package/dist/helpers/isLikelyMucJid.d.ts

@@ -0,0 +1 @@
+export declare const isLikelyMucJid: (jid: unknown) => jid is string;

package/dist/helpers/scheduleAckCatchup.d.ts

@@ -0,0 +1,27 @@
+import { default as XmppClient } from '../networking/xmppClient';
+/**
+ * How long to wait for the MUC to reflect our own message back before
+ * assuming it never will. A MUC echo normally lands in ~100-300ms - far
+ * faster than a MAM round trip could answer anyway - so this only has to
+ * be generous enough not to fire during a slow-but-healthy send.
+ */
+export declare const ACK_CATCHUP_DELAY_MS = 2500;
+/** The echo is what flips `pending` to false (see addRoomMessage). */
+export declare const hasEchoLanded: (roomJID: string, messageId: string) => boolean;
+/**
+ * Safety net for a send whose MUC echo never arrives (e.g. our presence
+ * silently dropped): re-assert presence and pull history - ONCE, and only
+ * if the echo really is missing.
+ *
+ * It must stay a safety net. This used to be a poll: an immediate fetch on
+ * every send plus a retry loop re-arming every 700ms for 5s until the echo
+ * landed. Every getHistoryStanza makes the server re-send the room's last
+ * 10-20 archived messages down the socket, so one send produced ~6 MAM
+ * replies (9 worst case) - the "I get my message back 4 times" seen in the
+ * WS frames. It was self-amplifying too: a slower echo fired more history
+ * storms, and each storm's stanzas fed the reducer/persist churn that was
+ * slowing the echo down in the first place.
+ *
+ * @returns the timer, so the caller can cancel it on unmount.
+ */
+export declare const scheduleAckCatchup: (client: XmppClient, roomJID: string, messageId: string, onSettled?: () => void) => ReturnType<typeof setTimeout>;

package/dist/helpers/storeConsole.d.ts

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

package/dist/hooks/useChatWrapperInit.d.ts

@@ -1,4 +1,4 @@
-import { IConfig } from '../types/types';
+import { IConfig, Iso639_1Codes } from '../types/types';
 import { default as XmppClient } from '../networking/xmppClient';
 interface useChatWrapperInitProps {
     roomJID: string | null | undefined;
@@ -15,5 +15,6 @@ interface useChatWrapperInitResult {
     setClient: React.Dispatch<React.SetStateAction<XmppClient | null>>;
     isConnectionLost: boolean;
 }
+export declare const resolveLegacyTranslatesLangSource: (translatesConfig?: IConfig["translates"]) => Iso639_1Codes | undefined;
 declare const useChatWrapperInit: ({ roomJID, wasAutoSelected, config, }: useChatWrapperInitProps) => useChatWrapperInitResult;
 export default useChatWrapperInit;

package/dist/hooks/useIsMobileViewport.d.ts

@@ -0,0 +1 @@
+export declare const useIsMobileViewport: (breakpoint?: number) => boolean;

package/dist/hooks/useMessageTranslation.d.ts

@@ -0,0 +1,25 @@
+import { IMessage } from '../types/types';
+export interface MessageTranslationState {
+    /** False when the message is already in the reader's language, or no
+     * translation is available (yet) - render the plain body, no quote. */
+    hasTranslation: boolean;
+    originalText: string;
+    /** Translation when hasTranslation, else the original - always safe to
+     * render directly. */
+    displayText: string;
+}
+/** Test-only: the cache is module state and would leak between cases. */
+export declare const resetMessageTranslationCacheForTests: () => void;
+/**
+ * Translation for ONE message, into the reader's language only.
+ *
+ * The sender doesn't pre-translate (that put an HTTP round trip in front of
+ * every send, translating into languages nobody may read). Instead each
+ * reader translates what they actually look at, into the one language they
+ * actually read - so cost scales with what's on screen, and the result is
+ * cached across renders/remounts.
+ *
+ * Server-attached translations (`message.translations`, from a
+ * pre-translating sender or a legacy stanza) win and skip the request.
+ */
+export declare const useMessageTranslation: (message: Pick<IMessage, "body" | "langSource" | "translations">, readerLocale?: string, enabled?: boolean) => MessageTranslationState;

package/dist/hooks/useRoomState.d.ts

@@ -1,7 +1,7 @@
 export declare const useRoomState: (roomJID?: string) => {
     room: any;
     roomsList: any;
-    activeRoomJID: any;
+    activeRoomJID: string;
     editAction: any;
     globalLoading: any;
     loadingText: any;

package/dist/i18n/strings.d.ts

@@ -0,0 +1,15 @@
+export type UiStringTable = Record<string, string>;
+export declare const BUILTIN_STRINGS: Record<string, UiStringTable>;
+export declare const DEFAULT_UI_LANGUAGE = "en";
+/** Reduce a BCP-47 locale ("fr-CA") to its base language ("fr"), lowercased. */
+export declare const toBaseLanguage: (locale?: string | null) => string;
+/**
+ * Build the effective string table for a locale: the built-in table for that
+ * base language (falling back to English for any missing key), with host
+ * overrides from `config.i18n.strings` merged on top.
+ */
+export declare const resolveStringTable: (locale?: string | null, overrides?: UiStringTable | null) => UiStringTable;
+/** Replace `{name}` placeholders with values from `vars`. */
+export declare const interpolate: (template: string, vars?: Record<string, string | number>) => string;
+/** One-shot translate for non-React code (helpers). */
+export declare const translateKey: (key: string, locale?: string | null, overrides?: UiStringTable | null, vars?: Record<string, string | number>) => string;

package/dist/i18n/useT.d.ts

@@ -0,0 +1,13 @@
+/**
+ * UI translation hook. Reads the active locale + host overrides from
+ * `config.i18n` and returns a `t(key, vars?)` function.
+ *
+ *   const t = useT();
+ *   <SearchInput placeholder={t('search.placeholder')} />
+ *   <span>{t('presence.onlineCount', { count })}</span>
+ *
+ * Locale resolves to the base language for captions (region is only used for
+ * message translation). Missing keys fall back to English, then to the raw
+ * key, so nothing ever renders blank.
+ */
+export declare const useT: () => (key: string, vars?: Record<string, string | number>) => string;