ikoncomponents 1.6.3 → 1.6.5

package/dist/vendor/assistant-ui-react/src/primitives/thread/ThreadMessages.js

@@ -0,0 +1,102 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { memo, useMemo } from "react";
+import { useAuiState } from "@assistant-ui/store";
+import { MessageByIndexProvider } from "../../context/providers";
+const isComponentsSame = (prev, next) => {
+    return (prev.Message === next.Message &&
+        prev.EditComposer === next.EditComposer &&
+        prev.UserEditComposer === next.UserEditComposer &&
+        prev.AssistantEditComposer === next.AssistantEditComposer &&
+        prev.SystemEditComposer === next.SystemEditComposer &&
+        prev.UserMessage === next.UserMessage &&
+        prev.AssistantMessage === next.AssistantMessage &&
+        prev.SystemMessage === next.SystemMessage);
+};
+const DEFAULT_SYSTEM_MESSAGE = () => null;
+const getComponent = (components, role, isEditing) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    switch (role) {
+        case "user":
+            if (isEditing) {
+                return ((_c = (_b = (_a = components.UserEditComposer) !== null && _a !== void 0 ? _a : components.EditComposer) !== null && _b !== void 0 ? _b : components.UserMessage) !== null && _c !== void 0 ? _c : components.Message);
+            }
+            else {
+                return (_d = components.UserMessage) !== null && _d !== void 0 ? _d : components.Message;
+            }
+        case "assistant":
+            if (isEditing) {
+                return ((_g = (_f = (_e = components.AssistantEditComposer) !== null && _e !== void 0 ? _e : components.EditComposer) !== null && _f !== void 0 ? _f : components.AssistantMessage) !== null && _g !== void 0 ? _g : components.Message);
+            }
+            else {
+                return ((_h = components.AssistantMessage) !== null && _h !== void 0 ? _h : components.Message);
+            }
+        case "system":
+            if (isEditing) {
+                return ((_l = (_k = (_j = components.SystemEditComposer) !== null && _j !== void 0 ? _j : components.EditComposer) !== null && _k !== void 0 ? _k : components.SystemMessage) !== null && _l !== void 0 ? _l : components.Message);
+            }
+            else {
+                return (_m = components.SystemMessage) !== null && _m !== void 0 ? _m : DEFAULT_SYSTEM_MESSAGE;
+            }
+        default:
+            const _exhaustiveCheck = role;
+            throw new Error(`Unknown message role: ${_exhaustiveCheck}`);
+    }
+};
+const ThreadMessageComponent = ({ components, }) => {
+    const role = useAuiState(({ message }) => message.role);
+    const isEditing = useAuiState(({ message }) => message.composer.isEditing);
+    const Component = getComponent(components, role, isEditing);
+    return _jsx(Component, {});
+};
+/**
+ * Renders a single message at the specified index in the current thread.
+ *
+ * This component provides message context for a specific message in the thread
+ * and renders it using the provided component configuration.
+ *
+ * @example
+ * ```tsx
+ * <ThreadPrimitive.MessageByIndex
+ *   index={0}
+ *   components={{
+ *     UserMessage: MyUserMessage,
+ *     AssistantMessage: MyAssistantMessage
+ *   }}
+ * />
+ * ```
+ */
+export const ThreadPrimitiveMessageByIndex = memo(({ index, components }) => {
+    return (_jsx(MessageByIndexProvider, { index: index, children: _jsx(ThreadMessageComponent, { components: components }) }));
+}, (prev, next) => prev.index === next.index &&
+    isComponentsSame(prev.components, next.components));
+ThreadPrimitiveMessageByIndex.displayName = "ThreadPrimitive.MessageByIndex";
+/**
+ * Renders all messages in the current thread using the provided component configuration.
+ *
+ * This component automatically renders all messages in the thread, providing the appropriate
+ * message context for each message. It handles different message types (user, assistant, system)
+ * and supports editing mode through the provided edit composer components.
+ *
+ * @example
+ * ```tsx
+ * <ThreadPrimitive.Messages
+ *   components={{
+ *     UserMessage: MyUserMessage,
+ *     AssistantMessage: MyAssistantMessage,
+ *     EditComposer: MyEditComposer
+ *   }}
+ * />
+ * ```
+ */
+export const ThreadPrimitiveMessagesImpl = ({ components, }) => {
+    const messagesLength = useAuiState(({ thread }) => thread.messages.length);
+    const messageElements = useMemo(() => {
+        if (messagesLength === 0)
+            return null;
+        return Array.from({ length: messagesLength }, (_, index) => (_jsx(ThreadPrimitiveMessageByIndex, { index: index, components: components }, index)));
+    }, [messagesLength, components]);
+    return messageElements;
+};
+ThreadPrimitiveMessagesImpl.displayName = "ThreadPrimitive.Messages";
+export const ThreadPrimitiveMessages = memo(ThreadPrimitiveMessagesImpl, (prev, next) => isComponentsSame(prev.components, next.components));

package/dist/vendor/assistant-ui-react/src/primitives/thread/ThreadRoot.d.ts

@@ -0,0 +1,28 @@
+import { Primitive } from "@radix-ui/react-primitive";
+import { type ComponentRef, ComponentPropsWithoutRef } from "react";
+export declare namespace ThreadPrimitiveRoot {
+    type Element = ComponentRef<typeof Primitive.div>;
+    /**
+     * Props for the ThreadPrimitive.Root component.
+     * Accepts all standard div element props.
+     */
+    type Props = ComponentPropsWithoutRef<typeof Primitive.div>;
+}
+/**
+ * The root container component for a thread.
+ *
+ * This component serves as the foundational wrapper for all thread-related components.
+ * It provides the basic structure and context needed for thread functionality.
+ *
+ * @example
+ * ```tsx
+ * <ThreadPrimitive.Root>
+ *   <ThreadPrimitive.Viewport>
+ *     <ThreadPrimitive.Messages components={{ Message: MyMessage }} />
+ *   </ThreadPrimitive.Viewport>
+ * </ThreadPrimitive.Root>
+ * ```
+ */
+export declare const ThreadPrimitiveRoot: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {
+    asChild?: boolean;
+}, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/dist/vendor/assistant-ui-react/src/primitives/thread/ThreadRoot.js

@@ -0,0 +1,23 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Primitive } from "@radix-ui/react-primitive";
+import { forwardRef } from "react";
+/**
+ * The root container component for a thread.
+ *
+ * This component serves as the foundational wrapper for all thread-related components.
+ * It provides the basic structure and context needed for thread functionality.
+ *
+ * @example
+ * ```tsx
+ * <ThreadPrimitive.Root>
+ *   <ThreadPrimitive.Viewport>
+ *     <ThreadPrimitive.Messages components={{ Message: MyMessage }} />
+ *   </ThreadPrimitive.Viewport>
+ * </ThreadPrimitive.Root>
+ * ```
+ */
+export const ThreadPrimitiveRoot = forwardRef((props, ref) => {
+    return _jsx(Primitive.div, Object.assign({}, props, { ref: ref }));
+});
+ThreadPrimitiveRoot.displayName = "ThreadPrimitive.Root";

package/dist/vendor/assistant-ui-react/src/primitives/thread/ThreadScrollToBottom.d.ts

@@ -0,0 +1,15 @@
+import { ActionButtonElement, ActionButtonProps } from "../../utils/createActionButton";
+export declare namespace useThreadScrollToBottom {
+    type Options = {
+        behavior?: ScrollBehavior | undefined;
+    };
+}
+declare const useThreadScrollToBottom: ({ behavior, }?: useThreadScrollToBottom.Options) => (() => void) | null;
+export declare namespace ThreadPrimitiveScrollToBottom {
+    type Element = ActionButtonElement;
+    type Props = ActionButtonProps<typeof useThreadScrollToBottom>;
+}
+export declare const ThreadPrimitiveScrollToBottom: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+}, "ref"> & useThreadScrollToBottom.Options & import("react").RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/vendor/assistant-ui-react/src/primitives/thread/ThreadScrollToBottom.js

@@ -0,0 +1,15 @@
+"use client";
+import { createActionButton, } from "../../utils/createActionButton";
+import { useCallback } from "react";
+import { useThreadViewport, useThreadViewportStore, } from "../../context/react/ThreadViewportContext";
+const useThreadScrollToBottom = ({ behavior, } = {}) => {
+    const isAtBottom = useThreadViewport((s) => s.isAtBottom);
+    const threadViewportStore = useThreadViewportStore();
+    const handleScrollToBottom = useCallback(() => {
+        threadViewportStore.getState().scrollToBottom({ behavior });
+    }, [threadViewportStore, behavior]);
+    if (isAtBottom)
+        return null;
+    return handleScrollToBottom;
+};
+export const ThreadPrimitiveScrollToBottom = createActionButton("ThreadPrimitive.ScrollToBottom", useThreadScrollToBottom, ["behavior"]);

package/dist/vendor/assistant-ui-react/src/primitives/thread/ThreadSuggestion.d.ts

@@ -0,0 +1,50 @@
+import { ActionButtonElement, ActionButtonProps } from "../../utils/createActionButton";
+declare const useThreadSuggestion: ({ prompt, send, clearComposer, autoSend, method: _method, }: {
+    /** The suggestion prompt. */
+    prompt: string;
+    /**
+     * When true, automatically sends the message.
+     * When false, replaces or appends the composer text with the suggestion - depending on the value of `clearComposer`.
+     */
+    send?: boolean | undefined;
+    /**
+     * Whether to clear the composer after sending.
+     * When send is set to false, determines if composer text is replaced with suggestion (true, default),
+     * or if it's appended to the composer text (false).
+     *
+     * @default true
+     */
+    clearComposer?: boolean | undefined;
+    /** @deprecated Use `send` instead. */
+    autoSend?: boolean | undefined;
+    /** @deprecated Use `clearComposer` instead. */
+    method?: "replace";
+}) => (() => void) | null;
+export declare namespace ThreadPrimitiveSuggestion {
+    type Element = ActionButtonElement;
+    type Props = ActionButtonProps<typeof useThreadSuggestion>;
+}
+export declare const ThreadPrimitiveSuggestion: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+}, "ref"> & {
+    /** The suggestion prompt. */
+    prompt: string;
+    /**
+     * When true, automatically sends the message.
+     * When false, replaces or appends the composer text with the suggestion - depending on the value of `clearComposer`.
+     */
+    send?: boolean | undefined;
+    /**
+     * Whether to clear the composer after sending.
+     * When send is set to false, determines if composer text is replaced with suggestion (true, default),
+     * or if it's appended to the composer text (false).
+     *
+     * @default true
+     */
+    clearComposer?: boolean | undefined;
+    /** @deprecated Use `send` instead. */
+    autoSend?: boolean | undefined;
+    /** @deprecated Use `clearComposer` instead. */
+    method?: "replace";
+} & import("react").RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/vendor/assistant-ui-react/src/primitives/thread/ThreadSuggestion.js

@@ -0,0 +1,36 @@
+"use client";
+import { createActionButton, } from "../../utils/createActionButton";
+import { useCallback } from "react";
+import { useAuiState, useAui } from "@assistant-ui/store";
+const useThreadSuggestion = ({ prompt, send, clearComposer = true, autoSend, method: _method, }) => {
+    var _a;
+    const aui = useAui();
+    const disabled = useAuiState(({ thread }) => thread.isDisabled);
+    // ========== Deprecation Mapping ==========
+    const resolvedSend = (_a = send !== null && send !== void 0 ? send : autoSend) !== null && _a !== void 0 ? _a : false;
+    // ==========================================
+    const callback = useCallback(() => {
+        const isRunning = aui.thread().getState().isRunning;
+        if (resolvedSend && !isRunning) {
+            aui.thread().append(prompt);
+            if (clearComposer) {
+                aui.composer().setText("");
+            }
+        }
+        else {
+            if (clearComposer) {
+                aui.composer().setText(prompt);
+            }
+            else {
+                const currentText = aui.composer().getState().text;
+                aui
+                    .composer()
+                    .setText(currentText.trim() ? `${currentText} ${prompt}` : prompt);
+            }
+        }
+    }, [aui, resolvedSend, clearComposer, prompt]);
+    if (disabled)
+        return null;
+    return callback;
+};
+export const ThreadPrimitiveSuggestion = createActionButton("ThreadPrimitive.Suggestion", useThreadSuggestion, ["prompt", "send", "clearComposer", "autoSend", "method"]);

package/dist/vendor/assistant-ui-react/src/primitives/thread/ThreadSuggestions.d.ts

@@ -0,0 +1,52 @@
+import { type ComponentType, type FC } from "react";
+export declare namespace ThreadPrimitiveSuggestions {
+    type Props = {
+        /**
+         * Component to render for each suggestion.
+         */
+        components: {
+            /** Component used to render each suggestion */
+            Suggestion: ComponentType;
+        };
+    };
+}
+export declare namespace ThreadPrimitiveSuggestionByIndex {
+    type Props = {
+        index: number;
+        components: ThreadPrimitiveSuggestions.Props["components"];
+    };
+}
+/**
+ * Renders a single suggestion at the specified index.
+ *
+ * This component provides suggestion context for a specific suggestion
+ * and renders it using the provided component configuration.
+ *
+ * @example
+ * ```tsx
+ * <ThreadPrimitive.SuggestionByIndex
+ *   index={0}
+ *   components={{
+ *     Suggestion: MySuggestion
+ *   }}
+ * />
+ * ```
+ */
+export declare const ThreadPrimitiveSuggestionByIndex: FC<ThreadPrimitiveSuggestionByIndex.Props>;
+/**
+ * Renders all suggestions using the provided component configuration.
+ *
+ * This component automatically renders all suggestions from the suggestions scope,
+ * providing the appropriate suggestion context for each one.
+ *
+ * @example
+ * ```tsx
+ * <ThreadPrimitive.Suggestions
+ *   components={{
+ *     Suggestion: MySuggestion
+ *   }}
+ * />
+ * ```
+ */
+export declare const ThreadPrimitiveSuggestionsImpl: FC<ThreadPrimitiveSuggestions.Props>;
+export declare const ThreadPrimitiveSuggestions: import("react").NamedExoticComponent<ThreadPrimitiveSuggestions.Props>;

package/dist/vendor/assistant-ui-react/src/primitives/thread/ThreadSuggestions.js

@@ -0,0 +1,57 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { memo, useMemo } from "react";
+import { useAuiState } from "@assistant-ui/store";
+import { SuggestionByIndexProvider } from "../../context/providers";
+const SuggestionComponent = ({ components }) => {
+    const Component = components.Suggestion;
+    return _jsx(Component, {});
+};
+/**
+ * Renders a single suggestion at the specified index.
+ *
+ * This component provides suggestion context for a specific suggestion
+ * and renders it using the provided component configuration.
+ *
+ * @example
+ * ```tsx
+ * <ThreadPrimitive.SuggestionByIndex
+ *   index={0}
+ *   components={{
+ *     Suggestion: MySuggestion
+ *   }}
+ * />
+ * ```
+ */
+export const ThreadPrimitiveSuggestionByIndex = memo(({ index, components }) => {
+    return (_jsx(SuggestionByIndexProvider, { index: index, children: _jsx(SuggestionComponent, { components: components }) }));
+}, (prev, next) => prev.index === next.index &&
+    prev.components.Suggestion === next.components.Suggestion);
+ThreadPrimitiveSuggestionByIndex.displayName =
+    "ThreadPrimitive.SuggestionByIndex";
+/**
+ * Renders all suggestions using the provided component configuration.
+ *
+ * This component automatically renders all suggestions from the suggestions scope,
+ * providing the appropriate suggestion context for each one.
+ *
+ * @example
+ * ```tsx
+ * <ThreadPrimitive.Suggestions
+ *   components={{
+ *     Suggestion: MySuggestion
+ *   }}
+ * />
+ * ```
+ */
+export const ThreadPrimitiveSuggestionsImpl = ({ components }) => {
+    const suggestionsLength = useAuiState(({ suggestions }) => suggestions.suggestions.length);
+    const suggestionElements = useMemo(() => {
+        if (suggestionsLength === 0)
+            return null;
+        return Array.from({ length: suggestionsLength }, (_, index) => (_jsx(ThreadPrimitiveSuggestionByIndex, { index: index, components: components }, index)));
+    }, [suggestionsLength, components]);
+    return suggestionElements;
+};
+ThreadPrimitiveSuggestionsImpl.displayName = "ThreadPrimitive.Suggestions";
+export const ThreadPrimitiveSuggestions = memo(ThreadPrimitiveSuggestionsImpl, (prev, next) => prev.components.Suggestion === next.components.Suggestion);

package/dist/vendor/assistant-ui-react/src/primitives/thread/ThreadViewport.d.ts

@@ -0,0 +1,87 @@
+import { Primitive } from "@radix-ui/react-primitive";
+import { type ComponentRef, ComponentPropsWithoutRef } from "react";
+export declare namespace ThreadPrimitiveViewport {
+    type Element = ComponentRef<typeof Primitive.div>;
+    type Props = ComponentPropsWithoutRef<typeof Primitive.div> & {
+        /**
+         * Whether to automatically scroll to the bottom when new messages are added.
+         * When enabled, the viewport will automatically scroll to show the latest content.
+         *
+         * Default false if `turnAnchor` is "top", otherwise defaults to true.
+         */
+        autoScroll?: boolean | undefined;
+        /**
+         * Controls scroll anchoring behavior for new messages.
+         * - "bottom" (default): Messages anchor at the bottom, classic chat behavior.
+         * - "top": New user messages anchor at the top of the viewport for a focused reading experience.
+         */
+        turnAnchor?: "top" | "bottom" | undefined;
+        /**
+         * Whether to scroll to bottom when a new run starts.
+         *
+         * Defaults to true.
+         */
+        scrollToBottomOnRunStart?: boolean | undefined;
+        /**
+         * Whether to scroll to bottom when thread history is first loaded.
+         *
+         * Defaults to true.
+         */
+        scrollToBottomOnInitialize?: boolean | undefined;
+        /**
+         * Whether to scroll to bottom when switching to a different thread.
+         *
+         * Defaults to true.
+         */
+        scrollToBottomOnThreadSwitch?: boolean | undefined;
+    };
+}
+/**
+ * A scrollable viewport container for thread messages.
+ *
+ * This component provides a scrollable area for displaying thread messages with
+ * automatic scrolling capabilities. It manages the viewport state and provides
+ * context for child components to access viewport-related functionality.
+ *
+ * @example
+ * ```tsx
+ * <ThreadPrimitive.Viewport turnAnchor="top">
+ *   <ThreadPrimitive.Messages components={{ Message: MyMessage }} />
+ * </ThreadPrimitive.Viewport>
+ * ```
+ */
+export declare const ThreadPrimitiveViewport: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {
+    asChild?: boolean;
+}, "ref"> & {
+    /**
+     * Whether to automatically scroll to the bottom when new messages are added.
+     * When enabled, the viewport will automatically scroll to show the latest content.
+     *
+     * Default false if `turnAnchor` is "top", otherwise defaults to true.
+     */
+    autoScroll?: boolean | undefined;
+    /**
+     * Controls scroll anchoring behavior for new messages.
+     * - "bottom" (default): Messages anchor at the bottom, classic chat behavior.
+     * - "top": New user messages anchor at the top of the viewport for a focused reading experience.
+     */
+    turnAnchor?: "top" | "bottom" | undefined;
+    /**
+     * Whether to scroll to bottom when a new run starts.
+     *
+     * Defaults to true.
+     */
+    scrollToBottomOnRunStart?: boolean | undefined;
+    /**
+     * Whether to scroll to bottom when thread history is first loaded.
+     *
+     * Defaults to true.
+     */
+    scrollToBottomOnInitialize?: boolean | undefined;
+    /**
+     * Whether to scroll to bottom when switching to a different thread.
+     *
+     * Defaults to true.
+     */
+    scrollToBottomOnThreadSwitch?: boolean | undefined;
+} & import("react").RefAttributes<HTMLDivElement>>;

package/dist/vendor/assistant-ui-react/src/primitives/thread/ThreadViewport.js

@@ -0,0 +1,58 @@
+"use client";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useComposedRefs } from "@radix-ui/react-compose-refs";
+import { Primitive } from "@radix-ui/react-primitive";
+import { forwardRef, useCallback, } from "react";
+import { useThreadViewportAutoScroll } from "./useThreadViewportAutoScroll";
+import { ThreadPrimitiveViewportProvider } from "../../context/providers/ThreadViewportProvider";
+import { useSizeHandle } from "../../utils/hooks/useSizeHandle";
+import { useThreadViewport } from "../../context/react/ThreadViewportContext";
+const useViewportSizeRef = () => {
+    const register = useThreadViewport((s) => s.registerViewport);
+    const getHeight = useCallback((el) => el.clientHeight, []);
+    return useSizeHandle(register, getHeight);
+};
+const ThreadPrimitiveViewportScrollable = forwardRef((_a, forwardedRef) => {
+    var { autoScroll, scrollToBottomOnRunStart, scrollToBottomOnInitialize, scrollToBottomOnThreadSwitch, children } = _a, rest = __rest(_a, ["autoScroll", "scrollToBottomOnRunStart", "scrollToBottomOnInitialize", "scrollToBottomOnThreadSwitch", "children"]);
+    const autoScrollRef = useThreadViewportAutoScroll({
+        autoScroll,
+        scrollToBottomOnRunStart,
+        scrollToBottomOnInitialize,
+        scrollToBottomOnThreadSwitch,
+    });
+    const viewportSizeRef = useViewportSizeRef();
+    const ref = useComposedRefs(forwardedRef, autoScrollRef, viewportSizeRef);
+    return (_jsx(Primitive.div, Object.assign({}, rest, { ref: ref, children: children })));
+});
+ThreadPrimitiveViewportScrollable.displayName =
+    "ThreadPrimitive.ViewportScrollable";
+/**
+ * A scrollable viewport container for thread messages.
+ *
+ * This component provides a scrollable area for displaying thread messages with
+ * automatic scrolling capabilities. It manages the viewport state and provides
+ * context for child components to access viewport-related functionality.
+ *
+ * @example
+ * ```tsx
+ * <ThreadPrimitive.Viewport turnAnchor="top">
+ *   <ThreadPrimitive.Messages components={{ Message: MyMessage }} />
+ * </ThreadPrimitive.Viewport>
+ * ```
+ */
+export const ThreadPrimitiveViewport = forwardRef((_a, ref) => {
+    var { turnAnchor } = _a, props = __rest(_a, ["turnAnchor"]);
+    return (_jsx(ThreadPrimitiveViewportProvider, { options: { turnAnchor }, children: _jsx(ThreadPrimitiveViewportScrollable, Object.assign({}, props, { ref: ref })) }));
+});
+ThreadPrimitiveViewport.displayName = "ThreadPrimitive.Viewport";

package/dist/vendor/assistant-ui-react/src/primitives/thread/ThreadViewportFooter.d.ts

@@ -0,0 +1,30 @@
+import { Primitive } from "@radix-ui/react-primitive";
+import { type ComponentRef, ComponentPropsWithoutRef } from "react";
+export declare namespace ThreadPrimitiveViewportFooter {
+    type Element = ComponentRef<typeof Primitive.div>;
+    type Props = ComponentPropsWithoutRef<typeof Primitive.div>;
+}
+/**
+ * A footer container that measures its height for scroll calculations.
+ *
+ * This component measures its height and provides it to the viewport context
+ * for use in scroll calculations (e.g., ViewportSlack min-height).
+ *
+ * Multiple ViewportFooter components can be used - their heights are summed.
+ *
+ * Typically used with `className="sticky bottom-0"` to keep the footer
+ * visible at the bottom of the viewport while scrolling.
+ *
+ * @example
+ * ```tsx
+ * <ThreadPrimitive.Viewport>
+ *   <ThreadPrimitive.Messages components={{ ... }} />
+ *   <ThreadPrimitive.ViewportFooter className="sticky bottom-0">
+ *     <Composer />
+ *   </ThreadPrimitive.ViewportFooter>
+ * </ThreadPrimitive.Viewport>
+ * ```
+ */
+export declare const ThreadPrimitiveViewportFooter: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {
+    asChild?: boolean;
+}, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/dist/vendor/assistant-ui-react/src/primitives/thread/ThreadViewportFooter.js

@@ -0,0 +1,39 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useComposedRefs } from "@radix-ui/react-compose-refs";
+import { Primitive } from "@radix-ui/react-primitive";
+import { forwardRef, useCallback, } from "react";
+import { useSizeHandle } from "../../utils/hooks/useSizeHandle";
+import { useThreadViewport } from "../../context/react/ThreadViewportContext";
+/**
+ * A footer container that measures its height for scroll calculations.
+ *
+ * This component measures its height and provides it to the viewport context
+ * for use in scroll calculations (e.g., ViewportSlack min-height).
+ *
+ * Multiple ViewportFooter components can be used - their heights are summed.
+ *
+ * Typically used with `className="sticky bottom-0"` to keep the footer
+ * visible at the bottom of the viewport while scrolling.
+ *
+ * @example
+ * ```tsx
+ * <ThreadPrimitive.Viewport>
+ *   <ThreadPrimitive.Messages components={{ ... }} />
+ *   <ThreadPrimitive.ViewportFooter className="sticky bottom-0">
+ *     <Composer />
+ *   </ThreadPrimitive.ViewportFooter>
+ * </ThreadPrimitive.Viewport>
+ * ```
+ */
+export const ThreadPrimitiveViewportFooter = forwardRef((props, forwardedRef) => {
+    const register = useThreadViewport((s) => s.registerContentInset);
+    const getHeight = useCallback((el) => {
+        const marginTop = parseFloat(getComputedStyle(el).marginTop) || 0;
+        return el.offsetHeight + marginTop;
+    }, []);
+    const resizeRef = useSizeHandle(register, getHeight);
+    const ref = useComposedRefs(forwardedRef, resizeRef);
+    return _jsx(Primitive.div, Object.assign({}, props, { ref: ref }));
+});
+ThreadPrimitiveViewportFooter.displayName = "ThreadPrimitive.ViewportFooter";

package/dist/vendor/assistant-ui-react/src/primitives/thread/ThreadViewportSlack.d.ts

@@ -0,0 +1,19 @@
+import { type FC, type ReactNode } from "react";
+export type ThreadViewportSlackProps = {
+    /** Threshold at which the user message height clamps to the offset */
+    fillClampThreshold?: string;
+    /** Offset used when clamping large user messages */
+    fillClampOffset?: string;
+    children: ReactNode;
+};
+/**
+ * A slot component that provides minimum height to enable scroll anchoring.
+ *
+ * When using `turnAnchor="top"`, this component ensures there is
+ * enough scroll room below the anchor point (last user message) for it to scroll
+ * to the top of the viewport. The min-height is applied only to the last
+ * assistant message.
+ *
+ * This component is used internally by MessagePrimitive.Root.
+ */
+export declare const ThreadPrimitiveViewportSlack: FC<ThreadViewportSlackProps>;