@ethora/chat-component 26.7.6 → 26.7.7

package/dist/components/Modals/ModalBox/ModalBox.d.ts

@@ -3,6 +3,15 @@ interface ModalBoxProps {
     title: string;
     handleCloseModal: () => void;
     children: ReactNode;
+    /**
+     * True while the caller is keeping this mounted only to let the exit
+     * animation finish (see `useExitTransition` at the call site - typically
+     * `{shouldRender && <ModalBox isClosing={isExiting} .../>}`). Every close
+     * trigger here (X button, Escape, outside click) still just calls
+     * `handleCloseModal` immediately: the caller decides how long to keep
+     * rendering, this component only decides how it looks while that happens.
+     */
+    isClosing?: boolean;
 }
 export declare const ModalBox: FC<ModalBoxProps>;
 export {};

package/dist/components/Modals/ModalReportChat/ModalReportChat.d.ts

@@ -1,3 +1,8 @@
 import { default as React, FC } from 'react';
 export declare const Report: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, never>> & string;
-export declare const ModalReportChat: FC;
+interface ModalReportChatProps {
+    /** Forwarded to `ModalBox` - see its `isClosing` doc. */
+    isClosing?: boolean;
+}
+export declare const ModalReportChat: FC<ModalReportChatProps>;
+export {};

package/dist/components/Modals/ModalWrapper/ModalWrapper.d.ts

@@ -11,6 +11,14 @@ interface ModalWrapperProps {
     setTextarea?: (value: string) => void;
     handleCloseModal: () => void;
     handleClick: () => void;
+    /**
+     * True while the caller is keeping this mounted only so the exit
+     * animation can finish - see `ModalBox`'s `isClosing` doc for the pattern
+     * (a `useExitTransition` at the `{shouldRender && <ModalWrapper .../>}`
+     * call site). Buttons here still call `handleCloseModal`/`handleClick`
+     * immediately either way.
+     */
+    isClosing?: boolean;
 }
 export declare const ModalWrapper: FC<ModalWrapperProps>;
 export {};

package/dist/components/Modals/SettingsModals/SharedStyledComponents.d.ts

@@ -11,11 +11,23 @@ export declare const RowWrapper: import('styled-components/dist/types').IStyledC
 export declare const SharedSettingsLabelData: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<Omit<import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>, "ref"> & {
     ref?: import('react').Ref<HTMLSpanElement>;
 }, never>> & string;
+/**
+ * A settings action rendered as its own outlined row rather than an inline
+ * link, so "download my data" / "delete my account" read as deliberate,
+ * separately-weighted decisions - not just more text in the card. The
+ * border colour is caller-driven (primary for a normal action, the danger
+ * token for the destructive one), everything else - radius, padding,
+ * weight, the hover/focus feedback - comes from the shared tokens so both
+ * read as the same kind of control.
+ */
 export declare const SharedSettingsStyledButton: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<Omit<ButtonProps & import('react').RefAttributes<HTMLButtonElement>, "ref"> & {
     ref?: import('react').Ref<HTMLButtonElement>;
 }, {
     borderColor: string;
 }>> & string & Omit<import('react').ForwardRefExoticComponent<ButtonProps & import('react').RefAttributes<HTMLButtonElement>>, keyof import('react').Component<any, {}, any>>;
+/** A quiet, boxed disclosure - the read-only counterpart to the button
+ * above, so a fact ("your data may be retained on-chain") doesn't compete
+ * visually with an action the person can take. */
 export declare const SharedSettingsInfoPanel: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
     bgColor: string;
 }>> & string;

package/dist/components/Modals/SideDrawer/DrawerProfileParts.d.ts

@@ -7,7 +7,36 @@
  * the same shape.
  */
 export declare const ProfileHero: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+/**
+ * The one bold, largest line in the entire panel family: deliberately so.
+ * Everything else in these drawers tops out at semibold (section labels,
+ * header title, row labels), so this is the only place `font-weight-bold`
+ * is used - it is what makes the hero read as the peak of the hierarchy
+ * instead of just another slightly-bigger label.
+ */
 export declare const ProfileHeroName: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
 export declare const ProfileHeroSubtitle: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
 /** Stack of full-width action buttons, one per row. */
 export declare const ProfileActions: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+/**
+ * Room/profile description, set directly under the hero with no "Description"
+ * label above it - the About section heading already says what this is.
+ * When there is no description yet, `$empty` swaps in a muted italic tone so
+ * the placeholder line reads as an unwritten blank rather than a failed
+ * value, without changing the copy or the layout.
+ */
+export declare const DrawerDescriptionText: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, {
+    $empty?: boolean;
+}>> & string;
+/** Small icon+label tag for a single fact (chat type, visibility, ...). */
+export declare const DrawerFactPill: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>> & string;
+/**
+ * A deliberate blank state - icon, title, optional hint - for "nothing here
+ * yet" spots (no files, no members) that used to be a single line of grey
+ * text sitting in a box and reading like something had gone wrong.
+ */
+export declare const DrawerEmptyState: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+    $compact?: boolean;
+}>> & string;
+export declare const DrawerEmptyStateTitle: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const DrawerEmptyStateHint: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;

package/dist/components/Modals/SideDrawer/SideDrawer.d.ts

@@ -1,5 +1,7 @@
 import { FC, ReactNode } from 'react';
-export declare const DrawerPanel: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const DrawerPanel: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+    $closing?: boolean;
+}>> & string;
 /** A labelled group: small caps heading, then a bordered card of rows. */
 export declare const DrawerSection: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLElement>, HTMLElement>, never>> & string;
 export declare const DrawerSectionTitle: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, never>> & string;
@@ -17,6 +19,24 @@ export declare const SectionHeaderRow: import('styled-components/dist/types').IS
 export declare const ShowMoreButton: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, never>> & string;
 /** Hairline between two rows of the same card. */
 export declare const DrawerRowDivider: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+/**
+ * Filled, borderless search field - matches the room list's and the Files
+ * tab's own search bars (bg-subtle fill, no border) rather than the boxed,
+ * bordered field the member search used to be, which sat inside a bordered
+ * `DrawerCard` and read as a box nested in another box. Not built on the
+ * shared `InputComponents/Search` component: that one adds its own visible
+ * border and isn't in this pass's file list, so this is a local, purpose-fit
+ * equivalent that shares the same visual language as the other search bars
+ * in the app.
+ */
+export declare const DrawerSearchBar: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const DrawerSearchInput: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, never>> & string;
+/**
+ * Flat row list with no surrounding card border - used where the rows
+ * themselves (via hover/press state) already read as one group, e.g. the
+ * member list, so it doesn't also need a bounding box drawn around it.
+ */
+export declare const DrawerList: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
 export declare const DrawerLabel: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
 export declare const DrawerHint: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
 interface DrawerNavRowProps {

package/dist/components/Modals/SidePanel/SidePanel.d.ts

@@ -0,0 +1,31 @@
+import { default as React } from 'react';
+import { ModalType } from '../../../types/types';
+/**
+ * The chat's third column: chat profile, user profile, settings, Manage Data
+ * and Visibility.
+ *
+ * These used to be children of the modal overlay layer - a fixed,
+ * full-viewport `ModalBackground` with the panel parked against its right
+ * edge - so opening one dropped a 400px panel ON TOP of the conversation and
+ * the message you were reading disappeared underneath it. This component is
+ * rendered as a sibling of the chat pane inside `ChatWrapper`'s flex row
+ * instead, so the panel occupies real layout space and the chat simply gets
+ * narrower, the way Telegram Web behaves.
+ *
+ * Which panel is open is still the store's `activeModal` and is still routed
+ * through `MODAL_COMPONENTS`; `ModalContent` is the shared router both this
+ * and `Modal` use, so there is exactly one source of truth.
+ *
+ * Below the mobile breakpoint the column goes back to covering everything:
+ * three columns cannot fit on a phone, and the panel being the whole screen
+ * is the behaviour that was already there. `ChatWrapperInnerBox` is
+ * positioned, so `inset: 0` here is the chat's own box, not the host page.
+ */
+export declare const SIDE_PANEL_WIDTH_PX = 400;
+export declare const SIDE_PANEL_BREAKPOINT_PX = 767;
+interface SidePanelProps {
+    modal?: string;
+    setOpenModal: (value?: ModalType) => any;
+}
+declare const SidePanel: React.FC<SidePanelProps>;
+export default SidePanel;

package/dist/components/Modals/UserProfileModal/EditUserModal.d.ts

@@ -4,5 +4,9 @@ interface EditUserModalProps {
     modalUser: any;
     config: any;
 }
-declare const EditUserModal: React.FC<EditUserModalProps>;
+/** What the parent drawer's header Save button calls. */
+export interface EditUserModalHandle {
+    save: () => Promise<void>;
+}
+declare const EditUserModal: React.ForwardRefExoticComponent<EditUserModalProps & React.RefAttributes<EditUserModalHandle>>;
 export default EditUserModal;

package/dist/components/Modals/motionVariants.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Exit-animation variants of the shared modal primitives from
+ * `styledModalComponents.tsx` (owned by another agent right now - see
+ * CLAUDE.md coordination notes, not edited here). `styled(Component)`
+ * composition lets these add a `$closing` branch without touching that
+ * file: styled-components injects the extending component's class after the
+ * base one, so its rules win the cascade for the same element.
+ *
+ * Used by `Modal.tsx`, `NewChatModal.tsx` and `ModalWrapper.tsx` to fade/
+ * scale a modal out instead of letting it vanish when it unmounts.
+ */
+/**
+ * `$closing` fades the scrim back out.
+ *
+ * This used to skip the fade in the backdrop's old `$drawer` mode, where the
+ * scrim was transparent and had nothing to fade. That mode is gone: the
+ * profile and settings panels are a layout column now (see SidePanel), so the
+ * only things left behind this backdrop are real centred dialogs, and they all
+ * want the fade.
+ */
+export declare const PresenceModalBackground: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<Omit<import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "$anchorTop"> & {
+    $anchorTop?: boolean;
+}, "ref"> & {
+    ref?: import('react').Ref<HTMLDivElement>;
+}, {
+    $closing?: boolean;
+}>> & string;
+export declare const PresenceModalContainer: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: import('react').Ref<HTMLDivElement>;
+}>, never>, never>, {
+    $closing?: boolean;
+}>> & string;
+export declare const PresenceModalContainerFullScreen: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: import('react').Ref<HTMLDivElement>;
+}>, never>, never>, {
+    $closing?: boolean;
+}>> & string;

package/dist/components/Modals/styledModalComponents.d.ts

@@ -1,7 +1,6 @@
 import { ButtonProps } from '../styled/Button';
 export declare const ModalBackground: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
     $anchorTop?: boolean;
-    $drawer?: boolean;
 }>> & string;
 export declare const CloseButton: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, never>> & string;
 export declare const ModalContainer: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {

package/dist/context/ModalTransitionContext.d.ts

@@ -0,0 +1,2 @@
+export declare const ModalExitingProvider: import('react').Provider<boolean>;
+export declare const useIsModalExiting: () => boolean;

package/dist/handleCopyClick-BoZWTBLC.js

@@ -0,0 +1,108 @@
+import { v as e, x as t } from "./main-C2FKeV6y.js";
+const i = e.div`
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: var(--ethora-space-4, 16px);
+  padding: var(--ethora-space-3, 12px) 0 var(--ethora-space-2, 8px);
+  text-align: center;
+
+  /*
+   * The avatar (ProfileImagePlaceholder) is always this block's first and
+   * only non-text child - both callers (ChatProfileModal, UserProfileModal)
+   * render it first, before the name. A soft ring around it - the panel's
+   * own background colour, then the same elevation a card gets - lifts it
+   * off the page as the one deliberately-composed focal point instead of a
+   * flat circle sitting in a vertical stack. Targeting the position (not a
+   * class) means this works without touching ProfileImagePlaceholder itself,
+   * which is outside this pass's file list.
+   */
+  & > *:first-child {
+    box-shadow:
+      0 0 0 4px var(--ethora-color-bg, #fff),
+      var(--ethora-shadow-md, 0 4px 12px rgba(16, 24, 40, 0.1));
+    border-radius: var(--ethora-radius-full, 999px);
+  }
+`, s = e.div`
+  font-size: var(--ethora-font-size-xl, 22px);
+  font-weight: var(--ethora-font-weight-bold, 700);
+  line-height: var(--ethora-line-height-tight, 1.25);
+  color: var(--ethora-color-text, #141414);
+  overflow-wrap: anywhere;
+`, l = e.div`
+  margin-top: var(--ethora-space-1, 4px);
+  font-size: var(--ethora-font-size-sm, 14px);
+  font-weight: var(--ethora-font-weight-medium, 500);
+  color: var(--ethora-color-text-muted, #8c8c8c);
+`, n = e.div`
+  display: flex;
+  flex-direction: column;
+  gap: var(--ethora-space-2, 8px);
+  width: 100%;
+  margin-top: var(--ethora-space-1, 4px);
+`, c = e.p`
+  margin: 0;
+  font-size: var(--ethora-font-size-sm, 14px);
+  line-height: var(--ethora-line-height-normal, 1.5);
+  color: ${({ $empty: a }) => a ? "var(--ethora-color-text-muted, #8c8c8c)" : "var(--ethora-color-text, #141414)"};
+  font-style: ${({ $empty: a }) => a ? "italic" : "normal"};
+  text-align: start;
+  overflow-wrap: anywhere;
+`, h = e.span`
+  display: inline-flex;
+  /* The pill is usually a child of a column flex container, which blockifies
+     inline-flex and stretches it to the full column width unless it opts out.
+     A pill that spans the whole panel reads as a banner, not as a tag. */
+  align-self: flex-start;
+  align-items: center;
+  gap: var(--ethora-space-1, 4px);
+  padding: var(--ethora-space-1, 4px) var(--ethora-space-3, 12px);
+  border-radius: var(--ethora-radius-full, 999px);
+  background: var(--ethora-color-primary-soft, #e7edf9);
+  color: var(--ethora-color-primary, #0052cd);
+  font-size: var(--ethora-font-size-xs, 12px);
+  font-weight: var(--ethora-font-weight-semibold, 600);
+
+  & > svg {
+    width: 14px;
+    height: 14px;
+  }
+`, o = t`
+  padding: ${({ $compact: a }) => a ? "var(--ethora-space-4, 16px) var(--ethora-space-2, 8px)" : "var(--ethora-space-6, 24px) var(--ethora-space-4, 16px)"};
+`, p = e.div`
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  text-align: center;
+  gap: var(--ethora-space-1, 4px);
+  color: var(--ethora-color-text-secondary, #5a5f66);
+  ${o}
+
+  & > svg {
+    opacity: 0.7;
+    margin-bottom: var(--ethora-space-1, 4px);
+  }
+`, f = e.div`
+  font-size: var(--ethora-font-size-sm, 14px);
+  font-weight: var(--ethora-font-weight-medium, 500);
+  color: var(--ethora-color-text-secondary, #5a5f66);
+`;
+e.div`
+  font-size: var(--ethora-font-size-xs, 12px);
+  color: var(--ethora-color-text-muted, #8c8c8c);
+`;
+const d = (a) => {
+  navigator.clipboard.writeText(a);
+};
+export {
+  c as D,
+  i as P,
+  s as a,
+  n as b,
+  l as c,
+  h as d,
+  p as e,
+  f,
+  d as h
+};

package/dist/helpers/buildChatShareLink.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Builds the "open this chat" link that the QR modal encodes.
+ *
+ * Two rules matter here:
+ *
+ * 1. The link has to point back at a page that actually mounts <Chat>.
+ *    The old fallback invented a `/app/chat/` path from the current origin
+ *    (and, with no window, an even older `beta.ethora.com` build-time URL),
+ *    so scanning the QR on any deployment whose chat does not live at
+ *    `/app/chat/` landed on a blank page. The current page is the one the
+ *    user is looking at the chat in, so its own origin + pathname is the
+ *    only entry point we can honestly guarantee. A host that serves chat
+ *    somewhere else still overrides everything via `config.qrUrl`.
+ *
+ * 2. The parameter is written with URLSearchParams so an existing query
+ *    string on the page (locale switches, host params) survives instead of
+ *    being clobbered, and the id is encoded.
+ */
+export declare const CHAT_LINK_PARAM = "chatId";
+export declare const buildChatShareLink: (chatJid: string, qrUrl?: string, currentHref?: string) => string;

package/dist/helpers/cacheScope.d.ts

@@ -1,8 +1,22 @@
 import { IConfig } from '../types/types';
 export declare const buildCacheScope: (config?: IConfig) => string;
-export declare const clearScopedChatCache: () => void;
+interface ClearScopedChatCacheOptions {
+    /**
+     * Keep the chat id a QR code / shared link just parked.
+     *
+     * That id is not cached data from a previous session, it is the room the
+     * user is arriving at RIGHT NOW. Wiping it on a first-run reset (which is
+     * exactly when someone opens a link on a fresh browser) dropped the
+     * destination on the floor: the selection was cleared, and the first room
+     * that happened to arrive over XMPP was opened instead. A genuine tenant
+     * switch still drops it - a bare chat id means nothing in another tenant.
+     */
+    keepPendingChatId?: boolean;
+}
+export declare const clearScopedChatCache: (options?: ClearScopedChatCacheOptions) => void;
 export declare const ensureScopedChatCache: (config?: IConfig) => {
     changed: boolean;
     scope: string;
     previousScope: string | null;
 };
+export {};

package/dist/helpers/constants/MODAL_TYPES.d.ts

@@ -12,8 +12,10 @@ export declare const MODAL_TYPES: {
  */
 export declare const SETTINGS_SUB_MODAL_TYPES: string[];
 /**
- * Panels that open as a right-hand side drawer instead of a centred card:
- * the profile/settings family. Everything else (file preview) keeps the
- * centred-dialog presentation.
+ * Panels that open as the chat's right-hand COLUMN rather than as a centred
+ * card on top of it: the profile/settings family. These take part in the
+ * layout (see `components/Modals/SidePanel/SidePanel.tsx`), so opening one
+ * narrows the conversation instead of covering it. Everything else (file
+ * preview and the confirm dialogs) keeps the centred-dialog presentation.
  */
-export declare const DRAWER_MODAL_TYPES: string[];
+export declare const SIDE_PANEL_MODAL_TYPES: string[];

package/dist/helpers/createRoomFromApi.d.ts

@@ -1,2 +1,2 @@
 import { ApiRoom, IRoom } from '../types/types';
-export declare const createRoomFromApi: (room: ApiRoom, service?: string, usersArrayLength?: number) => IRoom;
+export declare const createRoomFromApi: (room: ApiRoom, service?: string, usersArrayLength?: number) => IRoom | null;

package/dist/helpers/formatNumberWithCommas.d.ts

@@ -1 +1 @@
-export declare function formatNumberWithCommas(num: number | string): string;
+export declare function formatNumberWithCommas(num: number | string, locale?: string): string;

package/dist/hooks/useChatOpenPhase.d.ts

@@ -0,0 +1,21 @@
+export type ChatOpenPhase = 'opening' | 'settled';
+/**
+ * Collapses "is this room's history still loading" into one phase that only
+ * ever moves forward, once, for a given room key: 'opening' -> 'settled'.
+ * It never reports 'opening' again for the same key once it has settled -
+ * ChatRoom relies on that to stop the Loader/placeholder pane from
+ * oscillating while a room opens (see the flicker this hook exists to
+ * fix). A settled-but-empty room can still legitimately start rendering
+ * messages later (a live message arrives) - that is not this hook's
+ * concern; callers derive that from their own `hasMessages`, this hook only
+ * owns whether the opening UI is still allowed to show.
+ *
+ * `roomKey` resets the latch: pass the active room's JID (or null). The
+ * reset happens synchronously during render (React's "adjust state while
+ * rendering" pattern), so switching rooms - even quickly, back and forth -
+ * never paints a frame of the previous room's settled state under the new
+ * room's key, and never leaves a stale debounce timer running against the
+ * new key (the effect below is keyed on `roomKey` too, so its cleanup
+ * clears the old timer before the new one can be scheduled).
+ */
+export declare const useChatOpenPhase: (roomKey: string | null, isLoadingSignal: boolean) => ChatOpenPhase;

package/dist/hooks/useDelayedAction.d.ts

@@ -0,0 +1,22 @@
+export interface DelayedActionState {
+    /** Call instead of the real close/dismiss handler. */
+    requestAction: () => void;
+    /** True from the moment `requestAction` is called until `action` actually
+     *  runs - apply the exit animation while this is true. */
+    isPending: boolean;
+}
+/**
+ * For a component that closes ITSELF (a modal that owns `isOpen` locally,
+ * or one that only gets an `onClose` callback with no boolean to watch):
+ * wraps `action` so calling `requestAction()` plays out the exit animation
+ * first and only invokes the real `action` once it has finished, instead of
+ * unmounting on the same tick the user clicked close.
+ *
+ * This works because the component stays mounted for exactly as long as its
+ * parent's render condition stays true, and that condition usually depends
+ * on the very state `action` is about to change - delaying the call delays
+ * the unmount for free, no separate "still rendering while closing" flag
+ * needed at the parent. See `useExitTransition` for the opposite case: the
+ * parent owns `isOpen` and the child has no closing callback to intercept.
+ */
+export declare function useDelayedAction(action: () => void, durationMs: number): DelayedActionState;

package/dist/hooks/useExclusiveRightPane.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Keeps the chat to at most three columns.
+ *
+ * Two different things want to be the right-hand column: the thread view
+ * (`Thread/ThreadWrapper`) and the profile/settings panel
+ * (`Modals/SidePanel`). Letting both take space at once gives four columns
+ * and squeezes the conversation into nothing, so the rule is the one most
+ * products use: THE ONE OPENED LAST WINS, and the other closes. Opening a
+ * profile while reading a thread puts the profile there and drops back to the
+ * room's messages; opening a thread from a message while a profile is open
+ * closes the profile. Either way, dismissing the survivor leaves the plain
+ * two-column chat, never a half-state.
+ *
+ * The tie-break for "both already open on the first render" (a remount with
+ * persisted state, not something a click can produce) is to close the panel:
+ * the thread is the reading context the user was in, the panel is chrome.
+ */
+interface UseExclusiveRightPaneOptions {
+    threadOpen: boolean;
+    panelOpen: boolean;
+    closeThread: () => void;
+    closePanel: () => void;
+}
+export declare const useExclusiveRightPane: ({ threadOpen, panelOpen, closeThread, closePanel, }: UseExclusiveRightPaneOptions) => void;
+export default useExclusiveRightPane;

package/dist/hooks/useExitTransition.d.ts

@@ -0,0 +1,24 @@
+export interface ExitTransitionState {
+    /** Whether the caller should still render the element at all. */
+    shouldRender: boolean;
+    /** True for the window between `isOpen` going false and the element
+     *  actually leaving the DOM - apply the exit animation while this is true. */
+    isExiting: boolean;
+}
+/**
+ * Keeps an element mounted for `durationMs` after `isOpen` flips to false, so
+ * a CSS exit animation has time to play instead of the element vanishing on
+ * the same frame the state changes.
+ *
+ * This is the "someone else decides when I close" half of the presence
+ * story - the caller owns `isOpen` (Redux state, a prop, ...) and this hook
+ * just tells it how long to keep rendering. For a component that closes
+ * itself (a modal with its own local open flag, reacting to its own close
+ * button), prefer `useDelayedAction` instead: it lets the component play the
+ * animation and only THEN flip its own state, which is simpler when there is
+ * no external boolean to watch.
+ *
+ * Respects `prefers-reduced-motion`: when set, the element is removed on the
+ * same tick `isOpen` goes false, same as if `durationMs` were 0.
+ */
+export declare function useExitTransition(isOpen: boolean, durationMs: number): ExitTransitionState;

package/dist/hooks/useGetNewArchRoom.d.ts

@@ -1,3 +1,5 @@
 import { ApiRoom } from '../types/types';
-declare const useGetNewArchRoom: () => (client: any, config: any) => Promise<ApiRoom[]>;
+declare const useGetNewArchRoom: () => (client: any, config: any, options?: {
+    force?: boolean;
+}) => Promise<ApiRoom[]>;
 export default useGetNewArchRoom;

package/dist/hooks/useQRCodeChatHandler.d.ts

@@ -1,6 +1,34 @@
 export declare const handleQRChatId: () => void;
+/**
+ * Turns whatever the link carried into a room JID.
+ *
+ * Accepts a bare chat id (`<appId>_<chatId>`) or an already-qualified JID,
+ * so a QR that encodes either form lands in the same room.
+ *
+ * Returns '' when no conference server is known. That is deliberate: the
+ * hook used to fall back to the build-time `VITE_APP_XMPP_CONFERENCE`, which
+ * is baked into the published bundle and is empty in this package's own
+ * build. In a multi-tenant deploy that produced a JID for the wrong tenant
+ * (or the malformed `<id>@`), so an unknown conference now means "wait",
+ * never "guess".
+ */
+export declare const resolveQrChatRoomJid: (qrChatId?: string | null, conferenceServer?: string) => string;
+interface QRCodeChatOptions {
+    /** Rooms currently known to the store, keyed by JID. */
+    rooms?: Record<string, unknown> | null;
+    /** The room the store currently has selected. */
+    activeRoomJID?: string | null;
+    /**
+     * True once the client is connected and the room list has settled, i.e.
+     * once "the room is still not here" is a real answer rather than "not
+     * loaded yet".
+     */
+    isReady?: boolean;
+}
 export declare const useQRCodeChat: (setCurrentRoom: (params: {
     roomJID: string;
-}) => void, conferenceServer?: string) => {
+}) => void, conferenceServer?: string, options?: QRCodeChatOptions) => {
     wasAutoSelected: boolean;
+    notFoundRoomJID: string;
 };
+export {};