stream-chat-react 14.4.1 → 14.6.0

package/dist/es/channel-detail.mjs

@@ -0,0 +1,2950 @@
+import { $r as useChannelActionContext, Ar as useDialogIsOpen, Bn as IconUserAdd, Bt as IconDelete, Ft as IconChevronLeft, Gn as IconVideoFill, Hn as IconUserRemove, It as IconChevronRight, Lr as useStateStore, Mr as useDialogOnNearestManager, Qt as IconFolder, Vr as useComponentContext, Wr as useChatContext, Xr as useChannelListContext, Zn as Button, cn as IconMessageBubble, en as IconImage, gn as IconNoSign, hn as IconMute, jt as IconCheckmark, kn as IconSearch, mr as isDate, nn as IconLeave, pr as getDateString, qr as useChannelStateContext, r as useNotificationApi, sn as IconMenu, tn as IconInfo, ur as useTranslationContext, wt as IconAudio, yn as IconPin, zn as IconUser } from "./useNotificationApi.fa5cddf9.mjs";
+import { A as GalleryUI, B as FileIcon, Ct as LoadingIndicator, I as toBaseImageDescriptors, L as BaseImage, Q as ContextMenu, S as Checkbox, St as FileSizeIndicator, X as Prompt, Y as GlobalModal, _t as Alert, c as useIsUserMuted, dt as ChannelAvatar, f as isDmChannel, ft as Badge, k as Gallery, kt as useModalContext, l as useIsChannelMuted, mt as Avatar, n as useChannelHasMembersOnline, p as useChannelPreviewInfo, t as useChannelHeaderOnlineStatus, tt as ContextMenuButton, u as useChannelMembershipState, w as Switch, x as TextInput, xt as useStableCallback, y as ListItemLayout, z as formatTime } from "./useChannelHeaderOnlineStatus.c5215b13.mjs";
+import React, { createContext, forwardRef, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { ChannelMemberSearchSource, MessageSearchSource, UserSearchSource, isImageAttachment, isScrapedContent, isVideoAttachment } from "stream-chat";
+import clsx from "clsx";
+import debounce from "lodash.debounce";
+import uniqBy from "lodash.uniqby";
+import { GroupedVirtuoso, Virtuoso } from "react-virtuoso";
+//#region src/plugins/ChannelDetail/SectionNavigator/SectionNavigator.tsx
+var SECTION_NAVIGATOR_LAYOUT = {
+	inline: "inline",
+	tabs: "tabs"
+};
+var DEFAULT_TABS_LAYOUT_MIN_WIDTH = 640;
+var defaultCreateLayoutObserver = ({ element, setLayout, tabsLayoutMinWidth }) => {
+	if (typeof ResizeObserver === "undefined") return;
+	const observedElement = element.parentElement ?? element;
+	const updateLayout = (width) => {
+		if (width <= 0) return;
+		setLayout(width < tabsLayoutMinWidth ? SECTION_NAVIGATOR_LAYOUT.inline : SECTION_NAVIGATOR_LAYOUT.tabs);
+	};
+	const observer = new ResizeObserver(([entry]) => {
+		updateLayout(entry.contentRect.width);
+	});
+	updateLayout(observedElement.getBoundingClientRect().width);
+	observer.observe(observedElement);
+	return () => observer.disconnect();
+};
+var SectionNavigatorContext = createContext({
+	closeNavigation: () => void 0,
+	history: [],
+	historyPop: () => void 0,
+	historyPush: () => void 0,
+	isNavigationOpen: false,
+	layout: SECTION_NAVIGATOR_LAYOUT.tabs,
+	openNavigation: () => void 0
+});
+var useSectionNavigatorContext = () => useContext(SectionNavigatorContext);
+var getCurrentRoute = (history) => history[history.length - 1];
+var SectionNavigator = ({ className, createLayoutObserver = defaultCreateLayoutObserver, defaultLayout = SECTION_NAVIGATOR_LAYOUT.tabs, initialHistory, layout: controlledLayout, onLayoutChange, sections, tabsLayoutMinWidth = DEFAULT_TABS_LAYOUT_MIN_WIDTH, ...props }) => {
+	const rootRef = useRef(null);
+	const [internalLayout, setInternalLayout] = useState(defaultLayout);
+	const [history, setHistory] = useState(() => initialHistory ?? (sections[0] ? [{ id: sections[0].id }] : []));
+	const [isNavigationOpen, setIsNavigationOpen] = useState(false);
+	const layout = controlledLayout ?? internalLayout;
+	const currentRoute = getCurrentRoute(history);
+	const currentSection = sections.find((section) => section.id === currentRoute?.id);
+	const activeSection = currentSection ?? sections[0];
+	const isInlineLayout = layout === SECTION_NAVIGATOR_LAYOUT.inline;
+	const showDockedNavigation = !isInlineLayout || !currentSection;
+	const openNavigation = useCallback(() => setIsNavigationOpen(true), []);
+	const closeNavigation = useCallback(() => setIsNavigationOpen(false), []);
+	const historyPush = useCallback((route) => {
+		setHistory((history) => {
+			if (getCurrentRoute(history)?.id === route.id) return history;
+			if (layout === SECTION_NAVIGATOR_LAYOUT.tabs) return [route];
+			return [...history, route];
+		});
+	}, [layout]);
+	const historyPop = useCallback(() => {
+		setHistory((history) => history.length > 1 ? history.slice(0, -1) : history);
+	}, []);
+	useEffect(() => {
+		if (!isInlineLayout) setIsNavigationOpen(false);
+	}, [isInlineLayout]);
+	useEffect(() => {
+		if (!isNavigationOpen) return;
+		const handleKeyDown = (event) => {
+			if (event.key === "Escape") closeNavigation();
+		};
+		document.addEventListener("keydown", handleKeyDown);
+		return () => document.removeEventListener("keydown", handleKeyDown);
+	}, [closeNavigation, isNavigationOpen]);
+	useEffect(() => {
+		onLayoutChange?.(layout);
+	}, [layout, onLayoutChange]);
+	useEffect(() => {
+		if (controlledLayout) return;
+		if (!rootRef.current) return;
+		return createLayoutObserver({
+			element: rootRef.current,
+			setLayout: setInternalLayout,
+			tabsLayoutMinWidth
+		});
+	}, [
+		controlledLayout,
+		createLayoutObserver,
+		tabsLayoutMinWidth
+	]);
+	useEffect(() => {
+		setHistory((history) => {
+			const currentRoute = getCurrentRoute(history);
+			const currentRouteHasSection = sections.some((section) => section.id === currentRoute?.id);
+			if (!currentRoute) return sections[0] ? [{ id: sections[0].id }] : [];
+			if (currentRouteHasSection) return history;
+			return sections[0] ? [{ id: sections[0].id }] : [];
+		});
+	}, [sections]);
+	const contextValue = useMemo(() => ({
+		closeNavigation,
+		history,
+		historyPop,
+		historyPush,
+		isNavigationOpen,
+		layout,
+		openNavigation
+	}), [
+		closeNavigation,
+		history,
+		historyPop,
+		historyPush,
+		isNavigationOpen,
+		layout,
+		openNavigation
+	]);
+	const Content = activeSection?.SectionContent;
+	const navigation = /* @__PURE__ */ jsx("div", {
+		className: "str-chat__section-navigator__navigation",
+		children: sections.map((section) => {
+			const NavButton = section.NavButton;
+			const selected = activeSection?.id === section.id;
+			return /* @__PURE__ */ jsx("div", {
+				className: "str-chat__section-navigator__navigation-item",
+				children: /* @__PURE__ */ jsx(NavButton, {
+					className: "str-chat__section-navigator__navigation-item__nav-button",
+					sectionId: section.id,
+					select: () => {
+						historyPush({ id: section.id });
+						closeNavigation();
+					},
+					selected
+				})
+			}, section.id);
+		})
+	});
+	return /* @__PURE__ */ jsx(SectionNavigatorContext.Provider, {
+		value: contextValue,
+		children: /* @__PURE__ */ jsxs("div", {
+			className: clsx("str-chat__section-navigator", className, { "str-chat__section-navigator--inline": isInlineLayout }),
+			"data-layout": layout,
+			ref: rootRef,
+			...props,
+			children: [
+				showDockedNavigation && navigation,
+				Content && /* @__PURE__ */ jsx("div", {
+					className: "str-chat__section-navigator__content",
+					children: /* @__PURE__ */ jsx(Content, { layout })
+				}),
+				isInlineLayout && /* @__PURE__ */ jsxs("div", {
+					className: clsx("str-chat__section-navigator__navigation-overlay", { "str-chat__section-navigator__navigation-overlay--open": isNavigationOpen }),
+					children: [/* @__PURE__ */ jsx("button", {
+						"aria-hidden": true,
+						className: "str-chat__section-navigator__navigation-scrim",
+						onClick: closeNavigation,
+						tabIndex: -1,
+						type: "button"
+					}), /* @__PURE__ */ jsx("div", {
+						className: "str-chat__section-navigator__navigation-drawer",
+						children: navigation
+					})]
+				})
+			]
+		})
+	});
+};
+//#endregion
+//#region src/plugins/ChannelDetail/SectionNavigator/SectionNavigatorHeader.tsx
+/**
+* Generic header for content rendered inside a `SectionNavigator`. It renders a
+* `Prompt.Header` and, in the inline layout (where the navigation sidebar is not
+* shown), prepends a hamburger button that opens the navigation drawer. The
+* hamburger is omitted on nested views that already show a back button
+* (`goBack`), where it would compete with the back affordance.
+*/
+var SectionNavigatorHeader = (props) => {
+	const { t } = useTranslationContext("SectionNavigatorHeader");
+	const { layout, openNavigation } = useSectionNavigatorContext();
+	const MenuButton = useMemo(() => {
+		if (layout !== SECTION_NAVIGATOR_LAYOUT.inline) return void 0;
+		if (props.goBack) return void 0;
+		return function SectionNavigatorHeaderMenuButton() {
+			return /* @__PURE__ */ jsx(Button, {
+				appearance: "ghost",
+				"aria-label": t("Open menu"),
+				circular: true,
+				className: "str-chat__section-navigator__header-menu-button",
+				onClick: openNavigation,
+				size: "md",
+				variant: "secondary",
+				children: /* @__PURE__ */ jsx(IconMenu, {})
+			});
+		};
+	}, [
+		layout,
+		openNavigation,
+		props.goBack,
+		t
+	]);
+	return /* @__PURE__ */ jsx(Prompt.Header, {
+		...props,
+		LeadingContent: MenuButton
+	});
+};
+//#endregion
+//#region src/plugins/ChannelDetail/ChannelDetailNavButton.tsx
+/**
+* Underlying button shared by all ChannelDetail section nav buttons. Renders a
+* `ListItemLayout` as a `<button>` and wires the SectionNavigator selection
+* state into `aria-current` and the click handler.
+*/
+var ChannelDetailNavButton = ({ className, LeadingIcon, sectionId: _sectionId, select, selected, title, ...props }) => /* @__PURE__ */ jsx(ListItemLayout, {
+	LeadingIcon,
+	RootElement: "button",
+	rootProps: {
+		...props,
+		"aria-current": selected ? "page" : void 0,
+		className: clsx("str-chat__channel-detail__nav-button", className),
+		onClick: select
+	},
+	selected,
+	title
+});
+//#endregion
+//#region src/plugins/ChannelDetail/ChannelDetailContext.tsx
+var ChannelDetailContext = React.createContext(void 0);
+var ChannelDetailProvider = ({ channel, children }) => {
+	const value = useMemo(() => ({ channel }), [channel]);
+	return /* @__PURE__ */ jsx(ChannelDetailContext.Provider, {
+		value,
+		children
+	});
+};
+var useChannelDetailContext = () => {
+	const contextValue = useContext(ChannelDetailContext);
+	if (!contextValue) throw new Error("The useChannelDetailContext hook was called outside of ChannelDetailProvider.");
+	return contextValue;
+};
+//#endregion
+//#region src/plugins/ChannelDetail/Views/ChannelFilesView/ChannelFilesEmptyList.tsx
+var ChannelFilesEmptyList = () => {
+	const { t } = useTranslationContext("ChannelFilesEmptyList");
+	return /* @__PURE__ */ jsxs("div", {
+		className: "str-chat__channel-detail__files-view__empty-state",
+		children: [/* @__PURE__ */ jsx(IconFolder, { className: "str-chat__channel-detail__files-view__empty-state__icon" }), /* @__PURE__ */ jsxs("div", {
+			className: "str-chat__channel-detail__files-view__empty-state__content",
+			children: [/* @__PURE__ */ jsx("p", {
+				className: "str-chat__channel-detail__files-view__empty-state__title",
+				children: t("No files")
+			}), /* @__PURE__ */ jsx("p", {
+				className: "str-chat__channel-detail__files-view__empty-state__description",
+				children: t("Share a file to see it here")
+			})]
+		})]
+	});
+};
+//#endregion
+//#region src/plugins/ChannelDetail/ChannelDetailListLoadingIndicator.tsx
+var searchSourceFooterStateSelector = (state) => ({
+	hasNextPage: state.hasNext,
+	isLoading: state.isLoading
+});
+var ChannelDetailListLoadingIndicator = ({ searchSource }) => {
+	const { hasNextPage, isLoading } = useStateStore(searchSource.state, searchSourceFooterStateSelector);
+	if (!hasNextPage || !isLoading) return null;
+	return /* @__PURE__ */ jsx("div", {
+		className: "str-chat__loading-indicator-placeholder",
+		children: isLoading && /* @__PURE__ */ jsx(LoadingIndicator, {})
+	});
+};
+//#endregion
+//#region src/plugins/ChannelDetail/Views/ChannelFilesView/ChannelFilesView.utils.ts
+/** Attachment types listed by the files view (everything that is not an image/video). */
+var FILE_ATTACHMENT_TYPES = ["file", "audio"];
+var FILE_ATTACHMENT_TYPE_SET = new Set(FILE_ATTACHMENT_TYPES);
+var normalizeTimestamp$1 = (timestamp) => {
+	if (!timestamp) return void 0;
+	return isDate(timestamp) ? timestamp.toISOString() : timestamp;
+};
+var isChannelFileAttachment = (attachment) => !isScrapedContent(attachment) && !!attachment.type && FILE_ATTACHMENT_TYPE_SET.has(attachment.type);
+var byCreatedAtDesc = (a, b) => (b.createdAt ?? "").localeCompare(a.createdAt ?? "");
+/**
+* Flattens messages into file/audio attachment items organized into descending
+* month/year sections (newest first), in a single pass over the attachments.
+*
+* The result is shaped for GroupedVirtuoso: a single flat `items` array (items
+* grouped contiguously by section) plus `groupCounts`/`sections` aligned with
+* it, so the view never has to re-flatten. The raw attachment is kept
+* untransformed; only the carrying message timestamp is captured for headers.
+*/
+var toChannelFileSections = (messages) => {
+	const groups = [];
+	const groupIndexByKey = /* @__PURE__ */ new Map();
+	messages.forEach((message) => {
+		const createdAt = normalizeTimestamp$1(message.created_at);
+		const key = createdAt ? createdAt.slice(0, 7) : "unknown";
+		message.attachments?.forEach((attachment, index) => {
+			if (!isChannelFileAttachment(attachment)) return;
+			const item = {
+				attachment,
+				createdAt,
+				id: `${message.id}-${index}`
+			};
+			const existingIndex = groupIndexByKey.get(key);
+			if (existingIndex === void 0) {
+				groupIndexByKey.set(key, groups.length);
+				groups.push({
+					items: [item],
+					key,
+					timestamp: createdAt
+				});
+			} else groups[existingIndex].items.push(item);
+		});
+	});
+	groups.forEach((group) => {
+		group.items.sort(byCreatedAtDesc);
+		group.timestamp = group.items[0]?.createdAt;
+	});
+	groups.sort((a, b) => (b.timestamp ?? "").localeCompare(a.timestamp ?? ""));
+	return {
+		groupCounts: groups.map((group) => group.items.length),
+		items: groups.flatMap((group) => group.items),
+		sections: groups.map(({ key, timestamp }) => ({
+			key,
+			timestamp
+		}))
+	};
+};
+//#endregion
+//#region src/plugins/ChannelDetail/Views/ChannelFilesView/useChannelFilesSearch.ts
+var CHANNEL_FILES_SEARCH_PAGE_SIZE = 30;
+var channelFilesSearchSourceStateSelector = (state) => ({
+	isLoading: state.isLoading,
+	messages: state.items
+});
+var useChannelFilesSearch = () => {
+	const { client } = useChatContext();
+	const { channel } = useChannelDetailContext();
+	const channelFilesSearchSource = useMemo(() => {
+		const source = new MessageSearchSource(client, {
+			allowEmptySearchString: true,
+			pageSize: CHANNEL_FILES_SEARCH_PAGE_SIZE,
+			resetOnNewSearchQuery: false
+		});
+		source.messageSearchChannelFilters = { cid: channel.cid };
+		source.messageSearchFilters = { "attachments.type": { $in: [...FILE_ATTACHMENT_TYPES] } };
+		return source;
+	}, [channel.cid, client]);
+	const { isLoading, messages } = useStateStore(channelFilesSearchSource.state, channelFilesSearchSourceStateSelector);
+	const { groupCounts, items, sections } = useMemo(() => toChannelFileSections(messages ?? []), [messages]);
+	useEffect(() => {
+		channelFilesSearchSource.activate();
+		channelFilesSearchSource.search("");
+		return () => {
+			channelFilesSearchSource.cancelScheduledQuery();
+		};
+	}, [channelFilesSearchSource]);
+	return {
+		channelFilesSearchSource,
+		fileItems: items,
+		groupCounts,
+		hasResultsLoaded: Array.isArray(messages),
+		isLoading,
+		sections
+	};
+};
+//#endregion
+//#region src/plugins/ChannelDetail/Views/ChannelFilesView/ChannelFilesView.tsx
+var ChannelFilesItem = forwardRef(function ChannelFilesItem({ className, ...props }, ref) {
+	return /* @__PURE__ */ jsx("div", {
+		...props,
+		className: clsx("str-chat__channel-detail__files-view__item", className),
+		ref
+	});
+});
+var ChannelFilesGroup = forwardRef(function ChannelFilesGroup({ className, ...props }, ref) {
+	return /* @__PURE__ */ jsx("div", {
+		...props,
+		className: clsx("str-chat__channel-detail__files-view__group", className),
+		ref
+	});
+});
+var ChannelFilesSectionHeader = ({ timestamp }) => {
+	const { t, tDateTimeParser } = useTranslationContext("ChannelFilesView");
+	const label = getDateString({
+		format: "MMMM YYYY",
+		messageCreatedAt: timestamp,
+		t,
+		tDateTimeParser
+	});
+	if (!label) return null;
+	return /* @__PURE__ */ jsx("div", {
+		className: "str-chat__channel-detail__files-view__section-header",
+		children: label
+	});
+};
+var getAttachmentFileName = (attachment) => attachment.title || attachment.fallback || "";
+var ChannelFileListItem = ({ item }) => {
+	const { attachment } = item;
+	const fileName = getAttachmentFileName(attachment);
+	const assetUrl = attachment.asset_url;
+	const LeadingSlot = useMemo(() => function FileListItemIcon() {
+		return /* @__PURE__ */ jsx(FileIcon, {
+			className: "str-chat__channel-detail__files-view__list-item__icon",
+			fileName,
+			mimeType: attachment.mime_type,
+			size: "md"
+		});
+	}, [attachment.mime_type, fileName]);
+	const sharedProps = useMemo(() => ({
+		LeadingSlot,
+		subtitle: /* @__PURE__ */ jsx(FileSizeIndicator, { fileSize: attachment.file_size }),
+		subtitleClassName: "str-chat__channel-detail__files-view__list-item__size",
+		title: fileName,
+		titleClassName: "str-chat__channel-detail__files-view__list-item__name"
+	}), [
+		attachment.file_size,
+		fileName,
+		LeadingSlot
+	]);
+	const linkRootProps = useMemo(() => ({
+		className: "str-chat__channel-detail__files-view__list-item",
+		download: fileName || void 0,
+		href: assetUrl,
+		rel: "noopener noreferrer",
+		target: "_blank"
+	}), [assetUrl, fileName]);
+	const divRootProps = useMemo(() => ({ className: "str-chat__channel-detail__files-view__list-item" }), []);
+	if (assetUrl) return /* @__PURE__ */ jsx(ListItemLayout, {
+		...sharedProps,
+		RootElement: "a",
+		rootProps: linkRootProps
+	});
+	return /* @__PURE__ */ jsx(ListItemLayout, {
+		...sharedProps,
+		RootElement: "div",
+		rootProps: divRootProps
+	});
+};
+var ChannelFilesView = () => {
+	const { t } = useTranslationContext();
+	const { close } = useModalContext();
+	const { channelFilesSearchSource, fileItems, groupCounts, hasResultsLoaded, sections } = useChannelFilesSearch();
+	const groupContent = useCallback((groupIndex) => /* @__PURE__ */ jsx(ChannelFilesSectionHeader, { timestamp: sections[groupIndex]?.timestamp }), [sections]);
+	const itemContent = useCallback((index) => /* @__PURE__ */ jsx(ChannelFileListItem, { item: fileItems[index] }), [fileItems]);
+	const atBottomStateChange = useCallback((atBottom) => {
+		if (atBottom) channelFilesSearchSource.search();
+	}, [channelFilesSearchSource]);
+	const EmptyPlaceholder = useMemo(() => function ChannelFilesEmptyPlaceholder() {
+		return hasResultsLoaded ? /* @__PURE__ */ jsx(ChannelFilesEmptyList, {}) : null;
+	}, [hasResultsLoaded]);
+	const Footer = useMemo(() => function ChannelFilesListFooter() {
+		return /* @__PURE__ */ jsx(ChannelDetailListLoadingIndicator, { searchSource: channelFilesSearchSource });
+	}, [channelFilesSearchSource]);
+	const components = useMemo(() => ({
+		EmptyPlaceholder,
+		Footer,
+		Group: ChannelFilesGroup,
+		Item: ChannelFilesItem
+	}), [EmptyPlaceholder, Footer]);
+	return /* @__PURE__ */ jsxs("div", {
+		className: "str-chat__channel-detail__files-view",
+		children: [/* @__PURE__ */ jsx(SectionNavigatorHeader, {
+			close,
+			title: t("Files")
+		}), /* @__PURE__ */ jsx(Prompt.Body, {
+			className: "str-chat__channel-detail__files-view__body",
+			children: /* @__PURE__ */ jsx(GroupedVirtuoso, {
+				atBottomStateChange,
+				className: "str-chat__virtualized-list str-chat__channel-detail__files-view__list",
+				components,
+				groupContent,
+				groupCounts,
+				itemContent
+			})
+		})]
+	});
+};
+//#endregion
+//#region src/plugins/ChannelDetail/Views/ChannelManagementView/ChannelManagementActions.defaults.tsx
+var toError$1 = (error) => error instanceof Error ? error : /* @__PURE__ */ new Error("An unknown error occurred");
+var getDisplayName = (name, fallback) => name || fallback || "";
+var BlockUserActionIcon$1 = () => /* @__PURE__ */ jsx(IconNoSign, { className: "str-chat__icon--destructive str-chat__channel-detail__action-icon str-chat__channel-detail__action-icon--block-user" });
+var DeleteChatActionIcon = () => /* @__PURE__ */ jsx(IconDelete, { className: "str-chat__icon--destructive str-chat__channel-detail__action-icon str-chat__channel-detail__action-icon--delete-chat" });
+var MuteActionIcon = () => /* @__PURE__ */ jsx(IconMute, { className: "str-chat__channel-detail__action-icon str-chat__channel-detail__action-icon--mute" });
+var MutedActionIcon = () => /* @__PURE__ */ jsx(IconAudio, { className: "str-chat__channel-detail__action-icon str-chat__channel-detail__action-icon--unmute" });
+var LeaveChannelActionIcon = () => /* @__PURE__ */ jsx(IconLeave, { className: "str-chat__icon--destructive str-chat__channel-detail__action-icon str-chat__channel-detail__action-icon--leave-channel" });
+var channelManagementViewActionClassName = "str-chat__channel-management-view-action";
+var blockedUsersSelector$1 = ({ userIds }) => ({ userIds });
+var ChannelManagementConfirmationAlert = ({ action, cancelLabel, confirmLabel, description, isSubmitting, onCancel, onConfirm, testId, title }) => /* @__PURE__ */ jsxs(Alert.Root, {
+	className: clsx("str-chat__channel-management-confirmation-alert", { [`str-chat__channel-management-confirmation-alert--${action}`]: action }),
+	"data-testid": testId,
+	children: [/* @__PURE__ */ jsx(Alert.Header, {
+		description,
+		title
+	}), /* @__PURE__ */ jsxs(Alert.Actions, { children: [/* @__PURE__ */ jsx(Button, {
+		appearance: "solid",
+		"data-testid": `${testId}-confirm-button`,
+		disabled: isSubmitting,
+		onClick: onConfirm,
+		size: "md",
+		variant: "danger",
+		children: confirmLabel
+	}), /* @__PURE__ */ jsx(Button, {
+		appearance: "outline",
+		autoFocus: true,
+		"data-testid": `${testId}-cancel-button`,
+		disabled: isSubmitting,
+		onClick: onCancel,
+		size: "md",
+		variant: "secondary",
+		children: cancelLabel
+	})] })]
+});
+var useOtherMember = () => {
+	const { client } = useChatContext();
+	const { channel } = useChannelDetailContext();
+	return useMemo(() => {
+		const stateMembers = Object.values(channel.state?.members ?? {});
+		return (stateMembers.length ? stateMembers : channel.data?.members ?? []).find((member) => member.user?.id && member.user.id !== client.user?.id);
+	}, [channel, client.user?.id]);
+};
+var useChannelManagementActionFilterState = () => {
+	const { client } = useChatContext();
+	const { channel } = useChannelDetailContext();
+	const otherMember = useOtherMember();
+	const resolvedIsDmChannel = isDmChannel({
+		channel,
+		ownUserId: client.user?.id
+	});
+	const isGroupChannel = !resolvedIsDmChannel;
+	const ownCapabilities = channel.data?.own_capabilities;
+	const isDmChannelWithOtherUser = resolvedIsDmChannel && !!otherMember;
+	return {
+		canBlockUser: isDmChannelWithOtherUser && ownCapabilities?.includes("ban-channel-members"),
+		canDeleteChat: ownCapabilities?.includes("delete-channel"),
+		canLeaveChannel: isGroupChannel && ownCapabilities?.includes("leave-channel"),
+		canMuteChannel: ownCapabilities?.includes("mute-channel"),
+		canMuteUser: isDmChannelWithOtherUser
+	};
+};
+var useBaseChannelManagementActionSetFilter = (channelManagementActionSet) => {
+	const { canBlockUser, canDeleteChat, canLeaveChannel, canMuteChannel, canMuteUser } = useChannelManagementActionFilterState();
+	return useMemo(() => channelManagementActionSet.filter((action) => {
+		switch (action.type) {
+			case "blockUser": return canBlockUser;
+			case "deleteChat": return canDeleteChat;
+			case "muteChannel": return canMuteChannel;
+			case "muteUser": return canMuteUser;
+			case "leaveChannel": return canLeaveChannel;
+			default: return true;
+		}
+	}), [
+		canBlockUser,
+		canDeleteChat,
+		canLeaveChannel,
+		canMuteChannel,
+		canMuteUser,
+		channelManagementActionSet
+	]);
+};
+var ChannelMuteAction = () => {
+	const { channel } = useChannelDetailContext();
+	const { addNotification } = useNotificationApi();
+	const { t } = useTranslationContext();
+	const { muted: channelMuted } = useIsChannelMuted(channel);
+	const [optimisticChannelMuted, setOptimisticChannelMuted] = useState(channelMuted);
+	useEffect(() => {
+		setOptimisticChannelMuted(channelMuted);
+	}, [channelMuted]);
+	const toggleChannelMuteRequest = useStableCallback((nextMuted, targetChannel) => {
+		if (!nextMuted) return targetChannel.unmute().then(() => addNotification({
+			context: { channel: targetChannel },
+			emitter: "ChannelManagementView",
+			message: t("Channel unmuted"),
+			severity: "success",
+			type: "api:channel:unmute:success"
+		})).catch((error) => {
+			setOptimisticChannelMuted(channelMuted);
+			return addNotification({
+				context: { channel: targetChannel },
+				emitter: "ChannelManagementView",
+				error: toError$1(error),
+				message: t("Error unmuting channel"),
+				severity: "error",
+				type: "api:channel:unmute:failed"
+			});
+		});
+		return targetChannel.mute().then(() => addNotification({
+			context: { channel: targetChannel },
+			emitter: "ChannelManagementView",
+			message: t("Channel muted"),
+			severity: "success",
+			type: "api:channel:mute:success"
+		})).catch((error) => {
+			setOptimisticChannelMuted(channelMuted);
+			return addNotification({
+				context: { channel: targetChannel },
+				emitter: "ChannelManagementView",
+				error: toError$1(error),
+				message: t("Error muting channel"),
+				severity: "error",
+				type: "api:channel:mute:failed"
+			});
+		});
+	});
+	const toggleChannelMute = useMemo(() => debounce(toggleChannelMuteRequest, 1e3), [toggleChannelMuteRequest]);
+	useEffect(() => () => {
+		toggleChannelMute.cancel();
+	}, [toggleChannelMute]);
+	const toggleOptimisticChannelMute = useCallback(() => {
+		const nextMuted = !optimisticChannelMuted;
+		setOptimisticChannelMuted(nextMuted);
+		toggleChannelMute(nextMuted, channel);
+	}, [
+		channel,
+		optimisticChannelMuted,
+		toggleChannelMute
+	]);
+	const rootProps = useMemo(() => ({
+		"aria-pressed": optimisticChannelMuted,
+		className: clsx("str-chat__form__switch-field", channelManagementViewActionClassName),
+		onClick: toggleOptimisticChannelMute
+	}), [optimisticChannelMuted, toggleOptimisticChannelMute]);
+	const TrailingSlot = useMemo(() => {
+		function ChannelMuteSwitch() {
+			return /* @__PURE__ */ jsx(Switch, {
+				on: optimisticChannelMuted,
+				presentation: true
+			});
+		}
+		return ChannelMuteSwitch;
+	}, [optimisticChannelMuted]);
+	return /* @__PURE__ */ jsx(ListItemLayout, {
+		LeadingIcon: optimisticChannelMuted ? MutedActionIcon : MuteActionIcon,
+		RootElement: "button",
+		rootProps,
+		title: optimisticChannelMuted ? t("Unmute chat") : t("Mute chat"),
+		TrailingSlot
+	});
+};
+var UserMuteAction$1 = () => {
+	const { client, mutes } = useChatContext();
+	const { channel } = useChannelDetailContext();
+	const { addNotification } = useNotificationApi();
+	const { t } = useTranslationContext();
+	const otherMember = useOtherMember();
+	const userMuted = !!mutes.find((mute) => mute.target.id === otherMember?.user?.id);
+	const [optimisticUserMuted, setOptimisticUserMuted] = useState(userMuted);
+	useEffect(() => {
+		setOptimisticUserMuted(userMuted);
+	}, [userMuted]);
+	const otherMemberUserId = otherMember?.user?.id;
+	const toggleUserMuteRequest = useStableCallback((nextMuted, targetUserId) => {
+		if (!targetUserId) return;
+		if (!nextMuted) return client.unmuteUser(targetUserId).then(() => addNotification({
+			context: { channel },
+			emitter: "ChannelManagementView",
+			message: t("User unmuted"),
+			severity: "success",
+			type: "api:user:unmute:success"
+		})).catch((error) => {
+			setOptimisticUserMuted(userMuted);
+			return addNotification({
+				context: { channel },
+				emitter: "ChannelManagementView",
+				error: toError$1(error),
+				message: t("Error unmuting user"),
+				severity: "error",
+				type: "api:user:unmute:failed"
+			});
+		});
+		return client.muteUser(targetUserId).then(() => addNotification({
+			context: { channel },
+			emitter: "ChannelManagementView",
+			message: t("User muted"),
+			severity: "success",
+			type: "api:user:mute:success"
+		})).catch((error) => {
+			setOptimisticUserMuted(userMuted);
+			return addNotification({
+				context: { channel },
+				emitter: "ChannelManagementView",
+				error: toError$1(error),
+				message: t("Error muting user"),
+				severity: "error",
+				type: "api:user:mute:failed"
+			});
+		});
+	});
+	const toggleUserMute = useMemo(() => debounce(toggleUserMuteRequest, 1e3), [toggleUserMuteRequest]);
+	useEffect(() => () => {
+		toggleUserMute.cancel();
+	}, [toggleUserMute]);
+	const toggleOptimisticUserMute = useCallback(() => {
+		const nextMuted = !optimisticUserMuted;
+		setOptimisticUserMuted(nextMuted);
+		toggleUserMute(nextMuted, otherMemberUserId);
+	}, [
+		optimisticUserMuted,
+		otherMemberUserId,
+		toggleUserMute
+	]);
+	const rootProps = useMemo(() => ({
+		"aria-pressed": optimisticUserMuted,
+		className: clsx("str-chat__form__switch-field", channelManagementViewActionClassName),
+		onClick: toggleOptimisticUserMute
+	}), [optimisticUserMuted, toggleOptimisticUserMute]);
+	const TrailingSlot = useMemo(() => {
+		function UserMuteSwitch() {
+			return /* @__PURE__ */ jsx(Switch, {
+				on: optimisticUserMuted,
+				presentation: true
+			});
+		}
+		return UserMuteSwitch;
+	}, [optimisticUserMuted]);
+	return /* @__PURE__ */ jsx(ListItemLayout, {
+		LeadingIcon: optimisticUserMuted ? MutedActionIcon : MuteActionIcon,
+		RootElement: "button",
+		rootProps,
+		title: optimisticUserMuted ? t("Unmute user") : t("Mute user"),
+		TrailingSlot
+	});
+};
+var BlockUserAction$1 = () => {
+	const { client } = useChatContext();
+	const { Modal = GlobalModal } = useComponentContext();
+	const { channel } = useChannelDetailContext();
+	const { addNotification } = useNotificationApi();
+	const { t } = useTranslationContext();
+	const targetUserId = useOtherMember()?.user?.id;
+	const { userIds: blockedUserIds } = useStateStore(client.blockedUsers, blockedUsersSelector$1);
+	const isBlocked = useMemo(() => !!targetUserId && new Set(blockedUserIds).has(targetUserId), [blockedUserIds, targetUserId]);
+	const [alertOpen, setAlertOpen] = useState(false);
+	const [userBlockInProgress, setUserBlockInProgress] = useState(false);
+	const closeBlockUserAlert = useCallback(() => {
+		setAlertOpen(false);
+	}, []);
+	const openBlockUserAlert = useCallback(() => {
+		setAlertOpen(true);
+	}, []);
+	const unblockUser = useCallback(async () => {
+		if (!targetUserId) return;
+		try {
+			setUserBlockInProgress(true);
+			await client.unBlockUser(targetUserId);
+			addNotification({
+				context: { channel },
+				emitter: "ChannelManagementView",
+				message: t("User unblocked"),
+				severity: "success",
+				type: "api:user:unblock:success"
+			});
+		} catch (error) {
+			addNotification({
+				context: { channel },
+				emitter: "ChannelManagementView",
+				error: toError$1(error),
+				message: t("Error unblocking user"),
+				severity: "error",
+				type: "api:user:unblock:failed"
+			});
+		} finally {
+			setAlertOpen(false);
+			setUserBlockInProgress(false);
+		}
+	}, [
+		addNotification,
+		channel,
+		client,
+		targetUserId,
+		t
+	]);
+	const blockUser = useCallback(async () => {
+		if (!targetUserId) return;
+		try {
+			setUserBlockInProgress(true);
+			await client.blockUser(targetUserId);
+			addNotification({
+				context: { channel },
+				emitter: "ChannelManagementView",
+				message: t("User blocked"),
+				severity: "success",
+				type: "api:user:block:success"
+			});
+		} catch (error) {
+			addNotification({
+				context: { channel },
+				emitter: "ChannelManagementView",
+				error: toError$1(error),
+				message: t("Error blocking user"),
+				severity: "error",
+				type: "api:user:block:failed"
+			});
+		} finally {
+			setAlertOpen(false);
+			setUserBlockInProgress(false);
+		}
+	}, [
+		addNotification,
+		channel,
+		client,
+		targetUserId,
+		t
+	]);
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(ListItemLayout, {
+		destructive: true,
+		LeadingIcon: BlockUserActionIcon$1,
+		RootElement: "button",
+		rootProps: useMemo(() => ({
+			className: channelManagementViewActionClassName,
+			disabled: userBlockInProgress,
+			onClick: openBlockUserAlert
+		}), [openBlockUserAlert, userBlockInProgress]),
+		title: isBlocked ? t("Unblock") : t("Block user")
+	}), /* @__PURE__ */ jsx(Modal, {
+		open: alertOpen,
+		role: "alertdialog",
+		children: /* @__PURE__ */ jsx(ChannelManagementConfirmationAlert, {
+			action: "blockUser",
+			cancelLabel: t("Cancel"),
+			confirmLabel: isBlocked ? t("Unblock") : t("Block User"),
+			description: isBlocked ? t("This user will be able to message you again.") : t("This user won't be able to message you anymore. You can unblock them anytime."),
+			isSubmitting: userBlockInProgress,
+			onCancel: closeBlockUserAlert,
+			onConfirm: isBlocked ? unblockUser : blockUser,
+			testId: "channel-detail-block-user-alert",
+			title: isBlocked ? t("Unblock") : t("Block User")
+		})
+	})] });
+};
+var LeaveChannelAction = () => {
+	const { client } = useChatContext();
+	const { channel } = useChannelDetailContext();
+	const { Modal = GlobalModal } = useComponentContext();
+	const { close } = useModalContext();
+	const { addNotification } = useNotificationApi();
+	const { t } = useTranslationContext();
+	const [alertOpen, setAlertOpen] = useState(false);
+	const [leaveChannelInProgress, setLeaveChannelInProgress] = useState(false);
+	const closeLeaveChannelAlert = useCallback(() => {
+		setAlertOpen(false);
+	}, []);
+	const openLeaveChannelAlert = useCallback(() => {
+		setAlertOpen(true);
+	}, []);
+	const leaveChannel = useCallback(async () => {
+		if (!client.userID) return;
+		try {
+			setLeaveChannelInProgress(true);
+			await channel.removeMembers([client.userID]);
+			addNotification({
+				context: { channel },
+				emitter: "ChannelManagementView",
+				message: t("Left channel"),
+				severity: "success",
+				type: "api:channel:leave:success"
+			});
+			setAlertOpen(false);
+			close();
+		} catch (error) {
+			addNotification({
+				context: { channel },
+				emitter: "ChannelManagementView",
+				error: toError$1(error),
+				message: t("Failed to leave channel"),
+				severity: "error",
+				type: "api:channel:leave:failed"
+			});
+		} finally {
+			setLeaveChannelInProgress(false);
+		}
+	}, [
+		addNotification,
+		channel,
+		client.userID,
+		close,
+		t
+	]);
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(ListItemLayout, {
+		destructive: true,
+		LeadingIcon: LeaveChannelActionIcon,
+		RootElement: "button",
+		rootProps: useMemo(() => ({
+			className: channelManagementViewActionClassName,
+			disabled: leaveChannelInProgress,
+			onClick: openLeaveChannelAlert
+		}), [leaveChannelInProgress, openLeaveChannelAlert]),
+		title: t("Leave chat")
+	}), /* @__PURE__ */ jsx(Modal, {
+		open: alertOpen,
+		role: "alertdialog",
+		children: /* @__PURE__ */ jsx(ChannelManagementConfirmationAlert, {
+			action: "leaveChannel",
+			cancelLabel: t("Cancel"),
+			confirmLabel: t("Leave chat"),
+			description: t("Are you sure you want to leave this channel?"),
+			isSubmitting: leaveChannelInProgress,
+			onCancel: closeLeaveChannelAlert,
+			onConfirm: leaveChannel,
+			testId: "channel-detail-leave-channel-alert",
+			title: t("Leave chat")
+		})
+	})] });
+};
+var DeleteChatAction = () => {
+	const { channel } = useChannelDetailContext();
+	const { Modal = GlobalModal } = useComponentContext();
+	const { close: closeChannelDetail } = useModalContext();
+	const { addNotification } = useNotificationApi();
+	const { t } = useTranslationContext();
+	const otherMember = useOtherMember();
+	const [alertOpen, setAlertOpen] = useState(false);
+	const [deleteChatInProgress, setDeleteChatInProgress] = useState(false);
+	const userName = getDisplayName(otherMember?.user?.name, otherMember?.user?.id);
+	const closeDeleteChatAlert = useCallback(() => {
+		setAlertOpen(false);
+	}, []);
+	const openDeleteChatAlert = useCallback(() => {
+		setAlertOpen(true);
+	}, []);
+	const deleteChat = useCallback(async () => {
+		try {
+			setDeleteChatInProgress(true);
+			await channel.delete();
+			addNotification({
+				context: { channel },
+				emitter: "ChannelManagementView",
+				message: t("Chat deleted"),
+				severity: "success",
+				type: "api:channel:delete:success"
+			});
+			setAlertOpen(false);
+			closeChannelDetail();
+		} catch (error) {
+			addNotification({
+				context: { channel },
+				emitter: "ChannelManagementView",
+				error: toError$1(error),
+				message: t("Error deleting chat"),
+				severity: "error",
+				type: "api:channel:delete:failed"
+			});
+		} finally {
+			setDeleteChatInProgress(false);
+		}
+	}, [
+		addNotification,
+		channel,
+		closeChannelDetail,
+		t
+	]);
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(ListItemLayout, {
+		destructive: true,
+		LeadingIcon: DeleteChatActionIcon,
+		RootElement: "button",
+		rootProps: useMemo(() => ({
+			className: channelManagementViewActionClassName,
+			disabled: deleteChatInProgress,
+			onClick: openDeleteChatAlert
+		}), [deleteChatInProgress, openDeleteChatAlert]),
+		title: t("Delete chat")
+	}), /* @__PURE__ */ jsx(Modal, {
+		open: alertOpen,
+		role: "alertdialog",
+		children: /* @__PURE__ */ jsx(ChannelManagementConfirmationAlert, {
+			action: "deleteChat",
+			cancelLabel: t("Cancel"),
+			confirmLabel: t("Delete chat"),
+			description: t("This permanently deletes your message history with {{ user }}. This can't be undone.", { user: userName }),
+			isSubmitting: deleteChatInProgress,
+			onCancel: closeDeleteChatAlert,
+			onConfirm: deleteChat,
+			testId: "channel-detail-delete-chat-alert",
+			title: t("Delete chat")
+		})
+	})] });
+};
+var DefaultChannelManagementActions = {
+	BlockUser: BlockUserAction$1,
+	DeleteChat: DeleteChatAction,
+	LeaveChannel: LeaveChannelAction,
+	MuteChannel: ChannelMuteAction,
+	MuteUser: UserMuteAction$1
+};
+var defaultChannelManagementActionSet = [
+	{
+		Component: DefaultChannelManagementActions.MuteChannel,
+		type: "muteChannel"
+	},
+	{
+		Component: DefaultChannelManagementActions.MuteUser,
+		type: "muteUser"
+	},
+	{
+		Component: DefaultChannelManagementActions.BlockUser,
+		type: "blockUser"
+	},
+	{
+		Component: DefaultChannelManagementActions.LeaveChannel,
+		type: "leaveChannel"
+	},
+	{
+		Component: DefaultChannelManagementActions.DeleteChat,
+		type: "deleteChat"
+	}
+];
+//#endregion
+//#region src/plugins/ChannelDetail/Views/ChannelManagementView/ChannelManagementView.tsx
+var ChannelManagementInfoBody = ({ actions }) => {
+	const { client } = useChatContext();
+	const { channel } = useChannelDetailContext();
+	const { Avatar = ChannelAvatar } = useComponentContext();
+	const { displayImage, displayTitle, groupChannelDisplayInfo } = useChannelPreviewInfo({ channel });
+	const resolvedIsDmChannel = isDmChannel({
+		channel,
+		ownUserId: client.user?.id
+	});
+	const otherMemberUserId = useMemo(() => {
+		if (!resolvedIsDmChannel) return;
+		return Object.values(channel.state?.members ?? {}).find((member) => member.user?.id && member.user.id !== client.user?.id)?.user?.id;
+	}, [
+		channel,
+		client.user?.id,
+		resolvedIsDmChannel
+	]);
+	const isOnline = useChannelHasMembersOnline({ channel });
+	const { muted: channelMuted } = useIsChannelMuted(channel);
+	const userMuted = useIsUserMuted(otherMemberUserId);
+	const membership = useChannelMembershipState(channel);
+	const onlineStatusText = useChannelHeaderOnlineStatus({ channel });
+	const pinned = !!membership.pinned_at;
+	return /* @__PURE__ */ jsxs(Prompt.Body, {
+		className: "str-chat__channel-detail__channel-management-view__body",
+		children: [/* @__PURE__ */ jsxs("div", {
+			className: "str-chat__channel-detail__channel-management-view__profile",
+			children: [/* @__PURE__ */ jsx(Avatar, {
+				displayMembers: groupChannelDisplayInfo.members,
+				imageUrl: displayImage,
+				isOnline: resolvedIsDmChannel ? isOnline : void 0,
+				size: "2xl",
+				userName: displayTitle
+			}), /* @__PURE__ */ jsxs("div", {
+				className: "str-chat__channel-detail__channel-management-view__profile__details",
+				children: [/* @__PURE__ */ jsxs("div", {
+					className: "str-chat__channel-detail__channel-management-view__profile__details__title",
+					children: [
+						displayTitle && /* @__PURE__ */ jsx("span", { children: displayTitle }),
+						pinned && /* @__PURE__ */ jsx(IconPin, {}),
+						resolvedIsDmChannel && userMuted || !resolvedIsDmChannel && channelMuted ? /* @__PURE__ */ jsx(IconMute, {}) : null
+					]
+				}), onlineStatusText && /* @__PURE__ */ jsx("div", {
+					className: "str-chat__channel-detail__channel-management-view__profile__details__connection-status",
+					children: onlineStatusText
+				})]
+			})]
+		}), /* @__PURE__ */ jsx("div", {
+			className: "str-chat__channel-detail__channel-management-view__actions str-chat__form__switch-fieldset",
+			children: actions.map(({ Component, type }) => /* @__PURE__ */ jsx(Component, {}, type))
+		})]
+	});
+};
+var EDIT_BODY_EMITTER = "ChannelManagementEditBody";
+/**
+* Assembles the argument for `channel.updatePartial` from the pending edits,
+* or returns `null` when there is nothing to persist. `image` is a tri-state:
+* a string sets a new avatar, `null` clears it, `undefined` leaves it untouched.
+*/
+var buildChannelUpdatePayload = ({ image, name }) => {
+	const payload = {};
+	const set = {};
+	if (name !== void 0) set.name = name;
+	if (typeof image === "string") set.image = image;
+	if (Object.keys(set).length > 0) payload.set = set;
+	if (image === null) payload.unset = ["image"];
+	return Object.keys(payload).length > 0 ? payload : null;
+};
+/**
+* Owns the channel-edit form: field state, the local image preview lifecycle,
+* the derived "can save" flags, and the save orchestration (upload → persist →
+* notify). The component is left to render the values this returns.
+*/
+var useChannelManagementEditForm = ({ uploadImage }) => {
+	const { t } = useTranslationContext();
+	const { client } = useChatContext();
+	const { channel } = useChannelDetailContext();
+	const { displayImage, displayTitle, groupChannelDisplayInfo } = useChannelPreviewInfo({ channel });
+	const { addNotification } = useNotificationApi();
+	const resolvedIsDmChannel = isDmChannel({
+		channel,
+		ownUserId: client.user?.id
+	});
+	const hasMembersOnline = useChannelHasMembersOnline({ channel });
+	const isOnline = resolvedIsDmChannel ? hasMembersOnline : void 0;
+	const nameLabel = resolvedIsDmChannel ? t("Contact name") : t("Group name");
+	const [baselineName, setBaselineName] = useState(channel.data?.name ?? "");
+	const [name, setName] = useState(baselineName);
+	const [imageEdit, setImageEdit] = useState(null);
+	const [isSaving, setIsSaving] = useState(false);
+	const fileInputRef = useRef(null);
+	const pickedFile = imageEdit instanceof File ? imageEdit : null;
+	const objectUrl = useMemo(() => pickedFile ? URL.createObjectURL(pickedFile) : null, [pickedFile]);
+	useEffect(() => () => {
+		if (objectUrl) URL.revokeObjectURL(objectUrl);
+	}, [objectUrl]);
+	const previewImageUrl = objectUrl ?? (imageEdit === "removed" ? void 0 : displayImage);
+	const trimmedName = name.trim();
+	const nameChanged = trimmedName !== baselineName.trim();
+	const imageChanged = imageEdit !== null;
+	const hasChanges = trimmedName.length > 0 && nameChanged || imageChanged;
+	const canSubmit = trimmedName.length > 0 && !isSaving && hasChanges;
+	const handleOpenFilePicker = useCallback(() => {
+		fileInputRef.current?.click();
+	}, []);
+	const handleFileChange = useCallback((event) => {
+		const file = event.target.files?.[0];
+		if (file) setImageEdit(file);
+		event.target.value = "";
+	}, []);
+	const handleDeleteImage = useCallback(() => setImageEdit("removed"), []);
+	const resolveImageUrl = useCallback(async (file) => {
+		const url = uploadImage ? await uploadImage(file) : (await channel.sendImage(file)).file;
+		if (!url) throw new Error("Image upload did not return a URL");
+		return url;
+	}, [channel, uploadImage]);
+	return {
+		canSubmit,
+		displayTitle,
+		fileInputRef,
+		groupChannelDisplayInfo,
+		handleDeleteImage,
+		handleFileChange,
+		handleOpenFilePicker,
+		handleSubmit: useCallback(async (event) => {
+			event.preventDefault();
+			if (!canSubmit) return;
+			setIsSaving(true);
+			try {
+				let image;
+				if (pickedFile) image = await resolveImageUrl(pickedFile);
+				else if (imageEdit === "removed") image = null;
+				const payload = buildChannelUpdatePayload({
+					image,
+					name: nameChanged ? trimmedName : void 0
+				});
+				if (payload) await channel.updatePartial(payload);
+				setImageEdit(null);
+				setBaselineName(trimmedName);
+				setName(trimmedName);
+				addNotification({
+					duration: 3e3,
+					emitter: EDIT_BODY_EMITTER,
+					incident: {
+						domain: "channel",
+						entity: "channel",
+						operation: "update",
+						status: "success"
+					},
+					message: t("Changes saved"),
+					severity: "success"
+				});
+			} catch (error) {
+				addNotification({
+					emitter: EDIT_BODY_EMITTER,
+					error: error instanceof Error ? error : void 0,
+					incident: {
+						domain: "api",
+						entity: "channel",
+						operation: "update",
+						status: "failed"
+					},
+					message: t("Failed to save changes"),
+					severity: "error"
+				});
+			} finally {
+				setIsSaving(false);
+			}
+		}, [
+			addNotification,
+			canSubmit,
+			channel,
+			imageEdit,
+			nameChanged,
+			pickedFile,
+			resolveImageUrl,
+			t,
+			trimmedName
+		]),
+		hasAvatarImage: !!previewImageUrl,
+		isOnline,
+		name,
+		nameLabel,
+		previewImageUrl,
+		setName,
+		t,
+		trimmedName
+	};
+};
+var ChannelManagementEditBody = (props) => {
+	const { Avatar = ChannelAvatar } = useComponentContext();
+	const { canSubmit, displayTitle, fileInputRef, groupChannelDisplayInfo, handleDeleteImage, handleFileChange, handleOpenFilePicker, handleSubmit, hasAvatarImage, isOnline, name, nameLabel, previewImageUrl, setName, t, trimmedName } = useChannelManagementEditForm(props);
+	return /* @__PURE__ */ jsxs("form", {
+		className: "str-chat__channel-detail__channel-management-view__form",
+		onSubmit: handleSubmit,
+		children: [/* @__PURE__ */ jsxs(Prompt.Body, {
+			className: "str-chat__channel-detail__channel-management-view__body",
+			children: [/* @__PURE__ */ jsxs("div", {
+				className: "str-chat__channel-detail__channel-management-view__avatar-row",
+				children: [/* @__PURE__ */ jsx(Avatar, {
+					displayMembers: groupChannelDisplayInfo.members,
+					imageUrl: previewImageUrl,
+					isOnline,
+					size: "2xl",
+					userName: trimmedName || displayTitle
+				}), /* @__PURE__ */ jsxs("div", {
+					className: "str-chat__channel-detail__channel-management-view__avatar-row__actions",
+					children: [
+						/* @__PURE__ */ jsx(Button, {
+							appearance: "outline",
+							onClick: handleOpenFilePicker,
+							size: "sm",
+							type: "button",
+							variant: "secondary",
+							children: t("Upload Picture")
+						}),
+						hasAvatarImage && /* @__PURE__ */ jsx(Button, {
+							appearance: "outline",
+							onClick: handleDeleteImage,
+							size: "sm",
+							type: "button",
+							variant: "secondary",
+							children: t("Delete")
+						}),
+						/* @__PURE__ */ jsx("input", {
+							accept: "image/*",
+							"aria-hidden": true,
+							className: "str-chat__channel-detail__channel-management-view__file-input",
+							onChange: handleFileChange,
+							ref: fileInputRef,
+							tabIndex: -1,
+							type: "file"
+						})
+					]
+				})]
+			}), /* @__PURE__ */ jsx(TextInput, {
+				"aria-label": nameLabel,
+				autoFocus: true,
+				className: "str-chat__channel-detail__channel-management-view__name-input",
+				maxLength: 255,
+				onChange: (event) => setName(event.target.value),
+				placeholder: nameLabel,
+				value: name
+			})]
+		}), /* @__PURE__ */ jsx(Prompt.Footer, {
+			className: "str-chat__channel-detail__channel-management-view__footer",
+			children: /* @__PURE__ */ jsx(Prompt.FooterControls, { children: canSubmit && /* @__PURE__ */ jsxs(Prompt.FooterControlsButtonPrimary, {
+				className: "str-chat__channel-detail__channel-management-view__footer__save-button",
+				type: "submit",
+				children: [/* @__PURE__ */ jsx(IconCheckmark, {}), t("Save")]
+			}) })
+		})]
+	});
+};
+var ChannelManagementView = ({ channelManagementActionSet = defaultChannelManagementActionSet, EditModeComponent = ChannelManagementEditBody, uploadImage, ViewModeComponent = ChannelManagementInfoBody }) => {
+	const { t } = useTranslationContext();
+	const { client } = useChatContext();
+	const { channel } = useChannelDetailContext();
+	const { close } = useModalContext();
+	const resolvedIsDmChannel = isDmChannel({
+		channel,
+		ownUserId: client.user?.id
+	});
+	const actions = useBaseChannelManagementActionSetFilter(channelManagementActionSet);
+	const [isEditing, setIsEditing] = useState(false);
+	const canEditChannel = channel.data?.own_capabilities?.includes("update-channel");
+	const isEditMode = isEditing && canEditChannel;
+	useEffect(() => {
+		setIsEditing(false);
+	}, [channel.cid]);
+	const EditChannelButton = useMemo(() => function EditChannelButton() {
+		return /* @__PURE__ */ jsx(Button, {
+			appearance: "outline",
+			"aria-label": t("Edit chat data"),
+			className: "str-chat__channel-detail__channel-management-view__edit-button",
+			onClick: () => {
+				setIsEditing(true);
+			},
+			size: "md",
+			variant: "secondary",
+			children: t("Edit")
+		});
+	}, [t]);
+	const headerTitle = isEditMode ? resolvedIsDmChannel ? t("Edit contact") : t("Edit group") : resolvedIsDmChannel ? t("Contact info") : t("Group info");
+	return /* @__PURE__ */ jsxs("div", {
+		className: "str-chat__channel-detail__channel-management-view",
+		children: [/* @__PURE__ */ jsx(SectionNavigatorHeader, {
+			close,
+			description: isEditMode ? void 0 : t("Manage channel"),
+			goBack: isEditMode ? () => setIsEditing(false) : void 0,
+			title: headerTitle,
+			TrailingContent: !isEditMode && canEditChannel ? EditChannelButton : void 0
+		}), isEditMode ? /* @__PURE__ */ jsx(EditModeComponent, { uploadImage }) : /* @__PURE__ */ jsx(ViewModeComponent, { actions })]
+	});
+};
+//#endregion
+//#region src/plugins/ChannelDetail/Views/ChannelMediaView/ChannelMediaEmptyList.tsx
+var ChannelMediaEmptyList = () => {
+	const { t } = useTranslationContext("ChannelMediaEmptyList");
+	return /* @__PURE__ */ jsxs("div", {
+		className: "str-chat__channel-detail__media-view__empty-state",
+		children: [/* @__PURE__ */ jsx(IconImage, { className: "str-chat__channel-detail__media-view__empty-state__icon" }), /* @__PURE__ */ jsxs("div", {
+			className: "str-chat__channel-detail__media-view__empty-state__content",
+			children: [/* @__PURE__ */ jsx("p", {
+				className: "str-chat__channel-detail__media-view__empty-state__title",
+				children: t("No photos or videos")
+			}), /* @__PURE__ */ jsx("p", {
+				className: "str-chat__channel-detail__media-view__empty-state__description",
+				children: t("Share a photo or video to see it here")
+			})]
+		})]
+	});
+};
+//#endregion
+//#region src/plugins/ChannelDetail/Views/ChannelMembersView/ChannelMembersView.utils.ts
+var getMemberDisplayName = (member) => getUserDisplayName(member.user) || member.user_id || "";
+var getMemberUserId = (member) => member.user?.id || member.user_id;
+var getUserDisplayName = (user) => user?.name || user?.username || user?.id || "";
+var getChannelMemberUserIds = (channel) => Object.values(channel.state?.members ?? {}).map((member) => member.user?.id || member.user_id).filter((userId) => !!userId);
+var canUpdateChannelMembers = (channel) => channel.data?.own_capabilities?.includes("update-channel-members") ?? false;
+//#endregion
+//#region src/plugins/ChannelDetail/Views/ChannelMediaView/ChannelMediaView.utils.ts
+/** Attachment types rendered by the media gallery. */
+var MEDIA_ATTACHMENT_TYPES = ["image", "video"];
+var getMediaAttachmentType = (attachment) => {
+	if (isVideoAttachment(attachment)) return "video";
+	if (isImageAttachment(attachment)) return "image";
+};
+/**
+* Flattens messages into one renderable media item per image/video attachment,
+* carrying over the gallery descriptor, posting user, and video duration.
+*/
+var toChannelMediaItems = (messages) => {
+	const items = [];
+	messages.forEach((message) => {
+		message.attachments?.forEach((attachment, index) => {
+			const type = getMediaAttachmentType(attachment);
+			if (!type) return;
+			const descriptor = toBaseImageDescriptors(attachment);
+			if (!descriptor) return;
+			if (!(type === "video" ? Boolean(descriptor.videoThumbnailUrl || descriptor.videoUrl) : Boolean(descriptor.imageUrl))) return;
+			items.push({
+				durationSeconds: typeof attachment.duration === "number" ? attachment.duration : void 0,
+				galleryItem: descriptor,
+				id: `${message.id}-${index}`,
+				type,
+				user: message.user ?? void 0
+			});
+		});
+	});
+	return items;
+};
+//#endregion
+//#region src/plugins/ChannelDetail/Views/ChannelMediaView/useChannelMediaSearch.ts
+var CHANNEL_MEDIA_SEARCH_PAGE_SIZE = 30;
+var channelMediaSearchSourceItemsStateSelector = (state) => ({
+	hasNext: state.hasNext,
+	isLoading: state.isLoading,
+	messages: state.items
+});
+var useChannelMediaSearch = () => {
+	const { client } = useChatContext();
+	const { channel } = useChannelDetailContext();
+	const channelMediaSearchSource = useMemo(() => {
+		const source = new MessageSearchSource(client, {
+			allowEmptySearchString: true,
+			pageSize: CHANNEL_MEDIA_SEARCH_PAGE_SIZE,
+			resetOnNewSearchQuery: false
+		});
+		source.messageSearchChannelFilters = { cid: channel.cid };
+		source.messageSearchFilters = { "attachments.type": { $in: [...MEDIA_ATTACHMENT_TYPES] } };
+		return source;
+	}, [channel.cid, client]);
+	const { hasNext, isLoading, messages } = useStateStore(channelMediaSearchSource.state, channelMediaSearchSourceItemsStateSelector);
+	const mediaItems = useMemo(() => toChannelMediaItems(messages ?? []), [messages]);
+	useEffect(() => {
+		channelMediaSearchSource.activate();
+		channelMediaSearchSource.search("");
+		return () => {
+			channelMediaSearchSource.cancelScheduledQuery();
+		};
+	}, [channelMediaSearchSource]);
+	return {
+		channelMediaSearchSource,
+		hasNext: Boolean(hasNext),
+		hasResultsLoaded: Array.isArray(messages),
+		isLoading,
+		mediaItems
+	};
+};
+//#endregion
+//#region src/plugins/ChannelDetail/Views/ChannelMediaView/ChannelMediaView.tsx
+var DEFAULT_CHANNEL_MEDIA_ITEMS_PER_PAGE = 30;
+var ChannelMediaGridItem = ({ BaseImage, item, onClick }) => {
+	const { t } = useTranslationContext("ChannelMediaView");
+	const displayName = getUserDisplayName(item.user);
+	const mediaSrc = item.type === "video" ? item.galleryItem.videoThumbnailUrl : item.galleryItem.imageUrl;
+	const durationLabel = formatTime(item.durationSeconds, "floor");
+	return /* @__PURE__ */ jsxs("button", {
+		"aria-label": item.type === "video" ? t("aria/Open video shared by {{ name }}", { name: displayName }) : t("aria/Open image shared by {{ name }}", { name: displayName }),
+		className: "str-chat__channel-detail__media-view__item",
+		onClick,
+		type: "button",
+		children: [
+			mediaSrc ? /* @__PURE__ */ jsx(BaseImage, {
+				alt: item.galleryItem.alt ?? item.galleryItem.title ?? "",
+				className: "str-chat__channel-detail__media-view__item__media",
+				src: mediaSrc
+			}) : /* @__PURE__ */ jsx("div", {
+				"aria-hidden": "true",
+				className: "str-chat__channel-detail__media-view__item__placeholder",
+				children: /* @__PURE__ */ jsx(IconImage, {})
+			}),
+			/* @__PURE__ */ jsx(Avatar, {
+				"aria-hidden": "true",
+				className: "str-chat__channel-detail__media-view__item__avatar",
+				imageUrl: item.user?.image,
+				size: "sm",
+				userName: displayName
+			}),
+			item.type === "video" && /* @__PURE__ */ jsxs(Badge, {
+				className: "str-chat__channel-detail__media-view__item__duration",
+				size: "sm",
+				variant: "inverse",
+				children: [/* @__PURE__ */ jsx(IconVideoFill, { className: "str-chat__channel-detail__media-view__item__duration-icon" }), durationLabel ? /* @__PURE__ */ jsx("span", { children: durationLabel }) : null]
+			})
+		]
+	});
+};
+var ChannelMediaPagination = ({ nextDisabled, onNext, onPrevious, previousDisabled }) => {
+	const { t } = useTranslationContext("ChannelMediaView");
+	return /* @__PURE__ */ jsxs("div", {
+		className: "str-chat__channel-detail__media-view__pagination",
+		children: [/* @__PURE__ */ jsxs(Button, {
+			appearance: "outline",
+			"aria-label": t("aria/Previous page"),
+			className: "str-chat__channel-detail__media-view__pagination__button str-chat__channel-detail__media-view__pagination__button--previous",
+			disabled: previousDisabled,
+			onClick: onPrevious,
+			size: "md",
+			variant: "secondary",
+			children: [/* @__PURE__ */ jsx(IconChevronLeft, {}), t("Previous")]
+		}), /* @__PURE__ */ jsxs(Button, {
+			appearance: "outline",
+			"aria-label": t("aria/Next page"),
+			className: "str-chat__channel-detail__media-view__pagination__button str-chat__channel-detail__media-view__pagination__button--next",
+			disabled: nextDisabled,
+			onClick: onNext,
+			size: "md",
+			variant: "secondary",
+			children: [t("Next"), /* @__PURE__ */ jsx(IconChevronRight, {})]
+		})]
+	});
+};
+var ChannelMediaView = ({ itemsPerPage = DEFAULT_CHANNEL_MEDIA_ITEMS_PER_PAGE }) => {
+	const { t } = useTranslationContext();
+	const { close } = useModalContext();
+	const { BaseImage: BaseImage$1 = BaseImage, Gallery: Gallery$1 = Gallery, Modal = GlobalModal } = useComponentContext();
+	const { channelMediaSearchSource, hasNext, hasResultsLoaded, isLoading, mediaItems } = useChannelMediaSearch();
+	const [viewerOpen, setViewerOpen] = useState(false);
+	const [selectedIndex, setSelectedIndex] = useState(0);
+	const [page, setPage] = useState(0);
+	const gridRef = useRef(null);
+	const pendingNextRef = useRef(false);
+	const galleryItems = useMemo(() => mediaItems.map((item) => item.galleryItem), [mediaItems]);
+	const pageStart = page * itemsPerPage;
+	const pageItems = useMemo(() => mediaItems.slice(pageStart, pageStart + itemsPerPage), [
+		mediaItems,
+		itemsPerPage,
+		pageStart
+	]);
+	const canGoNext = mediaItems.length > pageStart + itemsPerPage || hasNext;
+	const showPagination = mediaItems.length > itemsPerPage || mediaItems.length > 0 && hasNext;
+	const openViewer = useCallback((index) => {
+		setSelectedIndex(index);
+		setViewerOpen(true);
+	}, []);
+	const closeViewer = useCallback(() => {
+		setViewerOpen(false);
+	}, []);
+	const goToPreviousPage = useCallback(() => {
+		pendingNextRef.current = false;
+		setPage((current) => Math.max(0, current - 1));
+	}, []);
+	const goToNextPage = useCallback(() => {
+		const nextPageStart = (page + 1) * itemsPerPage;
+		if (mediaItems.length > nextPageStart) setPage(page + 1);
+		else if (hasNext) {
+			pendingNextRef.current = true;
+			channelMediaSearchSource.search();
+		}
+	}, [
+		channelMediaSearchSource,
+		hasNext,
+		itemsPerPage,
+		mediaItems.length,
+		page
+	]);
+	useEffect(() => {
+		if (isLoading) return;
+		if (pendingNextRef.current) {
+			const nextPageStart = (page + 1) * itemsPerPage;
+			if (mediaItems.length > nextPageStart) {
+				pendingNextRef.current = false;
+				setPage((current) => current + 1);
+				return;
+			}
+			if (!hasNext) {
+				pendingNextRef.current = false;
+				return;
+			}
+			channelMediaSearchSource.search();
+			return;
+		}
+		const need = pageStart + itemsPerPage;
+		if (mediaItems.length < need && hasNext) channelMediaSearchSource.search();
+	}, [
+		channelMediaSearchSource,
+		hasNext,
+		isLoading,
+		itemsPerPage,
+		mediaItems.length,
+		page,
+		pageStart
+	]);
+	useEffect(() => {
+		const grid = gridRef.current;
+		if (typeof grid?.scrollTo === "function") grid.scrollTo({ top: 0 });
+		else if (grid) grid.scrollTop = 0;
+	}, [page]);
+	return /* @__PURE__ */ jsxs("div", {
+		className: "str-chat__channel-detail__media-view",
+		children: [
+			/* @__PURE__ */ jsx(SectionNavigatorHeader, {
+				close,
+				title: t("Photos & videos")
+			}),
+			/* @__PURE__ */ jsx(Prompt.Body, {
+				className: "str-chat__channel-detail__media-view__body",
+				children: /* @__PURE__ */ jsx("div", {
+					className: "str-chat__channel-detail__media-view__grid",
+					ref: gridRef,
+					children: /* @__PURE__ */ jsxs("div", {
+						className: "str-chat__channel-detail__media-view__grid__content",
+						children: [
+							pageItems.length > 0 ? /* @__PURE__ */ jsx("div", {
+								className: "str-chat__channel-detail__media-view__grid__items",
+								children: pageItems.map((item, index) => /* @__PURE__ */ jsx(ChannelMediaGridItem, {
+									BaseImage: BaseImage$1,
+									item,
+									onClick: () => openViewer(pageStart + index)
+								}, item.id))
+							}) : hasResultsLoaded ? /* @__PURE__ */ jsx(ChannelMediaEmptyList, {}) : null,
+							/* @__PURE__ */ jsx(ChannelDetailListLoadingIndicator, { searchSource: channelMediaSearchSource }),
+							showPagination && /* @__PURE__ */ jsx(ChannelMediaPagination, {
+								nextDisabled: !canGoNext || isLoading,
+								onNext: goToNextPage,
+								onPrevious: goToPreviousPage,
+								previousDisabled: page === 0
+							})
+						]
+					})
+				})
+			}),
+			/* @__PURE__ */ jsx(Modal, {
+				className: clsx("str-chat__gallery-modal", "str-chat__channel-detail__media-view__viewer"),
+				onClose: closeViewer,
+				open: viewerOpen,
+				children: /* @__PURE__ */ jsx(Gallery$1, {
+					GalleryUI,
+					initialIndex: selectedIndex,
+					items: galleryItems,
+					onRequestClose: closeViewer
+				})
+			})
+		]
+	});
+};
+//#endregion
+//#region src/plugins/ChannelDetail/Views/ChannelMembersView/ChannelMembersHeaderActions.defaults.tsx
+/**
+* First-pass filter applied by {@link DefaultHeaderActions}. The SDK's own
+* actions are gated internally by capability — `addMembers` requires
+* `update-channel-members`; any other action is shown by default. App-defined
+* actions may further narrow visibility via their own `filter` predicate (which
+* is what an app should use to gate, e.g., a custom member-removal action).
+*/
+var useBaseChannelMembersHeaderActionSetFilter = (channelMembersHeaderActionSet) => {
+	const { channel } = useChannelDetailContext();
+	const canManageChannelMembers = canUpdateChannelMembers(channel);
+	return useMemo(() => channelMembersHeaderActionSet.filter((action) => {
+		return (action.type !== "addMembers" || canManageChannelMembers) && (action.filter?.({ channel }) ?? true);
+	}), [
+		canManageChannelMembers,
+		channel,
+		channelMembersHeaderActionSet
+	]);
+};
+var AddMembersHeaderAction = ({ modeController }) => {
+	const { t } = useTranslationContext();
+	if (modeController.mode !== "browse") return null;
+	return /* @__PURE__ */ jsx(Button, {
+		appearance: "outline",
+		"aria-label": t("Add channel members"),
+		className: "str-chat__channel-detail__channel-members-view__add-button",
+		onClick: () => modeController.setMode("add"),
+		size: "md",
+		variant: "secondary",
+		children: t("Add")
+	});
+};
+var AddMembersMenuAction = ({ closeMenu, modeController }) => {
+	const { t } = useTranslationContext();
+	if (modeController.mode !== "browse") return null;
+	return /* @__PURE__ */ jsx(ContextMenuButton, {
+		"aria-label": t("Add channel members"),
+		Icon: IconUserAdd,
+		onClick: () => {
+			modeController.setMode("add");
+			closeMenu?.();
+		},
+		children: t("Add")
+	});
+};
+var DefaultChannelMembersHeaderActions = {
+	AddMembers: AddMembersHeaderAction,
+	AddMembersMenu: AddMembersMenuAction
+};
+var defaultChannelMembersHeaderActionSet = [{
+	component: DefaultChannelMembersHeaderActions.AddMembers,
+	placement: "quick",
+	type: "addMembers"
+}];
+var DefaultHeaderActionsMenuTrigger = ({ referenceRef, ...props }) => {
+	const { t } = useTranslationContext();
+	return /* @__PURE__ */ jsx(Button, {
+		appearance: "outline",
+		"aria-label": t("Open members actions"),
+		className: "str-chat__channel-detail__channel-members-view__actions-button",
+		ref: referenceRef,
+		size: "md",
+		variant: "secondary",
+		...props,
+		children: t("Actions")
+	});
+};
+var getHeaderActionsDialogId = (channelId) => `channel-members-header-actions-${channelId ?? "unknown"}`;
+var DefaultHeaderActions = ({ headerActionSet, HeaderActionsMenuTrigger = DefaultHeaderActionsMenuTrigger, modeController }) => {
+	const { ContextMenu: ContextMenuComponent = ContextMenu } = useComponentContext();
+	const { channel } = useChannelDetailContext();
+	const actions = useBaseChannelMembersHeaderActionSetFilter(headerActionSet);
+	const [referenceElement, setReferenceElement] = useState(null);
+	const dialogId = getHeaderActionsDialogId(channel.id);
+	const { dialog, dialogManager } = useDialogOnNearestManager({ id: dialogId });
+	const dialogManagerId = dialogManager?.id;
+	const dialogIsOpen = useDialogIsOpen(dialogId, dialogManagerId);
+	if (!actions.length) return null;
+	const quickActions = actions.filter((action) => action.placement === "quick");
+	const menuActions = actions.filter((action) => action.placement === "menu");
+	return /* @__PURE__ */ jsxs("div", {
+		className: "str-chat__channel-detail__channel-members-view__header-actions",
+		children: [quickActions.map(({ component: QuickComponent, type }) => /* @__PURE__ */ jsx(QuickComponent, { modeController }, type)), menuActions.length > 0 && /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(HeaderActionsMenuTrigger, {
+			"aria-expanded": dialogIsOpen,
+			onClick: () => {
+				dialog.toggle();
+			},
+			referenceRef: setReferenceElement
+		}), /* @__PURE__ */ jsx(ContextMenuComponent, {
+			"aria-label": "Members actions",
+			className: "str-chat__channel-detail__channel-members-view__header-actions-menu",
+			dialogManagerId,
+			id: dialog.id,
+			onClose: () => dialog.close(),
+			placement: "bottom-start",
+			referenceElement,
+			tabIndex: -1,
+			trapFocus: true,
+			children: menuActions.map(({ component: MenuComponent, type }) => /* @__PURE__ */ jsx(MenuComponent, {
+				closeMenu: () => dialog.close(),
+				modeController
+			}, type))
+		})] })]
+	});
+};
+//#endregion
+//#region src/plugins/ChannelDetail/VirtualizedList/VirtualizedList.tsx
+var VirtualizedListContent = forwardRef(function VirtualizedListContent({ className, ...props }, ref) {
+	return /* @__PURE__ */ jsx("div", {
+		...props,
+		className: clsx("str-chat__virtualized-list__content", className),
+		ref
+	});
+});
+/**
+* Thin wrapper around `react-virtuoso`'s `Virtuoso` for the simple,
+* append-only, flat lists used across the ChannelDetail views. It keeps the
+* call sites declarative (data + itemContent + empty/footer slots) and hides
+* the infinite-scroll wiring.
+*/
+var VirtualizedList = ({ className, computeItemKey, data, EmptyPlaceholder, Footer, itemContent, loadNext, virtuosoProps, ...rest }) => {
+	const atBottomStateChange = useCallback((atBottom) => {
+		if (atBottom) loadNext?.();
+	}, [loadNext]);
+	const components = useMemo(() => ({
+		EmptyPlaceholder,
+		Footer,
+		List: VirtualizedListContent
+	}), [EmptyPlaceholder, Footer]);
+	return /* @__PURE__ */ jsx(Virtuoso, {
+		atBottomStateChange,
+		className: clsx("str-chat__virtualized-list", className),
+		components,
+		computeItemKey,
+		data,
+		itemContent,
+		...rest,
+		...virtuosoProps
+	});
+};
+//#endregion
+//#region src/plugins/ChannelDetail/Views/ChannelMembersView/useChannelMemberIds.ts
+var MEMBER_IDS_EVENTS = [
+	"member.added",
+	"member.removed",
+	"member.updated"
+];
+/** Reactive set of channel member user ids derived from real channel state. */
+var useChannelMemberIds = (channel) => {
+	const [memberIds, setMemberIds] = useState(() => getChannelMemberUserIds(channel));
+	useEffect(() => {
+		const syncMemberIds = () => setMemberIds(getChannelMemberUserIds(channel));
+		syncMemberIds();
+		const subscriptions = MEMBER_IDS_EVENTS.map((event) => channel.on(event, syncMemberIds));
+		return () => subscriptions.forEach((subscription) => subscription.unsubscribe());
+	}, [channel]);
+	return memberIds;
+};
+//#endregion
+//#region src/plugins/ChannelDetail/ChannelDetailSearchInput.tsx
+var ChannelDetailSearchInput = React.memo(({ autoFocus, onSearchChange, resetKey }) => {
+	const { t } = useTranslationContext();
+	const [searchInput, setSearchInput] = useState("");
+	useEffect(() => {
+		setSearchInput("");
+	}, [resetKey]);
+	const handleSearchChange = useCallback((event) => {
+		const { value } = event.target;
+		setSearchInput(value);
+		onSearchChange(value);
+	}, [onSearchChange]);
+	return /* @__PURE__ */ jsx(TextInput, {
+		"aria-label": t("Search"),
+		autoComplete: "off",
+		autoFocus,
+		className: "str-chat__channel-detail__search-input",
+		leading: /* @__PURE__ */ jsx(IconSearch, {}),
+		onChange: handleSearchChange,
+		placeholder: t("Search"),
+		type: "search",
+		value: searchInput
+	});
+});
+ChannelDetailSearchInput.displayName = "ChannelDetailSearchInput";
+//#endregion
+//#region src/plugins/ChannelDetail/ChannelDetailEmptyList.tsx
+var ChannelDetailEmptyList = ({ children }) => /* @__PURE__ */ jsxs("div", {
+	className: "str-chat__channel-detail__channel-members-view__empty-state",
+	children: [/* @__PURE__ */ jsx(IconSearch, {}), /* @__PURE__ */ jsx("div", { children })]
+});
+//#endregion
+//#region src/plugins/ChannelDetail/Views/ChannelMembersView/ChannelMembersAddView.tsx
+var USER_SEARCH_PAGE_SIZE = 30;
+var searchSourceItemsStateSelector = (state) => ({
+	isLoading: state.isLoading,
+	users: state.items
+});
+var EMPTY_USERS = [];
+var computeUserItemKey = (_, user) => user.id;
+var MuteIndicator = () => /* @__PURE__ */ jsx(IconMute, { className: "str-chat__channel-detail__action-icon str-chat__channel-detail__action-icon--mute" });
+var readOnlyRootProps = { className: "str-chat__channel-detail__channel-members-view__list-item" };
+var ChannelMembersAddViewItem = ({ canManageChannelMembers, isMember, isMuted, isSelected, toggleSelectedUser, user }) => {
+	const { t } = useTranslationContext();
+	const displayName = getUserDisplayName(user);
+	const LeadingSlot = useMemo(() => function MemberAvatar() {
+		return /* @__PURE__ */ jsx(Avatar, {
+			imageUrl: user.image,
+			isOnline: user.online,
+			size: "md",
+			userName: displayName
+		});
+	}, [
+		displayName,
+		user.image,
+		user.online
+	]);
+	const SelectableTrailingSlot = useMemo(() => function SelectCheckbox() {
+		return /* @__PURE__ */ jsx(Checkbox, {
+			"aria-hidden": true,
+			checked: isSelected
+		});
+	}, [isSelected]);
+	const selectableRootProps = useMemo(() => ({
+		"aria-pressed": isSelected,
+		className: "str-chat__channel-detail__channel-members-view__list-item",
+		onClick: () => toggleSelectedUser(user.id)
+	}), [
+		isSelected,
+		toggleSelectedUser,
+		user.id
+	]);
+	if (canManageChannelMembers && !isMember) return /* @__PURE__ */ jsx(ListItemLayout, {
+		LeadingSlot,
+		RootElement: "button",
+		rootProps: selectableRootProps,
+		title: displayName,
+		TrailingSlot: SelectableTrailingSlot
+	});
+	return /* @__PURE__ */ jsx(ListItemLayout, {
+		LeadingSlot,
+		rootProps: readOnlyRootProps,
+		subtitle: isMember ? t("Already a member") : void 0,
+		title: displayName,
+		TrailingSlot: isMuted ? MuteIndicator : void 0
+	});
+};
+var ChannelMembersAddView = ({ modeController, searchSource }) => {
+	const { client, mutes } = useChatContext();
+	const { t } = useTranslationContext();
+	const { channel } = useChannelDetailContext();
+	const canManageChannelMembers = canUpdateChannelMembers(channel);
+	const { addNotification } = useNotificationApi();
+	const memberUserIds = useChannelMemberIds(channel);
+	const memberIdSet = useMemo(() => new Set(memberUserIds), [memberUserIds]);
+	const userSearchSource = useMemo(() => searchSource ?? new UserSearchSource(client, {
+		allowEmptySearchString: true,
+		pageSize: USER_SEARCH_PAGE_SIZE,
+		resetOnNewSearchQuery: false
+	}), [client, searchSource]);
+	const { isLoading, users } = useStateStore(userSearchSource.state, searchSourceItemsStateSelector);
+	const [isSaving, setIsSaving] = useState(false);
+	const [selectedUserIds, setSelectedUserIds] = useState([]);
+	useEffect(() => {
+		userSearchSource.activate();
+		userSearchSource.search("");
+		return () => userSearchSource.cancelScheduledQuery();
+	}, [userSearchSource]);
+	const selectedUserIdSet = useMemo(() => new Set(selectedUserIds), [selectedUserIds]);
+	const mutedUserIdSet = useMemo(() => new Set(mutes.map((mute) => mute.target.id)), [mutes]);
+	const handleSearchChange = useCallback((query) => {
+		userSearchSource.search(query);
+	}, [userSearchSource]);
+	const toggleSelectedUser = useCallback((userId) => setSelectedUserIds((currentSelectedUserIds) => currentSelectedUserIds.includes(userId) ? currentSelectedUserIds.filter((id) => id !== userId) : [...currentSelectedUserIds, userId]), []);
+	const renderItem = useCallback((_, user) => /* @__PURE__ */ jsx(ChannelMembersAddViewItem, {
+		canManageChannelMembers,
+		isMember: memberIdSet.has(user.id),
+		isMuted: mutedUserIdSet.has(user.id),
+		isSelected: selectedUserIdSet.has(user.id),
+		toggleSelectedUser,
+		user
+	}), [
+		canManageChannelMembers,
+		memberIdSet,
+		mutedUserIdSet,
+		selectedUserIdSet,
+		toggleSelectedUser
+	]);
+	const EmptyPlaceholder = useMemo(() => function ChannelMembersAddEmptyPlaceholder() {
+		if (isLoading || !users) return null;
+		return /* @__PURE__ */ jsx(ChannelDetailEmptyList, { children: t("No user found") });
+	}, [
+		isLoading,
+		t,
+		users
+	]);
+	const Footer = useMemo(() => function ChannelMembersAddListFooter() {
+		return /* @__PURE__ */ jsx(ChannelDetailListLoadingIndicator, { searchSource: userSearchSource });
+	}, [userSearchSource]);
+	const handleSave = async () => {
+		if (!canManageChannelMembers || !selectedUserIds.length || isSaving) return;
+		setIsSaving(true);
+		try {
+			await channel.addMembers(selectedUserIds);
+			addNotification({
+				context: { channel },
+				emitter: "ChannelMembersView",
+				message: t("{{ count }} members added", { count: selectedUserIds.length }),
+				severity: "success",
+				type: "api:channel:addMembers:success"
+			});
+			setSelectedUserIds([]);
+			setIsSaving(false);
+			modeController.setMode("browse");
+		} catch (error) {
+			setIsSaving(false);
+			addNotification({
+				context: { channel },
+				emitter: "ChannelMembersView",
+				error,
+				message: t("Error adding members"),
+				severity: "error",
+				type: "api:channel:addMembers:failed"
+			});
+		}
+	};
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsxs(Prompt.Body, {
+		className: "str-chat__channel-members-view__body",
+		children: [/* @__PURE__ */ jsx(ChannelDetailSearchInput, {
+			autoFocus: true,
+			onSearchChange: handleSearchChange
+		}), /* @__PURE__ */ jsx(VirtualizedList, {
+			className: "str-chat__channel-detail__channel-members-view__list",
+			computeItemKey: computeUserItemKey,
+			data: users ?? EMPTY_USERS,
+			EmptyPlaceholder,
+			Footer,
+			itemContent: renderItem,
+			loadNext: userSearchSource.search
+		})]
+	}), canManageChannelMembers && selectedUserIds.length > 0 && /* @__PURE__ */ jsx(Prompt.Footer, { children: /* @__PURE__ */ jsx(Prompt.FooterControls, { children: /* @__PURE__ */ jsx(Prompt.FooterControlsButtonPrimary, {
+		disabled: isSaving,
+		onClick: handleSave,
+		children: t("Add {{ count }} members", { count: selectedUserIds.length })
+	}) }) })] });
+};
+//#endregion
+//#region src/plugins/ChannelDetail/Views/ChannelMembersView/useChannelMemberCount.ts
+var MEMBER_COUNT_EVENTS = [
+	"member.added",
+	"member.removed",
+	"channel.updated"
+];
+/** Reactive channel member count derived from real channel state. */
+var useChannelMemberCount = (channel) => {
+	const [memberCount, setMemberCount] = useState(channel.data?.member_count ?? 0);
+	useEffect(() => {
+		const syncMemberCount = () => setMemberCount(channel.data?.member_count ?? 0);
+		syncMemberCount();
+		const subscriptions = MEMBER_COUNT_EVENTS.map((event) => channel.on(event, syncMemberCount));
+		return () => subscriptions.forEach((subscription) => subscription.unsubscribe());
+	}, [channel]);
+	return memberCount;
+};
+//#endregion
+//#region src/plugins/ChannelDetail/Views/ChannelMembersView/useChannelMembersSearch.ts
+var MEMBERS_SEARCH_DEBOUNCE_MS = 300;
+var membersSearchSourceItemsStateSelector = (state) => ({ members: state.items });
+var useChannelMembersSearch = () => {
+	const { channel } = useChannelDetailContext();
+	const fallbackMembers = useMemo(() => Object.values(channel.state?.members ?? {}), [channel]);
+	const memberCount = useChannelMemberCount(channel);
+	const hasMembers = channel.data?.member_count === void 0 || memberCount !== 0;
+	const membersSearchSource = useMemo(() => new ChannelMemberSearchSource(channel, {
+		allowEmptySearchString: true,
+		debounceMs: MEMBERS_SEARCH_DEBOUNCE_MS,
+		pageSize: 100,
+		resetOnNewSearchQuery: false
+	}), [channel]);
+	const { members } = useStateStore(membersSearchSource.state, membersSearchSourceItemsStateSelector);
+	const [searchInputResetKey, setSearchInputResetKey] = useState(0);
+	const resetMembersSearch = useCallback(() => {
+		membersSearchSource.cancelScheduledQuery();
+		setSearchInputResetKey((currentResetKey) => currentResetKey + 1);
+		membersSearchSource.resetState();
+		membersSearchSource.activate();
+		membersSearchSource.search("");
+	}, [membersSearchSource]);
+	const handleSearchChange = useCallback((query) => {
+		membersSearchSource.search(query.trim());
+	}, [membersSearchSource]);
+	useEffect(() => {
+		if (!hasMembers) return;
+		membersSearchSource.activate();
+		membersSearchSource.search("");
+	}, [hasMembers, membersSearchSource]);
+	useEffect(() => () => {
+		membersSearchSource.cancelScheduledQuery();
+	}, [membersSearchSource]);
+	return {
+		displayedMembers: members ?? fallbackMembers,
+		handleSearchChange,
+		hasMembers,
+		membersSearchSource,
+		resetMembersSearch,
+		searchInputResetKey
+	};
+};
+//#endregion
+//#region src/plugins/ChannelDetail/Views/ChannelMembersView/ChannelMembersBrowseView.tsx
+var getMemberRoleTranslation = (member, t) => {
+	if ([member.user?.role, member.channel_role].includes("admin")) return t("Admin");
+	if (member.channel_role === "channel_moderator" || member.channel_role === "moderator") return t("Moderator");
+	if (member.role === "owner") return t("Owner");
+};
+var getPresenceStatusText$1 = (user, t) => {
+	if (user?.online) return t("Online");
+	if (user?.last_active) return t("Last seen {{ timestamp }}", { timestamp: t("timestamp/ChannelMembersLastActive", { timestamp: user.last_active }) });
+	return t("Offline");
+};
+var ChannelMembersBrowseViewItem = ({ isMuted, member, onMemberSelect }) => {
+	const { t } = useTranslationContext();
+	const user = member.user;
+	const displayName = getMemberDisplayName(member);
+	const roleTranslation = getMemberRoleTranslation(member, t);
+	const LeadingSlot = useMemo(() => function MemberAvatar() {
+		return /* @__PURE__ */ jsx(Avatar, {
+			imageUrl: user?.image,
+			isOnline: user?.online,
+			size: "md",
+			userName: getUserDisplayName(user)
+		});
+	}, [user]);
+	const TrailingSlot = useMemo(() => function MemberTrailingSlot() {
+		return /* @__PURE__ */ jsxs("div", {
+			className: "str-chat__channel-detail__channel-members-view__list-item__trailing-slot",
+			children: [roleTranslation ? /* @__PURE__ */ jsx("span", {
+				className: "str-chat__channel-detail__channel-members-view__role-label",
+				children: roleTranslation
+			}) : null, isMuted ? /* @__PURE__ */ jsx(IconMute, { className: "str-chat__channel-detail__channel-members-view__list-item__indicator-icon str-chat__channel-detail__channel-members-view__list-item__indicator-icon--mute" }) : null]
+		});
+	}, [isMuted, roleTranslation]);
+	return /* @__PURE__ */ jsx(ListItemLayout, {
+		LeadingSlot,
+		RootElement: "button",
+		rootProps: useMemo(() => ({
+			"aria-label": t("View member details for {{ member }}", { member: displayName }),
+			className: "str-chat__channel-detail__channel-members-view__list-item",
+			onClick: () => onMemberSelect?.(member)
+		}), [
+			displayName,
+			member,
+			onMemberSelect,
+			t
+		]),
+		subtitle: getPresenceStatusText$1(user, t),
+		title: displayName,
+		TrailingSlot
+	});
+};
+var computeMemberItemKey = (_, member) => getMemberUserId(member);
+var ChannelMembersBrowseView = ({ onMemberSelect }) => {
+	const { mutes } = useChatContext();
+	const { t } = useTranslationContext();
+	const { displayedMembers, handleSearchChange, hasMembers, membersSearchSource, searchInputResetKey } = useChannelMembersSearch();
+	const mutedUserIdSet = useMemo(() => new Set(mutes.map((mute) => mute.target.id)), [mutes]);
+	const renderableMembers = useMemo(() => displayedMembers.filter((member) => getMemberUserId(member)), [displayedMembers]);
+	const renderItem = useCallback((_, member) => /* @__PURE__ */ jsx(ChannelMembersBrowseViewItem, {
+		isMuted: mutedUserIdSet.has(getMemberUserId(member)),
+		member,
+		onMemberSelect
+	}), [mutedUserIdSet, onMemberSelect]);
+	const EmptyPlaceholder = useMemo(() => function ChannelMembersEmptyPlaceholder() {
+		return /* @__PURE__ */ jsx(ChannelDetailEmptyList, { children: t("No member found") });
+	}, [t]);
+	const Footer = useMemo(() => function ChannelMembersListFooter() {
+		return /* @__PURE__ */ jsx(ChannelDetailListLoadingIndicator, { searchSource: membersSearchSource });
+	}, [membersSearchSource]);
+	return /* @__PURE__ */ jsxs(Prompt.Body, {
+		className: "str-chat__channel-members-view__body",
+		children: [hasMembers && /* @__PURE__ */ jsx(ChannelDetailSearchInput, {
+			onSearchChange: handleSearchChange,
+			resetKey: searchInputResetKey
+		}), /* @__PURE__ */ jsx(VirtualizedList, {
+			className: "str-chat__channel-detail__channel-members-view__list",
+			computeItemKey: computeMemberItemKey,
+			data: renderableMembers,
+			EmptyPlaceholder,
+			Footer,
+			itemContent: renderItem,
+			loadNext: hasMembers ? membersSearchSource.search : void 0
+		})]
+	});
+};
+//#endregion
+//#region src/plugins/ChannelDetail/Views/ChannelMemberDetailView/ChannelMemberActions.defaults.tsx
+var ChannelMemberActionContext = createContext(void 0);
+var ChannelMemberActionProvider = ({ children, value }) => /* @__PURE__ */ jsx(ChannelMemberActionContext.Provider, {
+	value,
+	children
+});
+var useChannelMemberActionContext = () => {
+	const contextValue = useContext(ChannelMemberActionContext);
+	if (!contextValue) throw new Error("The useChannelMemberActionContext hook was called outside of ChannelMemberActionProvider.");
+	return contextValue;
+};
+var toError = (error) => error instanceof Error ? error : /* @__PURE__ */ new Error("An unknown error occurred");
+var MemberMuteActionIcon = () => /* @__PURE__ */ jsx(IconMute, { className: "str-chat__channel-detail__action-icon str-chat__channel-detail__action-icon--mute" });
+var MemberUnmuteActionIcon = () => /* @__PURE__ */ jsx(IconAudio, { className: "str-chat__channel-detail__action-icon str-chat__channel-detail__action-icon--unmute" });
+var SendDirectMessageActionIcon = () => /* @__PURE__ */ jsx(IconMessageBubble, { className: "str-chat__channel-detail__action-icon" });
+var BlockUserActionIcon = () => /* @__PURE__ */ jsx(IconNoSign, { className: "str-chat__icon--destructive str-chat__channel-detail__action-icon str-chat__channel-detail__action-icon--block-user" });
+var RemoveUserActionIcon = () => /* @__PURE__ */ jsx(IconUserRemove, { className: "str-chat__icon--destructive str-chat__channel-detail__action-icon str-chat__channel-detail__action-icon--remove-user" });
+var channelMemberDetailActionClassName = "str-chat__channel-member-detail-action";
+var blockedUsersSelector = ({ userIds }) => ({ userIds });
+var ChannelMemberConfirmationAlert = ({ action, cancelLabel, confirmLabel, description, isSubmitting, onCancel, onConfirm, testId, title }) => /* @__PURE__ */ jsxs(Alert.Root, {
+	className: clsx("str-chat__channel-member-confirmation-alert", { [`str-chat__channel-member-confirmation-alert--${action}`]: action }),
+	"data-testid": testId,
+	children: [/* @__PURE__ */ jsx(Alert.Header, {
+		description,
+		title
+	}), /* @__PURE__ */ jsxs(Alert.Actions, { children: [/* @__PURE__ */ jsx(Button, {
+		appearance: "solid",
+		"data-testid": `${testId}-confirm-button`,
+		disabled: isSubmitting,
+		onClick: onConfirm,
+		size: "md",
+		variant: "danger",
+		children: confirmLabel
+	}), /* @__PURE__ */ jsx(Button, {
+		appearance: "outline",
+		autoFocus: true,
+		"data-testid": `${testId}-cancel-button`,
+		disabled: isSubmitting,
+		onClick: onCancel,
+		size: "md",
+		variant: "secondary",
+		children: cancelLabel
+	})] })]
+});
+var useChannelMemberActionFilterState = () => {
+	const { client } = useChatContext();
+	const { channel } = useChannelDetailContext();
+	const { targetUserId } = useChannelMemberActionContext();
+	const ownCapabilities = channel.data?.own_capabilities;
+	const isCurrentUser = targetUserId === client.user?.id;
+	return {
+		canBlockUser: !isCurrentUser && !!targetUserId,
+		canMuteUser: !isCurrentUser && !!targetUserId,
+		canRemoveUser: !isCurrentUser && !!targetUserId && ownCapabilities?.includes("update-channel-members"),
+		canSendMessage: !isCurrentUser && !!targetUserId
+	};
+};
+var useBaseChannelMemberActionSetFilter = (channelMemberActionSet) => {
+	const { canBlockUser, canMuteUser, canRemoveUser, canSendMessage } = useChannelMemberActionFilterState();
+	return useMemo(() => channelMemberActionSet.filter((action) => {
+		switch (action.type) {
+			case "blockUser": return canBlockUser;
+			case "muteUser": return canMuteUser;
+			case "removeUser": return canRemoveUser;
+			case "sendMessage": return canSendMessage;
+			default: return true;
+		}
+	}), [
+		canBlockUser,
+		canMuteUser,
+		canRemoveUser,
+		canSendMessage,
+		channelMemberActionSet
+	]);
+};
+var SendDirectMessageAction = () => {
+	const { client, setActiveChannel } = useChatContext();
+	const { setChannels } = useChannelListContext();
+	const { close } = useModalContext();
+	const { channel } = useChannelDetailContext();
+	const { addNotification } = useNotificationApi();
+	const { t } = useTranslationContext();
+	const { targetUserId } = useChannelMemberActionContext();
+	const [isSending, setIsSending] = useState(false);
+	const openDirectMessage = useCallback(async () => {
+		if (!client.userID || !targetUserId || isSending) return;
+		setIsSending(true);
+		try {
+			const directMessageChannel = client.channel(channel.type, { members: [client.userID, targetUserId] });
+			await directMessageChannel.watch();
+			setActiveChannel(directMessageChannel);
+			setChannels?.((channels) => uniqBy([directMessageChannel, ...channels], "cid"));
+			close();
+		} catch (error) {
+			addNotification({
+				context: { channel },
+				emitter: "ChannelMemberDetail",
+				error: toError(error),
+				message: t("Error opening direct message"),
+				severity: "error",
+				type: "api:channel:watch:failed"
+			});
+		} finally {
+			setIsSending(false);
+		}
+	}, [
+		addNotification,
+		channel,
+		client,
+		close,
+		isSending,
+		setActiveChannel,
+		setChannels,
+		t,
+		targetUserId
+	]);
+	return /* @__PURE__ */ jsx(ListItemLayout, {
+		LeadingIcon: SendDirectMessageActionIcon,
+		RootElement: "button",
+		rootProps: useMemo(() => ({
+			className: channelMemberDetailActionClassName,
+			disabled: isSending,
+			onClick: openDirectMessage
+		}), [isSending, openDirectMessage]),
+		title: t("Send direct message")
+	});
+};
+var UserMuteAction = () => {
+	const { channel } = useChannelDetailContext();
+	const { client, mutes } = useChatContext();
+	const { addNotification } = useNotificationApi();
+	const { t } = useTranslationContext();
+	const { targetUserId } = useChannelMemberActionContext();
+	const userMuted = !!targetUserId && mutes.some((mute) => mute.target.id === targetUserId);
+	const [optimisticUserMuted, setOptimisticUserMuted] = useState(userMuted);
+	useEffect(() => {
+		setOptimisticUserMuted(userMuted);
+	}, [userMuted]);
+	const toggleUserMuteRequest = useStableCallback((nextMuted, userId) => {
+		if (!userId) return;
+		if (!nextMuted) return client.unmuteUser(userId).then(() => addNotification({
+			context: { channel },
+			emitter: "ChannelMemberDetail",
+			message: t("User unmuted"),
+			severity: "success",
+			type: "api:user:unmute:success"
+		})).catch((error) => {
+			setOptimisticUserMuted(userMuted);
+			return addNotification({
+				context: { channel },
+				emitter: "ChannelMemberDetail",
+				error: toError(error),
+				message: t("Error unmuting user"),
+				severity: "error",
+				type: "api:user:unmute:failed"
+			});
+		});
+		return client.muteUser(userId).then(() => addNotification({
+			context: { channel },
+			emitter: "ChannelMemberDetail",
+			message: t("User muted"),
+			severity: "success",
+			type: "api:user:mute:success"
+		})).catch((error) => {
+			setOptimisticUserMuted(userMuted);
+			return addNotification({
+				context: { channel },
+				emitter: "ChannelMemberDetail",
+				error: toError(error),
+				message: t("Error muting user"),
+				severity: "error",
+				type: "api:user:mute:failed"
+			});
+		});
+	});
+	const toggleUserMute = useMemo(() => debounce(toggleUserMuteRequest, 1e3), [toggleUserMuteRequest]);
+	useEffect(() => () => {
+		toggleUserMute.cancel();
+	}, [toggleUserMute]);
+	const toggleOptimisticUserMute = useCallback(() => {
+		const nextMuted = !optimisticUserMuted;
+		setOptimisticUserMuted(nextMuted);
+		toggleUserMute(nextMuted, targetUserId);
+	}, [
+		optimisticUserMuted,
+		targetUserId,
+		toggleUserMute
+	]);
+	const rootProps = useMemo(() => ({
+		"aria-pressed": optimisticUserMuted,
+		className: clsx("str-chat__form__switch-field", channelMemberDetailActionClassName),
+		onClick: toggleOptimisticUserMute
+	}), [optimisticUserMuted, toggleOptimisticUserMute]);
+	const TrailingSlot = useMemo(() => {
+		function UserMuteSwitch() {
+			return /* @__PURE__ */ jsx(Switch, {
+				on: optimisticUserMuted,
+				presentation: true
+			});
+		}
+		return UserMuteSwitch;
+	}, [optimisticUserMuted]);
+	return /* @__PURE__ */ jsx(ListItemLayout, {
+		LeadingIcon: optimisticUserMuted ? MemberUnmuteActionIcon : MemberMuteActionIcon,
+		RootElement: "button",
+		rootProps,
+		title: optimisticUserMuted ? t("Unmute user") : t("Mute user"),
+		TrailingSlot
+	});
+};
+var BlockUserAction = () => {
+	const { client } = useChatContext();
+	const { Modal = GlobalModal } = useComponentContext();
+	const { channel } = useChannelDetailContext();
+	const { addNotification } = useNotificationApi();
+	const { t } = useTranslationContext();
+	const { memberDisplayName, targetUserId } = useChannelMemberActionContext();
+	const { userIds: blockedUserIds } = useStateStore(client.blockedUsers, blockedUsersSelector);
+	const isBlocked = !!targetUserId && new Set(blockedUserIds).has(targetUserId);
+	const [alertOpen, setAlertOpen] = useState(false);
+	const [userBlockInProgress, setUserBlockInProgress] = useState(false);
+	const closeBlockUserAlert = useCallback(() => {
+		setAlertOpen(false);
+	}, []);
+	const openBlockUserAlert = useCallback(() => {
+		setAlertOpen(true);
+	}, []);
+	const unblockUser = useCallback(async () => {
+		if (!targetUserId) return;
+		try {
+			setUserBlockInProgress(true);
+			await client.unBlockUser(targetUserId);
+			addNotification({
+				context: { channel },
+				emitter: "ChannelMemberDetail",
+				message: t("User unblocked"),
+				severity: "success",
+				type: "api:user:unblock:success"
+			});
+		} catch (error) {
+			addNotification({
+				context: { channel },
+				emitter: "ChannelMemberDetail",
+				error: toError(error),
+				message: t("Error unblocking user"),
+				severity: "error",
+				type: "api:user:unblock:failed"
+			});
+		} finally {
+			setAlertOpen(false);
+			setUserBlockInProgress(false);
+		}
+	}, [
+		addNotification,
+		channel,
+		client,
+		t,
+		targetUserId
+	]);
+	const blockUser = useCallback(async () => {
+		if (!targetUserId) return;
+		try {
+			setUserBlockInProgress(true);
+			await client.blockUser(targetUserId);
+			addNotification({
+				context: { channel },
+				emitter: "ChannelMemberDetail",
+				message: t("User blocked"),
+				severity: "success",
+				type: "api:user:block:success"
+			});
+		} catch (error) {
+			addNotification({
+				context: { channel },
+				emitter: "ChannelMemberDetail",
+				error: toError(error),
+				message: t("Error blocking user"),
+				severity: "error",
+				type: "api:user:block:failed"
+			});
+		} finally {
+			setAlertOpen(false);
+			setUserBlockInProgress(false);
+		}
+	}, [
+		addNotification,
+		channel,
+		client,
+		t,
+		targetUserId
+	]);
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(ListItemLayout, {
+		destructive: true,
+		LeadingIcon: BlockUserActionIcon,
+		RootElement: "button",
+		rootProps: useMemo(() => ({
+			className: channelMemberDetailActionClassName,
+			disabled: userBlockInProgress,
+			onClick: openBlockUserAlert
+		}), [openBlockUserAlert, userBlockInProgress]),
+		title: isBlocked ? t("Unblock user") : t("Block user")
+	}), /* @__PURE__ */ jsx(Modal, {
+		open: alertOpen,
+		role: "alertdialog",
+		children: /* @__PURE__ */ jsx(ChannelMemberConfirmationAlert, {
+			action: "blockUser",
+			cancelLabel: t("Cancel"),
+			confirmLabel: isBlocked ? t("Unblock user") : t("Block user"),
+			description: isBlocked ? t("{{ member }} will be able to message you again.", { member: memberDisplayName }) : t("{{ member }} won't be able to message you anymore.", { member: memberDisplayName }),
+			isSubmitting: userBlockInProgress,
+			onCancel: closeBlockUserAlert,
+			onConfirm: isBlocked ? unblockUser : blockUser,
+			testId: "channel-detail-block-member-alert",
+			title: isBlocked ? t("Unblock user") : t("Block user")
+		})
+	})] });
+};
+var RemoveUserAction = () => {
+	const { Modal = GlobalModal } = useComponentContext();
+	const { channel } = useChannelDetailContext();
+	const { addNotification } = useNotificationApi();
+	const { t } = useTranslationContext();
+	const { memberDisplayName, targetUserId } = useChannelMemberActionContext();
+	const [alertOpen, setAlertOpen] = useState(false);
+	const [removeMemberInProgress, setRemoveMemberInProgress] = useState(false);
+	const closeRemoveUserAlert = useCallback(() => {
+		setAlertOpen(false);
+	}, []);
+	const openRemoveUserAlert = useCallback(() => {
+		setAlertOpen(true);
+	}, []);
+	const removeUser = useCallback(async () => {
+		if (!targetUserId) return;
+		try {
+			setRemoveMemberInProgress(true);
+			await channel.removeMembers([targetUserId]);
+			addNotification({
+				context: { channel },
+				emitter: "ChannelMemberDetail",
+				message: t("User removed"),
+				severity: "success",
+				type: "api:channel:remove-members:success"
+			});
+			setAlertOpen(false);
+		} catch (error) {
+			addNotification({
+				context: { channel },
+				emitter: "ChannelMemberDetail",
+				error: toError(error),
+				message: t("Error removing user"),
+				severity: "error",
+				type: "api:channel:remove-members:failed"
+			});
+		} finally {
+			setRemoveMemberInProgress(false);
+		}
+	}, [
+		addNotification,
+		channel,
+		t,
+		targetUserId
+	]);
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(ListItemLayout, {
+		destructive: true,
+		LeadingIcon: RemoveUserActionIcon,
+		RootElement: "button",
+		rootProps: useMemo(() => ({
+			className: channelMemberDetailActionClassName,
+			disabled: removeMemberInProgress,
+			onClick: openRemoveUserAlert
+		}), [openRemoveUserAlert, removeMemberInProgress]),
+		title: t("Remove user")
+	}), /* @__PURE__ */ jsx(Modal, {
+		open: alertOpen,
+		role: "alertdialog",
+		children: /* @__PURE__ */ jsx(ChannelMemberConfirmationAlert, {
+			action: "removeUser",
+			cancelLabel: t("Cancel"),
+			confirmLabel: t("Remove user"),
+			description: t("Remove {{ member }} from this channel?", { member: memberDisplayName }),
+			isSubmitting: removeMemberInProgress,
+			onCancel: closeRemoveUserAlert,
+			onConfirm: removeUser,
+			testId: "channel-detail-remove-member-alert",
+			title: t("Remove user")
+		})
+	})] });
+};
+var DefaultChannelMemberActions = {
+	BlockUser: BlockUserAction,
+	MuteUser: UserMuteAction,
+	RemoveUser: RemoveUserAction,
+	SendDirectMessage: SendDirectMessageAction
+};
+var defaultChannelMemberActionSet = [
+	{
+		Component: DefaultChannelMemberActions.SendDirectMessage,
+		type: "sendMessage"
+	},
+	{
+		Component: DefaultChannelMemberActions.MuteUser,
+		type: "muteUser"
+	},
+	{
+		Component: DefaultChannelMemberActions.BlockUser,
+		type: "blockUser"
+	},
+	{
+		Component: DefaultChannelMemberActions.RemoveUser,
+		type: "removeUser"
+	}
+];
+//#endregion
+//#region src/plugins/ChannelDetail/Views/ChannelMemberDetailView/ChannelMemberDetail.tsx
+var getPresenceStatusText = (user, t) => {
+	if (user?.online) return t("Online");
+	if (user?.last_active) return t("Last seen {{ timestamp }}", { timestamp: t("timestamp/ChannelMembersLastActive", { timestamp: user.last_active }) });
+	return t("Offline");
+};
+var ChannelMemberDetail = ({ channelMemberActionSet = defaultChannelMemberActionSet, member, onBack }) => {
+	const { t } = useTranslationContext();
+	const memberDisplayName = getMemberDisplayName(member);
+	const memberStatusText = getPresenceStatusText(member.user, t);
+	return /* @__PURE__ */ jsx(ChannelMemberActionProvider, {
+		value: useMemo(() => ({
+			member,
+			memberDisplayName,
+			targetUserId: member.user?.id || member.user_id
+		}), [member, memberDisplayName]),
+		children: /* @__PURE__ */ jsx(ChannelMemberDetailContent, {
+			channelMemberActionSet,
+			memberDisplayName,
+			memberStatusText,
+			onBack
+		})
+	});
+};
+var ChannelMemberDetailContent = ({ channelMemberActionSet, memberDisplayName, memberStatusText, onBack }) => {
+	const { close } = useModalContext();
+	const { t } = useTranslationContext();
+	const { Avatar = ChannelAvatar } = useComponentContext();
+	const { member } = useChannelMemberActionContext();
+	const filteredActions = useBaseChannelMemberActionSetFilter(channelMemberActionSet);
+	return /* @__PURE__ */ jsxs("div", {
+		className: "str-chat__channel-detail__channel-member-detail-view",
+		children: [/* @__PURE__ */ jsx(SectionNavigatorHeader, {
+			close,
+			goBack: onBack,
+			title: t("Member detail")
+		}), /* @__PURE__ */ jsxs(Prompt.Body, {
+			className: "str-chat__channel-detail__channel-member-detail-view__body",
+			children: [/* @__PURE__ */ jsxs("div", {
+				className: "str-chat__channel-detail__channel-member-detail-view__profile",
+				children: [/* @__PURE__ */ jsx(Avatar, {
+					imageUrl: member.user?.image,
+					isOnline: member.user?.online,
+					size: "2xl",
+					userName: memberDisplayName
+				}), /* @__PURE__ */ jsxs("div", {
+					className: "str-chat__channel-detail__channel-member-detail-view__profile__details",
+					children: [/* @__PURE__ */ jsx("div", {
+						className: "str-chat__channel-detail__channel-member-detail-view__profile__details__title",
+						children: memberDisplayName
+					}), /* @__PURE__ */ jsx("div", {
+						className: "str-chat__channel-detail__channel-member-detail-view__profile__details__connection-status",
+						children: memberStatusText
+					})]
+				})]
+			}), /* @__PURE__ */ jsx("div", {
+				className: "str-chat__channel-detail__channel-member-detail-view__actions str-chat__form__switch-fieldset",
+				children: filteredActions.map(({ Component, type }) => /* @__PURE__ */ jsx(Component, {}, type))
+			})]
+		})]
+	});
+};
+//#endregion
+//#region src/plugins/ChannelDetail/Views/ChannelMembersView/ChannelMembersView.tsx
+var RESERVED_MODES = ["browse", "memberDetail"];
+var isReservedMode = (mode) => RESERVED_MODES.includes(mode);
+var AddMembersModeTitle = () => {
+	const { t } = useTranslationContext();
+	return /* @__PURE__ */ jsx(Fragment$1, { children: t("Add members") });
+};
+/** Built-in mode descriptors. Merged with (and overridable by) the `modeViews` prop. */
+var defaultChannelMembersModeViews = { add: {
+	Body: ChannelMembersAddView,
+	Title: AddMembersModeTitle
+} };
+var ChannelMembersView = ({ HeaderActions = DefaultHeaderActions, headerActionSet = defaultChannelMembersHeaderActionSet, HeaderActionsMenuTrigger, layout, modeViews: customModeViews }) => {
+	const { t } = useTranslationContext();
+	const { channel } = useChannelDetailContext();
+	const { close } = useModalContext();
+	const [mode, setMode] = useState("browse");
+	const [selectedMember, setSelectedMember] = useState();
+	const memberCount = useChannelMemberCount(channel);
+	const modeViews = useMemo(() => ({
+		...defaultChannelMembersModeViews,
+		...customModeViews
+	}), [customModeViews]);
+	const activeModeDescriptor = isReservedMode(mode) ? void 0 : modeViews[mode];
+	const isViewingMemberDetail = mode === "memberDetail";
+	const setViewMode = useCallback((nextMode) => {
+		setMode(nextMode);
+		if (nextMode !== "memberDetail") setSelectedMember(void 0);
+	}, []);
+	useEffect(() => {
+		if (!isReservedMode(mode) && !modeViews[mode]) setViewMode("browse");
+	}, [
+		mode,
+		modeViews,
+		setViewMode
+	]);
+	const goBack = useCallback(() => setViewMode("browse"), [setViewMode]);
+	const modeController = useMemo(() => ({
+		mode,
+		setMode: setViewMode
+	}), [mode, setViewMode]);
+	const HeaderTrailingActions = useMemo(() => function HeaderTrailingActions() {
+		if (mode !== "browse") return null;
+		return /* @__PURE__ */ jsx(HeaderActions, {
+			headerActionSet,
+			HeaderActionsMenuTrigger,
+			modeController
+		});
+	}, [
+		HeaderActions,
+		HeaderActionsMenuTrigger,
+		modeController,
+		headerActionSet,
+		mode
+	]);
+	if (isViewingMemberDetail && selectedMember) return /* @__PURE__ */ jsx(ChannelMemberDetail, {
+		layout,
+		member: selectedMember,
+		onBack: goBack
+	});
+	const ActiveModeTitle = activeModeDescriptor?.Title;
+	const ActiveModeBody = activeModeDescriptor?.Body;
+	return /* @__PURE__ */ jsxs("div", {
+		className: "str-chat__channel-detail__channel-members-view",
+		children: [/* @__PURE__ */ jsx(SectionNavigatorHeader, {
+			close,
+			description: activeModeDescriptor ? void 0 : t("Browse channel members"),
+			goBack: activeModeDescriptor ? goBack : void 0,
+			title: ActiveModeTitle ? /* @__PURE__ */ jsx(ActiveModeTitle, {}) : t("{{ count }} members", { count: memberCount }),
+			TrailingContent: HeaderTrailingActions
+		}), ActiveModeBody ? /* @__PURE__ */ jsx(ActiveModeBody, { modeController }) : /* @__PURE__ */ jsx(ChannelMembersBrowseView, { onMemberSelect: (member) => {
+			setSelectedMember(member);
+			setViewMode("memberDetail");
+		} })]
+	});
+};
+//#endregion
+//#region src/plugins/ChannelDetail/Views/PinnedMessagesView/PinnedMessagesEmptyList.tsx
+var PinnedMessagesEmptyList = () => {
+	const { t } = useTranslationContext();
+	return /* @__PURE__ */ jsxs("div", {
+		className: "str-chat__channel-detail__pinned-messages-view__empty-state",
+		children: [/* @__PURE__ */ jsx(IconPin, { className: "str-chat__channel-detail__pinned-messages-view__empty-state__icon" }), /* @__PURE__ */ jsxs("div", {
+			className: "str-chat__channel-detail__pinned-messages-view__empty-state__content",
+			children: [/* @__PURE__ */ jsx("p", {
+				className: "str-chat__channel-detail__pinned-messages-view__empty-state__title",
+				children: t("No pinned messages")
+			}), /* @__PURE__ */ jsx("p", {
+				className: "str-chat__channel-detail__pinned-messages-view__empty-state__description",
+				children: t("Pin a message to see it here")
+			})]
+		})]
+	});
+};
+//#endregion
+//#region src/plugins/ChannelDetail/Views/PinnedMessagesView/usePinnedMessagesCount.ts
+var PINNED_MESSAGES_EVENTS = [
+	"message.new",
+	"message.updated",
+	"message.deleted",
+	"message.undeleted"
+];
+var getPinnedMessagesCount = (channel) => channel.state?.pinnedMessages?.length ?? 0;
+/** Reactive count of the channel's pinned messages derived from channel state. */
+var usePinnedMessagesCount = (channel) => {
+	const [pinnedMessagesCount, setPinnedMessagesCount] = useState(() => getPinnedMessagesCount(channel));
+	useEffect(() => {
+		const syncPinnedMessagesCount = () => setPinnedMessagesCount(getPinnedMessagesCount(channel));
+		syncPinnedMessagesCount();
+		const subscriptions = PINNED_MESSAGES_EVENTS.map((event) => channel.on(event, syncPinnedMessagesCount));
+		return () => subscriptions.forEach((subscription) => subscription.unsubscribe());
+	}, [channel]);
+	return pinnedMessagesCount;
+};
+//#endregion
+//#region src/plugins/ChannelDetail/Views/PinnedMessagesView/usePinnedMessagesSearch.ts
+var PINNED_MESSAGES_SEARCH_PAGE_SIZE = 30;
+var PINNED_MESSAGES_SEARCH_DEBOUNCE_MS = 300;
+var pinnedMessagesSearchSourceItemsStateSelector = (state) => ({ messages: state.items });
+var usePinnedMessagesSearch = ({ searchSource } = {}) => {
+	const { client } = useChatContext();
+	const { channel } = useChannelDetailContext();
+	const pinnedMessagesSearchSource = useMemo(() => {
+		const source = searchSource ?? new MessageSearchSource(client, {
+			allowEmptySearchString: true,
+			debounceMs: PINNED_MESSAGES_SEARCH_DEBOUNCE_MS,
+			pageSize: PINNED_MESSAGES_SEARCH_PAGE_SIZE,
+			resetOnNewSearchQuery: false
+		}, { messageSearch: { initialFilterConfig: { text: {
+			enabled: true,
+			generate: ({ searchQuery }) => searchQuery ? { text: { $autocomplete: searchQuery } } : null
+		} } } });
+		if (!searchSource) {
+			source.messageSearchChannelFilters = { cid: channel.cid };
+			source.messageSearchFilters = { pinned: true };
+		}
+		return source;
+	}, [
+		channel.cid,
+		client,
+		searchSource
+	]);
+	const { messages } = useStateStore(pinnedMessagesSearchSource.state, pinnedMessagesSearchSourceItemsStateSelector);
+	useEffect(() => {
+		pinnedMessagesSearchSource.activate();
+		return () => {
+			pinnedMessagesSearchSource.cancelScheduledQuery();
+		};
+	}, [pinnedMessagesSearchSource]);
+	const hasPinnedMessages = usePinnedMessagesCount(channel) > 0;
+	useEffect(() => {
+		if (!hasPinnedMessages) return;
+		pinnedMessagesSearchSource.search("");
+	}, [hasPinnedMessages, pinnedMessagesSearchSource]);
+	const handleSearchChange = useCallback((query) => {
+		const trimmedQuery = query.trim();
+		if (!trimmedQuery) {
+			pinnedMessagesSearchSource.cancelScheduledQuery();
+			pinnedMessagesSearchSource.resetState();
+			pinnedMessagesSearchSource.activate();
+			pinnedMessagesSearchSource.search("");
+			return;
+		}
+		pinnedMessagesSearchSource.search(trimmedQuery);
+	}, [pinnedMessagesSearchSource]);
+	return {
+		displayedMessages: messages ?? [],
+		handleSearchChange,
+		hasPinnedMessages,
+		hasSearchResultsLoaded: Array.isArray(messages),
+		pinnedMessagesSearchSource
+	};
+};
+//#endregion
+//#region src/plugins/ChannelDetail/Views/PinnedMessagesView/PinnedMessagesView.tsx
+var computeItemKey = (_, message) => message.id;
+var normalizeTimestamp = (timestamp) => {
+	if (!timestamp) return void 0;
+	return isDate(timestamp) ? timestamp.toISOString() : timestamp;
+};
+var getPinnedMessagePreview = (message, t) => {
+	const text = message.text?.trim();
+	if (text) return text;
+	const attachment = message.attachments?.[0];
+	return attachment?.title || attachment?.text || attachment?.fallback || attachment?.type || t("Pinned message");
+};
+var PinnedMessageDate = ({ message }) => {
+	const { t, tDateTimeParser } = useTranslationContext("PinnedMessageDate");
+	const normalizedTimestamp = normalizeTimestamp(message.created_at);
+	const when = useMemo(() => getDateString({
+		messageCreatedAt: normalizedTimestamp,
+		t,
+		tDateTimeParser,
+		timestampTranslationKey: "timestamp/ChannelDetailPinnedMessageTimestamp"
+	}), [
+		normalizedTimestamp,
+		t,
+		tDateTimeParser
+	]);
+	if (!when) return null;
+	return /* @__PURE__ */ jsx("time", {
+		className: "str-chat__channel-detail__pinned-messages-view__list-item__date",
+		dateTime: normalizedTimestamp,
+		children: when
+	});
+};
+var PinnedMessagesViewItem = ({ message, onSelect }) => {
+	const { t } = useTranslationContext();
+	const displayName = getUserDisplayName(message.user ?? void 0);
+	const LeadingSlot = useMemo(() => function MessageAuthorAvatar() {
+		return /* @__PURE__ */ jsx(Avatar, {
+			imageUrl: message.user?.image,
+			size: "md",
+			userName: displayName
+		});
+	}, [displayName, message.user?.image]);
+	const TrailingSlot = useMemo(() => function MessageDate() {
+		return /* @__PURE__ */ jsx(PinnedMessageDate, { message });
+	}, [message]);
+	return /* @__PURE__ */ jsx(ListItemLayout, {
+		LeadingSlot,
+		RootElement: "button",
+		rootProps: useMemo(() => ({
+			className: "str-chat__channel-detail__pinned-messages-view__list-item",
+			onClick: () => onSelect(message)
+		}), [message, onSelect]),
+		subtitle: getPinnedMessagePreview(message, t),
+		subtitleClassName: "str-chat__channel-detail__pinned-messages-view__list-item__message-preview",
+		title: displayName,
+		TrailingSlot
+	});
+};
+var PinnedMessagesView = ({ searchSource }) => {
+	const { setActiveChannel } = useChatContext();
+	const { t } = useTranslationContext();
+	const { close } = useModalContext();
+	const { jumpToMessage } = useChannelActionContext();
+	const { channel } = useChannelDetailContext();
+	const { displayedMessages, handleSearchChange, hasPinnedMessages, hasSearchResultsLoaded, pinnedMessagesSearchSource } = usePinnedMessagesSearch({ searchSource });
+	const handleSelectMessage = useCallback((message) => {
+		setActiveChannel(channel);
+		jumpToMessage(message.id);
+		close();
+	}, [
+		channel,
+		close,
+		jumpToMessage,
+		setActiveChannel
+	]);
+	const renderItem = useCallback((_, message) => /* @__PURE__ */ jsx(PinnedMessagesViewItem, {
+		message,
+		onSelect: handleSelectMessage
+	}), [handleSelectMessage]);
+	const EmptyPlaceholder = useMemo(() => function PinnedMessagesEmptyPlaceholder() {
+		if (!hasPinnedMessages) return /* @__PURE__ */ jsx(PinnedMessagesEmptyList, {});
+		if (hasSearchResultsLoaded) return /* @__PURE__ */ jsx(ChannelDetailEmptyList, { children: t("No messages found") });
+		return null;
+	}, [
+		hasPinnedMessages,
+		hasSearchResultsLoaded,
+		t
+	]);
+	const Footer = useMemo(() => function PinnedMessagesListFooter() {
+		return /* @__PURE__ */ jsx(ChannelDetailListLoadingIndicator, { searchSource: pinnedMessagesSearchSource });
+	}, [pinnedMessagesSearchSource]);
+	return /* @__PURE__ */ jsxs("div", {
+		className: "str-chat__channel-detail__pinned-messages-view",
+		children: [/* @__PURE__ */ jsx(SectionNavigatorHeader, {
+			close,
+			description: t("Browse pinned messages"),
+			title: t("Pinned messages")
+		}), /* @__PURE__ */ jsxs(Prompt.Body, {
+			className: "str-chat__channel-detail__pinned-messages-view__body",
+			children: [hasPinnedMessages && /* @__PURE__ */ jsx(ChannelDetailSearchInput, { onSearchChange: handleSearchChange }), /* @__PURE__ */ jsx(VirtualizedList, {
+				className: "str-chat__channel-detail__pinned-messages-view__list",
+				computeItemKey,
+				data: displayedMessages,
+				EmptyPlaceholder,
+				Footer,
+				itemContent: renderItem,
+				loadNext: hasPinnedMessages ? pinnedMessagesSearchSource.search : void 0
+			})]
+		})]
+	});
+};
+//#endregion
+//#region src/plugins/ChannelDetail/ChannelDetail.tsx
+var ChannelManagementNavButtonIcon = () => /* @__PURE__ */ jsx(IconInfo, { className: "str-chat__channel-detail__action-icon" });
+var ChannelMembersNavButtonIcon = () => /* @__PURE__ */ jsx(IconUser, { className: "str-chat__channel-detail__action-icon" });
+var PinnedMessagesNavButtonIcon = () => /* @__PURE__ */ jsx(IconPin, { className: "str-chat__channel-detail__action-icon" });
+var ChannelMediaNavButtonIcon = () => /* @__PURE__ */ jsx(IconImage, { className: "str-chat__channel-detail__action-icon" });
+var ChannelFilesNavButtonIcon = () => /* @__PURE__ */ jsx(IconFolder, { className: "str-chat__channel-detail__action-icon" });
+var ChannelManagementNavButton = (props) => /* @__PURE__ */ jsx(ChannelDetailNavButton, {
+	...props,
+	LeadingIcon: ChannelManagementNavButtonIcon,
+	title: "Channel info"
+});
+var ChannelMembersNavButton = (props) => /* @__PURE__ */ jsx(ChannelDetailNavButton, {
+	...props,
+	LeadingIcon: ChannelMembersNavButtonIcon,
+	title: "Members"
+});
+var PinnedMessagesNavButton = (props) => /* @__PURE__ */ jsx(ChannelDetailNavButton, {
+	...props,
+	LeadingIcon: PinnedMessagesNavButtonIcon,
+	title: "Pinned messages"
+});
+var ChannelMediaNavButton = (props) => /* @__PURE__ */ jsx(ChannelDetailNavButton, {
+	...props,
+	LeadingIcon: ChannelMediaNavButtonIcon,
+	title: "Photos & videos"
+});
+var ChannelFilesNavButton = (props) => /* @__PURE__ */ jsx(ChannelDetailNavButton, {
+	...props,
+	LeadingIcon: ChannelFilesNavButtonIcon,
+	title: "Files"
+});
+var defaultChannelDetailSections = [
+	{
+		id: "channel-info",
+		NavButton: ChannelManagementNavButton,
+		SectionContent: ChannelManagementView
+	},
+	{
+		id: "channel-members",
+		NavButton: ChannelMembersNavButton,
+		SectionContent: ChannelMembersView
+	},
+	{
+		id: "pinned-messages",
+		NavButton: PinnedMessagesNavButton,
+		SectionContent: PinnedMessagesView
+	},
+	{
+		id: "channel-media",
+		NavButton: ChannelMediaNavButton,
+		SectionContent: ChannelMediaView
+	},
+	{
+		id: "channel-files",
+		NavButton: ChannelFilesNavButton,
+		SectionContent: ChannelFilesView
+	}
+];
+var ChannelDetail = ({ channel, className, defaultLayout = SECTION_NAVIGATOR_LAYOUT.tabs, sections = defaultChannelDetailSections, ...props }) => {
+	const [layout, setLayout] = useState(defaultLayout);
+	return /* @__PURE__ */ jsx(ChannelDetailProvider, {
+		channel,
+		children: /* @__PURE__ */ jsx(Prompt.Root, {
+			className: clsx("str-chat__channel-detail", { "str-chat__channel-detail--inline": layout === SECTION_NAVIGATOR_LAYOUT.inline }, className),
+			children: /* @__PURE__ */ jsx(SectionNavigator, {
+				...props,
+				defaultLayout,
+				onLayoutChange: setLayout,
+				sections
+			})
+		})
+	});
+};
+//#endregion
+//#region src/plugins/ChannelDetail/AvatarWithChannelDetail.tsx
+var avatarWithChannelDetailDialogRootProps = { className: "str-chat__channel-detail-modal" };
+var AvatarWithChannelDetail = ({ Avatar, ChannelDetail: ChannelDetail$1 = ChannelDetail, className, ...avatarProps }) => {
+	const { t } = useTranslationContext();
+	const { channel } = useChannelStateContext();
+	const { Avatar: ContextAvatar, Modal = GlobalModal } = useComponentContext();
+	const [isModalOpen, setIsModalOpen] = useState(false);
+	const openModal = useCallback(() => setIsModalOpen(true), []);
+	const closeModal = useCallback(() => setIsModalOpen(false), []);
+	const AvatarComponent = Avatar ?? (ContextAvatar === AvatarWithChannelDetail ? void 0 : ContextAvatar) ?? ChannelAvatar;
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("button", {
+		"aria-label": t("aria/Open channel details"),
+		className: "str-chat__avatar-with-channel-detail-button",
+		onClick: openModal,
+		type: "button",
+		children: /* @__PURE__ */ jsx(AvatarComponent, {
+			...avatarProps,
+			className: clsx("str-chat__avatar-with-channel-detail-button__avatar", className)
+		})
+	}), /* @__PURE__ */ jsx(Modal, {
+		"aria-label": t("aria/Channel details"),
+		dialogRootProps: avatarWithChannelDetailDialogRootProps,
+		onClose: closeModal,
+		open: isModalOpen,
+		children: /* @__PURE__ */ jsx(ChannelDetail$1, { channel })
+	})] });
+};
+//#endregion
+export { AvatarWithChannelDetail, ChannelDetail, ChannelDetailEmptyList, ChannelDetailListLoadingIndicator, ChannelDetailNavButton, ChannelDetailProvider, ChannelDetailSearchInput, ChannelFilesEmptyList, ChannelFilesNavButton, ChannelFilesView, ChannelManagementEditBody, ChannelManagementInfoBody, ChannelManagementNavButton, ChannelManagementView, ChannelMediaEmptyList, ChannelMediaNavButton, ChannelMediaView, ChannelMemberActionProvider, ChannelMemberDetail, ChannelMembersAddView, ChannelMembersBrowseView, ChannelMembersNavButton, ChannelMembersView, DefaultChannelManagementActions, DefaultChannelMemberActions, DefaultChannelMembersHeaderActions, DefaultHeaderActions, DefaultHeaderActionsMenuTrigger, FILE_ATTACHMENT_TYPES, MEDIA_ATTACHMENT_TYPES, PinnedMessagesEmptyList, PinnedMessagesNavButton, PinnedMessagesView, SECTION_NAVIGATOR_LAYOUT, SectionNavigator, SectionNavigatorHeader, defaultChannelDetailSections, defaultChannelManagementActionSet, defaultChannelMemberActionSet, defaultChannelMembersHeaderActionSet, defaultChannelMembersModeViews, toChannelFileSections, toChannelMediaItems, useBaseChannelManagementActionSetFilter, useBaseChannelMemberActionSetFilter, useBaseChannelMembersHeaderActionSetFilter, useChannelDetailContext, useChannelFilesSearch, useChannelMediaSearch, useChannelMemberActionContext, useChannelMembersSearch, usePinnedMessagesSearch, useSectionNavigatorContext };
+
+//# sourceMappingURL=channel-detail.mjs.map