feat: add reveal intent to the slot geometry

Author: MartinCupela

examples/vite/src/App.tsx

@@ -53,6 +53,8 @@ import {
   OPTIONAL_THREAD_SLOT,
 } from './ChatLayout/constants.ts';
 import { ChatSkipNavigation } from './AccessibilityNavigation/ChatSkipNavigation.tsx';
+import { SlotGeometryProvider } from 'stream-chat-react/slot-geometry';
+import { AlsoSentInChannelIndicator } from './ChatLayout/AlsoSentInChannelIndicator.tsx';
 import { ChannelsPanels, ThreadsPanels } from './ChatLayout/Panels.tsx';
 import { SidebarProvider } from './ChatLayout/SidebarContext.tsx';
 import {
@@ -481,7 +483,6 @@ const App = () => {
     [initialPanelLayout.leftPanel.width, initialPanelLayout.threadPanel.width],
   );
 
-  // Memoized so the ChatView `views` map keeps a stable reference across renders.
   const chatViews = useMemo(
     () => ({
       channels: (
@@ -531,6 +532,10 @@ const App = () => {
   return (
     <WithComponents
       overrides={{
+        // Coverage-aware "Also sent in channel → View": records a reveal intent that a
+        // channels-view effect resolves after navigation (works across the threads → channels
+        // switch; closes the covering thread only when it actually covers).
+        MessageAlsoSentInChannelIndicator: AlsoSentInChannelIndicator,
         emojiSearchIndex: SearchIndex,
         EmojiPicker: EmojiPickerWithCustomOptions,
         NotificationList: ConfigurableNotificationList,
@@ -566,16 +571,22 @@ const App = () => {
                 iconOnly={chatView.iconOnly}
                 layoutRef={appLayoutRef}
               />
-              <ChatView
-                dialogManagerId={globalDialogManager}
-                layouts={chatViewLayouts}
-                maxSlots={2}
-                minSlots={2}
-                views={chatViews}
-              >
-                <ChatStateSync initialChatView={initialChatView} />
-                <SidebarLayoutSync />
-              </ChatView>
+              {/* Geometry provider spans the whole ChatView so slot-coverage state and the reveal
+                  intent are shared across views (the "Also sent in channel → View" indicator sets
+                  the intent in the threads view; the channels panels resolve it after navigating).
+                  Instance-scoped — not a module singleton — so other chat surfaces don't collide. */}
+              <SlotGeometryProvider>
+                <ChatView
+                  dialogManagerId={globalDialogManager}
+                  layouts={chatViewLayouts}
+                  maxSlots={2}
+                  minSlots={2}
+                  views={chatViews}
+                >
+                  <ChatStateSync initialChatView={initialChatView} />
+                  <SidebarLayoutSync />
+                </ChatView>
+              </SlotGeometryProvider>
             </div>
           </div>
           {/* The single-channel scenario floats over the full app in a draggable modal (the full

examples/vite/src/ChatLayout/AlsoSentInChannelIndicator.tsx

@@ -1,29 +1,29 @@
 import {
   MessageAlsoSentInChannelIndicator,
-  useChatViewNavigation,
   useMessageAlsoSentInChannelNavigation,
 } from 'stream-chat-react';
 import { useSlotGeometry } from 'stream-chat-react/slot-geometry';
 
-import { CHANNEL_THREAD_SLOT, MAIN_CHANNEL_SLOT } from './constants';
+import { MAIN_CHANNEL_SLOT } from './constants';
 
 /**
  * Coverage-aware "Also sent in channel" indicator. It reuses the SDK default component and its
- * navigation hook — no logic or markup is copied — and only augments the click: when jumping to the
- * channel from inside the reply thread, it first releases the thread slot **if** the geometry module
- * reports the channel column is actually obscured (collapsed under / covered by the thread) right
- * now. On wide side-by-side layouts the channel isn't obscured, so the thread stays open.
+ * navigation hook — no logic or markup is copied — and only records a one-shot intent (on the
+ * geometry provider) to reveal the channel column when jumping to it from inside a reply thread.
  *
- * Coverage is app-layout knowledge (this example's responsive CSS), so it lives here rather than in
- * the SDK — measured from real DOM rects, no breakpoint or class-name coupling.
+ * The actual "close the covering thread" decision is deferred to a channels-view effect
+ * (in `ResponsiveChannelPanels`), because it must run *after* navigation: in the cross-view
+ * case (threads → channels) the channel isn't mounted or measurable at click time. The effect closes
+ * the thread only when the geometry plugin reports the channel is actually obscured, so wide
+ * side-by-side layouts keep the thread. This scopes the behavior to this navigation only — it does
+ * not change global channel-open semantics.
  */
 export const AlsoSentInChannelIndicator = () => {
   const { isInThread, viewReference } = useMessageAlsoSentInChannelNavigation();
-  const { close } = useChatViewNavigation();
-  const { isObscured } = useSlotGeometry();
+  const { requestReveal } = useSlotGeometry();
 
   const onView = async () => {
-    if (isInThread && isObscured(MAIN_CHANNEL_SLOT)) close(CHANNEL_THREAD_SLOT);
+    if (isInThread) requestReveal(MAIN_CHANNEL_SLOT);
     await viewReference();
   };