@ethora/chat-component 26.6.1 → 26.6.3

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

@@ -1,8 +1,9 @@
 import { default as React } from 'react';
-import { IRoom } from '../../types/types';
+import { IConfig, IRoom } from '../../types/types';
 interface ChatHeaderProps {
     currentRoom: IRoom;
     handleBackClick?: (value: boolean) => void;
 }
+export declare const shouldShowLanguageSelector: (translatesConfig: IConfig["translates"] | undefined) => boolean;
 declare const ChatHeader: React.FC<ChatHeaderProps>;
 export default ChatHeader;

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

@@ -1,13 +1,3 @@
 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/MainComponents/Switch.d.ts

@@ -4,6 +4,14 @@ interface SwitchProps {
     bgColor?: string;
     onSwitchOn?: () => void;
     onSwitchOff?: () => void;
+    /**
+     * Reflects an existing value (e.g. redux state) instead of always
+     * starting from "off". Optional and defaults to undefined so every
+     * existing fire-and-forget caller keeps its original always-starts-off
+     * behaviour unchanged - only pass this when the switch represents a
+     * real, already-known boolean.
+     */
+    checked?: boolean;
 }
 declare const Switch: React.FC<SwitchProps>;
 export default Switch;

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

@@ -6,10 +6,14 @@ interface MessageTranslateProps {
     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.
+ * Manual-mode message translation (LinkedIn-style). Renders a "Translate"
+ * link under an incoming message; on click it calls
+ * `config.translates.onTranslate` (host-provided) - or, when the host
+ * doesn't supply one, reads whatever translation already arrived attached
+ * to the stanza (`message.translations`) - and shows the result inline
+ * with a "Show original" toggle. No default translation service is called
+ * here; a message with nothing attached and no host `onTranslate` simply
+ * has nothing to reveal (see `translation.failed`).
  *
  * Visibility: `config.translates.showTranslateForMessage(message)` if the host
  * supplies it (they keep the locale logic and just tell us yes/no); otherwise

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

@@ -5,10 +5,17 @@ interface TranslatedMessageBodyProps {
     accentColor?: string;
     /** Renders the translated text (markdown pipeline, mentions, etc). */
     children: ReactNode;
+    /**
+     * Whether this message was sent by the current user. The sender already
+     * knows what they wrote, so their own messages skip the quote-plus-
+     * translation treatment and just show the original text.
+     */
+    isUser: boolean;
 }
 /**
  * A message body that is showing a translation: the translated text reads
- * as the primary content, with the original quoted above it for reference.
+ * as the primary content, with the original quoted above it for reference
+ * - skipped for the current user's own messages (see `isUser`).
  */
 export declare const TranslatedMessageBody: React.FC<TranslatedMessageBodyProps>;
 export default TranslatedMessageBody;

package/dist/firebase-messaging-sw.js

@@ -384,9 +384,10 @@ async function handlePush(raw = {}, source = 'push') {
   });
 
   const visible = isVisibleClients(windowClients);
+  const hasAnyClient = windowClients.length > 0;
 
   if (DEBUG) log('clients:', dumpClients(windowClients));
-  log('visibleClientExists:', visible);
+  log('visibleClientExists:', visible, 'anyClientExists:', hasAnyClient);
 
   await broadcastDebugMessage({
     source,
@@ -445,9 +446,20 @@ async function handlePush(raw = {}, source = 'push') {
     },
   };
 
-  if (!visible) {
+  // Calls: a client that's merely backgrounded (open, just not the
+  // visible/focused tab) is NOT the "nobody will hear this ring" case -
+  // VideoCallOverlay already rings its own OS notification for exactly
+  // that state (see its comment: this SW push is meant to be the
+  // fully-offline fallback). `visible` collapses "backgrounded but open"
+  // and "fully closed" into the same false, which duplicated that
+  // client-side ring every time the tab was merely hidden. Suppress on
+  // ANY open client for calls; regular messages keep the visible-only
+  // check they already had.
+  const suppress = isCall ? hasAnyClient : visible;
+
+  if (!suppress) {
     log('SHOW NOTIFICATION', {
-      reason: 'NO_VISIBLE_CLIENT',
+      reason: isCall ? 'NO_CLIENT_AT_ALL' : 'NO_VISIBLE_CLIENT',
       tag: options.tag,
       isCall,
     });
@@ -456,7 +468,7 @@ async function handlePush(raw = {}, source = 'push') {
   }
 
   log('SKIP NOTIFICATION', {
-    reason: 'VISIBLE_CLIENT',
+    reason: isCall ? 'CLIENT_OPEN_WILL_RING_ITSELF' : 'VISIBLE_CLIENT',
   });
 }
 

package/dist/helpers/callLogMessage.d.ts

@@ -17,3 +17,17 @@ export declare const buildLocalCallLogMessage: (params: {
     kind: "audio" | "video";
     selfXmppUsername: string;
 }) => IMessage;
+/**
+ * The label for a call-log entry, built at RENDER time from the callLog
+ * meta rather than read off `message.body`.
+ *
+ * transformCallLogMessage bakes an English sentence into `body` the moment
+ * the stanza arrives, which freezes the language: switch to Chinese and
+ * every call log you already received stays English forever, because the
+ * text is data by then, not a rendering. The meta (direction/duration/
+ * missed) is the actual fact - the sentence is a view of it, so it belongs
+ * where the view is. `body` stays as the fallback for entries received
+ * before this existed, and for the notification/sidebar preview paths that
+ * only have the raw message.
+ */
+export declare const formatCallLogLabel: (callLog: CallLogMeta | undefined, t: (key: string, vars?: Record<string, string | number>) => string, fallbackBody?: string) => string;

package/dist/helpers/createUserNameFromSetUser.d.ts

@@ -1,2 +1,37 @@
-import { RoomMember } from '../types/types';
+import { IMessage, RoomMember } from '../types/types';
+/**
+ * Cache-only lookup. Returns the literal "Deleted User" as a MISS sentinel
+ * when `usersSet` has no entry for `userId` yet - callers that want a
+ * better fallback (e.g. resolveSenderDisplayName below) check for that
+ * exact string rather than treating it as a real name.
+ */
 export declare const createUserNameFromSetUser: (usersSet: Record<string, RoomMember>, userId: string) => string;
+/**
+ * The sender's display name, resolved WITHOUT depending on `usersSet`
+ * having already been hydrated.
+ *
+ * `usersSet` is populated by a separate fetch (member list / presence) that
+ * can still be in flight when a message arrives - most reliably right after
+ * reconnect, when a burst of catch-up messages can land before that fetch
+ * resolves. A cache-only lookup shows the literal "Deleted User" for every
+ * one of those messages, even though the sender is very much not deleted.
+ *
+ * The message itself already carries the sender's name on the wire: every
+ * client that sends through this SDK stamps `senderFirstName` /
+ * `senderLastName` / `fullName` onto the outgoing stanza's `<data>` element
+ * (see sendTextMessage.xmpp.ts / sendTextMessageWithTranslateTag.xmpp.ts),
+ * and createMessageFromXml spreads those onto the top-level message object.
+ * Preferring that over the cache removes the timing dependency entirely for
+ * the common case, and "Deleted User" becomes what it should have always
+ * been: a rare last resort, not "usersSet hasn't loaded yet".
+ *
+ * Mirrors roomsSlice.ts's enrichMessageAuthor, which does the same
+ * self-healing for the message list - this is that same resolution used
+ * where a live decision is needed once (e.g. a notification), rather than
+ * baked into a message object that re-resolves on every store update.
+ */
+export declare const resolveSenderDisplayName: (message: Pick<IMessage, "user"> & {
+    fullName?: string;
+    senderFirstName?: string;
+    senderLastName?: string;
+}, usersSet: Record<string, RoomMember>) => string;

package/dist/helpers/toBaseLanguage.d.ts

@@ -0,0 +1,8 @@
+import { Iso639_1Codes } from '../types/models/language.model';
+/**
+ * "fr-CA" -> "fr", "EN" -> "en". Region only matters for the translation
+ * service's dialect handling - everywhere else (matching a source language
+ * against a reader's, caching, `langSource`) only the base language is
+ * meaningful.
+ */
+export declare const toBaseLanguage: (locale?: string | null) => Iso639_1Codes;

package/dist/hooks/useChatSettingState.d.ts

@@ -6,4 +6,6 @@ export declare const useChatSettingState: () => {
     deleteModal: any;
     selectedUser: any;
     langSource: any;
+    translateSendEnabled: any;
+    translateMode: any;
 };

package/dist/hooks/useChatWrapperInit.d.ts

@@ -16,5 +16,6 @@ interface useChatWrapperInitResult {
     isConnectionLost: boolean;
 }
 export declare const resolveLegacyTranslatesLangSource: (translatesConfig?: IConfig["translates"]) => Iso639_1Codes | undefined;
+export declare const resolveExternalReaderLocaleLangSource: (readerLocale?: string) => Iso639_1Codes | undefined;
 declare const useChatWrapperInit: ({ roomJID, wasAutoSelected, config, }: useChatWrapperInitProps) => useChatWrapperInitResult;
 export default useChatWrapperInit;

package/dist/hooks/useMessageTranslation.d.ts

@@ -1,25 +1,28 @@
 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. */
+     * translation is available - 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.
+ * Pure and synchronous - no HTTP call. Every translation this client ever
+ * shows arrives over XMPP already: the sender tags outgoing messages with
+ * `<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.
  *
- * Server-attached translations (`message.translations`, from a
- * pre-translating sender or a legacy stanza) win and skip the request.
+ * 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
+ * absence of the underlying data (see the enable/disable-translates
+ * disclaimer in LanguageSelectorModal).
  */
 export declare const useMessageTranslation: (message: Pick<IMessage, "body" | "langSource" | "translations">, readerLocale?: string, enabled?: boolean) => MessageTranslationState;

package/dist/hooks/useSendMessage.d.ts

@@ -1,3 +1,4 @@
+export declare const shouldTagOutgoingTranslateSource: (translatesEnabled: boolean | undefined, translateSendEnabled: boolean | undefined) => boolean;
 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>;

package/dist/i18n/useT.d.ts

@@ -9,5 +9,25 @@
  * 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.
+ *
+ * When the host doesn't set `config.i18n.locale` explicitly, this falls
+ * back to `langSource` - the same reader-language state the in-chat globe
+ * picker (LanguageSelectorButton) and `config.translates.readerLocale`
+ * drive (see useChatWrapperInit's resolveExternalReaderLocaleLangSource).
+ * So picking a language in the chat changes both message translations AND
+ * static captions together, as one language switch, unless the host is
+ * explicitly managing UI locale separately via `config.i18n.locale`.
+ */
+/**
+ * The locale the UI is currently in, resolved by the same rule useT uses
+ * (explicit `config.i18n.locale`, else the reader's `langSource`).
+ *
+ * For anything Intl already localises - dates, numbers, relative times -
+ * where you need the locale itself rather than a string from the table.
+ * Without it components reach for a hardcoded 'en-US' and quietly render
+ * American dates under a Chinese UI (DateLabel did exactly that).
+ * Undefined means "no explicit choice", which Intl reads as the browser's
+ * own locale - the right default.
  */
+export declare const useUiLocale: () => string | undefined;
 export declare const useT: () => (key: string, vars?: Record<string, string | number>) => string;