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

package/dist/types/plugins/SlotGeometry/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/SlotGeometry/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,oBAAoB,EACpB,eAAe,EACf,uBAAuB,GACxB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EACV,YAAY,EACZ,YAAY,EACZ,wBAAwB,EACxB,MAAM,GACP,MAAM,gBAAgB,CAAC"}

package/dist/types/plugins/SlotLayout/ChannelSlot.d.ts

@@ -0,0 +1,24 @@
+import { type ChannelProps } from '../../components/Channel';
+import type { PropsWithChildren, ReactNode } from 'react';
+import type { SlotName } from './layoutController/layoutControllerTypes';
+export type ChannelSlotProps = PropsWithChildren<Omit<ChannelProps, 'channel'> & {
+    /** Rendered when no channel is bound to `slot`. */
+    fallback?: ReactNode;
+    /**
+     * The layout slot this adapter renders. Always pass an explicit `slot` — a
+     * generic list/workspace must be precise about which slot it displays (multiple
+     * channels can be open side by side). Omitting it falls back to the first
+     * channel slot and is only meaningful for a single-channel workspace.
+     */
+    slot?: SlotName;
+}>;
+/**
+ * ChatView-aware channel adapter: renders the channel bound to `slot`.
+ *
+ * It only *displays* — it never adopts/moves a channel from another slot. Which
+ * channel goes into which slot is decided by navigation (`open`). If your app
+ * resolves channel instances directly from layout bindings (e.g. via custom
+ * `slotRenderers`), render `<Channel channel={...} />` directly and skip this.
+ */
+export declare const ChannelSlot: ({ children, fallback, slot, ...channelProps }: ChannelSlotProps) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ChannelSlot.d.ts.map

package/dist/types/plugins/SlotLayout/ChannelSlot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChannelSlot.d.ts","sourceRoot":"","sources":["../../../../src/plugins/SlotLayout/ChannelSlot.tsx"],"names":[],"mappings":"AAGA,OAAO,EAA+B,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAG1F,OAAO,KAAK,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAC1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0CAA0C,CAAC;AAEzE,MAAM,MAAM,gBAAgB,GAAG,iBAAiB,CAC9C,IAAI,CAAC,YAAY,EAAE,SAAS,CAAC,GAAG;IAC9B,mDAAmD;IACnD,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB;;;;;OAKG;IACH,IAAI,CAAC,EAAE,QAAQ,CAAC;CACjB,CACF,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,GAAI,+CAKzB,gBAAgB,4CAYlB,CAAC"}

package/dist/types/plugins/SlotLayout/ChatView.a11y.utility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChatView.a11y.utility.d.ts","sourceRoot":"","sources":["../../../../src/plugins/SlotLayout/ChatView.a11y.utility.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACrC,gBAAgB,EAAE,MAAM,CAAC,UAAU,GAAG,SAAS,EAAE,MAAM,CAAC,CAAC;CAC1D,CAAC;AAEF,eAAO,MAAM,oCAAoC,EAAE,wBAKlD,CAAC;AAEF,eAAO,MAAM,8BAA8B,GACzC,YAAY,MAAM,KACjB,wBAKD,CAAC"}

package/dist/types/plugins/SlotLayout/ChatView.d.ts

@@ -0,0 +1,113 @@
+import React, { type ComponentType, type ReactNode } from 'react';
+import { type ButtonProps } from '../../components/Button';
+import type { DeriveWorkspaceNavigation } from './workspaceNavigationAdapter';
+import type { PropsWithChildren } from 'react';
+import type { Thread } from 'stream-chat';
+import type { DuplicateEntityPolicy, LayoutController, LayoutSlotBinding, ResolveDuplicateEntity, SlotName } from './layoutController/layoutControllerTypes';
+import type { ChatViewEntityBinding, ChatViewSlotFallbackProps, ChatViewSlotRenderers, LayoutDescriptor } from './slotBinding';
+export * from './slotBinding';
+export type { SlotKindDefinition, SlotKindRegistry } from './slotRegistry';
+export { defaultSlotKindRegistry } from './slotRegistry';
+export type ChatView = 'channels' | 'threads';
+/**
+ * ChatView switches between two independent surfaces, not panels in a single
+ * WAI-ARIA Tabs widget. The selector is a navigation landmark
+ * (`role="navigation"`) holding one button per surface; the button for the
+ * surface currently shown is marked with `aria-current="true"` (the "current
+ * item in a set" — not `"page"`, since this SDK view may be embedded in a larger
+ * host UI that owns the page). View wrappers stay plain `<div>`s (id only, from
+ * `chatViewPanelIds`) to avoid leaking ancestor context into descendants like
+ * the composer textarea.
+ */
+export type ChatViewEntityInferer = {
+    kind: ChatViewEntityBinding['kind'];
+    match: (source: unknown) => boolean;
+    toBinding: (source: unknown) => ChatViewEntityBinding;
+};
+export type ChatViewBuiltinLayout = 'nav-rail-entity-list-workspace';
+export type ChatViewProps = PropsWithChildren<{
+    /**
+     * Optional id for the dialog manager ChatView hosts inside its `.str-chat` root. Dialogs
+     * opened by view content (context menus, member actions, …) resolve to this manager and
+     * their overlays render under `.str-chat`, so the SDK's `.str-chat`-scoped dialog CSS
+     * applies. Omit for a local (unregistered) manager.
+     */
+    /**
+     * Optionally override the {@link WorkspaceNavigation} the ChatView provides — e.g. make
+     * `openChannel`/`openThread` open beside the current content on ⌘/ctrl-click. Receives the
+     * SDK-derived navigation and returns only the members to override — the rest keep their default.
+     * Must be referentially stable.
+     */
+    deriveWorkspaceNavigation?: DeriveWorkspaceNavigation;
+    dialogManagerId?: string;
+    duplicateEntityPolicy?: DuplicateEntityPolicy;
+    entityInferrers?: ChatViewEntityInferer[];
+    layout?: ChatViewBuiltinLayout;
+    layoutController?: LayoutController;
+    layouts?: LayoutDescriptor[];
+    resolveDuplicateEntity?: ResolveDuplicateEntity;
+    SlotFallback?: ComponentType<ChatViewSlotFallbackProps>;
+    slotFallbackComponents?: Partial<Record<string, ComponentType<ChatViewSlotFallbackProps>>>;
+    slotRenderers?: ChatViewSlotRenderers;
+    /**
+     * Per-view content (D8). The active view's node is rendered inside an a11y tabpanel;
+     * that view's slot topology comes from the matching `layouts` descriptor, and
+     * `viewActionSlotResolvers[view]` (if any) is registered while it is active. Replaces
+     * the removed `ChatView.Channels`/`ChatView.Threads` gated components — the app writes
+     * one mapping instead of two hand-composed, activeView-gated trees.
+     */
+    views?: Partial<Record<ChatView, ReactNode>>;
+    /** Optional per-view navigation action slot resolvers. */
+    viewActionSlotResolvers?: Partial<Record<ChatView, ViewActionSlotResolvers>>;
+}>;
+export type ChatViewNavigationAction = 'openChannel' | 'openThread';
+export type ResolveViewActionTargetSlotArgs = {
+    action: ChatViewNavigationAction;
+    activeView: ChatView;
+    availableSlots: SlotName[];
+    requestedSlot?: SlotName;
+    slotBindings: Record<SlotName, LayoutSlotBinding | undefined>;
+    slotNames?: SlotName[];
+};
+export type ResolveViewActionTargetSlot = (args: ResolveViewActionTargetSlotArgs) => SlotName | undefined;
+export type ViewActionSlotResolvers = Partial<Record<ChatViewNavigationAction, ResolveViewActionTargetSlot>>;
+type ChatViewContextValue = {
+    activeView: ChatView;
+    entityInferers: ChatViewEntityInferer[];
+    layoutController: LayoutController;
+    registerViewActionSlotResolvers: (view: ChatView, resolvers?: ViewActionSlotResolvers) => void;
+    resolveActionTargetSlot: (view: ChatView, args: ResolveViewActionTargetSlotArgs) => SlotName | undefined;
+    setActiveView: (cv: ChatView) => void;
+};
+export declare const ChatViewContext: React.Context<ChatViewContextValue | undefined>;
+export declare const useChatViewContext: () => ChatViewContextValue;
+export declare const ChatView: {
+    ({ children, deriveWorkspaceNavigation, dialogManagerId, duplicateEntityPolicy, entityInferrers, layout, layoutController, layouts: layoutsProp, resolveDuplicateEntity, SlotFallback, slotFallbackComponents, slotRenderers, viewActionSlotResolvers: viewActionSlotResolversProp, views, }: ChatViewProps): import("react/jsx-runtime").JSX.Element;
+    Selector: ({ iconOnly, itemSet, }: ChatViewSelectorProps) => import("react/jsx-runtime").JSX.Element;
+};
+export declare const useActiveThread: ({ activeThread }: {
+    activeThread?: Thread;
+}) => void;
+export declare const ChatViewSelectorButton: ({ ActiveIcon, children, className, Icon, iconOnly, isActive, text, ...props }: ButtonProps & {
+    ActiveIcon?: ComponentType;
+    iconOnly?: boolean;
+    Icon?: ComponentType;
+    isActive?: boolean;
+    text?: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export type ChatViewSelectorItemProps = {
+    iconOnly?: boolean;
+};
+export declare const ChatViewChannelsSelectorButton: ({ iconOnly, }: ChatViewSelectorItemProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ChatViewThreadsSelectorButton: ({ iconOnly, }: ChatViewSelectorItemProps) => import("react/jsx-runtime").JSX.Element;
+export type ChatViewSelectorItem = {
+    Component: React.ComponentType<ChatViewSelectorItemProps>;
+    type: string & {};
+};
+export type ChatViewSelectorEntry = ChatViewSelectorItem;
+export type ChatViewSelectorProps = {
+    iconOnly?: boolean;
+    itemSet?: ChatViewSelectorEntry[];
+};
+export declare const defaultChatViewSelectorItemSet: ChatViewSelectorEntry[];
+//# sourceMappingURL=ChatView.d.ts.map

package/dist/types/plugins/SlotLayout/ChatView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChatView.d.ts","sourceRoot":"","sources":["../../../../src/plugins/SlotLayout/ChatView.tsx"],"names":[],"mappings":"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"}

package/dist/types/plugins/SlotLayout/ChatViewNavigationContext.d.ts

@@ -0,0 +1,111 @@
+import type { PropsWithChildren } from 'react';
+import type { LocalMessage, Channel as StreamChannel, StreamChat, Thread as StreamThread } from 'stream-chat';
+import type { ChatView, ChatViewEntityBinding } from './ChatView';
+import type { OpenResult, SlotName } from './layoutController/layoutControllerTypes';
+export type OpenThreadTarget = StreamThread | {
+    channel: StreamChannel;
+    message: LocalMessage;
+};
+/**
+ * Binding builder for the `thread` kind (D6). The `{ channel, message }` ->
+ * `Thread` construction (with dedupe against `client.threads`) lives here so
+ * callers can drive the generic `open` with a ready binding instead of a
+ * thread-specific navigation method.
+ */
+export declare const createThreadEntityBinding: (client: StreamChat, target: {
+    channel: StreamChannel;
+    message: LocalMessage;
+}) => ChatViewEntityBinding;
+/** Options for {@link ChatViewNavigation.open}. */
+export type ChatViewOpenOptions = {
+    /**
+     * Open *beside* existing content instead of replacing it.
+     *
+     * By default `open` reuses the slot that already holds the binding's `kind` (so selecting a
+     * channel replaces the current channel). With `additive: true` the resolver skips that
+     * same-kind slot and instead targets the first free non-persistent slot — falling back to the
+     * last non-persistent slot when every slot is occupied. The effect is that the entity opens in
+     * a *secondary* slot next to the current one (e.g. ctrl/⌘-click a channel to open a 2nd channel
+     * side-by-side, or a search result beside the open channel).
+     *
+     * In a single-slot layout there is no secondary slot to open into, so it falls back to that
+     * one slot and behaves like a normal open. Ignored when an explicit `slot` is provided.
+     *
+     * @default false
+     */
+    additive?: boolean;
+    /**
+     * Open non-destructively: push the binding as a **layer** on top of the resolved target slot's
+     * current content instead of replacing it, and skip dependent-slot invalidation (nothing is
+     * being replaced). `close`/`popLayer` on that slot later restores what was underneath, at its
+     * exact state. Compose with `additive` to target the *secondary* slot — e.g.
+     * `open(channel, { additive: true, layer: true })` stacks a channel over an open reply thread
+     * without closing it. Orthogonal to slot resolution: `layer` chooses stack-vs-replace, while
+     * `slot`/`additive` choose *which* slot.
+     *
+     * @default false
+     */
+    layer?: boolean;
+    /**
+     * Bind into this specific slot, when it exists in the target view's layout. Takes precedence
+     * over `additive` and over the default kind-based slot resolution. Ignored (falls back to the
+     * default resolution) when the named slot is not part of the active layout.
+     */
+    slot?: SlotName;
+};
+export type ChatViewNavigation = {
+    /**
+     * Dismiss the top of `slot`. If the slot has layers (see {@link pushLayer}), pop the topmost
+     * layer, revealing what's beneath at its preserved state. Only when no layers remain does this
+     * release the base binding. No-op for empty or persistent slots.
+     */
+    close: (slot: SlotName) => void;
+    /**
+     * Close `slot` entirely: its base binding and every layer stacked on it. Where {@link close}
+     * steps back one layer, this dismisses the whole panel. No-op for empty or persistent slots.
+     */
+    release: (slot: SlotName) => void;
+    /** Hide `slot` without releasing its binding (subtree stays mounted). */
+    hide: (slot: SlotName) => void;
+    /**
+     * Push `binding` as a **layer** on top of `slot`'s current content. The content beneath stays
+     * mounted (state/scroll preserved) and hidden; the layer covers it. Use for transient overlays
+     * that should return to the underlying view — e.g. a member profile opened over a thread, where
+     * `close`/`popLayer` restores the thread exactly where it was. Ephemeral (not serialized).
+     */
+    pushLayer: (slot: SlotName, binding: ChatViewEntityBinding) => void;
+    /** Pop `slot`'s top layer, revealing the layer/base beneath. No-op when there are no layers. */
+    popLayer: (slot: SlotName) => void;
+    /**
+     * Resolve a target slot for `binding` and bind it there, switching to the binding kind's view
+     * first if needed (e.g. a `channel` binding activates the channels view).
+     *
+     * Slot resolution, in order:
+     * 1. `options.slot`, if that slot exists in the target view's layout;
+     * 2. otherwise, unless `options.additive` is set, the slot already holding this `kind`
+     *    (replacing its content);
+     * 3. the first free non-persistent slot;
+     * 4. the first free slot;
+     * 5. the last non-persistent slot (evicting a secondary panel — never the primary).
+     *
+     * See {@link ChatViewOpenOptions.additive} for opening *beside* current content instead of
+     * replacing.
+     *
+     * Returns an {@link OpenResult}; if no slot can be resolved the call is a rejected no-op — no
+     * view switch and no dependent-slot teardown, so a rejected open never leaves a partial state.
+     */
+    open: (binding: ChatViewEntityBinding, options?: ChatViewOpenOptions) => OpenResult;
+    /** Switch the active view (channels/threads); optionally focus a specific `slot`. */
+    openView: (view: ChatView, options?: {
+        slot?: SlotName;
+    }) => void;
+    /** Reveal a previously hidden `slot`. */
+    unhide: (slot: SlotName) => void;
+};
+export declare const useChatViewNavigation: () => ChatViewNavigation;
+/** The slot (in the active view) currently holding a binding of `kind`, if any. */
+export declare const useSlotForKind: (kind: ChatViewEntityBinding["kind"]) => SlotName | undefined;
+/** The slot (in the active view) whose binding carries entity `key`, if any. */
+export declare const useSlotForKey: (key?: string) => SlotName | undefined;
+export declare const ChatViewNavigationProvider: ({ children }: PropsWithChildren) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ChatViewNavigationContext.d.ts.map

package/dist/types/plugins/SlotLayout/ChatViewNavigationContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChatViewNavigationContext.d.ts","sourceRoot":"","sources":["../../../../src/plugins/SlotLayout/ChatViewNavigationContext.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAC;AAC/C,OAAO,KAAK,EACV,YAAY,EACZ,OAAO,IAAI,aAAa,EACxB,UAAU,EACV,MAAM,IAAI,YAAY,EACvB,MAAM,aAAa,CAAC;AAErB,OAAO,KAAK,EACV,QAAQ,EACR,qBAAqB,EAEtB,MAAM,YAAY,CAAC;AAEpB,OAAO,KAAK,EAIV,UAAU,EACV,QAAQ,EACT,MAAM,0CAA0C,CAAC;AAgElD,MAAM,MAAM,gBAAgB,GACxB,YAAY,GACZ;IAAE,OAAO,EAAE,aAAa,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAE,CAAC;AAEtD;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,GACpC,QAAQ,UAAU,EAClB,QAAQ;IAAE,OAAO,EAAE,aAAa,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAE,KACxD,qBAUF,CAAC;AAEF,mDAAmD;AACnD,MAAM,MAAM,mBAAmB,GAAG;IAChC;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;;;;;;;OAUG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;;OAIG;IACH,IAAI,CAAC,EAAE,QAAQ,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B;;;;OAIG;IACH,KAAK,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI,CAAC;IAChC;;;OAGG;IACH,OAAO,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI,CAAC;IAClC,yEAAyE;IACzE,IAAI,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI,CAAC;IAC/B;;;;;OAKG;IACH,SAAS,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,qBAAqB,KAAK,IAAI,CAAC;IACpE,gGAAgG;IAChG,QAAQ,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI,CAAC;IACnC;;;;;;;;;;;;;;;;;OAiBG;IACH,IAAI,EAAE,CAAC,OAAO,EAAE,qBAAqB,EAAE,OAAO,CAAC,EAAE,mBAAmB,KAAK,UAAU,CAAC;IACpF,qFAAqF;IACrF,QAAQ,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,QAAQ,CAAA;KAAE,KAAK,IAAI,CAAC;IAClE,yCAAyC;IACzC,MAAM,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI,CAAC;CAClC,CAAC;AAiBF,eAAO,MAAM,qBAAqB,0BAA8C,CAAC;AAEjF,mFAAmF;AACnF,eAAO,MAAM,cAAc,GACzB,MAAM,qBAAqB,CAAC,MAAM,CAAC,KAClC,QAAQ,GAAG,SASb,CAAC;AAEF,gFAAgF;AAChF,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,KAAG,QAAQ,GAAG,SAWvD,CAAC;AAEF,eAAO,MAAM,0BAA0B,GAAI,cAAc,iBAAiB,4CAkQzE,CAAC"}

package/dist/types/plugins/SlotLayout/ThreadListSlot.d.ts

@@ -0,0 +1,8 @@
+import type { PropsWithChildren, ReactNode } from 'react';
+import type { SlotName } from './layoutController/layoutControllerTypes';
+export type ThreadListSlotProps = PropsWithChildren<{
+    fallback?: ReactNode;
+    slot?: SlotName;
+}>;
+export declare const ThreadListSlot: ({ children, fallback, slot, }: ThreadListSlotProps) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ThreadListSlot.d.ts.map

package/dist/types/plugins/SlotLayout/ThreadListSlot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadListSlot.d.ts","sourceRoot":"","sources":["../../../../src/plugins/SlotLayout/ThreadListSlot.tsx"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAC1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0CAA0C,CAAC;AAEzE,MAAM,MAAM,mBAAmB,GAAG,iBAAiB,CAAC;IAClD,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,IAAI,CAAC,EAAE,QAAQ,CAAC;CACjB,CAAC,CAAC;AAKH,eAAO,MAAM,cAAc,GAAI,+BAI5B,mBAAmB,4CAsCrB,CAAC"}

package/dist/types/plugins/SlotLayout/ThreadSlot.d.ts

@@ -0,0 +1,10 @@
+import { type ThreadProps } from '../../components/Thread';
+import type { PropsWithChildren, ReactNode } from 'react';
+import type { SlotName } from './layoutController/layoutControllerTypes';
+export type ThreadSlotProps = PropsWithChildren<Omit<ThreadProps, 'thread'> & {
+    fallback?: ReactNode;
+    hideIfEmpty?: boolean;
+    slot?: SlotName;
+}>;
+export declare const ThreadSlot: ({ children, fallback, hideIfEmpty, slot, ...threadProps }: ThreadSlotProps) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ThreadSlot.d.ts.map

package/dist/types/plugins/SlotLayout/ThreadSlot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadSlot.d.ts","sourceRoot":"","sources":["../../../../src/plugins/SlotLayout/ThreadSlot.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAU,KAAK,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAGnE,OAAO,KAAK,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAC1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0CAA0C,CAAC;AAEzE,MAAM,MAAM,eAAe,GAAG,iBAAiB,CAC7C,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,GAAG;IAC5B,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,IAAI,CAAC,EAAE,QAAQ,CAAC;CACjB,CACF,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,2DAMxB,eAAe,4CAmBjB,CAAC"}

package/dist/types/plugins/SlotLayout/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export * from './useLayoutViewState';
+export * from './useSlotEntity';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/plugins/SlotLayout/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/SlotLayout/hooks/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC"}

package/dist/types/plugins/SlotLayout/hooks/useLayoutViewState.d.ts

@@ -0,0 +1,5 @@
+import type { ChatView } from '../ChatView';
+import type { ChatViewLayoutState, ChatViewLayoutViewState } from '../layoutController/layoutControllerTypes';
+export declare const getLayoutViewState: (state: ChatViewLayoutState, view?: ChatView) => ChatViewLayoutViewState;
+export declare const useLayoutViewState: (view?: ChatView) => ChatViewLayoutViewState;
+//# sourceMappingURL=useLayoutViewState.d.ts.map

package/dist/types/plugins/SlotLayout/hooks/useLayoutViewState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLayoutViewState.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/SlotLayout/hooks/useLayoutViewState.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,OAAO,KAAK,EACV,mBAAmB,EACnB,uBAAuB,EACxB,MAAM,2CAA2C,CAAC;AAEnD,eAAO,MAAM,kBAAkB,GAC7B,OAAO,mBAAmB,EAC1B,eAAuB,KACtB,uBAYF,CAAC;AACF,eAAO,MAAM,kBAAkB,GAAI,OAAO,QAAQ,4BAYjD,CAAC"}

package/dist/types/plugins/SlotLayout/hooks/useSlotEntity.d.ts

@@ -0,0 +1,162 @@
+import type { ChatView, ChatViewEntityBinding } from '../ChatView';
+import type { SlotName } from '../layoutController/layoutControllerTypes';
+type SlotEntityKind = ChatViewEntityBinding['kind'];
+type SlotEntitySourceMap = {
+    [TKind in SlotEntityKind]: Extract<ChatViewEntityBinding, {
+        kind: TKind;
+    }>['source'];
+};
+type SlotEntitySourceByKind<TKind extends SlotEntityKind> = SlotEntitySourceMap[TKind];
+type UseSlotEntityOptions<TKind extends SlotEntityKind> = {
+    /**
+     * Entity kind to resolve from ChatView slot bindings.
+     */
+    kind: TKind;
+    /**
+     * Optional explicit slot to inspect.
+     *
+     * - when provided: only that slot is checked
+     * - when omitted: slots are checked in active view order (`availableSlots`)
+     */
+    slot?: SlotName;
+    /**
+     * Optional explicit view to read slots from.
+     *
+     * - when omitted: the **active** view's slots are read
+     * - when provided: that view's slots are read regardless of which view is active
+     *   (its layout state is retained across view switches). Useful for cross-view
+     *   concerns like URL sync that must not clear when another view is focused.
+     */
+    view?: ChatView;
+};
+/**
+ * Resolves the `source` of the first matching ChatView entity binding.
+ *
+ * Behavior:
+ * 1. Read active-view slot topology/bindings via `useLayoutViewState()`.
+ * 2. Build candidate slots:
+ *    - `[slot]` when explicit `slot` is provided
+ *    - `availableSlots` order when `slot` is omitted
+ * 3. Return `entity.source` for the first binding whose `kind` matches.
+ * 4. Return `undefined` when no match exists.
+ *
+ * Why this exists:
+ * - Keeps slot-to-entity lookup consistent and centralized for ChatView-aware
+ *   components (e.g. `ChannelSlot`, `ThreadSlot`).
+ * - Preserves type safety by narrowing returned `source` based on `kind`.
+ *
+ * @example
+ * ```tsx
+ * const channel = useSlotEntity({ kind: 'channel' });
+ * // channel is Stream Channel | undefined
+ * ```
+ *
+ * @example
+ * ```tsx
+ * const thread = useSlotEntity({ kind: 'thread', slot: 'main-thread' });
+ * // thread is Thread | undefined from that slot only
+ * ```
+ *
+ * @example
+ * ```tsx
+ * const list = useSlotEntity({ kind: 'channelList', slot: 'list' });
+ * // list is { view?: ChatView } | undefined
+ * ```
+ */
+export declare const useSlotEntity: <TKind extends SlotEntityKind>({ kind, slot, view, }: UseSlotEntityOptions<TKind>) => SlotEntitySourceByKind<TKind> | undefined;
+/**
+ * Like {@link useSlotEntity}, but resolves the source of the **topmost layer** on a slot (the last
+ * entry of `slotLayers[slot]`) rather than its base binding — when that layer's `kind` matches.
+ *
+ * Layers stack above the base binding and cover it while it stays mounted (see
+ * `ChatViewNavigation.pushLayer`). Read the base with `useSlotEntity`/`useSlotChannel`/… and the
+ * overlay on top with this hook, then render the overlay covering the base.
+ *
+ * @example
+ * ```tsx
+ * const profile = useSlotTopLayerEntity({ kind: 'userProfile', slot: 'main-thread' });
+ * // profile is { userId } | undefined — present while a userProfile layer covers the slot
+ * ```
+ */
+export declare const useSlotTopLayerEntity: <TKind extends SlotEntityKind>({ kind, slot, view, }: UseSlotEntityOptions<TKind>) => SlotEntitySourceByKind<TKind> | undefined;
+/**
+ * Resolves **every** matching ChatView entity binding as `{ slot, source }` pairs
+ * (in active-view `availableSlots` order, or only `slot` when provided).
+ *
+ * Prefer this over `useSlotEntity` when several slots can hold the same kind (e.g.
+ * two channels side by side) — it never collapses the set to "the first match".
+ *
+ * @example
+ * ```tsx
+ * const channels = useSlotEntities({ kind: 'channel' });
+ * // channels is Array<{ slot: SlotName; source: Channel }>
+ * ```
+ */
+export declare const useSlotEntities: <TKind extends SlotEntityKind>({ kind, slot, view, }: UseSlotEntityOptions<TKind>) => Array<{
+    slot: SlotName;
+    source: SlotEntitySourceByKind<TKind>;
+}>;
+/**
+ * Convenience wrapper for `useSlotEntity({ kind: 'channel' })` — the channel in a
+ * single slot. Pass `slot` to be precise; omitting it returns the first channel slot
+ * (only meaningful for a single-channel workspace). For multiple channels, use
+ * `useSlotChannels`.
+ *
+ * @example
+ * ```tsx
+ * const channel = useSlotChannel({ slot: 'main' });
+ * ```
+ */
+export declare const useSlotChannel: (options?: {
+    slot?: SlotName;
+    view?: ChatView;
+}) => import("stream-chat").Channel | undefined;
+/**
+ * Every slot currently holding a channel, as `{ channel, slot }` pairs. Robust for
+ * side-by-side channels — the caller renders one panel per entry (and, for a
+ * single-channel workspace, gets an array of length ≤ 1).
+ *
+ * @example
+ * ```tsx
+ * useSlotChannels().map(({ channel, slot }) => <ChannelPanel key={slot} channel={channel} />)
+ * ```
+ */
+export declare const useSlotChannels: (options?: {
+    slot?: SlotName;
+    view?: ChatView;
+}) => {
+    channel: import("stream-chat").Channel;
+    slot: string;
+}[];
+/**
+ * Convenience wrapper for `useSlotEntity({ kind: 'thread' })`.
+ *
+ * @example
+ * ```tsx
+ * const thread = useSlotThread();
+ * ```
+ */
+export declare const useSlotThread: (options?: {
+    slot?: SlotName;
+    view?: ChatView;
+}) => import("stream-chat").Thread | undefined;
+/**
+ * Every slot currently holding a thread, as `{ thread, slot }` pairs — the thread
+ * analog of `useSlotChannels`. The caller renders one thread panel per entry.
+ *
+ * @example
+ * ```tsx
+ * useSlotThreads().map(({ thread, slot }) => (
+ *   <Thread key={slot} thread={thread}><ThreadHeader /><MessageList /></Thread>
+ * ))
+ * ```
+ */
+export declare const useSlotThreads: (options?: {
+    slot?: SlotName;
+    view?: ChatView;
+}) => {
+    slot: string;
+    thread: import("stream-chat").Thread;
+}[];
+export {};
+//# sourceMappingURL=useSlotEntity.d.ts.map

package/dist/types/plugins/SlotLayout/hooks/useSlotEntity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSlotEntity.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/SlotLayout/hooks/useSlotEntity.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACnE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,2CAA2C,CAAC;AAE1E,KAAK,cAAc,GAAG,qBAAqB,CAAC,MAAM,CAAC,CAAC;AAEpD,KAAK,mBAAmB,GAAG;KACxB,KAAK,IAAI,cAAc,GAAG,OAAO,CAAC,qBAAqB,EAAE;QAAE,IAAI,EAAE,KAAK,CAAA;KAAE,CAAC,CAAC,QAAQ,CAAC;CACrF,CAAC;AAEF,KAAK,sBAAsB,CAAC,KAAK,SAAS,cAAc,IAAI,mBAAmB,CAAC,KAAK,CAAC,CAAC;AAEvF,KAAK,oBAAoB,CAAC,KAAK,SAAS,cAAc,IAAI;IACxD;;OAEG;IACH,IAAI,EAAE,KAAK,CAAC;IACZ;;;;;OAKG;IACH,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE,QAAQ,CAAC;CACjB,CAAC;AAeF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,aAAa,GAAI,KAAK,SAAS,cAAc,EAAE,uBAIzD,oBAAoB,CAAC,KAAK,CAAC,KAAG,sBAAsB,CAAC,KAAK,CAAC,GAAG,SAahE,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,qBAAqB,GAAI,KAAK,SAAS,cAAc,EAAE,uBAIjE,oBAAoB,CAAC,KAAK,CAAC,KAAG,sBAAsB,CAAC,KAAK,CAAC,GAAG,SAchE,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe,GAAI,KAAK,SAAS,cAAc,EAAE,uBAI3D,oBAAoB,CAAC,KAAK,CAAC,KAAG,KAAK,CAAC;IACrC,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,sBAAsB,CAAC,KAAK,CAAC,CAAC;CACvC,CAgBA,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,GAAI,UAAU;IAAE,IAAI,CAAC,EAAE,QAAQ,CAAC;IAAC,IAAI,CAAC,EAAE,QAAQ,CAAA;CAAE,8CACC,CAAC;AAE/E;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,GAAI,UAAU;IAAE,IAAI,CAAC,EAAE,QAAQ,CAAC;IAAC,IAAI,CAAC,EAAE,QAAQ,CAAA;CAAE;;;GAM3E,CAAC;AAEJ;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,GAAI,UAAU;IAAE,IAAI,CAAC,EAAE,QAAQ,CAAC;IAAC,IAAI,CAAC,EAAE,QAAQ,CAAA;CAAE,6CACC,CAAC;AAE9E;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,GAAI,UAAU;IAAE,IAAI,CAAC,EAAE,QAAQ,CAAC;IAAC,IAAI,CAAC,EAAE,QAAQ,CAAA;CAAE;;;GAM1E,CAAC"}

package/dist/types/plugins/SlotLayout/index.d.ts

@@ -0,0 +1,12 @@
+export * from './ChatView';
+export * from './ChatViewNavigationContext';
+export * from './workspaceNavigationAdapter';
+export * from './layoutController/layoutControllerTypes';
+export * from './layoutController/serialization';
+export * from './hooks';
+export * from './ChannelSlot';
+export * from './ThreadSlot';
+export * from './ThreadListSlot';
+export * from './layout/Slot';
+export * from './layout/WorkspaceLayout';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/plugins/SlotLayout/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/SlotLayout/index.tsx"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,0CAA0C,CAAC;AACzD,cAAc,kCAAkC,CAAC;AACjD,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,0BAA0B,CAAC"}

package/dist/types/plugins/SlotLayout/layout/Slot.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from 'react';
+export type SlotProps = {
+    children?: ReactNode;
+    className?: string;
+    slot: string;
+};
+export declare const Slot: ({ children, className, slot }: SlotProps) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Slot.d.ts.map

package/dist/types/plugins/SlotLayout/layout/Slot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Slot.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/SlotLayout/layout/Slot.tsx"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,eAAO,MAAM,IAAI,GAAI,+BAA+B,SAAS,4CAgE5D,CAAC"}

package/dist/types/plugins/SlotLayout/layout/WorkspaceLayout.d.ts

@@ -0,0 +1,11 @@
+import type { ReactNode } from 'react';
+export type WorkspaceLayoutSlot = {
+    content?: ReactNode;
+    slot: string;
+};
+export type WorkspaceLayoutProps = {
+    navRail?: ReactNode;
+    slots: WorkspaceLayoutSlot[];
+};
+export declare const WorkspaceLayout: ({ navRail, slots }: WorkspaceLayoutProps) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=WorkspaceLayout.d.ts.map

package/dist/types/plugins/SlotLayout/layout/WorkspaceLayout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkspaceLayout.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/SlotLayout/layout/WorkspaceLayout.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,CAAC,EAAE,SAAS,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,CAAC,EAAE,SAAS,CAAC;IACpB,KAAK,EAAE,mBAAmB,EAAE,CAAC;CAC9B,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,oBAAoB,oBAAoB,4CAqBvE,CAAC"}

package/dist/types/plugins/SlotLayout/layoutController/LayoutController.d.ts

@@ -0,0 +1,25 @@
+import { StateStore } from '@stream-io/state-store';
+import type { ChatViewLayoutState, CreateLayoutControllerOptions, LayoutController as LayoutControllerApi, LayoutRuntimeState } from './layoutControllerTypes';
+/** Build a full per-layout runtime state, defaulting any field left unset.
+ * Handy for `initialState` callers that only want to seed a couple of fields. */
+export declare const createLayoutRuntimeState: (partial?: Partial<LayoutRuntimeState>) => LayoutRuntimeState;
+export declare class LayoutController implements LayoutControllerApi {
+    private readonly duplicateEntityPolicy;
+    private readonly resolveDuplicateEntity?;
+    state: StateStore<ChatViewLayoutState>;
+    constructor(options?: CreateLayoutControllerOptions);
+    setActiveView: LayoutControllerApi['setActiveView'];
+    openView: LayoutControllerApi['openView'];
+    setAvailableSlots: LayoutControllerApi['setAvailableSlots'];
+    setSlotNames: LayoutControllerApi['setSlotNames'];
+    hide: LayoutControllerApi['hide'];
+    unhide: LayoutControllerApi['unhide'];
+    bind: LayoutControllerApi['bind'];
+    release: LayoutControllerApi['release'];
+    pushLayer: LayoutControllerApi['pushLayer'];
+    popLayer: LayoutControllerApi['popLayer'];
+    goBack: LayoutControllerApi['goBack'];
+    goForward: LayoutControllerApi['goForward'];
+    openInLayout: LayoutControllerApi['openInLayout'];
+}
+//# sourceMappingURL=LayoutController.d.ts.map

package/dist/types/plugins/SlotLayout/layoutController/LayoutController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LayoutController.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/SlotLayout/layoutController/LayoutController.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEpD,OAAO,KAAK,EACV,mBAAmB,EAEnB,6BAA6B,EAE7B,gBAAgB,IAAI,mBAAmB,EACvC,kBAAkB,EAKnB,MAAM,yBAAyB,CAAC;AAOjC;iFACiF;AACjF,eAAO,MAAM,wBAAwB,GACnC,UAAS,OAAO,CAAC,kBAAkB,CAAM,KACxC,kBASD,CAAC;AAwVH,qBAAa,gBAAiB,YAAW,mBAAmB;IAC1D,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAwB;IAC9D,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAC,CAA0D;IAClG,KAAK,EAAE,UAAU,CAAC,mBAAmB,CAAC,CAAC;gBAE3B,OAAO,GAAE,6BAAkC;IAavD,aAAa,EAAE,mBAAmB,CAAC,eAAe,CAAC,CAEjD;IAEF,QAAQ,EAAE,mBAAmB,CAAC,UAAU,CAAC,CAGvC;IAEF,iBAAiB,EAAE,mBAAmB,CAAC,mBAAmB,CAAC,CAQzD;IAEF,YAAY,EAAE,mBAAmB,CAAC,cAAc,CAAC,CAQ/C;IAEF,IAAI,EAAE,mBAAmB,CAAC,MAAM,CAAC,CAW/B;IAEF,MAAM,EAAE,mBAAmB,CAAC,QAAQ,CAAC,CAWnC;IAKF,IAAI,EAAE,mBAAmB,CAAC,MAAM,CAAC,CAU/B;IAEF,OAAO,EAAE,mBAAmB,CAAC,SAAS,CAAC,CAKrC;IAKF,SAAS,EAAE,mBAAmB,CAAC,WAAW,CAAC,CAYzC;IAEF,QAAQ,EAAE,mBAAmB,CAAC,UAAU,CAAC,CAmBvC;IAEF,MAAM,EAAE,mBAAmB,CAAC,QAAQ,CAAC,CAanC;IAEF,SAAS,EAAE,mBAAmB,CAAC,WAAW,CAAC,CAazC;IAEF,YAAY,EAAE,mBAAmB,CAAC,cAAc,CAAC,CAwE/C;CACH"}