stream-chat-react 14.11.1 → 15.0.0-rc.1

package/dist/es/context/MessageComposerContext.mjs

@@ -0,0 +1,19 @@
+import { requireContext } from "./requireContext.mjs";
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/context/MessageComposerContext.tsx
+var MessageComposerContext = createContext(void 0);
+var MessageComposerContextProvider = ({ children, value }) => /* @__PURE__ */ jsx(MessageComposerContext.Provider, {
+	value,
+	children
+});
+var useMessageComposerContext = () => requireContext(useContext(MessageComposerContext), "useMessageComposerContext", "MessageComposerContextProvider");
+/**
+* Whether the caller sits beneath a `MessageComposerContextProvider`, for components that render
+* both inside and outside a composer. See `WithDragAndDropUpload`.
+*/
+var useIsWithinMessageComposerContext = () => useContext(MessageComposerContext) !== void 0;
+//#endregion
+export { MessageComposerContext, MessageComposerContextProvider, useIsWithinMessageComposerContext, useMessageComposerContext };
+
+//# sourceMappingURL=MessageComposerContext.mjs.map

package/dist/es/context/MessageComposerContext.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageComposerContext.mjs","names":[],"sources":["../../../src/context/MessageComposerContext.tsx"],"sourcesContent":["import React, { createContext, useContext } from 'react';\nimport type { PropsWithChildren } from 'react';\n\nimport type { MessageComposerProps } from '../components/MessageComposer';\nimport type { UseMessageComposerBindingsParams } from '../components/MessageComposer/hooks/useMessageComposerBindings';\nimport { requireContext } from './requireContext';\n\nexport type MessageComposerContextValue = UseMessageComposerBindingsParams &\n  Omit<MessageComposerProps, 'Input'>;\n\nexport const MessageComposerContext = createContext<\n  MessageComposerContextValue | undefined\n>(undefined);\n\nexport const MessageComposerContextProvider = ({\n  children,\n  value,\n}: PropsWithChildren<{\n  value: MessageComposerContextValue;\n}>) => (\n  <MessageComposerContext.Provider value={value}>\n    {children}\n  </MessageComposerContext.Provider>\n);\n\nexport const useMessageComposerContext = () =>\n  requireContext(\n    useContext(MessageComposerContext),\n    'useMessageComposerContext',\n    'MessageComposerContextProvider',\n  );\n\n/**\n * Whether the caller sits beneath a `MessageComposerContextProvider`, for components that render\n * both inside and outside a composer. See `WithDragAndDropUpload`.\n */\nexport const useIsWithinMessageComposerContext = () =>\n  useContext(MessageComposerContext) !== undefined;\n"],"mappings":";;;;AAUA,IAAa,yBAAyB,cAEpC,KAAA,CAAS;AAEX,IAAa,kCAAkC,EAC7C,UACA,YAIA,oBAAC,uBAAuB,UAAxB;CAAwC;CACrC;AAC8B,CAAA;AAGnC,IAAa,kCACX,eACE,WAAW,sBAAsB,GACjC,6BACA,gCACF;;;;;AAMF,IAAa,0CACX,WAAW,sBAAsB,MAAM,KAAA"}

package/dist/es/context/MessageComposerControllerContext.mjs

@@ -0,0 +1,19 @@
+import React, { useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/context/MessageComposerControllerContext.tsx
+var MessageComposerControllerContext = React.createContext(void 0);
+/**
+* Supplies the composer a `MessageComposer` below it edits, in place of the thread's or channel's own.
+* For a composition the integrator owns - editing a message inline, for instance - where the default
+* composer is the wrong one to write into.
+*/
+var MessageComposerControllerProvider = ({ children, messageComposerController }) => /* @__PURE__ */ jsx(MessageComposerControllerContext.Provider, {
+	value: messageComposerController,
+	children
+});
+/** The composer supplied by {@link MessageComposerControllerProvider}, if any. */
+var useMessageComposerControllerContext = () => useContext(MessageComposerControllerContext);
+//#endregion
+export { MessageComposerControllerProvider, useMessageComposerControllerContext };
+
+//# sourceMappingURL=MessageComposerControllerContext.mjs.map

package/dist/es/context/MessageComposerControllerContext.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageComposerControllerContext.mjs","names":[],"sources":["../../../src/context/MessageComposerControllerContext.tsx"],"sourcesContent":["import type { PropsWithChildren } from 'react';\nimport React, { useContext } from 'react';\nimport type { MessageComposer as MessageComposerController } from 'stream-chat';\n\nconst MessageComposerControllerContext = React.createContext<\n  MessageComposerController | undefined\n>(undefined);\n\n/**\n * Supplies the composer a `MessageComposer` below it edits, in place of the thread's or channel's own.\n * For a composition the integrator owns - editing a message inline, for instance - where the default\n * composer is the wrong one to write into.\n */\nexport const MessageComposerControllerProvider = ({\n  children,\n  messageComposerController,\n}: PropsWithChildren<{\n  messageComposerController?: MessageComposerController;\n}>) => (\n  <MessageComposerControllerContext.Provider value={messageComposerController}>\n    {children}\n  </MessageComposerControllerContext.Provider>\n);\n\n/** The composer supplied by {@link MessageComposerControllerProvider}, if any. */\nexport const useMessageComposerControllerContext = () =>\n  useContext(MessageComposerControllerContext);\n"],"mappings":";;;AAIA,IAAM,mCAAmC,MAAM,cAE7C,KAAA,CAAS;;;;;;AAOX,IAAa,qCAAqC,EAChD,UACA,gCAIA,oBAAC,iCAAiC,UAAlC;CAA2C,OAAO;CAC/C;AACwC,CAAA;;AAI7C,IAAa,4CACX,WAAW,gCAAgC"}

package/dist/es/context/MessageContext.mjs

@@ -0,0 +1,14 @@
+import { requireContext } from "./requireContext.mjs";
+import React, { useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/context/MessageContext.tsx
+var MessageContext = React.createContext(void 0);
+var MessageProvider = ({ children, value }) => /* @__PURE__ */ jsx(MessageContext.Provider, {
+	value,
+	children
+});
+var useMessageContext = () => requireContext(useContext(MessageContext), "useMessageContext", "MessageProvider");
+//#endregion
+export { MessageContext, MessageProvider, useMessageContext };
+
+//# sourceMappingURL=MessageContext.mjs.map

package/dist/es/context/MessageContext.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageContext.mjs","names":[],"sources":["../../../src/context/MessageContext.tsx"],"sourcesContent":["import type { PropsWithChildren } from 'react';\nimport React, { useContext } from 'react';\n\nimport type {\n  DeleteMessageOptions,\n  LocalMessage,\n  ReactionResponse,\n  SortParamRequest,\n  UserResponse,\n} from 'stream-chat';\n\nimport type { ActionHandlerReturnType } from '../components/Message/hooks/useActionHandler';\nimport type { ReactEventHandler } from '../components/Message/types';\nimport type { GroupStyle } from '../components/MessageList/utils';\nimport type { ReactionsComparator, ReactionType } from '../components/Reactions/types';\n\nimport type { RenderTextFunction } from '../components/Message/renderText';\nimport { requireContext } from './requireContext';\n\nexport type MessageContextValue = {\n  /** Function to send an action in a Channel */\n  handleAction: ActionHandlerReturnType;\n  /** Function to delete a message in a Channel */\n  handleDelete: (options?: DeleteMessageOptions) => Promise<void> | void;\n  /** Function to fetch the message reactions */\n  handleFetchReactions: (\n    reactionType?: ReactionType,\n    sort?: SortParamRequest[],\n  ) => Promise<Array<ReactionResponse>>;\n  /** Function to flag a message in a Channel */\n  handleFlag: ReactEventHandler;\n  /** Function to mark message and the messages that follow it as unread in a Channel */\n  handleMarkUnread: ReactEventHandler;\n  /** Function to mute a user in a Channel */\n  handleMute: ReactEventHandler;\n  /** Function to open a thread for the message (routed through ChatView navigation) */\n  handleOpenThread: ReactEventHandler;\n  /** Function to pin a Message in a Channel */\n  handlePin: ReactEventHandler;\n  /** Function to post a reaction on a Message */\n  handleReaction: (\n    reactionType: string,\n    event: React.BaseSyntheticEvent,\n  ) => Promise<void>;\n  /** Function to resend a failed message */\n  handleRetry: (message: LocalMessage) => Promise<void> | void;\n  /** Function that returns whether the Message belongs to the current user */\n  isMyMessage: () => boolean;\n  /** The message object */\n  message: LocalMessage;\n  /** Handler function for a click event on an @mention in Message */\n  onMentionsClickMessage: ReactEventHandler;\n  /** Handler function for a hover event on an @mention in Message */\n  onMentionsHoverMessage: ReactEventHandler;\n  /** Handler function for a click event on the user that posted the Message */\n  onUserClick: ReactEventHandler;\n  /** Handler function for a hover event on the user that posted the Message */\n  onUserHover: ReactEventHandler;\n  /** Call this function to keep message list scrolled to the bottom when the scroll height increases, e.g. an element appears below the last message (only used in the `VirtualizedMessageList`) */\n  autoscrollToBottom?: () => void;\n  /** Message component configuration prop. If true, picking a reaction from the `ReactionSelector` component will close the selector */\n  closeReactionSelectorOnClick?: boolean;\n  /** An array of user IDs that have confirmed the message delivery to their device */\n  deliveredTo?: UserResponse[];\n  /** If true, the message is the last one in a group sent by a specific user (only used in the `VirtualizedMessageList`) */\n  endOfGroup?: boolean;\n  /** If true, the message is the first one in a group sent by a specific user (only used in the `VirtualizedMessageList`) */\n  firstOfGroup?: boolean;\n  /** Override the default formatting of the date. This is a function that has access to the original date object, returns a string  */\n  formatDate?: (date: Date) => string;\n  /** If true, group messages sent by each user (only used in the `VirtualizedMessageList`) */\n  groupedByUser?: boolean;\n  /** A list of styles to apply to this message, ie. top, bottom, single */\n  groupStyles?: GroupStyle[];\n  /** Whether to highlight and focus the message on load */\n  highlighted?: boolean;\n  /** Whether the threaded message is the first in the thread list */\n  initialMessage?: boolean;\n  /**\n   * A factory function that determines whether a message is AI generated or not.\n   */\n  isMessageAIGenerated?: (message: LocalMessage) => boolean;\n  /** Latest own message in currently displayed message set. */\n  lastOwnMessage?: LocalMessage;\n  /** Latest message id on current channel */\n  lastReceivedId?: string | null;\n  /** DOMRect object for parent MessageList component */\n  messageListRect?: DOMRect;\n  /** Sort options to provide to a reactions query */\n  reactionDetailsSort?: SortParamRequest[];\n  /** A list of users that have read this Message */\n  readBy?: UserResponse[];\n  /** When set, shows the sender avatar in a grid layout. Values: true | 'incoming' | 'outgoing'. */\n  showAvatar?: boolean | 'incoming' | 'outgoing';\n  /** Custom function to render message text content, defaults to the renderText function: [utils](https://github.com/GetStream/stream-chat-react/blob/master/src/utils.tsx) */\n  renderText?: RenderTextFunction;\n  /** Keep track of read receipts for each message sent by the user. When disabled, only the last own message delivery / read status is rendered. */\n  returnAllReadData?: boolean;\n  /** Comparator function to sort reactions, defaults to chronological order */\n  sortReactions?: ReactionsComparator;\n  /** If true, the Message is rendered inside a thread's reply list */\n  threadList?: boolean;\n  /** render HTML instead of markdown. Posting HTML is only allowed server-side */\n  unsafeHTML?: boolean;\n  /**\n   * User-specific view for translated messages: which text to show.\n   * - `'original'`: show `message.text` (source language).\n   * - `'translated'`: show the translation for the **current user language** (from\n   *   `useTranslationContext().userLanguage`), i.e. `message.i18n[userLanguage + '_text']`\n   *   or fallback to `message.text` when missing. Resolved via `getTranslatedMessageText`.\n   */\n  translationView?: 'original' | 'translated';\n  /** Set whether this message shows original or translated text (user-specific, does not change message data). */\n  setTranslationView?: (view: 'original' | 'translated') => void;\n};\n\nexport const MessageContext = React.createContext<MessageContextValue | undefined>(\n  undefined,\n);\n\nexport const MessageProvider = ({\n  children,\n  value,\n}: PropsWithChildren<{\n  value: MessageContextValue;\n}>) => (\n  <MessageContext.Provider value={value as unknown as MessageContextValue}>\n    {children}\n  </MessageContext.Provider>\n);\n\nexport const useMessageContext = () =>\n  requireContext(useContext(MessageContext), 'useMessageContext', 'MessageProvider');\n"],"mappings":";;;;AAoHA,IAAa,iBAAiB,MAAM,cAClC,KAAA,CACF;AAEA,IAAa,mBAAmB,EAC9B,UACA,YAIA,oBAAC,eAAe,UAAhB;CAAgC;CAC7B;AACsB,CAAA;AAG3B,IAAa,0BACX,eAAe,WAAW,cAAc,GAAG,qBAAqB,iBAAiB"}

package/dist/es/context/MessageListContext.mjs

@@ -0,0 +1,17 @@
+import { requireContext } from "./requireContext.mjs";
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/context/MessageListContext.tsx
+var MessageListContext = createContext(void 0);
+/**
+* Context provider for components rendered within the `MessageList`
+*/
+var MessageListContextProvider = ({ children, value }) => /* @__PURE__ */ jsx(MessageListContext.Provider, {
+	value,
+	children
+});
+var useMessageListContext = () => requireContext(useContext(MessageListContext), "useMessageListContext", "MessageListContextProvider");
+//#endregion
+export { MessageListContext, MessageListContextProvider, useMessageListContext };
+
+//# sourceMappingURL=MessageListContext.mjs.map

package/dist/es/context/MessageListContext.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageListContext.mjs","names":[],"sources":["../../../src/context/MessageListContext.tsx"],"sourcesContent":["import React, { createContext, useContext } from 'react';\nimport type { PropsWithChildren } from 'react';\nimport type { RenderedMessage } from '../components';\nimport { requireContext } from './requireContext';\n\nexport type MessageListContextValue = {\n  /** Enriched message list, including date separators and intro message (if enabled) */\n  processedMessages: RenderedMessage[];\n  /** The scroll container within which the messages and typing indicator are rendered */\n  listElement: HTMLElement | null;\n  /** Function that scrolls the `listElement` to the bottom. */\n  scrollToBottom: () => void;\n};\n\nexport const MessageListContext = createContext<MessageListContextValue | undefined>(\n  undefined,\n);\n\n/**\n * Context provider for components rendered within the `MessageList`\n */\nexport const MessageListContextProvider = ({\n  children,\n  value,\n}: PropsWithChildren<{\n  value: MessageListContextValue;\n}>) => (\n  <MessageListContext.Provider value={value as MessageListContextValue}>\n    {children}\n  </MessageListContext.Provider>\n);\n\nexport const useMessageListContext = () =>\n  requireContext(\n    useContext(MessageListContext),\n    'useMessageListContext',\n    'MessageListContextProvider',\n  );\n"],"mappings":";;;;AAcA,IAAa,qBAAqB,cAChC,KAAA,CACF;;;;AAKA,IAAa,8BAA8B,EACzC,UACA,YAIA,oBAAC,mBAAmB,UAApB;CAAoC;CACjC;AAC0B,CAAA;AAG/B,IAAa,8BACX,eACE,WAAW,kBAAkB,GAC7B,yBACA,4BACF"}

package/dist/es/context/MessageTranslationViewContext.mjs

@@ -0,0 +1,73 @@
+import React, { createContext, useCallback, useContext, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/context/MessageTranslationViewContext.tsx
+/**
+* Message translation view context: user-specific state for whether each message
+* shows original text or a translation.
+*
+* ## Spec
+*
+* - **State**: Per message list (channel vs thread), we store a map
+*   `messageId → 'original' | 'translated'`. Default for messages with `message.i18n`
+*   is `'translated'`; otherwise `'original'`.
+*
+* - **Provider placement**: The provider is tied to the **message list**, not the channel.
+*   It is rendered inside `MessageList` and `VirtualizedMessageList`. That way the
+*   main channel list and the thread list each have their own translation view state
+*   (e.g. Thread.tsx gets correct behavior without sharing channel state).
+*
+* - **Multiple translations**: `message.i18n` can contain multiple languages, e.g.:
+*   `{ en_text: "Good morning", fr_text: "Bonjour", it_text: "Buongiorno", language: "en" }`.
+*   Which translation is shown is determined by the app’s **user language**
+*   (`useTranslationContext().userLanguage`). We use `message.i18n[userLanguage + '_text']`;
+*   if missing, we fall back to `message.text`. Only one translation is shown at a time.
+*
+* - **Source language**: When present, `message.i18n.language` is the original/source
+*   language of `message.text`. It can be used for the indicator label, e.g.
+*   "Translated from English · View original".
+*
+* - **Invariants**: The original message content, layout, grouping, and order stay
+*   unchanged. Removing or toggling translation only changes the annotation and which
+*   text is displayed. "View original" / "View translation" switch the displayed
+*   text and update the annotation (e.g. "Original · View translation" when showing
+*   original).
+*
+* - **Translation indicator visibility**: The translation indicator (e.g. "Translated ·
+*   View original") is **not** shown when the currently viewed text already corresponds
+*   to `userLanguage` — for example when viewing original and the original text is the
+*   user-language version (i.e. `getTranslatedMessageText({ language: userLanguage, message })`
+*   equals `message.text`). In that case there is no meaningful original/translated choice,
+*   so the indicator is hidden.
+*/
+/**
+* Returns the translated message text for a given language from `message.i18n`, or
+* undefined if not present. Used to resolve which of the multiple translations to show.
+*/
+var getTranslatedMessageText = ({ language, message }) => message?.i18n?.[`${language}_text`];
+var MessageTranslationViewContext = createContext({
+	getTranslationView: (_messageId, hasI18n) => hasI18n ? "translated" : "original",
+	setTranslationView: () => {}
+});
+var MessageTranslationViewProvider = ({ children }) => {
+	const [viewByMessageId, setViewByMessageId] = useState({});
+	const setTranslationView = useCallback((messageId, view) => {
+		setViewByMessageId((prev) => ({
+			...prev,
+			[messageId]: view
+		}));
+	}, []);
+	const getTranslationView = useCallback((messageId, hasI18n) => viewByMessageId[messageId] ?? (hasI18n ? "translated" : "original"), [viewByMessageId]);
+	const stableValue = React.useMemo(() => ({
+		getTranslationView,
+		setTranslationView
+	}), [getTranslationView, setTranslationView]);
+	return /* @__PURE__ */ jsx(MessageTranslationViewContext.Provider, {
+		value: stableValue,
+		children
+	});
+};
+var useMessageTranslationViewContext = () => useContext(MessageTranslationViewContext);
+//#endregion
+export { MessageTranslationViewContext, MessageTranslationViewProvider, getTranslatedMessageText, useMessageTranslationViewContext };
+
+//# sourceMappingURL=MessageTranslationViewContext.mjs.map

package/dist/es/context/MessageTranslationViewContext.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageTranslationViewContext.mjs","names":[],"sources":["../../../src/context/MessageTranslationViewContext.tsx"],"sourcesContent":["/**\n * Message translation view context: user-specific state for whether each message\n * shows original text or a translation.\n *\n * ## Spec\n *\n * - **State**: Per message list (channel vs thread), we store a map\n *   `messageId → 'original' | 'translated'`. Default for messages with `message.i18n`\n *   is `'translated'`; otherwise `'original'`.\n *\n * - **Provider placement**: The provider is tied to the **message list**, not the channel.\n *   It is rendered inside `MessageList` and `VirtualizedMessageList`. That way the\n *   main channel list and the thread list each have their own translation view state\n *   (e.g. Thread.tsx gets correct behavior without sharing channel state).\n *\n * - **Multiple translations**: `message.i18n` can contain multiple languages, e.g.:\n *   `{ en_text: \"Good morning\", fr_text: \"Bonjour\", it_text: \"Buongiorno\", language: \"en\" }`.\n *   Which translation is shown is determined by the app’s **user language**\n *   (`useTranslationContext().userLanguage`). We use `message.i18n[userLanguage + '_text']`;\n *   if missing, we fall back to `message.text`. Only one translation is shown at a time.\n *\n * - **Source language**: When present, `message.i18n.language` is the original/source\n *   language of `message.text`. It can be used for the indicator label, e.g.\n *   \"Translated from English · View original\".\n *\n * - **Invariants**: The original message content, layout, grouping, and order stay\n *   unchanged. Removing or toggling translation only changes the annotation and which\n *   text is displayed. \"View original\" / \"View translation\" switch the displayed\n *   text and update the annotation (e.g. \"Original · View translation\" when showing\n *   original).\n *\n * - **Translation indicator visibility**: The translation indicator (e.g. \"Translated ·\n *   View original\") is **not** shown when the currently viewed text already corresponds\n *   to `userLanguage` — for example when viewing original and the original text is the\n *   user-language version (i.e. `getTranslatedMessageText({ language: userLanguage, message })`\n *   equals `message.text`). In that case there is no meaningful original/translated choice,\n *   so the indicator is hidden.\n */\n\nimport React, { createContext, useCallback, useContext, useState } from 'react';\nimport type { LocalMessage, TranslationLanguage } from 'stream-chat';\n\n/**\n * Returns the translated message text for a given language from `message.i18n`, or\n * undefined if not present. Used to resolve which of the multiple translations to show.\n */\nexport const getTranslatedMessageText = ({\n  language,\n  message,\n}: {\n  language: string;\n  message?: LocalMessage;\n}): string | undefined =>\n  message?.i18n?.[`${language}_text` as `${TranslationLanguage}_text`];\n\n/**\n * Which message text to show.\n * - `'original'`: `message.text` (source language).\n * - `'translated'`: translation for the **current user language** (TranslationContext’s\n *   `userLanguage`), i.e. `getTranslatedMessageText({ language: userLanguage, message })`\n *   or fallback to `message.text`.\n */\nexport type TranslationView = 'original' | 'translated';\n\nexport type MessageTranslationViewContextValue = {\n  getTranslationView: (messageId: string, hasI18n: boolean) => TranslationView;\n  setTranslationView: (messageId: string, view: TranslationView) => void;\n};\n\nconst defaultContextValue: MessageTranslationViewContextValue = {\n  getTranslationView: (_messageId, hasI18n) => (hasI18n ? 'translated' : 'original'),\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n  setTranslationView: () => {},\n};\n\nexport const MessageTranslationViewContext =\n  createContext<MessageTranslationViewContextValue>(defaultContextValue);\n\nexport const MessageTranslationViewProvider = ({\n  children,\n}: {\n  children: React.ReactNode;\n}) => {\n  const [viewByMessageId, setViewByMessageId] = useState<Record<string, TranslationView>>(\n    {},\n  );\n\n  const setTranslationView = useCallback((messageId: string, view: TranslationView) => {\n    setViewByMessageId((prev) => ({ ...prev, [messageId]: view }));\n  }, []);\n\n  const getTranslationView = useCallback(\n    (messageId: string, hasI18n: boolean): TranslationView =>\n      viewByMessageId[messageId] ?? (hasI18n ? 'translated' : 'original'),\n    [viewByMessageId],\n  );\n\n  const stableValue = React.useMemo(\n    () => ({ getTranslationView, setTranslationView }),\n    [getTranslationView, setTranslationView],\n  );\n\n  return (\n    <MessageTranslationViewContext.Provider value={stableValue}>\n      {children}\n    </MessageTranslationViewContext.Provider>\n  );\n};\n\n// created with a default value, so there is no missing-provider case\nexport const useMessageTranslationViewContext = () =>\n  useContext(MessageTranslationViewContext);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CA,IAAa,4BAA4B,EACvC,UACA,cAKA,SAAS,OAAO,GAAG,SAAS;AAsB9B,IAAa,gCACX,cAAkD;CANlD,qBAAqB,YAAY,YAAa,UAAU,eAAe;CAEvE,0BAA0B,CAAC;AAIuB,CAAmB;AAEvE,IAAa,kCAAkC,EAC7C,eAGI;CACJ,MAAM,CAAC,iBAAiB,sBAAsB,SAC5C,CAAC,CACH;CAEA,MAAM,qBAAqB,aAAa,WAAmB,SAA0B;EACnF,oBAAoB,UAAU;GAAE,GAAG;IAAO,YAAY;EAAK,EAAE;CAC/D,GAAG,CAAC,CAAC;CAEL,MAAM,qBAAqB,aACxB,WAAmB,YAClB,gBAAgB,eAAe,UAAU,eAAe,aAC1D,CAAC,eAAe,CAClB;CAEA,MAAM,cAAc,MAAM,eACjB;EAAE;EAAoB;CAAmB,IAChD,CAAC,oBAAoB,kBAAkB,CACzC;CAEA,OACE,oBAAC,8BAA8B,UAA/B;EAAwC,OAAO;EAC5C;CACqC,CAAA;AAE5C;AAGA,IAAa,yCACX,WAAW,6BAA6B"}

package/dist/es/context/ModalContext.mjs

@@ -0,0 +1,18 @@
+import React, { useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/context/ModalContext.tsx
+var ModalContext = React.createContext(void 0);
+var ModalContextProvider = ({ children, value }) => /* @__PURE__ */ jsx(ModalContext.Provider, {
+	value,
+	children
+});
+var NO_MODAL_FALLBACK = { close: () => void 0 };
+/**
+* Works outside a modal: `Alert`, `Prompt` and `Viewer` are usable standalone, reading only
+* `dialogId` for aria wiring, and get a no-op `close`.
+*/
+var useModalContext = () => useContext(ModalContext) ?? NO_MODAL_FALLBACK;
+//#endregion
+export { ModalContext, ModalContextProvider, useModalContext };
+
+//# sourceMappingURL=ModalContext.mjs.map

package/dist/es/context/ModalContext.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModalContext.mjs","names":[],"sources":["../../../src/context/ModalContext.tsx"],"sourcesContent":["import type { PropsWithChildren } from 'react';\nimport React, { useContext } from 'react';\n\nexport type ModalContextValue = {\n  close: () => void;\n  dialogId?: string;\n};\n\nexport const ModalContext = React.createContext<ModalContextValue | undefined>(undefined);\n\nexport const ModalContextProvider = ({\n  children,\n  value,\n}: PropsWithChildren<{\n  value: ModalContextValue;\n}>) => <ModalContext.Provider value={value}>{children}</ModalContext.Provider>;\n\n// module-level to keep a stable identity across renders\nconst NO_MODAL_FALLBACK: ModalContextValue = { close: () => undefined };\n\n/**\n * Works outside a modal: `Alert`, `Prompt` and `Viewer` are usable standalone, reading only\n * `dialogId` for aria wiring, and get a no-op `close`.\n */\nexport const useModalContext = () => useContext(ModalContext) ?? NO_MODAL_FALLBACK;\n"],"mappings":";;;AAQA,IAAa,eAAe,MAAM,cAA6C,KAAA,CAAS;AAExF,IAAa,wBAAwB,EACnC,UACA,YAGK,oBAAC,aAAa,UAAd;CAA8B;CAAQ;AAAgC,CAAA;AAG7E,IAAM,oBAAuC,EAAE,aAAa,KAAA,EAAU;;;;;AAMtE,IAAa,wBAAwB,WAAW,YAAY,KAAK"}

package/dist/es/context/PollContext.mjs

@@ -0,0 +1,14 @@
+import { requireContext } from "./requireContext.mjs";
+import React, { useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/context/PollContext.tsx
+var PollContext = React.createContext(void 0);
+var PollProvider = ({ children, poll }) => poll ? /* @__PURE__ */ jsx(PollContext.Provider, {
+	value: { poll },
+	children
+}) : null;
+var usePollContext = () => requireContext(useContext(PollContext), "usePollContext", "PollProvider");
+//#endregion
+export { PollContext, PollProvider, usePollContext };
+
+//# sourceMappingURL=PollContext.mjs.map

package/dist/es/context/PollContext.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"PollContext.mjs","names":[],"sources":["../../../src/context/PollContext.tsx"],"sourcesContent":["import React, { useContext } from 'react';\nimport type { PropsWithChildren } from 'react';\nimport type { Poll } from 'stream-chat';\nimport { requireContext } from './requireContext';\n\nexport type PollContextValue = {\n  poll: Poll;\n};\n\nexport const PollContext = React.createContext<PollContextValue | undefined>(undefined);\n\nexport const PollProvider = ({\n  children,\n  poll,\n}: PropsWithChildren<{\n  poll: Poll;\n}>) =>\n  poll ? (\n    <PollContext.Provider value={{ poll } as unknown as PollContextValue}>\n      {children}\n    </PollContext.Provider>\n  ) : null;\n\nexport const usePollContext = () =>\n  requireContext(useContext(PollContext), 'usePollContext', 'PollProvider');\n"],"mappings":";;;;AASA,IAAa,cAAc,MAAM,cAA4C,KAAA,CAAS;AAEtF,IAAa,gBAAgB,EAC3B,UACA,WAIA,OACE,oBAAC,YAAY,UAAb;CAAsB,OAAO,EAAE,KAAK;CACjC;AACmB,CAAA,IACpB;AAEN,IAAa,uBACX,eAAe,WAAW,WAAW,GAAG,kBAAkB,cAAc"}

package/dist/es/context/TranslationContext.mjs

@@ -0,0 +1,17 @@
+import { defaultDateTimeParser, defaultTranslatorFunction } from "../i18n/utils.mjs";
+import { createTranslationContext } from "@stream-io/i18n/react";
+//#region src/context/TranslationContext.tsx
+/**
+* Built from the shared factory in `@stream-io/i18n/react`. What stays this SDK's own: the
+* catalog-typed `t`, and supplying a **default** rather than throwing, so primitives render outside
+* `<Chat>` (React Native throws instead — hence the option).
+*/
+var { TranslationContext, TranslationProvider, useTranslationContext } = createTranslationContext({ defaultValue: {
+	t: defaultTranslatorFunction,
+	tDateTimeParser: defaultDateTimeParser,
+	userLanguage: "en"
+} });
+//#endregion
+export { TranslationContext, TranslationProvider, useTranslationContext };
+
+//# sourceMappingURL=TranslationContext.mjs.map

package/dist/es/context/TranslationContext.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"TranslationContext.mjs","names":[],"sources":["../../../src/context/TranslationContext.tsx"],"sourcesContent":["import { createTranslationContext } from '@stream-io/i18n/react';\n\nimport { defaultDateTimeParser, defaultTranslatorFunction } from '../i18n/utils';\nimport type { StreamTFunction, TDateTimeParser } from '../i18n/types';\n\n/**\n * The `Dayjs.extend(calendar)` / `extend(localizedFormat)` calls that used to sit here are gone:\n * `defaultDateTimeParser` from `@stream-io/i18n` registers the plugins itself on first use, which\n * is what lets the package stay side-effect-free.\n *\n * If that ever regresses it fails *silently* — `.calendar()` is simply absent, so timestamps render\n * malformed rather than throwing.\n */\n\nexport type TranslationContextValue = {\n  t: StreamTFunction;\n  tDateTimeParser: TDateTimeParser;\n  userLanguage: string;\n};\n\n/**\n * Built from the shared factory in `@stream-io/i18n/react`. What stays this SDK's own: the\n * catalog-typed `t`, and supplying a **default** rather than throwing, so primitives render outside\n * `<Chat>` (React Native throws instead — hence the option).\n */\nconst { TranslationContext, TranslationProvider, useTranslationContext } =\n  createTranslationContext<TranslationContextValue>({\n    defaultValue: {\n      t: defaultTranslatorFunction,\n      tDateTimeParser: defaultDateTimeParser,\n      userLanguage: 'en',\n    },\n  });\n\nexport { TranslationContext, TranslationProvider };\n\n/** Works outside `<Chat>` — the default translator renders each call site's inline English. */\nexport { useTranslationContext };\n"],"mappings":";;;;;;;;AAyBA,IAAM,EAAE,oBAAoB,qBAAqB,0BAC/C,yBAAkD,EAChD,cAAc;CACZ,GAAG;CACH,iBAAiB;CACjB,cAAc;AAChB,EACF,CAAC"}

package/dist/es/context/VirtualizedMessageListContext.mjs

@@ -0,0 +1,17 @@
+import { requireContext } from "./requireContext.mjs";
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/context/VirtualizedMessageListContext.tsx
+var VirtualizedMessageListContext = createContext(void 0);
+/**
+* Context provider for components rendered within the `VirtualizedMessageList`
+*/
+var VirtualizedMessageListContextProvider = ({ children, value }) => /* @__PURE__ */ jsx(VirtualizedMessageListContext.Provider, {
+	value,
+	children
+});
+var useVirtualizedMessageListContext = () => requireContext(useContext(VirtualizedMessageListContext), "useVirtualizedMessageListContext", "VirtualizedMessageListContextProvider");
+//#endregion
+export { VirtualizedMessageListContext, VirtualizedMessageListContextProvider, useVirtualizedMessageListContext };
+
+//# sourceMappingURL=VirtualizedMessageListContext.mjs.map

package/dist/es/context/VirtualizedMessageListContext.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"VirtualizedMessageListContext.mjs","names":[],"sources":["../../../src/context/VirtualizedMessageListContext.tsx"],"sourcesContent":["import React, { createContext, useContext } from 'react';\nimport type { PropsWithChildren } from 'react';\nimport { requireContext } from './requireContext';\n\nexport type VirtualizedMessageListContextValue = {\n  /** Function that scrolls the list to the bottom. */\n  scrollToBottom: () => void;\n};\n\nexport const VirtualizedMessageListContext = createContext<\n  VirtualizedMessageListContextValue | undefined\n>(undefined);\n\n/**\n * Context provider for components rendered within the `VirtualizedMessageList`\n */\nexport const VirtualizedMessageListContextProvider = ({\n  children,\n  value,\n}: PropsWithChildren<{\n  value: VirtualizedMessageListContextValue;\n}>) => (\n  <VirtualizedMessageListContext.Provider\n    value={value as VirtualizedMessageListContextValue}\n  >\n    {children}\n  </VirtualizedMessageListContext.Provider>\n);\n\nexport const useVirtualizedMessageListContext = () =>\n  requireContext(\n    useContext(VirtualizedMessageListContext),\n    'useVirtualizedMessageListContext',\n    'VirtualizedMessageListContextProvider',\n  );\n"],"mappings":";;;;AASA,IAAa,gCAAgC,cAE3C,KAAA,CAAS;;;;AAKX,IAAa,yCAAyC,EACpD,UACA,YAIA,oBAAC,8BAA8B,UAA/B;CACS;CAEN;AACqC,CAAA;AAG1C,IAAa,yCACX,eACE,WAAW,6BAA6B,GACxC,oCACA,uCACF"}

package/dist/es/context/WithComponents.mjs

@@ -0,0 +1,23 @@
+import { ComponentContext } from "./ComponentContext.mjs";
+import { useContext, useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/context/WithComponents.tsx
+function WithComponents({ children, overrides }) {
+	const parentOverrides = useContext(ComponentContext);
+	const actualOverrides = useMemo(() => ({
+		...parentOverrides,
+		...overrides,
+		icons: {
+			...parentOverrides?.icons,
+			...overrides?.icons
+		}
+	}), [parentOverrides, overrides]);
+	return /* @__PURE__ */ jsx(ComponentContext.Provider, {
+		value: actualOverrides,
+		children
+	});
+}
+//#endregion
+export { WithComponents };
+
+//# sourceMappingURL=WithComponents.mjs.map

package/dist/es/context/WithComponents.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"WithComponents.mjs","names":[],"sources":["../../../src/context/WithComponents.tsx"],"sourcesContent":["import React, { useContext, useMemo } from 'react';\nimport type { PropsWithChildren } from 'react';\n\nimport { ComponentContext } from './ComponentContext';\nimport type { ComponentContextValue } from './ComponentContext';\n\nexport function WithComponents({\n  children,\n  overrides,\n}: PropsWithChildren<{ overrides: Partial<ComponentContextValue> }>) {\n  const parentOverrides = useContext(ComponentContext);\n  // Memoized because this provider sits on render paths hot enough for the identity of the\n  // merged value to matter: a new object on every render re-renders every\n  // `useComponentContext()` consumer below it, which would defeat the per-message\n  // memoization in `areMessagePropsEqual`.\n  const actualOverrides: ComponentContextValue = useMemo(\n    () => ({\n      ...parentOverrides,\n      ...overrides,\n      // `icons` merges per slot rather than being replaced wholesale: a nested provider that\n      // rebrands one icon must not clear the ones an ancestor supplied.\n      icons: { ...parentOverrides?.icons, ...overrides?.icons },\n    }),\n    [parentOverrides, overrides],\n  );\n  return (\n    <ComponentContext.Provider value={actualOverrides}>\n      {children}\n    </ComponentContext.Provider>\n  );\n}\n"],"mappings":";;;;AAMA,SAAgB,eAAe,EAC7B,UACA,aACmE;CACnE,MAAM,kBAAkB,WAAW,gBAAgB;CAKnD,MAAM,kBAAyC,eACtC;EACL,GAAG;EACH,GAAG;EAGH,OAAO;GAAE,GAAG,iBAAiB;GAAO,GAAG,WAAW;EAAM;CAC1D,IACA,CAAC,iBAAiB,SAAS,CAC7B;CACA,OACE,oBAAC,iBAAiB,UAAlB;EAA2B,OAAO;EAC/B;CACwB,CAAA;AAE/B"}

package/dist/es/context/WorkspaceNavigationContext.mjs

@@ -0,0 +1,45 @@
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/context/WorkspaceNavigationContext.tsx
+var WorkspacePanelContext = createContext(void 0);
+/**
+* Declares the panel its subtree renders in. The layout provides it around each panel's content,
+* so controls inside (e.g. a header's back and close buttons) act on their own panel even when the
+* same channel or thread is open in more than one.
+*/
+var WorkspacePanelProvider = ({ children, panel }) => /* @__PURE__ */ jsx(WorkspacePanelContext.Provider, {
+	value: panel,
+	children
+});
+/** The panel the calling component renders in, or `undefined` outside one. */
+var useWorkspacePanel = () => useContext(WorkspacePanelContext);
+/** Inert no-op default (D2): used when no `slot-layout` plugin provides an implementation. */
+var defaultWorkspaceNavigation = {
+	canGoBack: () => false,
+	closeChannel: () => void 0,
+	closeThread: () => void 0,
+	goBack: () => void 0,
+	isChannelActive: () => false,
+	isChannelDismissable: () => false,
+	isThreadActive: () => false,
+	isThreadDismissable: () => false,
+	isThreadsView: false,
+	openChannel: () => void 0,
+	openChannels: [],
+	openThread: () => void 0,
+	openThreads: []
+};
+var WorkspaceNavigationContext = createContext(defaultWorkspaceNavigation);
+var WorkspaceNavigationProvider = ({ children, value }) => /* @__PURE__ */ jsx(WorkspaceNavigationContext.Provider, {
+	value,
+	children
+});
+/**
+* Access the workspace navigation abstraction. Returns the inert no-op default outside a
+* `slot-layout` provider, so callers can navigate unconditionally without guarding for a provider.
+*/
+var useWorkspaceNavigation = () => useContext(WorkspaceNavigationContext);
+//#endregion
+export { WorkspaceNavigationProvider, WorkspacePanelProvider, defaultWorkspaceNavigation, useWorkspaceNavigation, useWorkspacePanel };
+
+//# sourceMappingURL=WorkspaceNavigationContext.mjs.map

package/dist/es/context/WorkspaceNavigationContext.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkspaceNavigationContext.mjs","names":[],"sources":["../../../src/context/WorkspaceNavigationContext.tsx"],"sourcesContent":["import React, { createContext, useContext } from 'react';\n\nimport type { PropsWithChildren } from 'react';\nimport type {\n  LocalMessage,\n  Channel as StreamChannel,\n  Thread as StreamThread,\n} from 'stream-chat';\n\n/**\n * Target for {@link WorkspaceNavigation.openThread}: an existing thread instance, or the channel +\n * parent message from which one is derived.\n */\nexport type OpenThreadTarget =\n  | StreamThread\n  | { channel: StreamChannel; message: LocalMessage };\n\n/**\n * A DOM event that may have triggered a workspace navigation. Restricted to the React event types\n * that expose modifier keys (`metaKey`/`ctrlKey`/…) — the reason the event is forwarded at all — so\n * overrides can read them without narrowing. `PointerEvent`, `DragEvent`, and `WheelEvent` extend\n * `MouseEvent` and are accepted through it; `TouchEvent` and `KeyboardEvent` are the other carriers.\n */\nexport type WorkspaceNavigationTriggerEvent =\n  | React.MouseEvent\n  | React.KeyboardEvent\n  | React.TouchEvent;\n\n/** Identifies a panel of the workspace layout (for the slot layout, a slot name). */\nexport type WorkspacePanelId = string;\n\nconst WorkspacePanelContext = createContext<WorkspacePanelId | undefined>(undefined);\n\n/**\n * Declares the panel its subtree renders in. The layout provides it around each panel's content,\n * so controls inside (e.g. a header's back and close buttons) act on their own panel even when the\n * same channel or thread is open in more than one.\n */\nexport const WorkspacePanelProvider = ({\n  children,\n  panel,\n}: PropsWithChildren<{ panel?: WorkspacePanelId }>) => (\n  <WorkspacePanelContext.Provider value={panel}>\n    {children}\n  </WorkspacePanelContext.Provider>\n);\n\n/** The panel the calling component renders in, or `undefined` outside one. */\nexport const useWorkspacePanel = (): WorkspacePanelId | undefined =>\n  useContext(WorkspacePanelContext);\n\n/** Options shared by the workspace navigation operations. */\nexport type WorkspaceNavigationOptions = {\n  /**\n   * Open *beside* the current content (e.g. ctrl/⌘-click) instead of replacing it, when the active\n   * workspace layout has room for a secondary panel. Ignored in single-panel layouts.\n   */\n  additive?: boolean;\n  /**\n   * The DOM event that triggered the navigation, when there is one. Forwarded by the SDK components\n   * that initiate navigation from a user gesture (channel-list / search-result selection, …) so a\n   * consumer overriding these operations (e.g. via `ChatView`'s `deriveWorkspaceNavigation`) can read\n   * modifier keys — deciding `additive` from ⌘/ctrl-click — without tracking key state globally.\n   */\n  event?: WorkspaceNavigationTriggerEvent;\n  /**\n   * Open *over* the current content as a transient layer instead of replacing it; dismissing the\n   * entity restores what was beneath. Ignored by layouts that do not support layering.\n   */\n  layer?: boolean;\n  /**\n   * The panel the operation is triggered from (see {@link WorkspacePanelProvider}). Resolves which\n   * panel an entity is in when the same channel or thread is open in more than one; without it, the\n   * first panel showing the entity is used.\n   */\n  panel?: WorkspacePanelId;\n};\n\n/**\n * Slot-agnostic, intent-level navigation abstraction that core components depend on instead of the\n * ChatView slot system (D1). The `slot-layout` plugin implements it over its layout controller; with\n * no plugin installed the default is an inert no-op (D2) — core renders, navigation does nothing.\n */\nexport type WorkspaceNavigation = {\n  /**\n   * Whether the panel showing the channel or thread with `key` (a channel's `cid`, a thread's id)\n   * is stacked over other content that {@link WorkspaceNavigation.goBack} would reveal.\n   */\n  canGoBack: (key?: string, panel?: WorkspacePanelId) => boolean;\n  /**\n   * Dismiss the channel with `cid` from the workspace: close the panel showing it, together with\n   * anything stacked beneath it. Accepts the triggering event (see\n   * {@link WorkspaceNavigationOptions.event}).\n   */\n  closeChannel: (cid?: string, options?: WorkspaceNavigationOptions) => void;\n  /**\n   * Dismiss a thread from the workspace. With `threadId`, dismiss that thread's panel — together\n   * with anything stacked beneath it — otherwise the active thread panel. Does not deactivate the\n   * thread instance — the caller owns that. Accepts the triggering event (see\n   * {@link WorkspaceNavigationOptions.event}).\n   */\n  closeThread: (threadId?: string, options?: WorkspaceNavigationOptions) => void;\n  /**\n   * Step back from the channel or thread with `key`: remove it from the panel, revealing what it is\n   * stacked over. No-op when {@link WorkspaceNavigation.canGoBack} is false. Accepts the triggering\n   * event (see {@link WorkspaceNavigationOptions.event}).\n   */\n  goBack: (key?: string, options?: WorkspaceNavigationOptions) => void;\n  /**\n   * Whether the channel with `cid` is shown in the workspace: open in a panel and not covered by\n   * something stacked over it there.\n   */\n  isChannelActive: (cid?: string) => boolean;\n  /**\n   * Whether the channel panel for `cid` can be dismissed by the user — i.e. it is a secondary\n   * panel opened beside another channel, rather than the primary channel surface.\n   */\n  isChannelDismissable: (cid?: string, panel?: WorkspacePanelId) => boolean;\n  /**\n   * Whether the thread with `threadId` is shown in the workspace: open in a panel and not covered by\n   * something stacked over it there.\n   */\n  isThreadActive: (threadId?: string) => boolean;\n  /**\n   * Whether the thread panel for `threadId` (or the active thread) can be dismissed by the user —\n   * i.e. it is a closable side/secondary panel rather than the primary thread surface.\n   */\n  isThreadDismissable: (threadId?: string, panel?: WorkspacePanelId) => boolean;\n  /** Whether the thread-list (\"threads\") workspace view is the active one. */\n  isThreadsView: boolean;\n  /** Open `channel` in the workspace. */\n  openChannel: (channel: StreamChannel, options?: WorkspaceNavigationOptions) => void;\n  /** Channels currently open in the workspace (empty when none / no plugin). */\n  openChannels: StreamChannel[];\n  /** Open a thread — by instance, or derived from `{ channel, message }`. */\n  openThread: (target: OpenThreadTarget, options?: WorkspaceNavigationOptions) => void;\n  /** Threads currently open in the workspace (empty when none / no plugin). */\n  openThreads: StreamThread[];\n};\n\nconst NOOP_OPEN_CHANNELS: WorkspaceNavigation['openChannels'] = [];\nconst NOOP_OPEN_THREADS: WorkspaceNavigation['openThreads'] = [];\n\n/** Inert no-op default (D2): used when no `slot-layout` plugin provides an implementation. */\nexport const defaultWorkspaceNavigation: WorkspaceNavigation = {\n  canGoBack: () => false,\n  closeChannel: () => undefined,\n  closeThread: () => undefined,\n  goBack: () => undefined,\n  isChannelActive: () => false,\n  isChannelDismissable: () => false,\n  isThreadActive: () => false,\n  isThreadDismissable: () => false,\n  isThreadsView: false,\n  openChannel: () => undefined,\n  openChannels: NOOP_OPEN_CHANNELS,\n  openThread: () => undefined,\n  openThreads: NOOP_OPEN_THREADS,\n};\n\nconst WorkspaceNavigationContext = createContext<WorkspaceNavigation>(\n  defaultWorkspaceNavigation,\n);\n\nexport const WorkspaceNavigationProvider = ({\n  children,\n  value,\n}: PropsWithChildren<{ value: WorkspaceNavigation }>) => (\n  <WorkspaceNavigationContext.Provider value={value}>\n    {children}\n  </WorkspaceNavigationContext.Provider>\n);\n\n/**\n * Access the workspace navigation abstraction. Returns the inert no-op default outside a\n * `slot-layout` provider, so callers can navigate unconditionally without guarding for a provider.\n */\nexport const useWorkspaceNavigation = (): WorkspaceNavigation =>\n  useContext(WorkspaceNavigationContext);\n"],"mappings":";;;AA+BA,IAAM,wBAAwB,cAA4C,KAAA,CAAS;;;;;;AAOnF,IAAa,0BAA0B,EACrC,UACA,YAEA,oBAAC,sBAAsB,UAAvB;CAAgC,OAAO;CACpC;AAC6B,CAAA;;AAIlC,IAAa,0BACX,WAAW,qBAAqB;;AA+FlC,IAAa,6BAAkD;CAC7D,iBAAiB;CACjB,oBAAoB,KAAA;CACpB,mBAAmB,KAAA;CACnB,cAAc,KAAA;CACd,uBAAuB;CACvB,4BAA4B;CAC5B,sBAAsB;CACtB,2BAA2B;CAC3B,eAAe;CACf,mBAAmB,KAAA;CACnB,cAAc,CAAA;CACd,kBAAkB,KAAA;CAClB,aAAa,CAAA;AACf;AAEA,IAAM,6BAA6B,cACjC,0BACF;AAEA,IAAa,+BAA+B,EAC1C,UACA,YAEA,oBAAC,2BAA2B,UAA5B;CAA4C;CACzC;AACkC,CAAA;;;;;AAOvC,IAAa,+BACX,WAAW,0BAA0B"}

package/dist/es/context/requireContext.mjs

@@ -0,0 +1,17 @@
+//#region src/context/requireContext.ts
+/**
+* Guard for context hooks whose provider is mandatory: returns the value, or throws an error naming
+* the hook and the missing provider. Contexts with a meaningful default return that default
+* instead, so their components keep rendering outside a provider.
+*
+* Compares against `undefined` so a context legitimately holding `null`, `0` or `''` still counts
+* as present.
+*/
+var requireContext = (value, hookName, providerName) => {
+	if (value === void 0) throw new Error(`${hookName} was called outside of ${providerName}. Make sure the component calling ${hookName} is rendered within <${providerName}>.`);
+	return value;
+};
+//#endregion
+export { requireContext };
+
+//# sourceMappingURL=requireContext.mjs.map

package/dist/es/context/requireContext.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"requireContext.mjs","names":[],"sources":["../../../src/context/requireContext.ts"],"sourcesContent":["/**\n * Guard for context hooks whose provider is mandatory: returns the value, or throws an error naming\n * the hook and the missing provider. Contexts with a meaningful default return that default\n * instead, so their components keep rendering outside a provider.\n *\n * Compares against `undefined` so a context legitimately holding `null`, `0` or `''` still counts\n * as present.\n */\nexport const requireContext = <T>(\n  value: T | undefined,\n  hookName: string,\n  providerName: string,\n): T => {\n  if (value === undefined) {\n    throw new Error(\n      `${hookName} was called outside of ${providerName}. Make sure the component calling ` +\n        `${hookName} is rendered within <${providerName}>.`,\n    );\n  }\n\n  return value;\n};\n"],"mappings":";;;;;;;;;AAQA,IAAa,kBACX,OACA,UACA,iBACM;CACN,IAAI,UAAU,KAAA,GACZ,MAAM,IAAI,MACR,GAAG,SAAS,yBAAyB,aAAa,oCAC7C,SAAS,uBAAuB,aAAa,GACpD;CAGF,OAAO;AACT"}

package/dist/es/context/useChannel.mjs

@@ -0,0 +1,14 @@
+import { useChannelInstanceContext } from "./ChannelInstanceContext.mjs";
+import { useThreadContext } from "../components/Threads/ThreadContext.mjs";
+//#region src/context/useChannel.ts
+var useChannel = () => {
+	const channelFromThread = useThreadContext()?.channel;
+	const { channel: channelFromInstanceContext } = useChannelInstanceContext();
+	const channel = channelFromThread ?? channelFromInstanceContext;
+	if (!channel) throw new Error("The useChannel hook could not resolve a channel. Make sure this hook is called within a Thread subtree or within a child of Channel (ChannelInstanceContext provider).");
+	return channel;
+};
+//#endregion
+export { useChannel };
+
+//# sourceMappingURL=useChannel.mjs.map

package/dist/es/context/useChannel.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useChannel.mjs","names":[],"sources":["../../../src/context/useChannel.ts"],"sourcesContent":["import { useThreadContext } from '../components/Threads';\nimport { useChannelInstanceContext } from './ChannelInstanceContext';\n\nimport type { Channel } from 'stream-chat';\n\nexport const useChannel = (): Channel => {\n  const thread = useThreadContext();\n  const channelFromThread = thread?.channel;\n  const { channel: channelFromInstanceContext } = useChannelInstanceContext();\n  const channel = channelFromThread ?? channelFromInstanceContext;\n\n  if (!channel) {\n    throw new Error(\n      'The useChannel hook could not resolve a channel. Make sure this hook is called within a Thread subtree or within a child of Channel (ChannelInstanceContext provider).',\n    );\n  }\n\n  return channel;\n};\n"],"mappings":";;;AAKA,IAAa,mBAA4B;CAEvC,MAAM,oBADS,iBACW,CAAA,EAAQ;CAClC,MAAM,EAAE,SAAS,+BAA+B,0BAA0B;CAC1E,MAAM,UAAU,qBAAqB;CAErC,IAAI,CAAC,SACH,MAAM,IAAI,MACR,wKACF;CAGF,OAAO;AACT"}

package/dist/es/context/useComponentContextIcons.mjs

@@ -0,0 +1,26 @@
+import { useComponentContext } from "./ComponentContext.mjs";
+import { icons_exports } from "../components/Icons/icons.mjs";
+import { useMemo } from "react";
+//#region src/context/useComponentContextIcons.ts
+/**
+* Reads the `icons` override from `ComponentContext` and merges it over the SDK's own icons. Every
+* slot is guaranteed defined, so callers destructure without fallbacks:
+*
+* ```tsx
+* const { IconFlag } = useComponentContextIcons();
+* ```
+*
+* Overrides supplied via `<WithComponents overrides={{ icons: { … } }} />` win per slot; slots the
+* consumer did not provide fall back to the SDK icon.
+*/
+var useComponentContextIcons = () => {
+	const { icons } = useComponentContext();
+	return useMemo(() => ({
+		...icons_exports,
+		...Object.fromEntries(Object.entries(icons ?? {}).filter(([, Icon]) => !!Icon))
+	}), [icons]);
+};
+//#endregion
+export { useComponentContextIcons };
+
+//# sourceMappingURL=useComponentContextIcons.mjs.map

package/dist/es/context/useComponentContextIcons.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useComponentContextIcons.mjs","names":[],"sources":["../../../src/context/useComponentContextIcons.ts"],"sourcesContent":["import { useMemo } from 'react';\n\nimport { useComponentContext } from './ComponentContext';\nimport * as DEFAULT_ICONS from '../components/Icons/icons';\nimport type { IconSlots } from '../components/Icons/slots';\n\n/**\n * Reads the `icons` override from `ComponentContext` and merges it over the SDK's own icons. Every\n * slot is guaranteed defined, so callers destructure without fallbacks:\n *\n * ```tsx\n * const { IconFlag } = useComponentContextIcons();\n * ```\n *\n * Overrides supplied via `<WithComponents overrides={{ icons: { … } }} />` win per slot; slots the\n * consumer did not provide fall back to the SDK icon.\n */\nexport const useComponentContextIcons = (): Required<IconSlots> => {\n  const { icons } = useComponentContext();\n\n  // Keyed on `icons`, not on `[]`: `WithComponents` already memoizes the merged context value, so\n  // this identity is stable across renders and an override swapped at runtime is still picked up.\n  // Entries are filtered because a slot explicitly set to `undefined` must fall back to the SDK\n  // icon rather than spread a hole over it.\n  return useMemo(\n    () => ({\n      ...DEFAULT_ICONS,\n      ...Object.fromEntries(Object.entries(icons ?? {}).filter(([, Icon]) => !!Icon)),\n    }),\n    [icons],\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;AAiBA,IAAa,iCAAsD;CACjE,MAAM,EAAE,UAAU,oBAAoB;CAMtC,OAAO,eACE;EACL,GAAG;EACH,GAAG,OAAO,YAAY,OAAO,QAAQ,SAAS,CAAC,CAAC,CAAC,CAAC,QAAQ,GAAG,UAAU,CAAC,CAAC,IAAI,CAAC;CAChF,IACA,CAAC,KAAK,CACR;AACF"}